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 "du_app_mac_inf.h"
  32 #include "du_cfg.h"
  33 #include "du_app_rlc_inf.h"
  34 #include "du_mgr_main.h"
  35 #include "du_mgr.h"
  36 #include "du_utils.h"
  37 #include "du_ue_mgr.h"
  38 #include "RAT-Type.h"
  39 #include "FeatureSetUplinkPerCC.h"
  40 #include "FeatureSetDownlinkPerCC.h"
  41 #include "FeatureSets.h"
  42 #include "UE-NR-Capability.h"
  43 #include "UE-CapabilityRAT-Container.h"
  44 #include "UE-CapabilityRAT-ContainerListRRC.h"
  45 #include "GNB-DU-System-Information.h"
  46 #include "CellGroupConfigRrc.h"
  47 #include "MAC-CellGroupConfig.h"
  48 #include "SchedulingRequestConfig.h"
  49 #include "SchedulingRequestToAddMod.h"
  50 #include "BSR-Config.h"
  51 #include "TAG-Config.h"
  52 #include "TAG.h"
  53 #include "PHR-Config.h"
  54 #include "RLC-Config.h"
  55 #include "UL-AM-RLC.h"
  56 #include "DL-AM-RLC.h"
  57 #include "LogicalChannelConfig.h"
  58 #include "RLC-BearerConfig.h"
  59 #include "PhysicalCellGroupConfig.h"
  60 #include "SpCellConfig.h"
  61 #include "TDD-UL-DL-ConfigDedicated.h"
  62 #include "ServingCellConfig.h"
  63 #include "ControlResourceSet.h"
  64 #include "SearchSpace.h"
  65 #include "PDCCH-Config.h"
  66 #include "PDSCH-TimeDomainResourceAllocation.h"
  67 #include "PDSCH-TimeDomainResourceAllocationList.h"
  68 #include "PDSCH-CodeBlockGroupTransmission.h"
  69 #include "PDSCH-ServingCellConfig.h"
  70 #include "DMRS-DownlinkConfig.h"
  71 #include "PDSCH-Config.h"
  72 #include "BWP-DownlinkDedicated.h"
  73 #include "BWP-Downlink.h"
  74 #include "PUSCH-TimeDomainResourceAllocation.h"
  75 #include "PUSCH-TimeDomainResourceAllocationList.h"
  76 #include "DMRS-UplinkConfig.h"
  77 #include "PUSCH-Config.h"
  78 #include "SRS-ResourceId.h"
  79 #include "SRS-Resource.h"
  80 #include "SRS-ResourceSet.h"
  81 #include "SRS-Config.h"
  82 #include "BWP-UplinkDedicated.h"
  83 #include "PUSCH-ServingCellConfig.h"
  84 #include "UplinkConfig.h"
  85 #include "DUtoCURRCContainer.h"
  86 #include "GBR-QoSFlowInformation.h"
  87 #include "QoSFlowLevelQoSParameters.h"
  88 #include "PUCCH-Config.h"
  89 #include "PUCCH-ResourceSet.h"
  90 #include "PUCCH-Resource.h"
  91 #include "PUCCH-PowerControl.h"
  92 #include "P0-PUCCH.h"
  93 #include "PUCCH-PathlossReferenceRS.h"
  94 #include "PUCCH-format0.h"
  95 #include "PUCCH-format1.h"
  96 #include "PUCCH-format2.h"
  97 #include "PUCCH-format3.h"
  98 #include "PUCCH-format4.h"
  99 #include "PUCCH-FormatConfig.h"
 100 #include "SchedulingRequestResourceConfig.h"
 101 #include<ProtocolIE-Field.h>
 102 #include "ProtocolExtensionField.h"
 103 #include "odu_common_codec.h"
 104 #include "du_mgr.h"
 105 #include "du_cell_mgr.h"
 106 #include "du_f1ap_msg_hdl.h"
 107 #include "DRBs-Setup-Item.h"
 108 #include "DLUPTNLInformation-ToBeSetup-List.h"
 109 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 110 #include "UPTransportLayerInformation.h"
 111 #include "GTPTunnel.h"
 112 #include "SupportedSULFreqBandItem.h"
 113 #include "du_e2ap_msg_hdl.h"
 114 #include "du_f1ap_conversions.h"
 115 #include "CNUEPagingIdentity.h"
 116 #include "PCCH-Config.h"
 117 #include "SCS-SpecificCarrier.h"
 118 #include "FrequencyInfoDL.h"
 119 #include "DownlinkConfigCommon.h"
 120 #include "FrequencyInfoUL.h"
 121 #include "UplinkConfigCommon.h"
 122 #include "TDD-UL-DL-ConfigCommon.h"
 123 #include "RACH-ConfigDedicated.h"
 124 #include "CFRA-SSB-Resource.h"
 125 #include "BWP-UplinkCommon.h"
 126 #include "ReconfigurationWithSync.h"
 127 #include "du_sys_info_hdl.h"
 128 #include "DRX-ConfigRrc.h"
 129
 130 #ifdef O1_ENABLE
 131 #include "CmInterface.h"
 132 extern StartupConfig g_cfg;
 133 #endif
 134
 135 DuCfgParams duCfgParam;
 136
 137 /******************************************************************
 138  *
 139  * @brief Function to fetch lcId based on DRB Id
 140  *
 141  * @details
 142  *
 143  *    Function : fetchLcId
 144  *
 145  *    @params[in] drbId
 146  *
 147  *    Functionality: Function to fetch lcId based on DRB Id
 148  *
 149  * Returns: lcId - SUCCESS
 150  *          RFAILED - FAILURE
 151  *****************************************************************/
 152
 153 uint8_t fetchLcId(uint8_t drbId)
 154 {
 155    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 156
 157    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 158    {
 159       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 160       {
 161          if(duCb.actvCellLst[cellIdx] != NULLP)
 162          {
 163             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 164             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 165             {
 166                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 167                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 168                {
 169                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 170                   return lcId;
 171                }
 172             }
 173          }
 174       }
 175    }
 176    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 177    return RFAILED;
 178 }
 179
 180 /*******************************************************************
 181 *
 182 * @brief Adding F1AP pdu to reserved pdu list
 183 *
 184 * @details
 185 *
 186 *    Function : addToReservedF1apPduList
 187 *
 188 *    Functionality: Adding F1AP pdu to reserved pdu list.
 189 *     These pdu are awaiting aknowledgment from CU
 190 *
 191 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 192 *
 193 * @return ROK - success
 194 *         RFAILED - failure
 195 *
 196 * ****************************************************************/
 197 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 198 {
 199    CmLList         *node = NULLP;
 200    ReservedF1apPduInfo *pduInfo = NULLP;
 201    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 202    if(pduInfo)
 203    {
 204       DU_ALLOC(node, sizeof(CmLList));
 205       if(node)
 206       {
 207          pduInfo->transId = transId;
 208          pduInfo->f1apMsg = (void*) f1apPdu;
 209
 210          node->node = (PTR)pduInfo;
 211          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 212       }
 213    }
 214 }
 215
 216 /*******************************************************************
 217 *
 218 * @brief searching for F1AP pdu from ReservedF1apPduList
 219 *
 220 * @details
 221 *
 222 *    Function : searchFromReservedF1apPduList
 223 *
 224 *    Functionality: searching for F1AP pdu information
 225 *
 226 * @params[in] uint8_t transId
 227 *
 228 * @return pointer to F1AP_PDU_t
 229 *
 230 * ****************************************************************/
 231
 232 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 233 {
 234    CmLList         *node;
 235    ReservedF1apPduInfo *f1apPdu;
 236    if(duCb.reservedF1apPduList.count)
 237    {
 238       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 239       while(node)
 240       {
 241          f1apPdu = (ReservedF1apPduInfo*)node->node;
 242          if(f1apPdu->transId == transId)
 243          {
 244             return node;
 245          }
 246          node = node->next;
 247       }
 248    }
 249    return NULL;
 250 }
 251
 252 /*******************************************************************
 253 *
 254 * @brief deleting F1AP pdu information from ReservedF1apPduList
 255 *
 256 * @details
 257 *
 258 *    Function : deleteFromReservedF1apPduList
 259 *
 260 *    Functionality: deleting pdu information from ReservedF1apPduList
 261 *
 262 * @params[in] CmLList *node
 263 *
 264 * @return void
 265 *
 266 * ****************************************************************/
 267
 268 void deleteFromReservedF1apPduList(CmLList *node)
 269 {
 270    ReservedF1apPduInfo *f1apPdu;
 271
 272    if(node != NULL)
 273    {
 274       f1apPdu = (ReservedF1apPduInfo *)node->node;
 275       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 276       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 277       DU_FREE(node, sizeof(CmLList));
 278       node = NULL;
 279    }
 280 }
 281
 282 /*******************************************************************
 283  *
 284  * @brief Builds Uplink Info for NR
 285  *
 286  * @details
 287  *
 288  *    Function : BuildULNRInfo
 289  *
 290  *    Functionality: Building NR Uplink Info
 291  *
 292  * @params[in] NRFreqInfo_t *ulnrfreq
 293  * @return ROK     - success
 294  *         RFAILED - failure
 295  *
 296  * ****************************************************************/
 297 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 298 {
 299    uint8_t idx=0;
 300    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 301                        fdd.ulNrFreqInfo.nrArfcn;
 302    ulnrfreq->freqBandListNr.list.count = 1;
 303    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 304    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 305    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 306    {
 307       return RFAILED;
 308    }
 309    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 310    {
 311       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 312       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 313       {
 314          return RFAILED;
 315       }
 316    }
 317    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 318                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 319                                                                  freqBand[0].nrFreqBand;
 320    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 321    return ROK;
 322 }
 323 /*******************************************************************
 324  *
 325  * @brief Builds Downlink NR Info
 326  *
 327  * @details
 328  *
 329  *    Function : BuildDLNRInfo
 330  *
 331  *    Functionality: Building Downlink NR Info
 332  *
 333  * @params[in] NRFreqInfo_t *dlnrfreq
 334  * @return ROK     - success
 335  *         RFAILED - failure
 336  *
 337  * ****************************************************************/
 338 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 339 {
 340    uint8_t idx=0;
 341    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 342                        fdd.dlNrFreqInfo.nrArfcn;
 343    dlnrfreq->freqBandListNr.list.count = 1;
 344    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 345    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 346    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 347    {
 348       return RFAILED;
 349    }
 350    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 351    {
 352       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 353       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 354       {
 355          return RFAILED;
 356       }
 357    }
 358    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 359                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 360                                                                  freqBand[0].nrFreqBand;
 361    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 362
 363    return ROK;
 364 }
 365
 366 /*******************************************************************
 367  *
 368  * @brief Builds Nrcgi
 369  *
 370  * @details
 371  *
 372  *    Function : BuildNrcgi
 373  *
 374  *    Functionality: Building the PLMN ID and NR Cell id
 375  *
 376  * @params[in] NRCGI_t *nrcgi
 377  * @return ROK     - success
 378  *         RFAILED - failure
 379  *
 380  * ****************************************************************/
 381 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 382 {
 383    uint8_t ret;
 384    uint8_t byteSize = 5;
 385    /* Allocate Buffer Memory */
 386    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 387    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 388    if(nrcgi->pLMN_Identity.buf == NULLP)
 389    {
 390       return RFAILED;
 391    }
 392    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 393          nrcgi->pLMN_Identity.buf); // Building PLMN function
 394    if(ret != ROK)
 395    {
 396       return RFAILED;
 397    }
 398    /*nrCellIdentity*/
 399    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 400    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 401    if(nrcgi->nRCellIdentity.buf == NULLP)
 402    {
 403       return RFAILED;
 404    }
 405    fillBitString(&nrcgi->nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
 406
 407    return ROK;
 408 }
 409 /*******************************************************************
 410  *
 411  * @brief Builds FiveGStac
 412  *
 413  * @details
 414  *
 415  *    Function : BuildFiveGSTac
 416  *
 417  *    Functionality: Building the FiveGSTac
 418  *
 419  * @params[in] OCTET_STRING_t *fivegsTac
 420  * @return ROK     - success
 421  *         RFAILED - failure
 422  *
 423  * ****************************************************************/
 424 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 425 {
 426    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 427    if(servcell->fiveGS_TAC == NULLP)
 428    {
 429       return RFAILED;
 430    }
 431    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 432    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 433          sizeof(servcell->fiveGS_TAC->size));
 434    if(servcell->fiveGS_TAC->buf == NULLP)
 435    {
 436       return RFAILED;
 437    }
 438    servcell->fiveGS_TAC->buf[0] = 0;
 439    servcell->fiveGS_TAC->buf[1] = 0;
 440    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 441    return ROK;
 442 }
 443
 444 /*******************************************************************
 445  *
 446  * @brief fill nr frequency information
 447  *
 448  * @details
 449  *
 450  *    Function : fillNrTddInfo
 451  *
 452  *    Functionality: fill nr frequency information
 453  *
 454  * @params[in] NRFreqInfo_t freqInfo
 455  * @return ROK     - success
 456  *         RFAILED - failure
 457  *
 458  * ****************************************************************/
 459 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 460 {
 461    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 462    NRFreqInfo_t *freqInfo = NULLP;
 463
 464    if(tddInfo == NULLP)
 465    {
 466       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 467       return RFAILED;
 468    }
 469
 470    freqInfo = &tddInfo->nRFreqInfo;
 471    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 472
 473    freqInfo->freqBandListNr.list.count = elementCnt;
 474    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 475    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 476    if(!freqInfo->freqBandListNr.list.array)
 477    {
 478       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 479       return RFAILED;
 480    }
 481
 482    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 483    {
 484       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 485       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 486       {
 487          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 488          return RFAILED;
 489       }
 490
 491       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 492       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 493       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 494       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 495       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 496
 497       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 498             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 499       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 500       {
 501          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 502          return RFAILED;
 503       }
 504
 505       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 506       {
 507          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 508                sizeof(SupportedSULFreqBandItem_t));
 509          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 510          {
 511             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 512             return RFAILED;
 513          }
 514
 515          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 516          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 517       }
 518    }
 519
 520    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 521    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 522
 523    return ROK;
 524 }
 525
 526 /*******************************************************************
 527  *
 528  * @brief Builds NR Mode
 529  *
 530  * @details
 531  *
 532  *    Function : BuildNrMode
 533  *
 534  *    Functionality: Building the NR Mode
 535  *
 536  * @params[in] NR_Mode_Info_t *fdd
 537  * @return ROK     - success
 538  *         RFAILED - failure
 539  *
 540  * ****************************************************************/
 541 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 542 {
 543    uint8_t BuildDLNRInforet=0;
 544    uint8_t BuildULNRInforet=0;
 545
 546 #ifdef NR_TDD
 547    mode->present = NR_Mode_Info_PR_tDD;
 548 #else
 549    mode->present = NR_Mode_Info_PR_fDD;
 550 #endif
 551
 552    if(mode->present == NR_Mode_Info_PR_fDD)
 553    {
 554       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 555       if(mode->choice.fDD == NULLP)
 556       {
 557          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 558          return RFAILED;
 559       }
 560       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 561       if(BuildULNRInforet != ROK)
 562       {
 563          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 564          return RFAILED;
 565       }
 566       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 567       if(BuildDLNRInforet != ROK)
 568       {
 569          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 570          return RFAILED;
 571       }
 572       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 573                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 574                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 575       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 576                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 577                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 578       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 579                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 580                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 581       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 582                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 583                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 584    }
 585    else if(mode->present == NR_Mode_Info_PR_tDD)
 586    {
 587       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 588       if(mode->choice.tDD == NULLP)
 589       {
 590          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 591          return RFAILED;
 592       }
 593
 594       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 595       {
 596          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 597          return RFAILED;
 598       }
 599
 600    }
 601
 602    return ROK;
 603 }
 604 /*******************************************************************
 605  *
 606  * @brief Builds IE Extensions for Served PLMNs
 607  *
 608  * @details
 609  *
 610  *    Function : BuildExtensions
 611  *
 612  *    Functionality: Building the IE Extensions
 613  *
 614  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 615  * @return ROK     - success
 616  *         RFAILED - failure
 617  *
 618  * ****************************************************************/
 619 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 620 {
 621    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 622    uint8_t elementCnt=0, extensionCnt=0;
 623
 624    extensionCnt=IE_EXTENSION_LIST_COUNT;
 625    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 626    if((*ieExtend) == NULLP)
 627    {
 628       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 629       return RFAILED;
 630    }
 631    (*ieExtend)->list.count = extensionCnt;
 632    (*ieExtend)->list.size = \
 633                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 634    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 635    if((*ieExtend)->list.array == NULLP)
 636    {
 637       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 638       return RFAILED;
 639    }
 640    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 641    {
 642       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 643             sizeof(ServedPLMNs_ItemExtIEs_t));
 644       if((*ieExtend)->list.array[plmnidx] == NULLP)
 645       {
 646          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 647          return RFAILED;
 648       }
 649    }
 650
 651    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 652    idx = 0;
 653    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 654    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 655    (*ieExtend)->list.array[idx]->extensionValue.present = \
 656    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 657    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 658       list.count = elementCnt;
 659    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 660       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 661       list.count * sizeof(SliceSupportItem_t *);
 662
 663    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 664          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 665    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 666          list.array == NULLP)
 667    {
 668       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 669       return RFAILED;
 670    }
 671
 672    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 673    {
 674       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 675             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 676       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 677             list.array[sliceLstIdx] == NULLP)
 678       {
 679          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 680          return RFAILED;
 681       }
 682       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 683          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 684       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 685             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 686             extensionValue.choice.SliceSupportList.\
 687             list.array[sliceLstIdx]->sNSSAI.sST.size);
 688       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 689             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 690       {
 691          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 692          return RFAILED;
 693       }
 694       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 695          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 696          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 697
 698       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 699             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 700       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 701             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 702       {
 703          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 704          return RFAILED;
 705       }
 706       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 707          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 708       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 709             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 710             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 711       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 712             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 713       {
 714          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 715          return RFAILED;
 716       }
 717       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 718       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 719       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 720       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 721    }
 722    return ROK;
 723 }
 724 /*******************************************************************
 725  *
 726  * @brief Builds Served PLMN
 727  *
 728  * @details
 729  *
 730  *    Function : BuildServedPlmn
 731  *
 732  *    Functionality: Building the Served PLMN
 733  *
 734  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 735  * @return ROK     - success
 736  *         RFAILED - failure
 737  *
 738  * ****************************************************************/
 739 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 740 {
 741    uint8_t  plmnidx;
 742    uint8_t  servPlmnCnt=1;
 743    uint8_t buildPlmnIdret=0;
 744    uint8_t BuildExtensionsret=0;
 745    srvplmn->list.count = servPlmnCnt;
 746    srvplmn->list.size = \
 747                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 748    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 749    if(srvplmn->list.array == NULLP)
 750    {
 751       return RFAILED;
 752    }
 753    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 754    {
 755       DU_ALLOC(srvplmn->list.array[plmnidx],\
 756             sizeof(ServedPLMNs_Item_t));
 757       if(srvplmn->list.array[plmnidx] == NULLP)
 758       {
 759          return RFAILED;
 760       }
 761    }
 762    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 763    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 764    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 765          srvplmn->list.array[0]->pLMN_Identity.buf);
 766    if(buildPlmnIdret!= ROK)
 767    {
 768       return RFAILED;
 769    }
 770    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 771    if(BuildExtensionsret!= ROK)
 772    {
 773       return RFAILED;
 774    }
 775    return ROK;
 776 }
 777 /*******************************************************************
 778  *
 779  * @brief Builds Served Cell List
 780  *
 781  * @details
 782  *
 783  *    Function : BuildServedCellList
 784  *
 785  *    Functionality: Building Served Cell List
 786  *
 787  * @params[in] PLMNID plmn
 788  * @return ROK     - success
 789  *         RFAILED - failure
 790  *
 791  * ****************************************************************/
 792
 793 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 794 {
 795    uint8_t  BuildNrcgiret=0;
 796    uint8_t  BuildFiveGSTacret=0;
 797    uint8_t  BuildServedPlmnret=0;
 798    uint8_t  BuildNrModeret=0;
 799    uint8_t  idx;
 800    uint8_t  plmnidx;
 801    uint8_t  plmnCnt=1;
 802    GNB_DU_Served_Cells_Item_t *srvCellItem;
 803    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 804    duServedCell->list.count = plmnCnt;
 805
 806    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 807    if(duServedCell->list.array == NULLP)
 808    {
 809       return RFAILED;
 810    }
 811    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 812    {
 813       DU_ALLOC(duServedCell->list.array[plmnidx],\
 814             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 815       if(duServedCell->list.array[plmnidx] == NULLP)
 816       {
 817          return RFAILED;
 818       }
 819    }
 820    idx = 0;
 821    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 822    duServedCell->list.array[idx]->criticality = Criticality_reject;
 823    duServedCell->list.array[idx]->value.present = \
 824                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 825    srvCellItem = \
 826                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 827    /*nRCGI*/
 828    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 829    if(BuildNrcgiret != ROK)
 830    {
 831       return RFAILED;
 832    }
 833    /*nRPCI*/
 834    srvCellItem->served_Cell_Information.nRPCI = \
 835                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 836
 837    /*fiveGS_TAC*/
 838    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 839    if(BuildFiveGSTacret != ROK)
 840    {
 841       return RFAILED;
 842    }
 843    /*Served PLMNs*/
 844    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 845    if(BuildServedPlmnret !=ROK)
 846    {
 847       return RFAILED;
 848    }
 849    /*nR Mode Info with FDD*/
 850    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 851    if(BuildNrModeret != ROK)
 852    {
 853       return RFAILED;
 854    }
 855    /*Measurement timing Config*/
 856    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 857       size = sizeof(uint8_t);
 858    DU_ALLOC(srvCellItem->served_Cell_Information.\
 859          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 860    if(srvCellItem->served_Cell_Information.\
 861          measurementTimingConfiguration.buf == NULLP)
 862    {
 863       return RFAILED;
 864    }
 865    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 866                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 867
 868    /* GNB DU System Information */
 869    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 870          sizeof(GNB_DU_System_Information_t));
 871    if(!srvCellItem->gNB_DU_System_Information)
 872    {
 873       return RFAILED;
 874    }
 875    /* MIB */
 876    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 877    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 878          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 879    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 880    {
 881       return RFAILED;
 882    }
 883    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 884                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 885
 886    /* SIB1 */
 887    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 888                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 889
 890    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 891          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 892    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 893    {
 894       return RFAILED;
 895    }
 896    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 897    {
 898       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 899                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 900    }
 901    return ROK;
 902 }
 903 /*******************************************************************
 904  *
 905  * @brief Builds RRC Version
 906  *
 907  * @details
 908  *
 909  *    Function : BuildRrcVer
 910  *
 911  *    Functionality: Building RRC Version
 912  *
 913  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 914  * @return ROK     - success
 915  *         RFAILED - failure
 916  *
 917  * ****************************************************************/
 918 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 919 {
 920    uint8_t rrcExt;
 921    uint8_t rrcLatest;
 922    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 923    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 924    if(rrcVer->latest_RRC_Version.buf == NULLP)
 925    {
 926       return RFAILED;
 927    }
 928    rrcVer->latest_RRC_Version.buf[0] = 0;
 929    rrcVer->latest_RRC_Version.bits_unused = 5;
 930    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 931    if(rrcVer->iE_Extensions == NULLP)
 932    {
 933       return RFAILED;
 934    }
 935    rrcVer->iE_Extensions->list.count = 1;
 936    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 937    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 938    if(rrcVer->iE_Extensions->list.array == NULLP)
 939    {
 940       return RFAILED;
 941    }
 942    rrcExt = 0;
 943    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 944          sizeof(RRC_Version_ExtIEs_t));
 945    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 946    {
 947       return RFAILED;
 948    }
 949    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 950                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 951    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 952    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 953                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 954    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 955       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 956    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 957          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 958          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 959    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 960          .Latest_RRC_Version_Enhanced.buf == NULLP)
 961    {
 962       return RFAILED;
 963    }
 964    rrcLatest = 0;
 965    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 966       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 967    rrcLatest++;
 968    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 969       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 970    rrcLatest++;
 971    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 972       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 973    return ROK;
 974 }
 975 /*******************************************************************
 976  *
 977  * @brief Sends F1 msg over SCTP
 978  *
 979  * @details
 980  *
 981  *    Function : sendF1APMsg
 982  *
 983  *    Functionality: Sends F1 msg over SCTP
 984  *
 985  * @params[in] Region region
 986  *             Pool pool
 987  * @return ROK     - success
 988  *         RFAILED - failure
 989  *
 990  * ****************************************************************/
 991 uint8_t sendF1APMsg()
 992 {
 993    Buffer *mBuf = NULLP;
 994
 995    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
 996    {
 997       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 998       {
 999             ODU_PRINT_MSG(mBuf, 0,0);
1000
1001             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1002             {
1003                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1004                ODU_PUT_MSG_BUF(mBuf);
1005                return RFAILED;
1006             }
1007       }
1008       else
1009       {
1010          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1011          ODU_PUT_MSG_BUF(mBuf);
1012          return RFAILED;
1013       }
1014       ODU_PUT_MSG_BUF(mBuf);
1015    }
1016    else
1017    {
1018       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1019       return RFAILED;
1020    }
1021    return ROK;
1022 } /* sendF1APMsg */
1023
1024 /*******************************************************************
1025  *
1026  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1027  *
1028  * @details
1029  *
1030  *    Function :  FreeRrcVer
1031  *
1032  *    Functionality: deallocating the memory of function BuildRrcVer
1033  *
1034  * @params[in] RRC_Version_t *rrcVer
1035  *
1036  * @return void
1037  *
1038  *****************************************************************/
1039 void FreeRrcVer(RRC_Version_t *rrcVer)
1040 {
1041    if(rrcVer->latest_RRC_Version.buf != NULLP)
1042    {
1043       if(rrcVer->iE_Extensions != NULLP)
1044       {
1045          if(rrcVer->iE_Extensions->list.array != NULLP)
1046          {
1047             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1048             {
1049                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1050                      != NULLP)
1051                {
1052                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1053                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1054                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1055                }
1056                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1057             }
1058             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1059          }
1060          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1061       }
1062       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1063    }
1064 }
1065
1066 /*******************************************************************
1067  *
1068  * @brief Deallocating memory of TDD NrFreqInfo
1069  *
1070  * @details
1071  *
1072  *    Function : freeTddNrFreqInfo
1073  *
1074  *    Functionality: freeTddNrFreqInfo
1075  *
1076  * @params[in]  F1AP_PDU_t *f1apDuCfg
1077  *
1078  * @return ROK     - void
1079  *
1080  * ****************************************************************/
1081 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1082 {
1083    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1084
1085    if(freqInfo->freqBandListNr.list.array)
1086    {
1087       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1088       {
1089          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1090          {
1091             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1092             {
1093                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1094                {
1095                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1096                         sizeof(SupportedSULFreqBandItem_t));
1097                }
1098                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1099                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1100
1101             }
1102             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1103          }
1104       }
1105       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1106    }
1107 }
1108
1109 /*******************************************************************
1110  *
1111  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1112  *
1113  * @details
1114  *
1115  *    Function : freeFddNrFreqInfo
1116  *
1117  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1118  *
1119  * @params[in]
1120  *
1121  * @return ROK     - void
1122  *
1123  * ****************************************************************/
1124 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1125 {
1126    uint8_t arrIdx =0;
1127
1128    if(fDD != NULLP)
1129    {
1130       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1131       {
1132          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1133                array[arrIdx], sizeof(FreqBandNrItem_t));
1134          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1135                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1136       }
1137
1138       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1139       {
1140          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1141                array[arrIdx], sizeof(FreqBandNrItem_t));
1142          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1143                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1144       }
1145       DU_FREE(fDD,sizeof(FDD_Info_t));
1146    }
1147 }
1148
1149 /*******************************************************************
1150  *
1151  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1152  *
1153  * @details
1154  *
1155  *    Function :  FreeServedCellList
1156  *
1157  *    Functionality:  deallocating the memory of function BuildServedCellList
1158
1159  *
1160  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1161  *
1162  * @return void
1163  *
1164  * ****************************************************************/
1165 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1166 {
1167    uint8_t   plmnCnt=MAX_PLMN;
1168    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1169    uint8_t  plmnIdx=0, sliceIdx=0;
1170    GNB_DU_Served_Cells_Item_t *srvCellItem;
1171    ServedPLMNs_Item_t  *servedPlmnItem;
1172    SliceSupportItem_t  *sliceSupportItem;
1173
1174    if(duServedCell->list.array!=NULLP)
1175    {
1176       if(duServedCell->list.array[0]!=NULLP)
1177       {
1178          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1179
1180          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1181                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1182          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1183                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1184
1185          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1186          {
1187             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1188                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1189             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1190          }
1191
1192          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1193          {
1194             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1195             {
1196                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1197                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1198
1199                if(servedPlmnItem->iE_Extensions != NULLP)
1200                {
1201                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1202                   {
1203                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1204                      {
1205                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1206                               SliceSupportList.list.array != NULLP)
1207                         {
1208                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1209                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1210                            {
1211                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1212                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1213                               {
1214                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1215                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1216
1217                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1218
1219                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1220                                  {
1221                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1222                                           sliceSupportItem->sNSSAI.sD->size);
1223                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1224                                  }
1225
1226                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1227                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1228                               }
1229                            }
1230                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1231                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1232                                  extensionValue.choice.SliceSupportList.list.size);
1233                         }
1234                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1235                               sizeof(ServedPLMNs_ItemExtIEs_t));
1236                      }
1237                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1238                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1239                   }
1240                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1241                }
1242                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1243                      sizeof(ServedPLMNs_Item_t));
1244             }
1245             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1246                   sizeof(ServedPLMNs_Item_t *));
1247          }
1248
1249          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1250          {
1251             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1252          }
1253          else
1254          {
1255             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1256             {
1257                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1258                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1259             }
1260          }
1261
1262          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1263                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1264
1265          if(srvCellItem->gNB_DU_System_Information != NULLP)
1266          {
1267             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1268             {
1269                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1270                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1271             }
1272
1273             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1274             {
1275                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1276                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1277             }
1278
1279             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1280          }
1281
1282          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1283       }
1284       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1285    }
1286 }
1287
1288 /*******************************************************************
1289  *
1290  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1291  *
1292  * @details
1293  *
1294  *    Function :  FreeF1SetupReq
1295  *
1296  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1297  *
1298  * @params[in] F1AP_PDU_t *f1apMsg
1299  *
1300  * @return void
1301  *
1302  * ****************************************************************/
1303 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1304 {
1305    uint8_t ieIdx, ieIdx2;
1306    F1SetupRequest_t *f1SetupReq=NULLP;
1307
1308    if(f1apMsg != NULLP)
1309    {
1310       if(f1apMsg->choice.initiatingMessage != NULLP)
1311       {
1312          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1313          if(f1SetupReq->protocolIEs.list.array != NULLP)
1314          {
1315             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1316             {
1317                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1318                {
1319                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1320                   {
1321                      case ProtocolIE_ID_id_TransactionID:
1322                         break;
1323                      case ProtocolIE_ID_id_gNB_DU_ID:
1324                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1325                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1326                         break;
1327                      case ProtocolIE_ID_id_gNB_DU_Name:
1328                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1329                               strlen((char *)duCfgParam.duName));
1330                         break;
1331                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1332                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1333                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1334                         break;
1335                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1336                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1337                         break;
1338                      default:
1339                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1340                         break;
1341                   }
1342                }
1343             }
1344             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1345             {
1346                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1347             }
1348             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1349                   f1SetupReq->protocolIEs.list.size);
1350          }
1351          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1352       }
1353       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1354    }
1355 }
1356 /*******************************************************************
1357  *
1358  * @brief Builds and Send the F1SetupRequest
1359  *
1360  * @details
1361  *
1362  *    Function : BuildAndSendF1SetupReq
1363  *
1364  * Functionality:Fills the F1SetupRequest
1365  *
1366  * @return ROK     - success
1367  *         RFAILED - failure
1368  *
1369  ******************************************************************/
1370 uint8_t BuildAndSendF1SetupReq()
1371 {
1372    uint8_t   ret, ieIdx, elementCnt;
1373    F1AP_PDU_t                 *f1apMsg = NULLP;
1374    F1SetupRequest_t           *f1SetupReq=NULLP;
1375    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1376    RRC_Version_t              *rrcVer=NULLP;
1377    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1378    ret= RFAILED;
1379
1380    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1381    do
1382    {
1383       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1384       if(f1apMsg == NULLP)
1385       {
1386          break;
1387       }
1388       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1389       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1390       if(f1apMsg->choice.initiatingMessage == NULLP)
1391       {
1392          break;
1393       }
1394       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1395       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1396       f1apMsg->choice.initiatingMessage->value.present = \
1397                                                          InitiatingMessage__value_PR_F1SetupRequest;
1398
1399       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1400
1401       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1402
1403       f1SetupReq->protocolIEs.list.count = elementCnt;
1404       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1405
1406       /* Initialize the F1Setup members */
1407       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1408       if(f1SetupReq->protocolIEs.list.array == NULLP)
1409       {
1410          break;
1411       }
1412       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1413       {
1414          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1415                sizeof(F1SetupRequestIEs_t));
1416          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1417          {
1418             break;
1419          }
1420       }
1421
1422       ieIdx = 0;
1423       /*TransactionID*/
1424       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1425       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1426       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1427                                                                F1SetupRequestIEs__value_PR_TransactionID;
1428       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1429                                                                              TRANS_ID;
1430
1431       /*DU ID*/
1432       ieIdx++;
1433       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1434       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1435       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1436                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1437       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1438                                                                              sizeof(uint8_t);
1439
1440       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1441             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1442       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1443             NULLP)
1444       {
1445          break;
1446       }
1447
1448       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1449          duCfgParam.duId;
1450
1451       /*DU Name*/
1452       if(duCfgParam.duName != NULL)
1453       {
1454          ieIdx++;
1455          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1456          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1457          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1458          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1459             strlen((char *)duCfgParam.duName);
1460          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1461                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1462          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1463                buf == NULLP)
1464          {
1465             break;
1466          }
1467          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1468                choice.GNB_DU_Name.buf,
1469                (char*)&duCfgParam.duName);
1470
1471       }
1472
1473       /*Served Cell list */
1474       ieIdx++;
1475       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1476                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1477       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1478       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1479                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1480       duServedCell = &f1SetupReq->protocolIEs.list.\
1481                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1482       if(BuildServedCellList(duServedCell))
1483       {
1484          break;
1485       }
1486       /*RRC Version*/
1487       ieIdx++;
1488       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1489                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1490       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1491       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1492                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1493       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1494       if(BuildRrcVer(rrcVer))
1495       {
1496          break;
1497       }
1498       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1499
1500       /* Encode the F1SetupRequest type as APER */
1501       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1502       encBufSize = 0;
1503       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1504             encBuf);
1505
1506       /* Encode results */
1507       if(encRetVal.encoded == ENCODE_FAIL)
1508       {
1509          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1510                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1511          break;
1512       }
1513       else
1514       {
1515          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1516 #ifdef DEBUG_ASN_PRINT
1517          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1518          {
1519             printf("%x",encBuf[ieIdx]);
1520          }
1521 #endif
1522
1523          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1524          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1525          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1526          {
1527              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1528              return RFAILED;
1529          }
1530          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1531       }
1532
1533       /* Sending msg */
1534       if(sendF1APMsg() != ROK)
1535       {
1536          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1537          break;
1538       }
1539
1540       ret=ROK;
1541       break;
1542    }while(true);
1543
1544    FreeF1SetupReq(f1apMsg);
1545
1546    return ret;
1547 }/* End of BuildAndSendF1SetupReq */
1548
1549 /*******************************************************************
1550  *
1551  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1552  *
1553  * @details
1554  *
1555  *    Function : freeCellsToModifyItem
1556  *
1557  *    Functionality: Deallocating memory of variables allocated in
1558  *                    BuildAndSendDUConfigUpdate function
1559  *
1560  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1561  *
1562  * @return ROK     - void
1563  *
1564  * ****************************************************************/
1565
1566 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1567 {
1568    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1569    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1570    SliceSupportItem_t *sliceSupportItem = NULLP;
1571
1572    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1573    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1574
1575    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1576            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1577    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1578          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1579
1580    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1581    {
1582       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1583       {
1584          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1585
1586          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1587
1588          if(servedPlmnItem->iE_Extensions != NULLP)
1589          {
1590             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1591             {
1592                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1593                {
1594                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1595                         list.array != NULLP)
1596                   {
1597                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1598                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1599                      {
1600                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1601                               list.array[sliceLstIdx] != NULLP)
1602                         {
1603
1604                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1605                                               SliceSupportList.list.array[sliceLstIdx];
1606
1607                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1608                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1609                            {
1610                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1611                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1612                            }
1613                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1614                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1615                         }
1616                      }
1617                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1618                            choice.SliceSupportList.list.array,\
1619                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1620                            extensionValue.choice.SliceSupportList.list.size);
1621                   }
1622                }
1623                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1624                {
1625                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1626                }
1627                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1628             }
1629             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1630          }
1631       }
1632       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1633       {
1634          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1635       }
1636       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1637          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1638    }
1639
1640    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1641    {
1642       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1643    }
1644    else
1645    {
1646       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1647       {
1648          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1649          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1650       }
1651    }
1652    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1653       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1654 }
1655
1656 /*******************************************************************
1657  *
1658  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1659  *
1660  * @details
1661  *
1662  *    Function : FreeDUConfigUpdate
1663  *
1664  *    Functionality: Deallocating memory of variables allocated in
1665  *                    BuildAndSendDUConfigUpdate function
1666  *
1667  * @params[in]  F1AP_PDU_t *f1apDuCfg
1668  *
1669  * @return ROK     - void
1670  *
1671  * ****************************************************************/
1672 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1673 {
1674    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1675    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1676    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1677    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1678    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1679    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1680
1681    if(f1apDuCfg != NULLP)
1682    {
1683       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1684       {
1685          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1686                        value.choice.GNBDUConfigurationUpdate;
1687          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1688          {
1689             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1690             {
1691                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1692                {
1693                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1694                   {
1695                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1696                         {
1697                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1698                                            value.choice.Served_Cells_To_Modify_List;
1699                            if(cellsToModify->list.array != NULLP)
1700                            {
1701                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1702                               {
1703                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1704                                  {
1705                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1706                                           Served_Cells_To_Modify_Item);
1707                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1708                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1709                                  }
1710                               }
1711                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1712                            }
1713                            break;
1714                         }
1715                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1716                         {
1717                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1718                                            value.choice.Served_Cells_To_Delete_List;
1719                            if(cellsToDelete->list.array != NULLP)
1720                            {
1721                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1722                               {
1723                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1724                                  {
1725                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1726                                           cellsToDelete->list.array[cellDeleteIdx]);
1727                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1728                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1729                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1730                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1731                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1732                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1733                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1734                                  }
1735                               }
1736                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1737                            }
1738
1739                            break;
1740                         }
1741                      case ProtocolIE_ID_id_gNB_DU_ID:
1742                         {
1743                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1744                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1745                            break;
1746                         }
1747                   }
1748                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1749                         sizeof(GNBDUConfigurationUpdateIEs_t));
1750                }
1751             }
1752             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1753          }
1754          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1755       }
1756       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1757    }
1758 }
1759
1760 /*******************************************************************
1761  *
1762  * @brief Fills Served Plmns required in ServCellInfo IE
1763  *
1764  * @details
1765  *
1766  *    Function : fillServedPlmns
1767  *
1768  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1769  *
1770  * @params[in] Pointer to ServedPLMNs_List_t *
1771  *
1772  * @return ROK     - success
1773  *         RFAILED - failure
1774  *
1775  *****************************************************************/
1776
1777 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1778 {
1779    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1780
1781    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1782    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1783          array[arrayIdx]->pLMN_Identity.size);
1784    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1785    {
1786       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1787       return RFAILED;
1788    }
1789    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1790          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1791    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1792    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1793    {
1794       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1795       return RFAILED;
1796    }
1797
1798    ieListCnt=1;
1799    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1800    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1801    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1802          iE_Extensions->list.size);
1803    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1804    {
1805       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1806       return RFAILED;
1807    }
1808    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1809    {
1810       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1811             sizeof(ServedPLMNs_ItemExtIEs_t));
1812       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1813       {
1814          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1815          return RFAILED;
1816       }
1817    }
1818
1819    ieIdx = 0;
1820    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1821    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1822    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1823    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1824    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1825    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1826       list.count = elementCnt;
1827    servedPlmn->list.array[arrayIdx]->\
1828       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1829       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1830    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1831          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1832          list.array,servedPlmn->list.array[arrayIdx]->\
1833          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1834    if(servedPlmn->list.array[arrayIdx]->\
1835          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1836          list.array == NULLP)
1837    {
1838       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1839       return RFAILED;
1840    }
1841
1842    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1843    {
1844       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1845       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1846       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1847       if(servedPlmn->list.array[arrayIdx]->\
1848       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1849       list.array[sliceLstIdx] == NULLP)
1850       {
1851          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1852          return RFAILED;
1853       }
1854
1855       servedPlmn->list.array[arrayIdx]->\
1856       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1857       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1858       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1859       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1860       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1861       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1862       sNSSAI.sST.size);
1863
1864       if(servedPlmn->list.array[arrayIdx]->\
1865       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1866       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1867       {
1868          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1869          return RFAILED;
1870       }
1871       servedPlmn->list.array[arrayIdx]->\
1872       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1873       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1874       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1875
1876       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1877       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1878       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1879       if(servedPlmn->list.array[arrayIdx]->\
1880       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1881       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1882       {
1883          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1884          return RFAILED;
1885       }
1886       servedPlmn->list.array[arrayIdx]->\
1887       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1888       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1889       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1890       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1891       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1892       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1893       list.array[sliceLstIdx]->sNSSAI.sD->size);
1894       if(servedPlmn->list.array[arrayIdx]->\
1895       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1896       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1897       {
1898          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1899          return RFAILED;
1900       }
1901       memcpy(servedPlmn->list.array[arrayIdx]->\
1902       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1903       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1904       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1905       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1906       list.array[sliceLstIdx]->sNSSAI.sD->size);
1907    }
1908    return ROK;
1909 }
1910
1911 /*******************************************************************
1912  *
1913  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1914  *
1915  * @details
1916  *
1917  *    Function : fillNrFddInfo
1918  *
1919  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1920  *
1921  * @params[in] FDD_Info_t *fDD
1922  *
1923  * @return ROK     - success
1924  *         RFAILED - failure
1925  *
1926  *****************************************************************/
1927
1928 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1929 {
1930    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1931       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1932    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1933    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1934    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1935          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1936    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1937    {
1938       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1939       return RFAILED;
1940    }
1941
1942    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1943       sizeof(FreqBandNrItem_t));
1944    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1945    {
1946       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1947       return RFAILED;
1948    }
1949
1950    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1951       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1952       freqBand[0].nrFreqBand;
1953    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1954    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1955       dlNrFreqInfo.nrArfcn;
1956    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1957    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1958    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1959    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1960    {
1961       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1962       return RFAILED;
1963    }
1964
1965    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
1966    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1967    {
1968       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1969       return RFAILED;
1970    }
1971
1972    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1973       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1974       freqBand[0].nrFreqBand;
1975    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1976
1977    /*Transmission Bandwidth*/
1978    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1979       f1Mode.mode.fdd.ulTxBw.nrScs;
1980    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1981       f1Mode.mode.fdd.ulTxBw.nrb;
1982    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1983       f1Mode.mode.fdd.dlTxBw.nrScs;
1984    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1985       f1Mode.mode.fdd.dlTxBw.nrb;
1986
1987    return ROK;
1988 }
1989
1990 /*******************************************************************
1991  *
1992  * @brief Fills ServCellInfo IE
1993  *
1994  * @details
1995  *
1996  *    Function : fillServedCellInfo
1997  *
1998  *    Functionality: Fills ServCellInfo
1999  *
2000  * @params[in] Pointer to Served_Cell_Information_t *
2001  *
2002  * @return ROK     - success
2003  *         RFAILED - failure
2004  *
2005  *****************************************************************/
2006
2007 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2008 {
2009    uint8_t ieIdx, ieListCnt;
2010
2011    /*nRCGI*/
2012    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2013    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2014          srvCellInfo->nRCGI.pLMN_Identity.size);
2015    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2016    {
2017       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2018       return RFAILED;
2019    }
2020    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2021          srvCellInfo->nRCGI.pLMN_Identity.buf);
2022    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2023    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2024          srvCellInfo->nRCGI.nRCellIdentity.size);
2025    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2026    {
2027       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2028       return RFAILED;
2029    }
2030
2031    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2032    /*nRPCI*/
2033    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2034
2035    /*servedPLMNs*/
2036    ieListCnt = 1;
2037    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2038    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2039    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2040    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2041    {
2042       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2043       return RFAILED;
2044    }
2045    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2046    {
2047       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2048       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2049       {
2050          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2051          return RFAILED;
2052       }
2053    }
2054    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2055    {
2056       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2057       return RFAILED;
2058    }
2059
2060 #ifndef NR_TDD
2061    /*nR Mode Info with FDD*/
2062    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2063    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2064    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2065    {
2066       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2067       return RFAILED;
2068    }
2069    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2070    {
2071        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2072       return RFAILED;
2073    }
2074 #else
2075    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2076    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2077    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2078    {
2079       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2080       return RFAILED;
2081    }
2082    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2083    {
2084       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2085       return RFAILED;
2086    }
2087 #endif
2088
2089    /*Measurement timing Config*/
2090    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2091    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2092          buf,srvCellInfo->measurementTimingConfiguration.size);
2093    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2094    {
2095       return RFAILED;
2096    }
2097    srvCellInfo->measurementTimingConfiguration.\
2098          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2099
2100    return ROK;
2101 }
2102
2103 /*******************************************************************
2104  *
2105  * @brief Fills ServCellToModItem IE
2106  *
2107  * @details
2108  *
2109  *    Function : fillServCellToModItem
2110  *
2111  *    Functionality: Fills ServCellToModItem IE
2112  *
2113  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2114  *
2115  * @return ROK     - success
2116  *         RFAILED - failure
2117  *
2118  *****************************************************************/
2119
2120 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2121 {
2122    /*pLMN_Identity*/
2123    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2124    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2125    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2126    {
2127       return RFAILED;
2128    }
2129    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2130          modifyItem->oldNRCGI.pLMN_Identity.buf);
2131
2132    /*nRCellIdentity*/
2133    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2134    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2135          modifyItem->oldNRCGI.nRCellIdentity.size);
2136    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2137    {
2138       return RFAILED;
2139    }
2140    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2141
2142    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2143       return RFAILED;
2144    else
2145       return ROK;
2146 }
2147
2148 /*******************************************************************
2149  *
2150  * @brief Builds ServCellToModList
2151  *
2152  * @details
2153  *
2154  *    Function : buildServCellToModList
2155  *
2156  *    Functionality: Builds the serv cell to Mod List
2157  *
2158  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2159  *
2160  * @return ROK     - success
2161  *         RFAILED - failure
2162  *
2163  *****************************************************************/
2164
2165 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2166 {
2167    uint8_t ieListCnt, ieIdx;
2168    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2169
2170    ieListCnt = 1;
2171    cellsToModify->list.count = ieListCnt;
2172    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2173    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2174    if(cellsToModify->list.array == NULLP)
2175    {
2176       return RFAILED;
2177    }
2178    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2179    {
2180       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2181       if(cellsToModify->list.array[ieIdx] == NULLP)
2182       {
2183          return RFAILED;
2184       }
2185    }
2186    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2187    cellsToModify->list.array[0]->criticality = Criticality_reject;
2188    cellsToModify->list.array[0]->value.present =\
2189       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2190    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2191
2192    if(fillServCellToModItem(modifyItem))
2193       return RFAILED;
2194    else
2195       return ROK;
2196 }
2197 /*******************************************************************
2198  *
2199  * @brief filling the DeleteItemList
2200  *
2201  * @details
2202  *
2203  *    Function : fillCellToDeleteItem
2204  *
2205  *    Functionality: Filling the DeleteItemIe
2206  *
2207  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2208  *
2209  * @return ROK     - success
2210  *         RFAILED - failure
2211  *
2212  *****************************************************************/
2213 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2214 {
2215    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2216
2217    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2218    deleteItemIe->criticality = Criticality_reject;
2219    deleteItemIe->value.present =\
2220    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2221    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2222
2223    /*pLMN_Identity*/
2224    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2225    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2226    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2227    {
2228       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2229       return RFAILED;
2230    }
2231    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2232          deleteItem->oldNRCGI.pLMN_Identity.buf);
2233
2234    /*nRCellIdentity*/
2235    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2236    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2237          deleteItem->oldNRCGI.nRCellIdentity.size);
2238    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2239    {
2240       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2241       return RFAILED;
2242    }
2243    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2244    return ROK;
2245 }
2246 /*******************************************************************
2247  *
2248  * @brief Builds ServCellToDeleteList
2249  *
2250  * @details
2251  *
2252  *    Function : buildServCellToDeleteList
2253  *
2254  *    Functionality: Builds the serv cell to delete List
2255  *
2256  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2257  *
2258  * @return ROK     - success
2259  *         RFAILED - failure
2260  *
2261  *****************************************************************/
2262
2263 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2264 {
2265    uint8_t ieListCnt, arrIdx;
2266
2267    ieListCnt = 1;
2268    cellsToDelete->list.count = ieListCnt;
2269    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2270
2271    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2272    if(cellsToDelete->list.array == NULLP)
2273    {
2274       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2275       return RFAILED;
2276    }
2277
2278    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2279    {
2280       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2281       if(cellsToDelete->list.array[arrIdx] == NULLP)
2282       {
2283          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2284          return RFAILED;
2285       }
2286    }
2287
2288    arrIdx=0;
2289    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2290    {
2291       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2292       return RFAILED;
2293    }
2294    return ROK;
2295 }
2296
2297 /*******************************************************************
2298  *
2299  * @brief Builds and sends the DUConfigUpdate
2300  *
2301  * @details
2302  *
2303  *    Function : BuildAndSendDUConfigUpdate
2304  *
2305  *    Functionality: Constructs the DU Update message and sends
2306  *                   it to the CU through SCTP.
2307  *
2308  * @params[in] void **buf,Buffer to which encoded pattern is written into
2309  * @params[in] int *size,size of buffer
2310  *
2311  * @return ROK     - success
2312  *         RFAILED - failure
2313  *
2314  * ****************************************************************/
2315 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2316 {
2317    uint8_t ret =0, ieIdx=0, elementCnt=0;
2318    bool memAlloctionFailure = false;
2319    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2320    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2321    asn_enc_rval_t encRetVal;     /* Encoder return value */
2322
2323    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2324    ret= RFAILED;
2325
2326    while(true)
2327    {
2328       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2329       /* Allocate the memory for F1DuCfg */
2330       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2331       if(f1apDuCfg == NULLP)
2332       {
2333          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2334          break;
2335       }
2336
2337       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2338       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2339       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2340       {
2341          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2342          break;
2343       }
2344
2345       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2346                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2347       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2348       f1apDuCfg->choice.initiatingMessage->value.present = \
2349                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2350       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2351                     choice.GNBDUConfigurationUpdate;
2352       elementCnt = 3;
2353       duCfgUpdate->protocolIEs.list.count = elementCnt;
2354       duCfgUpdate->protocolIEs.list.size = \
2355                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2356
2357       /* Initialize the F1Setup members */
2358       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2359       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2360       {
2361          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2362          break;
2363       }
2364       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2365       {
2366          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2367          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2368          {
2369             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2370             memAlloctionFailure = true;
2371             break;
2372          }
2373       }
2374
2375       if(memAlloctionFailure == true)
2376       {
2377          break;
2378       }
2379       /*TransactionID*/
2380       ieIdx = 0;
2381       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2382       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2383       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2384       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2385       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2386
2387       ieIdx++;
2388       if(servCellAction == SERV_CELL_TO_MODIFY)
2389       {
2390          /*Served Cell to Modify */
2391          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2392          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2393          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2394          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2395          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2396          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2397                   Served_Cells_To_Modify_List))
2398          {
2399             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2400             break;
2401          }
2402       }
2403       else
2404       {
2405          /*Served Cell to Delete */
2406          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2407          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2408          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2409          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2410          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2411          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2412          Served_Cells_To_Delete_List)!=ROK)
2413          {
2414             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2415             break;
2416          }
2417
2418       }
2419       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2420       /*GNB DU ID */
2421       ieIdx++;
2422       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2423       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2424       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2425       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2426       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2427       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2428             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2429       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2430       {
2431          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2432          break;
2433       }
2434       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2435
2436       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2437
2438       /* Encode the DU Config Update type as APER */
2439       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2440       encBufSize = 0;
2441       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2442
2443       /* Checking encode results */
2444       if(encRetVal.encoded == ENCODE_FAIL)
2445       {
2446          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2447                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2448          break;
2449       }
2450       else
2451       {
2452          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2453 #ifdef DEBUG_ASN_PRINT
2454          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2455          {
2456             printf("%x",encBuf[ieIdx]);
2457          }
2458 #endif
2459       }
2460       /* Sending msg */
2461       if(sendF1APMsg() != ROK)
2462       {
2463          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2464          break;
2465       }
2466
2467       ret = ROK;
2468       break;
2469    }
2470
2471    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2472    return ret;
2473 }
2474
2475
2476 /*******************************************************************
2477  *
2478  * @brief free the ULRRCMessageTransfer
2479  *
2480  * @details
2481  *
2482  *    Function : FreeULRRCMessageTransfer
2483  *
2484  *    Functionality: Deallocating the memory of variable allocated in
2485  *                      FreeULRRCMessageTransfer
2486  *
2487  * @params[in]
2488  *
2489  * @return ROK     - void
2490  *
2491  ******************************************************************/
2492 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2493 {
2494    uint8_t idx1;
2495    ULRRCMessageTransfer_t  *ulRRCMsg;
2496
2497    if(f1apMsg != NULLP)
2498    {
2499       if(f1apMsg->choice.initiatingMessage != NULLP)
2500       {
2501          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2502          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2503          {
2504             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2505             {
2506                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2507                {
2508                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2509                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2510                   {
2511                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2512                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2513                   }
2514                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2515                }
2516             }
2517             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2518          }
2519          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2520       }
2521       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2522    }
2523 }
2524 /*******************************************************************
2525  *
2526  * @brief Builds and sends the ULRRCMessageTransfer
2527  *
2528  * @details
2529  *
2530  *    Function : BuildAndSendULRRCMessageTransfer
2531  *
2532  *    Functionality: Constructs the UL RRC Message Transfer and sends
2533  *                   it to the CU through SCTP.
2534  *
2535  * @params[in]
2536  *
2537  * @return ROK     - success
2538  *         RFAILED - failure
2539  *
2540  * ****************************************************************/
2541 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  *ueCb, uint8_t lcId, \
2542       uint16_t msgLen, uint8_t *rrcMsg)
2543 {
2544    uint8_t                 elementCnt=0, idx1=0, idx=0;
2545    uint8_t                 ret = RFAILED;
2546    F1AP_PDU_t              *f1apMsg = NULLP;
2547    ULRRCMessageTransfer_t  *ulRRCMsg = NULLP;
2548    asn_enc_rval_t          encRetVal;        /* Encoder return value */
2549
2550    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2551
2552    while(true)
2553    {
2554       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2555
2556       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2557       if(f1apMsg == NULLP)
2558       {
2559          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2560          break;
2561       }
2562       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2563       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2564       if(f1apMsg->choice.initiatingMessage == NULLP)
2565       {
2566          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2567          break;
2568       }
2569       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2570       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2571       f1apMsg->choice.initiatingMessage->value.present = \
2572                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2573       ulRRCMsg =
2574          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2575       elementCnt = 4;
2576       ulRRCMsg->protocolIEs.list.count = elementCnt;
2577       ulRRCMsg->protocolIEs.list.size = \
2578                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2579
2580       /* Initialize the F1Setup members */
2581       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2582       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2583       {
2584          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2585          break;
2586       }
2587       for(idx=0; idx<elementCnt; idx++)
2588       {
2589          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2590          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2591          {
2592             break;
2593          }
2594       }
2595
2596       idx1 = 0;
2597
2598       /*GNB CU UE F1AP ID*/
2599       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2600       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2601       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2602                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2603       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
2604
2605       /*GNB DU UE F1AP ID*/
2606       idx1++;
2607       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2608       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2609       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2610                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2611       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
2612
2613       /*SRBID*/
2614       idx1++;
2615       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2616       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2617       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2618                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2619       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2620
2621       /*RRCContainer*/
2622       idx1++;
2623       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2624       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2625       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2626                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2627       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2628       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2629             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2630       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2631       {
2632          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2633          break;
2634       }
2635       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2636       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2637             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2638
2639       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2640
2641       /* Encode the F1SetupRequest type as APER */
2642       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2643       encBufSize = 0;
2644       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2645             encBuf);
2646       /* Encode results */
2647       if(encRetVal.encoded == ENCODE_FAIL)
2648       {
2649          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2650                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2651          break;
2652       }
2653       else
2654       {
2655          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2656 #ifdef DEBUG_ASN_PRINT
2657          for(int i=0; i< encBufSize; i++)
2658          {
2659             printf("%x",encBuf[i]);
2660          }
2661 #endif
2662       }
2663
2664       /* Sending  msg  */
2665       if(sendF1APMsg()  !=      ROK)
2666       {
2667          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2668          break;
2669       }
2670       ret = ROK;
2671       break;
2672    }
2673    FreeULRRCMessageTransfer(f1apMsg);
2674
2675    return ret;
2676 }/* End of BuildAndSendULRRCMessageTransfer*/
2677
2678 /*******************************************************************
2679  *
2680  * @brief Builds tag config
2681  *
2682  * @details
2683  *
2684  *    Function : BuildTagConfig
2685  *
2686  *    Functionality: Builds tag config in MacCellGroupConfig
2687  *
2688  * @params[in] TAG_Config *tag_Config
2689  *
2690  * @return ROK     - success
2691  *         RFAILED - failure
2692  *
2693  * ****************************************************************/
2694 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2695 {
2696    struct TAG_Config__tag_ToAddModList *tagList;
2697    uint8_t                     idx, elementCnt;
2698
2699    tagConfig->tag_ToReleaseList = NULLP;
2700    tagConfig->tag_ToAddModList = NULLP;
2701    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2702    if(!tagConfig->tag_ToAddModList)
2703    {
2704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2705       return RFAILED;
2706    }
2707
2708    if(ueCb == NULLP)
2709       elementCnt = ODU_VALUE_ONE;
2710    else
2711       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2712
2713    tagList = tagConfig->tag_ToAddModList;
2714    tagList->list.count = elementCnt;
2715    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2716
2717    tagList->list.array = NULLP;
2718    DU_ALLOC(tagList->list.array, tagList->list.size);
2719    if(!tagList->list.array)
2720    {
2721       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2722       return RFAILED;
2723    }
2724
2725    for(idx=0; idx<tagList->list.count; idx++)
2726    {
2727       tagList->list.array[idx] = NULLP;
2728       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2729       if(!tagList->list.array[idx])
2730       {
2731          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2732          return RFAILED;
2733       }
2734    }
2735
2736    if(ueCb == NULLP)
2737    {
2738       idx = 0;
2739       tagList->list.array[idx]->tag_Id = TAG_ID;
2740       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2741    }
2742    else
2743    {
2744       for(idx=0; idx<tagList->list.count; idx++)
2745       {
2746          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2747          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2748       }
2749    }
2750
2751    return ROK;
2752 }
2753
2754 /*******************************************************************
2755  *
2756  * @brief Builds PHR Config
2757  *
2758  * @details
2759  *
2760  *    Function : BuildPhrConfig
2761  *
2762  *    Functionality: Builds phrConfig in MacCellGroupConfig
2763  *
2764  * @params[in] PHR Config *
2765  *
2766  * @return ROK     - success
2767  *         RFAILED - failure
2768  *
2769  * ****************************************************************/
2770 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2771 {
2772
2773    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2774    phrConfig->choice.setup = NULLP;
2775    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2776    if(!phrConfig->choice.setup)
2777    {
2778       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2779       return RFAILED;
2780    }
2781
2782    if(ueCb == NULLP)
2783    {
2784       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2785       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2786       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2787       phrConfig->choice.setup->multiplePHR              = false;
2788       phrConfig->choice.setup->dummy                    = false;
2789       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2790       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2791    }
2792    else
2793    {
2794       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2795       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2796       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2797       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2798       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2799       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2800       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2801    }
2802
2803    return ROK;
2804 }
2805
2806 /*******************************************************************
2807  *
2808  * @brief Builds BSR Config
2809  *
2810  * @details
2811  *
2812  *    Function : BuildBsrConfig
2813  *
2814  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2815  *
2816  * @params[in] BSR_Config *bsrConfig
2817  *
2818  * @return ROK     - success
2819  *         RFAILED - failure
2820  *
2821  * ****************************************************************/
2822 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2823 {
2824    if(ueCb == NULLP)
2825    {
2826       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2827       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2828       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2829    }
2830    else
2831    {
2832       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2833       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2834
2835       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2836       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2837       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2838       {
2839          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2840          return RFAILED;
2841       }
2842       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2843    }
2844
2845    return ROK;
2846 }
2847
2848 /*******************************************************************
2849  *
2850  * @brief Builds scheduling request config
2851  *
2852  * @details
2853  *
2854  *    Function : BuildSchedulingReqConfig
2855  *
2856  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2857  *
2858  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2859  *
2860  * @return ROK     - success
2861  *         RFAILED - failure
2862  *
2863  * ****************************************************************/
2864 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2865 {
2866    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2867    uint8_t                     idx, elementCnt;
2868
2869    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2870    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2871          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2872    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2873    {
2874       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2875       return RFAILED;
2876    }
2877
2878    if(ueCb == NULLP)
2879       elementCnt = ODU_VALUE_ONE;
2880    else
2881       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2882
2883    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2884    schReqList->list.count = elementCnt;
2885    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2886
2887    schReqList->list.array = NULLP;
2888    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2889    if(!schReqList->list.array)
2890    {
2891       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2892       return RFAILED;
2893    }
2894
2895    for(idx=0; idx<schReqList->list.count; idx++)
2896    {
2897       schReqList->list.array[idx] = NULLP;
2898       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2899       if(!schReqList->list.array[idx])
2900       {
2901          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2902          return RFAILED;
2903       }
2904    }
2905
2906    if(ueCb == NULLP)
2907    {
2908       idx = 0;
2909       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2910
2911       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2912       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2913       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2914       {
2915          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2916          return RFAILED;
2917       }
2918       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2919       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2920    }
2921    else
2922    {
2923       for(idx=0; idx<schReqList->list.count; idx++)
2924       {
2925          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2926
2927          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2928          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2929          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2930          {
2931             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2932             return RFAILED;
2933          }
2934          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2935          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2936       }
2937    }
2938
2939    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2940
2941    return ROK;
2942 }
2943
2944 /*******************************************************************
2945  *
2946  * @brief Builds RLC Configuration for AM mode
2947  *
2948  * @details
2949  *
2950  *    Function : BuildRlcConfigAm
2951  *
2952  *    Functionality:
2953  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
2954  *
2955  * @params[in] AmBearerCfg *amCfg
2956  *             RLC_Config_t  *rlcConfig
2957  *
2958  * @return ROK     - success
2959  *         RFAILED - failure
2960  *
2961  * ****************************************************************/
2962 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
2963 {
2964    rlcConfig->choice.am = NULLP;
2965    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2966    if(!rlcConfig->choice.am)
2967    {
2968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2969       return RFAILED;
2970    }
2971
2972    /* Fill AM UL configuration */
2973    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2974    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2975    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2976    {
2977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
2978       return RFAILED;
2979    }
2980
2981    /* Fill default AM UL configuration if input pointer to DU database is NULL */
2982    if(amCfg == NULLP)
2983    {
2984       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2985       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2986       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2987       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2988       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2989    }
2990    else
2991    {
2992       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
2993       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
2994       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
2995       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
2996       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
2997    }
2998
2999    /* Fill AM DL configuraion */
3000    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3001    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3002    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3003    {
3004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3005       return RFAILED;
3006    }
3007
3008    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3009    if(amCfg == NULLP)
3010    {
3011       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3012       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3013       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3014    }
3015    else /* Fill AM configuration from DU database */
3016    {
3017       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3018       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3019       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3020    }
3021    return ROK;
3022 }
3023
3024 /*******************************************************************
3025  *
3026  * @brief Builds RLC Config for UM Bidirection
3027  *
3028  * @details
3029  *
3030  *    Function : BuildRlcConfig UmBiDir
3031  *
3032  *    Functionality:
3033  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3034  *
3035  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3036  *             RLC_Config_t *rlcConfig
3037  *
3038  * @return ROK     - success
3039  *         RFAILED - failure
3040  *
3041  * ****************************************************************/
3042 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3043 {
3044    rlcConfig->choice.um_Bi_Directional = NULLP;
3045    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3046    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3047    {
3048       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3049       return RFAILED;
3050    }
3051
3052    /* Fill UM Bidirectional UL configuration */
3053    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3054    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3055    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3056    {
3057       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3058       return RFAILED;
3059    }
3060
3061    if(umBiDirCfg != NULLP)
3062    {
3063       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3064    }
3065
3066    /* Fill UM Bidirectional DL configuration */
3067    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3068    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3069    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3070    {
3071       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3072       return RFAILED;
3073    }
3074
3075    if(umBiDirCfg != NULLP)
3076    {
3077       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3078       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3079    }
3080
3081    return ROK;
3082 }
3083
3084 /*******************************************************************
3085  *
3086  * @brief Builds RLC Config for UM Uni directional UL
3087  *
3088  * @details
3089  *
3090  *    Function : BuildRlcConfigUmUniDirUl
3091  *
3092  *    Functionality:
3093  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3094  *
3095  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3096  *             RLC_Config_t *rlcConfig
3097  *
3098  * @return ROK     - success
3099  *         RFAILED - failure
3100  *
3101  * ****************************************************************/
3102 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3103 {
3104    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3105    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3106    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3107    {
3108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3109       return RFAILED;
3110    }
3111
3112    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3113    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3114    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3115    {
3116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3117       return RFAILED;
3118    }
3119
3120    if(umUniDirDlCfg != NULLP)
3121    {
3122       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3123    }
3124
3125    return ROK;
3126 }
3127
3128 /*******************************************************************
3129  *
3130  * @brief Builds RLC Config for UM Uni directional DL
3131  *
3132  * @details
3133  *
3134  *    Function : BuildRlcConfigUmUniDirDl
3135  *
3136  *    Functionality:
3137  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3138  *
3139  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3140  *             RLC_Config_t *rlcConfig
3141  *
3142  * @return ROK     - success
3143  *         RFAILED - failure
3144  *
3145  * ****************************************************************/
3146 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3147 {
3148    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3149    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3150    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3151    {
3152       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3153       return RFAILED;
3154    }
3155
3156    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3157    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3158    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3159    {
3160       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3161       return RFAILED;
3162    }
3163
3164    if(umUniDirUlCfg != NULLP)
3165    {
3166       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3167       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3168    }
3169
3170    return ROK;
3171 }
3172
3173 /*******************************************************************
3174  *
3175  * @brief Builds RLC Config
3176  *
3177  * @details
3178  *
3179  *    Function : BuildRlcConfig
3180  *
3181  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3182  *
3183  * @params[in] RLC_Config_t *rlcConfig
3184  *
3185  * @return ROK     - success
3186  *         RFAILED - failure
3187  *
3188  * ****************************************************************/
3189 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3190 {
3191
3192    /* Fill default values if rbCfg is NULL */
3193    if(rbCfg == NULLP)
3194    {
3195       rlcConfig->present = RLC_Config_PR_am;
3196       BuildRlcConfigAm(NULLP, rlcConfig);
3197    }
3198    /* If RbCfg is present, fill RLC configurations from DU Database */
3199    else
3200    {
3201       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3202       switch(rlcConfig->present)
3203       {
3204          case RLC_Config_PR_am:
3205             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3206             break;
3207          case RLC_Config_PR_um_Bi_Directional:
3208             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3209             break;
3210          case RLC_Config_PR_um_Uni_Directional_UL:
3211             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3212             break;
3213          case RLC_Config_PR_um_Uni_Directional_DL:
3214             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3215             break;
3216          case RLC_Config_PR_NOTHING:
3217          default:
3218             break;
3219       }
3220    }
3221
3222    return ROK;
3223 }
3224
3225 /*******************************************************************
3226  *
3227  * @brief Builds MAC LC Config
3228  *
3229  * @details
3230  *
3231  *    Function : BuildMacLCConfig
3232  *
3233  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3234  *
3235  * @params[in] struct LogicalChannelConfig macLcConfig
3236  *
3237  * @return ROK     - success
3238  *         RFAILED - failure
3239  *
3240  * ****************************************************************/
3241 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3242 {
3243    macLcConfig->ul_SpecificParameters = NULLP;
3244    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3245    if(!macLcConfig->ul_SpecificParameters)
3246    {
3247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3248       return RFAILED;
3249    }
3250
3251    if(lcCfgDb == NULLP)
3252    {
3253       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3254       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3255       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3256    }
3257    else
3258    {
3259       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3260       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3261       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3262    }
3263
3264    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3265    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3266    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3267    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3268
3269    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3270    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3271    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3272    {
3273       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3274       return RFAILED;
3275    }
3276
3277    if(lcCfgDb == NULLP)
3278       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3279    else
3280       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3281
3282    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3283    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3284    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3285    {
3286       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3287       return RFAILED;
3288    }
3289
3290    if(lcCfgDb == NULLP)
3291       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3292    else
3293       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3294
3295    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3296    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3297    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3298
3299    return ROK;
3300 }
3301
3302 /*******************************************************************
3303  *
3304  * @brief Builds RLC Bearer to Add/Mod list
3305  *
3306  * @details
3307  *
3308  *    Function :BuildRlcBearerToAddModList
3309  *
3310  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3311  *
3312  * @params[in] rlc_BearerToAddModList
3313  *
3314  * @return ROK     - success
3315  *         RFAILED - failure
3316  *
3317  * ****************************************************************/
3318 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3319 {
3320    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3321
3322    if(ueCb == NULLP)
3323       elementCnt = 1;
3324    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3325       elementCnt = ueCb->rlcUeCfg.numLcs;
3326    else
3327    {
3328       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3329       {
3330          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3331             elementCnt++;
3332       }
3333    }
3334    rlcBearerList->list.count = elementCnt;
3335    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3336
3337    rlcBearerList->list.array = NULLP;
3338    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3339    if(!rlcBearerList->list.array)
3340    {
3341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3342       return RFAILED;
3343    }
3344
3345    for(idx=0; idx<rlcBearerList->list.count; idx++)
3346    {
3347       rlcBearerList->list.array[idx] = NULLP;
3348       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3349       if(!rlcBearerList->list.array[idx])
3350       {
3351          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3352          return RFAILED;
3353       }
3354    }
3355
3356    if(ueCb == NULLP)
3357    {
3358       idx=0;
3359       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3360       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3361       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3362       {
3363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3364          return RFAILED;
3365       }
3366       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3367       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3368       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3369
3370       /* Fill RLC related Configurations for this Radio Bearer */
3371       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3372       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3373       if(!rlcBearerList->list.array[idx]->rlc_Config)
3374       {
3375          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3376          return RFAILED;
3377       }
3378       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3379       {
3380          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3381          return RFAILED;
3382       }
3383
3384       /* Fill MAC related configurations for this Radio Bearer */
3385       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3386       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3387       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3388       {
3389          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3390          return RFAILED;
3391       }
3392       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3393       {
3394          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3395          return RFAILED;
3396       }
3397    }
3398    else
3399    {
3400       idx=0;
3401       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3402       {
3403          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3404             continue;
3405
3406          /* Fill Logical channel identity */
3407          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3408
3409          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3410          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3411          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3412          {
3413             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3414             return RFAILED;
3415          }
3416          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3417                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3418          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3419          {
3420             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3421                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3422                break;
3423             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3424                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3425                break;
3426             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3427             default:
3428                break;
3429          }
3430          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3431
3432          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3433
3434          /* Fill RLC related Configurations for this Radio Bearer */
3435          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3436          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3437          if(!rlcBearerList->list.array[idx]->rlc_Config)
3438          {
3439             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3440             return RFAILED;
3441          }
3442          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3443          {
3444             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3445             return RFAILED;
3446          }
3447
3448          /* Fill MAC related configurations for this Radio Bearer */
3449          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3450          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3451          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3452          {
3453             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3454             return RFAILED;
3455          }
3456          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3457          {
3458             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3459             {
3460                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3461                {
3462                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3463                   return RFAILED;
3464                }
3465                break;
3466             }
3467          }
3468
3469          idx++;
3470       }
3471    }
3472    return ROK;
3473 }
3474
3475 /*******************************************************************
3476  *
3477  * @brief Build Control resource set to add/modify list
3478  *
3479  * @details
3480  *
3481  *    Function : BuildControlRSetToAddModList
3482  *
3483  *    Functionality: Build Control resource set to add/modify list
3484  *
3485  * @params[in]
3486  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3487  *
3488  * @return ROK     - success
3489  *         RFAILED - failure
3490  *
3491  * ****************************************************************/
3492 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3493 {
3494    uint8_t idx;
3495    uint8_t elementCnt;
3496    uint8_t numBytes, bitsUnused;
3497    struct ControlResourceSet *controlRSet;
3498    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3499    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3500
3501    if(pdcchCfg == NULLP)
3502       elementCnt = 1;
3503    else
3504       elementCnt = pdcchCfg->numCRsetToAddMod;
3505
3506    controlRSetList->list.count = elementCnt;
3507    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3508
3509    controlRSetList->list.array = NULLP;
3510    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3511    if(!controlRSetList->list.array)
3512    {
3513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3514       return RFAILED;
3515    }
3516
3517    for(idx = 0; idx < elementCnt; idx++)
3518    {
3519       controlRSetList->list.array[idx] = NULLP;
3520       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3521       if(!controlRSetList->list.array[idx])
3522       {
3523          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3524          return RFAILED;
3525       }
3526    }
3527
3528    for(idx = 0; idx < elementCnt; idx++)
3529    {
3530       controlRSet = controlRSetList->list.array[idx];
3531
3532       if(pdcchCfg == NULLP)
3533          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3534       else
3535          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3536
3537       /* size 6 bytes
3538        * 3 LSBs unsued
3539        * Bit string stored ff0000000000
3540        */
3541       numBytes = 6;
3542       bitsUnused = 3;
3543       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3544
3545       controlRSet->frequencyDomainResources.buf = NULLP;
3546       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3547       if(!controlRSet->frequencyDomainResources.buf)
3548       {
3549          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3550          return RFAILED;
3551       }
3552
3553       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3554
3555       if(pdcchCfg == NULLP)
3556       {
3557          coreset0EndPrb = CORESET0_END_PRB;
3558          coreset1StartPrb = coreset0EndPrb + 6;
3559          coreset1NumPrb = CORESET1_NUM_PRB;
3560          /* calculate the PRBs */
3561          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3562          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3563          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3564
3565          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3566          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3567          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3568       }
3569       else
3570       {
3571          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3572          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3573          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3574          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3575          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3576       }
3577       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3578       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3579       controlRSet->tci_PresentInDCI = NULLP;
3580
3581 #if 0
3582       uint8_t tciStateIdx;
3583
3584       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3585             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3586       if(!controlRset->tci_StatesPDCCH_ToAddList)
3587       {
3588          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3589          return RFAILED;
3590       }
3591
3592       elementCnt = 1;
3593       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3594       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3595       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3596             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3597          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3598          {
3599             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3600             return RFAILED;
3601          }
3602
3603       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3604       {
3605          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3606          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3607          {
3608             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3609             return RFAILED;
3610          }
3611       }
3612
3613       tciStateIdx = 0;
3614       /* TODO */
3615       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3616
3617       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3618       if(!controlRset->tci_PresentInDCI)
3619       {
3620          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3621          return RFAILED;
3622       }
3623       /* TODO */
3624       *(controlRset->tci_PresentInDCI);
3625 #endif
3626
3627       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3628       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3629       if(!controlRSet->pdcch_DMRS_ScramblingID)
3630       {
3631          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3632          return RFAILED;
3633       }
3634       if(pdcchCfg == NULLP)
3635          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3636       else
3637          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3638    }
3639    return ROK;
3640 } /* End BuildControlRSetToAddModList */
3641
3642 /*******************************************************************
3643  *
3644  * @brief Build search space to add/modify list
3645  *
3646  * @details
3647  *
3648  *    Function : BuildSearchSpcToAddModList
3649  *
3650  *    Functionality: Build search space to add/modify list
3651  *
3652  * @params[in]
3653  * @return ROK     - success
3654  *         RFAILED - failure
3655  *
3656  * ****************************************************************/
3657 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3658 {
3659    uint8_t idx;
3660    uint8_t numBytes;
3661    uint8_t byteIdx;
3662    uint8_t bitsUnused;
3663    uint8_t elementCnt;
3664    struct SearchSpace *searchSpc;
3665
3666    if(pdcchCfg == NULLP)
3667       elementCnt = 1;
3668    else
3669       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3670
3671    searchSpcList->list.count = elementCnt;
3672    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3673
3674    searchSpcList->list.array = NULLP;
3675    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3676    if(!searchSpcList->list.array)
3677    {
3678       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3679       return RFAILED;
3680    }
3681
3682    for(idx = 0; idx < elementCnt; idx++)
3683    {
3684       searchSpcList->list.array[idx] = NULLP;
3685       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3686       if(!searchSpcList->list.array[idx])
3687       {
3688          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3689          return RFAILED;
3690       }
3691    }
3692
3693    for(idx = 0; idx < elementCnt; idx++)
3694    {
3695       searchSpc = searchSpcList->list.array[idx];
3696
3697       if(pdcchCfg == NULLP)
3698          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3699       else
3700          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3701
3702       searchSpc->controlResourceSetId = NULLP;
3703       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3704       if(!searchSpc->controlResourceSetId)
3705       {
3706          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3707          return RFAILED;
3708       }
3709       if(pdcchCfg == NULLP)
3710          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3711       else
3712          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3713
3714       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3715       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3716       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3717       {
3718          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3719          return RFAILED;
3720       }
3721       if(pdcchCfg == NULLP)
3722          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3723       else
3724          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3725
3726       searchSpc->duration = NULLP;
3727       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3728       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3729       if(!searchSpc->monitoringSymbolsWithinSlot)
3730       {
3731          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3732          return RFAILED;
3733       }
3734
3735       /* Values taken from reference logs :
3736        * size 2 bytes
3737        * 2 LSBs unsued
3738        * Bit string stores 8000
3739        */
3740       numBytes = 2;
3741       bitsUnused = 2;
3742       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3743       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3744       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3745       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3746       {
3747          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3748          return RFAILED;
3749       }
3750       if(pdcchCfg == NULLP)
3751       {
3752          byteIdx = 0;
3753          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3754          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3755       }
3756       else
3757          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3758       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3759
3760       searchSpc->nrofCandidates = NULLP;
3761       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3762       if(!searchSpc->nrofCandidates)
3763       {
3764          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3765          return RFAILED;
3766       }
3767
3768       if(pdcchCfg == NULLP)
3769       {
3770          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3771          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3772          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3773          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3774          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3775       }
3776       else
3777       {
3778          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3779          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3780          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3781          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3782          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3783       }
3784
3785       searchSpc->searchSpaceType = NULLP;
3786       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3787       if(!searchSpc->searchSpaceType)
3788       {
3789          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3790          return RFAILED;
3791       }
3792       if(pdcchCfg == NULLP)
3793          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3794       else
3795          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3796
3797       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3798       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3799       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3800       {
3801          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3802          return RFAILED;
3803       }
3804       if(pdcchCfg == NULLP)
3805          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3806       else
3807          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3808    }
3809    return ROK;
3810 }/* End BuildSearchSpcToAddModList */
3811
3812 /*******************************************************************
3813  *
3814  * @brief Builds BWP DL dedicated PDCCH config
3815  *
3816  * @details
3817  *
3818  *    Function : BuildBWPDlDedPdcchCfg
3819  *
3820  *    Functionality: Builds BWP DL dedicated PDCCH config
3821  *
3822  * @params[in] struct PDCCH_Config *pdcchCfg
3823  *
3824  * @return ROK     - success
3825  *         RFAILED - failure
3826  *
3827  * ****************************************************************/
3828 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3829 {
3830    pdcchCfg->controlResourceSetToAddModList = NULLP;
3831    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3832    if(!pdcchCfg->controlResourceSetToAddModList)
3833    {
3834       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3835       return RFAILED;
3836    }
3837
3838    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3839    {
3840       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3841       return RFAILED;
3842    }
3843
3844    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3845
3846    pdcchCfg->searchSpacesToAddModList = NULLP;
3847    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3848    if(!pdcchCfg->searchSpacesToAddModList)
3849    {
3850       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3851       return RFAILED;
3852    }
3853
3854    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3855    {
3856       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3857       return RFAILED;
3858    }
3859
3860    pdcchCfg->searchSpacesToReleaseList = NULLP;
3861    pdcchCfg->downlinkPreemption = NULLP;
3862    pdcchCfg->tpc_PUSCH = NULLP;
3863    pdcchCfg->tpc_PUCCH = NULLP;
3864    pdcchCfg->tpc_SRS = NULLP;
3865
3866    return ROK;
3867 }
3868
3869 /*******************************************************************
3870  *
3871  * @brief Builds DMRS DL PDSCH Mapping type A
3872  *
3873  * @details
3874  *
3875  *    Function : BuildDMRSDLPdschMapTypeA
3876  *
3877  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3878  *
3879  * @params[in]
3880  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3881  * @return ROK     - success
3882  *         RFAILED - failure
3883  *
3884  * ****************************************************************/
3885 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3886 {
3887    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3888    dmrsDlCfg->choice.setup = NULLP;
3889    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3890    if(!dmrsDlCfg->choice.setup)
3891    {
3892       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3893       return RFAILED;
3894    }
3895
3896    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3897    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3898    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3899    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3900    {
3901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3902       return RFAILED;
3903    }
3904    if(pdschCfg == NULLP)
3905       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3906    else
3907       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3908
3909    dmrsDlCfg->choice.setup->maxLength = NULLP;
3910    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3911    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3912    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3913
3914    return ROK;
3915 }
3916
3917 /*******************************************************************
3918  *
3919  * @brief Builds TCI states to add/modify list
3920  *
3921  * @details
3922  *
3923  *    Function : BuildTCIStatesToAddModList
3924  *
3925  *    Functionality:Builds TCI states to add/modify list
3926  *
3927  * @params[in]
3928  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3929  *
3930  * @return ROK     - success
3931  *         RFAILED - failure
3932  *
3933  * ****************************************************************/
3934 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3935 {
3936    return ROK;
3937 }
3938
3939 /*******************************************************************
3940  *
3941  * @brief Builds PDSCH time domain allocation list
3942  *
3943  * @details
3944  *
3945  *    Function : BuildPdschTimeDomAllocList
3946  *
3947  *    Functionality: Builds PDSCH time domain allocation list
3948  *
3949  * @params[in]
3950  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3951  *
3952  * @return ROK     - success
3953  *         RFAILED - failure
3954  *
3955  * ****************************************************************/
3956 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
3957 {
3958    uint8_t idx;
3959    uint8_t elementCnt;
3960    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3961
3962    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3963
3964    timeDomAllocList->choice.setup = NULLP;
3965    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3966    if(!timeDomAllocList->choice.setup)
3967    {
3968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3969       return RFAILED;
3970    }
3971
3972 if(pdschCfg == NULLP)
3973    elementCnt = 2;
3974 else
3975 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
3976    timeDomAllocList->choice.setup->list.count = elementCnt;
3977    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3978
3979    timeDomAllocList->choice.setup->list.array = NULLP;
3980    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
3981    if(!timeDomAllocList->choice.setup->list.array)
3982    {
3983       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3984       return RFAILED;
3985    }
3986
3987    for(idx = 0; idx < elementCnt; idx++)
3988    {
3989       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3990       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3991             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3992       if(!timeDomAllocList->choice.setup->list.array[idx])
3993       {
3994          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3995          return RFAILED;
3996       }
3997    }
3998
3999    if(pdschCfg == NULLP)
4000    {
4001       idx = 0;
4002       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4003       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4004       if(!timeDomAlloc->k0)
4005       {
4006          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4007          return RFAILED;
4008       }
4009       *(timeDomAlloc->k0) = 0;
4010       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4011       timeDomAlloc->startSymbolAndLength = \
4012                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4013
4014       idx++;
4015       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4016       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4017       if(!timeDomAlloc->k0)
4018       {
4019          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4020          return RFAILED;
4021       }
4022       *(timeDomAlloc->k0) = 1;
4023       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4024       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4025    }
4026    else
4027    {
4028       for(idx = 0; idx < elementCnt; idx++)
4029       {
4030          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4031          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4032          if(!timeDomAlloc->k0)
4033          {
4034             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4035             return RFAILED;
4036          }
4037          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4038             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4039          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4040          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4041       }
4042    }
4043
4044    return ROK;
4045 }
4046
4047 /*******************************************************************
4048  *
4049  * @brief Builds PDSCH PRB Bundling type
4050  *
4051  * @details
4052  *
4053  *    Function : BuildPdschPrbBundlingType
4054  *
4055  *    Functionality: Builds PDSCH PRB Bundling type
4056  *
4057  * @params[in]
4058  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4059  *
4060  * @return ROK     - success
4061  *         RFAILED - failure
4062  *
4063  * ****************************************************************/
4064 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4065 {
4066    if(pdschCfg == NULLP)
4067       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4068    else
4069       prbBndlType->present = pdschCfg->bundlingType;
4070
4071    prbBndlType->choice.staticBundling = NULLP;
4072    DU_ALLOC(prbBndlType->choice.staticBundling, \
4073          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4074    if(!prbBndlType->choice.staticBundling)
4075    {
4076       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4077       return RFAILED;
4078    }
4079    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4080
4081    return ROK;
4082 }
4083
4084 /*******************************************************************
4085  *
4086  * @brief Builds BWP DL dedicated PDSCH config
4087  *
4088  * @details
4089  *
4090  *    Function : BuildBWPDlDedPdschCfg
4091  *
4092  *    Functionality: Builds BWP DL dedicated PDSCH config
4093  *
4094  * @params[in] struct PDSCH_Config *pdschCfg
4095  *
4096  * @return ROK     - success
4097  *         RFAILED - failure
4098  *
4099  * ****************************************************************/
4100 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4101 {
4102    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4103
4104    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4105    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4106    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4107    {
4108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4109       return RFAILED;
4110    }
4111
4112    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4113    {
4114       return RFAILED;
4115    }
4116
4117    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4118    pdschCfg->tci_StatesToAddModList = NULLP;
4119    pdschCfg->tci_StatesToReleaseList = NULLP;
4120    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4121 #if 0
4122    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4123    if(!pdschCfg->tci_StatesToAddModList)
4124    {
4125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4126       return RFAILED;
4127    }
4128    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4129    {
4130       return RFAILED;
4131    }
4132 #endif
4133
4134 if(pdschCfgDb == NULLP)
4135    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4136 else
4137 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4138
4139    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4140    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4141    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4142    {
4143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4144       return RFAILED;
4145    }
4146    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4147    {
4148       return RFAILED;
4149    }
4150
4151    pdschCfg->pdsch_AggregationFactor = NULLP;
4152    pdschCfg->rateMatchPatternToAddModList = NULLP;
4153    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4154    pdschCfg->rateMatchPatternGroup1 = NULLP;
4155    pdschCfg->rateMatchPatternGroup2 = NULLP;
4156    if(pdschCfgDb == NULLP)
4157       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4158    else
4159       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4160    pdschCfg->mcs_Table = NULLP;
4161
4162    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4163    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4164    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4165    {
4166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4167       return RFAILED;
4168    }
4169    if(pdschCfgDb == NULLP)
4170       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4171    else
4172       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4173
4174    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4175    {
4176       return RFAILED;
4177    }
4178
4179    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4180    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4181    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4182    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4183    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4184    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4185    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4186
4187    return ROK;
4188 }
4189
4190 /*******************************************************************
4191  *
4192  * @brief Builds intitial DL BWP
4193  * @details
4194  *
4195  *    Function : BuildInitialDlBWP
4196  *
4197  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4198  *
4199  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4200  *
4201  * @return ROK     - success
4202  *         RFAILED - failure
4203  *
4204  * ****************************************************************/
4205 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4206 {
4207    PdcchConfig *pdcchCfg = NULLP;
4208    PdschConfig *pdschCfg = NULLP;
4209
4210    if(initiDlBwp)
4211    {
4212       if(initiDlBwp->pdcchPresent)
4213          pdcchCfg = &initiDlBwp->pdcchCfg;
4214       if(initiDlBwp->pdschPresent)
4215          pdschCfg = &initiDlBwp->pdschCfg;
4216    }
4217
4218    dlBwp->pdcch_Config = NULLP;
4219    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4220    if(!dlBwp->pdcch_Config)
4221    {
4222       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4223       return RFAILED;
4224    }
4225    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4226
4227    dlBwp->pdcch_Config->choice.setup = NULLP;
4228    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4229    if(!dlBwp->pdcch_Config->choice.setup)
4230    {
4231       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4232       return RFAILED;
4233    }
4234    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4235    {
4236       return RFAILED;
4237    }
4238
4239    dlBwp->pdsch_Config = NULLP;
4240    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4241    if(!dlBwp->pdsch_Config)
4242    {
4243       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4244       return RFAILED;
4245    }
4246    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4247
4248    dlBwp->pdsch_Config->choice.setup = NULLP;
4249    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4250    if(!dlBwp->pdsch_Config->choice.setup)
4251    {
4252       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4253       return RFAILED;
4254    }
4255
4256    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4257    {
4258       return RFAILED;
4259    }
4260
4261    dlBwp->sps_Config = NULLP;
4262    dlBwp->radioLinkMonitoringConfig = NULLP;
4263    return ROK;
4264 }
4265
4266 /*******************************************************************
4267  *
4268  * @brief Builds DMRS UL Pusch Mapping type A
4269  *
4270  * @details
4271  *
4272  *    Function : BuildDMRSULPuschMapTypeA
4273  *
4274  *    Functionality: Builds DMRS UL Pusch Mapping type A
4275  *
4276  * @params[in]
4277  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4278  * @return ROK     - success
4279  *         RFAILED - failure
4280  *
4281  * ****************************************************************/
4282 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4283 {
4284    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4285    dmrsUlCfg->choice.setup= NULLP;
4286    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4287    if(!dmrsUlCfg->choice.setup)
4288    {
4289       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4290       return RFAILED;
4291    }
4292
4293    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4294    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4295    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4296    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4297    {
4298       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4299       return RFAILED;
4300    }
4301    if(ulDmrsCfgDb == NULLP)
4302       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4303    else
4304       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4305
4306    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4307    dmrsUlCfg->choice.setup->maxLength = NULLP;
4308    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4309    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4310    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4311    {
4312       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4313       return RFAILED;
4314    }
4315
4316    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4317    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4318          sizeof(long));
4319    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4320    {
4321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4322       return RFAILED;
4323    }
4324    if(ulDmrsCfgDb == NULLP)
4325       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4326    else
4327       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4328
4329    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4330    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4331    return ROK;
4332 }
4333
4334 /*******************************************************************
4335  *
4336  * @brief Build PUSCH time domain allocation list
4337  *
4338  * @details
4339  *
4340  *    Function : BuildPuschTimeDomAllocList
4341  *
4342  *    Functionality: Build PUSCH time domain allocation list
4343  *
4344  * @params[in]
4345  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4346  *
4347  * @return ROK     - success
4348  *         RFAILED - failure
4349  *
4350  * ****************************************************************/
4351 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4352 {
4353    uint8_t idx;
4354    uint8_t elementCnt;
4355    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4356
4357    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4358    timeDomAllocList->choice.setup = NULLP;
4359    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4360    if(!timeDomAllocList->choice.setup)
4361    {
4362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4363       return RFAILED;
4364    }
4365
4366    if(puschCfgDb == NULLP)
4367       elementCnt = 2;
4368    else
4369       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4370
4371    timeDomAllocList->choice.setup->list.count = elementCnt;
4372    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4373    timeDomAllocList->choice.setup->list.array = NULLP;
4374    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4375    if(!timeDomAllocList->choice.setup->list.array)
4376    {
4377       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4378       return RFAILED;
4379    }
4380
4381    for(idx = 0; idx < elementCnt; idx++)
4382    {
4383       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4384       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4385       if(!timeDomAllocList->choice.setup->list.array[idx])
4386       {
4387          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4388          return RFAILED;
4389       }
4390    }
4391
4392    for(idx = 0; idx < elementCnt; idx++)
4393    {
4394       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4395       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4396       if(!timeDomAlloc->k2)
4397       {
4398          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4399          return RFAILED;
4400       }
4401       if(puschCfgDb == NULLP)
4402       {
4403          if(idx == 0)
4404             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4405          else if(idx == 1)
4406             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4407
4408          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4409          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4410       }
4411       else
4412       {
4413          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4414          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4415          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4416       }
4417    }
4418
4419    return ROK;
4420 }
4421
4422 /*******************************************************************
4423  *
4424  * @brief Builds BWP UL dedicated PUSCH Config
4425  *
4426  * @details
4427  *
4428  *    Function : BuildBWPUlDedPuschCfg
4429  *
4430  *    Functionality:
4431  *      Builds BWP UL dedicated PUSCH Config
4432  *
4433  * @params[in] : PUSCH_Config_t *puschCfg
4434  *
4435  * @return ROK     - success
4436  *         RFAILED - failure
4437  *
4438  * ****************************************************************/
4439 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4440 {
4441    DmrsUlCfg *ulDmrsCfg = NULLP;
4442
4443    if(puschCfgDb)
4444       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4445
4446    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4447    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4448    if(!puschCfg->dataScramblingIdentityPUSCH)
4449    {
4450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4451       return RFAILED;
4452    }
4453    if(puschCfgDb == NULLP)
4454       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4455    else
4456       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4457
4458    puschCfg->txConfig = NULLP;
4459    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4460    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4461    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4462    {
4463       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4464       return RFAILED;
4465    }
4466
4467    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4468    {
4469       return RFAILED;
4470    }
4471
4472    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4473    puschCfg->pusch_PowerControl = NULLP;
4474    puschCfg->frequencyHopping = NULLP;
4475    puschCfg->frequencyHoppingOffsetLists = NULLP;
4476
4477    if(puschCfgDb == NULLP)
4478       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4479    else
4480       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4481
4482    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4483    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4484    if(!puschCfg->pusch_TimeDomainAllocationList)
4485    {
4486       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4487       return RFAILED;
4488    }
4489
4490    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4491    {
4492       return RFAILED;
4493    }
4494
4495    puschCfg->pusch_AggregationFactor = NULLP;
4496    puschCfg->mcs_Table = NULLP;
4497    puschCfg->mcs_TableTransformPrecoder = NULLP;
4498    puschCfg->transformPrecoder = NULLP;
4499    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4500    if(!puschCfg->transformPrecoder)
4501    {
4502       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4503       return RFAILED;
4504    }
4505    if(puschCfgDb == NULLP)
4506       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4507    else
4508       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4509
4510    puschCfg->codebookSubset = NULLP;
4511    puschCfg->maxRank = NULLP;
4512    puschCfg->rbg_Size = NULLP;
4513    puschCfg->uci_OnPUSCH = NULLP;
4514    puschCfg->tp_pi2BPSK = NULLP;
4515
4516    return ROK;
4517 }
4518
4519 /*******************************************************************
4520  *
4521  * @brief Builds PUCCH resource set add/modify list
4522  *
4523  * @details
4524  *
4525  *    Function : BuildPucchRsrcSetAddModList
4526  *
4527  *    Functionality:
4528  *      Builds PUCCH resource set add/modify list
4529  *
4530  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4531  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4532  *
4533  * @return ROK     - success
4534  *         RFAILED - failure
4535  *
4536  * ****************************************************************/
4537 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4538    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4539 {
4540    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4541    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4542
4543    if(rsrcSetCfgDb == NULLP)
4544       elementCnt = 1;
4545    else
4546       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4547
4548    resourceSetToAddModList->list.count = elementCnt;
4549    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4550    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4551    if(resourceSetToAddModList->list.array == NULLP)
4552    {
4553       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4554       return RFAILED;
4555    }
4556    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4557    {
4558       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4559       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4560       {
4561          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4562          return RFAILED;
4563       }
4564    }
4565
4566    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4567    {
4568       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4569
4570       /* Resource set Id */
4571       if(rsrcSetCfgDb == NULLP)
4572          rsrcSet->pucch_ResourceSetId = 1;
4573       else
4574          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4575
4576       /* Resource list of a resource set */
4577       if(rsrcSetCfgDb == NULLP)
4578          elementCnt = 1;
4579       else
4580          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4581       rsrcSet->resourceList.list.count = elementCnt;
4582       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4583       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4584       if(rsrcSet->resourceList.list.array == NULLP)
4585       {
4586          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4587          return RFAILED;
4588       }
4589
4590       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4591       {
4592          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4593          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4594          {
4595             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4596             return RFAILED;
4597          }
4598       }
4599       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4600       {
4601          if(rsrcSetCfgDb == NULLP)
4602             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4603          else
4604             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4605       }
4606
4607       /* Max payload size (minus 1) in a Resource set */
4608       rsrcSet->maxPayloadMinus1 = NULLP;
4609       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4610       {
4611          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4612          if(rsrcSet->maxPayloadMinus1 == NULLP)
4613          {
4614             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4615             return RFAILED;
4616          }
4617          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4618       }
4619    }
4620    return ROK;
4621 }
4622
4623 /*******************************************************************
4624  *
4625  * @brief Builds PUCCH resource add/modify list
4626  *
4627  * @details
4628  *
4629  *    Function : BuildPucchRsrcAdddModList
4630  *
4631  *    Functionality:
4632  *      Builds PUCCH resource add/modify list
4633  *
4634  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4635  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4636  *
4637  * @return ROK     - success
4638  *         RFAILED - failure
4639  *
4640  * ****************************************************************/
4641 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4642 {
4643    uint8_t elementCnt = 0, rsrcIdx = 0;
4644    PUCCH_Resource_t *rsrc = NULLP;
4645
4646    if(rsrcCfgDb == NULLP)
4647       elementCnt = 1;
4648    else
4649       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4650    resourceToAddModList->list.count = elementCnt;
4651    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4652    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4653    if(resourceToAddModList->list.array == NULLP)
4654    {
4655       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4656       return RFAILED;
4657    }
4658    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4659    {
4660       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4661       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4662       {
4663          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4664          return RFAILED;
4665       }
4666    }
4667
4668    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4669    {
4670       rsrc = resourceToAddModList->list.array[rsrcIdx];
4671
4672       if(rsrcCfgDb == NULLP)
4673       {
4674          rsrc->pucch_ResourceId = 1;
4675          rsrc->startingPRB = 0;
4676          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4677          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4678          if(rsrc->format.choice.format1 == NULLP)
4679          {
4680             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4681             return RFAILED;
4682          }
4683          rsrc->format.choice.format1->initialCyclicShift = 0;
4684          rsrc->format.choice.format1->nrofSymbols = 4;
4685          rsrc->format.choice.format1->startingSymbolIndex = 0;
4686          rsrc->format.choice.format1->timeDomainOCC = 0;
4687       }
4688       else
4689       {
4690          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4691          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4692          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4693          {
4694             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4695             if(rsrc->intraSlotFrequencyHopping == NULLP)
4696             {
4697                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4698                return RFAILED;
4699             }
4700             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4701          }
4702          else
4703             rsrc->intraSlotFrequencyHopping = NULLP;
4704
4705          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4706          {
4707             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4708             if(rsrc->secondHopPRB == NULLP)
4709             {
4710                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4711                return RFAILED;
4712             }
4713             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4714          }
4715          else
4716             rsrc->secondHopPRB = NULLP;
4717          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4718
4719          switch(rsrc->format.present)
4720          {
4721             case PUCCH_Resource__format_PR_NOTHING:
4722                break;
4723             case PUCCH_Resource__format_PR_format0:
4724                {
4725                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4726                   if(rsrc->format.choice.format0 == NULLP)
4727                   {
4728                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4729                      return RFAILED;
4730                   }
4731                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4732                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4733                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4734                   break;
4735                }
4736
4737             case PUCCH_Resource__format_PR_format1:
4738                {
4739                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4740                   if(rsrc->format.choice.format1 == NULLP)
4741                   {
4742                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4743                      return RFAILED;
4744                   }
4745                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4746                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4747                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4748                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4749                   break;
4750                }
4751
4752             case PUCCH_Resource__format_PR_format2:
4753                {
4754                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4755                   if(rsrc->format.choice.format2 == NULLP)
4756                   {
4757                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4758                      return RFAILED;
4759                   }
4760                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4761                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4762                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4763                   break;
4764                }
4765
4766             case PUCCH_Resource__format_PR_format3:
4767                {
4768                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4769                   if(rsrc->format.choice.format3 == NULLP)
4770                   {
4771                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4772                      return RFAILED;
4773                   }
4774                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4775                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4776                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4777                   break;
4778                }
4779
4780             case PUCCH_Resource__format_PR_format4:
4781                {
4782                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4783                   if(rsrc->format.choice.format4 == NULLP)
4784                   {
4785                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4786                      return RFAILED;
4787                   }
4788                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4789                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4790                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4791                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4792                   break;
4793                }
4794          }
4795       }
4796    }
4797    return ROK;
4798 }
4799
4800 /*******************************************************************
4801  *
4802  * @brief Builds PUCCH format  config
4803  *
4804  * @details
4805  *
4806  *    Function : BuildPucchFormat
4807  *
4808  *    Functionality: Builds PUCCH format  config
4809  *
4810  * @params[in] : PucchFormatCfg *formatDb
4811  *               PUCCH_FormatConfig_t *format
4812  *
4813  * @return ROK     - success
4814  *         RFAILED - failure
4815  *
4816  * ****************************************************************/
4817 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4818 {
4819    /* Inter Slot Fequency hopping */
4820    format->interslotFrequencyHopping = NULLP;
4821    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4822    {
4823       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4824       if(format->interslotFrequencyHopping)
4825       {
4826          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4827          return RFAILED;
4828       }
4829       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4830    }
4831
4832    /* Additional DMRS */
4833    format->additionalDMRS = NULLP;
4834    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4835    {
4836       DU_ALLOC(format->additionalDMRS, sizeof(long));
4837       if(format->additionalDMRS)
4838       {
4839          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4840          return RFAILED;
4841       }
4842       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4843    }
4844
4845     /* Maximum code rate */
4846    format->maxCodeRate = NULLP;
4847    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4848    {
4849       DU_ALLOC(format->maxCodeRate, sizeof(long));
4850       if(format->maxCodeRate)
4851       {
4852          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4853          return RFAILED;
4854       }
4855       *(format->maxCodeRate) = formatDb->maxCodeRate;
4856    }
4857
4858    /* Number of slots */
4859    format->nrofSlots = NULLP;
4860    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4861    {
4862       DU_ALLOC(format->nrofSlots, sizeof(long));
4863       if(format->nrofSlots == NULLP)
4864       {
4865          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4866          return RFAILED;
4867       }
4868       if(formatDb == NULLP)
4869          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4870       else
4871          *(format->nrofSlots) = formatDb->numSlots;
4872    }
4873
4874    /* Pi2BPSK*/
4875    format->pi2BPSK = NULLP;
4876    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4877    {
4878       DU_ALLOC(format->pi2BPSK, sizeof(long));
4879       if(format->pi2BPSK)
4880       {
4881          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4882          return RFAILED;
4883       }
4884       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4885    }
4886
4887    /* Simultaneous HARQ ACK and CSI */
4888    format->simultaneousHARQ_ACK_CSI = NULLP;
4889    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4890    {
4891       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4892       if(format->simultaneousHARQ_ACK_CSI)
4893       {
4894          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4895          return RFAILED;
4896       }
4897       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4898    }
4899
4900    return ROK;
4901 }
4902
4903
4904 /*******************************************************************
4905  *
4906  * @brief Builds PUCCH scheduling request list
4907  *
4908  * @details
4909  *
4910  *    Function : BuildPucchSchReqAddModList
4911  *
4912  *    Functionality:
4913  *      Builds PUCCH scheduling request list
4914  *
4915  * @params[in] : PucchSchedReqCfg *schReqDb
4916  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4917  *
4918  * @return ROK     - success
4919  *         RFAILED - failure
4920  *
4921  * ****************************************************************/
4922 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4923    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4924 {
4925    uint8_t elementCnt = 0, schReqIdx = 0;
4926    SchedulingRequestResourceConfig_t *schReqRsrc;
4927
4928    elementCnt = schReqDb->schedAddModListCount;
4929    schReqRsrcToAddModList->list.count = elementCnt;
4930    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4931
4932    schReqRsrcToAddModList->list.array = NULLP;
4933    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4934    if(schReqRsrcToAddModList->list.array == NULLP)
4935    {
4936       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4937       return RFAILED;
4938    }
4939
4940    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4941    {
4942       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4943       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4944       {
4945          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4946          return RFAILED;
4947       }
4948    }
4949
4950    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4951    {
4952       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
4953       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
4954       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
4955
4956       if(schReqDb->schedAddModList[schReqIdx].periodicity)
4957       {
4958          schReqRsrc->periodicityAndOffset = NULLP;
4959          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
4960          if(schReqRsrc->periodicityAndOffset == NULLP)
4961          {
4962             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4963             return RFAILED;
4964          }
4965
4966          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
4967          switch(schReqRsrc->periodicityAndOffset->present)
4968          {
4969             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
4970                break;
4971             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
4972                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
4973                break;
4974             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
4975                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
4976                break;
4977             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
4978                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
4979                break;
4980             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
4981                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
4982                break;
4983             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
4984                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
4985                break;
4986             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
4987                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
4988                break;
4989             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
4990                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
4991                break;
4992             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
4993                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
4994                break;
4995             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
4996                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
4997                break;
4998             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
4999                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5000                break;
5001             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5002                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5003                break;
5004             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5005                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5006                break;
5007             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5008                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5009                break;
5010             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5011                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5012                break;
5013             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5014                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5015                break;
5016          }
5017       }
5018
5019       if(schReqDb->schedAddModList[schReqIdx].resrc)
5020       {
5021          schReqRsrc->resource = NULLP;
5022          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5023          if(schReqRsrc->resource == NULLP)
5024          {
5025             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5026             return RFAILED;
5027          }
5028          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5029
5030       }
5031    }
5032    return ROK;
5033 }
5034
5035 /*******************************************************************
5036  *
5037  * @brief Builds PUCCH multi csi resource list
5038  *
5039  * @details
5040  *
5041  *    Function : BuildPucchMultiCsiRsrcList
5042  *
5043  *    Functionality:
5044  *      Builds PUCCH multi csi resource list
5045  *
5046  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5047  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5048  *
5049  * @return ROK     - success
5050  *         RFAILED - failure
5051  *
5052  * ****************************************************************/
5053 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5054 {
5055    uint8_t elementCnt = 0, rsrcIdx = 0;
5056
5057    elementCnt = multiCsiDb->multiCsiResrcListCount;
5058    multiCsiRsrcList->list.count = elementCnt;
5059    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5060    multiCsiRsrcList->list.array = NULLP;
5061    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5062    if(multiCsiRsrcList->list.array == NULLP)
5063    {
5064       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5065       return RFAILED;
5066    }
5067
5068    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5069    {
5070       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5071       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5072       {
5073          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5074          return RFAILED;
5075       }
5076    }
5077
5078    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5079    {
5080       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5081    }
5082    return ROK;
5083 }
5084
5085 /*******************************************************************
5086  *
5087  * @brief Builds DL data -to- Ul Ack list
5088  *
5089  * @details
5090  *
5091  *    Function : BuildDlDataToUlAckList
5092  *
5093  *    Functionality: Builds DL data -to- Ul Ack list
5094  *
5095  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5096  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5097  *
5098  * @return ROK     - success
5099  *         RFAILED - failure
5100  *
5101  * ****************************************************************/
5102 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5103 {
5104    uint8_t elementCnt = 0, arrIdx = 0;
5105
5106    if(dlDataToUlAckDb == NULLP)
5107       elementCnt = 2;
5108    else
5109       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5110
5111    dlDataToUlACKList->list.count = elementCnt;
5112    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5113    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5114    if(dlDataToUlACKList->list.array == NULLP)
5115    {
5116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5117       return RFAILED;
5118    }
5119
5120    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5121    {
5122       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5123       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5124       {
5125          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5126          return RFAILED;
5127       }
5128    }
5129
5130    if(dlDataToUlAckDb == NULLP)
5131    {
5132       arrIdx = 0;
5133       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5134       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5135    }
5136    else
5137    {
5138       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5139       {
5140          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5141       }
5142    }
5143    return ROK;
5144 }
5145
5146 /*******************************************************************
5147  *
5148  * @brief Builds BWP UL dedicated PUCCH Config
5149  *
5150  * @details
5151  *
5152  *    Function : BuildBWPUlDedPucchCfg
5153  *
5154  *    Functionality:
5155  *      Builds BWP UL dedicated PUCCH Config
5156  *
5157  * @params[in] : PUCCH_Config_t *pucchCfg
5158  *
5159  * @return ROK     - success
5160  *         RFAILED - failure
5161  *
5162  * ****************************************************************/
5163 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5164 {
5165    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5166    PucchResrcCfg *rsrcCfgDb = NULLP;
5167    PucchFormatCfg *format1Db = NULLP;
5168    PucchFormatCfg *format2Db = NULLP;
5169    PucchFormatCfg *format3Db = NULLP;
5170    PucchFormatCfg *format4Db = NULLP;
5171    PucchSchedReqCfg *schReqDb = NULLP;
5172    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5173    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5174
5175    if(pucchCfgDb)
5176    {
5177       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5178       rsrcCfgDb = pucchCfgDb->resrc;
5179       format1Db = pucchCfgDb->format1;
5180       format2Db = pucchCfgDb->format2;
5181       format3Db = pucchCfgDb->format3;
5182       format4Db = pucchCfgDb->format4;
5183       schReqDb = pucchCfgDb->schedReq;
5184       multiCsiDb = pucchCfgDb->multiCsiCfg;
5185       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5186    }
5187
5188    /* RESOURCE SET */
5189    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5190    if(pucchCfg->resourceSetToAddModList == NULL)
5191    {
5192       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5193       return RFAILED;
5194    }
5195
5196    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5197    {
5198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5199       return RFAILED;
5200    }
5201
5202    /* PUCCH RESOURCE */
5203    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5204    if(pucchCfg->resourceToAddModList == NULLP)
5205    {
5206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5207       return RFAILED;
5208    }
5209
5210    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5211    {
5212       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5213       return RFAILED;
5214    }
5215
5216    /* PUCCH Format 1 */
5217    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5218    if(pucchCfg->format1 == NULLP)
5219    {
5220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5221       return RFAILED;
5222    }
5223
5224    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5225    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5226    if(pucchCfg->format1->choice.setup == NULLP)
5227    {
5228       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5229       return RFAILED;
5230    }
5231
5232    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5233    {
5234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5235       return RFAILED;
5236    }
5237
5238    /* PUCCH Format 2 */
5239    if(format2Db)
5240    {
5241       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5242       if(pucchCfg->format2 == NULLP)
5243       {
5244          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5245          return RFAILED;
5246       }
5247
5248       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5249       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5250       if(pucchCfg->format2->choice.setup == NULLP)
5251       {
5252          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5253          return RFAILED;
5254       }
5255
5256       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5257       {
5258          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5259          return RFAILED;
5260       }
5261    }
5262
5263    /* PUCCH Format 3 */
5264    if(format3Db)
5265    {
5266       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5267       if(pucchCfg->format3 == NULLP)
5268       {
5269          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5270          return RFAILED;
5271       }
5272
5273       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5274       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5275       if(pucchCfg->format3->choice.setup == NULLP)
5276       {
5277          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5278          return RFAILED;
5279       }
5280
5281       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5282       {
5283          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5284          return RFAILED;
5285       }
5286    }
5287
5288    /* PUCCH Format 4 */
5289    if(format4Db)
5290    {
5291       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5292       if(pucchCfg->format4 == NULLP)
5293       {
5294          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5295          return RFAILED;
5296       }
5297
5298       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5299       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5300       if(pucchCfg->format4->choice.setup == NULLP)
5301       {
5302          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5303          return RFAILED;
5304       }
5305
5306       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5307       {
5308          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5309          return RFAILED;
5310       }
5311    }
5312
5313    /* Scheduling Request */
5314    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5315    {
5316       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5317       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5318       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5319       {
5320          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5321          return RFAILED;
5322       }
5323
5324       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5325       {
5326          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5327          return RFAILED;
5328       }
5329    }
5330
5331    /* Multi CSI */
5332    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5333    {
5334       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5335       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5336       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5337       {
5338          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5339          return RFAILED;
5340       }
5341
5342       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5343       {
5344          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5345          return RFAILED;
5346       }
5347    }
5348
5349    /* DL DATA TO UL ACK */
5350    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5351    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5352    {
5353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5354       return RFAILED;
5355    }
5356
5357    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5358    {
5359       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5360       return RFAILED;
5361    }
5362
5363    /* TODO : spatial relation info add/mod list and power control*/
5364
5365    return ROK;
5366 }
5367
5368 /*******************************************************************
5369  *
5370  * @brief Fills SRS resource to add/modify list
5371  *
5372  * @details
5373  *
5374  *    Function : BuildSrsRsrcAddModList
5375  *
5376  *    Functionality: Fills SRS resource to add/modify list
5377  *
5378  * @params[in]
5379  * @return ROK     - success
5380  *         RFAILED - failure
5381  *
5382  * ****************************************************************/
5383 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5384 {
5385    uint8_t   elementCnt;
5386    uint8_t   rsrcIdx;
5387
5388    elementCnt = 1;
5389    resourceList->list.count = elementCnt;
5390    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5391    resourceList->list.array = NULLP;
5392    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5393    if(!resourceList->list.array)
5394    {
5395       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5396       return RFAILED;
5397    }
5398
5399    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5400    {
5401       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5402       if(!resourceList->list.array[rsrcIdx])
5403       {
5404          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5405          return RFAILED;
5406       }
5407    }
5408
5409    rsrcIdx = 0;
5410    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5411    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5412    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5413
5414    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5415    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5416          sizeof(struct SRS_Resource__transmissionComb__n2));
5417    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5418    {
5419       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5420       return RFAILED;
5421    }
5422    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5423       = SRS_COMB_OFFSET_N2;
5424    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5425       = SRS_CYCLIC_SHIFT_N2;
5426
5427    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5428                                                                       PUSCH_START_SYMBOL;
5429    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5430                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5431    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5432                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5433
5434    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5435    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5436    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5437    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5438    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5439    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5440                                                                SRS_Resource__groupOrSequenceHopping_neither;
5441
5442    /* Setting resource type to aperiodic for intergration purposes */
5443    resourceList->list.array[rsrcIdx]->resourceType.present = \
5444                                                              SRS_Resource__resourceType_PR_aperiodic;
5445    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5446    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5447          sizeof(struct SRS_Resource__resourceType__aperiodic));
5448    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5449    {
5450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5451       return RFAILED;
5452    }
5453    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5454
5455    return ROK;
5456 }
5457
5458 /*******************************************************************
5459  *
5460  * @brief Build SRS resource set Add/mod list
5461  *
5462  * @details
5463  *
5464  *    Function : BuildSrsRsrcSetAddModList
5465  *
5466  *    Functionality: Build SRS resource set Add/mod list
5467  *
5468  * @params[in]
5469  * @return ROK     - success
5470  *         RFAILED - failure
5471  *
5472  * ****************************************************************/
5473    uint8_t BuildSrsRsrcSetAddModList
5474 (
5475  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5476  )
5477 {
5478    uint8_t  elementCnt;
5479    uint8_t  rSetIdx;
5480    uint8_t  rsrcIdx;
5481    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5482
5483    elementCnt = 1;
5484    rsrcSetList->list.count = elementCnt;
5485    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5486    rsrcSetList->list.array = NULLP;
5487    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5488    if(!rsrcSetList->list.array)
5489    {
5490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5491       return RFAILED;
5492    }
5493
5494    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5495    {
5496       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5497       if(!rsrcSetList->list.array[rSetIdx])
5498       {
5499          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5500          return RFAILED;
5501       }
5502    }
5503
5504    rSetIdx = 0;
5505    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5506
5507    /* Fill Resource Id list in resource set */
5508    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5509    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5510          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5511    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5512    {
5513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5514       return RFAILED;
5515    }
5516
5517    elementCnt = 1;
5518    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5519    rsrcIdList->list.count = elementCnt;
5520    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5521    rsrcIdList->list.array = NULLP;
5522    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5523    if(!rsrcIdList->list.array)
5524    {
5525       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5526       return RFAILED;
5527    }
5528
5529    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5530    {
5531       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5532       if(!rsrcIdList->list.array[rsrcIdx])
5533       {
5534          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5535          return RFAILED;
5536       }
5537    }
5538
5539    rsrcIdx = 0;
5540    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5541
5542    /* Fill resource type */
5543    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5544                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5545
5546    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5547    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5548          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5549    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5550    {
5551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5552       return RFAILED;
5553    }
5554    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5555       = APERIODIC_SRS_RESRC_TRIGGER;
5556
5557    /* TODO : Fill values for below IEs as expected by Viavi */
5558    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5559    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5560
5561
5562    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5563    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5564    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5565    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5566    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5567
5568    return ROK;
5569 }
5570
5571 /*******************************************************************
5572  *
5573  * @brief Builds BWP UL dedicated SRS Config
5574  *
5575  * @details
5576  *
5577  *    Function : BuildBWPUlDedSrsCfg
5578  *
5579  *    Functionality: Builds BWP UL dedicated SRS Config
5580  *
5581  * @params[in] SRS Config
5582  * @return ROK     - success
5583  *         RFAILED - failure
5584  *
5585  * ****************************************************************/
5586 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5587 {
5588    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5589    srsCfg->srs_ResourceSetToAddModList = NULLP;
5590    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5591          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5592    if(!srsCfg->srs_ResourceSetToAddModList)
5593    {
5594       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5595       return RFAILED;
5596    }
5597    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5598    {
5599       return RFAILED;
5600    }
5601
5602    srsCfg->srs_ResourceToReleaseList = NULLP;
5603
5604    /* Resource to Add/Modify list */
5605    srsCfg->srs_ResourceToAddModList = NULLP;
5606    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5607          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5608    if(!srsCfg->srs_ResourceToAddModList)
5609    {
5610       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5611       return RFAILED;
5612    }
5613
5614    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5615    {
5616       return RFAILED;
5617    }
5618
5619    srsCfg->tpc_Accumulation = NULLP;
5620
5621    return ROK;
5622 }
5623
5624
5625
5626 /*******************************************************************
5627  *
5628  * @brief Builds Pusch Serving cell Config
5629  *
5630  * @details
5631  *
5632  *    Function : BuildPuschSrvCellCfg
5633  *
5634  *    Functionality: Builds Pusch Serving cell Config
5635  *
5636  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5637  *
5638  * @return ROK     - success
5639  *         RFAILED - failure
5640  *
5641  * ****************************************************************/
5642 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5643 {
5644    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5645    puschCfg->choice.setup = NULLP;
5646    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5647    if(!puschCfg->choice.setup)
5648    {
5649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5650       return RFAILED;
5651    }
5652
5653    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5654    puschCfg->choice.setup->rateMatching = NULLP;
5655    puschCfg->choice.setup->xOverhead = NULLP;
5656    puschCfg->choice.setup->ext1 = NULLP;
5657    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5658    if(!puschCfg->choice.setup->ext1)
5659    {
5660       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5661       return RFAILED;
5662    }
5663
5664    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5665    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5666    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5667    {
5668       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5669       return RFAILED;
5670    }
5671    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5672
5673    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5674    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5675    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5676    {
5677       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5678       return RFAILED;
5679    }
5680    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5681    return ROK;
5682 }
5683
5684 /*******************************************************************
5685  *
5686  * @brief Builds inital UL BWP
5687  *
5688  * @details
5689  *
5690  *    Function : BuildInitialUlBWP
5691  *
5692  *    Functionality: Builds initial UL BWP
5693  *
5694  * @params[in] BWP_UplinkDedicated_t *ulBwp
5695  * @return ROK     - success
5696  *         RFAILED - failure
5697  *
5698  * ****************************************************************/
5699 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5700 {
5701    PucchCfg *pucchCfg = NULLP;
5702    PuschCfg *puschCfg = NULLP;
5703
5704    if(initUlBwp)
5705    {
5706       if(initUlBwp->pucchPresent)
5707          pucchCfg = &initUlBwp->pucchCfg;
5708       if(initUlBwp->puschPresent)
5709          puschCfg = &initUlBwp->puschCfg;
5710    }
5711
5712    ulBwp->pucch_Config = NULLP;
5713    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5714    if(!ulBwp->pucch_Config)
5715    {
5716       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5717       return RFAILED;
5718    }
5719
5720    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5721    ulBwp->pucch_Config->choice.setup = NULLP;
5722    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5723    if(!ulBwp->pucch_Config->choice.setup)
5724    {
5725       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5726       return RFAILED;
5727    }
5728
5729    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5730    {
5731       return RFAILED;
5732    }
5733
5734    /* Fill BWP UL dedicated PUSCH config */
5735    ulBwp->pusch_Config = NULLP;
5736    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5737    if(!ulBwp->pusch_Config)
5738    {
5739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5740       return RFAILED;
5741    }
5742
5743    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5744    ulBwp->pusch_Config->choice.setup = NULLP;
5745    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5746    if(!ulBwp->pusch_Config->choice.setup)
5747    {
5748       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5749       return RFAILED;
5750    }
5751
5752    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5753    {
5754       return RFAILED;
5755    }
5756
5757    ulBwp->configuredGrantConfig = NULLP;
5758
5759    /* Fill BPW UL dedicated SRS config */
5760    ulBwp->srs_Config = NULLP;
5761    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5762    if(!ulBwp->srs_Config)
5763    {
5764       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5765       return RFAILED;
5766    }
5767
5768    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5769    ulBwp->srs_Config->choice.setup = NULLP;
5770    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5771    if(!ulBwp->srs_Config->choice.setup)
5772    {
5773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5774       return RFAILED;
5775    }
5776
5777    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5778    {
5779       return RFAILED;
5780    }
5781
5782    ulBwp->beamFailureRecoveryConfig = NULLP;
5783
5784    return ROK;
5785 }
5786
5787 /*******************************************************************
5788  *
5789  * @brief Builds UL config
5790  * @details
5791  *
5792  *    Function : BuildUlCfg
5793  *
5794  *    Functionality: Builds UL config in spCellCfgDed
5795  *
5796  * @params[in] UplinkConfig_t *ulCfg
5797  *
5798  * @return ROK     - success
5799  *         RFAILED - failure
5800  *
5801  * ****************************************************************/
5802 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5803 {
5804    InitialUlBwp *initUlBwp = NULLP;
5805
5806    if(servCellCfg)
5807    {
5808       initUlBwp = &servCellCfg->initUlBwp;
5809    }
5810
5811    ulCfg->initialUplinkBWP = NULLP;
5812    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5813    if(!ulCfg->initialUplinkBWP)
5814    {
5815       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5816       return RFAILED;
5817    }
5818
5819    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5820    {
5821       return RFAILED;
5822    }
5823
5824    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5825    ulCfg->uplinkBWP_ToAddModList = NULLP;
5826    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5827    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5828    if(!ulCfg->firstActiveUplinkBWP_Id)
5829    {
5830       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5831       return RFAILED;
5832    }
5833    if(servCellCfg == NULLP)
5834       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5835    else
5836       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5837
5838    ulCfg->pusch_ServingCellConfig = NULLP;
5839    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5840    if(!ulCfg->pusch_ServingCellConfig)
5841    {
5842       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5843       return RFAILED;
5844    }
5845
5846    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5847    {
5848       return RFAILED;
5849    }
5850
5851    ulCfg->carrierSwitching = NULLP;
5852    ulCfg->ext1 = NULLP;
5853    return ROK;
5854 }
5855
5856 /*******************************************************************
5857  *
5858  * @brief Builds PDSCH serving cell config
5859  * @details
5860  *
5861  *    Function : BuildPdschSrvCellCfg
5862  *
5863  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5864  *
5865  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5866  *
5867  * @return ROK     - success
5868  *         RFAILED - failure
5869  *
5870  * ****************************************************************/
5871 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5872 {
5873    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5874    pdschCfg->choice.setup = NULLP;
5875    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5876    if(!pdschCfg->choice.setup)
5877    {
5878       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5879       return RFAILED;
5880    }
5881
5882    /* Code Block Group Transmission */
5883    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5884    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5885    {
5886       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5887       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5888       {
5889          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5890          return RFAILED;
5891       }
5892
5893       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5894       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5895       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5896       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5897       {
5898          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5899          return RFAILED;
5900       }
5901
5902       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5903          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5904       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5905          *(pdschServCellDb->codeBlkGrpFlushInd);
5906    }
5907
5908    /* xOverhead */
5909    pdschCfg->choice.setup->xOverhead = NULLP;
5910    if(pdschServCellDb && pdschServCellDb->xOverhead)
5911    {
5912       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5913       if(pdschCfg->choice.setup->xOverhead == NULLP)
5914       {
5915          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5916          return RFAILED;
5917       }
5918       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5919    }
5920
5921    /* Number of HARQ processes */
5922    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5923    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5924    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5925    {
5926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5927       return RFAILED;
5928    }
5929
5930    if(pdschServCellDb == NULLP)
5931    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5932    else
5933    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5934
5935    pdschCfg->choice.setup->pucch_Cell = NULLP;
5936
5937    /* Extension */
5938    pdschCfg->choice.setup->ext1 = NULLP;
5939    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5940    {
5941       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5942       if(pdschCfg->choice.setup->ext1 == NULLP)
5943       {
5944          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5945          return RFAILED;
5946       }
5947
5948       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5949       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
5950       {
5951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5952          return RFAILED;
5953       }
5954       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
5955    }
5956
5957    return ROK;
5958 }
5959
5960 /*******************************************************************
5961  *
5962  * @brief Builds CSI Meas config
5963  * @details
5964  *
5965  *    Function : BuildCsiMeasCfg
5966  *
5967  *    Functionality: Builds CSI Meas config in spCellCfgDed
5968  *
5969  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5970  *
5971  * @return ROK     - success
5972  *         RFAILED - failure
5973  *
5974  * ****************************************************************/
5975 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5976 {
5977
5978    return ROK;
5979 }
5980
5981 /*******************************************************************
5982  *
5983  * @brief Builds DL BWP to add/modify list
5984  * @details
5985  *
5986  *    Function : BuildDlBwpToAddModList
5987  *
5988  *    Functionality: Builds DL BWP to add/modify list
5989  *
5990  * @params[in] ServCellCfgInfo *servCellCfg,
5991  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
5992  *
5993  * @return ROK     - success
5994  *         RFAILED - failure
5995  *
5996  * ****************************************************************/
5997 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
5998 {
5999    uint8_t elementCnt, idx;
6000
6001    elementCnt = servCellCfg->numDlBwpToAdd;
6002    dlBwpAddModList->list.count = elementCnt;
6003    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6004    dlBwpAddModList->list.array = NULLP;
6005    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6006    if(dlBwpAddModList->list.array == NULLP)
6007    {
6008       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6009       return RFAILED;
6010    }
6011
6012    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6013    {
6014       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6015       if(dlBwpAddModList->list.array[idx] == NULLP)
6016       {
6017          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6018          return RFAILED;
6019       }
6020    }
6021
6022    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6023    {
6024       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6025       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6026       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6027    }
6028    return ROK;
6029 }
6030
6031 /*******************************************************************
6032  *
6033  * @brief Builds Spcell config dedicated
6034  * @details
6035  *
6036  *    Function : BuildSpCellCfgDed
6037  *
6038  *    Functionality: Builds sp cell config dedicated in spCellCfg
6039  *
6040  * @params[in] ServingCellConfig_t srvCellCfg
6041  *
6042  * @return ROK     - success
6043  *         RFAILED - failure
6044  *
6045  * ****************************************************************/
6046 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6047 {
6048    ServCellCfgInfo *servCellCfg = NULLP;
6049    InitialDlBwp *initDlBwp = NULLP;
6050    PdschServCellCfg *pdschServCellDb = NULLP;
6051
6052    if(ueCb)
6053    {
6054       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6055       initDlBwp = &servCellCfg->initDlBwp;
6056       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6057    }
6058
6059    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6060    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6061    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6062    {
6063       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6064       return RFAILED;
6065    }
6066
6067    srvCellCfg->initialDownlinkBWP = NULLP;
6068    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6069    if(!srvCellCfg->initialDownlinkBWP)
6070    {
6071       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6072       return RFAILED;
6073    }
6074
6075    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6076    {
6077       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6078       return RFAILED;
6079    }
6080
6081    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6082
6083    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6084    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6085    {
6086       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6087       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6088       {
6089          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6090          return RFAILED;
6091       }
6092
6093       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6094       {
6095          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6096          return RFAILED;
6097       }
6098    }
6099
6100    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6101    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6102    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6103    {
6104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6105       return RFAILED;
6106    }
6107    if(ueCb == NULLP)
6108       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6109    else
6110       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6111
6112    srvCellCfg->bwp_InactivityTimer = NULLP;
6113
6114    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6115    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6116    if(!srvCellCfg->defaultDownlinkBWP_Id)
6117    {
6118       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6119       return RFAILED;
6120    }
6121    if(ueCb == NULLP)
6122       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6123    else
6124       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6125
6126    srvCellCfg->uplinkConfig = NULLP;
6127    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6128    if(!srvCellCfg->uplinkConfig)
6129    {
6130       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6131       return RFAILED;
6132    }
6133
6134    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6135    {
6136       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6137       return RFAILED;
6138    }
6139    srvCellCfg->supplementaryUplink = NULLP;
6140    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6141
6142    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6143    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6144    if(!srvCellCfg->pdsch_ServingCellConfig)
6145    {
6146       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6147       return RFAILED;
6148    }
6149
6150    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6151    {
6152       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6153       return RFAILED;
6154    }
6155
6156    srvCellCfg->csi_MeasConfig = NULLP;
6157 #if 0
6158    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6159       if(!srvCellCfg->csi_MeasConfig)
6160       {
6161          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6162          return RFAILED;
6163       }
6164
6165    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6166    {
6167       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6168       return RFAILED;
6169    }
6170 #endif
6171    srvCellCfg->sCellDeactivationTimer = NULLP;
6172    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6173    srvCellCfg->tag_Id = TAG_ID;
6174    srvCellCfg->dummy = NULLP;
6175    srvCellCfg->pathlossReferenceLinking = NULLP;
6176    srvCellCfg->servingCellMO = NULLP;
6177    srvCellCfg->ext1 = NULLP;
6178
6179    return ROK;
6180 }
6181
6182 /*******************************************************************
6183  *
6184  * @brief Fills SCS specific carrier list in DL frequency info
6185  *
6186  * @details
6187  *
6188  *    Function : BuildScsSpecificCarrierListDl
6189  *
6190  *    Functionality: Fills SCS specific carrier list in DL frequency info
6191  *
6192  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
6193  *
6194  * @return ROK     - success
6195  *         RFAILED - failure
6196  *
6197  * ****************************************************************/
6198 uint8_t BuildScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
6199 {
6200    uint8_t elementCnt = 0, listIdx = 0;
6201    ScsSpecCarrier duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.dlScsCarrier;
6202
6203    elementCnt = ODU_VALUE_ONE;
6204    scsCarrierList->list.count = elementCnt;
6205    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6206
6207    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6208    if(!scsCarrierList->list.array)
6209    {
6210       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for scs carrier list array \
6211          in BuildScsSpecificCarrierListDl()");
6212       return RFAILED;
6213    }
6214
6215    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6216    {
6217       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6218       if(!scsCarrierList->list.array[listIdx])
6219       {
6220          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SCS Specific Carrier list array \
6221             element in BuildScsSpecificCarrierListDl()");
6222          return RFAILED;
6223       }
6224    }
6225
6226    listIdx = 0;
6227    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6228    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6229    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6230
6231    return ROK;
6232 }
6233
6234 /*******************************************************************
6235  *
6236  * @brief Fills DL frequency info in DL config common
6237  *
6238  * @details
6239  *
6240  *    Function : BuildFreqInfoDl
6241  *
6242  *    Functionality: Fills DL frequency info in DL config common
6243  *
6244  * @params[in] Pointer to DownlinkConfigCommon_t
6245  *
6246  * @return ROK     - success
6247  *         RFAILED - failure
6248  *
6249  * ****************************************************************/
6250 uint8_t BuildFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
6251 {
6252    uint8_t freqBandIdx = 0, elementCnt = 0;
6253    DlCfgCommon  dlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
6254
6255    /* TODO : Fill SSB Absolute Frequency */
6256    /*
6257       DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
6258       if(!frequencyInfoDL->absoluteFrequencySSB)
6259       {
6260       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
6261       return RFAILED;
6262       }
6263       frequencyInfoDL->absoluteFrequencySSB = ?;
6264       */
6265
6266    /* NR Multi Frequency Band List */
6267    elementCnt = ODU_VALUE_ONE;
6268    frequencyInfoDL->frequencyBandList.list.count = elementCnt;
6269    frequencyInfoDL->frequencyBandList.list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6270
6271    DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
6272    if(!frequencyInfoDL->frequencyBandList.list.array)
6273    {
6274       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
6275       return RFAILED;
6276    }
6277
6278    for(freqBandIdx = 0; freqBandIdx < elementCnt; freqBandIdx++)
6279    {
6280       DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
6281       if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
6282       {
6283          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
6284          return RFAILED;
6285       }
6286    }
6287
6288    freqBandIdx = 0;
6289    *(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx]) = dlCfg.freqBandInd;
6290
6291    /* TODO : Absolute Frequency to Point A */
6292    //frequencyInfoDL->absoluteFrequencyPointA
6293
6294    /* Subcarrier Spacing specifc carrier List */
6295    if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
6296    {
6297       DU_LOG("\nERROR  -->  DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
6298       return RFAILED;
6299    }
6300
6301    return ROK;
6302
6303 }
6304
6305 /*******************************************************************
6306  *
6307  * @brief Fills DL config common in Serving cell config common
6308  *
6309  * @details
6310  *
6311  *    Function : BuildDlConfigCommon
6312  *
6313  *    Functionality: Fills DL config common in Serving cell config common
6314  *
6315  * @params[in] Pointer to DownlinkConfigCommon_t
6316  *
6317  * @return ROK     - success
6318  *         RFAILED - failure
6319  *
6320  * ****************************************************************/
6321 uint8_t BuildDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
6322 {
6323    /* DL Frequency Info */
6324    DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
6325    if(!dlCfgCommon->frequencyInfoDL)
6326    {
6327       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
6328       return RFAILED;
6329    }
6330    if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
6331    {
6332       DU_LOG("\nERROR  --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
6333       return RFAILED;
6334    }
6335
6336    /* DL BWP config common */
6337    DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
6338    if(!dlCfgCommon->initialDownlinkBWP)
6339    {
6340       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
6341       return RFAILED;
6342    }
6343    if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
6344    {
6345       DU_LOG("\nERROR  --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
6346       return RFAILED;
6347    }
6348
6349    return ROK;
6350 }
6351
6352 /*******************************************************************
6353  *
6354  * @brief Fills SCS specific carrier list in UL frequency Info
6355  *
6356  * @details
6357  *
6358  *    Function : BuildScsSpecificCarrierListUl
6359  *
6360  *    Functionality: Fills SCS specific carrier list in UL frequency Info
6361  *
6362  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
6363  *
6364  * @return ROK     - success
6365  *         RFAILED - failure
6366  *
6367  * ****************************************************************/
6368 uint8_t BuildScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
6369 {
6370    uint8_t elementCnt = 0, listIdx = 0;
6371    ScsSpecCarrier   duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
6372
6373    elementCnt = ODU_VALUE_ONE;
6374    scsCarrierList->list.count = elementCnt;
6375    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6376
6377    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6378    if(!scsCarrierList->list.array)
6379    {
6380       DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6381       return RFAILED;
6382    }
6383
6384    for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
6385    {
6386       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6387       if(!scsCarrierList->list.array[listIdx])
6388       {
6389          DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6390          return RFAILED;
6391       }
6392    }
6393    listIdx = 0;
6394    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6395    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6396    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6397
6398    return ROK;
6399 }
6400
6401 /*******************************************************************
6402  *
6403  * @brief Fills frequency info in UL config common
6404  *
6405  * @details
6406  *
6407  *    Function : BuildFreqInfoUl
6408  *
6409  *    Functionality: Fills frequency info in UL config common
6410  *
6411  * @params[in] Pointer to FrequencyInfoUL_t
6412  *
6413  * @return ROK     - success
6414  *         RFAILED - failure
6415  *
6416  * ****************************************************************/
6417 uint8_t BuildFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
6418 {
6419    uint8_t elementCnt = 0, listIdx= 0;
6420    UlCfgCommon  ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
6421
6422    /* NR Multi Frequency Band List */
6423    DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
6424    if(!frequencyInfoUL->frequencyBandList)
6425    {
6426       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
6427       return RFAILED;
6428    }
6429
6430    elementCnt = ODU_VALUE_ONE;
6431    frequencyInfoUL->frequencyBandList->list.count = elementCnt;
6432    frequencyInfoUL->frequencyBandList->list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6433
6434    DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
6435    if(!frequencyInfoUL->frequencyBandList->list.array)
6436    {
6437       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
6438       return RFAILED;
6439    }
6440
6441    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6442    {
6443       DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
6444       if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
6445       {
6446          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
6447          return RFAILED;
6448       }
6449    }
6450
6451    listIdx = 0;
6452    *(frequencyInfoUL->frequencyBandList->list.array[listIdx]) = ulCfg.freqBandInd;
6453
6454    /* TODO : Fill Absolute frequency point A */
6455    /*
6456       DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
6457       if(!frequencyInfoUL->absoluteFrequencyPointA)
6458       {
6459       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
6460       return RFAILED;
6461       }
6462     *(frequencyInfoUL->absoluteFrequencyPointA) = ?;
6463     */
6464
6465    /* Subcarrier Spacing specifc carrier */
6466    if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
6467    {
6468       DU_LOG("\nERROR  --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
6469       return RFAILED;
6470    }
6471
6472    /* P-MAX */
6473    DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
6474    if(!frequencyInfoUL->p_Max)
6475    {
6476       DU_LOG("\nERROR  -->  DU APP : UL Frequency Infoo  memory allocation failure");
6477       return RFAILED;
6478    }
6479    *frequencyInfoUL->p_Max = ulCfg.pMax;
6480
6481    return ROK;
6482 }
6483
6484 /*******************************************************************
6485  *
6486  * @brief Fills UL config common in Serving cell config common
6487  *
6488  * @details
6489  *
6490  *    Function : BuildUlConfigCommon
6491  *
6492  *    Functionality: Fills UL config common in Serving cell config common
6493  *
6494  * @params[in] Pointer to UplinkConfigCommon_t
6495  *
6496  * @return ROK     - success
6497  *         RFAILED - failure
6498  *
6499  * ****************************************************************/
6500 uint8_t BuildUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
6501 {
6502    /* UL Frequency Info */
6503    DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
6504    if(!ulCfgCommon->frequencyInfoUL)
6505    {
6506       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
6507       return RFAILED;
6508    }
6509
6510    if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
6511    {
6512       DU_LOG("\nERROR  -->  DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
6513       return RFAILED;
6514    }
6515
6516    /* UL BWP common */
6517    DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
6518    if(!ulCfgCommon->initialUplinkBWP)
6519    {
6520       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
6521       return RFAILED;
6522    }
6523
6524    if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
6525    {
6526       DU_LOG("\nERROR  -->  DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
6527       return RFAILED;
6528    }
6529
6530    /* Time Alignment timer */
6531    ulCfgCommon->dummy = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
6532
6533    return ROK;
6534 }
6535
6536 /*******************************************************************
6537  *
6538  * @brief Fills SSB position in burst in SP cell config common
6539  *
6540  * @details
6541  *
6542  *    Function : BuildSsbPosInBurst
6543  *
6544  *    Functionality:
6545  *       Fills SSB position in burst in SP cell config common
6546  *
6547  * @params[in] Pointer to struct ServingCellConfigCommon__ssb_PositionsInBurst
6548  *
6549  * @return ROK     - success
6550  *         RFAILED - failure
6551  *
6552  * ****************************************************************/
6553 uint8_t BuildSsbPosInBurst(struct ServingCellConfigCommon__ssb_PositionsInBurst *ssbPosInBurst)
6554 {
6555    uint8_t bitStringSizeInBytes = 0;
6556
6557    ssbPosInBurst->present = ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
6558
6559    /* As per spec 38.331,in the definition of ServingCellConfigCommon */
6560    bitStringSizeInBytes = 1;
6561    ssbPosInBurst->choice.mediumBitmap.size = bitStringSizeInBytes * sizeof(uint8_t);
6562
6563    DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
6564    if(!ssbPosInBurst->choice.mediumBitmap.buf)
6565    {
6566       DU_LOG("\nERROR  -->  DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
6567       return RFAILED;
6568    }
6569
6570    if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
6571                duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
6572    {
6573       DU_LOG("\nERROR  -->  DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
6574       return RFAILED;
6575    }
6576
6577    return ROK;
6578 }
6579
6580 /*******************************************************************
6581  *
6582  * @brief Fills SP cell config common in Reconfig with Sync
6583  *
6584  * @details
6585  *
6586  *    Function : BuildSpCellConfigCommon
6587  *
6588  *    Functionality: Fills SP cell config common in Reconfig with Sync
6589  *
6590  * @params[in] Pointer to ServingCellConfigCommon_t
6591  *
6592  * @return ROK     - success
6593  *         RFAILED - failure
6594  *
6595  * ****************************************************************/
6596 uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
6597 {
6598    /* Physical Cell Identity */
6599    DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
6600    if(!spCellConfigCommon->physCellId)
6601    {
6602       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
6603       return RFAILED;
6604    }
6605    *(spCellConfigCommon->physCellId) = NR_PCI;
6606
6607    /* Downlink Config Common */
6608    DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
6609    if(!spCellConfigCommon->downlinkConfigCommon)
6610    {
6611       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
6612       return RFAILED;
6613    }
6614    if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
6615    {
6616       DU_LOG("\nERROR  -->  DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
6617       return RFAILED;
6618    }
6619
6620    /* Uplinlink Config Common */
6621    DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
6622    if(!spCellConfigCommon->uplinkConfigCommon)
6623    {
6624       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
6625       return RFAILED;
6626    }
6627    if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
6628    {
6629       DU_LOG("\nERROR  -->  DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
6630       return RFAILED;
6631    }
6632
6633    /* Timing Advance offset */
6634    DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
6635    if(!spCellConfigCommon->n_TimingAdvanceOffset)
6636    {
6637       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
6638       return RFAILED;
6639    }
6640    *(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
6641
6642    /* SSB Position In Burst */
6643    DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
6644    if(!spCellConfigCommon->ssb_PositionsInBurst)
6645    {
6646       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
6647       return RFAILED;
6648    }
6649    if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
6650    {
6651       DU_LOG("\nERROR  -->  DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
6652       return RFAILED;
6653    }
6654
6655    /* SSB Periodicity in Serving cell */
6656    DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
6657    if(!spCellConfigCommon->ssb_periodicityServingCell)
6658    {
6659       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
6660          BuildSpCellConfigCommon()");
6661       return RFAILED;
6662    }
6663    *(spCellConfigCommon->ssb_periodicityServingCell) = \
6664       convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell);
6665
6666    /* DMRS Type A position */
6667    spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.dmrsTypeAPos);
6668
6669    /* SSB subcarrier spacing */
6670    DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
6671    if(!spCellConfigCommon->ssbSubcarrierSpacing)
6672    {
6673       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
6674       return RFAILED;
6675    }
6676    *(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
6677
6678    /* TDD UL-DL configuration common */
6679    DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
6680    if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
6681    {
6682       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
6683       return RFAILED;
6684    }
6685    if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
6686    {
6687       DU_LOG("\nERROR  -->  DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
6688       return RFAILED;
6689    }
6690
6691    /* SS PBCH Block Power */
6692    spCellConfigCommon->ss_PBCH_BlockPower = duCfgParam.sib1Params.srvCellCfgCommSib.ssPbchBlockPwr;
6693
6694    return ROK;
6695 }
6696
6697 /*******************************************************************
6698  *
6699  * @brief Fills dedicated RACH configuration in Reconfiguration with sync
6700  *
6701  * @details
6702  *
6703  *    Function : BuildRecfgWithSync
6704  *
6705  *    Functionality:
6706  *       Fills dedicated RACH configuration in Reconfiguration with sync
6707  *
6708  * @params[in] DU UE CB
6709  *             Pointer to Rach config dedicated struct
6710  *
6711  * @return ROK     - success
6712  *         RFAILED - failure
6713  *
6714  * ****************************************************************/
6715 uint8_t BuildRachConfigDedicated(DuUeCb *ueCb, struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
6716 {
6717    uint8_t elementCnt = 0, listIdx = 0;
6718    CFRA_t *cfra = NULLP;
6719    struct CFRA__resources__ssb *ssbResource = NULLP;
6720    RachCfgCommon duRachCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.rachCfg;
6721
6722    rachCfgDed->present = ReconfigurationWithSync__rach_ConfigDedicated_PR_uplink;
6723
6724    /* Uplink */
6725    DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
6726    if(!rachCfgDed->choice.uplink)
6727    {
6728       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
6729       return RFAILED;
6730    }
6731
6732    /* CFRA : Contention free Random Access */
6733    DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
6734    if(!rachCfgDed->choice.uplink->cfra)
6735    {
6736       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
6737       return RFAILED;
6738    }
6739    cfra = rachCfgDed->choice.uplink->cfra;
6740
6741    /* CFRA occassions */
6742    DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
6743    if(!cfra->occasions)
6744    {
6745       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
6746       return RFAILED;
6747    }
6748
6749    /* CFRA occassions : RACH generic configuration */
6750    cfra->occasions->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
6751    cfra->occasions->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
6752    cfra->occasions->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
6753    cfra->occasions->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
6754    cfra->occasions->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
6755    cfra->occasions->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
6756    cfra->occasions->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
6757    cfra->occasions->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
6758
6759    /* CFRA occassions : SSB per RACH occasion */
6760    DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
6761    if(!cfra->occasions->ssb_perRACH_Occasion)
6762    {
6763       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
6764       return RFAILED;
6765    }
6766    *(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
6767
6768    /* CFRA resource */
6769    cfra->resources.present = CFRA__resources_PR_ssb;
6770
6771    /* CFRA resource : SSB */
6772    DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
6773    if(!cfra->resources.choice.ssb)
6774    {
6775       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
6776       return RFAILED;
6777    }
6778    ssbResource = cfra->resources.choice.ssb;
6779
6780    /* CFRA SSB resource list */
6781    elementCnt = ueCb->cfraResource.numSsb;
6782    ssbResource->ssb_ResourceList.list.count = elementCnt;
6783    ssbResource->ssb_ResourceList.list.size = elementCnt * sizeof(CFRA_SSB_Resource_t *);
6784
6785    DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
6786    if(!ssbResource->ssb_ResourceList.list.array)
6787    {
6788       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
6789       return RFAILED;
6790    }
6791
6792    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6793    {
6794       DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
6795       if(!ssbResource->ssb_ResourceList.list.array[listIdx])
6796       {
6797          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
6798          return RFAILED;
6799       }
6800       ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
6801       ssbResource->ssb_ResourceList.list.array[listIdx]->ra_PreambleIndex = ueCb->cfraResource.ssbResource[listIdx].raPreambleIdx;
6802    }
6803
6804    return ROK;
6805 }
6806
6807 /*******************************************************************
6808  *
6809  * @brief Fills reconfiguration with sync in SP cell config
6810  *
6811  * @details
6812  *
6813  *    Function : BuildRecfgWithSync
6814  *
6815  *    Functionality: Fills reconfiguration with sync in SP cell config
6816  *
6817  * @params[in] DU UE CB
6818  *             Pointer to ReconfigurationWithSync_t
6819  *
6820  * @return ROK     - success
6821  *         RFAILED - failure
6822  *
6823  * ****************************************************************/
6824 uint8_t BuildRecfgWithSync(DuUeCb *ueCb, ReconfigurationWithSync_t *recfgWithSync)
6825 {
6826    /* SP Cell Config Common */
6827    DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
6828    if(!recfgWithSync->spCellConfigCommon)
6829    {
6830       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
6831       return RFAILED;
6832    }
6833
6834    if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
6835    {
6836       DU_LOG("\nERROR  -->  DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
6837       return RFAILED;
6838    }
6839
6840    /* New UE Identity */
6841    recfgWithSync->newUE_Identity = ueCb->crnti;
6842
6843    /* T304 timer */
6844    recfgWithSync->t304 = ReconfigurationWithSync__t304_ms1000;
6845
6846    /* RACH configuration dedicated */
6847    DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
6848    if(!recfgWithSync->rach_ConfigDedicated)
6849    {
6850       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
6851       return RFAILED;
6852    }
6853
6854    if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
6855    {
6856       DU_LOG("\nERROR  -->  DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
6857       return RFAILED;
6858    }
6859
6860    return ROK;
6861 }
6862
6863 /*******************************************************************
6864  *
6865  * @brief Builds Spcell config
6866  *
6867  * @details
6868  *
6869  *    Function : BuildSpCellCfg
6870  *
6871  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6872  *
6873  * @params[in] SpCellConfig_t spCellCfg
6874  *
6875  * @return ROK     - success
6876  *         RFAILED - failure
6877  *
6878  * ****************************************************************/
6879 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6880 {
6881    spCellCfg->servCellIndex = NULLP;
6882    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6883    if(!spCellCfg->servCellIndex)
6884    {
6885       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6886       return RFAILED;
6887    }
6888
6889    if(ueCb == NULLP)
6890       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6891    else
6892       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6893
6894    spCellCfg->reconfigurationWithSync = NULLP;
6895    if(ueCb && (ueCb->ueState == UE_HANDIN_IN_PROGRESS))
6896    {
6897       DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
6898       if(!spCellCfg->reconfigurationWithSync)
6899       {
6900          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6901          return RFAILED;
6902       }
6903
6904       if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
6905       {
6906          DU_LOG("\nERROR  -->  F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
6907          return RFAILED;
6908       }
6909    }
6910
6911    spCellCfg->rlf_TimersAndConstants = NULLP;
6912    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6913
6914    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6915    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6916    {
6917       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6918       return RFAILED;
6919    }
6920    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6921
6922    spCellCfg->spCellConfigDedicated = NULLP;
6923    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6924    if(!spCellCfg->spCellConfigDedicated)
6925    {
6926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6927       return RFAILED;
6928    }
6929    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6930    {
6931       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6932       return RFAILED;
6933    }
6934
6935    return ROK;
6936 }
6937
6938 /*******************************************************************
6939  *
6940  * @brief Builds Phy cell group config
6941  *
6942  * @details
6943  *
6944  *    Function : BuildPhyCellGrpCfg
6945  *
6946  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6947  *
6948  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
6949  *
6950  * @return ROK     - success
6951  *         RFAILED - failure
6952  *
6953  * ****************************************************************/
6954 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
6955 {
6956    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
6957    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
6958
6959    phyCellGrpCfg->p_NR_FR1 = NULLP;
6960    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6961    if(!phyCellGrpCfg->p_NR_FR1)
6962    {
6963       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
6964       return RFAILED;
6965    }
6966
6967    if(ueCb == NULLP)
6968    {
6969       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
6970       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
6971    }
6972    else
6973    {
6974       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
6975       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
6976    }
6977
6978    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
6979    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
6980    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
6981    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
6982    phyCellGrpCfg->cs_RNTI = NULLP;
6983    phyCellGrpCfg->ext1 = NULLP;
6984    phyCellGrpCfg->ext2 = NULLP;
6985
6986    return ROK;
6987 }
6988 #ifdef NR_DRX
6989 /*******************************************************************
6990  *
6991  * @brief fill long cycle offset value of drx
6992  *
6993  * @details
6994  *
6995  *    Function : fillLongCycleOffsetValFromDuCb
6996  *
6997  *    Functionality: fill long cycle offset value of drx
6998  *
6999  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
7000  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
7001  *
7002  * @return ROK     - success
7003  *         RFAILED - failure
7004  *
7005  * ****************************************************************/
7006 void fillLongCycleOffsetValFromDuCb(DrxLongCycleStartOffset  drxLongCycleStartOffset,\
7007 struct DRX_ConfigRrc__drx_LongCycleStartOffset *drx_LongCycleStartOffset)
7008 {
7009
7010    drx_LongCycleStartOffset->present = convertLongDrxCycleLengthValueToEnum(drxLongCycleStartOffset.drxLongCycleStartOffsetChoice);
7011    switch(drx_LongCycleStartOffset->present)
7012    {
7013       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
7014          {
7015             drx_LongCycleStartOffset->choice.ms10 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7016             break;
7017          }
7018       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
7019          {
7020             drx_LongCycleStartOffset->choice.ms20 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7021             break;
7022          }
7023       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
7024          {
7025             drx_LongCycleStartOffset->choice.ms32 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7026             break;
7027          }
7028       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
7029          {
7030             drx_LongCycleStartOffset->choice.ms40 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7031             break;
7032          }
7033       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
7034          {
7035             drx_LongCycleStartOffset->choice.ms60 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7036             break;
7037          }
7038       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
7039          {
7040             drx_LongCycleStartOffset->choice.ms64 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7041             break;
7042          }
7043       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
7044          {
7045             drx_LongCycleStartOffset->choice.ms70 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7046             break;
7047          }
7048       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
7049          {
7050             drx_LongCycleStartOffset->choice.ms80 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7051             break;
7052          }
7053       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
7054          {
7055             drx_LongCycleStartOffset->choice.ms128 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7056             break;
7057          }
7058       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
7059          {
7060             drx_LongCycleStartOffset->choice.ms160 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7061             break;
7062          }
7063       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
7064          {
7065             drx_LongCycleStartOffset->choice.ms256 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7066             break;
7067          }
7068       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
7069          {
7070             drx_LongCycleStartOffset->choice.ms320 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7071             break;
7072          }
7073       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
7074          {
7075             drx_LongCycleStartOffset->choice.ms512 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7076             break;
7077          }
7078       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
7079          {
7080             drx_LongCycleStartOffset->choice.ms640 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7081             break;
7082          }
7083       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
7084          {
7085             drx_LongCycleStartOffset->choice.ms1024 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7086             break;
7087          }
7088       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
7089          {
7090             drx_LongCycleStartOffset->choice.ms1280 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7091             break;
7092          }
7093       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
7094          {
7095             drx_LongCycleStartOffset->choice.ms2048 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7096             break;
7097          }
7098       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
7099          {
7100             drx_LongCycleStartOffset->choice.ms2560 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7101             break;
7102          }
7103       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
7104          {
7105             drx_LongCycleStartOffset->choice.ms5120 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7106             break;
7107          }
7108       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
7109          {
7110             drx_LongCycleStartOffset->choice.ms10240 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7111             break;
7112          }
7113       default :
7114          break;
7115    }
7116 }
7117 /*******************************************************************
7118  *
7119  * @brief Builds drx config IE
7120  *
7121  * @details
7122  *
7123  *    Function : BuildDrxConfigRrc
7124  *
7125  *    Functionality: Build drx config in MacCellGrpCfg
7126  *
7127  * @params[in] struct MAC_CellGroupConfig__drx_ConfigRrc
7128  *
7129  * @return ROK     - success
7130  *         RFAILED - failure
7131  *
7132  * ****************************************************************/
7133 uint8_t BuildDrxConfigRrc(DuUeCb *ueCb, struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg)
7134 {
7135    drxCfg->present = MAC_CellGroupConfig__drx_ConfigRrc_PR_setup;
7136    DU_ALLOC(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
7137    if(!drxCfg->choice.setup)
7138    {
7139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7140       return RFAILED;
7141    }
7142    if(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
7143    {
7144       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds;
7145       drxCfg->choice.setup->drx_onDurationTimer.choice.milliSeconds = convertOnDurationTimerMilliSecondsValueToEnum(ueCb->macUeCfg.\
7146       macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds);
7147    }
7148    else
7149    {
7150       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds;
7151       drxCfg->choice.setup->drx_onDurationTimer.choice.subMilliSeconds = ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7152       drxOnDurationTimer.onDurationtimerValue.subMilliSeconds;
7153    }
7154    drxCfg->choice.setup->drx_InactivityTimer = convertDrxInactivityTimerValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxInactivityTimer);
7155    drxCfg->choice.setup->drx_HARQ_RTT_TimerDL = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerDl;
7156    drxCfg->choice.setup->drx_HARQ_RTT_TimerUL = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerUl;
7157    drxCfg->choice.setup->drx_RetransmissionTimerDL = convertDrxRetransmissionTimerDlValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7158    drxRetransmissionTimerDl);
7159    drxCfg->choice.setup->drx_RetransmissionTimerUL = convertDrxRetransmissionTimerUlValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7160    drxRetransmissionTimerUl);
7161    drxCfg->choice.setup->drx_SlotOffset = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxSlotOffset;
7162    fillLongCycleOffsetValFromDuCb(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxLongCycleStartOffset, &drxCfg->choice.setup->drx_LongCycleStartOffset);
7163
7164    if(ueCb->macUeCfg.macCellGrpCfg.drxCfg.shortDrxPres)
7165    {
7166       DU_ALLOC(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
7167       if(drxCfg->choice.setup->shortDRX)
7168       {
7169          drxCfg->choice.setup->shortDRX->drx_ShortCycle = convertShortDrxCycleLengthValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7170          shortDrx.drxShortCycle);
7171          drxCfg->choice.setup->shortDRX->drx_ShortCycleTimer = ueCb->macUeCfg.macCellGrpCfg.drxCfg.shortDrx.drxShortCycleTimer;
7172       }
7173       else
7174       {
7175          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7176          return RFAILED;
7177       }
7178    }
7179    return ROK;
7180 }
7181 #endif
7182 /*******************************************************************
7183  *
7184  * @brief Builds Mac cell group config
7185  *
7186  * @details
7187  *
7188  *    Function : BuildMacCellGrpCfg
7189  *
7190  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
7191  *
7192  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
7193  *
7194  * @return ROK     - success
7195  *         RFAILED - failure
7196  *
7197  * ****************************************************************/
7198 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
7199 {
7200    macCellGrpCfg->drx_ConfigRrc = NULLP;
7201 #ifdef NR_DRX
7202    if(ueCb)
7203    {
7204       DU_ALLOC(macCellGrpCfg->drx_ConfigRrc, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
7205       if(!macCellGrpCfg->drx_ConfigRrc)
7206       {
7207          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7208          return RFAILED;
7209       }
7210       if(BuildDrxConfigRrc(ueCb, macCellGrpCfg->drx_ConfigRrc) != ROK)
7211       {
7212          DU_LOG("\nERROR  -->  F1AP : failed to build drx config");
7213          return RFAILED;
7214       }
7215    }
7216 #endif
7217    macCellGrpCfg->schedulingRequestConfig = NULLP;
7218    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7219    if(!macCellGrpCfg->schedulingRequestConfig)
7220    {
7221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7222       return RFAILED;
7223    }
7224
7225    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
7226    {
7227       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
7228       return RFAILED;
7229    }
7230
7231    macCellGrpCfg->bsr_Config = NULLP;
7232    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7233    if(!macCellGrpCfg->bsr_Config)
7234    {
7235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7236       return RFAILED;
7237    }
7238
7239    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
7240    {
7241       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
7242       return RFAILED;
7243    }
7244
7245    macCellGrpCfg->tag_Config = NULLP;
7246    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
7247    if(!macCellGrpCfg->tag_Config)
7248    {
7249       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7250       return RFAILED;
7251    }
7252
7253    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
7254    {
7255       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
7256       return RFAILED;
7257    }
7258
7259    macCellGrpCfg->phr_Config = NULLP;
7260    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
7261    if(!macCellGrpCfg->phr_Config)
7262    {
7263       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7264       return RFAILED;
7265    }
7266
7267    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
7268    {
7269       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
7270       return RFAILED;
7271    }
7272
7273    macCellGrpCfg->skipUplinkTxDynamic = false;
7274    macCellGrpCfg->ext1 = NULLP;
7275
7276    return ROK;
7277 }
7278 /*******************************************************************
7279  *
7280  * @brief Frees memeory allocated for SearchSpcToAddModList
7281  *
7282  * @details
7283  *
7284  *    Function : FreeSearchSpcToAddModList
7285  *
7286  *    Functionality: Deallocating memory of SearchSpcToAddModList
7287  *
7288  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7289  *
7290  * @return void
7291  *
7292  4221 * ****************************************************************/
7293 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7294 {
7295    uint8_t idx1=0;
7296    uint8_t idx2=0;
7297    struct  SearchSpace *searchSpc=NULLP;
7298
7299    if(searchSpcList->list.array)
7300    {
7301       if(searchSpcList->list.array[idx2])
7302       {
7303          searchSpc = searchSpcList->list.array[idx2];
7304          if(searchSpc->controlResourceSetId)
7305          {
7306             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7307             {
7308                if(searchSpc->monitoringSymbolsWithinSlot)
7309                {
7310                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7311                   {
7312                      if(searchSpc->nrofCandidates)
7313                      {
7314                         if(searchSpc->searchSpaceType)
7315                         {
7316                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
7317                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
7318                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
7319                                     SearchSpace__searchSpaceType));
7320                         }
7321                         DU_FREE(searchSpc->nrofCandidates,
7322                               sizeof(struct SearchSpace__nrofCandidates));
7323                      }
7324                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
7325                            searchSpc->monitoringSymbolsWithinSlot->size);
7326                   }
7327                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
7328                         sizeof(BIT_STRING_t));
7329                }
7330                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
7331                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
7332             }
7333             DU_FREE(searchSpc->controlResourceSetId,
7334                   sizeof(ControlResourceSetId_t));
7335          }
7336       }
7337       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
7338       {
7339          DU_FREE(searchSpcList->list.array[idx1],
7340                sizeof(struct SearchSpace));
7341       }
7342       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
7343    }
7344 }
7345 /*******************************************************************
7346  *
7347  * @brief Frees memory allocated for PdschTimeDomAllocList
7348  *
7349  * @details
7350  *
7351  *    Function : FreePdschTimeDomAllocList
7352  *
7353  *    Functionality: Deallocating memory of PdschTimeDomAllocList
7354  *
7355  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7356  *
7357  * @return void
7358  *
7359  * ****************************************************************/
7360 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7361 {
7362    uint8_t idx1=0;
7363
7364    if(timeDomAllocList->choice.setup)
7365    {
7366       if(timeDomAllocList->choice.setup->list.array)
7367       {
7368          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
7369          {
7370             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
7371             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
7372                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
7373          }
7374          DU_FREE(timeDomAllocList->choice.setup->list.array, \
7375                timeDomAllocList->choice.setup->list.size);
7376       }
7377       DU_FREE(timeDomAllocList->choice.setup,\
7378             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
7379    }
7380 }
7381 /*******************************************************************
7382  *
7383  * @brief Frees memory allocated for PuschTimeDomAllocList
7384  *
7385  *@details
7386  *
7387  *    Function : FreePuschTimeDomAllocList
7388  *
7389  *    Functionality: Deallocating memory of PuschTimeDomAllocList
7390  *
7391  * @params[in] PUSCH_Config_t *puschCfg
7392  *
7393  * @return void
7394  *
7395  * ****************************************************************/
7396 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
7397 {
7398    uint8_t rsrcListIdx=0;
7399    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7400
7401    if(puschCfg->pusch_TimeDomainAllocationList)
7402    {
7403       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7404       if(timeDomAllocList_t->choice.setup)
7405       {
7406          if(timeDomAllocList_t->choice.setup->list.array)
7407          {
7408             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
7409             {
7410                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
7411                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
7412                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
7413             }
7414             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
7415                   timeDomAllocList_t->choice.setup->list.size);
7416          }
7417          DU_FREE(timeDomAllocList_t->choice.setup, \
7418                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
7419       }
7420       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
7421       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
7422             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
7423    }
7424
7425 }
7426
7427 /*******************************************************************
7428  *
7429  * @brief Frees memory allocated for Dedicated PUCCH config
7430  *
7431  * @details
7432  *
7433  *    Function : FreeBWPUlDedPucchCfg
7434  *
7435  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
7436  *
7437  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
7438  *
7439  * @return void
7440  *
7441  * ****************************************************************/
7442 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
7443 {
7444    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
7445    PUCCH_Config_t *pucchCfg = NULLP;
7446    PUCCH_ResourceSet_t *rsrcSet = NULLP;
7447    PUCCH_Resource_t *rsrc = NULLP;
7448
7449    if(ulBwpPucchCfg)
7450    {
7451       if(ulBwpPucchCfg->choice.setup)
7452       {
7453          pucchCfg = ulBwpPucchCfg->choice.setup;
7454
7455          //Free resource set list
7456          if(pucchCfg->resourceSetToAddModList)
7457          {
7458             if(pucchCfg->resourceSetToAddModList->list.array)
7459             {
7460                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
7461                {
7462                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
7463                   if(rsrcSet->resourceList.list.array)
7464                   {
7465                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
7466                      {
7467                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
7468                      }
7469                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
7470                   }
7471                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
7472                }
7473                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
7474             }
7475             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
7476          }
7477
7478          //Free resource list
7479          if(pucchCfg->resourceToAddModList)
7480          {
7481             if(pucchCfg->resourceToAddModList->list.array)
7482             {
7483                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
7484                {
7485                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
7486                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
7487                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
7488                }
7489                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
7490             }
7491             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
7492          }
7493
7494          //PUCCH Format 1
7495          if(pucchCfg->format1)
7496          {
7497             if(pucchCfg->format1->choice.setup)
7498             {
7499                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
7500                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
7501             }
7502             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
7503          }
7504
7505          //DL DATA TO UL ACK
7506          if(pucchCfg->dl_DataToUL_ACK)
7507          {
7508             if(pucchCfg->dl_DataToUL_ACK->list.array)
7509             {
7510                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
7511                {
7512                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
7513                }
7514                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
7515             }
7516             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
7517          }
7518
7519          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
7520       }
7521       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
7522    }
7523 }
7524
7525 /*******************************************************************
7526  *
7527  * @brief Frees memory allocated for InitialUlBWP
7528  *
7529  * @details
7530  *
7531  *    Function : FreeInitialUlBWP
7532  *
7533  *    Functionality: Deallocating memory of InitialUlBWP
7534  *
7535  * @params[in] BWP_UplinkDedicated_t *ulBwp
7536  *
7537  * @return void
7538  *
7539  * ****************************************************************/
7540 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
7541 {
7542    uint8_t  rSetIdx, rsrcIdx;
7543    SRS_Config_t   *srsCfg = NULLP;
7544    PUSCH_Config_t *puschCfg = NULLP;
7545    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7546    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7547    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7548    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7549
7550    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
7551
7552    if(ulBwp->pusch_Config)
7553    {
7554       if(ulBwp->pusch_Config->choice.setup)
7555       {
7556          puschCfg=ulBwp->pusch_Config->choice.setup;
7557          if(puschCfg->dataScramblingIdentityPUSCH)
7558          {
7559             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7560             {
7561                FreePuschTimeDomAllocList(puschCfg);
7562                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7563                if(dmrsUlCfg->choice.setup)
7564                {
7565                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7566                   {
7567                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7568                      {
7569                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
7570                               sizeof(long));
7571                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
7572                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
7573                      }
7574                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
7575                            sizeof(long));
7576                   }
7577                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
7578                }
7579                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
7580                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
7581             }
7582             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
7583          }
7584          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
7585       }
7586       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
7587
7588       /* Free SRS-Config */
7589       if(ulBwp->srs_Config)
7590       {
7591          if(ulBwp->srs_Config->choice.setup)
7592          {
7593             srsCfg = ulBwp->srs_Config->choice.setup;
7594
7595             /* Free Resource Set to add/mod list */
7596             if(srsCfg->srs_ResourceSetToAddModList)
7597             {
7598                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7599                if(rsrcSetList->list.array)
7600                {
7601                   rSetIdx = 0;
7602
7603                   /* Free SRS resource Id list in this SRS resource set */
7604                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7605                   {
7606                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7607
7608                      if(rsrcIdList->list.array)
7609                      {
7610                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
7611                         {
7612                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
7613                         }
7614                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
7615                      }
7616                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
7617                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
7618                   }
7619
7620                   /* Free resource type info for this SRS resource set */
7621                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
7622                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
7623
7624                   /* Free memory for each resource set */
7625                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7626                   {
7627                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
7628                   }
7629                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
7630                }
7631                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
7632                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
7633             }
7634
7635             /* Free resource to add/modd list */
7636             if(srsCfg->srs_ResourceToAddModList)
7637             {
7638                resourceList = srsCfg->srs_ResourceToAddModList;
7639                if(resourceList->list.array)
7640                {
7641                   rsrcIdx = 0;
7642                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
7643                         sizeof(struct SRS_Resource__transmissionComb__n2));
7644                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
7645                         sizeof(struct SRS_Resource__resourceType__aperiodic));
7646
7647                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7648                   {
7649                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
7650                   }
7651                   DU_FREE(resourceList->list.array, resourceList->list.size);
7652                }
7653                DU_FREE(srsCfg->srs_ResourceToAddModList, \
7654                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
7655             }
7656
7657             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
7658          }
7659          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
7660       }
7661    }
7662 }
7663 /*******************************************************************
7664  *
7665  * @brief Frees memory allocated for initialUplinkBWP
7666  *
7667  * @details
7668  *
7669  *    Function : FreeinitialUplinkBWP
7670  *
7671  *    Functionality: Deallocating memory of initialUplinkBWP
7672  *
7673  * @params[in] UplinkConfig_t *ulCfg
7674  *
7675  * @return void
7676  *
7677  *
7678  * ****************************************************************/
7679 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
7680 {
7681    BWP_UplinkDedicated_t *ulBwp=NULLP;
7682    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7683
7684    if(ulCfg->initialUplinkBWP)
7685    {
7686       ulBwp=ulCfg->initialUplinkBWP;
7687       if(ulCfg->firstActiveUplinkBWP_Id)
7688       {
7689          if(ulCfg->pusch_ServingCellConfig)
7690          {
7691             puschCfg=ulCfg->pusch_ServingCellConfig;
7692             if(puschCfg->choice.setup)
7693             {
7694                if(puschCfg->choice.setup->ext1)
7695                {
7696                   DU_FREE(puschCfg->choice.setup->ext1->\
7697                         processingType2Enabled,sizeof(BOOLEAN_t));
7698                   DU_FREE(puschCfg->choice.setup->ext1->\
7699                         maxMIMO_Layers,sizeof(long));
7700                   DU_FREE(puschCfg->choice.setup->ext1, \
7701                         sizeof(struct PUSCH_ServingCellConfig__ext1));
7702                }
7703                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
7704             }
7705             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
7706          }
7707          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
7708       }
7709       FreeInitialUlBWP(ulBwp);
7710       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
7711    }
7712 }
7713 /*******************************************************************
7714  *
7715  * @brief Frees emmory allocated for BWPDlDedPdschCfg
7716  *
7717  * @details
7718  *
7719  *    Function : FreeBWPDlDedPdschCfg
7720  *
7721  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
7722  *
7723  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7724  *
7725  * @return void
7726  *
7727  *
7728  * ****************************************************************/
7729 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
7730 {
7731    struct PDSCH_Config *pdschCfg=NULLP;
7732    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7733    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7734    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7735
7736    if(dlBwp->pdsch_Config->choice.setup)
7737    {
7738       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7739       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7740       {
7741          if(pdschCfg->pdsch_TimeDomainAllocationList)
7742          {
7743             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7744             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7745             {
7746                prbBndlType=&pdschCfg->prb_BundlingType;
7747                DU_FREE(prbBndlType->choice.staticBundling,\
7748                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
7749                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
7750             }
7751             FreePdschTimeDomAllocList(timeDomAllocList);
7752             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
7753                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
7754          }
7755          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7756          if(dmrsDlCfg->choice.setup)
7757          {
7758             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
7759                   sizeof(long));
7760             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
7761          }
7762          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
7763                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
7764       }
7765       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
7766    }
7767 }
7768 /*******************************************************************
7769  *
7770  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
7771  *
7772  * @details
7773  *
7774  *    Function : FreeBWPDlDedPdcchCfg
7775  *
7776  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
7777  *
7778  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7779  *
7780  * @return void
7781  *
7782  *
7783  * ****************************************************************/
7784 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
7785 {
7786    uint8_t idx1=0;
7787    uint8_t idx2=0;
7788    struct PDCCH_Config *pdcchCfg=NULLP;
7789    struct ControlResourceSet *controlRSet=NULLP;
7790    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7791
7792    if(dlBwp->pdcch_Config->choice.setup)
7793    {
7794       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7795       if(pdcchCfg->controlResourceSetToAddModList)
7796       {
7797          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7798          if(controlRSetList->list.array)
7799          {
7800             controlRSet = controlRSetList->list.array[idx2];
7801             if(controlRSet)
7802             {
7803                if(controlRSet->frequencyDomainResources.buf)
7804                {
7805                   if(controlRSet->pdcch_DMRS_ScramblingID)
7806                   {
7807                      if(pdcchCfg->searchSpacesToAddModList)
7808                      {
7809                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7810                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
7811                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
7812                      }
7813                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
7814                   }
7815                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
7816                         controlRSet->frequencyDomainResources.size);
7817                }
7818             }
7819             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
7820             {
7821                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
7822             }
7823             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
7824          }
7825          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
7826                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
7827       }
7828       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
7829    }
7830 }
7831
7832 /*******************************************************************
7833  *
7834  * @brief Free SCS specific carrier list in DL frequency info
7835  *
7836  * @details
7837  *
7838  *    Function : FreeScsSpecificCarrierListDl
7839  *
7840  *    Functionality: Free SCS specific carrier list in DL frequency info
7841  *
7842  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
7843  *
7844  * @return void
7845  *
7846  * ****************************************************************/
7847 void FreeScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
7848 {
7849    uint8_t listIdx = 0;
7850
7851    if(!scsCarrierList->list.array)
7852    {
7853       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7854       {
7855          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7856       }
7857       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7858    }
7859 }
7860
7861 /*******************************************************************
7862  *
7863  * @brief Free DL frequency info in DL config common
7864  *
7865  * @details
7866  *
7867  *    Function : FreeFreqInfoDl
7868  *
7869  *    Functionality: Free DL frequency info in DL config common
7870  *
7871  * @params[in] Pointer to DownlinkConfigCommon_t
7872  *
7873  * @return void
7874  *
7875  * ****************************************************************/
7876 void FreeFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
7877 {
7878    uint8_t freqBandIdx = 0;
7879
7880    /* SSB Absolute Frequency */
7881    DU_FREE(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
7882
7883    /* NR Multi Frequency Band List */
7884    if(frequencyInfoDL->frequencyBandList.list.array)
7885    {
7886       for(freqBandIdx = 0; freqBandIdx < frequencyInfoDL->frequencyBandList.list.count; freqBandIdx++)
7887       {
7888          DU_FREE(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
7889       }
7890       DU_FREE(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
7891    }
7892
7893    /* Subcarrier Spacing specifc carrier List */
7894    FreeScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
7895 }
7896
7897 /*******************************************************************
7898  *
7899  * @brief Free DL config common in Serving cell config common
7900  *
7901  * @details
7902  *
7903  *    Function : FreeDlConfigCommon
7904  *
7905  *    Functionality: Free DL config common in Serving cell config common
7906  *
7907  * @params[in] Pointer to DownlinkConfigCommon_t
7908  *
7909  * @return void
7910  *
7911  * ****************************************************************/
7912 void FreeDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
7913 {
7914    /* DL Frequency Info */
7915    if(dlCfgCommon->frequencyInfoDL)
7916    {
7917       FreeFreqInfoDl(dlCfgCommon->frequencyInfoDL);
7918       DU_FREE(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
7919    }
7920
7921    /* DL BWP config common */
7922    if(dlCfgCommon->initialDownlinkBWP)
7923    {
7924       FreeBwpDlCommon(dlCfgCommon->initialDownlinkBWP);
7925       DU_FREE(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
7926    }
7927 }
7928
7929 /*******************************************************************
7930  *
7931  * @brief Free SCS specific carrier list in UL frequency Info
7932  *
7933  * @details
7934  *
7935  *    Function : FreeScsSpecificCarrierListUl
7936  *
7937  *    Functionality: Free SCS specific carrier list in UL frequency Info
7938  *
7939  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
7940  *
7941  * @return void
7942  *
7943  * ****************************************************************/
7944 void FreeScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
7945 {
7946    uint8_t listIdx = 0;
7947
7948    if(scsCarrierList->list.array)
7949    {
7950       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7951       {
7952          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7953       }
7954       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7955    }
7956 }
7957
7958 /*******************************************************************
7959  *
7960  * @brief Free frequency info in UL config common
7961  *
7962  * @details
7963  *
7964  *    Function : FreeFreqInfoUl
7965  *
7966  *    Functionality: Free frequency info in UL config common
7967  *
7968  * @params[in] Pointer to FrequencyInfoUL_t
7969  *
7970  * @return void
7971  *
7972  * ****************************************************************/
7973 void FreeFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
7974 {
7975    uint8_t listIdx= 0;
7976
7977    /* NR Multi Frequency Band List */
7978    if(!frequencyInfoUL->frequencyBandList)
7979    {
7980       if(frequencyInfoUL->frequencyBandList->list.array)
7981       {
7982          for(listIdx = 0; listIdx < frequencyInfoUL->frequencyBandList->list.count; listIdx++)
7983          {
7984             DU_FREE(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
7985          }
7986          DU_FREE(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
7987       }
7988       DU_FREE(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
7989    }
7990
7991    /* Absolute frequency point A */
7992    DU_FREE(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
7993
7994    /* Subcarrier Spacing specifc carrier */
7995    FreeScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
7996
7997    /* P-MAX */
7998    DU_FREE(frequencyInfoUL->p_Max, sizeof(P_Max_t));
7999 }
8000
8001 /*******************************************************************
8002  *
8003  * @brief Free UL config common in Serving cell config common
8004  *
8005  * @details
8006  *
8007  *    Function : FreeUlConfigCommon
8008  *
8009  *    Functionality: Free UL config common in Serving cell config common
8010  *
8011  * @params[in] Pointer to UplinkConfigCommon_t
8012  *
8013  * @return void
8014  *
8015  * ****************************************************************/
8016 void FreeUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
8017 {
8018    /* UL Frequency Info */
8019    if(ulCfgCommon->frequencyInfoUL)
8020    {
8021       FreeFreqInfoUl(ulCfgCommon->frequencyInfoUL);
8022       DU_FREE(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
8023    }
8024
8025    /* UL BWP common */
8026    if(ulCfgCommon->initialUplinkBWP)
8027    {
8028       FreeBwpUlCommon(ulCfgCommon->initialUplinkBWP);
8029       DU_FREE(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
8030    }
8031 }
8032
8033 /*******************************************************************
8034  *
8035  * @brief Free SP cell config common in Reconfig with Sync
8036  *
8037  * @details
8038  *
8039  *    Function : FreeSpCellConfigCommon
8040  *
8041  *    Functionality: Free SP cell config common in Reconfig with Sync
8042  *
8043  * @params[in] Pointer to ServingCellConfigCommon_t
8044  *
8045  * @return void
8046  *
8047  * ****************************************************************/
8048 void FreeSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
8049 {
8050    /* Free Physical cell identity */
8051    DU_FREE(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
8052
8053    /* Free Downlink Config common */
8054    if(spCellConfigCommon->downlinkConfigCommon)
8055    {
8056       FreeDlConfigCommon(spCellConfigCommon->downlinkConfigCommon);
8057       DU_FREE(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
8058    }
8059
8060    /* Free Uplink Config common */
8061    if(spCellConfigCommon->uplinkConfigCommon)
8062    {
8063       FreeUlConfigCommon(spCellConfigCommon->uplinkConfigCommon);
8064       DU_FREE(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
8065    }
8066
8067    /* Free Timing Advance offset */
8068    DU_FREE(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
8069
8070    /* Free SSB Position in Burst */
8071    if(spCellConfigCommon->ssb_PositionsInBurst)
8072    {
8073       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.buf, \
8074          spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.size);
8075       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
8076    }
8077
8078    /* Free SSB Periodicity in Serving cell */
8079    DU_FREE(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
8080
8081    /* Free SSB subcarrier spacing */
8082    DU_FREE(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8083
8084    /* TDD UL-DL configuration common */
8085    DU_FREE(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
8086 }
8087
8088 /*******************************************************************
8089  *
8090  * @brief Free dedicated RACH configuration in Reconfiguration with sync
8091  *
8092  * @details
8093  *
8094  *    Function : FreeRecfgWithSync
8095  *
8096  *    Functionality:
8097  *       Free dedicated RACH configuration in Reconfiguration with sync
8098  *
8099  * @params[in] Pinter to Rach config dedicated struct
8100  *
8101  * @return void
8102  *
8103  * ****************************************************************/
8104 void FreeRachConfigDedicated(struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
8105 {
8106    uint8_t listIdx = 0;
8107    CFRA_t *cfra = NULLP;
8108    struct CFRA__resources__ssb *ssbResource = NULLP;
8109
8110    /* Uplink */
8111    if(rachCfgDed->choice.uplink)
8112    {
8113       /* CFRA : Contention free Random Access */
8114       if(rachCfgDed->choice.uplink->cfra)
8115       {
8116          cfra = rachCfgDed->choice.uplink->cfra;
8117
8118          /* CFRA occassions */
8119          if(cfra->occasions)
8120          {
8121             /* CFRA occassions : SSB per RACH occasion */
8122             DU_FREE(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
8123             DU_FREE(cfra->occasions, sizeof(struct CFRA__occasions));
8124          }
8125
8126          /* CFRA resource */
8127          cfra->resources.present = CFRA__resources_PR_ssb;
8128
8129          /* CFRA resource : SSB */
8130          if(cfra->resources.choice.ssb)
8131          {
8132             ssbResource = cfra->resources.choice.ssb;
8133
8134             /* CFRA SSB resource list */
8135             if(ssbResource->ssb_ResourceList.list.array)
8136             {
8137                for(listIdx = 0; listIdx < ssbResource->ssb_ResourceList.list.count; listIdx++)
8138                {
8139                   DU_FREE(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
8140                }
8141                DU_FREE(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
8142             }
8143             DU_FREE(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
8144          }
8145          DU_FREE(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
8146       }
8147       DU_FREE(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
8148    }
8149 }
8150
8151 /*******************************************************************
8152  *
8153  * @brief Frees reconfiguration with sync in SP cell config
8154  *
8155  * @details
8156  *
8157  *    Function : FreeRecfgWithSync
8158  *
8159  *    Functionality: Fress reconfiguration with sync in SP cell config
8160  *
8161  * @params[in] Pointer to ReconfigurationWithSync_t
8162  *
8163  * @return void
8164  *
8165  * ****************************************************************/
8166 void FreeRecfgWithSync(ReconfigurationWithSync_t *recfgWithSync)
8167 {
8168    /* Free SP Cell config common */
8169    if(recfgWithSync->spCellConfigCommon)
8170    {
8171       FreeSpCellConfigCommon(recfgWithSync->spCellConfigCommon);
8172       DU_FREE(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
8173    }
8174
8175    /* Free Dedicated RACH configuration */
8176    if(recfgWithSync->rach_ConfigDedicated)
8177    {
8178       FreeRachConfigDedicated(recfgWithSync->rach_ConfigDedicated);
8179       DU_FREE(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
8180    }
8181 }
8182
8183 /*******************************************************************
8184  *
8185  * @brief Frees emmory allocated for DUToCURRCContainer
8186  *
8187  * @details
8188  *
8189  *    Function : FreeMemDuToCuRrcCont
8190  *
8191  *    Functionality: Deallocating memory of DuToCuRrcContainer
8192  *
8193  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
8194  *
8195  * @return ROK     - success
8196  *         RFAILED - failure
8197  *
8198  * ****************************************************************/
8199 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
8200 {
8201    uint8_t idx=0;
8202    SpCellConfig_t *spCellCfg=NULLP;
8203    ServingCellConfig_t *srvCellCfg=NULLP;
8204    BWP_DownlinkDedicated_t *dlBwp=NULLP;
8205    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
8206    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
8207    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
8208    struct RLC_Config *rlcConfig=NULLP;
8209    struct LogicalChannelConfig *macLcConfig=NULLP;
8210    struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg=NULLP;
8211    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
8212    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
8213    struct TAG_Config *tagConfig=NULLP;
8214    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
8215    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
8216    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
8217
8218    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8219    if(rlcBearerList)
8220    {
8221       if(rlcBearerList->list.array)
8222       {
8223          for(idx=0; idx<rlcBearerList->list.count; idx++)
8224          {
8225             if(rlcBearerList->list.array[idx])
8226             {
8227                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
8228                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
8229                if(rlcConfig)
8230                {
8231                   switch(rlcConfig->present)
8232                   {
8233                      case RLC_Config_PR_NOTHING:
8234                         break;
8235
8236                      case RLC_Config_PR_am:
8237                         {
8238                            if(rlcConfig->choice.am)
8239                            {
8240                               DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8241                               DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8242                               DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
8243                            }
8244                            break;
8245                         }
8246                      case RLC_Config_PR_um_Bi_Directional:
8247                         {
8248                            if(rlcConfig->choice.um_Bi_Directional)
8249                            {
8250                               DU_FREE(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8251                               DU_FREE(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8252                               DU_FREE(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
8253                            }
8254                            break;
8255                         }
8256                      case RLC_Config_PR_um_Uni_Directional_UL:
8257                         {
8258                            if(rlcConfig->choice.um_Uni_Directional_UL)
8259                            {
8260                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8261                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
8262                            }
8263                            break;
8264                         }
8265                      case RLC_Config_PR_um_Uni_Directional_DL:
8266                         {
8267                            if(rlcConfig->choice.um_Uni_Directional_DL )
8268                            {
8269                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8270                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
8271                            }
8272                            break;
8273                         }
8274                   }
8275                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
8276                }
8277                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
8278                if(macLcConfig)
8279                {
8280                   if(macLcConfig->ul_SpecificParameters)
8281                   {
8282                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
8283                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
8284                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
8285                   }
8286                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
8287                }
8288                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
8289             }
8290          }
8291          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
8292       }
8293       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8294    }
8295
8296    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8297    if(macCellGrpCfg)
8298    {
8299       drxCfg = macCellGrpCfg->drx_ConfigRrc;
8300
8301       if(drxCfg)
8302       {
8303           switch(drxCfg->present)
8304           {
8305             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
8306                break;
8307             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
8308             {
8309                if(drxCfg->choice.setup)
8310                {
8311                   DU_FREE(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
8312                   DU_FREE(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
8313                }
8314             }
8315             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
8316                break;
8317           }
8318           DU_FREE(drxCfg, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
8319       }
8320       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8321       if(schedulingRequestConfig)
8322       {
8323          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8324          if(schReqList)
8325          {
8326             if(schReqList->list.array)
8327             {
8328                for(idx=0;idx<schReqList->list.count; idx++)
8329                {
8330                   if(schReqList->list.array[idx])
8331                   {
8332                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
8333                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
8334                   }
8335                }
8336                DU_FREE(schReqList->list.array, schReqList->list.size);
8337             }
8338             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
8339                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
8340             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
8341       }
8342       if(macCellGrpCfg->bsr_Config)
8343       {
8344          DU_FREE(macCellGrpCfg->bsr_Config->logicalChannelSR_DelayTimer, sizeof(long));
8345          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
8346       }
8347       tagConfig = macCellGrpCfg->tag_Config;
8348       if(tagConfig)
8349       {
8350          tagList = tagConfig->tag_ToAddModList;
8351          if(tagList)
8352          {
8353             if(tagList->list.array)
8354             {
8355                for(idx=0; idx<tagList->list.count; idx++)
8356                {
8357                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
8358                }
8359                DU_FREE(tagList->list.array, tagList->list.size);
8360             }
8361             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
8362          }
8363          DU_FREE(tagConfig, sizeof(struct TAG_Config));
8364       }
8365
8366       phrConfig = macCellGrpCfg->phr_Config;
8367       if(phrConfig)
8368       {
8369          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
8370          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
8371       }
8372
8373       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
8374    }
8375
8376    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8377    if(phyCellGrpCfg)
8378    {
8379       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
8380       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
8381    }
8382
8383    spCellCfg = cellGrpCfg->spCellConfig;
8384    if(spCellCfg)
8385    {
8386       /* Free serving cell index */
8387       DU_FREE(spCellCfg->servCellIndex, sizeof(long));
8388
8389       /* Free Reconfiguration with sync */
8390       if(spCellCfg->reconfigurationWithSync)
8391       {
8392          FreeRecfgWithSync(spCellCfg->reconfigurationWithSync);
8393          DU_FREE(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
8394       }
8395
8396       /* Free rlmInSyncOutOfSyncThreshold */
8397       DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
8398
8399       /* Free SP Cell config dedicated */
8400       if(spCellCfg->spCellConfigDedicated)
8401       {
8402          srvCellCfg = spCellCfg->spCellConfigDedicated;
8403
8404          /* Free TDD UL-DL config dedicated */
8405          DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
8406
8407          /* Free Initial Downlink BWP */
8408          if(srvCellCfg->initialDownlinkBWP)
8409          {
8410             dlBwp = srvCellCfg->initialDownlinkBWP;
8411
8412             /* Free DL BWP PDCCH Config */
8413             if(dlBwp->pdcch_Config)
8414             {
8415                FreeBWPDlDedPdcchCfg(dlBwp);
8416                DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
8417             }
8418
8419             /* Free DL BWP PDSCH config */
8420             if(dlBwp->pdsch_Config)
8421             {
8422                FreeBWPDlDedPdschCfg(dlBwp);
8423                DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
8424             }
8425             DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
8426          }
8427
8428          /* Free First Active Downlink BWP */
8429          DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
8430
8431          /* Free Default downlink BWP */
8432          DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
8433
8434          /* Free Uplink config */
8435          if(srvCellCfg->uplinkConfig)
8436          {
8437             FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
8438             DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
8439          }
8440
8441          /* Free PDSCH serving cell config */
8442          if(srvCellCfg->pdsch_ServingCellConfig)
8443          {
8444             pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
8445             if(pdschCfg->choice.setup)
8446             {
8447                DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
8448                DU_FREE(pdschCfg->choice.setup, sizeof(struct PDSCH_ServingCellConfig));
8449             }
8450             DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
8451          }
8452
8453          DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
8454       }
8455       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
8456    }
8457    return ROK;
8458 }
8459
8460 /*******************************************************************
8461  *
8462  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
8463  *
8464  * @details
8465  *
8466  *    Function : BuildCellGroupConfigRrc
8467  *
8468  *    Functionality: Builds and copied Cell group config buffer into
8469  *       DuToCuRrcContainer
8470  *
8471  * @params[in] idx, index in F1AP msg
8472  *             DuToCuRRCContainer, DuToCuRRCContainer
8473  *
8474  * @return ROK     - success
8475  *         RFAILED - failure
8476  *
8477  * ****************************************************************/
8478 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
8479 {
8480    uint8_t  ret = ROK;
8481    CellGroupConfigRrc_t  cellGrpCfg;
8482    asn_enc_rval_t        encRetVal;
8483    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8484    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8485
8486    while(true)
8487    {
8488       cellGrpCfg.cellGroupId = CELL_GRP_ID;
8489
8490       cellGrpCfg.rlc_BearerToAddModList = NULLP;
8491       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8492       if(!cellGrpCfg.rlc_BearerToAddModList)
8493       {
8494          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8495          ret = RFAILED;
8496          break;
8497       }
8498       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
8499       {
8500          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
8501          ret = RFAILED;
8502          break;
8503       }
8504
8505       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
8506       cellGrpCfg.mac_CellGroupConfig = NULLP;
8507       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
8508       if(!cellGrpCfg.mac_CellGroupConfig)
8509       {
8510          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8511          ret = RFAILED;
8512          break;
8513       }
8514       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
8515       {
8516          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
8517          ret = RFAILED;
8518          break;
8519       }
8520
8521       cellGrpCfg.physicalCellGroupConfig = NULLP;
8522       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
8523       if(!cellGrpCfg.physicalCellGroupConfig)
8524       {
8525          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8526          ret = RFAILED;
8527          break;
8528       }
8529       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
8530       {
8531          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
8532          ret = RFAILED;
8533          break;
8534       }
8535
8536       cellGrpCfg.spCellConfig = NULLP;
8537       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
8538       if(!cellGrpCfg.spCellConfig)
8539       {
8540          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8541          ret = RFAILED;
8542          break;
8543       }
8544       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
8545       {
8546          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
8547          ret = RFAILED;
8548          break;
8549       }
8550
8551       cellGrpCfg.sCellToAddModList = NULLP;
8552       cellGrpCfg.sCellToReleaseList = NULLP;
8553       cellGrpCfg.ext1 = NULLP;
8554
8555       /* encode cellGrpCfg into duToCuRrcContainer */
8556       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
8557       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8558       encBufSize = 0;
8559       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
8560       /* Encode results */
8561       if(encRetVal.encoded == ENCODE_FAIL)
8562       {
8563          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
8564                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8565          ret = RFAILED;
8566          break;
8567       }
8568       else
8569       {
8570          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
8571 #ifdef DEBUG_ASN_PRINT
8572          for(int i=0; i< encBufSize; i++)
8573          {
8574             printf("%x",encBuf[i]);
8575          }
8576 #endif
8577       }
8578
8579       duToCuRrcContainer->size = encBufSize;
8580       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
8581       if(!duToCuRrcContainer->buf)
8582       {
8583          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
8584          ret = RFAILED;
8585          break;
8586       }
8587       if(ret == ROK)
8588       {
8589          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
8590       }
8591       break;
8592    }
8593    FreeMemDuToCuRrcCont(&cellGrpCfg);
8594    return ret;
8595 }
8596
8597 /*******************************************************************
8598  *
8599  * @brief Free memory allocated in InitialULRRCMessage
8600  *
8601  * @details
8602  *
8603  *    Function : freeInitUlRrcMsgTransfer
8604  *
8605  *    Functionality: Free memory allocated in InitialULRRCMessage
8606  *
8607  * @params[in]F1AP_PDU_t  *f1apMsg)
8608  *
8609  * @return ROK     - success
8610  *         RFAILED - failure
8611  *
8612  * ****************************************************************/
8613
8614 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
8615 {
8616    uint8_t ieIdx, arrIdx;
8617    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
8618
8619    if(f1apMsg)
8620    {
8621       if(f1apMsg->choice.initiatingMessage)
8622       {
8623          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
8624             choice.InitialULRRCMessageTransfer;
8625          if(initULRRCMsg->protocolIEs.list.array)
8626          {
8627             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
8628             {
8629                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
8630                {
8631                   case ProtocolIE_ID_id_NRCGI:
8632                   {
8633                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
8634                      {
8635                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
8636                         {
8637                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
8638                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
8639                         }
8640                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
8641                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
8642                      }
8643                      break;
8644                   }
8645                   case ProtocolIE_ID_id_RRCContainer:
8646                   {
8647                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8648                      {
8649                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
8650                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8651                      }
8652                      break;
8653                   }
8654                   case ProtocolIE_ID_id_DUtoCURRCContainer:
8655                   {
8656                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
8657                      {
8658                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
8659                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
8660                      }
8661                      break;
8662                   }
8663                   default:
8664                      break;
8665                }
8666              }
8667              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8668              {
8669                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
8670                 {
8671                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
8672                       sizeof(InitialULRRCMessageTransferIEs_t));
8673                 }
8674              }
8675              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
8676           }
8677          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8678       }
8679       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
8680    }
8681    else
8682    {
8683       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
8684       return RFAILED;
8685    }
8686    return ROK;
8687 }
8688
8689 /*******************************************************************
8690  *
8691  * @brief Builds and sends the InitialULRRCMessage
8692  *
8693  * @details
8694  *
8695  *    Function : BuildAndSendInitialRrcMsgTransfer
8696  *
8697  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
8698  *                   it to the CU through SCTP.
8699  *
8700  * @params[in]
8701  *
8702  * @return ROK     - success
8703  *         RFAILED - failure
8704  *
8705  * ****************************************************************/
8706 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
8707       uint16_t rrcContSize, uint8_t *rrcContainer)
8708 {
8709    uint8_t   ret;
8710    uint8_t   elementCnt;
8711    uint8_t   ieIdx, cellIdx, ueIdx;
8712    DuUeCb    *duUeCb = NULLP;
8713    asn_enc_rval_t  encRetVal;
8714    F1AP_PDU_t  *f1apMsg = NULLP;
8715    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
8716    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8717
8718    while(true)
8719    {
8720       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
8721       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8722       if(f1apMsg == NULLP)
8723       {
8724          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8725          break;
8726       }
8727       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8728       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8729       if(f1apMsg->choice.initiatingMessage == NULLP)
8730       {
8731          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
8732          break;
8733       }
8734       f1apMsg->choice.initiatingMessage->procedureCode =\
8735                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
8736       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
8737       f1apMsg->choice.initiatingMessage->value.present = \
8738                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
8739       initULRRCMsg =\
8740                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
8741       elementCnt = 5;
8742       initULRRCMsg->protocolIEs.list.count = elementCnt;
8743       initULRRCMsg->protocolIEs.list.size = \
8744                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
8745       /* Initialize the F1Setup members */
8746       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
8747       if(initULRRCMsg->protocolIEs.list.array == NULLP)
8748       {
8749          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
8750                RRCSetupRequestMessageTransferIEs failed");
8751          break;
8752       }
8753       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
8754       {
8755          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
8756                sizeof(InitialULRRCMessageTransferIEs_t));
8757          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
8758          {
8759             break;
8760          }
8761       }
8762       ieIdx = 0;
8763       /*GNB DU UE F1AP ID*/
8764       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8765                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8766       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
8767       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8768                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
8769       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
8770
8771
8772       /*NRCGI*/
8773       ieIdx++;
8774       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8775                                                         ProtocolIE_ID_id_NRCGI;
8776       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
8777       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8778                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
8779
8780       ret =\
8781            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
8782       if(ret!=ROK)
8783       {
8784          break;
8785       }
8786
8787       /*CRNTI*/
8788       ieIdx++;
8789       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8790                                                         ProtocolIE_ID_id_C_RNTI;
8791       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8792       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8793                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
8794       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
8795
8796       /*RRCContainer*/
8797       ieIdx++;
8798       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8799                                                         ProtocolIE_ID_id_RRCContainer;
8800       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8801       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8802                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
8803
8804       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
8805       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
8806             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
8807       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8808       {
8809          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
8810          break;
8811
8812       }
8813       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
8814             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8815
8816
8817       /*DUtoCURRCContainer*/
8818       ieIdx++;
8819       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
8820       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8821       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8822                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
8823
8824       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
8825       {
8826          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
8827          {
8828             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
8829                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
8830             {
8831                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
8832             }
8833          }
8834       }
8835
8836       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
8837       if(ret != ROK)
8838       {
8839          break;
8840       }
8841
8842       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8843
8844       /* Encode the Intial UL RRC Message transfer as APER */
8845       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8846       encBufSize = 0;
8847       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
8848       /* Encode results */
8849       if(encRetVal.encoded == ENCODE_FAIL)
8850       {
8851          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
8852                structure (at %s)\n",encRetVal.failed_type ? \
8853                encRetVal.failed_type->name : "unknown");
8854          ret = RFAILED;
8855          break;
8856       }
8857       else
8858       {
8859
8860          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
8861                Message transfer\n");
8862 #ifdef DEBUG_ASN_PRINT
8863          for(int i=0; i< encBufSize; i++)
8864          {
8865             printf("%x",encBuf[i]);
8866          }
8867 #endif
8868       }
8869       /* Sending  msg  */
8870       if(sendF1APMsg() != ROK)
8871       {
8872          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
8873          ret = RFAILED;
8874          break;
8875       }
8876       break;
8877    }
8878    freeInitUlRrcMsgTransfer(f1apMsg);
8879    return ret;
8880 }/* End of BuildAndSendInitialRrcMsgTransfer*/
8881
8882 /*****  UE SETUP REQUEST *****/
8883
8884 /*******************************************************************
8885  *
8886  * @brief Free Qos And Snssai Drb Info
8887  *
8888  * @details
8889  *
8890  *    Function : freeDrbQosAndSnssaiInfo
8891  *
8892  *    Functionality: Free Qos And Snssai Drb Info
8893  *
8894  * @params[in] LcCfg *lcCfg,
8895  * @return void
8896  *
8897  * ****************************************************************/
8898 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
8899 {
8900    if(lcCfg->snssai)
8901    {
8902       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8903    }
8904    if(lcCfg->drbQos)
8905    {
8906       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
8907    }
8908 }
8909
8910 /******************************************************************
8911 *
8912 * @brief Function to delete the RLC Lc cfg from UE APP DB
8913 *
8914 * @details
8915 *
8916 *  Function : freeRlcLcCfg
8917 *
8918 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
8919 *
8920 *
8921  *****************************************************************/
8922
8923 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
8924 {
8925    switch(lcCfg->rlcMode)
8926    {
8927       case RLC_AM :
8928          {
8929             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
8930             break;
8931          }
8932       case RLC_UM_BI_DIRECTIONAL :
8933          {
8934             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8935             break;
8936          }
8937       case RLC_UM_UNI_DIRECTIONAL_UL :
8938          {
8939             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8940             break;
8941          }
8942       case RLC_UM_UNI_DIRECTIONAL_DL :
8943          {
8944             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8945             break;
8946          }
8947       default:
8948          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
8949          break;
8950    }
8951    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8952 }
8953
8954 /*******************************************************************
8955  *
8956  * @brief Function to free MacLcCfg
8957  *
8958  * @details
8959  *
8960  *    Function : freeMacLcCfg
8961  *
8962  *    Functionality: Function to free MacLcCfg
8963  *
8964  * @params[in] LcCfg *lcCfg,
8965  * @return void
8966  *
8967  * ****************************************************************/
8968
8969 void  freeMacLcCfg(LcCfg *lcCfg)
8970 {
8971     /* Deleting DRBQOS */
8972    if(lcCfg->drbQos)
8973    {
8974       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
8975    }
8976    /* Deleting SNSSAI */
8977    if(lcCfg->snssai)
8978    {
8979       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8980    }
8981 }
8982 /*******************************************************************
8983  *
8984  * @brief Free UE NR Capability received in UE Context setup request
8985  *
8986  * @details
8987  *
8988  *    Function : freeAperDecodeUeNrCapability
8989  *
8990  *    Functionality:
8991  *       Free UE NR Capability received in UE Context setup request
8992  *
8993  * @params[in]
8994  * @return ROK     - success
8995  *         RFAILED - failure
8996  *
8997  * ****************************************************************/
8998 void freeAperDecodeUeNrCapability(void *ueNrCapability)
8999 {
9000    uint8_t arrIdx =0;
9001    FeatureSets_t *featureSets =NULLP;
9002    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
9003
9004    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
9005    {
9006       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
9007       {
9008          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
9009             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
9010       }
9011       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
9012    }
9013
9014    if(ueNrCap->featureSets)
9015    {
9016       featureSets = ueNrCap->featureSets;
9017       if(featureSets->featureSetsDownlinkPerCC)
9018       {
9019          if(featureSets->featureSetsDownlinkPerCC->list.array)
9020          {
9021             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
9022             {
9023                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
9024                {
9025                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
9026                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
9027                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
9028                }
9029             }
9030             free(featureSets->featureSetsDownlinkPerCC->list.array);
9031          }
9032          free(featureSets->featureSetsDownlinkPerCC);
9033       }
9034       if(featureSets->featureSetsUplinkPerCC)
9035       {
9036          if(featureSets->featureSetsUplinkPerCC->list.array)
9037          {
9038             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
9039             {
9040                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
9041                {
9042                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
9043                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
9044                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
9045                }
9046             }
9047             free(featureSets->featureSetsUplinkPerCC->list.array);
9048          }
9049          free(featureSets->featureSetsUplinkPerCC);
9050       }
9051       free(ueNrCap->featureSets);
9052    }
9053 }
9054
9055 /*******************************************************************
9056 *
9057 * @brief Function to free PdcchSearchSpcToAddModList
9058          where memory allocated by aper_decoder
9059 *
9060 * @details
9061 *
9062 *    Function : freeAperDecodePdcchSearchSpcToAddModList
9063 *
9064 *    Functionality: Function to free PdcchSearchSpcToAddModList
9065 *
9066 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
9067 * @return void
9068 *
9069 * ****************************************************************/
9070
9071 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
9072 {
9073    uint8_t searchSpcArrIdx=0;
9074    uint8_t searchSpcArrIdx1=0;
9075    struct  SearchSpace *searchSpc=NULLP;
9076
9077
9078    if(searchSpcList->list.array)
9079    {
9080       if(searchSpcList->list.array[searchSpcArrIdx1])
9081       {
9082          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
9083          if(searchSpc->controlResourceSetId)
9084          {
9085             if(searchSpc->monitoringSlotPeriodicityAndOffset)
9086             {
9087                if(searchSpc->monitoringSymbolsWithinSlot)
9088                {
9089                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
9090                   {
9091                      if(searchSpc->nrofCandidates)
9092                      {
9093                         if(searchSpc->searchSpaceType)
9094                         {
9095                            free(searchSpc->searchSpaceType->choice.ue_Specific);
9096                            free(searchSpc->searchSpaceType);
9097                         }
9098                         free(searchSpc->nrofCandidates);
9099                      }
9100                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
9101                   }
9102                   free(searchSpc->monitoringSymbolsWithinSlot);
9103                }
9104                free(searchSpc->monitoringSlotPeriodicityAndOffset);
9105             }
9106             free(searchSpc->controlResourceSetId);
9107          }
9108       }
9109       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
9110       {
9111          free(searchSpcList->list.array[searchSpcArrIdx]);
9112       }
9113       free(searchSpcList->list.array);
9114    }
9115 }
9116 /*******************************************************************
9117 *
9118 * @brief Function for free part for the memory allocated by aper_decoder
9119 *
9120 * @details
9121 *
9122 *    Function : freeAperDecodeBWPDlDedPdcchConfig
9123 *
9124 *    Functionality: Function to free BWPDlDedPdcchConfig
9125 *
9126 * @params[in]
9127 * @return void
9128 *
9129 * ****************************************************************/
9130
9131
9132 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
9133 {
9134    uint8_t arrIdx1=0;
9135    uint8_t arrIdx2=0;
9136    struct PDCCH_Config *pdcchCfg=NULLP;
9137    struct ControlResourceSet *controlRSet=NULLP;
9138    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
9139
9140    if(dlBwp->pdcch_Config->choice.setup)
9141    {
9142       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
9143       if(pdcchCfg->controlResourceSetToAddModList)
9144       {
9145          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
9146          if(controlRSetList->list.array)
9147          {
9148             controlRSet = controlRSetList->list.array[arrIdx2];
9149             if(controlRSet)
9150             {
9151                if(controlRSet->frequencyDomainResources.buf)
9152                {
9153                   if(controlRSet->pdcch_DMRS_ScramblingID)
9154                   {
9155                      if(pdcchCfg->searchSpacesToAddModList)
9156                      {
9157                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
9158                         free(pdcchCfg->searchSpacesToAddModList);
9159                      }
9160                      free(controlRSet->pdcch_DMRS_ScramblingID);
9161                   }
9162                   free(controlRSet->frequencyDomainResources.buf);
9163                }
9164             }
9165             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
9166             {
9167                free(controlRSetList->list.array[arrIdx1]);
9168             }
9169             free(controlRSetList->list.array);
9170          }
9171          free(pdcchCfg->controlResourceSetToAddModList);
9172       }
9173       free(dlBwp->pdcch_Config->choice.setup);
9174    }
9175 }
9176 /*******************************************************************
9177 *
9178 * @brief Function to free PdschTimeDomAllocationList
9179 *     where the memory allocated by aper_decoder
9180 *
9181 * @details
9182 *
9183 *    Function : freeAperDecodePdschTimeDomAllocationList
9184 *
9185 *    Functionality: Function to free PdschTimeDomAllocationList
9186 *
9187 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
9188 * @return void
9189 *
9190 * ****************************************************************/
9191
9192
9193 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
9194 {
9195    uint8_t arrIdx=0;
9196
9197    if(timeDomAllocList->choice.setup)
9198    {
9199       if(timeDomAllocList->choice.setup->list.array)
9200       {
9201          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
9202          {
9203             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
9204          }
9205          free(timeDomAllocList->choice.setup->list.array);
9206       }
9207       free(timeDomAllocList->choice.setup);
9208    }
9209 }
9210
9211 /*******************************************************************
9212 *
9213 * @brief Function to free BWPDlDedPdschConfig
9214 *        where the memory allocated by aper_decoder
9215 *
9216 * @details
9217 *
9218 *    Function : freeAperDecodeBWPDlDedPdschConfig
9219 *
9220 *    Functionality: Function to free BWPDlDedPdschConfig
9221 *
9222 * @params[in] BWP_DownlinkDedicated_t *dlBwp
9223 * @return void
9224 *
9225 * ****************************************************************/
9226
9227
9228 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
9229 {
9230    struct PDSCH_Config *pdschCfg=NULLP;
9231    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
9232    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
9233    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
9234
9235    if(dlBwp->pdsch_Config->choice.setup)
9236    {
9237       pdschCfg=dlBwp->pdsch_Config->choice.setup;
9238       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9239       {
9240          if(pdschCfg->pdsch_TimeDomainAllocationList)
9241          {
9242             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
9243             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
9244             {
9245                prbBndlType=&pdschCfg->prb_BundlingType;
9246                free(prbBndlType->choice.staticBundling);
9247                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
9248             }
9249             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
9250             free(pdschCfg->pdsch_TimeDomainAllocationList);
9251          }
9252          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
9253          if(dmrsDlCfg->choice.setup)
9254          {
9255             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
9256             free(dmrsDlCfg->choice.setup);
9257          }
9258          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
9259       }
9260       free(dlBwp->pdsch_Config->choice.setup);
9261    }
9262 }
9263 /*******************************************************************
9264 *
9265 * @brief Function to free PuschTimeDomAllocListCfg
9266                  where the memory allocated by aper_decoder
9267 *
9268 * @details
9269 *
9270 *    Function : freeAperDecodePuschTimeDomAllocListCfg
9271 *
9272 *    Functionality: Function to free PuschTimeDomAllocListCfg
9273 *
9274 * @params[in] PUSCH_Config_t *puschCfg
9275 * @return void
9276 *
9277 * ****************************************************************/
9278
9279
9280 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
9281 {
9282    uint8_t arrIdx=0;
9283    uint8_t arrIdx1=0;
9284    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
9285
9286    if(puschCfg->pusch_TimeDomainAllocationList)
9287    {
9288       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
9289       if(timeDomAllocList_t->choice.setup)
9290       {
9291          if(timeDomAllocList_t->choice.setup->list.array)
9292          {
9293             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
9294             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
9295             {
9296                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
9297             }
9298             free(timeDomAllocList_t->choice.setup->list.array);
9299          }
9300          free(timeDomAllocList_t->choice.setup);
9301       }
9302       free(puschCfg->transformPrecoder);
9303       free(puschCfg->pusch_TimeDomainAllocationList);
9304    }
9305 }
9306 /*******************************************************************
9307 *
9308 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
9309 *
9310 * @details
9311 *
9312 *    Function : freeAperDecodeInitialUlBWPConfig
9313 *
9314 *    Functionality: Function to free InitialUlBWPConfig
9315 *
9316 * @params[in]  BWP_UplinkDedicated_t *ulBwp
9317 * @return void
9318 *
9319 * ****************************************************************/
9320
9321
9322 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
9323 {
9324    uint8_t  rSetIdx =0;
9325    uint8_t  rsrcIdx =0;
9326    SRS_Config_t   *srsCfg = NULLP;
9327    PUSCH_Config_t *puschCfg = NULLP;
9328    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
9329    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
9330    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
9331    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
9332
9333    if(ulBwp->pusch_Config)
9334    {
9335       if(ulBwp->pusch_Config->choice.setup)
9336       {
9337          puschCfg=ulBwp->pusch_Config->choice.setup;
9338          if(puschCfg->dataScramblingIdentityPUSCH)
9339          {
9340             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
9341             {
9342                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
9343                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
9344                if(dmrsUlCfg->choice.setup)
9345                {
9346                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
9347                   {
9348                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
9349                      {
9350                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
9351                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
9352                      }
9353                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
9354                   }
9355                   free(dmrsUlCfg->choice.setup);
9356                }
9357                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
9358             }
9359             free(puschCfg->dataScramblingIdentityPUSCH);
9360          }
9361          free(ulBwp->pusch_Config->choice.setup);
9362       }
9363       free(ulBwp->pusch_Config);
9364
9365       /* Free SRS-Config */
9366       if(ulBwp->srs_Config)
9367       {
9368          if(ulBwp->srs_Config->choice.setup)
9369          {
9370             srsCfg = ulBwp->srs_Config->choice.setup;
9371
9372             /* Free Resource Set to add/mod list */
9373             if(srsCfg->srs_ResourceSetToAddModList)
9374             {
9375                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
9376                if(rsrcSetList->list.array)
9377                {
9378                   rSetIdx = 0;
9379
9380                   /* Free SRS resource Id list in this SRS resource set */
9381                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
9382                   {
9383                      rsrcIdList =
9384                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
9385
9386                      if(rsrcIdList->list.array)
9387                      {
9388                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
9389                               rsrcIdx++)
9390                         {
9391                            free(rsrcIdList->list.array[rsrcIdx]);
9392                         }
9393                         free(rsrcIdList->list.array);
9394                      }
9395                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
9396                   }
9397
9398                   /* Free resource type info for this SRS resource set */
9399
9400                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
9401
9402                   /* Free memory for each resource set */
9403                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
9404                   {
9405                      free(rsrcSetList->list.array[rSetIdx]);
9406                   }
9407                   free(rsrcSetList->list.array);
9408                }
9409                free(srsCfg->srs_ResourceSetToAddModList);
9410             }
9411
9412             /* Free resource to add/modd list */
9413             if(srsCfg->srs_ResourceToAddModList)
9414             {
9415                resourceList = srsCfg->srs_ResourceToAddModList;
9416                if(resourceList->list.array)
9417                {
9418                   rsrcIdx = 0;
9419
9420                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
9421                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
9422
9423                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
9424                   {
9425                      free(resourceList->list.array[rsrcIdx]);
9426                   }
9427                   free(resourceList->list.array);
9428                }
9429                free(srsCfg->srs_ResourceToAddModList);
9430             }
9431
9432             free(ulBwp->srs_Config->choice.setup);
9433          }
9434          free(ulBwp->srs_Config);
9435       }
9436    }
9437 }
9438 /*******************************************************************
9439 *
9440 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
9441 *
9442 * @details
9443 *
9444 *    Function : freeAperDecodeinitialUplinkBWPConfig
9445 *
9446 *    Functionality: Function to free initialUplinkBWPConfig
9447 *
9448 * @params[in] UplinkConfig_t *ulCfg
9449 * @return void
9450 *
9451 * ****************************************************************/
9452
9453
9454 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
9455 {
9456    BWP_UplinkDedicated_t *ulBwp=NULLP;
9457    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
9458
9459    if(ulCfg->initialUplinkBWP)
9460    {
9461       ulBwp=ulCfg->initialUplinkBWP;
9462       if(ulCfg->firstActiveUplinkBWP_Id)
9463       {
9464          if(ulCfg->pusch_ServingCellConfig)
9465          {
9466             puschCfg=ulCfg->pusch_ServingCellConfig;
9467             if(puschCfg->choice.setup)
9468             {
9469                if(puschCfg->choice.setup->ext1)
9470                {
9471                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
9472                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
9473                   free(puschCfg->choice.setup->ext1);
9474                }
9475                free(puschCfg->choice.setup);
9476             }
9477             free(ulCfg->pusch_ServingCellConfig);
9478          }
9479          free(ulCfg->firstActiveUplinkBWP_Id);
9480       }
9481       freeAperDecodeInitialUlBWPConfig(ulBwp);
9482       free(ulCfg->initialUplinkBWP);
9483    }
9484 }
9485
9486 /*******************************************************************
9487  *
9488  * @brief Function to free DuUeCfg
9489  *
9490  * @details
9491  *
9492  *    Function : freeDuUeCfg
9493  *
9494  *    Functionality: Function to free DuUeCfg
9495  *
9496  * @params[in] DuUeCfg *ueCfg
9497  * @return void
9498  *
9499  * ****************************************************************/
9500 void freeDuUeCfg(UeCtxtActionType actionType, DuUeCfg *ueCfg)
9501 {
9502    uint8_t lcIdx = 0;
9503    uint8_t arrIdx = 0;
9504    SpCellConfig_t *spCellCfg = NULLP;
9505    ServingCellConfig_t *srvCellCfg = NULLP;
9506    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9507    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
9508    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9509    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
9510    struct RLC_Config *rlcConfig = NULLP;
9511    struct LogicalChannelConfig *macLcConfig = NULLP;
9512    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
9513    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
9514    struct TAG_Config *tagConfig = NULLP;
9515    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
9516    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
9517    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
9518    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
9519
9520    if(ueCfg->ueNrCapability)
9521    {
9522       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
9523       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
9524       ueCfg->ueNrCapability = NULLP;
9525    }
9526
9527    if(ueCfg->cellGrpCfg)
9528    {
9529       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
9530       if(rlcBearerList)
9531       {
9532          if(rlcBearerList->list.array)
9533          {
9534             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
9535             {
9536                if(rlcBearerList->list.array[arrIdx])
9537                {
9538                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
9539                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
9540
9541                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
9542                   {
9543                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
9544                   }
9545                   if(rlcConfig)
9546                   {
9547                      if(rlcConfig->choice.am)
9548                      {
9549                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
9550                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
9551                         free(rlcConfig->choice.am);
9552                      }
9553                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
9554                   }
9555                   if(macLcConfig)
9556                   {
9557                      if(macLcConfig->ul_SpecificParameters)
9558                      {
9559                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
9560                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
9561                         free(macLcConfig->ul_SpecificParameters);
9562                      }
9563                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
9564                   }
9565                   free(rlcBearerList->list.array[arrIdx]);
9566                }
9567             }
9568             free(rlcBearerList->list.array);
9569          }
9570          free(cellGrpCfg->rlc_BearerToAddModList);
9571       }
9572
9573       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
9574       if(macCellGrpCfg)
9575       {
9576          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
9577          if(schedulingRequestConfig)
9578          {
9579             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
9580             if(schReqList)
9581             {
9582                if(schReqList->list.array)
9583                {
9584                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
9585                   {
9586                      if(schReqList->list.array[arrIdx])
9587                      {
9588                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
9589                         free(schReqList->list.array[arrIdx]);
9590                      }
9591                   }
9592                   free(schReqList->list.array);
9593                }
9594                free(schedulingRequestConfig->schedulingRequestToAddModList);
9595             }
9596             free(macCellGrpCfg->schedulingRequestConfig);
9597          }
9598          if(macCellGrpCfg->bsr_Config)
9599          {
9600             free(macCellGrpCfg->bsr_Config);
9601          }
9602          tagConfig = macCellGrpCfg->tag_Config;
9603          if(tagConfig)
9604          {
9605             tagList = tagConfig->tag_ToAddModList;
9606             if(tagList)
9607             {
9608                if(tagList->list.array)
9609                {
9610                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
9611                   {
9612                      free(tagList->list.array[arrIdx]);
9613                   }
9614                   free(tagList->list.array);
9615                }
9616                free(tagConfig->tag_ToAddModList);
9617             }
9618             free(tagConfig);
9619          }
9620
9621          phrConfig = macCellGrpCfg->phr_Config;
9622          if(phrConfig)
9623          {
9624             free(phrConfig->choice.setup);
9625             free(phrConfig);
9626          }
9627
9628          free(macCellGrpCfg);
9629       }
9630
9631       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
9632       if(phyCellGrpCfg)
9633       {
9634          free(phyCellGrpCfg->p_NR_FR1);
9635          free(phyCellGrpCfg);
9636       }
9637
9638       spCellCfg = cellGrpCfg->spCellConfig;
9639       if(spCellCfg)
9640       {
9641          if(spCellCfg->servCellIndex)
9642          {
9643             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
9644             {
9645                if(spCellCfg->spCellConfigDedicated)
9646                {
9647                   srvCellCfg = spCellCfg->spCellConfigDedicated;
9648                   if(srvCellCfg->initialDownlinkBWP)
9649                   {
9650                      dlBwp = srvCellCfg->initialDownlinkBWP;
9651                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
9652                      {
9653                         if(srvCellCfg->defaultDownlinkBWP_Id)
9654                         {
9655                            if(srvCellCfg->uplinkConfig)
9656                            {
9657
9658                               if(srvCellCfg->pdsch_ServingCellConfig)
9659                               {
9660                                  pdschCfg=
9661                                     srvCellCfg->pdsch_ServingCellConfig;
9662                                  if(pdschCfg->choice.setup)
9663                                  {
9664
9665                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
9666                                     free(pdschCfg->choice.setup);
9667                                  }
9668
9669                                  free(srvCellCfg->pdsch_ServingCellConfig);
9670                               }
9671
9672                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
9673                               free(srvCellCfg->uplinkConfig);
9674                            }
9675                            free(srvCellCfg->defaultDownlinkBWP_Id);
9676                         }
9677
9678                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
9679                      }
9680                      if(dlBwp->pdcch_Config)
9681                      {
9682                         if(dlBwp->pdsch_Config)
9683                         {
9684                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
9685                            free(dlBwp->pdsch_Config);
9686                         }
9687                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
9688                         free(dlBwp->pdcch_Config);
9689                      }
9690                      free(srvCellCfg->initialDownlinkBWP);
9691                   }
9692
9693                   free(spCellCfg->spCellConfigDedicated);
9694                }
9695                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
9696             }
9697             free(spCellCfg->servCellIndex);
9698          }
9699          free(spCellCfg);
9700       }
9701       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9702       ueCfg->cellGrpCfg = NULLP;
9703    }
9704
9705    if(ueCfg->ambrCfg)
9706    {
9707       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
9708    }
9709
9710    if(actionType != UE_CTXT_CFG_QUERY)
9711    {
9712       for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
9713       {
9714          freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
9715       }
9716    }
9717
9718    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
9719    {
9720       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
9721    }
9722
9723    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
9724    {
9725       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
9726    }
9727 }
9728
9729 /*******************************************************************
9730  *
9731  * @brief Function to free UecontextSetupDb
9732  *
9733  * @details
9734  *
9735  *    Function : freeF1UeDb
9736  *
9737  *    Functionality: Function to free UecontextSetupDb
9738  *
9739  * @params[in] UecontextSetupDb *
9740  * @return void
9741  *
9742  * ****************************************************************/
9743
9744 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
9745 {
9746
9747    if(f1UeDb->dlRrcMsg)
9748    {
9749       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
9750       {
9751         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
9752                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
9753       }
9754       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9755    }
9756    freeDuUeCfg(f1UeDb->actionType, &f1UeDb->duUeCfg);
9757    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
9758    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
9759 }
9760
9761 /*******************************************************************
9762  *
9763  * @brief Function to build Am cfg Info
9764  *
9765  * @details
9766  *
9767  *    Function : extractRlcAmCfg
9768  *
9769  *    Functionality: Function to build Am cfg Info
9770  *
9771  * @params[in] AmBearerCfg *
9772  *             void *
9773  *
9774  * @return ROK/RFAILED
9775  *
9776  * ****************************************************************/
9777
9778 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
9779 {
9780    if(rlcAmCfg)
9781    {
9782       /* UL AM */
9783       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
9784       {
9785          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
9786          /*TODO: Check the timer value when sent by real CU */
9787          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
9788          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
9789       }
9790
9791       /* DL AM */
9792       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
9793       {
9794          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
9795          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
9796          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
9797          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
9798          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
9799       }
9800    }
9801 }
9802
9803 /*******************************************************************
9804  *
9805  * @brief Function to build Um Bi Info
9806  *
9807  * @details
9808  *
9809  *    Function : extractRlcUmBiCfg
9810  *
9811  *    Functionality: Function to build Um Bi Info
9812  *
9813  * @params[in] UmBiDirBearerCfg *
9814  *             void *
9815  *
9816  * @return ROK/RFAILED
9817  *
9818  * ****************************************************************/
9819
9820 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
9821 {
9822    if(rlcBiCfg)
9823    {
9824       /* UL UM BI DIR Cfg */
9825       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
9826       {
9827          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
9828          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
9829       }
9830
9831       /* DL UM BI DIR Cfg */
9832       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
9833          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
9834    }
9835 }
9836
9837 /*******************************************************************
9838  *
9839  * @brief Function to build Um Ul Info
9840  *
9841  * @details
9842  *
9843  *    Function : extractRlcUmUlCfg
9844  *
9845  *    Functionality: Function to build Um Ul Info
9846  *
9847  * @params[in] UmUniDirUlBearerCfg *
9848  *             void *
9849  *
9850  * @return ROK/RFAILED
9851  *
9852  * ****************************************************************/
9853
9854 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
9855 {
9856    if(umUlCfg)
9857    {
9858       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
9859       {
9860          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
9861          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
9862       }
9863    }
9864 }
9865
9866 /*******************************************************************
9867  *
9868  * @brief Function to build Um Uni Dl Info
9869  *
9870  * @details
9871  *
9872  *    Function : extractRlcUmDlCfg
9873  *
9874  *    Functionality: Function to build Um Uni Dl Info
9875  *
9876  * @params[in] UmUniDirDlBearerCfg *
9877  *             void *
9878  *
9879  * @return ROK/RFAILED
9880  *
9881  * ****************************************************************/
9882 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
9883 {
9884    if(umDlCfg)
9885    {
9886       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
9887          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
9888    }
9889 }
9890
9891 /*******************************************************************
9892  *
9893  * @brief Function to extractRlcModeCfg
9894  *
9895  * @details
9896  *
9897  *    Function : extractRlcModeCfg
9898  *
9899  *    Functionality: Function to extractRlcModeCfg
9900  *
9901  * @params[in] RLC_Config_t *
9902  *             RlcBearerCfg *
9903  *             void  *
9904  * @return ROK/RFAILED
9905  *
9906  * ****************************************************************/
9907 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
9908 {
9909    if(lcCfg)
9910    {
9911       switch(rlcMode)
9912       {
9913          case RLC_AM :
9914             {
9915                if(lcCfg->choice.am)
9916                {
9917                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
9918                   if(rlcDbCfg->u.amCfg)
9919                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
9920                }
9921                break;
9922             }
9923          case RLC_UM_BI_DIRECTIONAL :
9924             {
9925                if(lcCfg->choice.um_Bi_Directional)
9926                {
9927                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
9928                   if(rlcDbCfg->u.umBiDirCfg)
9929                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
9930                }
9931                break;
9932             }
9933          case RLC_UM_UNI_DIRECTIONAL_UL :
9934             {
9935                if(lcCfg->choice.um_Uni_Directional_DL)
9936                {
9937                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
9938                   if(rlcDbCfg->u.umUniDirUlCfg)
9939                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
9940                }
9941                break;
9942             }
9943          case RLC_UM_UNI_DIRECTIONAL_DL :
9944             {
9945                if(lcCfg->choice.um_Uni_Directional_UL)
9946                {
9947                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
9948                   if(rlcDbCfg->u.umUniDirDlCfg)
9949                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
9950                }
9951                break;
9952             }
9953          default:
9954             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
9955             break;
9956       }
9957    }
9958 }
9959
9960 /*******************************************************************
9961  *
9962  * @brief Function to extract extractUlLcCfg
9963  *
9964  * @details
9965  *
9966  *    Function : extractUlLcCfg
9967  *
9968  *    Functionality: Function to extract extractUlLcCfg
9969  *
9970  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
9971  * @return void
9972  *
9973  * ****************************************************************/
9974
9975 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
9976 {
9977    if(ulLcCfg)
9978    {
9979       if(ulLcCfg->ul_SpecificParameters)
9980       {
9981          f1UlLcCfg->priority = \
9982             ulLcCfg->ul_SpecificParameters->priority;
9983       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
9984       {
9985          f1UlLcCfg->lcGroup = \
9986            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
9987       }
9988       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
9989       {
9990          f1UlLcCfg->schReqId = \
9991            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
9992       }
9993       f1UlLcCfg->pbr = \
9994          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
9995       f1UlLcCfg->bsd = \
9996          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
9997       }
9998    }
9999 }
10000
10001 /*******************************************************************
10002 *
10003 * @brief Function to extract Snssai Cfg Info from CU
10004 *
10005 * @details
10006 *
10007 *    Function : extractDrbSnssaiCfg
10008 *
10009 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
10010 *
10011 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
10012 * @return ROK/RFAILED
10013 *
10014 * ****************************************************************/
10015
10016 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
10017 {
10018    if(!(*snssaiToBeShared))
10019    {
10020       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
10021       if(snssaiToBeShared == NULLP)
10022       {
10023          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
10024          return RFAILED;
10025       }
10026    }
10027    if(RecvSnssai)
10028    {
10029       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
10030       if(RecvSnssai->sD)
10031       {
10032          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
10033       }
10034       else
10035       {
10036          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
10037          return RFAILED;
10038       }
10039    }
10040    return ROK;
10041 }
10042
10043 /*******************************************************************
10044  *
10045  * @brief Function to procRlcLcCfg
10046  *
10047  * @details
10048  *
10049  *    Function : procRlcLcCfg
10050  *
10051  *    Functionality: Function to procRlcLcCfg
10052  *
10053  * @params[in] rbId, lcId, rbType, rlcMod
10054  *             RLC_Config_t *, RlcBearerCfg * ,
10055  * @return void
10056  *
10057  * ****************************************************************/
10058
10059 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
10060    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
10061 {
10062    DRB_Information_t *drbInfo;
10063
10064    lcCfg->rbId   = rbId;
10065    lcCfg->configType = configType;
10066
10067    if(rbType == RB_TYPE_SRB)
10068    {
10069       lcCfg->rbType = RB_TYPE_SRB;
10070       lcCfg->lcId   = rbId;
10071       lcCfg->lcType = LCH_DCCH;
10072       lcCfg->rlcMode = RLC_AM;
10073    }
10074    else if(rbType == RB_TYPE_DRB)
10075    {
10076       lcCfg->rbType = RB_TYPE_DRB;
10077       lcCfg->lcId   = lcId;
10078       lcCfg->lcType = LCH_DTCH;
10079       lcCfg->rlcMode = rlcMode;
10080    }
10081    if(f1RlcCfg) /* rlc mode config recived */
10082    {
10083       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
10084    }
10085    if(qoSInformation != NULLP)
10086    {
10087       if(qoSInformation->present == QoSInformation_PR_choice_extension)
10088       {
10089          if(qoSInformation->choice.choice_extension->value.present ==\
10090                QoSInformation_ExtIEs__value_PR_DRB_Information)
10091          {
10092             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10093             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
10094             {
10095                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
10096                return;
10097             }
10098          }
10099       }
10100    }
10101 }
10102
10103 /*******************************************************************
10104  *
10105  * @brief Fills DrbQos Info received by CU
10106  *
10107  * @details
10108  *
10109  *    Function : extractQosInfo
10110  *
10111  *    Functionality: Fills DrbQos Info received  by CU
10112  *
10113  * @params[in] DrbQosInfo *qosToAdd,
10114  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
10115  * @return void
10116  *
10117  * ****************************************************************/
10118
10119 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
10120 {
10121    uint8_t qosCntIdx = 0;
10122    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
10123
10124    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
10125    qosToAdd->u.nonDyn5Qi.fiveQi     =\
10126                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
10127    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
10128    {
10129       qosToAdd->u.nonDyn5Qi.avgWindow = \
10130                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10131    }
10132
10133    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
10134    {
10135       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
10136                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10137    }
10138
10139    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
10140    {
10141       qosToAdd->u.nonDyn5Qi.priorLevel = \
10142                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
10143    }
10144    qosToAdd->ngRanRetPri.priorityLevel = \
10145                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
10146    qosToAdd->ngRanRetPri.preEmptionCap = \
10147                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
10148    qosToAdd->ngRanRetPri.preEmptionVul = \
10149                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
10150    if(qosFlowCfg->gBR_QoS_Flow_Information)
10151    {
10152       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
10153             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
10154             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
10155       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
10156             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
10157             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
10158       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
10159             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
10160             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
10161       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
10162             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
10163             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
10164    }
10165    /*Extracting PDU_SESSION_ID*/
10166    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
10167    if(qosIeExt)
10168    {
10169       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
10170       {
10171          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
10172                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
10173          {
10174             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
10175             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
10176          }
10177       }
10178    }
10179    qosToAdd->ulPduSessAggMaxBitRate = 0;
10180 }
10181
10182 /*******************************************************************
10183  *
10184  * @brief Function to extract GTP Tunnel Info from CU
10185  *
10186  * @details
10187  *
10188  *    Function : extractUpTnlInfo
10189  *
10190  *    Functionality: Function to extract GTP Tunnel Info from CU
10191  *
10192  * @params[in] F1AP message
10193  * @return ROK/RFAILED
10194  *
10195  * ****************************************************************/
10196
10197 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
10198    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
10199 {
10200    uint8_t tnlIdx;
10201    uint32_t ipv4_du = 0;
10202    GTPTunnel_t *gtpTunnel = NULLP;
10203
10204    upTnlInfo->drbId = drbId;
10205    upTnlInfo->configType = configType;
10206 #ifdef O1_ENABLE
10207    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
10208 #else
10209    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
10210 #endif
10211
10212    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
10213    {
10214       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
10215       {
10216          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
10217          {
10218             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
10219             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
10220             if(upTnlInfo->tnlCfg1 == NULLP)
10221             {
10222                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
10223                return RFAILED;
10224             }
10225             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
10226             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
10227             if(gtpTunnel->gTP_TEID.size > 0)
10228             {
10229                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
10230             }
10231          }
10232          break;
10233       }
10234    }
10235    return ROK;
10236 }
10237
10238 /*******************************************************************
10239 *
10240 * @brief Function to extract Drb Qos Cfg Info from CU
10241 *
10242 * @details
10243 *
10244 *    Function : extractDrbQosCfg
10245 *
10246 *    Functionality: Function to extract Drb Qos Cfg Info from CU
10247 *
10248 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
10249 * @return ROK/RFAILED
10250 *
10251 * ****************************************************************/
10252
10253 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
10254 {
10255    if(!macLcToAdd->drbQos)
10256    {
10257       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
10258       if(macLcToAdd->drbQos == NULLP)
10259       {
10260          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
10261          return RFAILED;
10262       }
10263
10264    }
10265    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
10266    {
10267       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
10268       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
10269    }
10270    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
10271    {
10272       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
10273       return RFAILED;
10274    }
10275    return ROK;
10276 }
10277 /*******************************************************************
10278  *
10279  * @brief Function to extract DRB info received from CU
10280  *
10281  * @details
10282  *
10283  *    Function : extractDrbCfg
10284  *
10285  *    Functionality: Function to extract DRB info received from CU
10286  *
10287  * @params[in] F1AP message
10288  * @return void
10289  *
10290  * ****************************************************************/
10291 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
10292 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
10293 {
10294    DRB_Information_t *drbInfo = NULLP;
10295
10296    if(drbItem != NULLP)
10297    {
10298       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
10299       {
10300          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10301          return RFAILED;
10302       }
10303       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10304       {
10305          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
10306          {
10307             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10308             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10309             {
10310                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10311                return RFAILED;
10312             }
10313          }
10314       }
10315    }
10316    else if(drbSetupModItem != NULLP)
10317    {
10318       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
10319       upTnlInfo) != ROK)
10320       {
10321          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10322          return RFAILED;
10323       }
10324       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10325       {
10326          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
10327          QoSInformation_ExtIEs__value_PR_DRB_Information)
10328          {
10329             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10330             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10331             {
10332                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10333                return RFAILED;
10334             }
10335
10336          }
10337       }
10338    }
10339    else if(drbModItem != NULLP)
10340    {
10341       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
10342       upTnlInfo) != ROK)
10343       {
10344          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10345          return RFAILED;
10346       }
10347       if(drbModItem->qoSInformation != NULLP)
10348       {
10349          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
10350          {
10351             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
10352                   QoSInformation_ExtIEs__value_PR_DRB_Information)
10353             {
10354                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10355                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10356                {
10357                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10358                   return RFAILED;
10359                }
10360
10361             }
10362          }
10363       }
10364    }
10365    return ROK;
10366 }
10367
10368 /*******************************************************************
10369  *
10370  * @brief Function to extract RB info received from CU
10371  *
10372  * @details
10373  *
10374  *    Function : extractMacRbCfg
10375  *
10376  *    Functionality: Function to extract RB info received from CU
10377  *
10378  * @params[in] F1AP message
10379  * @return ROK/RFAILED
10380  *
10381  * ****************************************************************/
10382
10383 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
10384 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10385 {
10386    if(drbCfg != NULLP)
10387    {
10388       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
10389       {
10390          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10391          return RFAILED;
10392       }
10393    }
10394    else if(drbSetupModCfg != NULLP)
10395    {
10396       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
10397       {
10398          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10399          return RFAILED;
10400       }
10401    }
10402    else if(drbModCfg != NULLP)
10403    {
10404       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
10405       {
10406          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10407          return RFAILED;
10408       }
10409    }
10410    else
10411    {
10412       lcCfg->drbQos = NULLP;
10413       lcCfg->snssai = NULLP;
10414       if(lcCfg->lcId == SRB2_LCID)
10415          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
10416       else
10417          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
10418    }
10419    if(ulLcCfg)
10420    {
10421       lcCfg->ulLcCfgPres = true;
10422       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
10423    }
10424    else
10425       lcCfg->ulLcCfgPres = false;
10426    return ROK;
10427 }
10428
10429 /*******************************************************************
10430  *
10431  * @brief Function processing LC config info received from CU
10432  *
10433  * @details
10434  *
10435  *    Function : procMacLcCfg
10436  *
10437  *    Functionality: Function processing LC config info received from CU
10438  *
10439  * @params[in] F1AP message
10440  * @return ROK/RFAILED
10441  *
10442  * ****************************************************************/
10443
10444 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
10445 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
10446 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10447 {
10448    uint8_t ret = ROK;
10449
10450    lcCfg->lcId = lcId;
10451    lcCfg->configType = configType;
10452    if(rbType == RB_TYPE_SRB)
10453    {
10454       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
10455    }
10456    else if(rbType == RB_TYPE_DRB)
10457    {
10458       if(drbItem != NULL)
10459         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
10460       else if(drbSetupModItem != NULL)
10461         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
10462       else if(drbModItem != NULL)
10463         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
10464    }
10465    return ret;
10466 }
10467
10468 /*******************************************************************
10469  *
10470  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
10471  *
10472  * @details
10473  *
10474  *    Function : extractRlcCfgToAddMod
10475  *
10476  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
10477  *
10478  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
10479  *             DuUeCfg Pointer
10480  * @return ROK/RFAILED
10481  *
10482  * ****************************************************************/
10483
10484 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
10485 {
10486   uint8_t idx, rbId, lcId, rlcMode, rbType;
10487   RLC_Config_t *f1RlcCfg = NULLP;
10488   LogicalChannelConfig_t *macUlLcCfg = NULLP;
10489
10490   for(idx = 0; idx < lcCfg->list.count; idx++)
10491   {
10492      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
10493      if(lcCfg->list.array[idx]->servedRadioBearer)
10494      {
10495         /* RadioBearer for SRB/DRB */
10496         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10497         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
10498         {
10499            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
10500            rbType = RB_TYPE_SRB;
10501         }
10502         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10503         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
10504         {
10505            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
10506            rbType = RB_TYPE_DRB;
10507         }
10508         else
10509         {
10510            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
10511            return RFAILED;
10512         }
10513         /* MAC UL LC Config */
10514         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
10515         {
10516            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
10517         }
10518      }
10519      else
10520      {
10521         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
10522         return RFAILED;
10523      }
10524      /* RLC Mode Config */
10525      if(lcCfg->list.array[idx]->rlc_Config)
10526      {
10527         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
10528         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
10529      }
10530
10531      /* Filling RLC/MAC Config*/
10532      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
10533      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
10534      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
10535      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
10536      {
10537         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
10538         return RFAILED;
10539      }
10540      (ueCfgDb->numRlcLcs)++;
10541      (ueCfgDb->numMacLcs)++;
10542      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10543         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10544   }
10545   //TODO: To send the failure cause in UeContextSetupRsp
10546   return ROK;
10547 }
10548
10549 /*******************************************************************
10550  *
10551  * @brief DeAlloc pdsch serv cell config info
10552  *
10553  * @details
10554  *
10555  *    Function : freeMacPdschServCellInfo
10556  *
10557  *    Functionality: DeAlloc pdsch serv cell config info
10558  *
10559  * @params[in] PdschServCellCfg pointer
10560  * @return void
10561  *
10562  * ****************************************************************/
10563
10564 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
10565 {
10566    if(pdsch->xOverhead)
10567    {
10568       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
10569    }
10570    if(pdsch->codeBlkGrpFlushInd)
10571    {
10572       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
10573    }
10574    if(pdsch->maxCodeBlkGrpPerTb)
10575    {
10576       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10577    }
10578    if(pdsch->maxMimoLayers)
10579    {
10580       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
10581    }
10582 }
10583
10584 /*******************************************************************
10585  *
10586  * @brief Free Serving cell Info
10587  *
10588  * @details
10589  *
10590  *    Function : freeMacServingCellInfo
10591  *
10592  *    Functionality: Free Serving cell Info
10593  *
10594  * @params[in] ServCellCfgInfo *srvCellCfg
10595  * @return void
10596  *
10597  * ****************************************************************/
10598 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
10599 {
10600    uint8_t timeDomRsrcIdx;
10601
10602    if(srvCellCfg->initDlBwp.pdschPresent)
10603    {
10604       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
10605       {
10606          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
10607             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
10608       }
10609    }
10610
10611    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
10612    if(srvCellCfg->bwpInactivityTmr)
10613    {
10614       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10615    }
10616
10617    if(srvCellCfg->initUlBwp.pucchPresent)
10618    {
10619       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10620    }
10621 }
10622
10623 /*******************************************************************
10624  *
10625  * @brief Free cell Grp Cfg Info
10626  *
10627  * @details
10628  *
10629  *    Function : freeUeReCfgCellGrpInfo
10630  *
10631  *    Functionality: Free cell Grp Cfg Info
10632  *
10633  * @params[in] MacUeCfg*  duUeCfg
10634  * @return void
10635  *
10636  * ****************************************************************/
10637
10638 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
10639 {
10640    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
10641 }
10642
10643 /*******************************************************************
10644  *
10645  * @brief Fills Reconfig SchReqReConfig
10646  *
10647  * @details
10648  *
10649  *    Function : extractSchReqReConfig
10650  *
10651  *    Functionality: Fills Reconfig SchReqReConfig
10652  *
10653  * @params[in] SchedulingRequestConfig_t *cuSchedReq
10654  *             SchedReqCfg*  macSchedReq
10655  * @return void
10656  *
10657  * ****************************************************************/
10658 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
10659 {
10660    uint8_t schReqIdx = 0;
10661    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
10662    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
10663
10664    if(cuSchedReq->schedulingRequestToAddModList)
10665    {
10666       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
10667       if(schReqListToAdd->list.count)
10668       {
10669          macSchedReq->addModListCount = schReqListToAdd->list.count;
10670          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
10671          {
10672             macSchedReq->addModList[schReqIdx].schedReqId = \
10673                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
10674             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
10675                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
10676             macSchedReq->addModList[schReqIdx].srTransMax    =\
10677                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
10678          }
10679       }
10680    }
10681    /* Scheduling Req To release */
10682    if(cuSchedReq->schedulingRequestToReleaseList)
10683    {
10684       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
10685       if(schReqListToRel->list.count)
10686       {
10687          macSchedReq->relListCount = schReqListToRel->list.count;
10688          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
10689          {
10690             macSchedReq->relList[schReqIdx] = \
10691                *schReqListToRel->list.array[schReqIdx];
10692          }
10693       }
10694    }
10695 }
10696
10697 /*******************************************************************
10698  *
10699  * @brief Fills TagReconfig
10700  *
10701  * @details
10702  *
10703  *    Function : extractTagReconfig
10704  *
10705  *    Functionality: Fills extractTagReconfig
10706  *
10707  * @params[in] TAG_Config_t *cuTagCfg
10708  *             TagCfg *macTagCfg
10709  * @return void
10710  *
10711  * ****************************************************************/
10712
10713 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
10714 {
10715   uint8_t tagIdx = 0;
10716   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
10717   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
10718
10719   /* Tag config to AddMod */
10720   if(cuTagCfg->tag_ToAddModList)
10721   {
10722      tagListToAddMod = cuTagCfg->tag_ToAddModList;
10723      if(tagListToAddMod->list.count)
10724      {
10725         macTagCfg->addModListCount = tagListToAddMod->list.count;
10726         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
10727         {
10728            macTagCfg->addModList[tagIdx].tagId =\
10729               tagListToAddMod->list.array[tagIdx]->tag_Id;
10730            macTagCfg->addModList[tagIdx].timeAlignTimer = \
10731
10732               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
10733         }
10734      }
10735   }
10736   /* Tag config to release */
10737   if(cuTagCfg->tag_ToReleaseList)
10738   {
10739      tagListToRel = cuTagCfg->tag_ToReleaseList;
10740      if(tagListToRel->list.count)
10741      {
10742         macTagCfg->relListCount = tagListToRel->list.count;
10743         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
10744         {
10745            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
10746         }
10747      }
10748   }
10749 }
10750
10751 /*******************************************************************
10752  *
10753  * @brief Fills PdcchCfg received by CU
10754  *
10755  * @details
10756  *
10757  *    Function : extractPdcchCfg
10758  *
10759  *    Functionality: Fills PdcchCfg received  by CU
10760  *
10761  * @params[in] PDCCH_Config_t *cuPdcchCfg,
10762  *             PdcchConfig *duPdcchCfg
10763  * @return void
10764  *
10765  * ****************************************************************/
10766
10767 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
10768 {
10769    uint8_t cRsetIdx = 0;
10770    uint8_t srchSpcIdx = 0;
10771
10772    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
10773    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
10774    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
10775    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
10776
10777
10778    /* Control Resource Set To Add/Mod List */
10779    if(cuPdcchCfg->controlResourceSetToAddModList)
10780    {
10781       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
10782       if(cRsetToAddModList->list.count)
10783       {
10784          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
10785          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
10786          {
10787             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
10788                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
10789             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
10790                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
10791             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
10792                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
10793                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
10794
10795             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
10796                 cRsetToAddModList->list.array[cRsetIdx]->duration;
10797
10798             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
10799                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
10800             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
10801             {
10802                //TODO: handle the case for Interleaved
10803             }
10804             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
10805                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
10806             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
10807             {
10808                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
10809                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
10810             }
10811          }
10812       }
10813    }
10814    /* Control Resource Set To Release List */
10815    if(cuPdcchCfg->controlResourceSetToReleaseList)
10816    {
10817       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
10818       if(cRsetToRelList->list.count)
10819       {
10820          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
10821          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
10822          {
10823             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
10824          }
10825       }
10826    }
10827
10828    /* Search space To Add/Mod List */
10829    if(cuPdcchCfg->searchSpacesToAddModList)
10830    {
10831       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
10832       if(srchSpcToAddModList->list.count)
10833       {
10834          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
10835          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
10836          {
10837             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
10838                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
10839             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
10840                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
10841             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
10842             {
10843                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
10844                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
10845             }
10846             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
10847             {
10848                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
10849                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
10850             }
10851             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
10852             {
10853                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
10854                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
10855                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
10856                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
10857                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
10858                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
10859
10860                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
10861                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
10862
10863                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
10864                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
10865             }
10866             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
10867             {
10868                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
10869                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
10870                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
10871                {
10872                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
10873                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
10874                }
10875
10876             }
10877          }
10878       }
10879    }
10880    /* Search space To Rel List */
10881    if(cuPdcchCfg->searchSpacesToReleaseList)
10882    {
10883       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
10884       if(srchSpcToRelList->list.count)
10885       {
10886          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
10887          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
10888          {
10889             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
10890                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
10891          }
10892       }
10893    }
10894 }
10895
10896 /*******************************************************************
10897  *
10898  * @brief Fills PdschCfg received by CU
10899  *
10900  * @details
10901  *
10902  *    Function : extractPdschCfg
10903  *
10904  *    Functionality: Fills PdschCfg received  by CU
10905  *
10906  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
10907  *                   which we have stored in F1UeContextSetupDb,
10908  *             PdschConfig *macPdschCfg = Used to Store the information which
10909  *                   needs to send in other layer, as well as this can be the variable
10910  *                   which stores the information in DuCb,
10911  *             PdschConfig *storedPdschCfg =  Null in case of sending the
10912  *                   information to other layer else it will have stored pdsch
10913  *                   configuration in copyOfmacUeCfg.
10914  * @return void
10915  *
10916  * ****************************************************************/
10917
10918 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
10919 {
10920    uint8_t timeDomIdx;
10921    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
10922
10923    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
10924    {
10925       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
10926             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
10927       {
10928          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
10929          {
10930             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
10931                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
10932          }
10933       }
10934    }
10935    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
10936    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
10937    {
10938       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
10939       if(timeDomAlloc->present ==\
10940             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
10941       {
10942          if(timeDomAlloc->choice.setup)
10943          {
10944             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
10945             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
10946             {
10947                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
10948                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
10949                {
10950                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
10951                   {
10952                      if(storedPdschCfg)
10953                      {
10954                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
10955                         {
10956                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
10957                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
10958                         }
10959                         else
10960                         {
10961                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
10962                         }
10963                      }
10964                      else
10965                      {
10966                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
10967                      }
10968                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
10969                      {
10970                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
10971                         return;
10972                      }
10973                   }
10974                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
10975                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
10976                }
10977                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
10978                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
10979                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
10980                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
10981             }
10982          }
10983       }
10984    }
10985    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
10986    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
10987       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
10988    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
10989    {
10990       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
10991       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
10992       {
10993          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
10994          {
10995             macPdschCfg->bundlingInfo.StaticBundling.size = \
10996                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
10997          }
10998       }
10999    }
11000    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
11001    {
11002       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11003    }
11004
11005 }
11006
11007 /*******************************************************************
11008  *
11009  * @brief Fills PdschServingCellCfg received by CU
11010  *
11011  * @details
11012  *
11013  *    Function : extractPdschServingCellCfg
11014  *
11015  *    Functionality: Fills PdschCfg received  by CU
11016  *
11017  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
11018  *             PdschServCellCfg *macUePdschSrvCellCfg
11019  * @return ROK/RFAILED
11020  *
11021  * ****************************************************************/
11022
11023 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
11024 {
11025    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
11026    {
11027       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
11028       {
11029          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11030          {
11031             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11032                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11033          }
11034          else
11035          {
11036             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
11037             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11038             {
11039                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11040                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11041             }
11042             else
11043             {
11044                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
11045                return RFAILED;
11046             }
11047          }
11048          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11049          {
11050             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11051                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11052          }
11053          else
11054          {
11055             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
11056             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11057             {
11058                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11059                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11060             }
11061             else
11062             {
11063                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
11064                return RFAILED;
11065             }
11066          }
11067       }
11068    }
11069    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
11070    {
11071       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
11072    }
11073    if(cuPdschSrvCellCfg->ext1)
11074    {
11075       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
11076       {
11077         if(macUePdschSrvCellCfg->maxMimoLayers)
11078         {
11079            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11080         }
11081         else
11082         {
11083            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
11084            if(macUePdschSrvCellCfg->maxMimoLayers)
11085            {
11086               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11087            }
11088            else
11089            {
11090               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
11091               return RFAILED;
11092            }
11093         }
11094       }
11095    }
11096    if(cuPdschSrvCellCfg->xOverhead)
11097    {
11098       if(macUePdschSrvCellCfg->xOverhead)
11099       {
11100          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11101       }
11102       else
11103       {
11104          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
11105          if(macUePdschSrvCellCfg->xOverhead)
11106          {
11107             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11108          }
11109          else
11110          {
11111             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
11112             return RFAILED;
11113          }
11114       }
11115    }
11116    return ROK;
11117 }
11118
11119 /*******************************************************************
11120  *
11121  * @brief Fills PuschCfg received by CU
11122  *
11123  * @details
11124  *
11125  *    Function : extractPuschCfg
11126  *
11127  *    Functionality: Fills PuschCfg received  by CU
11128  *
11129  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
11130  *             PuschCfg *macPuschCfg
11131  * @return void
11132  *
11133  * ****************************************************************/
11134
11135 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
11136 {
11137    uint8_t timeDomIdx = 0;
11138    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
11139    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
11140
11141    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
11142    {
11143       if(cuPuschCfg->choice.setup)
11144       {
11145          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
11146          {
11147              macPuschCfg->dataScramblingId = \
11148                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
11149          }
11150          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
11151          {
11152             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
11153             {
11154                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
11155                {
11156                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
11157                   if(dmrsUlCfg->dmrs_AdditionalPosition)
11158                   {
11159                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
11160                         *(dmrsUlCfg->dmrs_AdditionalPosition);
11161                   }
11162                   if(dmrsUlCfg->transformPrecodingDisabled)
11163                   {
11164                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
11165                      {
11166                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
11167                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
11168                      }
11169                   }
11170                }
11171             }
11172          }
11173          /*Res Alloc Type for UL */
11174          if(cuPuschCfg->choice.setup->resourceAllocation)
11175          {
11176             macPuschCfg->resourceAllocType = \
11177                cuPuschCfg->choice.setup->resourceAllocation;
11178          }
11179          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
11180          {
11181             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
11182             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
11183             {
11184                if(timeDomAllocList->choice.setup)
11185                {
11186                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
11187                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
11188                   {
11189                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
11190                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
11191                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
11192                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
11193                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
11194                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11195                   }
11196                }
11197             }
11198          }
11199          if(cuPuschCfg->choice.setup->transformPrecoder)
11200             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
11201       }
11202    }
11203 }
11204
11205 /*******************************************************************
11206  *
11207  * @brief Function to fill pucch Power Control
11208  *
11209  * @details
11210  *
11211  *    Function : extractPucchPowerControl
11212  *
11213  *    Functionality: Function to fill pucch Power Control
11214  *
11215  * @params[in] PucchPowerControl *pwrCtrl,
11216  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
11217  * @return void
11218  *
11219  * ****************************************************************/
11220
11221 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
11222 {
11223    uint8_t arrIdx;
11224
11225    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
11226       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
11227    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
11228       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
11229    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
11230       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
11231    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
11232       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
11233    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
11234       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
11235    if(cuPwrCtrlCfg->p0_Set)
11236    {
11237       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
11238       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
11239       {
11240          pwrCtrl->p0Set[arrIdx].p0PucchId =\
11241             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
11242          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
11243             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
11244       }
11245    }
11246    if(cuPwrCtrlCfg->pathlossReferenceRSs)
11247    {
11248       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
11249       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
11250       {
11251          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
11252             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
11253       }
11254    }
11255 }
11256
11257  /*******************************************************************
11258  *
11259  * @brief Function to extractResrcSetToAddModList sent by CU
11260  *
11261  * @details
11262  *
11263  *    Function : extractResrcSetToAddModList
11264  *
11265  *    Functionality: Fucntion to extractResrcSetToAddModList
11266  *
11267  * @params[in] PucchResrcSetCfg pointer,
11268  *             struct PUCCH_Config__resourceSetToAddModList pointer
11269  * @return void
11270  *
11271  * ****************************************************************/
11272
11273 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
11274 {
11275    uint8_t arrIdx, rsrcListIdx;
11276
11277    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
11278    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
11279    {
11280       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
11281          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
11282       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
11283          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
11284       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
11285       {
11286          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
11287             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
11288       }
11289
11290       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
11291       {
11292          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
11293             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
11294       }
11295       else
11296       {
11297          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
11298       }
11299    }
11300 }/* End of extractResrcSetToAddModList */
11301
11302 /*******************************************************************
11303  *
11304  * @brief Fills extractResrcToAddModList sent by CU
11305  *
11306  * @details
11307  *
11308  *    Function : extractResrcToAddModList
11309  *
11310  *    Functionality: Fills extractResrcToAddModList
11311  *
11312  * @params[in] PucchResrcCfg pointer,
11313  *             struct PUCCH_Config__resourceToAddModList pointer
11314  * @return ROk/RFAILED
11315  *
11316  * ****************************************************************/
11317
11318 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
11319 {
11320    uint8_t arrIdx;
11321
11322    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
11323    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
11324    {
11325       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
11326         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
11327       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
11328         cuResrcList->list.array[arrIdx]->startingPRB;
11329       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
11330       {
11331          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
11332            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
11333       }
11334       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
11335       {
11336          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
11337            *cuResrcList->list.array[arrIdx]->secondHopPRB;
11338       }
11339       /* PUCCH RSRC FORMAT */
11340       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
11341       {
11342          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
11343          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
11344          {
11345             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
11346             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
11347             {
11348                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
11349                return RFAILED;
11350             }
11351             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
11352                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
11353             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
11354                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
11355             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
11356                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
11357          }
11358       }
11359       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
11360       {
11361          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
11362          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
11363          {
11364             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
11365             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
11366             {
11367                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
11368                return RFAILED;
11369             }
11370             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
11371                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
11372             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
11373                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
11374             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
11375                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
11376             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
11377                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
11378          }
11379       }
11380       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
11381       {
11382          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
11383          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
11384          {
11385             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
11386             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
11387             {
11388                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
11389                return RFAILED;
11390             }
11391             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
11392                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
11393             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
11394                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
11395             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
11396                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
11397          }
11398       }
11399       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
11400       {
11401          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
11402          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
11403          {
11404             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
11405             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
11406             {
11407                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
11408                return RFAILED;
11409             }
11410             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
11411                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
11412             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
11413                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
11414             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
11415                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
11416          }
11417       }
11418       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
11419       {
11420          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
11421          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
11422          {
11423             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
11424             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
11425             {
11426                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
11427                return RFAILED;
11428             }
11429             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
11430                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
11431             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
11432                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
11433             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
11434                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
11435             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
11436                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
11437          }
11438       }
11439    }
11440    return ROK;
11441
11442 }/* End of extractResrcToAddModList */
11443
11444 /*******************************************************************
11445  *
11446  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
11447  *
11448  * @details
11449  *
11450  *    Function : fillPucchSchedReqPeriodAndOffset
11451  *
11452  *    Functionality: To fillPucchSchedReqPeriodAndOffset
11453  *
11454  * @params[in] macPeriodicty,
11455  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
11456  * @return void
11457  *
11458  * ****************************************************************/
11459
11460 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
11461    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
11462 {
11463    macPeriodicty = cuPeriodicty->present;
11464    switch(macPeriodicty)
11465    {
11466       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
11467          {
11468             macOffset     = cuPeriodicty->choice.sym2;
11469             break;
11470          }
11471       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
11472          {
11473             macOffset     = cuPeriodicty->choice.sym6or7;
11474             break;
11475          }
11476       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
11477          {
11478             macOffset     = cuPeriodicty->choice.sl1;
11479             break;
11480          }
11481       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
11482          {
11483             macOffset = cuPeriodicty->choice.sl2;
11484             break;
11485          }
11486       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
11487          {
11488             macOffset = cuPeriodicty->choice.sl4;
11489             break;
11490          }
11491       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
11492          {
11493             macOffset = cuPeriodicty->choice.sl5;
11494             break;
11495          }
11496       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
11497          {
11498             macOffset = cuPeriodicty->choice.sl8;
11499             break;
11500          }
11501       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
11502          {
11503             macOffset = cuPeriodicty->choice.sl10;
11504             break;
11505          }
11506       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
11507          {
11508             macOffset = cuPeriodicty->choice.sl16;
11509             break;
11510          }
11511       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
11512          {
11513             macOffset = cuPeriodicty->choice.sl20;
11514             break;
11515          }
11516       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
11517          {
11518             macOffset = cuPeriodicty->choice.sl40;
11519             break;
11520          }
11521       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
11522          {
11523             macOffset = cuPeriodicty->choice.sl80;
11524             break;
11525          }
11526       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
11527          {
11528             macOffset = cuPeriodicty->choice.sl160;
11529             break;
11530          }
11531       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
11532          {
11533             macOffset = cuPeriodicty->choice.sl320;
11534             break;
11535          }
11536       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
11537          {
11538             macOffset = cuPeriodicty->choice.sl640;
11539             break;
11540          }
11541       default :
11542          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
11543    }
11544 }
11545
11546 /*******************************************************************
11547  *
11548  * @brief Function to extractPucchFormatCfg sent by CU
11549  *
11550  * @details
11551  *
11552  *    Function : extractPucchFormatCfg
11553  *
11554  *    Functionality: Function to extractPucchFormatCfg
11555  *
11556  * @params[in] PucchFormatCfg pointer,
11557  *             PUCCH_FormatConfig_t pointer
11558  * @return void
11559  *
11560  * ****************************************************************/
11561
11562 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
11563  {
11564     if(cuFormatCfg->interslotFrequencyHopping)
11565        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
11566     if(cuFormatCfg->additionalDMRS)
11567        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
11568     if(cuFormatCfg->maxCodeRate)
11569        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
11570     if(cuFormatCfg->nrofSlots)
11571        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
11572     if(cuFormatCfg->pi2BPSK)
11573        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
11574     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
11575        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
11576  }/* End of extractPucchFormatCfg */
11577
11578 /*******************************************************************
11579  *
11580  * @brief Function to extractSchedReqCfgToAddMod sent by CU
11581  *
11582  * @details
11583  *
11584  *    Function : extractSchedReqCfgToAddMod
11585  *
11586  *    Functionality: Function to extractSchedReqCfgToAddMod
11587  *
11588  * @params[in] PucchSchedReqCfg pointer,
11589  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
11590  * @return void
11591  *
11592  * ****************************************************************/
11593
11594 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
11595 {
11596    uint8_t arrIdx;
11597
11598    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
11599    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
11600    {
11601       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
11602          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
11603       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
11604          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
11605       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
11606       {
11607          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
11608             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
11609       }
11610       if(cuSchedReqList->list.array[arrIdx]->resource)
11611       {
11612          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
11613             *cuSchedReqList->list.array[arrIdx]->resource;
11614       }
11615    }
11616
11617 }/* End of extractSchedReqCfgToAddMod */
11618
11619  /*******************************************************************
11620  *
11621  * @brief Fills PucchCfg received by CU
11622  *
11623  * @details
11624  *
11625  *    Function : extractPucchCfg
11626  *
11627  *    Functionality: Fills PucchCfg received  by CU
11628  *
11629  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
11630  *                is send by CU, which we have stored in F1UeContextSetupDb,
11631  *             PucchCfg *macPucchCfg = Used to Store the information which
11632  *                needs to send in other layer, as well as this can be the variable
11633  *                which stores the information in DuCb,
11634  *             PucchCfg *storedPucchCfg = Null in case of sending the
11635  *                information to other layer else it will have Pucch Cfg which
11636  *                we have stored in copyOfmacUeCfg.
11637  * @return ROK/RFAILED
11638  *
11639  * ****************************************************************/
11640
11641 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
11642 PucchCfg *storedPucchCfg)
11643 {
11644    uint8_t arrIdx;
11645
11646    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
11647    {
11648       if(cuPucchCfg->choice.setup)
11649       {
11650          /* Resource Set Cfg */
11651          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
11652          {
11653             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
11654             if(macPucchCfg->resrcSet == NULLP)
11655             {
11656                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
11657                return RFAILED;
11658             }
11659             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
11660             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
11661          }
11662
11663          /* Resource Cfg */
11664          if(cuPucchCfg->choice.setup->resourceToAddModList)
11665          {
11666             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
11667             if(macPucchCfg->resrc == NULLP)
11668             {
11669                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
11670                return RFAILED;
11671             }
11672             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
11673             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
11674          }
11675
11676          /* Format 1 Cfg */
11677          if(cuPucchCfg->choice.setup->format1)
11678          {
11679             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
11680             if(macPucchCfg->format1 == NULLP)
11681             {
11682                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
11683                return RFAILED;
11684             }
11685             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
11686             extractPucchFormatCfg(macPucchCfg->format1,\
11687                cuPucchCfg->choice.setup->format1->choice.setup);
11688          }
11689
11690          /* Format 2 Cfg */
11691          if(cuPucchCfg->choice.setup->format2)
11692          {
11693             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
11694             if(macPucchCfg->format2 == NULLP)
11695             {
11696                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
11697                return RFAILED;
11698             }
11699             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
11700             extractPucchFormatCfg(macPucchCfg->format2,\
11701                cuPucchCfg->choice.setup->format2->choice.setup);
11702          }
11703
11704          /* Format 3 Cfg */
11705          if(cuPucchCfg->choice.setup->format3)
11706          {
11707             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
11708             if(macPucchCfg->format3 == NULLP)
11709             {
11710                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
11711                return RFAILED;
11712             }
11713             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
11714             extractPucchFormatCfg(macPucchCfg->format3,\
11715                cuPucchCfg->choice.setup->format3->choice.setup);
11716          }
11717
11718          /* Format 4 Cfg */
11719          if(cuPucchCfg->choice.setup->format4)
11720          {
11721             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
11722             if(macPucchCfg->format4 == NULLP)
11723             {
11724                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
11725                return RFAILED;
11726             }
11727             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
11728             extractPucchFormatCfg(macPucchCfg->format4,\
11729                cuPucchCfg->choice.setup->format4->choice.setup);
11730          }
11731
11732          /* Sched Req List */
11733          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
11734          {
11735             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
11736             if(macPucchCfg->schedReq == NULLP)
11737             {
11738                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
11739                return RFAILED;
11740             }
11741             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
11742             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
11743             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
11744          }
11745
11746          /*TODO: Add support for  Spatial Info */
11747
11748          /* MultiCsiCfg */
11749          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
11750          {
11751             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
11752             if(macPucchCfg->multiCsiCfg == NULLP)
11753             {
11754                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
11755                return RFAILED;
11756             }
11757             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
11758             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
11759             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
11760             {
11761                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
11762                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
11763             }
11764          }
11765
11766          /* Dl_DataToUL_ACK */
11767          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
11768     {
11769        if(storedPucchCfg)
11770        {
11771           if(storedPucchCfg->dlDataToUlAck)
11772           {
11773              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
11774           }
11775           else
11776           {
11777             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11778           }
11779        }
11780        else
11781        {
11782           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11783        }
11784        if(macPucchCfg->dlDataToUlAck == NULLP)
11785        {
11786           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
11787           return RFAILED;
11788        }
11789        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
11790        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
11791        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
11792        {
11793           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
11794           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
11795        }
11796          }
11797
11798          /* Power Control */
11799          if(cuPucchCfg->choice.setup->pucch_PowerControl)
11800          {
11801             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
11802             if(macPucchCfg->powerControl == NULLP)
11803             {
11804                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
11805                return RFAILED;
11806             }
11807             extractPucchPowerControl(macPucchCfg->powerControl,\
11808                cuPucchCfg->choice.setup->pucch_PowerControl);
11809          }
11810       }
11811    }
11812    return ROK;
11813 }
11814
11815 /*******************************************************************
11816  *
11817  * @brief Fills ServingCellReconfig received by CU
11818  *
11819  * @details
11820  *
11821  *    Function : extractSpCellDedicatedCfg
11822  *
11823  *    Functionality: Fills ServingCellReconfig received  by CU
11824  *
11825  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
11826  *                  CU, which we have stored in F1UeContextSetupDb,
11827  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
11828  *                  which  needs to send in other layer, as well as this can be the
11829  *                  variable which stores the information in DuCb,
11830  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
11831  *                  information to other layer else it will have ServCellCfgInfo which
11832  *                  we have stored in copyOfmacUeCfg.
11833  * @return ROK/RFAILD
11834  *
11835  * ****************************************************************/
11836 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
11837 ServCellCfgInfo *storedSrvCellCfg)
11838 {
11839    uint8_t ret = ROK;
11840    BWP_DownlinkDedicated_t *dlBwp = NULLP;
11841    BWP_UplinkDedicated_t   *ulBwp = NULLP;
11842
11843    if(cuSrvCellCfg->initialDownlinkBWP)
11844    {
11845       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
11846       if(dlBwp->pdcch_Config)
11847       {
11848          if(dlBwp->pdcch_Config->choice.setup)
11849          {
11850             macSrvCellCfg->initDlBwp.pdcchPresent = true;
11851             if(storedSrvCellCfg)
11852             {
11853                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
11854                {
11855                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11856                }
11857                else
11858                {
11859                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11860                }
11861             }
11862             else
11863             {
11864                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11865             }
11866          }
11867       }
11868       if(dlBwp->pdsch_Config)
11869       {
11870          if(dlBwp->pdsch_Config->choice.setup)
11871          {
11872             macSrvCellCfg->initDlBwp.pdschPresent = true;
11873
11874             if(storedSrvCellCfg)
11875             {
11876                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
11877                {
11878                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11879                }
11880                else
11881                {
11882                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
11883                         &storedSrvCellCfg->initDlBwp.pdschCfg);
11884                }
11885             }
11886             else
11887             {
11888                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11889             }
11890          }
11891       }
11892    }
11893    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
11894       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
11895    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
11896       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
11897    if(cuSrvCellCfg->bwp_InactivityTimer)
11898    {
11899       if(macSrvCellCfg->bwpInactivityTmr)
11900       {
11901          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11902       }
11903       else
11904       {
11905          macSrvCellCfg->bwpInactivityTmr = NULLP;
11906          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
11907          if(macSrvCellCfg->bwpInactivityTmr)
11908          {
11909             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11910          }
11911          else
11912          {
11913             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
11914             return RFAILED;
11915          }
11916       }
11917    }
11918    if(cuSrvCellCfg->pdsch_ServingCellConfig)
11919    {
11920       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
11921       {
11922          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
11923          if(ret == RFAILED)
11924          {
11925             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
11926             return RFAILED;
11927          }
11928       }
11929    }
11930    if(cuSrvCellCfg->uplinkConfig)
11931    {
11932       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
11933       {
11934          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
11935          if(ulBwp->pusch_Config)
11936          {
11937             macSrvCellCfg->initUlBwp.puschPresent = true;
11938             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
11939          }
11940          if(ulBwp->pucch_Config)
11941          {
11942             macSrvCellCfg->initUlBwp.pucchPresent = true;
11943             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
11944             if(storedSrvCellCfg)
11945             {
11946                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
11947                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11948                else
11949                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
11950                   &storedSrvCellCfg->initUlBwp.pucchCfg);
11951             }
11952             else
11953             {
11954                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11955             }
11956          }
11957       }
11958       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
11959          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
11960    }
11961    return ret;
11962 }
11963
11964 #ifdef NR_DRX
11965
11966 /*******************************************************************
11967  *
11968  * @brief fill long cycle offset value of drx in UE structure
11969  *
11970  * @details
11971  *
11972  *    Function : fillLongCycleOffsetValueInUeDb
11973  *
11974  *    Functionality: fill long cycle offset value of drx in UE structure
11975  *
11976  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
11977  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
11978  *
11979  * @return ROK     - success
11980  *         RFAILED - failure
11981  *
11982  * ****************************************************************/
11983 void fillLongCycleOffsetValueInUeDb(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset  *drx_LongCycleStartOffset)
11984 {
11985
11986    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = convertLongDrxCycleLengthEnumToValue(drx_LongCycleStartOffset->present);
11987    switch(drx_LongCycleStartOffset->present)
11988    {
11989       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
11990          {
11991             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10;
11992             break;
11993          }
11994       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
11995          {
11996             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms20;
11997             break;
11998          }
11999       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
12000          {
12001             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms32;
12002             break;
12003          }
12004       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
12005         {
12006             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms40;
12007             break;
12008          }
12009       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
12010          {
12011             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms60;
12012             break;
12013          }
12014       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
12015          {
12016             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms64;
12017             break;
12018          }
12019       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
12020          {
12021             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms70;
12022             break;
12023          }
12024       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
12025          {
12026             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms80;
12027             break;
12028          }
12029       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
12030          {
12031             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms128;
12032             break;
12033          }
12034       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
12035          {
12036             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms160;
12037             break;
12038          }
12039       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
12040          {
12041             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms256;
12042             break;
12043          }
12044       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
12045          {
12046             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms320;
12047             break;
12048          }
12049       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
12050          {
12051             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms512;
12052             break;
12053          }
12054       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
12055          {
12056             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms640;
12057             break;
12058          }
12059       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
12060          {
12061             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1024;
12062             break;
12063          }
12064       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
12065          {
12066             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1280;
12067             break;
12068          }
12069       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
12070          {
12071             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2048;
12072             break;
12073          }
12074       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
12075          {
12076             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2560;
12077             break;
12078          }
12079        case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
12080          {
12081             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms5120;
12082             break;
12083          }
12084       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
12085          {
12086             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10240;
12087             break;
12088          }
12089       default :
12090          break;
12091    }
12092 }
12093
12094 /*******************************************************************
12095  *
12096  * @brief Fills drx configuration structure with the help of drx_ConfigRrc
12097  *which recive from CU or storedDrxCfg which is already stored
12098  *
12099  * @details
12100  *
12101  *    Function : extractDrxConfiguration
12102  *
12103  *    Functionality: Fills Reconfig Cell group Info received by CU
12104  *
12105  * @params[in] cuMacCellGrpDrxConfig  = MAC_CellGroupConfig__drx_ConfigRrc information which
12106  *                       is send by CU, which we have stored in F1UeContextSetupDb
12107  *             DrxCfg * drxCfg  = Used to Store the information,
12108  *                      which needs to send in other layer, as well as this can be
12109  *                      the variable which stores the information in DuCb,
12110  *             DrxCfg *storedDrxCfg = Null in case of sending the
12111  *                      information to other layer else it will have the drx information
12112  *                      stored in the copyOfmacUeCfg which we have stored in F1UeContextSetupDb.
12113  *
12114  * @return void
12115  *
12116  * ****************************************************************/
12117 void extractDrxConfiguration(struct MAC_CellGroupConfig__drx_ConfigRrc *cuMacCellGrpDrxConfig, DrxCfg * drxCfg, DrxCfg *storedDrxCfg)
12118 {
12119    struct DRX_ConfigRrc *cuDrxConfig;
12120
12121    if(storedDrxCfg)
12122    {
12123       memcpy(drxCfg, storedDrxCfg, sizeof(DrxCfg));
12124    }
12125    else
12126    {
12127       if(cuMacCellGrpDrxConfig)
12128       {
12129          switch(cuMacCellGrpDrxConfig->present)
12130          {
12131             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
12132                break;
12133
12134             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
12135                {
12136                   cuDrxConfig = cuMacCellGrpDrxConfig->choice.setup;
12137                   if(cuDrxConfig)
12138                   {
12139                      switch(cuDrxConfig->drx_onDurationTimer.present)
12140                      {
12141                         case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
12142                            break;
12143                         case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
12144                            {
12145                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
12146                               drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=convertOnDurationTimerMilliSecondsEnumToValue(cuDrxConfig->\
12147                               drx_onDurationTimer.choice.milliSeconds);
12148                               break;
12149                            }
12150                         case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
12151                            {
12152                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
12153                               drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = cuDrxConfig->drx_onDurationTimer.choice.subMilliSeconds;
12154                               break;
12155                            }
12156                      }
12157                   }
12158                   fillLongCycleOffsetValueInUeDb(&drxCfg->drxLongCycleStartOffset, &cuDrxConfig->drx_LongCycleStartOffset);
12159                   drxCfg->drxInactivityTimer = convertDrxInactivityTimerEnumToValue(cuDrxConfig->drx_InactivityTimer);
12160                   drxCfg->drxHarqRttTimerDl = cuDrxConfig->drx_HARQ_RTT_TimerDL;
12161                   drxCfg->drxHarqRttTimerUl = cuDrxConfig->drx_HARQ_RTT_TimerUL;
12162                   drxCfg->drxRetransmissionTimerDl = convertDrxRetransmissionTimerDlEnumToValue(cuDrxConfig->drx_RetransmissionTimerDL);
12163                   drxCfg->drxRetransmissionTimerUl = convertDrxRetransmissionTimerUlEnumToValue(cuDrxConfig->drx_RetransmissionTimerUL);
12164                   drxCfg->drxSlotOffset = cuDrxConfig->drx_SlotOffset;
12165                   if(cuDrxConfig->shortDRX)
12166                   {
12167                      drxCfg->shortDrxPres=true;
12168                      drxCfg->shortDrx.drxShortCycle = convertShortDrxCycleLengthEnumToValue(cuDrxConfig->shortDRX->drx_ShortCycle);
12169                      drxCfg->shortDrx.drxShortCycleTimer = cuDrxConfig->shortDRX->drx_ShortCycleTimer;
12170                   }
12171                   else
12172                      drxCfg->shortDrxPres=false;
12173
12174                   break;
12175                }
12176
12177             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
12178                break;
12179          }
12180       }
12181    }
12182 }
12183 #endif
12184
12185 /*******************************************************************
12186  *
12187  * @brief Fills Reconfig Cell group Info received by CU
12188  *
12189  * @details
12190  *
12191  *    Function : extractUeReCfgCellInfo
12192  *
12193  *    Functionality: Fills Reconfig Cell group Info received by CU
12194  *
12195  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
12196  *                       is send by CU, which we have stored in F1UeContextSetupDb
12197  *             MacUeCfg *MacUeCfg = Used to Store the information,
12198  *                      which needs to send in other layer, as well as this can be
12199  *                      the variable which stores the information in DuCb,
12200  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12201  *                      information to other layer else it will have copyOfmacUeCfg
12202  *                      which we have stored in F1UeContextSetupDb.
12203  *
12204  * @return ROK/RFAILED
12205  *
12206  * ****************************************************************/
12207 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
12208 {
12209    uint8_t ret = ROK;
12210    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
12211    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
12212    SpCellConfig_t            *spcellCfg = NULLP;
12213    ServingCellConfig_t       *servCellCfg = NULLP;
12214
12215    if(cellGrp)
12216    {
12217       /* Fill MacCell Group Reconfig  */
12218       if(cellGrp->mac_CellGroupConfig)
12219       {
12220          macUeCfg->macCellGrpCfgPres = true;
12221          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
12222
12223 #ifdef NR_DRX
12224          if(macCellGroup->drx_ConfigRrc)
12225          {
12226             if(storedMacUeCfg)
12227             {
12228                if(!storedMacUeCfg->macCellGrpCfgPres)
12229                {
12230                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12231                }
12232                else
12233                {
12234                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg, &storedMacUeCfg->macCellGrpCfg.drxCfg);
12235                }
12236             }
12237             else
12238             {
12239                extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12240             }
12241          }
12242 #endif
12243
12244          if(macCellGroup->schedulingRequestConfig)
12245          {
12246             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
12247          }
12248          if(macCellGroup->tag_Config)
12249          {
12250             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
12251          }
12252          if(macCellGroup->bsr_Config)
12253          {
12254             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
12255             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
12256             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
12257             {
12258                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
12259                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
12260             }
12261          }
12262          if(macCellGroup->phr_Config)
12263          {
12264             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
12265             {
12266                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
12267                if(macCellGroup->phr_Config->choice.setup)
12268                {
12269                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
12270                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
12271                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
12272                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
12273                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
12274                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
12275                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
12276                   macCellGroup->phr_Config->choice.setup->multiplePHR;
12277                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
12278                   macCellGroup->phr_Config->choice.setup->dummy;
12279                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
12280                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
12281                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
12282                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
12283                }
12284             }
12285          }
12286       }
12287       /* Fill Physical Cell Group Reconfig */
12288       if(cellGrp->physicalCellGroupConfig)
12289       {
12290          macUeCfg->phyCellGrpCfgPres = true;
12291          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
12292          if(phyCellGrpCfg->p_NR_FR1)
12293          {
12294             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
12295                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
12296          }
12297          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
12298       }
12299       /* Fill SpCell Reconfig */
12300       if(cellGrp->spCellConfig)
12301       {
12302          macUeCfg->spCellCfgPres = true;
12303          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
12304          if(spcellCfg->servCellIndex)
12305          {
12306             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
12307          }
12308          /* Fill Serving cell Reconfig info */
12309          if(cellGrp->spCellConfig->spCellConfigDedicated)
12310          {
12311             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
12312             if(storedMacUeCfg)
12313             {
12314                if(!storedMacUeCfg->spCellCfgPres)
12315                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12316                else
12317                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
12318                         &storedMacUeCfg->spCellCfg.servCellCfg);
12319             }
12320             else
12321             {
12322                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12323             }
12324             if(ret == RFAILED)
12325             {
12326                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
12327             }
12328          }
12329       }
12330    }
12331    return ret;
12332 }
12333 /*******************************************************************
12334 *
12335 * @brief free the memory allocated by decoder
12336 *
12337 * @details
12338 *
12339 *    Function : freeAperDecodeNrcgi
12340 *
12341 *    Functionality: Free Nrcgi values
12342 *
12343 * @params[in] NRCGI_t *nrcgi
12344 * @return void
12345 *
12346 * ****************************************************************/
12347
12348
12349 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
12350 {
12351     if(nrcgi->pLMN_Identity.buf != NULLP)
12352     {
12353        free(nrcgi->pLMN_Identity.buf);
12354     }
12355     if(nrcgi->nRCellIdentity.buf != NULLP)
12356     {
12357        free(nrcgi->nRCellIdentity.buf);
12358     }
12359 }
12360 /*******************************************************************
12361 *
12362 * @brief free the memory allocated by decoder
12363 *
12364 * @details
12365 *
12366 *    Function : freeAperDecodeCuToDuInfo
12367 *
12368 *    Functionality:  Free Cu To Du Information
12369 *
12370 * @params[in] CUtoDURRCInformation_t *rrcMsg
12371 * @return void
12372 *
12373 * ****************************************************************/
12374
12375
12376 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
12377 {
12378    uint8_t ieIdx =0;
12379    uint8_t arrIdx =0;
12380
12381    if(rrcMsg->uE_CapabilityRAT_ContainerList)
12382    {
12383       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
12384          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
12385       free(rrcMsg->uE_CapabilityRAT_ContainerList);
12386    }
12387
12388    if(rrcMsg->iE_Extensions)
12389    {
12390       if(rrcMsg->iE_Extensions->list.array)
12391       {
12392          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
12393          {
12394             if(rrcMsg->iE_Extensions->list.array[ieIdx])
12395             {
12396                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
12397                {
12398                   case ProtocolIE_ID_id_CellGroupConfig:
12399                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
12400                      {
12401                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
12402                      }
12403                      break;
12404                   default:
12405                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
12406                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
12407                      break;
12408                }
12409             }
12410          }
12411          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
12412          {
12413             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
12414          }
12415          free(rrcMsg->iE_Extensions->list.array);
12416
12417       }
12418
12419       free(rrcMsg->iE_Extensions);
12420    }
12421 }
12422 /*******************************************************************
12423 *
12424 * @brief free the memory allocated by decoder
12425 *
12426 * @details
12427 *
12428 *    Function : freeAperDecodeSplCellList
12429 *
12430 *    Functionality: Free Spl Cell List
12431                     where memory allocated by aper_decoder
12432 *
12433 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
12434 * @return void
12435 *
12436 * ****************************************************************/
12437
12438
12439 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
12440 {
12441     uint8_t  cellIdx =0;
12442
12443     if(spCellLst->list.array != NULLP)
12444     {
12445        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
12446        {
12447           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
12448           {
12449              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
12450           }
12451           if(spCellLst->list.array[cellIdx]!=NULLP)
12452           {
12453              free(spCellLst->list.array[cellIdx]);
12454           }
12455        }
12456        free(spCellLst->list.array);
12457     }
12458 }
12459 /*******************************************************************
12460 *
12461 * @brief free the memory allocated by decoder
12462 *
12463 * @details
12464 *
12465 *    Function : freeAperDecodeSRBSetup
12466 *
12467 *    Functionality: added free part for the memory allocated by aper_decoder
12468 *
12469 * @params[in] SRBs_ToBeSetup_List_t *srbSet
12470 * @return void
12471 *
12472 ****************************************************************/
12473
12474
12475 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
12476 {
12477     uint8_t srbIdx =0;
12478     if(srbSet->list.array != NULLP)
12479     {
12480        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
12481        {
12482           if(srbSet->list.array[srbIdx]!=NULLP)
12483           {
12484              free(srbSet->list.array[srbIdx]);
12485           }
12486        }
12487        free(srbSet->list.array);
12488     }
12489 }
12490
12491 /*******************************************************************
12492 *
12493 * @brief free the memory allocated by decoder
12494 *
12495 * @details
12496 *
12497 *    Function : freeAperDecodeULTnlInfo
12498 *
12499 *    Functionality: added free part for the memory allocated by aper_decoder
12500 *
12501 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12502 * @return void
12503 *
12504 * ****************************************************************/
12505
12506
12507 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12508 {
12509    uint8_t ulIdx=0;
12510    if(ulInfo->list.array != NULLP)
12511    {
12512       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
12513       {
12514          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
12515          {
12516             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
12517             {
12518                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12519                      transportLayerAddress.buf != NULLP)
12520                {
12521                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
12522                         !=NULLP)
12523                   {
12524                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
12525                   }
12526                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12527                         transportLayerAddress.buf);
12528                }
12529                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
12530             }
12531          }
12532          if(ulInfo->list.array[ulIdx]!=NULLP)
12533          {
12534             free(ulInfo->list.array[ulIdx]);
12535          }
12536       }
12537       free(ulInfo->list.array);
12538    }
12539 }
12540 /*******************************************************************
12541 *
12542 * @brief free the memory allocated by decoder
12543 *
12544 * @details
12545 *
12546 *    Function : freeAperDecodeDRBSetup
12547 *
12548 *    Functionality: free DRBSetup which is allocated by decoder
12549 *
12550 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
12551 * @return void
12552 *
12553 * ****************************************************************/
12554
12555 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
12556 {
12557    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
12558    uint8_t  flowIdx =0;
12559    uint8_t  drbIdx =0;
12560
12561    if(drbSet->list.array != NULLP)
12562    {
12563       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
12564       {
12565          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
12566          {
12567             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
12568             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
12569             {
12570                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12571                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
12572                {
12573                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12574                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12575                   {
12576                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12577                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12578                      {
12579
12580                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
12581                         {
12582
12583                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
12584                            {
12585
12586                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
12587                                     buf!=NULLP)
12588                               {
12589
12590                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
12591                                        flows_Mapped_To_DRB_List.list.array != NULLP)
12592                                  {
12593
12594                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12595                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
12596                                     {
12597
12598                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12599                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12600                                        {
12601                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12602                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12603                                                 qoSFlowLevelQoSParameters.\
12604                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
12605                                           {
12606                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12607                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12608                                                    qoSFlowLevelQoSParameters.\
12609                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12610                                              {
12611
12612                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12613                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12614                                                       qoSFlowLevelQoSParameters.\
12615                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12616                                                 {
12617
12618
12619                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12620                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12621                                                          qoSFlowLevelQoSParameters.\
12622                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12623                                                 }
12624
12625                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12626                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12627                                                       qoSFlowLevelQoSParameters.\
12628                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12629                                              }
12630
12631                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12632
12633                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12634                                                    qoSFlowLevelQoSParameters.\
12635                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
12636                                           }
12637                                        }
12638                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12639                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12640                                        {
12641
12642                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12643                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
12644                                        }
12645                                     }
12646
12647                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12648                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
12649                                  }
12650
12651                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12652                                        DRB_Information.sNSSAI.sD->buf);
12653                               }
12654
12655                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
12656                            }
12657
12658                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
12659
12660                         }
12661
12662                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12663
12664                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12665                      }
12666
12667                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12668                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12669                   }
12670
12671                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12672                         qoS_Characteristics.choice.non_Dynamic_5QI);
12673                }
12674                free(drbSetItem->qoSInformation.choice.choice_extension);
12675             }
12676             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
12677             if(drbSetItem->uLConfiguration)
12678             {
12679                free(drbSetItem->uLConfiguration);
12680             }
12681          }
12682          if(drbSet->list.array[drbIdx]!=NULLP)
12683          {
12684             free(drbSet->list.array[drbIdx]);
12685          }
12686       }
12687       free(drbSet->list.array);
12688    }
12689 }
12690
12691
12692 /*******************************************************************
12693  *
12694  * @brief builds Mac Cell Cfg
12695  *
12696  * @details
12697  *
12698  *    Function : procUeReCfgCellInfo
12699  *
12700  *    Functionality: builds Mac Cell Cfg
12701  *
12702  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
12703  *                       needs to send in other layer, as well as this can be
12704  *                       the variable which stores the information in DuCb.
12705  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12706  *                       information to other layer else it will have copyOfmacUeCfg
12707  *                       which we have stored in F1UeContextSetupDb
12708  *             void *cellInfo = CellGroupConfigRrc_t information which is send
12709  *                        by CU, which we have stored in F1UeContextSetupDb
12710  *
12711  * @return void
12712  *
12713  * ****************************************************************/
12714 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, MacUeCfg *storedMacUeCfg, void *cellInfo)
12715 {
12716    uint8_t ret = ROK;
12717    CellGroupConfigRrc_t *cellGrp = NULLP;
12718
12719    if(cellInfo)
12720    {
12721       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
12722       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
12723       if(ret == RFAILED)
12724          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
12725    }
12726    if(ret == RFAILED)
12727    {
12728       freeUeReCfgCellGrpInfo(macUeCfgToSend);
12729    }
12730    return ret;
12731 }
12732
12733 /*******************************************************************
12734  *
12735  * @brief Filling modulation info in mac ue cfg
12736  *
12737  * @details
12738  *
12739  *    Function : duFillModulationDetails
12740  *
12741  *    Functionality: Filling modulation info in mac ue cfg
12742  *
12743  * @params[in] MAC UE Config to be updated
12744  *             Current UE configuration
12745  *             UE NR capability from CU
12746  * @return ROK     - success
12747  *         RFAILED - failure
12748  *
12749  * ****************************************************************/
12750 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
12751 {
12752    UE_NR_Capability_t *ueNrCap=NULLP;
12753
12754    if(!ueCap && oldUeCfg)
12755    {
12756       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12757       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12758    }
12759    else
12760    {
12761       ueNrCap = (UE_NR_Capability_t *)ueCap;
12762
12763       /* Filling DL modulation info */
12764       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
12765          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
12766          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
12767       {
12768          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
12769          {
12770             case ModulationOrder_qpsk:
12771                {
12772                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
12773                   break;
12774                }
12775             case ModulationOrder_qam16:
12776                {
12777                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
12778                   break;
12779                }
12780             case ModulationOrder_qam64:
12781                {
12782                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
12783                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
12784                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
12785                   break;
12786                }
12787             case ModulationOrder_qam256:
12788                {
12789                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
12790                   break;
12791                }
12792             default:
12793                {
12794                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
12795                   if(oldUeCfg)
12796                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12797                   break;
12798                }
12799          }
12800       }
12801       else
12802       {
12803          if(oldUeCfg)
12804             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12805       }
12806
12807       /* Filling UL modulation info */
12808       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
12809          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
12810          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
12811       {
12812          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
12813          {
12814             case ModulationOrder_qpsk:
12815                {
12816                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
12817                   break;
12818                }
12819             case ModulationOrder_qam16:
12820                {
12821                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
12822                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
12823                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
12824                   break;
12825                }
12826             case ModulationOrder_qam64:
12827                {
12828                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
12829                   break;
12830                }
12831             case ModulationOrder_qam256:
12832                {
12833                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
12834                   break;
12835                }
12836             default:
12837                {
12838                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
12839                   if(oldUeCfg)
12840                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12841                   break;
12842                }
12843          }
12844       }
12845       else
12846       {
12847          if(oldUeCfg)
12848             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12849       }
12850    }
12851 }
12852
12853 /*******************************************************************
12854  *
12855  * @brief Function to extract info from CU to DU RRC container extension
12856  *
12857  * @details
12858  *
12859  *    Function : extractCuToDuRrcInfoExt
12860  *
12861  *    Functionality: Function to extract info from CU to DU RRC container
12862  *    extension
12863  *
12864  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
12865  *
12866  * @return ROK
12867  *         RFAILED
12868  *
12869  * ****************************************************************/
12870 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
12871 {
12872    uint8_t ieIdx =0;
12873    uint16_t recvBufLen =0;
12874    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
12875    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
12876    asn_dec_rval_t rval; /* Decoder return value */
12877    memset(&rval, 0, sizeof(asn_dec_rval_t));
12878
12879    if(protocolIeExtn)
12880    {
12881       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
12882       {
12883          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
12884          switch(extIeInfo->id)
12885          {
12886             case ProtocolIE_ID_id_CellGroupConfig:
12887                {
12888                   /* decoding the CellGroup Buf received */
12889                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
12890                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
12891                   if(cellGrpCfg)
12892                   {
12893                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
12894                      rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
12895                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
12896                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12897                      {
12898                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12899                         return RFAILED;
12900                      }
12901                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
12902
12903                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
12904                         return NULLP;
12905                      ueCfgDb->cellGrpCfg = cellGrpCfg;
12906                   }
12907                   break;
12908                }
12909
12910             case ProtocolIE_ID_id_HandoverPreparationInformation:
12911                {
12912                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
12913                   break;
12914                }
12915
12916             default:
12917                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
12918                break;
12919          }
12920       }
12921    }
12922    return ROK;
12923 }
12924
12925 /*******************************************************************
12926  *
12927  * @brief Fills Srb List received by CU
12928  *
12929  * @details
12930  *
12931  *    Function : procSrbListToSetup
12932  *
12933  *    Functionality: Fills Srb List received  by CU
12934  *
12935  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
12936  *             LcCfg pointer
12937  *             RlcBearerCfg pointer
12938  * @return void
12939  *
12940  * ****************************************************************/
12941 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
12942 {
12943
12944    /* Filling RLC INFO */
12945    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
12946
12947    /* Filling MAC INFO */
12948    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
12949    {
12950       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
12951       return RFAILED;
12952    }
12953
12954    return ROK;
12955 }
12956
12957
12958
12959 /*******************************************************************
12960  *
12961  * @brief extract Srb List received by CU
12962  *
12963  * @details
12964  *
12965  *    Function : extractSrbListToSetup
12966  *
12967  *    Functionality: extract Srb List received by CU
12968  *                   for both MAC and RLC
12969  *
12970  * @params[in] SRBs_ToBeSetup_Item_t pointer
12971  *             DuUeCfg pointer
12972  * @return ROK/RFAIED
12973  *
12974  * ****************************************************************/
12975
12976 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
12977 {
12978    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
12979    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
12980    LcCfg *macLcCtxt = NULLP;
12981    RlcBearerCfg *rlcLcCtxt = NULLP;
12982
12983    if(srbCfg)
12984    {
12985       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
12986       {
12987          macLcCtxt = NULL;
12988          rlcLcCtxt = NULL;
12989
12990          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
12991          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
12992          {
12993             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
12994             ret = RFAILED;
12995             break;
12996          }
12997          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
12998          {
12999             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
13000             ret = RFAILED;
13001             break;
13002          }
13003
13004          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
13005          {
13006             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
13007             {
13008                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13009                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13010                break;
13011             }
13012          }
13013          if(!macLcCtxt)
13014          {
13015             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
13016             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13017             ueCfgDb->numMacLcs++;
13018          }
13019          if(!rlcLcCtxt)
13020          {
13021             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13022             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13023             ueCfgDb->numRlcLcs++;
13024          }
13025
13026          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
13027
13028          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13029                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13030          if(ret == RFAILED)
13031          {
13032             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
13033             break;
13034          }
13035       }
13036    }
13037    else
13038       ret = RFAILED;
13039
13040    return ret;
13041 }
13042
13043 /*******************************************************************
13044  *
13045  * @brief Fills Drb List received by CU
13046  *
13047  * @details
13048  *
13049  *    Function : procDrbListToSetupMod
13050  *
13051  *    Functionality: Fills Drb List received by CU
13052  *                   for both MAC and RLC
13053  *
13054  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
13055  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
13056  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
13057  * @return void
13058  *
13059  * ****************************************************************/
13060
13061 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
13062 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
13063 {
13064    uint8_t cfgIdx = 0;
13065    RlcMode rlcModeInfo;
13066
13067    if(drbItem != NULLP)
13068    {
13069       /* Filling RLC INFO */
13070       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
13071       qoSInformation);
13072
13073       /* Filling MAC INFO */
13074       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13075       {
13076          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13077          return RFAILED;
13078       }
13079    }
13080    else if(drbSetupModItem != NULLP)
13081    {
13082       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
13083       &drbSetupModItem->qoSInformation);
13084
13085       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13086       {
13087          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13088          return RFAILED;
13089       }
13090    }
13091    else if(drbModItem != NULLP)
13092    {
13093       /* Drb to Mod IEs doesnot have rlcMode to be modified
13094        * in ASN. Hence no change in RLC configurations */
13095       if(storedRlcUeCfg != NULLP)
13096       {
13097          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
13098          {
13099             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
13100             {
13101                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
13102                break;
13103             }
13104          }
13105       }
13106
13107       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
13108       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
13109       {
13110          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13111          return RFAILED;
13112       }
13113    }
13114    return ROK;
13115 }
13116
13117 /*******************************************************************
13118  *
13119  * @brief extract Drb List received by CU
13120  *
13121  * @details
13122  *
13123  *    Function : extractDrbListToSetupMod
13124  *
13125  *    Functionality: extract Drb List received by CU
13126  *                   for both MAC and RLC
13127  *
13128  * @params[in] DRBs_ToBeSetup_Item_t pointer
13129  *             DuUeCfg pointer
13130  * @return ROK/RFAIED
13131  *
13132  * ****************************************************************/
13133
13134 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
13135  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
13136 {
13137    uint8_t ret = ROK;
13138    uint8_t drbIdx = 0, rlcLcIdx = 0;
13139    uint8_t drbId = 0, lcId = 0;
13140    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
13141    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
13142    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
13143    LcCfg *macLcCtxt = NULLP;
13144    RlcBearerCfg *rlcLcCtxt = NULLP;
13145
13146    ret = ROK;
13147    if(drbCount > 0)
13148    {
13149       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13150       {
13151          macLcCtxt = NULL;
13152          rlcLcCtxt = NULL;
13153
13154          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13155          {
13156             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
13157             ret = RFAILED;
13158             break;
13159          }
13160          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13161          {
13162             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
13163             ret = RFAILED;
13164             break;
13165          }
13166
13167          if(drbModCfg != NULLP)
13168          {
13169             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
13170             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
13171          }
13172          else if(drbCfg != NULLP)
13173             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
13174          else if(drbSetupModCfg != NULL)
13175          {
13176             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
13177             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
13178          }
13179
13180          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13181          {
13182             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
13183             {
13184                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13185                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13186                break;
13187             }
13188          }
13189          if(!macLcCtxt)
13190          {
13191             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
13192             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13193             ueCfgDb->numMacLcs++;
13194          }
13195          if(!rlcLcCtxt)
13196          {
13197             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13198             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13199             ueCfgDb->numRlcLcs++;
13200          }
13201
13202          if(drbModCfg != NULLP)
13203          {
13204             lcId = fetchLcId(drbId);
13205             if(lcId < MIN_DRB_LCID)
13206             {
13207                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
13208                break;
13209             }
13210             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
13211             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13212             if(ret == RFAILED)
13213             {
13214                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
13215                break;
13216             }
13217          }
13218          else
13219          {
13220             lcId = getDrbLcId(drbBitMap);
13221             if(lcId == RFAILED)
13222             {
13223                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
13224                ret = RFAILED;
13225                break;
13226             }
13227             if(drbCfg != NULL)
13228             {
13229                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
13230                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13231                if(ret == RFAILED)
13232                {
13233                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
13234                   break;
13235                }
13236             }
13237             else if(drbSetupModCfg != NULL)
13238             {
13239                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
13240                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13241                if(ret == RFAILED)
13242                {
13243                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
13244                   break;
13245                }
13246                ueCfgDb->numDrbSetupMod++;
13247             }
13248          }
13249          ueCfgDb->numDrb++;
13250
13251          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13252                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13253          if(ret == RFAILED)
13254          {
13255             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
13256             break;
13257          }
13258       }
13259    }
13260    else
13261       ret = RFAILED;
13262
13263    return ret;
13264 }
13265
13266 /*******************************************************************
13267  *
13268  * @brief Function to extract Dl RRC Msg received from CU
13269  *
13270  * @details
13271  *
13272  *    Function : extractDlRrcMsg
13273  *
13274  *    Functionality: Function to extract Dl RRC Msg received from CU
13275  *
13276  * @params[in] F1AP message
13277  * @return ROK     - success
13278  *         RFAILED - failure
13279  *
13280  * ****************************************************************/
13281
13282 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
13283    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
13284 {
13285    uint8_t ret = ROK;
13286    dlRrcMsg->rrcMsgSize = rrcContainer->size;
13287    if(dlRrcMsg->rrcMsgSize > 0)
13288    {
13289       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
13290       if(!dlRrcMsg->rrcMsgPdu)
13291       {
13292          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
13293          ret = RFAILED;
13294       }
13295       else
13296       {
13297          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
13298          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
13299          dlRrcMsg->srbId = SRB1_LCID;
13300          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
13301       }
13302    }
13303    return ret;
13304 }
13305
13306 /*******************************************************************
13307  *
13308  * @brief Extract UE capability info
13309  *
13310  * @details
13311  *
13312  *    Function : extractUeCapability
13313  *
13314  *    Functionality: Extract UE capability info and stores in ue Cb
13315  *
13316  * @params[in] Octet string of UE capability RAT container list
13317  * @return ROK     - success
13318  *         RFAILED - failure
13319  *
13320  * ****************************************************************/
13321 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
13322 {
13323    uint8_t  idx;
13324    uint16_t recvBufLen;
13325    asn_dec_rval_t rval;
13326    UE_NR_Capability_t  *ueNrCap = NULLP;
13327    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
13328
13329    /* Decoding UE Capability RAT Container List */
13330    recvBufLen = ueCapablityListBuf->size;
13331    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13332    if(!ueCapRatContList)
13333    {
13334       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13335       return NULLP;
13336    }
13337    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13338    memset(&rval, 0, sizeof(asn_dec_rval_t));
13339    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
13340           ueCapablityListBuf->buf, recvBufLen, 0, 0);
13341    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13342    {
13343       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13344       return NULLP;
13345    }
13346    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
13347
13348    /* Free encoded buffer after decoding */
13349
13350    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
13351    {
13352       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
13353       {
13354          /* Decoding UE NR Capability */
13355           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
13356           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
13357           if(!ueNrCap)
13358           {
13359              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13360              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13361              return NULLP;
13362           }
13363           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
13364           memset(&rval, 0, sizeof(asn_dec_rval_t));
13365           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
13366                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
13367           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13368           {
13369              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13370              return NULLP;
13371           }
13372           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
13373
13374           /* Free encoded buffer after decoding */
13375           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
13376       }
13377       free(ueCapRatContList->list.array[idx]);
13378    }
13379
13380    /* Free Memory*/
13381    free(ueCapRatContList->list.array);
13382    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13383    return ueNrCap;
13384 }
13385
13386 /*******************************************************************
13387 *
13388 * @brief free UE context setup request from CU
13389 *
13390 * @details
13391 *
13392 *    Function : freeAperDecodeF1UeContextSetupReq
13393 *
13394 *    Functionality: freeing part for the memory allocated by aper_decoder
13395 *
13396 * @params[in] F1AP message
13397 * @return ROK     - success
13398 *         RFAILED - failure
13399 *
13400 * ****************************************************************/
13401 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
13402 {
13403    uint8_t ieIdx = 0;
13404
13405    if(ueSetReq->protocolIEs.list.array != NULLP)
13406    {
13407       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
13408       {
13409          if(ueSetReq->protocolIEs.list.array[ieIdx])
13410          {
13411             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13412             {
13413                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13414                   break;
13415                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13416                   break;
13417                case ProtocolIE_ID_id_SpCell_ID:
13418                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
13419                   break;
13420                case ProtocolIE_ID_id_ServCellIndex:
13421                   break;
13422                case ProtocolIE_ID_id_SpCellULConfigured:
13423                   break;
13424                case ProtocolIE_ID_id_CUtoDURRCInformation:
13425
13426                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
13427                   break;
13428                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
13429
13430                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
13431                   break;
13432                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13433
13434                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
13435                   break;
13436                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13437
13438                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
13439                   break;
13440                case ProtocolIE_ID_id_RRCContainer:
13441                   {
13442
13443                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
13444                      {
13445
13446                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13447                      }
13448                      break;
13449                   }
13450                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13451                   break;
13452                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13453                   {
13454                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
13455                      {
13456                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
13457                      }
13458                      break;
13459                   }
13460 #ifdef NR_DRX
13461                case ProtocolIE_ID_id_DRXCycle:
13462                   {
13463                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength)
13464                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength);
13465                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer)
13466                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer);
13467                      break;
13468                   }
13469 #endif
13470                 default:
13471                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
13472             }
13473             free(ueSetReq->protocolIEs.list.array[ieIdx]);
13474          }
13475       }
13476       free(ueSetReq->protocolIEs.list.array);
13477    }
13478 }
13479 /*******************************************************************
13480  *
13481  * @brief Process UE context setup request from CU
13482  *
13483  * @details
13484  *
13485  *    Function : procF1UeContextSetupReq
13486  *
13487  *    Functionality: Process UE context setup request from CU
13488  *
13489  * @params[in] F1AP message
13490  * @return ROK     - success
13491  *         RFAILED - failure
13492  *
13493  * ****************************************************************/
13494 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
13495 {
13496    int8_t ueIdx = -1;
13497    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0, servCellIdx = 0;
13498    bool ueCbFound = false, hoInProgress = false;
13499    uint16_t cellIdx=0;
13500    uint64_t nrCellId = 0;
13501    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
13502    DuUeCb   *duUeCb = NULL;
13503    UEContextSetupRequest_t   *ueSetReq = NULL;
13504    DRBs_ToBeSetup_List_t *drbCfg = NULL;
13505    CUtoDURRCInformation_t *rrcInfo = NULL;
13506    DRXCycle_t *drxCycle;
13507
13508    ret = ROK;
13509
13510    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
13511    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13512    {
13513       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13514       {
13515          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13516             {
13517                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13518                break;
13519             }
13520
13521          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13522             {
13523                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13524                break;
13525             }
13526
13527          case ProtocolIE_ID_id_SpCell_ID:
13528             {
13529                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
13530
13531                GET_CELL_IDX(nrCellId, cellIdx);
13532                if(!duCb.actvCellLst[cellIdx])
13533                {
13534                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%lu] not found", nrCellId);
13535                   ret = RFAILED;
13536                }
13537                break;
13538             }
13539
13540          case ProtocolIE_ID_id_ServCellIndex:
13541             {
13542                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
13543                break;
13544             }
13545
13546          case ProtocolIE_ID_id_SpCellULConfigured:
13547             {
13548                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
13549                   UL, SUL or UL+SUL for the indicated cell for the UE */
13550                break;
13551             }
13552
13553          case ProtocolIE_ID_id_CUtoDURRCInformation:
13554             {
13555                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
13556
13557                /* Search if UE context is present */
13558                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13559                {
13560                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
13561                   {
13562                      ueCbFound = true;
13563                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13564                      break;
13565                   }
13566                }
13567
13568                /* Check if UE Handover scenario */
13569                if(rrcInfo->iE_Extensions)
13570                {
13571                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
13572                   {
13573                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
13574                      {
13575                         hoInProgress = true;
13576                         break;
13577                      }
13578                   }
13579                }
13580
13581                /* If UE context is not present, but UE is in handover */
13582                if(!ueCbFound && hoInProgress)
13583                {
13584                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
13585                   if(ueIdx != -1)
13586                      gnbDuUeF1apId = ueIdx +1;
13587                   else
13588                   {
13589                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
13590                      ret = RFAILED;
13591                      break;
13592                   }
13593                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13594                   duUeCb->f1UeDb = NULL;
13595                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
13596                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
13597                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
13598                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
13599                }
13600
13601                if(duUeCb)
13602                {
13603                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13604                   if(duUeCb->f1UeDb)
13605                   {
13606                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13607                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
13608                      duUeCb->f1UeDb->cellIdx = cellIdx;
13609                   }
13610                   else
13611                   {
13612                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
13613                      ret = RFAILED;
13614                      break;
13615                   }
13616                }
13617                else
13618                {
13619                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13620                   ret = RFAILED;
13621                   break;
13622                }
13623
13624                /* Extract UE capability info */
13625                if(rrcInfo->uE_CapabilityRAT_ContainerList)
13626                {
13627                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
13628                }
13629
13630                /* Extract IE extension */
13631                if(rrcInfo->iE_Extensions)
13632                {
13633                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
13634                   {
13635                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
13636                      //TODO: Update the failure cause in ue context Setup Response
13637                      ret = RFAILED;
13638                   }
13639                }
13640                break;
13641             }
13642
13643 #ifdef NR_DRX
13644          case ProtocolIE_ID_id_DRXCycle:
13645             {
13646                duUeCb->f1UeDb->duUeCfg.drxCyclePres = true;
13647                drxCycle = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle;
13648                duUeCb->f1UeDb->duUeCfg.drxCycle.drxLongCycleLength =  convertLongDrxCycleLengthEnumToValue(drxCycle->longDRXCycleLength);
13649                if(drxCycle->shortDRXCycleLength)
13650                {
13651                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCyclePres = true;
13652                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycle = \
13653                   convertShortDrxCycleLengthEnumToValue(*(drxCycle->shortDRXCycleLength));
13654                }
13655                if(drxCycle->shortDRXCycleTimer)
13656                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycleTimer = *(drxCycle->shortDRXCycleTimer);
13657
13658                break;
13659             }
13660
13661 #endif
13662          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13663             {
13664                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
13665                         &duUeCb->f1UeDb->duUeCfg))
13666                {
13667                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
13668                   //TODO: Update the failure cause in ue context Setup Response
13669                   ret = RFAILED;
13670                }
13671                break;
13672             }
13673
13674          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13675             {
13676                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
13677
13678                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
13679                {
13680                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
13681                   //TODO: Update the failure cause in ue context Setup Response
13682                   ret = RFAILED;
13683                }
13684                break;
13685             }
13686          case ProtocolIE_ID_id_RRCContainer:
13687             {
13688                /* Filling Dl RRC Msg Info */
13689                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13690                if(!duUeCb->f1UeDb->dlRrcMsg)
13691                {
13692                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
13693                   ret = RFAILED;
13694                }
13695                else
13696                {
13697                   duUeCb->f1UeDb->dlRrcMsgPres = true;
13698                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13699                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13700                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
13701                }
13702                break;
13703             }
13704
13705          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13706             {
13707                if(duUeCb->f1UeDb->dlRrcMsg)
13708                {
13709                   if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
13710                   {
13711                      duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
13712                   }
13713                   else
13714                   {
13715                      DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
13716                   }
13717                }
13718                break;
13719             }
13720
13721          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13722             {
13723                /* MaximumBitRate Uplink */
13724                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
13725                if(bitRateSize > 0)
13726                {
13727                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
13728                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
13729                   {
13730                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
13731                      ret = RFAILED;
13732                   }
13733                   else
13734                   {
13735                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
13736                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
13737                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
13738                   }
13739                }
13740                else
13741                   ret = RFAILED;
13742                break;
13743             }
13744
13745          default:
13746             {
13747                break;
13748             }
13749       } /* End of switch */
13750
13751       /* In case of any failure in any IE */
13752       if(ret == RFAILED)
13753       {
13754          // BuildAndSendUeContextSetupRsp(cellId,ueId);
13755          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
13756          break;
13757       }
13758    } /* End of for loop of IEs */
13759
13760    if(ret == ROK)
13761       ret = duProcUeContextSetupRequest(duUeCb);
13762
13763    freeAperDecodeF1UeContextSetupReq(ueSetReq);
13764    return ret;
13765
13766 }
13767 /*******************************************************************
13768  * @brief Free the memory allocated for Dl Tunnel Info
13769  *
13770  * @details
13771  *
13772  *    Function : freeDlTnlInfo
13773  *
13774  *    Functionality:
13775  *       Free the memory allocated for Dl Tunnel Info
13776  *
13777  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
13778  * @return void
13779  *
13780  * ****************************************************************/
13781
13782 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
13783 {
13784    uint8_t arrIdx = 0;
13785
13786    if(tnlInfo)
13787    {
13788       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
13789       {
13790          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
13791                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
13792          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
13793                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
13794          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13795          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13796       }
13797       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
13798    }
13799 }
13800
13801 /*******************************************************************
13802  * @brief Free the memory allocated for DRB setup List
13803  *
13804  * @details
13805  *
13806  *    Function : freeDrbSetupList
13807  *
13808  *    Functionality:
13809  *       Free the memory allocated for DRB setup list
13810  *
13811  * @params[in] DRBs_Setup_List_t *
13812  * @return void
13813  *
13814  * ****************************************************************/
13815 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
13816 {
13817    uint8_t arrIdx = 0;
13818    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13819
13820    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13821    {
13822       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13823       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
13824       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
13825    }
13826    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13827 }
13828
13829 /*******************************************************************
13830  * @brief Free the memory allocated for UE Setup response
13831  *
13832  * @details
13833  *
13834  *    Function : FreeUeContextSetupRsp
13835  *
13836  *    Functionality:
13837  *       Free the memory allocated for UE Setup response
13838  *
13839  * @params[in] F1AP PDU for UE setup response
13840  * @return ROK     - success
13841  *         RFAILED - failure
13842  *
13843  * ****************************************************************/
13844 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
13845 {
13846    uint8_t idx;
13847    UEContextSetupResponse_t *ueSetRsp = NULLP;
13848
13849    if(f1apMsg)
13850    {
13851       if(f1apMsg->choice.successfulOutcome)
13852       {
13853          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
13854                     UEContextSetupResponse;
13855          if(ueSetRsp->protocolIEs.list.array)
13856          {
13857             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
13858             {
13859                if(ueSetRsp->protocolIEs.list.array[idx])
13860                {
13861                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
13862                   {
13863                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13864                         break;
13865                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13866                         break;
13867                      case ProtocolIE_ID_id_C_RNTI:
13868                         break;
13869                      case ProtocolIE_ID_id_DUtoCURRCInformation:
13870                         {
13871                            CellGroupConfig_t *cellGrpCfg = NULLP;
13872                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
13873                                          DUtoCURRCInformation.cellGroupConfig;
13874                            if(cellGrpCfg->buf != NULLP)
13875                            {
13876                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
13877                               cellGrpCfg = NULLP;
13878                            }
13879                            break;
13880                         }
13881                      case ProtocolIE_ID_id_DRBs_Setup_List:
13882                         {
13883                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
13884                            break;
13885                         }
13886                      default:
13887                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
13888                               ueSetRsp->protocolIEs.list.array[idx]->id);
13889                         break;
13890                   }
13891                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
13892                         sizeof(UEContextSetupResponseIEs_t));
13893                }
13894             }
13895             DU_FREE(ueSetRsp->protocolIEs.list.array, \
13896                   ueSetRsp->protocolIEs.list.size);
13897          }
13898          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13899       }
13900       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13901    }
13902 }
13903
13904 /*******************************************************************
13905  *
13906  * @brief Builds Ue context Setup Rsp DU To CU Info
13907  *
13908  * @details
13909  *
13910  *    Function : EncodeUeCntxtDuToCuInfo
13911  *
13912  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
13913  *
13914  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
13915  *
13916  * @return ROK     - success
13917  *         RFAILED - failure
13918  *
13919  ******************************************************************/
13920
13921 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
13922 {
13923    asn_enc_rval_t        encRetVal;
13924
13925    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
13926    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
13927    encBufSize = 0;
13928    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
13929    /* Encode results */
13930    if(encRetVal.encoded == ENCODE_FAIL)
13931    {
13932       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
13933             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13934       return RFAILED;
13935    }
13936    else
13937    {
13938       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
13939 #ifdef DEBUG_ASN_PRINT
13940       for(int i=0; i< encBufSize; i++)
13941       {
13942          printf("%x",encBuf[i]);
13943       }
13944 #endif
13945    }
13946    duToCuCellGrp->size = encBufSize;
13947    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
13948    if(!duToCuCellGrp->buf)
13949    {
13950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
13951    }
13952    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
13953    return ROK;
13954 }
13955
13956 /*******************************************************************
13957  *
13958  * @brief Fills Dl Gtp tunnel Info
13959  *
13960  * @details
13961  *
13962  *    Function : fillGtpTunnelforDl
13963  *
13964  *    Functionality: Fills Dl Gtp tunnel Info
13965  *
13966  * @params[in]
13967  *
13968  * @return ROK     - success
13969  *         RFAILED - failure
13970  *
13971  * ****************************************************************/
13972
13973 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
13974 {
13975    uint8_t bufSize = 0;
13976
13977    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
13978    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
13979    if(gtpDl->transportLayerAddress.buf == NULLP)
13980    {
13981       return RFAILED;
13982    }
13983    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
13984
13985    /*GTP TEID*/
13986    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
13987    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
13988    if(gtpDl->gTP_TEID.buf == NULLP)
13989    {
13990       return RFAILED;
13991    }
13992    bufSize = 3; /*forming an Octect String*/
13993    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
13994
13995    return ROK;
13996 }
13997
13998 /*******************************************************************
13999  *
14000  * @brief Fills DL Tunnel Setup List
14001  *
14002  * @details
14003  *
14004  *    Function : fillDlTnlSetupList
14005  *
14006  *    Functionality: Fills the DL Tunnel Setup List
14007  *
14008  * @params[in]
14009  *
14010  * @return ROK     - success
14011  *         RFAILED - failure
14012  *
14013  * ****************************************************************/
14014
14015 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
14016 {
14017    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14018
14019    eleCount = 1;
14020    dlTnlInfo->list.count = eleCount;
14021    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
14022
14023    /* Initialize the DL Tnl Setup List Members */
14024    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
14025    if(dlTnlInfo->list.array == NULLP)
14026    {
14027       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
14028       ret = RFAILED;
14029    }
14030    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14031    {
14032       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14033       if(dlTnlInfo->list.array[arrIdx] == NULLP)
14034       {
14035          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
14036          return RFAILED;
14037       }
14038       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
14039       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14040       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
14041       {
14042          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
14043          return RFAILED;
14044       }
14045       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
14046                tnlCfg->tnlCfg1);
14047       if(ret != ROK)
14048          break;
14049    }
14050    return ret;
14051 }
14052
14053 /*******************************************************************
14054  *
14055  * @brief Fills the Drb Setup List for Ue Context Setup Response
14056  *
14057  * @details
14058  *
14059  *    Function : fillDrbSetupList
14060  *
14061  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
14062  *
14063  * @params[in]
14064  *
14065  * @return ROK     - success
14066  *         RFAILED - failure
14067  *
14068  * ****************************************************************/
14069 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
14070 {
14071    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14072    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14073
14074    eleCount = ueCfg->numDrb;
14075    drbSetupList->list.count = eleCount;
14076    drbSetupList->list.size = \
14077         (eleCount * sizeof(DRBs_Setup_Item_t *));
14078
14079    /* Initialize the Drb Setup List Members */
14080    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
14081    if(drbSetupList->list.array == NULLP)
14082    {
14083       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
14084       ret = RFAILED;
14085    }
14086
14087    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14088    {
14089       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
14090       if(drbSetupList->list.array[arrIdx] == NULLP)
14091       {
14092          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
14093          return RFAILED;
14094       }
14095       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14096       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
14097       drbItemIe->criticality = Criticality_reject;
14098       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
14099       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14100       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
14101           &ueCfg->upTnlInfo[arrIdx]);
14102       if(ret != ROK)
14103          break;
14104    }
14105    return ret;
14106 }
14107
14108 /*******************************************************************
14109  *
14110  * @brief Builds and sends the UE Setup Response
14111  *
14112  * @details
14113  *
14114  *    Function : BuildAndSendUeContextSetupRsp
14115  *
14116  *    Functionality: Constructs the UE Setup Response and sends
14117  *                   it to the DU through SCTP.
14118  *
14119  * @params[in] uint8_t cellId,uint8_t ueId
14120  *
14121  * @return ROK     - success
14122  *         RFAILED - failure
14123  *
14124  * ****************************************************************/
14125 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
14126 {
14127    uint8_t   idx, ret, cellIdx, elementCnt;
14128    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
14129    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
14130    asn_enc_rval_t  encRetVal;        /* Encoder return value */
14131    F1AP_PDU_t               *f1apMsg = NULLP;
14132    UEContextSetupResponse_t *ueSetRsp = NULLP;
14133    DuUeCb                   *ueCb = NULLP;
14134
14135    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
14136
14137    while(true)
14138    {
14139       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14140       if(f1apMsg == NULLP)
14141       {
14142          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14143          ret = RFAILED;
14144          break;
14145       }
14146
14147       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14148       DU_ALLOC(f1apMsg->choice.successfulOutcome,
14149             sizeof(SuccessfulOutcome_t));
14150       if(f1apMsg->choice.successfulOutcome == NULLP)
14151       {
14152          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
14153          ret = RFAILED;
14154          break;
14155       }
14156
14157       f1apMsg->choice.successfulOutcome->procedureCode = \
14158                                                          ProcedureCode_id_UEContextSetup;
14159       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14160       f1apMsg->choice.successfulOutcome->value.present = \
14161                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
14162
14163       ueSetRsp =
14164          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
14165       elementCnt = 5;
14166       ueSetRsp->protocolIEs.list.count = elementCnt;
14167       ueSetRsp->protocolIEs.list.size = \
14168                                         elementCnt * sizeof(UEContextSetupResponse_t *);
14169
14170       /* Initialize the UESetup members */
14171       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
14172             ueSetRsp->protocolIEs.list.size);
14173       if(ueSetRsp->protocolIEs.list.array == NULLP)
14174       {
14175          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14176          ret = RFAILED;
14177          break;
14178       }
14179
14180       for(idx=0; idx<elementCnt; idx++)
14181       {
14182          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
14183                sizeof(UEContextSetupResponseIEs_t));
14184          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
14185          {
14186             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14187             ret = RFAILED;
14188             break;
14189          }
14190       }
14191       /* Fetching Ue Cb Info*/
14192       GET_CELL_IDX(cellId, cellIdx);
14193       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14194       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14195       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
14196
14197       idx = 0;
14198       /*GNB CU UE F1AP ID*/
14199       ueSetRsp->protocolIEs.list.array[idx]->id = \
14200                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14201       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14202       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14203                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14204       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14205
14206       /*GNB DU UE F1AP ID*/
14207       idx++;
14208       ueSetRsp->protocolIEs.list.array[idx]->id = \
14209                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14210       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14211       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14212                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14213       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14214
14215
14216       /*DUtoCURRC Information */
14217       idx++;
14218       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14219                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
14220       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14221       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14222                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
14223       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14224
14225       /* CRNTI */
14226       idx++;
14227       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
14228       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14229       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
14230       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
14231
14232
14233       /* Drb Setup List */
14234       idx++;
14235       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14236                                                    ProtocolIE_ID_id_DRBs_Setup_List;
14237       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14238       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14239                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
14240       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
14241             &ueCb->f1UeDb->duUeCfg);
14242       if(ret == RFAILED)
14243       {
14244          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
14245          freeF1UeDb(ueCb->f1UeDb);
14246          ueCb->f1UeDb = NULLP;
14247          break;
14248       }
14249
14250       /* Free UeContext Db created during Ue context Req */
14251       freeF1UeDb(ueCb->f1UeDb);
14252       ueCb->f1UeDb = NULLP;
14253
14254       /* TODO: To send Drb list */
14255       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14256
14257       /* Encode the UE context setup response type as APER */
14258       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14259       encBufSize = 0;
14260       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14261             encBuf);
14262       /* Encode results */
14263       if(encRetVal.encoded == ENCODE_FAIL)
14264       {
14265          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
14266                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14267          ret = RFAILED;
14268          break;
14269       }
14270       else
14271       {
14272          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
14273 #ifdef DEBUG_ASN_PRINT
14274          for(int i=0; i< encBufSize; i++)
14275          {
14276             printf("%x",encBuf[i]);
14277          }
14278 #endif
14279       }
14280
14281       /* Sending  msg  */
14282       if(sendF1APMsg()  != ROK)
14283       {
14284          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
14285          ret = RFAILED;
14286          break;
14287       }
14288       break;
14289    }
14290    FreeUeContextSetupRsp(f1apMsg);
14291    return ret;
14292 }/* End of BuildAndSendUeContextSetupRsp */
14293 /*******************************************************************
14294 *
14295 * @brief  Build And Send Ue Context Rsp
14296 *
14297 * @details
14298 *
14299 *    Function : BuildAndSendUeCtxtRsp
14300 *
14301 *    Functionality : Build And Send Ue Context Rsp
14302
14303 * @params[in]
14304 * @return sucess = ROK
14305 *         failure = RFAILED
14306 *
14307 * ****************************************************************/
14308 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
14309 {
14310    uint8_t cellIdx = 0, actionType = 0;
14311
14312    GET_CELL_IDX(cellId, cellIdx);
14313    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
14314
14315    switch(actionType)
14316    {
14317       case UE_CTXT_SETUP:
14318          {
14319             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
14320             {
14321                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
14322                return RFAILED;
14323             }
14324             break;
14325          }
14326       case UE_CTXT_MOD:
14327          {
14328             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
14329             {
14330                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
14331                return RFAILED;
14332             }
14333             break;
14334          }
14335       default:
14336          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
14337          break;
14338
14339    }
14340    return ROK;
14341 }
14342
14343 /*******************************************************************
14344  *
14345  * @brief deallocating the memory of  F1reset msg
14346  *
14347  * @details
14348  *
14349  *    Function : FreeF1ResetReq
14350  *
14351  *    Functionality :
14352  *         - freeing memory of F1reset request msg
14353  *
14354  * @params[in]
14355  * @return void
14356  *
14357  *
14358  * ****************************************************************/
14359 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
14360 {
14361    uint8_t idx =0 ;
14362    Reset_t *f1ResetMsg;
14363
14364    if(f1apMsg)
14365    {
14366       if(f1apMsg->choice.initiatingMessage)
14367       {
14368          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14369
14370          if(f1ResetMsg->protocolIEs.list.array)
14371          {
14372             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
14373             {
14374                if(f1ResetMsg->protocolIEs.list.array[idx])
14375                {
14376                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14377                }
14378             }
14379             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14380          }
14381          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14382       }
14383       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14384    }
14385 }
14386 /*******************************************************************
14387  *
14388  * @brief Build and Send F1reset request
14389  *
14390  * @details
14391  *
14392  *    Function : BuildAndSendF1ResetReq
14393  *
14394  *    Functionality:
14395  *         - Build and Send F1reset request msg
14396  *
14397  * @params[in]
14398  * @return ROK     - success
14399  *         RFAILED - failure
14400  *
14401  * ****************************************************************/
14402 uint8_t BuildAndSendF1ResetReq()
14403 {
14404    uint8_t          elementCnt=0;
14405    uint8_t          idx=0;
14406    uint8_t          ret= RFAILED;
14407    Reset_t          *f1ResetMsg = NULLP;
14408    F1AP_PDU_t       *f1apMsg = NULLP;
14409    asn_enc_rval_t   encRetVal;
14410    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
14411    do
14412    {
14413       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14414       if(f1apMsg == NULLP)
14415       {
14416          break;
14417       }
14418       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14419       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14420       if(f1apMsg->choice.initiatingMessage == NULLP)
14421       {
14422          break;
14423       }
14424       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
14425       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14426       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
14427
14428       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14429
14430       elementCnt = 3;
14431       f1ResetMsg->protocolIEs.list.count = elementCnt;
14432       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
14433
14434       /* Initialize the F1Setup members */
14435       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14436       if(f1ResetMsg->protocolIEs.list.array == NULLP)
14437       {
14438          break;
14439       }
14440       for(idx=0; idx<elementCnt; idx++)
14441       {
14442          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14443          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
14444          {
14445             break;
14446          }
14447       }
14448
14449       /*TransactionID*/
14450       idx=0;
14451       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14452       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14453       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
14454       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
14455
14456       /*Cause*/
14457       idx++;
14458       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
14459       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
14460       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
14461       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
14462       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
14463
14464       /*Reset Type*/
14465       idx++;
14466       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
14467       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14468       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
14469       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
14470       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
14471
14472       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14473
14474       /* Encode the F1SetupRequest type as APER */
14475       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14476       encBufSize = 0;
14477       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14478             encBuf);
14479
14480       /* Encode results */
14481       if(encRetVal.encoded == ENCODE_FAIL)
14482       {
14483          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
14484                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14485          break;
14486       }
14487       else
14488       {
14489          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
14490 #ifdef DEBUG_ASN_PRINT
14491          for(idx=0; idx< encBufSize; idx++)
14492          {
14493             printf("%x",encBuf[idx]);
14494          }
14495 #endif
14496       }
14497
14498       if(sendF1APMsg() != ROK)
14499       {
14500          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
14501          break;
14502       }
14503
14504       ret = ROK;
14505       break;
14506    }while(true);
14507
14508    FreeF1ResetReq(f1apMsg);
14509    return ret;
14510 }
14511 /*******************************************************************
14512  *
14513  * @brief Build And Send F1ResetAck
14514  *
14515  * @details
14516  *
14517  *    Function : BuildAndSendF1ResetAck
14518  *
14519  *    Functionality:
14520  *         - Build And Send  F1ResetRSP
14521  *
14522  * @return ROK     - success
14523  *         RFAILED - failure
14524  *
14525  * ****************************************************************/
14526 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
14527 {
14528    uint8_t idx;
14529    ResetAcknowledge_t *f1ResetAck;
14530
14531    if(f1apMsg)
14532    {
14533       if(f1apMsg->choice.successfulOutcome)
14534       {
14535          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14536
14537          if(f1ResetAck->protocolIEs.list.array)
14538          {
14539             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
14540             {
14541                if(f1ResetAck->protocolIEs.list.array[idx])
14542                {
14543                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14544                }
14545             }
14546             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14547          }
14548          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14549       }
14550       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14551    }
14552 }
14553
14554 /*******************************************************************
14555  *
14556  * @brief Build And Send F1ResetAck
14557  *
14558  * @details
14559  *
14560  *    Function : BuildAndSendF1ResetAck
14561  *
14562  *    Functionality:
14563  *         - Build And Send  F1ResetRSP
14564  *
14565  *  @params[in]
14566  * @return ROK     - success
14567  *         RFAILED - failure
14568  *
14569  * ****************************************************************/
14570 uint8_t BuildAndSendF1ResetAck()
14571 {
14572    uint8_t                idx = 0;
14573    uint8_t                elementCnt = 0;
14574    uint8_t                ret = RFAILED;
14575    F1AP_PDU_t             *f1apMsg = NULL;
14576    ResetAcknowledge_t     *f1ResetAck = NULLP;
14577    asn_enc_rval_t         encRetVal;
14578    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
14579
14580    do{
14581       /* Allocate the memory for F1ResetRequest_t */
14582       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14583       if(f1apMsg == NULLP)
14584       {
14585          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14586          break;
14587       }
14588
14589       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14590
14591       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14592       if(f1apMsg->choice.successfulOutcome == NULLP)
14593       {
14594          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14595          break;
14596       }
14597       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
14598       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
14599       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14600
14601       elementCnt = 1;
14602
14603       f1ResetAck->protocolIEs.list.count = elementCnt;
14604       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
14605
14606       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14607       if(f1ResetAck->protocolIEs.list.array == NULLP)
14608       {
14609          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
14610          break;
14611       }
14612
14613       for(idx=0; idx<elementCnt; idx++)
14614       {
14615          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14616          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
14617          {
14618             break;
14619          }
14620       }
14621       /*TransactionID*/
14622       idx = 0;
14623       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14624       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14625       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
14626       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
14627
14628       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14629
14630       /* Encode the F1SetupRequest type as UPER */
14631       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14632       encBufSize = 0;
14633       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14634
14635       /* Check encode results */
14636       if(encRetVal.encoded == ENCODE_FAIL)
14637       {
14638          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
14639                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14640          break;
14641       }
14642       else
14643       {
14644          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
14645 #ifdef DEBUG_ASN_PRINT
14646          for(int i=0; i< encBufSize; i++)
14647          {
14648             printf("%x",encBuf[i]);
14649          }
14650 #endif
14651       }
14652       /* Sending msg */
14653       if(sendF1APMsg() != ROK)
14654       {
14655          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
14656          break;
14657       }
14658
14659       ret = ROK;
14660       break;
14661    }while(true);
14662
14663    FreeF1ResetAck(f1apMsg);
14664    return ret;
14665 }
14666 /******************************************************************
14667 *
14668 * @brief free F1 reset msg allocated by aper_decoder
14669 *
14670 * @details
14671 *
14672 *    Function : freeAperDecodeF1ResetMsg
14673 *
14674 *    Functionality: free F1 reset msg allocated by aper_decoder
14675 *
14676 * @params[in] Reset_t *f1ResetMsg
14677 * @return void
14678 *
14679 * ****************************************************************/
14680
14681 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
14682 {
14683    uint8_t ieIdx =0;
14684    if(f1ResetMsg->protocolIEs.list.array)
14685    {
14686       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
14687       {
14688          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
14689          {
14690             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
14691          }
14692       }
14693       free(f1ResetMsg->protocolIEs.list.array);
14694    }
14695 }
14696
14697 /******************************************************************
14698  *
14699  * @brief Processes DL RRC Message Transfer  sent by CU
14700  *
14701  * @details
14702  *
14703  *    Function : procF1ResetReq
14704  *
14705  *    Functionality: Processes DL RRC Message Transfer sent by CU
14706  *
14707  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14708  * @return ROK     - success
14709  *         RFAILED - failure
14710  *
14711  * ****************************************************************/
14712 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
14713 {
14714    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
14715    uint8_t       ieIdx = 0;
14716    uint8_t        ret = ROK;
14717    Reset_t       *f1ResetMsg = NULLP;
14718
14719    DU_LOG("\nINFO   -->  Processing F1 reset request");
14720    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14721
14722    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
14723    {
14724       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
14725       {
14726          case ProtocolIE_ID_id_TransactionID:
14727             break;
14728
14729          case ProtocolIE_ID_id_Cause:
14730             break;
14731
14732          case ProtocolIE_ID_id_ResetType:
14733             {
14734                break;
14735             }
14736
14737          default:
14738             break;
14739       }
14740    }
14741    ret = BuildAndSendF1ResetAck();
14742    DU_LOG("\nINFO   -->  UE release is not supported for now");
14743
14744    freeAperDecodeF1ResetMsg(f1ResetMsg);
14745
14746    return ret;
14747 }
14748
14749 /*******************************************************************
14750  *
14751  * @brief free the RRC delivery report
14752  *
14753  * @details
14754  *
14755  *    Function : freeRrcDeliveryReport
14756  *
14757  *    Functionality: free the RRC delivery report
14758  *
14759  * @params[in]
14760  * @return ROK     - success
14761  *         RFAILED - failure
14762  *
14763  * ****************************************************************/
14764 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
14765 {
14766    uint8_t idx=0;
14767    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14768
14769    if(f1apMsg)
14770    {
14771       if(f1apMsg->choice.initiatingMessage)
14772       {
14773          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14774          if(rrcDeliveryReport->protocolIEs.list.array)
14775          {
14776             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
14777                   idx++)
14778             {
14779                if(rrcDeliveryReport->protocolIEs.list.array[idx])
14780                {
14781                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
14782                         sizeof(RRCDeliveryReportIEs_t));
14783                }
14784             }
14785             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
14786                   rrcDeliveryReport->protocolIEs.list.size);
14787          }
14788          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14789       }
14790       DU_FREE(f1apMsg,
14791             sizeof(F1AP_PDU_t));
14792    }
14793 }
14794
14795 /*******************************************************************
14796 *
14797 * @brief Builds and sends the RRC delivery report
14798 *
14799 * @details
14800 *
14801 *    Function : BuildAndSendRrcDeliveryReport
14802 *
14803 *    Functionality: Builds and sends the RRC delivery report
14804 *
14805 * @params[in]
14806 *
14807 * @return ROK     - success
14808 *         RFAILED - failure
14809 *
14810 * ****************************************************************/
14811 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
14812    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
14813 {
14814    uint8_t             ret = RFAILED;
14815    uint8_t             idx    = 0;
14816    uint8_t             idx1   = 0;
14817    uint8_t             elementCnt = 0;
14818    F1AP_PDU_t          *f1apMsg = NULLP;
14819    asn_enc_rval_t      encRetVal;
14820    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14821
14822    do{
14823
14824       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
14825       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14826       if(f1apMsg == NULLP)
14827       {
14828          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14829          break;
14830       }
14831       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14832       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14833       if(f1apMsg->choice.initiatingMessage == NULLP)
14834       {
14835          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
14836          break;
14837       }
14838       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
14839       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
14840       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
14841
14842       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14843       elementCnt = 4;
14844       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
14845       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
14846
14847       /* Initialize the F1Setup members */
14848       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
14849       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
14850       {
14851          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
14852          break;
14853       }
14854       for(idx =0 ;idx <elementCnt; idx++)
14855       {
14856          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
14857          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
14858          {
14859             break;
14860          }
14861       }
14862
14863       idx1 = 0;
14864
14865       /*GNB CU UE F1AP ID*/
14866       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14867       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14868       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
14869       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14870
14871       /*GNB DU UE F1AP ID*/
14872       idx1++;
14873       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14874       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14875       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
14876       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14877
14878       /*RRC delivery status*/
14879       idx1++;
14880       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
14881       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14882       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
14883       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
14884       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
14885       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
14886       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
14887
14888       /* SRB ID */
14889       idx1++;
14890       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
14891       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14892       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
14893       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
14894
14895       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14896
14897       /* Encode the RRC DELIVERY REPORT type as APER */
14898       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14899       encBufSize = 0;
14900       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14901             encBuf);
14902
14903       /* Encode results */
14904       if(encRetVal.encoded == ENCODE_FAIL)
14905       {
14906          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
14907                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14908          break;
14909       }
14910       else
14911       {
14912          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
14913 #ifdef DEBUG_ASN_PRINT
14914          for(idx=0; idx< encBufSize; idx++)
14915          {
14916             printf("%x",encBuf[idx]);
14917          }
14918 #endif
14919       }
14920
14921       /* Sending msg */
14922       if(sendF1APMsg() != ROK)
14923       {
14924          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
14925          break;
14926       }
14927       ret = ROK;
14928       break;
14929
14930    }while(true);
14931
14932    freeRrcDeliveryReport(f1apMsg);
14933    return ret;
14934 }
14935
14936 /*******************************************************************
14937  *
14938  * @brief Processes cells to be activated
14939  *
14940  * @details
14941  *
14942  *    Function : extractCellsToBeActivated
14943  *
14944  *    Functionality:
14945  *      - Processes cells to be activated list received in F1SetupRsp
14946  *
14947  * @params[in] void
14948  * @return ROK     - success
14949  *         RFAILED - failure
14950  *
14951  * ****************************************************************/
14952
14953 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
14954 {
14955    uint8_t  ret = ROK;
14956    uint16_t idx, pci = 0;
14957    uint64_t nci;
14958    Cells_to_be_Activated_List_Item_t cell;
14959
14960    for(idx=0; idx<cellsToActivate.list.count; idx++)
14961    {
14962       nci = 0;
14963       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
14964       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
14965
14966       if(cell.nRPCI)
14967       {
14968          pci = *cell.nRPCI;
14969       }
14970       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
14971    }
14972    return ret;
14973 }
14974 /******************************************************************
14975 *
14976 * @brief Processes F1 Setup Response allocated by aper_decoder
14977 *
14978 * @details
14979 *
14980 *    Function : freeF1SetupRsp
14981 *
14982 *    Functionality: free F1 Setup Response allocated by aper_decoder
14983 *
14984 * @params[in] F1SetupResponse_t *f1SetRspMsg
14985 * @return void
14986 *
14987 * ****************************************************************/
14988
14989 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
14990 {
14991    uint8_t ieIdx =0;
14992    uint8_t arrIdx =0;
14993    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
14994    RRC_Version_t      *rrcVer =NULLP;
14995
14996    if(f1SetRspMsg->protocolIEs.list.array)
14997    {
14998       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
14999       {
15000          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
15001          {
15002             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
15003             {
15004                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15005                   {
15006                      cellToActivate =
15007                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
15008                      if(cellToActivate->list.array)
15009                      {
15010                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
15011                         {
15012                            if(cellToActivate->list.array[arrIdx])
15013                            {
15014
15015                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
15016                               pLMN_Identity.buf)
15017                               {
15018                                  if(cellToActivate->list.array[0]->value.choice.\
15019                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
15020                                  {
15021                                     free(cellToActivate->list.array[0]->value.choice.\
15022                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
15023                                  }
15024
15025                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
15026                                        nRCGI.pLMN_Identity.buf);
15027                               }
15028                               free(cellToActivate->list.array[arrIdx]);
15029                            }
15030                         }
15031                         free(cellToActivate->list.array);
15032                      }
15033                      break;
15034                   }
15035                case ProtocolIE_ID_id_TransactionID:
15036                   {
15037                      break;
15038                   }
15039                case ProtocolIE_ID_id_gNB_CU_Name:
15040                   {
15041                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
15042                      break;
15043                   }
15044                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15045                   {
15046                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
15047                      if(rrcVer->latest_RRC_Version.buf)
15048                      {
15049                         if(rrcVer->iE_Extensions)
15050                         {
15051                            if(rrcVer->iE_Extensions->list.array)
15052                            {
15053                               if(rrcVer->iE_Extensions->list.array[0])
15054                               {
15055                                  if(rrcVer->iE_Extensions->list.\
15056                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
15057                                  {
15058                                     free(rrcVer->iE_Extensions->list.\
15059                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
15060                                  }
15061                                  free(rrcVer->iE_Extensions->list.array[0]);
15062                               }
15063                               free(rrcVer->iE_Extensions->list.array);
15064                            }
15065                            free(rrcVer->iE_Extensions);
15066                         }
15067                         free(rrcVer->latest_RRC_Version.buf);
15068                      }
15069                      break;
15070
15071                   }
15072                default:
15073                   {
15074                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15075                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
15076                   }
15077             }
15078             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
15079          }
15080       }
15081       free(f1SetRspMsg->protocolIEs.list.array);
15082    }
15083 }
15084 /******************************************************************
15085  *
15086  * @brief Processes F1 Setup Response sent by CU
15087  *
15088  * @details
15089  *
15090  *    Function : procF1SetupRsp
15091  *
15092  *    Functionality: Processes F1 Setup Response sent by CU
15093  *
15094  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15095  * @return ROK     - success
15096  *         RFAILED - failure
15097  *
15098  * ****************************************************************/
15099 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15100 {
15101    uint8_t ret = ROK;
15102    uint16_t idx =0;
15103    F1SetupResponse_t *f1SetRspMsg = NULLP;
15104    GNB_CU_Name_t     *cuName = NULLP;
15105    F1SetupRsp  f1SetRspDb;
15106    RRC_Version_t      *rrcVer =NULLP;
15107
15108    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
15109
15110    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
15111    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
15112
15113    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
15114    {
15115       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
15116       {
15117          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15118             {
15119                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
15120                      value.choice.Cells_to_be_Activated_List);
15121                break;
15122             }
15123          case ProtocolIE_ID_id_TransactionID:
15124             {
15125                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
15126                                     value.choice.TransactionID;
15127                break;
15128             }
15129          case ProtocolIE_ID_id_gNB_CU_Name:
15130             {
15131                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
15132                         value.choice.GNB_CU_Name;
15133                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
15134                break;
15135             }
15136          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15137             {
15138                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
15139                strcpy(f1SetRspDb.rrcVersion.rrcVer,
15140                      (const char*)rrcVer->latest_RRC_Version.buf);
15141                break;
15142             }
15143          default:
15144             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15145                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
15146       }
15147       duProcF1SetupRsp();
15148    }
15149
15150    freeAperDecodeF1SetupRsp(f1SetRspMsg);
15151
15152    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
15153    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
15154    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
15155    {
15156       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
15157       return RFAILED;
15158    }
15159    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
15160
15161    if(BuildAndSendE2SetupReq() != ROK)
15162    {
15163       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
15164       return RFAILED;
15165    }
15166    return ret;
15167 }
15168 /*******************************************************************
15169 *
15170 * @brief free GNB DU config update ack
15171 *
15172 * @details
15173 *
15174 *    Function : freeAperDecodeGnbDuAck
15175 *
15176 *    Functionality: Processes GNB DU config update ack And
15177 *                     added free part for the memory allocated by aper_decoder
15178 *
15179 * @params[in] F1AP_PDU_t ASN decoded F1AP message
15180 * @return ROK     - success
15181 *         RFAILED - failure
15182 *
15183 * ****************************************************************/
15184
15185 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
15186 {
15187    uint8_t ieIdx = 0;
15188
15189    if(gnbDuAck->protocolIEs.list.array)
15190    {
15191       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15192       {
15193          if(gnbDuAck->protocolIEs.list.array[ieIdx])
15194          {
15195             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
15196          }
15197       }
15198       free(gnbDuAck->protocolIEs.list.array);
15199    }
15200 }
15201
15202 /*******************************************************************
15203 *
15204 * @brief Building  result of gnb-du config update ack output
15205 *
15206 * @details
15207 *
15208 *    Function : duProcGnbDuCfgUpdAckMsg
15209 *
15210 *    Functionality:
15211 *        Building output of gnb-du config update ack
15212 *
15213 * @params[in] transId
15214 * @return void
15215 *
15216 * ****************************************************************/
15217
15218 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
15219 {
15220    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
15221    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
15222    uint16_t cellIdx =0, crnti=0;
15223    uint64_t cellId =0;
15224    CmLList *f1apPduNode = NULLP;
15225    ReservedF1apPduInfo *f1apPduInfo =NULLP;
15226    F1AP_PDU_t *f1apMsgPdu = NULLP;
15227    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
15228    BIT_STRING_t *cellIdentity=NULLP;
15229    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
15230    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
15231    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
15232
15233    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
15234    f1apPduNode = searchFromReservedF1apPduList(transId);
15235    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
15236    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
15237
15238    if(f1apMsgPdu)
15239    {
15240       if(f1apMsgPdu->choice.initiatingMessage)
15241       {
15242          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
15243          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
15244          {
15245             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
15246             {
15247                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
15248                   {
15249                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
15250                                      Served_Cells_To_Delete_List;
15251                      if(cellsToDelete->list.array)
15252                      {
15253                         if(cellsToDelete->list.array[arrIdx])
15254                         {
15255                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
15256                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
15257                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
15258                            {
15259                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
15260                               bitStringToInt(cellIdentity, &cellId);
15261
15262                               GET_CELL_IDX(cellId, cellIdx);
15263                               if(duCb.actvCellLst[cellIdx] != NULLP)
15264                               {
15265                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15266                               }
15267                            }
15268                         }
15269                      }
15270
15271                      if(duCb.actvCellLst[cellIdx] != NULLP)
15272                      {
15273                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
15274                         {
15275                            ret = duSendCellDeletReq(cellId);
15276                            if(ret == RFAILED)
15277                            {
15278                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
15279                               request for cellId[%lu]", cellId);
15280                            }
15281                         }
15282                         else
15283                         {
15284                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
15285                            while(totalActiveUe)
15286                            {
15287                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
15288                               {
15289                                  ueIdx++;
15290                                  continue;
15291                               }
15292
15293                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
15294                               GET_UE_ID(crnti,ueId);
15295                               /* Sending Ue Context release request only for maximum supporting UEs */
15296                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
15297                               if(ret == RFAILED)
15298                               {
15299                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
15300                                  request for cellId[%lu]", cellId);
15301                               }
15302                               ueIdx++;
15303                               totalActiveUe--;
15304                            }
15305                         }
15306                      }
15307                      else
15308                      {
15309                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
15310                         ret = RFAILED;
15311                      }
15312                      break;
15313                   }
15314
15315                default:
15316                   break;
15317             }
15318          }
15319       }
15320    }
15321
15322    FreeDUConfigUpdate(f1apMsgPdu);
15323    deleteFromReservedF1apPduList(f1apPduNode);
15324    return ret;
15325 }
15326
15327 /*******************************************************************
15328 *
15329 * @brief Processes GNB DU config update ack
15330 *
15331 * @details
15332 *
15333 *    Function : procF1GNBDUCfgUpdAck
15334 *
15335 *    Functionality: added free part for the memory allocated by aper_decoder
15336 *
15337 * @params[in] F1AP_PDU_t *f1apMsg
15338 * @return void
15339 *
15340 * ****************************************************************/
15341 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
15342 {
15343    uint8_t ieIdx=0,transId=0;
15344    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
15345
15346    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
15347    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
15348
15349    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15350    {
15351       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
15352       {
15353          case ProtocolIE_ID_id_TransactionID:
15354             {
15355                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
15356                break;
15357             }
15358          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15359             {
15360                break;
15361             }
15362          default :
15363             {
15364                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
15365                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
15366                break;
15367             }
15368       }
15369    }
15370
15371    duProcGnbDuCfgUpdAckMsg(transId);
15372
15373 #if 0
15374    /* presently we are not supporting F1 Reset from DU to CU , we are only
15375     * supporting F1 Reset from CU to DU */
15376
15377    if(BuildAndSendF1ResetReq() != ROK)
15378    {
15379       return RFAILED;
15380    }
15381 #endif
15382
15383    freeAperDecodeGnbDuAck(gnbDuAck);
15384    return ROK;
15385 }
15386 /******************************************************************
15387 *
15388 * @brief free DL RRC Message Transfer allocated by aper_decoder
15389 *
15390 * @details
15391 *
15392 *    Function : freeAperDecodef1DlRrcMsg
15393 *
15394 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
15395 *
15396 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
15397 * @return ROK     - success
15398 *         RFAILED - failure
15399 *
15400 * ****************************************************************/
15401
15402 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
15403 {
15404    uint8_t ieIdx =0;
15405    RRCContainer_t *rrcContainer = NULLP;
15406
15407    if(f1DlRrcMsg->protocolIEs.list.array)
15408    {
15409       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
15410       {
15411          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
15412          {
15413             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
15414             {
15415                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15416                   break;
15417                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15418                   break;
15419                case ProtocolIE_ID_id_SRBID:
15420                   break;
15421                case ProtocolIE_ID_id_RRCContainer:
15422                   {
15423                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
15424                      free(rrcContainer->buf);
15425                   }
15426                case ProtocolIE_ID_id_ExecuteDuplication:
15427                   break;
15428                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15429                   break;
15430                   break;
15431             }
15432             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
15433          }
15434       }
15435       free(f1DlRrcMsg->protocolIEs.list.array);
15436    }
15437 }
15438 /******************************************************************
15439  *
15440  * @brief Processes DL RRC Message Transfer  sent by CU
15441  *
15442  * @details
15443  *
15444  *    Function : procF1DlRrcMsgTrans
15445  *
15446  *    Functionality: Processes DL RRC Message Transfer sent by CU
15447  *
15448  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15449  * @return ROK     - success
15450  *         RFAILED - failure
15451  *
15452  * ****************************************************************/
15453 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
15454 {
15455    uint8_t  idx, ret;
15456    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
15457    F1DlRrcMsg dlMsg;
15458    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
15459
15460    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
15461    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
15462
15463    ret = ROK;
15464
15465    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
15466    {
15467       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
15468       {
15469          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15470             {
15471                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
15472                break;
15473             }
15474          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15475             {
15476                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
15477                break;
15478             }
15479          case ProtocolIE_ID_id_SRBID:
15480             {
15481                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
15482                break;
15483             }
15484          case ProtocolIE_ID_id_ExecuteDuplication:
15485             dlMsg.execDup = true;
15486             break;
15487
15488          case ProtocolIE_ID_id_RRCContainer:
15489             {
15490                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
15491                {
15492                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
15493                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
15494                   if(dlMsg.rrcMsgPdu)
15495                   {
15496                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
15497                         dlMsg.rrcMsgSize);
15498                   }
15499                   else
15500                   {
15501                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
15502                      return RFAILED;
15503                   }
15504                }
15505                else
15506                {
15507                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
15508                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
15509                   return RFAILED;
15510                }
15511                break;
15512             }
15513          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15514             {
15515                dlMsg.deliveryStatRpt = true;
15516                break;
15517             }
15518          default:
15519             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
15520                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
15521       }
15522    }
15523
15524    ret = duProcDlRrcMsg(&dlMsg);
15525
15526    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
15527    return ret;
15528 }
15529 /*******************************************************************
15530  *
15531 * @brief Builds the DRB to be Setup Mod list
15532 *
15533 * @details
15534 *
15535 *    Function :
15536 *
15537 *    Functionality: Constructs the DRB to be Setup Mod list
15538 *
15539 * @params[in] DRBs_SetupMod_List_t *drbSet
15540 *
15541 * @return ROK     - success
15542 *         RFAILED - failure
15543 *
15544 * ****************************************************************/
15545 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
15546 {
15547    uint8_t srbIdx = 0;
15548    struct SRBs_SetupMod_ItemIEs *srbItemIe;
15549
15550    srbList->list.count = ueCfg->numRlcLcs;
15551    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
15552
15553    DU_ALLOC(srbList->list.array, srbList->list.size);
15554    if(srbList->list.array == NULLP)
15555    {
15556       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15557       return RFAILED;
15558    }
15559
15560    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
15561    {
15562       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15563       if(srbList->list.array[srbIdx] == NULLP)
15564       {
15565          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15566          return RFAILED;
15567       }
15568    }
15569
15570    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
15571    {
15572       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
15573       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
15574       srbItemIe->criticality = Criticality_reject;
15575       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
15576       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
15577       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
15578    }
15579    return ROK;
15580 }
15581
15582 /*******************************************************************
15583  *
15584 * @brief Builds the DRB to be Setup Mod list
15585 *
15586 * @details
15587 *
15588 *    Function :
15589 *
15590 *    Functionality: Constructs the DRB to be Setup Mod list
15591 *
15592 * @params[in] DRBs_SetupMod_List_t *drbSet
15593 *
15594 * @return ROK     - success
15595 *         RFAILED - failure
15596 *
15597 * ****************************************************************/
15598
15599 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
15600 {
15601    uint8_t arrIdx =0;
15602    uint8_t drbCnt =0;
15603    struct DRBs_SetupMod_ItemIEs *drbItemIe;
15604
15605    drbCnt = ueCfg->numDrbSetupMod;
15606
15607    if(!drbCnt)
15608    {
15609       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
15610       return ROK;
15611    }
15612
15613    drbSet->list.count = drbCnt;
15614    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
15615    DU_ALLOC(drbSet->list.array, drbSet->list.size);
15616    if(drbSet->list.array == NULLP)
15617    {
15618       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15619       return  RFAILED;
15620    }
15621    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
15622    {
15623       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15624       if(drbSet->list.array[arrIdx] == NULLP)
15625       {
15626               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15627               return  RFAILED;
15628       }
15629
15630       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
15631       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
15632       drbItemIe->criticality = Criticality_reject;
15633       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
15634       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15635       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
15636       &ueCfg->upTnlInfo[arrIdx])!= ROK)
15637       {
15638          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
15639          return RFAILED;
15640       }
15641
15642    }
15643
15644    return ROK;
15645 }
15646 /*******************************************************************
15647 * @brief Free the memory allocated for DRB setup List
15648 *
15649 * @details
15650 *
15651 *    Function : FreeDrbSetupModList
15652 *
15653 *    Functionality:
15654 *       Free the memory allocated for DRB setup list
15655 *
15656 * @params[in] DRBs_Setup_List_t *
15657 * @return void
15658 *
15659 * ****************************************************************/
15660 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
15661 {
15662    uint8_t arrIdx = 0;
15663    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
15664
15665    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
15666    {
15667       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
15668       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
15669       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15670    }
15671    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
15672 }
15673
15674 /*******************************************************************
15675 * @brief Free the memory allocated for SRB setup List
15676 *
15677 * @details
15678 *
15679 *    Function : FreeSrbSetupModList
15680 *
15681 *    Functionality:
15682 *       Free the memory allocated for SRB setup list
15683 *
15684 * @params[in] SRBs_Setup_List_t *
15685 * @return void
15686 *
15687 * ****************************************************************/
15688 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
15689 {
15690    uint8_t srbIdx = 0;
15691
15692    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
15693       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15694    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
15695 }
15696
15697 /*******************************************************************
15698 * @brief Free the memory allocated for UE Context Mod Response
15699 *
15700 * @details
15701 *
15702 *    Function : FreeUeContextModResp
15703 *
15704 *    Functionality:
15705 *       Free the memory allocated for UE Context Mod Response
15706 *
15707 * @params[in] F1AP_PDU_t *f1apMsg
15708 * @return void
15709 *
15710 * ****************************************************************/
15711
15712 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
15713 {
15714    uint8_t ieIdx;
15715    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15716    if(f1apMsg)
15717    {
15718       if(f1apMsg->choice.successfulOutcome)
15719       {
15720          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15721          if(ueContextModifyRes->protocolIEs.list.array)
15722          {
15723             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
15724             {
15725                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
15726                {
15727                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
15728                   {
15729                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15730                         break;
15731                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15732                         break;
15733                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
15734                         {
15735                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15736                             value.choice.DRBs_SetupMod_List));
15737                             break;
15738                         }
15739                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
15740                         {
15741                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
15742                               SRBs_SetupMod_List));
15743                            break;
15744                         }
15745                   }
15746                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15747                }
15748
15749             }
15750             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15751          }
15752          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15753       }
15754       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15755    }
15756 }
15757
15758 /*****************************************************************i
15759 *
15760 * @brief Creating the ue context modifcation response and sending
15761 *
15762 * @details
15763 *
15764 *    Function : BuildAndSendUeContextModRsp
15765 *
15766 *    Functionality:
15767 *         - Creating the ue context modifcation response
15768 *
15769 * @params[in] uint8_t cellId,uint8_t ueId
15770 * @return ROK     - success
15771 *         RFAILED - failure
15772 *
15773 * ****************************************************************/
15774 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
15775 {
15776    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
15777    uint8_t   elementCnt = 0;
15778    uint8_t   ret = RFAILED;
15779    F1AP_PDU_t *f1apMsg = NULLP;
15780    asn_enc_rval_t  encRetVal;
15781    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15782
15783    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
15784
15785    while(true)
15786    {
15787       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15788       if(f1apMsg == NULLP)
15789       {
15790          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15791          break;
15792       }
15793
15794       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
15795
15796       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15797       if(f1apMsg->choice.successfulOutcome == NULLP)
15798       {
15799          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15800          break;
15801       }
15802       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
15803       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15804       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
15805
15806       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15807
15808       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
15809       {
15810          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
15811             elementCnt =3;
15812          else
15813             elementCnt =2;
15814       }
15815       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15816          elementCnt = 5;
15817       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
15818          elementCnt = 2;
15819       ueContextModifyRes->protocolIEs.list.count = elementCnt;
15820       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
15821
15822       /* Initialize the UE context modification members */
15823       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15824       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
15825       {
15826          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15827          break;
15828       }
15829
15830       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
15831       {
15832          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15833          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
15834          {
15835             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15836             break;
15837          }
15838       }
15839
15840       ieIdx=0;
15841       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15842       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15843       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15844       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
15845       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
15846
15847       ieIdx++;
15848       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15849       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15850       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
15851       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
15852       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
15853
15854       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15855       {
15856          ieIdx++;
15857          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
15858          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15859          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15860          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
15861          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
15862       }
15863
15864       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
15865       {
15866          ieIdx++;
15867          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
15868          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15869          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15870                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
15871          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15872          {
15873             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
15874             {
15875                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
15876                {
15877                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
15878                }
15879             }
15880          }
15881          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15882                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
15883          if(ret != ROK)
15884          {
15885             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
15886             break;
15887          }
15888       }
15889
15890       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15891       {
15892          ieIdx++;
15893          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
15894          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15895          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15896                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
15897          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
15898          {
15899             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
15900             {
15901                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
15902                      sizeof(RlcBearerCfg));
15903             }
15904          }
15905          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
15906                &ueCb->f1UeDb->duUeCfg);
15907          if(ret != ROK)
15908          {
15909             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
15910             break;
15911          }
15912       }
15913
15914       freeF1UeDb(ueCb->f1UeDb);
15915       ueCb->f1UeDb = NULLP;
15916
15917       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15918
15919       /* Encode the F1SetupRequest type as APER */
15920       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15921       encBufSize = 0;
15922       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
15923
15924       /* Encode results */
15925       if(encRetVal.encoded == ENCODE_FAIL)
15926       {
15927          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
15928                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15929          ret = RFAILED;
15930          break;
15931       }
15932       else
15933       {
15934          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
15935 #ifdef DEBUG_ASN_PRINT
15936          for(int i=0; i< encBufSize; i++)
15937          {
15938             printf("%x",encBuf[i]);
15939          }
15940 #endif
15941       }
15942
15943       /* Sending  msg  */
15944       if(sendF1APMsg() != ROK)
15945       {
15946          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
15947          ret = RFAILED;
15948          break;
15949       }
15950
15951       ret = ROK;
15952       break;
15953    }
15954    FreeUeContextModResp(f1apMsg);
15955    //sleep(5);
15956    //BuildAndSendDUConfigUpdate(SERV_CELL_TO_DELETE);
15957    return ret;
15958 }
15959 /*******************************************************************
15960  *
15961  * @brief Deallocating the memory allocated by the aper decoder
15962  *          for QOSInfo
15963  *
15964  * @details
15965  *
15966  *    Function : freeAperDecodeQosInfo
15967  *
15968  *    Functionality:  Deallocating the memory allocated for QOSInfo
15969  *
15970  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
15971  *
15972  * @return void
15973  *
15974  * ****************************************************************/
15975
15976 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
15977 {
15978    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
15979    {
15980       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
15981       {
15982          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
15983          {
15984             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
15985          }
15986          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
15987       }
15988       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
15989    }
15990 }
15991 /*******************************************************************
15992  *
15993  * @brief Deallocating the memory allocated by the aper decoder
15994  *          for UlTnlInfoforDrb
15995  *
15996  * @details
15997  *
15998  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
15999  *
16000  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
16001  *
16002  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
16003  *
16004  * @return void
16005  *
16006  * ****************************************************************/
16007 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
16008 {
16009    uint8_t arrIdx =0;
16010
16011    if(ulInfo->list.array)
16012    {
16013       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
16014       {
16015          if(ulInfo->list.array[arrIdx])
16016          {
16017             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
16018             {
16019                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
16020                {
16021                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
16022                   {
16023                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16024                            gTP_TEID.buf);
16025                   }
16026                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16027                         transportLayerAddress.buf);
16028                }
16029                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
16030             }
16031             free(ulInfo->list.array[arrIdx]);
16032          }
16033       }
16034       free(ulInfo->list.array);
16035    }
16036 }
16037 /*******************************************************************
16038  *
16039  * @brief Deallocating the memory allocated by the aper decoder
16040  *          for DrbSetupModItem
16041  *
16042  * @details
16043  *
16044  *    Function : freeAperDecodeDrbSetupModItem
16045  *
16046  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
16047  *
16048  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
16049  *
16050  * @return void
16051  *
16052  * ****************************************************************/
16053
16054 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
16055 {
16056    uint8_t arrIdx =0;
16057    SNSSAI_t *snssai =NULLP;
16058    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16059
16060    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
16061    switch(drbItem->qoSInformation.present)
16062    {
16063       case QoSInformation_PR_NOTHING:
16064          break;
16065       case QoSInformation_PR_eUTRANQoS:
16066          {
16067             if(drbItem->qoSInformation.choice.eUTRANQoS)
16068             {
16069                free(drbItem->qoSInformation.choice.eUTRANQoS);
16070             }
16071             break;
16072          }
16073       case QoSInformation_PR_choice_extension:
16074          {
16075             if(drbItem->qoSInformation.choice.choice_extension)
16076             {
16077                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
16078                      DRB_Information.dRB_QoS);
16079                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16080                if(snssai->sST.buf)
16081                {
16082                   free(snssai->sST.buf);
16083                }
16084                if(snssai->sD)
16085                {
16086                   if(snssai->sD->buf)
16087                   {
16088                      free(snssai->sD->buf);
16089                   }
16090                   free(snssai->sD);
16091                }
16092
16093                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
16094                          DRB_Information.flows_Mapped_To_DRB_List;
16095                if(flowMap->list.array)
16096                {
16097                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16098                   {
16099                      if(flowMap->list.array[arrIdx] )
16100                      {
16101                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16102                         free(flowMap->list.array[arrIdx]);
16103                      }
16104                   }
16105                   free(flowMap->list.array);
16106                }
16107
16108                free(drbItem->qoSInformation.choice.choice_extension);
16109             }
16110             break;
16111          }
16112
16113    }
16114    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16115    if(drbItem->uLConfiguration)
16116    {
16117       free(drbItem->uLConfiguration);
16118    }
16119 }
16120
16121 /*******************************************************************
16122  *
16123  * @brief Deallocating the memory allocated by the aper decoder
16124  *          for DrbToBeSetupModList
16125  *
16126  * @details
16127  *
16128  *    Function : freeAperDecodeDrbToBeSetupModList
16129  *
16130  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
16131  *
16132  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
16133  *
16134  * @return void
16135  *
16136  * ****************************************************************/
16137
16138 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
16139 {
16140    uint8_t arrIdx =0;
16141    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
16142
16143    if(drbSet->list.array)
16144    {
16145       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16146       {
16147          if(drbSet->list.array[arrIdx] != NULLP)
16148          {
16149             if(arrIdx == 0)
16150             {
16151                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
16152                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
16153             }
16154             free(drbSet->list.array[arrIdx]);
16155          }
16156       }
16157       free(drbSet->list.array);
16158    }
16159
16160 }
16161 /*******************************************************************
16162  *
16163  * @brief Deallocating the memory allocated by the aper decoder
16164  *          for UeContextModificationReqMsg
16165  *
16166  * @details
16167  *
16168  *    Function : freeAperDecodeUeContextModificationReqMsg
16169  *
16170  *    Functionality:  Deallocating memory allocated for
16171  *                  UeContextModificationReqMsg
16172  *
16173  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
16174  *
16175  * @return void
16176  *
16177  * ****************************************************************/
16178 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
16179 {
16180    uint8_t arrIdx, ieId;
16181
16182    if(ueContextModifyReq->protocolIEs.list.array)
16183    {
16184       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
16185       {
16186          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
16187          {
16188             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
16189             switch(ieId)
16190             {
16191                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16192                   break;
16193                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16194                   break;
16195                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16196                   {
16197                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16198                            value.choice.DRBs_ToBeSetupMod_List);
16199                      break;
16200                   }
16201                case ProtocolIE_ID_id_TransmissionActionIndicator:
16202                   break;
16203                case ProtocolIE_ID_id_RRCContainer:
16204                   {
16205                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
16206                   }
16207             }
16208             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
16209          }
16210       }
16211       free(ueContextModifyReq->protocolIEs.list.array);
16212    }
16213 }
16214 /*******************************************************************
16215  *
16216  * @brief processing the F1 UeContextModificationReq
16217  *
16218  * @details
16219  *
16220  *    Function : procF1UeContextModificationReq
16221  *
16222  *    Functionality:  processing the F1 UeContextModificationReq
16223  *
16224  * @params[in] F1AP_PDU_t *f1apMsg
16225  *
16226  * @return
16227  * ****************************************************************/
16228 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
16229 {
16230    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
16231    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
16232    DuUeCb   *duUeCb = NULLP;
16233    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
16234    DRBs_ToBeModified_List_t *drbModifiedCfg;
16235    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
16236
16237    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
16238    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
16239    {
16240       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
16241       {
16242          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16243             {
16244                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
16245                break;
16246             }
16247          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16248             {
16249                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
16250                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16251                {
16252                   if(duCb.actvCellLst[cellIdx])
16253                   {
16254                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16255                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
16256                      {
16257                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
16258                         if(duUeCb->f1UeDb == NULLP)
16259                         {
16260                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16261                            duUeCb->f1UeDb->cellIdx = cellIdx;
16262                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
16263                         }
16264                         break;
16265                      }
16266                   }
16267                }
16268                if(duUeCb == NULLP)
16269                {
16270                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
16271                   ret = RFAILED;
16272                }
16273                break;
16274             }
16275
16276          case ProtocolIE_ID_id_RRCContainer:
16277             {
16278                /* Filling Dl RRC Msg Info */
16279                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16280                if(!duUeCb->f1UeDb->dlRrcMsg)
16281                {
16282                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16283                         Memory allocation failed ");
16284                   ret = RFAILED;
16285                }
16286                else
16287                {
16288                   duUeCb->f1UeDb->dlRrcMsgPres = true;
16289                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16290                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16291                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
16292                         value.choice.RRCContainer);
16293                }
16294
16295                break;
16296             }
16297
16298          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16299          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
16300             {
16301                if(duUeCb->f1UeDb)
16302                {
16303                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
16304                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
16305                   {
16306                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16307                                       choice.DRBs_ToBeSetupMod_List;
16308
16309                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
16310                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
16311                      {
16312                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
16313                         ret = RFAILED;
16314                      }
16315                   }
16316
16317                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
16318                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
16319
16320                   {
16321                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16322                                       choice.DRBs_ToBeModified_List;
16323                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
16324                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
16325                      {
16326                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
16327                         ret = RFAILED;
16328                      }
16329                   }
16330                }
16331                break;
16332             }
16333
16334          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
16335             {
16336                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
16337                if(duUeCb->f1UeDb)
16338                {
16339                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
16340                }
16341                break;
16342             }
16343
16344          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
16345             {
16346                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
16347                   RRCReconfigurationCompleteIndicator_true)
16348                {
16349                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
16350                }
16351                break;
16352             }
16353          case ProtocolIE_ID_id_TransmissionActionIndicator:
16354             {
16355                if(duUeCb->f1UeDb)
16356                {
16357                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
16358                   {
16359                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
16360                   }
16361                   else
16362                   {
16363                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
16364                   }
16365                }
16366                break;
16367             }
16368
16369          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
16370             {
16371                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
16372                {
16373                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
16374                }
16375                break;
16376             }
16377 #ifdef NR_DRX
16378          case ProtocolIE_ID_id_DRXConfigurationIndicator:
16379             {
16380                duUeCb->f1UeDb->duUeCfg.drxConfigIndicatorRelease = true;
16381                break;
16382             }
16383 #endif
16384
16385       }
16386    }
16387
16388    if(ret != RFAILED)
16389    {
16390       ret = duProcUeContextModReq(duUeCb);
16391    }
16392    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
16393    return ret;
16394 }
16395
16396 /*****************************************************************i
16397 *
16398 * @brief Free memory allocated for UE Context Release Request
16399 *
16400 * @details
16401 *
16402 *    Function : FreeUeContextReleaseReq
16403 *
16404 *    Functionality:
16405 *         - Free memory allocated for UE Context Release Request
16406 *
16407 * @params[in] F1AP_PDU_t *f1apMsg
16408 * @return void
16409 *
16410 * *************************************************************/
16411 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
16412 {
16413    uint8_t ieIdx;
16414    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16415
16416    if(f1apMsg)
16417    {
16418       if(f1apMsg->choice.initiatingMessage)
16419       {
16420          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16421          if(ueReleaseReq->protocolIEs.list.array)
16422          {
16423             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
16424             {
16425                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
16426             }
16427             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
16428          }
16429          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16430       }
16431       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16432    }
16433
16434 }
16435 /*****************************************************************i
16436 *
16437 * @brief Build and Send UE Context Release Request
16438 *
16439 * @details
16440 *
16441 *    Function : BuildAndSendUeContextReleaseReq
16442 *
16443 *    Functionality:
16444 *         - Build and Send UE Context Release Request
16445 *
16446 * @params[in]
16447 * @return ROK     - success
16448 *         RFAILED - failure
16449 *
16450 * *************************************************************/
16451 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
16452 {
16453    bool memAllocFail = false;
16454    uint8_t ieIdx =0;
16455    uint8_t ret = RFAILED;
16456    uint16_t cellIdx =0;
16457    uint16_t crnti = 0;
16458    uint8_t  elementCnt = 0;
16459    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
16460    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
16461    asn_enc_rval_t encRetVal;
16462    F1AP_PDU_t *f1apMsg = NULLP;
16463    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16464
16465    DU_LOG("\nINFO  --> Building the UE Context Release Request");
16466    do
16467    {
16468       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16469       if(f1apMsg == NULLP)
16470       {
16471          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
16472          break;
16473       }
16474
16475       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
16476       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16477       if(f1apMsg->choice.initiatingMessage == NULLP)
16478       {
16479          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
16480          initiatingMessage");
16481          break;
16482       }
16483       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
16484       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
16485       f1apMsg->choice.initiatingMessage->value.present = \
16486       InitiatingMessage__value_PR_UEContextReleaseRequest;
16487
16488       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16489
16490       elementCnt = 2;
16491
16492       ueReleaseReq->protocolIEs.list.count = elementCnt;
16493       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
16494
16495       /* Initialize the F1Setup members */
16496       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
16497       if(ueReleaseReq->protocolIEs.list.array == NULLP)
16498       {
16499          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
16500          break;
16501       }
16502       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16503       {
16504          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
16505                sizeof(UEContextReleaseRequest_t));
16506          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
16507          {
16508             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
16509             memAllocFail = true;
16510             break;
16511          }
16512       }
16513       if(memAllocFail == true)
16514          break;
16515
16516       /* Fetching Ue Cb Info*/
16517       GET_CELL_IDX(cellId, cellIdx);
16518       if(duCb.actvCellLst[cellIdx] == NULLP)
16519       {
16520          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
16521          break;
16522       }
16523       else
16524       {
16525          GET_CRNTI(crnti, ueId);
16526          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
16527          {
16528             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
16529             break;
16530          }
16531          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
16532          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
16533       }
16534
16535       ieIdx=0;
16536       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16537       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16538       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
16539       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
16540       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16541
16542       ieIdx++;
16543       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16544       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16545       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
16546       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
16547       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16548
16549       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16550
16551       /* Encode the F1SetupRequest type as APER */
16552       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16553       encBufSize = 0;
16554       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16555       /* Encode results */
16556       if(encRetVal.encoded == ENCODE_FAIL)
16557       {
16558          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
16559                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16560          break;
16561       }
16562       else
16563       {
16564          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
16565 #ifdef DEBUG_ASN_PRINT
16566          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16567          {
16568             printf("%x",encBuf[ieIdx]);
16569          }
16570 #endif
16571       }
16572
16573       /* Sending msg */
16574       if(sendF1APMsg() != ROK)
16575       {
16576          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
16577          break;
16578       }
16579       ret = ROK;
16580       break;
16581    }while(true);
16582
16583    FreeUeContextReleaseReq(f1apMsg);
16584    return ret;
16585 }
16586 /*****************************************************************i
16587  *
16588  * @brief Free memory allocated for UE Context Release Complete
16589  *
16590  * @details
16591  *
16592  *    Function : FreeUeContextReleaseComplete
16593  *
16594  *    Functionality:
16595  *         - Free memory allocated for UE Context Release Complete
16596  *
16597  * @params[in] F1AP_PDU_t *f1apMsg
16598  * @return void
16599  *
16600  * *************************************************************/
16601 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
16602 {
16603    uint8_t ieIdx;
16604    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16605
16606    if(f1apMsg)
16607    {
16608       if(f1apMsg->choice.successfulOutcome)
16609       {
16610          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16611          if(ueReleaseComplete->protocolIEs.list.array)
16612          {
16613             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
16614             {
16615                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
16616             }
16617             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
16618          }
16619          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16620       }
16621       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16622    }
16623
16624 }
16625 /*****************************************************************i
16626  *
16627  * @brief Build and Send UE Context Release Complete
16628  *
16629  * @details
16630  *
16631  *    Function : BuildAndSendUeContextReleaseComplete
16632  *
16633  *    Functionality:
16634  *         - Build and Send UE Context Release Complete
16635  *
16636  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
16637  * @return ROK     - success
16638  *         RFAILED - failure
16639  *
16640  * *************************************************************/
16641 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
16642 {
16643    bool memAllocFail = false;
16644    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
16645    asn_enc_rval_t encRetVal;
16646    F1AP_PDU_t *f1apMsg = NULLP;
16647    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16648
16649    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
16650    do
16651    {
16652       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16653       if(f1apMsg == NULLP)
16654       {
16655          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
16656          break;
16657       }
16658
16659       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
16660       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16661       if(f1apMsg->choice.successfulOutcome == NULLP)
16662       {
16663          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
16664                successfulOutcome");
16665          break;
16666       }
16667       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
16668       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16669       f1apMsg->choice.successfulOutcome->value.present = \
16670       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
16671
16672       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16673
16674       elementCnt = 2;
16675       ueReleaseComplete->protocolIEs.list.count = elementCnt;
16676       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
16677
16678       /* Initialize the UE Release Complete members */
16679       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
16680       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
16681       {
16682          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
16683          break;
16684       }
16685       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16686       {
16687          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
16688                sizeof(UEContextReleaseComplete_t));
16689          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
16690          {
16691             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
16692             elements");
16693             memAllocFail = true;
16694             break;
16695          }
16696       }
16697       if(memAllocFail == true)
16698          break;
16699
16700
16701       ieIdx=0;
16702       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16703       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16704       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
16705       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
16706       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16707
16708       ieIdx++;
16709       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16710       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16711       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
16712       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
16713       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16714
16715       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16716
16717       /* Encode the F1SetupComplete type as APER */
16718       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16719       encBufSize = 0;
16720       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16721       /* Encode results */
16722       if(encRetVal.encoded == ENCODE_FAIL)
16723       {
16724          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
16725                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16726          break;
16727       }
16728       else
16729       {
16730          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
16731 #ifdef DEBUG_ASN_PRINT
16732          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16733          {
16734             printf("%x",encBuf[ieIdx]);
16735          }
16736 #endif
16737       }
16738
16739       /* Sending msg */
16740       if(sendF1APMsg() != ROK)
16741       {
16742          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
16743          break;
16744       }
16745       ret = ROK;
16746       break;
16747    }while(true);
16748
16749    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
16750          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
16751    {
16752       ret = duSendCellDeletReq(cellId);
16753       if(ret != ROK)
16754       {
16755          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
16756                Delete req for CellId");
16757       }
16758    }
16759    FreeUeContextReleaseComplete(f1apMsg);
16760    return ret;
16761
16762 }
16763
16764 /*******************************************************************
16765 *
16766 * @brief added free part for the memory allocated by aper_decoder
16767 *
16768 * @details
16769 *
16770 *    Function : freeAperDecodeUeContextReleaseCommand
16771 *
16772 *    Functionality: added free part for the memory allocated by aper_decoder
16773 *
16774 * @params[in] F1AP_PDU_t *f1apMsg
16775 * @return void
16776 *
16777 * ****************************************************************/
16778 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16779 {
16780    uint8_t ieIdx=0;
16781    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16782
16783    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16784
16785    if(ueContextReleaseCommand->protocolIEs.list.array)
16786    {
16787       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16788       {
16789          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16790          {
16791             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16792             {
16793                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16794                   break;
16795                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16796                   break;
16797                case ProtocolIE_ID_id_Cause:
16798                   break;
16799                case ProtocolIE_ID_id_RRCContainer:
16800                {
16801                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
16802                   {
16803                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
16804                   }
16805                   break;
16806                }
16807                default :
16808                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16809                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16810                   break;
16811             }
16812          }
16813          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
16814       }
16815       free(ueContextReleaseCommand->protocolIEs.list.array);
16816    }
16817 }
16818 /*******************************************************************
16819 *
16820 * @brief processing of UE Context Release Command
16821 *
16822 * @details
16823 *
16824 *    Function : procF1UeContextReleaseCommand
16825 *
16826 *    Functionality: processing of UE Context Release Command
16827 *
16828 * @params[in] F1AP_PDU_t *f1apMsg
16829 * @return void
16830 *
16831 * ****************************************************************/
16832 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16833 {
16834    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
16835    uint16_t cellIdx =0, cellId = 0;
16836    bool ueIdxFound = false;
16837    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
16838    DuUeCb   *duUeCb = NULLP;
16839    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16840
16841    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16842
16843    if(ueContextReleaseCommand->protocolIEs.list.array)
16844    {
16845       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16846       {
16847          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16848          {
16849             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16850             {
16851                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16852                   {
16853                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16854                                     value.choice.GNB_CU_UE_F1AP_ID;
16855                      break;
16856                   }
16857
16858                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16859                   {
16860                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16861                                      value.choice.GNB_DU_UE_F1AP_ID;
16862                      break;
16863                   }
16864
16865                case ProtocolIE_ID_id_Cause:
16866                   {
16867                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16868                      {
16869                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
16870                         {
16871                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16872                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
16873                            {
16874                               cellId = duCb.actvCellLst[cellIdx]->cellId;
16875                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
16876                               ueIdxFound = true;
16877                               break;
16878                            }
16879                         }
16880                         if(ueIdxFound == true)
16881                         {
16882                            break;
16883                         }
16884                      }
16885
16886                      if(!ueIdxFound)
16887                      {
16888                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
16889                         ret = RFAILED;
16890                      }
16891                      break;
16892                   }
16893
16894                case ProtocolIE_ID_id_RRCContainer:
16895                   {
16896                      if(ueIdxFound == true)
16897                      {
16898                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16899                         if(duUeCb->f1UeDb)
16900                         {
16901                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
16902                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
16903                            duUeCb->f1UeDb->cellIdx = cellIdx;
16904                            /* Filling Dl RRC Msg Info */
16905                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16906                            if(!duUeCb->f1UeDb->dlRrcMsg)
16907                            {
16908                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16909                                     Memory allocation failed ");
16910                               ret = RFAILED;
16911                            }
16912                            else
16913                            {
16914                               duUeCb->f1UeDb->dlRrcMsgPres = true;
16915                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16916                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16917                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16918                                     value.choice.RRCContainer);
16919                            }
16920
16921                         }
16922                         else
16923                         {
16924                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16925                                  Memory allocation failed ");
16926                            ret = RFAILED;
16927
16928                         }
16929                      }
16930                      break;
16931                   }
16932                default :
16933                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16934                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16935                   break;
16936             }
16937          }
16938       }
16939    }
16940    if(ret != RFAILED)
16941    {
16942       duProcUeContextReleaseCommand(cellId, duUeCb);
16943    }
16944    freeAperDecodeUeContextReleaseCommand(f1apMsg);
16945    return ret;
16946 }
16947
16948 /**************************************************************
16949  *
16950  * @brief free the memory allocated by aper decoder for paging
16951  *
16952  * @details
16953  *
16954  *    Function : freeAperDecodePagingMsg
16955  *
16956  *    Functionality:
16957  *         - free the memory allocated by aper decoder for
16958  *         the paging f1ap msg
16959  *
16960  * @params[in] Paging_t   *paging
16961  * @return ROK     - success
16962  *         RFAILED - failure
16963  *
16964  ****************************************************************/
16965 void freeAperDecodePagingMsg(Paging_t   *paging)
16966 {
16967    uint8_t ieIdx, cellIdx;
16968    PagingCell_ItemIEs_t *pagingCellItemIes;
16969    PagingCell_Item_t *pagingCellItem;
16970    PagingCell_list_t  *pagingCelllist;
16971
16972    if(paging)
16973    {
16974       if(paging->protocolIEs.list.array)
16975       {
16976          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
16977          {
16978             if(paging->protocolIEs.list.array[ieIdx])
16979             {
16980                switch(paging->protocolIEs.list.array[ieIdx]->id)
16981                {
16982                   case ProtocolIE_ID_id_UEIdentityIndexValue:
16983                      {
16984                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
16985                         break;
16986                      }
16987                   case ProtocolIE_ID_id_PagingIdentity:
16988                      {
16989                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
16990                         {
16991                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
16992                            {
16993                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
16994                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
16995                               {
16996                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
16997                               }
16998                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
16999                            }
17000                         }
17001                         break;
17002                      }
17003                   case ProtocolIE_ID_id_PagingCell_List:
17004                      {
17005                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17006                         if(pagingCelllist->list.array)
17007                         {
17008                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
17009                            {
17010                               if(pagingCelllist->list.array[cellIdx])
17011                               {
17012                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
17013                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
17014                                  {
17015                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17016                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
17017                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
17018                                  }
17019                                  free(pagingCelllist->list.array[cellIdx]);
17020                               }
17021                            }
17022                            free(pagingCelllist->list.array);
17023                         }
17024                         break;
17025                      }
17026                }
17027                free(paging->protocolIEs.list.array[ieIdx]);
17028             }
17029          }
17030          free(paging->protocolIEs.list.array);
17031
17032       }
17033    }
17034 }
17035
17036 /**************************************************************
17037  *
17038  * @brief processing the paging f1ap msg received from CU
17039  *
17040  * @details
17041  *
17042  *    Function : procPagingMsg
17043  *
17044  *    Functionality:
17045  *         - processing the paging f1ap msg received from CU
17046  *
17047  * @params[in] F1AP_PDU_t *f1apMsg
17048  * @return ROK     - success
17049  *         RFAILED - failure
17050  *
17051  *
17052  ****************************************************************/
17053 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
17054 {
17055    uint8_t ieIdx = 0, cellListIdx = 0;
17056    uint64_t cellId = 0;
17057    Paging_t   *paging = NULLP;
17058    PagingCell_list_t  *pagingCelllist = NULLP;
17059    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
17060    PagingCell_Item_t *pagingCellItem = NULLP;
17061    DuPagingMsg *tmpPagingParam = NULLP;
17062
17063    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
17064    if(paging)
17065    {
17066       if(paging->protocolIEs.list.array)
17067       {
17068          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
17069          if(tmpPagingParam == NULLP)
17070          {
17071             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
17072             freeAperDecodePagingMsg(paging);
17073             return RFAILED;
17074          }
17075          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17076          {
17077             if(paging->protocolIEs.list.array[ieIdx])
17078             {
17079                switch(paging->protocolIEs.list.array[ieIdx]->id)
17080                {
17081                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17082                      {
17083                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
17084                                          &tmpPagingParam->pagUeId);
17085                         break;
17086                      }
17087
17088                   case ProtocolIE_ID_id_PagingIdentity:
17089                      {
17090                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
17091                         {
17092                            case PagingIdentity_PR_cNUEPagingIdentity:
17093                               {
17094                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17095                                  {
17096                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
17097                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
17098
17099                                  }
17100                                  break;
17101                               }
17102                             case PagingIdentity_PR_rANUEPagingIdentity:
17103                                {
17104                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
17105                                   break;
17106                                }
17107                             default:
17108                                {
17109                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
17110                                   continue;
17111                                }
17112                         }
17113                      }
17114
17115                   case ProtocolIE_ID_id_PagingDRX:
17116                      {
17117                         tmpPagingParam->pagingDrxPres = TRUE;
17118                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
17119                         break;
17120                      }
17121
17122                   case ProtocolIE_ID_id_PagingPriority:
17123                      {
17124                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
17125                         break;
17126                      }
17127
17128                   case ProtocolIE_ID_id_PagingCell_List:
17129                      {
17130                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17131                         if(pagingCelllist->list.array)
17132                         {
17133                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
17134                            {
17135                               if(pagingCelllist->list.array[cellListIdx])
17136                               {
17137                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
17138                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17139                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
17140                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
17141                                  {
17142                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
17143                                     continue;
17144                                  }
17145                               }
17146                            }
17147                         }
17148                         break;
17149                      }
17150                    default:
17151                      {
17152                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
17153                          break;
17154                      }
17155                }
17156             }
17157          }
17158       }
17159    }
17160    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
17161    freeAperDecodePagingMsg(paging);
17162
17163    return ROK;
17164 }
17165
17166 /**************************************************************
17167  *
17168  * @brief Handles received F1AP message and sends back response
17169  *
17170  * @details
17171  *
17172  *    Function : F1APMsgHdlr
17173  *
17174  *    Functionality:
17175  *         - Decodes received F1AP control message
17176  *         - Prepares response message, encodes and sends to SCTP
17177  *
17178  * @params[in]
17179  * @return ROK     - success
17180  *         RFAILED - failure
17181  *
17182  * ****************************************************************/
17183 void F1APMsgHdlr(Buffer *mBuf)
17184 {
17185    int i =0;
17186    char *recvBuf =NULLP;
17187    MsgLen copyCnt =0;
17188    MsgLen recvBufLen =0;
17189    F1AP_PDU_t *f1apMsg =NULLP;
17190    asn_dec_rval_t rval; /* Decoder return value */
17191    F1AP_PDU_t f1apasnmsg ;
17192    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
17193    ODU_PRINT_MSG(mBuf, 0,0);
17194
17195    /* Copy mBuf into char array to decode it */
17196    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
17197    DU_ALLOC(recvBuf, (Size)recvBufLen);
17198
17199    if(recvBuf == NULLP)
17200    {
17201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
17202       return;
17203    }
17204    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
17205    {
17206       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
17207       return;
17208    }
17209
17210 #ifdef DEBUG_ASN_PRINT
17211    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
17212    for(i=0; i< recvBufLen; i++)
17213    {
17214       printf("%x",recvBuf[i]);
17215    }
17216 #endif
17217
17218    /* Decoding flat buffer into F1AP messsage */
17219    f1apMsg = &f1apasnmsg;
17220    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
17221
17222    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
17223
17224    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
17225    {
17226       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
17227       return;
17228    }
17229    printf("\n");
17230    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17231
17232    switch(f1apMsg->present)
17233    {
17234       case F1AP_PDU_PR_successfulOutcome:
17235          {
17236             switch(f1apMsg->choice.successfulOutcome->value.present)
17237             {
17238                case SuccessfulOutcome__value_PR_ResetAcknowledge:
17239                   {
17240                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
17241                      break;
17242                   }
17243                case SuccessfulOutcome__value_PR_F1SetupResponse:
17244                   {
17245 #ifndef ODU_TEST_STUB
17246                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
17247 #endif
17248                      break;
17249                   }
17250
17251                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
17252                   {
17253                      procF1GNBDUCfgUpdAck(f1apMsg);
17254                      break;
17255                   }
17256
17257                default:
17258                   {
17259                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
17260                            f1apMsg->choice.successfulOutcome->value.present);
17261                      return;
17262                   }
17263             }/* End of switch(successfulOutcome) */
17264             free(f1apMsg->choice.successfulOutcome);
17265             break;
17266          }
17267       case F1AP_PDU_PR_initiatingMessage:
17268          {
17269             switch(f1apMsg->choice.initiatingMessage->value.present)
17270             {
17271                case InitiatingMessage__value_PR_Reset:
17272                   {
17273                      procF1ResetReq(f1apMsg);
17274                      break;
17275                   }
17276                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
17277                   {
17278                      procF1DlRrcMsgTrans(f1apMsg);
17279                      break;
17280                   }
17281                case InitiatingMessage__value_PR_UEContextSetupRequest:
17282                   {
17283                      procF1UeContextSetupReq(f1apMsg);
17284                      break;
17285                   }
17286                case InitiatingMessage__value_PR_UEContextModificationRequest:
17287                   {
17288                      procF1UeContextModificationReq(f1apMsg);
17289                      break;
17290                   }
17291                case InitiatingMessage__value_PR_UEContextReleaseCommand:
17292                   {
17293                       procF1UeContextReleaseCommand(f1apMsg);
17294                       break;
17295                   }
17296                case InitiatingMessage__value_PR_Paging:
17297                   {
17298                      procPagingMsg(f1apMsg);
17299                      break;
17300                   }
17301                default:
17302                   {
17303                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
17304                            f1apMsg->choice.initiatingMessage->value.present);
17305                      return;
17306                   }
17307             }/* End of switch(initiatingMessage) */
17308             free(f1apMsg->choice.initiatingMessage);
17309             break;
17310          }
17311
17312       default:
17313          {
17314             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
17315             return;
17316          }
17317          free(f1apMsg);
17318
17319    }/* End of switch(f1apMsg->present) */
17320
17321    DU_FREE(recvBuf, (Size)recvBufLen);
17322 } /* End of F1APMsgHdlr */
17323
17324 /**********************************************************************
17325   End of file
17326  **********************************************************************/