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 "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "du_app_mac_inf.h"
  26 #include "du_cfg.h"
  27 #include "du_app_rlc_inf.h"
  28 #include "du_mgr_main.h"
  29 #include "du_utils.h"
  30 #include "GNB-DU-System-Information.h"
  31 #include "CellGroupConfigRrc.h"
  32 #include "MAC-CellGroupConfig.h"
  33 #include "SchedulingRequestConfig.h"
  34 #include "SchedulingRequestToAddMod.h"
  35 #include "BSR-Config.h"
  36 #include "TAG-Config.h"
  37 #include "TAG.h"
  38 #include "PHR-Config.h"
  39 #include "RLC-Config.h"
  40 #include "UL-AM-RLC.h"
  41 #include "DL-AM-RLC.h"
  42 #include "LogicalChannelConfig.h"
  43 #include "RLC-BearerConfig.h"
  44 #include "PhysicalCellGroupConfig.h"
  45 #include "SpCellConfig.h"
  46 #include "TDD-UL-DL-ConfigDedicated.h"
  47 #include "ServingCellConfig.h"
  48 #include "ControlResourceSet.h"
  49 #include "SearchSpace.h"
  50 #include "PDCCH-Config.h"
  51 #include "PDSCH-TimeDomainResourceAllocation.h"
  52 #include "PDSCH-TimeDomainResourceAllocationList.h"
  53 #include "PDSCH-CodeBlockGroupTransmission.h"
  54 #include "PDSCH-ServingCellConfig.h"
  55 #include "DMRS-DownlinkConfig.h"
  56 #include "PDSCH-Config.h"
  57 #include "BWP-DownlinkDedicated.h"
  58 #include "PUSCH-TimeDomainResourceAllocation.h"
  59 #include "PUSCH-TimeDomainResourceAllocationList.h"
  60 #include "DMRS-UplinkConfig.h"
  61 #include "PUSCH-Config.h"
  62 #include "SRS-ResourceId.h"
  63 #include "SRS-Resource.h"
  64 #include "SRS-ResourceSet.h"
  65 #include "SRS-Config.h"
  66 #include "BWP-UplinkDedicated.h"
  67 #include "PUSCH-ServingCellConfig.h"
  68 #include "UplinkConfig.h"
  69 #include "DUtoCURRCContainer.h"
  70 #include "GBR-QoSFlowInformation.h"
  71 #include "QoSFlowLevelQoSParameters.h"
  72 #include<ProtocolIE-Field.h>
  73 #include "ProtocolExtensionField.h"
  74 #include "F1AP-PDU.h"
  75 #include "odu_common_codec.h"
  76 #include "du_mgr.h"
  77 #include "du_cell_mgr.h"
  78 #include "du_f1ap_msg_hdl.h"
  79
  80 DuCfgParams duCfgParam;
  81
  82 /*******************************************************************
  83  *
  84  * @brief Builds Uplink Info for NR
  85  *
  86  * @details
  87  *
  88  *    Function : BuildULNRInfo
  89  *
  90  *    Functionality: Building NR Uplink Info
  91  *
  92  * @params[in] NRFreqInfo_t *ulnrfreq
  93  * @return ROK     - success
  94  *         RFAILED - failure
  95  *
  96  * ****************************************************************/
  97 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
  98 {
  99    uint8_t idx=0;
 100    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 101                        fdd.ulNrFreqInfo.nrArfcn;
 102    ulnrfreq->freqBandListNr.list.count = 1;
 103    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 104    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 105    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 106    {
 107       return RFAILED;
 108    }
 109    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 110    {
 111       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 112       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 113       {
 114          return RFAILED;
 115       }
 116    }
 117    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 118                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 119                                                                  freqBand[0].nrFreqBand;
 120    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 121    return ROK;
 122 }
 123 /*******************************************************************
 124  *
 125  * @brief Builds Downlink NR Info
 126  *
 127  * @details
 128  *
 129  *    Function : BuildDLNRInfo
 130  *
 131  *    Functionality: Building Downlink NR Info
 132  *
 133  * @params[in] NRFreqInfo_t *dlnrfreq
 134  * @return ROK     - success
 135  *         RFAILED - failure
 136  *
 137  * ****************************************************************/
 138 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 139 {
 140    uint8_t idx=0;
 141    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 142                        fdd.dlNrFreqInfo.nrArfcn;
 143    dlnrfreq->freqBandListNr.list.count = 1;
 144    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 145    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 146    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 147    {
 148       return RFAILED;
 149    }
 150    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 151    {
 152       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 153       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 154       {
 155          return RFAILED;
 156       }
 157    }
 158    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 159                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 160                                                                  freqBand[0].nrFreqBand;
 161    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 162
 163    return ROK;
 164 }
 165
 166 /*******************************************************************
 167  *
 168  * @brief Builds Nrcgi
 169  *
 170  * @details
 171  *
 172  *    Function : BuildNrcgi
 173  *
 174  *    Functionality: Building the PLMN ID and NR Cell id
 175  *
 176  * @params[in] NRCGI_t *nrcgi
 177  * @return ROK     - success
 178  *         RFAILED - failure
 179  *
 180  * ****************************************************************/
 181 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 182 {
 183    uint8_t ret;
 184    uint8_t unused = 4;
 185    uint8_t byteSize = 5;
 186    uint8_t val = 16;
 187    /* Allocate Buffer Memory */
 188    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 189    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 190    if(nrcgi->pLMN_Identity.buf == NULLP)
 191    {
 192       return RFAILED;
 193    }
 194    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 195          nrcgi->pLMN_Identity.buf); // Building PLMN function
 196    if(ret != ROK)
 197    {
 198       return RFAILED;
 199    }
 200    /*nrCellIdentity*/
 201    //ret = BuildNrCellId(&nrcgi->nRCellIdentity);
 202    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 203    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 204    if(nrcgi->nRCellIdentity.buf == NULLP)
 205    {
 206       return RFAILED;
 207    }
 208    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
 209    if(ret != ROK)
 210    {
 211       return RFAILED;
 212    }
 213    return ROK;
 214 }
 215 /*******************************************************************
 216  *
 217  * @brief Builds FiveGStac
 218  *
 219  * @details
 220  *
 221  *    Function : BuildFiveGSTac
 222  *
 223  *    Functionality: Building the FiveGSTac
 224  *
 225  * @params[in] OCTET_STRING_t *fivegsTac
 226  * @return ROK     - success
 227  *         RFAILED - failure
 228  *
 229  * ****************************************************************/
 230 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 231 {
 232    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 233    if(servcell->fiveGS_TAC == NULLP)
 234    {
 235       return RFAILED;
 236    }
 237    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 238    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 239          sizeof(servcell->fiveGS_TAC->size));
 240    if(servcell->fiveGS_TAC->buf == NULLP)
 241    {
 242       return RFAILED;
 243    }
 244    servcell->fiveGS_TAC->buf[0] = 0;
 245    servcell->fiveGS_TAC->buf[1] = 0;
 246    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 247    return ROK;
 248 }
 249 /*******************************************************************
 250  *
 251  * @brief Builds NR Mode
 252  *
 253  * @details
 254  *
 255  *    Function : BuildNrMode
 256  *
 257  *    Functionality: Building the NR Mode
 258  *
 259  * @params[in] NR_Mode_Info_t *fdd
 260  * @return ROK     - success
 261  *         RFAILED - failure
 262  *
 263  * ****************************************************************/
 264 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 265 {
 266    uint8_t BuildDLNRInforet=0;
 267    uint8_t BuildULNRInforet=0;
 268    /* FDD Mode */
 269    mode->present = NR_Mode_Info_PR_fDD;
 270    if(mode->present == NR_Mode_Info_PR_fDD)
 271    {
 272       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 273       if(mode->choice.fDD == NULLP)
 274       {
 275          return RFAILED;
 276       }
 277       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 278       if(BuildULNRInforet != ROK)
 279       {
 280          return RFAILED;
 281       }
 282       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 283       if(BuildDLNRInforet != ROK)
 284       {
 285          return RFAILED;
 286       }
 287    }
 288    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 289                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 290                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 291    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 292                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 293                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 294    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 295                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 296                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 297    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 298                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 299                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 300    return ROK;
 301 }
 302 /*******************************************************************
 303  *
 304  * @brief Builds IE Extensions for Served PLMNs
 305  *
 306  * @details
 307  *
 308  *    Function : BuildExtensions
 309  *
 310  *    Functionality: Building the IE Extensions
 311  *
 312  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 313  * @return ROK     - success
 314  *         RFAILED - failure
 315  *
 316  * ****************************************************************/
 317 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 318 {
 319    uint8_t idx;
 320    uint8_t plmnidx;
 321    uint8_t extensionCnt=1;
 322    uint8_t sliceId=0;
 323    uint8_t sdId;
 324    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 325    if((*ieExtend) == NULLP)
 326    {
 327       return RFAILED;
 328    }
 329    (*ieExtend)->list.count = extensionCnt;
 330    (*ieExtend)->list.size = \
 331                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 332    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 333    if((*ieExtend)->list.array == NULLP)
 334    {
 335       return RFAILED;
 336    }
 337    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 338    {
 339       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 340             sizeof(ServedPLMNs_ItemExtIEs_t));
 341       if((*ieExtend)->list.array[plmnidx] == NULLP)
 342       {
 343          return RFAILED;
 344       }
 345    }
 346    idx = 0;
 347    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 348    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 349    (*ieExtend)->list.array[idx]->extensionValue.present = \
 350                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 351    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 352       list.count = 1;
 353    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 354       list.size = sizeof(SliceSupportItem_t *);
 355    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 356          list.array,sizeof(SliceSupportItem_t *));
 357    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 358          list.array == NULLP)
 359    {
 360       return RFAILED;
 361    }
 362    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 363          list.array[sliceId],sizeof(SliceSupportItem_t));
 364    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 365          list.array[sliceId] == NULLP)
 366    {
 367       return RFAILED;
 368    }
 369    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 370       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 371    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 372          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 373          extensionValue.choice.SliceSupportList.\
 374          list.array[sliceId]->sNSSAI.sST.size);
 375    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 376          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 377    {
 378       return RFAILED;
 379    }
 380    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 381       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 382    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 383          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 384    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 385          list.array[sliceId]->sNSSAI.sD == NULLP)
 386    {
 387       return RFAILED;
 388    }
 389    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 390       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 391    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 392          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 393          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 394    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 395          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 396    {
 397       return RFAILED;
 398    }
 399    sdId = 0;
 400    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 401       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 402    sdId++;
 403    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 404       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 405    sdId++;
 406    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 407       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 408    return ROK;
 409 }
 410 /*******************************************************************
 411  *
 412  * @brief Builds Served PLMN
 413  *
 414  * @details
 415  *
 416  *    Function : BuildServedPlmn
 417  *
 418  *    Functionality: Building the Served PLMN
 419  *
 420  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 421  * @return ROK     - success
 422  *         RFAILED - failure
 423  *
 424  * ****************************************************************/
 425 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 426 {
 427    uint8_t  plmnidx;
 428    uint8_t  servPlmnCnt=1;
 429    uint8_t buildPlmnIdret=0;
 430    uint8_t BuildExtensionsret=0;
 431    srvplmn->list.count = servPlmnCnt;
 432    srvplmn->list.size = \
 433                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 434    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 435    if(srvplmn->list.array == NULLP)
 436    {
 437       return RFAILED;
 438    }
 439    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 440    {
 441       DU_ALLOC(srvplmn->list.array[plmnidx],\
 442             sizeof(ServedPLMNs_Item_t));
 443       if(srvplmn->list.array[plmnidx] == NULLP)
 444       {
 445          return RFAILED;
 446       }
 447    }
 448    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 449    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 450    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 451          srvplmn->list.array[0]->pLMN_Identity.buf);
 452    if(buildPlmnIdret!= ROK)
 453    {
 454       return RFAILED;
 455    }
 456    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 457    if(BuildExtensionsret!= ROK)
 458    {
 459       return RFAILED;
 460    }
 461    return ROK;
 462 }
 463 /*******************************************************************
 464  *
 465  * @brief Builds Served Cell List
 466  *
 467  * @details
 468  *
 469  *    Function : BuildServedCellList
 470  *
 471  *    Functionality: Building Served Cell List
 472  *
 473  * @params[in] PLMNID plmn
 474  * @return ROK     - success
 475  *         RFAILED - failure
 476  *
 477  * ****************************************************************/
 478
 479 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 480 {
 481    uint8_t  BuildNrcgiret=0;
 482    uint8_t  BuildFiveGSTacret=0;
 483    uint8_t  BuildServedPlmnret=0;
 484    uint8_t  BuildNrModeret=0;
 485    uint8_t  idx;
 486    uint8_t  plmnidx;
 487    uint8_t  plmnCnt=1;
 488    GNB_DU_Served_Cells_Item_t *srvCellItem;
 489    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 490    duServedCell->list.count = plmnCnt;
 491
 492    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 493    if(duServedCell->list.array == NULLP)
 494    {
 495       return RFAILED;
 496    }
 497    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 498    {
 499       DU_ALLOC(duServedCell->list.array[plmnidx],\
 500             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 501       if(duServedCell->list.array[plmnidx] == NULLP)
 502       {
 503          return RFAILED;
 504       }
 505    }
 506    idx = 0;
 507    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 508    duServedCell->list.array[idx]->criticality = Criticality_reject;
 509    duServedCell->list.array[idx]->value.present = \
 510                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 511    srvCellItem = \
 512                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 513    /*nRCGI*/
 514    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 515    if(BuildNrcgiret != ROK)
 516    {
 517       return RFAILED;
 518    }
 519    /*nRPCI*/
 520    srvCellItem->served_Cell_Information.nRPCI = \
 521                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 522
 523    /*fiveGS_TAC*/
 524    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 525    if(BuildFiveGSTacret != ROK)
 526    {
 527       return RFAILED;
 528    }
 529    /*Served PLMNs*/
 530    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 531    if(BuildServedPlmnret !=ROK)
 532    {
 533       return RFAILED;
 534    }
 535    /*nR Mode Info with FDD*/
 536    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 537    if(BuildNrModeret != ROK)
 538    {
 539       return RFAILED;
 540    }
 541    /*Measurement timing Config*/
 542    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 543       size = sizeof(uint8_t);
 544    DU_ALLOC(srvCellItem->served_Cell_Information.\
 545          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 546    if(srvCellItem->served_Cell_Information.\
 547          measurementTimingConfiguration.buf == NULLP)
 548    {
 549       return RFAILED;
 550    }
 551    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 552                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 553
 554    /* GNB DU System Information */
 555    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 556          sizeof(GNB_DU_System_Information_t));
 557    if(!srvCellItem->gNB_DU_System_Information)
 558    {
 559       return RFAILED;
 560    }
 561    /* MIB */
 562    srvCellItem->gNB_DU_System_Information->mIB_message.size =\
 563                                                              strlen(( char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 564    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 565          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 566    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 567    {
 568       return RFAILED;
 569    }
 570    strcpy((char *)srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 571          (char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
 572
 573    /* SIB1 */
 574    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 575                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 576
 577    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 578          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 579    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 580    {
 581       return RFAILED;
 582    }
 583    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 584    {
 585       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 586                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 587    }
 588    return ROK;
 589 }
 590 /*******************************************************************
 591  *
 592  * @brief Builds RRC Version
 593  *
 594  * @details
 595  *
 596  *    Function : BuildRrcVer
 597  *
 598  *    Functionality: Building RRC Version
 599  *
 600  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 601  * @return ROK     - success
 602  *         RFAILED - failure
 603  *
 604  * ****************************************************************/
 605 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 606 {
 607    uint8_t rrcExt;
 608    uint8_t rrcLatest;
 609    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 610    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 611    if(rrcVer->latest_RRC_Version.buf == NULLP)
 612    {
 613       return RFAILED;
 614    }
 615    rrcVer->latest_RRC_Version.buf[0] = 0;
 616    rrcVer->latest_RRC_Version.bits_unused = 5;
 617    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 618    if(rrcVer->iE_Extensions == NULLP)
 619    {
 620       return RFAILED;
 621    }
 622    rrcVer->iE_Extensions->list.count = 1;
 623    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 624    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 625    if(rrcVer->iE_Extensions->list.array == NULLP)
 626    {
 627       return RFAILED;
 628    }
 629    rrcExt = 0;
 630    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 631          sizeof(RRC_Version_ExtIEs_t));
 632    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 633    {
 634       return RFAILED;
 635    }
 636    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
 637                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 638    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
 639    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
 640                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 641    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 642       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
 643    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 644          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 645          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 646    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
 647          .Latest_RRC_Version_Enhanced.buf == NULLP)
 648    {
 649       return RFAILED;
 650    }
 651    rrcLatest = 0;
 652    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 653       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
 654    rrcLatest++;
 655    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 656       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
 657    rrcLatest++;
 658    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
 659       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
 660    return ROK;
 661 }
 662 /*******************************************************************
 663  *
 664  * @brief Sends F1 msg over SCTP
 665  *
 666  * @details
 667  *
 668  *    Function : SendF1APMsg
 669  *
 670  *    Functionality: Sends F1 msg over SCTP
 671  *
 672  * @params[in] Region region
 673  *             Pool pool
 674  * @return ROK     - success
 675  *         RFAILED - failure
 676  *
 677  * ****************************************************************/
 678 uint8_t SendF1APMsg(Region region, Pool pool)
 679 {
 680    Buffer *mBuf;
 681
 682    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 683    {
 684       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 685       {
 686          ODU_PRINT_MSG(mBuf, 0,0);
 687
 688          if(sctpSend(mBuf, F1_INTERFACE) != ROK)
 689          {
 690             DU_LOG("\nF1AP : SCTP Send failed");
 691             ODU_PUT_MSG_BUF(mBuf);
 692             return RFAILED;
 693          }
 694       }
 695       else
 696       {
 697          DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
 698          ODU_PUT_MSG_BUF(mBuf);
 699          return RFAILED;
 700       }
 701       ODU_PUT_MSG_BUF(mBuf);
 702    }
 703    else
 704    {
 705       DU_LOG("\nF1AP : Failed to allocate memory");
 706       return RFAILED;
 707    }
 708    return ROK;
 709 } /* SendF1APMsg */
 710
 711 /*******************************************************************
 712  *
 713  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 714  *
 715  * @details
 716  *
 717  *    Function :  FreeRrcVer
 718  *
 719  *    Functionality: deallocating the memory of function BuildRrcVer
 720  *
 721  * @params[in] RRC_Version_t *rrcVer
 722  *
 723  * @return void
 724  *
 725  *****************************************************************/
 726 void FreeRrcVer(RRC_Version_t *rrcVer)
 727 {
 728    if(rrcVer->latest_RRC_Version.buf != NULLP)
 729    {
 730       if(rrcVer->iE_Extensions != NULLP)
 731       {
 732          if(rrcVer->iE_Extensions->list.array != NULLP)
 733          {
 734             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
 735             {
 736                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
 737                      != NULLP)
 738                {
 739                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
 740                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
 741                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
 742                }
 743                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
 744             }
 745             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
 746          }
 747          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 748       }
 749       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
 750    }
 751 }
 752 /*******************************************************************
 753  *
 754  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 755  *
 756  * @details
 757  *
 758  *    Function :  FreeServedCellList
 759  *
 760  *    Functionality:  deallocating the memory of function BuildServedCellList
 761
 762  *
 763  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
 764  *
 765  * @return void
 766  *
 767  * ****************************************************************/
 768 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
 769 {
 770    uint8_t   plmnCnt=1;
 771    uint8_t  servId=0;
 772    uint8_t sliceId=0;
 773    uint8_t  ieId=0;
 774    uint8_t   extensionCnt=1;
 775    uint8_t plmnidx=0;
 776    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
 777    if(duServedCell->list.array!=NULLP)
 778    {
 779       if(duServedCell->list.array[0]!=NULLP)
 780       {
 781          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
 782          {
 783             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
 784             {
 785                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
 786                {
 787                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
 788                   {
 789                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
 790                      {
 791                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
 792                         {
 793                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
 794                            {
 795                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
 796                               {
 797                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
 798                                  {
 799                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
 800                                     {
 801                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 802                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
 803                                        {
 804                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 805                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
 806                                           {
 807                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 808                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
 809                                              {
 810                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 811                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
 812                                                 {
 813                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
 814                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
 815                                                    {
 816                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
 817                                                       {
 818                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
 819                                                                freqBandListNr.list.array!=NULLP)
 820                                                          {
 821                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
 822                                                                   freqBandListNr.list.array[0]!=NULLP)
 823                                                             {
 824                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 825                                                                      freqBandListNr.list.array)
 826                                                                {
 827                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 828                                                                         freqBandListNr.list.array[0]!=NULLP)
 829                                                                   {
 830                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
 831                                                                      {
 832                                                                         if(!srvCellItem->gNB_DU_System_Information)
 833                                                                         {
 834                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
 835                                                                            {
 836                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
 837                                                                               {
 838                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
 839                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 840                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
 841                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 842                                                                               }
 843                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
 844                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
 845                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
 846                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
 847                                                                            }
 848                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
 849                                                                         }
 850                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
 851                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 852                                                                      }
 853                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 854                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
 855                                                                   }
 856                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
 857                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
 858                                                                }
 859                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
 860                                                                      list.array[0],sizeof(FreqBandNrItem_t));
 861                                                             }
 862                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
 863                                                                   list.array,sizeof(FreqBandNrItem_t*));
 864                                                          }
 865                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
 866                                                       }
 867                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 868                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
 869                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
 870                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 871                                                    }
 872                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 873                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
 874                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 875                                                 }
 876                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
 877                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
 878                                                       sNSSAI.sST.buf,sizeof(uint8_t));
 879                                              }
 880                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 881                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
 882                                           }
 883                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
 884                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
 885                                        }
 886                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 887                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
 888                                     }
 889                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 890                                           array[servId]->iE_Extensions->list.array,\
 891                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
 892                                  }
 893                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 894                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
 895                               }
 896                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
 897                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
 898                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
 899                                     * sizeof(uint8_t));
 900                            }
 901                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
 902                                  sizeof(ServedPLMNs_Item_t *));
 903                         }
 904                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
 905                               sizeof(ServedPLMNs_Item_t *));
 906                      }
 907                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
 908                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
 909                   }
 910                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
 911                }
 912                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
 913                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
 914                      sizeof(uint8_t));
 915             }
 916             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
 917                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
 918                   sizeof(uint8_t));
 919          }
 920          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 921       }
 922       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
 923    }
 924 }
 925 /*******************************************************************
 926  *
 927  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
 928  *
 929  * @details
 930  *
 931  *    Function :  FreeF1SetupReq
 932  *
 933  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
 934  *
 935  * @params[in] F1AP_PDU_t *f1apMsg
 936  *
 937  * @return void
 938  *
 939  * ****************************************************************/
 940 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
 941 {
 942    uint8_t ieIdx, ieIdx2;
 943    F1SetupRequest_t *f1SetupReq=NULLP;
 944
 945    if(f1apMsg != NULLP)
 946    {
 947       if(f1apMsg->choice.initiatingMessage != NULLP)
 948       {
 949          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
 950          if(f1SetupReq->protocolIEs.list.array != NULLP)
 951          {
 952             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
 953             {
 954                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
 955                {
 956                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
 957                   {
 958                      case ProtocolIE_ID_id_TransactionID:
 959                         break;
 960                      case ProtocolIE_ID_id_gNB_DU_ID:
 961                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
 962                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
 963                         break;
 964                      case ProtocolIE_ID_id_gNB_DU_Name:
 965                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
 966                               strlen((char *)duCfgParam.duName));
 967                         break;
 968                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
 969                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
 970                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
 971                         break;
 972                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
 973                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
 974                         break;
 975                      default:
 976                         DU_LOG("\nInvalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
 977                         break;
 978                   }
 979                }
 980                break;
 981             }
 982             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
 983             {
 984                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
 985             }
 986             DU_FREE(f1SetupReq->protocolIEs.list.array,\
 987                   f1SetupReq->protocolIEs.list.size);
 988          }
 989          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 990       }
 991       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 992    }
 993 }
 994 /*******************************************************************
 995  *
 996  * @brief Builds and Send the F1SetupRequest
 997  *
 998  * @details
 999  *
1000  *    Function : BuildAndSendF1SetupReq
1001  *
1002  * Functionality:Fills the F1SetupRequest
1003  *
1004  * @return ROK     - success
1005  *         RFAILED - failure
1006  *
1007  ******************************************************************/
1008 uint8_t BuildAndSendF1SetupReq()
1009 {
1010    uint8_t   ret, ieIdx, elementCnt;
1011    F1AP_PDU_t                 *f1apMsg = NULLP;
1012    F1SetupRequest_t           *f1SetupReq=NULLP;
1013    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1014    RRC_Version_t              *rrcVer=NULLP;
1015    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1016    ret= RFAILED;
1017
1018    DU_LOG("\nF1AP : Building F1 Setup Request\n");
1019    do
1020    {
1021       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1022       if(f1apMsg == NULLP)
1023       {
1024          break;
1025       }
1026       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1027       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1028       if(f1apMsg->choice.initiatingMessage == NULLP)
1029       {
1030          break;
1031       }
1032       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1033       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1034       f1apMsg->choice.initiatingMessage->value.present = \
1035                                                          InitiatingMessage__value_PR_F1SetupRequest;
1036
1037       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1038
1039       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1040
1041       f1SetupReq->protocolIEs.list.count = elementCnt;
1042       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1043
1044       /* Initialize the F1Setup members */
1045       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1046       if(f1SetupReq->protocolIEs.list.array == NULLP)
1047       {
1048          break;
1049       }
1050       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1051       {
1052          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1053                sizeof(F1SetupRequestIEs_t));
1054          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1055          {
1056             break;
1057          }
1058       }
1059
1060       ieIdx = 0;
1061       /*TransactionID*/
1062       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1063       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1064       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1065                                                                F1SetupRequestIEs__value_PR_TransactionID;
1066       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1067                                                                              TRANS_ID;
1068
1069       /*DU ID*/
1070       ieIdx++;
1071       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1072       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1073       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1074                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1075       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1076                                                                              sizeof(uint8_t);
1077
1078       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1079             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1080       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1081             NULLP)
1082       {
1083          break;
1084       }
1085
1086       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1087          duCfgParam.duId;
1088
1089       /*DU Name*/
1090       if(duCfgParam.duName != NULL)
1091       {
1092          ieIdx++;
1093          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1094          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1095          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1096          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1097             strlen((char *)duCfgParam.duName);
1098          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1099                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1100          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1101                buf == NULLP)
1102          {
1103             break;
1104          }
1105          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1106                choice.GNB_DU_Name.buf,
1107                (char*)&duCfgParam.duName);
1108
1109       }
1110
1111       /*Served Cell list */
1112       ieIdx++;
1113       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1114                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1115       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1116       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1117                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1118       duServedCell = &f1SetupReq->protocolIEs.list.\
1119                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1120       if(BuildServedCellList(duServedCell))
1121       {
1122          break;
1123       }
1124       /*RRC Version*/
1125       ieIdx++;
1126       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1127                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1128       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1129       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1130                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1131       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1132       if(BuildRrcVer(rrcVer))
1133       {
1134          break;
1135       }
1136       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1137
1138       /* Encode the F1SetupRequest type as APER */
1139       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1140       encBufSize = 0;
1141       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1142             encBuf);
1143
1144       /* Encode results */
1145       if(encRetVal.encoded == ENCODE_FAIL)
1146       {
1147          DU_LOG("\nF1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1148                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1149          break;
1150       }
1151       else
1152       {
1153          DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupRequest\n");
1154          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1155          {
1156             printf("%x",encBuf[ieIdx]);
1157          }
1158       }
1159
1160       /* Sending msg */
1161       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1162       {
1163          DU_LOG("\nF1AP : Sending F1 Setup request failed");
1164          break;
1165       }
1166
1167       ret=ROK;
1168       break;
1169    }while(true);
1170
1171    FreeF1SetupReq(f1apMsg);
1172
1173    return ret;
1174 }/* End of BuildAndSendF1SetupReq */
1175
1176 /*******************************************************************
1177  *
1178  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1179  *
1180  * @details
1181  *
1182  *    Function : FreeDUConfigUpdate
1183  *
1184  *    Functionality: Deallocating memory of variables allocated in
1185  *                    BuildAndSendDUConfigUpdate function
1186  *
1187  * @params[in]  F1AP_PDU_t *f1apDuCfg
1188  *
1189  * @return ROK     - void
1190  *
1191  * ****************************************************************/
1192 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1193 {
1194    uint8_t  i;
1195    uint8_t  idx;
1196    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1197    Served_Cells_To_Modify_List_t  *cellsToModify;
1198    Served_Cells_To_Modify_Item_t *modifyItem;
1199    idx=0;
1200    i=1;
1201    if(f1apDuCfg != NULLP)
1202    {
1203       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1204       {
1205          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1206                        value.choice.GNBDUConfigurationUpdate;
1207          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1208          {
1209             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1210             {
1211                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1212                                value.choice.Served_Cells_To_Modify_List;
1213                if(cellsToModify->list.array != NULLP)
1214                {
1215                   if(cellsToModify->list.array[idx] != NULLP)
1216                   {
1217                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1218                                 Served_Cells_To_Modify_Item;
1219                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1220                      {
1221                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1222                         {
1223                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1224                            {
1225                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1226                                     != NULLP)
1227                               {
1228                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1229                                        != NULLP)
1230                                  {
1231                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1232                                     {
1233                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1234                                              array[idx]->pLMN_Identity.buf != NULLP)
1235                                        {
1236                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1237                                                 array[idx]->iE_Extensions!= NULLP)
1238                                           {
1239                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1240                                                    array[idx]->iE_Extensions->list.array != NULLP)
1241                                              {
1242                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1243                                                       array[idx]->iE_Extensions->list.array[idx])
1244                                                 {
1245                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1246                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1247                                                          list.array !=NULLP)
1248                                                    {
1249                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1250                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1251                                                             list.array[idx]!=NULLP)
1252                                                       {
1253                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1254                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1255                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1256                                                          {
1257                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1258                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1259                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1260                                                             {
1261                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1262                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1263                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1264                                                                {
1265                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1266                                                                         !=NULLP)
1267                                                                   {
1268                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1269                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1270                                                                      {
1271                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1272                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1273                                                                         {
1274                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1275                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1276                                                                            {
1277                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1278                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1279                                                                                     array[idx]!= NULLP)
1280                                                                               {
1281                                                                                  if(modifyItem->served_Cell_Information.\
1282                                                                                        measurementTimingConfiguration.buf !=NULLP)
1283                                                                                  {
1284                                                                                     idx=2;
1285                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1286                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1287                                                                                     {
1288                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1289                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1290                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1291                                                                                              value.choice.GNB_DU_ID.size);
1292                                                                                     }
1293                                                                                     idx=0;
1294                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1295                                                                                           measurementTimingConfiguration.\
1296                                                                                           buf,modifyItem->served_Cell_Information.\
1297                                                                                           measurementTimingConfiguration.size);
1298                                                                                  }
1299                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1300                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1301                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1302                                                                               }
1303                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1304                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1305                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1306                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1307                                                                            }
1308                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1309                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1310                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1311                                                                         }
1312                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1313                                                                               choice.\
1314                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1315                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1316                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1317                                                                      }
1318                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1319                                                                            fDD,sizeof(FDD_Info_t));
1320                                                                   }
1321                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1322                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1323                                                                         SliceSupportList.\
1324                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1325                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1326                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1327                                                                         sNSSAI.sD->size);
1328
1329                                                                }
1330                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1331                                                                      array[idx]->\
1332                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1333                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1334                                                             }
1335                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1336                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1337                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1338                                                                   servedPLMNs.\
1339                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1340                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1341                                                          }
1342                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1343                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1344                                                                list.array[idx],sizeof(SliceSupportItem_t));
1345                                                       }
1346                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1347                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1348                                                             list.array,\
1349                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1350                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1351                                                    }
1352                                                 }
1353                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1354                                                       array[idx]->iE_Extensions->list.count;i++)
1355                                                 {
1356                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1357                                                          array[idx]->iE_Extensions->list.array[i],\
1358                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1359                                                 }
1360                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1361                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1362                                                       list.array[idx]->iE_Extensions->list.size);
1363                                              }
1364                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1365                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1366                                           }
1367                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1368                                                 array[idx]->pLMN_Identity.buf,
1369                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1370                                        }
1371                                     }
1372                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1373                                     {
1374                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1375                                              != NULLP)
1376                                        {
1377                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1378                                                 sizeof(ServedPLMNs_Item_t));
1379                                        }
1380                                     }
1381                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1382                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1383                                  }
1384                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1385                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1386                               }
1387                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1388                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1389                            }
1390                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1391                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1392                         }
1393                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1394                               modifyItem->oldNRCGI.pLMN_Identity.size);
1395                      }
1396                   }
1397                   for(i=0; i<cellsToModify->list.count ;i++)
1398                   {
1399                      if(cellsToModify->list.array[i] != NULLP)
1400                      {
1401                         DU_FREE(cellsToModify->list.array[i],\
1402                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1403                      }
1404                   }
1405                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1406                }
1407             }
1408             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1409             {
1410                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1411                {
1412                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1413                         sizeof(GNBDUConfigurationUpdateIEs_t));
1414                }
1415             }
1416             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1417          }
1418          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1419       }
1420       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1421    }
1422 }
1423
1424 /*******************************************************************
1425  *
1426  * @brief Fills Served Plmns required in ServCellInfo IE
1427  *
1428  * @details
1429  *
1430  *    Function : fillServedPlmns
1431  *
1432  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1433  *
1434  * @params[in] Pointer to ServedPLMNs_List_t *
1435  *
1436  * @return ROK     - success
1437  *         RFAILED - failure
1438  *
1439  *****************************************************************/
1440
1441 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1442 {
1443    uint8_t ieIdx, ieListCnt;
1444
1445    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1446    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1447          array[0]->pLMN_Identity.size);
1448    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1449    {
1450       return RFAILED;
1451    }
1452    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1453          servedPlmn->list.array[0]->pLMN_Identity.buf);
1454    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1455    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1456    {
1457       return RFAILED;
1458    }
1459
1460    ieListCnt=1;
1461    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1462    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1463    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
1464          iE_Extensions->list.size);
1465    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
1466    {
1467       return RFAILED;
1468    }
1469    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
1470    {
1471       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
1472             sizeof(ServedPLMNs_ItemExtIEs_t));
1473       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
1474       {
1475          return RFAILED;
1476       }
1477    }
1478    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
1479    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
1480    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
1481    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
1482       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1483    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1484       list.count = 1;
1485    servedPlmn->list.array[0]->\
1486       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1487       list.size = sizeof(SliceSupportItem_t *);
1488    DU_ALLOC(servedPlmn->list.array[0]->\
1489          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1490          list.array,servedPlmn->list.array[0]->\
1491          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
1492    if(servedPlmn->list.array[0]->\
1493          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1494          list.array == NULLP)
1495    {
1496       return RFAILED;
1497    }
1498
1499    DU_ALLOC(servedPlmn->list.array[0]->\
1500          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1501          list.array[0],sizeof( SliceSupportItem_t));
1502    if(servedPlmn->list.array[0]->\
1503          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1504          list.array[0] == NULLP)
1505    {
1506       return RFAILED;
1507    }
1508    servedPlmn->list.array[0]->\
1509       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1510       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
1511    DU_ALLOC(servedPlmn->list.array[0]->\
1512          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1513          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
1514          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
1515    if(servedPlmn->list.array[0]->\
1516          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1517          list.array[0]->sNSSAI.sST.buf == NULLP)
1518    {
1519       return RFAILED;
1520    }
1521    servedPlmn->list.array[0]->\
1522       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1523       list.array[0]->sNSSAI.sST.buf[0] = 3;
1524    DU_ALLOC(servedPlmn->list.array[0]->\
1525          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1526          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1527    if(servedPlmn->list.array[0]->\
1528          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1529          list.array[0]->sNSSAI.sD == NULLP)
1530    {
1531       return RFAILED;
1532    }
1533    servedPlmn->list.array[0]->\
1534       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1535       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1536    DU_ALLOC(servedPlmn->list.array[0]->\
1537          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1538          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
1539          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1540          list.array[0]->sNSSAI.sD->size);
1541    if(servedPlmn->list.array[0]->\
1542          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1543          list.array[0]->sNSSAI.sD->buf == NULLP)
1544    {
1545       return RFAILED;
1546    }
1547    servedPlmn->list.array[0]->\
1548       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1549       list.array[0]->sNSSAI.sD->buf[0] = 3;
1550    servedPlmn->list.array[0]->\
1551       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1552       list.array[0]->sNSSAI.sD->buf[1] = 6;
1553    servedPlmn->list.array[0]->\
1554       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1555       list.array[0]->sNSSAI.sD->buf[2] = 9;
1556    return ROK;
1557 }
1558
1559 /*******************************************************************
1560  *
1561  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1562  *
1563  * @details
1564  *
1565  *    Function : fillNrFddInfo
1566  *
1567  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1568  *
1569  * @params[in] Pointer to NR_Mode_Info_t *
1570  *
1571  * @return ROK     - success
1572  *         RFAILED - failure
1573  *
1574  *****************************************************************/
1575
1576 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
1577 {
1578    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1579       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1580    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1581    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1582    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1583          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1584    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1585    {
1586       return RFAILED;
1587    }
1588    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1589       sizeof(FreqBandNrItem_t));
1590    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1591    {
1592       return RFAILED;
1593    }
1594    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1595       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
1596       freqBand[0].nrFreqBand;
1597    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1598    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
1599       dlNrFreqInfo.nrArfcn;
1600    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
1601    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
1602    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
1603          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1604    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1605    {
1606       return RFAILED;
1607    }
1608    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
1609          sizeof(FreqBandNrItem_t));
1610    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1611    {
1612       return RFAILED;
1613    }
1614    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
1615       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
1616       freqBand[0].nrFreqBand;
1617    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
1618
1619    /*Transmission Bandwidth*/
1620    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1621       f1Mode.mode.fdd.ulTxBw.nrScs;
1622    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1623       f1Mode.mode.fdd.ulTxBw.nrb;
1624    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
1625       f1Mode.mode.fdd.dlTxBw.nrScs;
1626    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
1627       f1Mode.mode.fdd.dlTxBw.nrb;
1628
1629    return ROK;
1630 }
1631
1632 /*******************************************************************
1633  *
1634  * @brief Fills ServCellInfo IE
1635  *
1636  * @details
1637  *
1638  *    Function : fillServedCellInfo
1639  *
1640  *    Functionality: Fills ServCellInfo
1641  *
1642  * @params[in] Pointer to Served_Cell_Information_t *
1643  *
1644  * @return ROK     - success
1645  *         RFAILED - failure
1646  *
1647  *****************************************************************/
1648
1649 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
1650 {
1651    uint8_t tmp, ieIdx, ieListCnt;
1652
1653    /*nRCGI*/
1654    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
1655    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
1656          srvCellInfo->nRCGI.pLMN_Identity.size);
1657    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
1658    {
1659       return RFAILED;
1660    }
1661    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1662          srvCellInfo->nRCGI.pLMN_Identity.buf);
1663    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
1664    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
1665          srvCellInfo->nRCGI.nRCellIdentity.size);
1666    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
1667    {
1668       return RFAILED;
1669    }
1670    for (tmp = 0 ; tmp < srvCellInfo->\
1671          nRCGI.nRCellIdentity.size-1 ; tmp++)
1672    {
1673       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
1674    }
1675    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
1676    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
1677
1678    /*nRPCI*/
1679    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1680
1681    /*servedPLMNs*/
1682    ieListCnt = 1;
1683    srvCellInfo->servedPLMNs.list.count = ieListCnt;
1684    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
1685    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
1686          srvCellInfo->servedPLMNs.list.size);
1687    if(srvCellInfo->servedPLMNs.list.array == NULLP)
1688    {
1689       return RFAILED;
1690    }
1691    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
1692    {
1693       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
1694             sizeof(ServedPLMNs_Item_t));
1695       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
1696       {
1697          return RFAILED;
1698       }
1699    }
1700    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
1701    {
1702       return RFAILED;
1703    }
1704
1705    /*nR Mode Info with FDD*/
1706    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
1707    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
1708          sizeof(FDD_Info_t));
1709    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
1710    {
1711       return RFAILED;
1712    }
1713    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
1714       return RFAILED;
1715
1716    /*Measurement timing Config*/
1717    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
1718    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
1719          buf,srvCellInfo->measurementTimingConfiguration.size);
1720    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
1721    {
1722       return RFAILED;
1723    }
1724    srvCellInfo->measurementTimingConfiguration.\
1725          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1726
1727    return ROK;
1728 }
1729
1730 /*******************************************************************
1731  *
1732  * @brief Fills ServCellToModItem IE
1733  *
1734  * @details
1735  *
1736  *    Function : fillServCellToModItem
1737  *
1738  *    Functionality: Fills ServCellToModItem IE
1739  *
1740  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
1741  *
1742  * @return ROK     - success
1743  *         RFAILED - failure
1744  *
1745  *****************************************************************/
1746
1747 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
1748 {
1749    uint8_t ieIdx;
1750
1751    /*pLMN_Identity*/
1752    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
1753    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
1754    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
1755    {
1756       return RFAILED;
1757    }
1758    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1759          modifyItem->oldNRCGI.pLMN_Identity.buf);
1760
1761    /*nRCellIdentity*/
1762    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
1763    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1764          modifyItem->oldNRCGI.nRCellIdentity.size);
1765    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
1766    {
1767       return RFAILED;
1768    }
1769    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
1770    {
1771       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
1772    }
1773    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
1774    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
1775
1776    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
1777       return RFAILED;
1778    else
1779       return ROK;
1780 }
1781
1782 /*******************************************************************
1783  *
1784  * @brief Builds ServCellToModList
1785  *
1786  * @details
1787  *
1788  *    Function : buildServCellToModList
1789  *
1790  *    Functionality: Builds the serv cell to Mod List
1791  *
1792  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
1793  *
1794  * @return ROK     - success
1795  *         RFAILED - failure
1796  *
1797  *****************************************************************/
1798
1799 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
1800 {
1801    uint8_t ieListCnt, ieIdx;
1802    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
1803
1804    ieListCnt = 1;
1805    cellsToModify->list.count = ieListCnt;
1806    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
1807    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
1808    if(cellsToModify->list.array == NULLP)
1809    {
1810       return RFAILED;
1811    }
1812    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
1813    {
1814       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
1815       if(cellsToModify->list.array[ieIdx] == NULLP)
1816       {
1817          return RFAILED;
1818       }
1819    }
1820    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
1821    cellsToModify->list.array[0]->criticality = Criticality_reject;
1822    cellsToModify->list.array[0]->value.present =\
1823       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
1824    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
1825
1826    if(fillServCellToModItem(modifyItem))
1827       return RFAILED;
1828    else
1829       return ROK;
1830 }
1831
1832 /*******************************************************************
1833  *
1834  * @brief Builds and sends the DUConfigUpdate
1835  *
1836  * @details
1837  *
1838  *    Function : BuildAndSendDUConfigUpdate
1839  *
1840  *    Functionality: Constructs the DU Update message and sends
1841  *                   it to the CU through SCTP.
1842  *
1843  * @params[in] void **buf,Buffer to which encoded pattern is written into
1844  * @params[in] int *size,size of buffer
1845  *
1846  * @return ROK     - success
1847  *         RFAILED - failure
1848  *
1849  * ****************************************************************/
1850 uint8_t BuildAndSendDUConfigUpdate()
1851 {
1852    uint8_t ret, ieIdx, elementCnt;
1853    F1AP_PDU_t                 *f1apDuCfg = NULLP;
1854    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1855    asn_enc_rval_t encRetVal;     /* Encoder return value */
1856    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
1857    ret= RFAILED;
1858
1859    while(true)
1860    {
1861       DU_LOG("\nF1AP : Building DU config update\n");
1862       /* Allocate the memory for F1DuCfg */
1863       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
1864       if(f1apDuCfg == NULLP)
1865       {
1866          DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1867          break;
1868       }
1869
1870       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
1871       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1872       if(f1apDuCfg->choice.initiatingMessage == NULLP)
1873       {
1874          DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
1875          break;
1876       }
1877
1878       f1apDuCfg->choice.initiatingMessage->procedureCode = \
1879                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
1880       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
1881       f1apDuCfg->choice.initiatingMessage->value.present = \
1882                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
1883       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
1884                     choice.GNBDUConfigurationUpdate;
1885       elementCnt = 3;
1886       duCfgUpdate->protocolIEs.list.count = elementCnt;
1887       duCfgUpdate->protocolIEs.list.size = \
1888                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
1889
1890       /* Initialize the F1Setup members */
1891       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1892       if(duCfgUpdate->protocolIEs.list.array == NULLP)
1893       {
1894          DU_LOG("F1AP : Memory allocation for F1RequestIEs failed");
1895          break;
1896       }
1897       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1898       {
1899          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
1900          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
1901          {
1902             break;
1903          }
1904       }
1905
1906       /*TransactionID*/
1907       ieIdx = 0;
1908       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
1909       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
1910       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
1911          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
1912       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
1913
1914       /*Served Cell to Modify */
1915       ieIdx++;
1916       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
1917                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
1918       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
1919       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
1920          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
1921       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
1922          Served_Cells_To_Modify_List))
1923          break;
1924
1925       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
1926       /*GNB DU ID */
1927       ieIdx++;
1928       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1929       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1930       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
1931         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
1932       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
1933       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1934             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1935       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
1936       {
1937          break;
1938       }
1939       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
1940
1941       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
1942
1943       /* Encode the DU Config Update type as APER */
1944       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
1945       encBufSize = 0;
1946       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
1947
1948       /* Checking encode results */
1949       if(encRetVal.encoded == ENCODE_FAIL)
1950       {
1951          DU_LOG("F1AP : Could not encode DUConfigUpdate structure (at %s)\n",encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1952          break;
1953       }
1954       else
1955       {
1956          DU_LOG("\nF1AP : Created APER encoded buffer for DUConfigUpdate\n");
1957          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
1958          {
1959             printf("%x",encBuf[ieIdx]);
1960          }
1961       }
1962       /* Sending msg */
1963       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1964       {
1965          DU_LOG("\nF1AP : Sending GND-DU Config Update failed");
1966          break;
1967       }
1968
1969       ret = ROK;
1970       break;
1971    }
1972    FreeDUConfigUpdate(f1apDuCfg);
1973
1974    return ret;
1975 }
1976
1977
1978 /*******************************************************************
1979  *
1980  * @brief free the ULRRCMessageTransfer
1981  *
1982  * @details
1983  *
1984  *    Function : FreeULRRCMessageTransfer
1985  *
1986  *    Functionality: Deallocating the memory of variable allocated in
1987  *                      FreeULRRCMessageTransfer
1988  *
1989  * @params[in]
1990  *
1991  * @return ROK     - void
1992  *
1993  ******************************************************************/
1994 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
1995 {
1996    uint8_t idx1;
1997    ULRRCMessageTransfer_t  *ulRRCMsg;
1998
1999    if(f1apMsg != NULLP)
2000    {
2001       if(f1apMsg->choice.initiatingMessage != NULLP)
2002       {
2003          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2004          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2005          {
2006             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2007             {
2008                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2009                {
2010                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2011                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2012                   {
2013                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2014                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2015                   }
2016                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2017                }
2018             }
2019             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2020          }
2021          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2022       }
2023       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2024    }
2025 }
2026 /*******************************************************************
2027  *
2028  * @brief Builds and sends the ULRRCMessageTransfer
2029  *
2030  * @details
2031  *
2032  *    Function : BuildAndSendULRRCMessageTransfer
2033  *
2034  *    Functionality: Constructs the UL RRC Message Transfer and sends
2035  *                   it to the CU through SCTP.
2036  *
2037  * @params[in]
2038  *
2039  * @return ROK     - success
2040  *         RFAILED - failure
2041  *
2042  * ****************************************************************/
2043 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2044       uint16_t msgLen, uint8_t *rrcMsg)
2045 {
2046    uint8_t   elementCnt;
2047    uint8_t   idx1;
2048    uint8_t   idx;
2049    F1AP_PDU_t                   *f1apMsg = NULL;
2050    ULRRCMessageTransfer_t       *ulRRCMsg;
2051    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2052    uint8_t ret =RFAILED;
2053    while(true)
2054    {
2055       DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n");
2056
2057       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2058       if(f1apMsg == NULLP)
2059       {
2060          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
2061          break;
2062       }
2063
2064       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2065       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2066       if(f1apMsg->choice.initiatingMessage == NULLP)
2067       {
2068          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
2069          break;
2070       }
2071       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2072       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2073       f1apMsg->choice.initiatingMessage->value.present = \
2074                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2075       ulRRCMsg =
2076          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2077       elementCnt = 4;
2078       ulRRCMsg->protocolIEs.list.count = elementCnt;
2079       ulRRCMsg->protocolIEs.list.size = \
2080                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2081
2082       /* Initialize the F1Setup members */
2083       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2084       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2085       {
2086          DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2087          break;
2088       }
2089       for(idx=0; idx<elementCnt; idx++)
2090       {
2091          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2092          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2093          {
2094             break;
2095          }
2096       }
2097
2098       idx1 = 0;
2099
2100       /*GNB CU UE F1AP ID*/
2101       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2102       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2103       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2104                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2105       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2106
2107       /*GNB DU UE F1AP ID*/
2108       idx1++;
2109       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2110       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2111       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2112                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2113       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2114
2115       /*SRBID*/
2116       idx1++;
2117       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2118       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2119       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2120                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2121       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2122
2123       /*RRCContainer*/
2124       idx1++;
2125       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2126       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2127       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2128                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2129       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2130       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2131             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2132          if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2133          {
2134             DU_LOG(" F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2135             break;
2136          }
2137       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2138             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2139
2140       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2141
2142       /* Encode the F1SetupRequest type as APER */
2143       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2144       encBufSize = 0;
2145       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2146             encBuf);
2147       /* Encode results */
2148       if(encRetVal.encoded == ENCODE_FAIL)
2149       {
2150          DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2151                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2152          break;
2153       }
2154       else
2155       {
2156          DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2157          for(int i=0; i< encBufSize; i++)
2158          {
2159             printf("%x",encBuf[i]);
2160          }
2161       }
2162
2163       /* Sending  msg  */
2164       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2165       {
2166          DU_LOG("\n F1AP : Sending      UL RRC Message Transfer Failed");
2167          break;
2168       }
2169       ret = ROK;
2170       break;
2171    }
2172    FreeULRRCMessageTransfer(f1apMsg);
2173
2174    return ret;
2175 }/* End of BuildAndSendULRRCMessageTransfer*/
2176
2177 /*******************************************************************
2178  *
2179  * @brief Builds tag config
2180  *
2181  * @details
2182  *
2183  *    Function : BuildTagConfig
2184  *
2185  *    Functionality: Builds tag config in MacCellGroupConfig
2186  *
2187  * @params[in] TAG_Config *tag_Config
2188  *
2189  * @return ROK     - success
2190  *         RFAILED - failure
2191  *
2192  * ****************************************************************/
2193 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2194 {
2195    struct TAG_Config__tag_ToAddModList *tagList;
2196    uint8_t                     idx, elementCnt;
2197
2198    tagConfig->tag_ToReleaseList = NULLP;
2199    tagConfig->tag_ToAddModList = NULLP;
2200    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2201    if(!tagConfig->tag_ToAddModList)
2202    {
2203       DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2204       return RFAILED;
2205    }
2206
2207    elementCnt = 1; //ODU_VALUE_ONE;
2208    tagList = tagConfig->tag_ToAddModList;
2209    tagList->list.count = elementCnt;
2210    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2211
2212    tagList->list.array = NULLP;
2213    DU_ALLOC(tagList->list.array, tagList->list.size);
2214    if(!tagList->list.array)
2215    {
2216       DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2217       return RFAILED;
2218    }
2219
2220    for(idx=0; idx<tagList->list.count; idx++)
2221    {
2222       tagList->list.array[idx] = NULLP;
2223       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2224       if(!tagList->list.array[idx])
2225       {
2226          DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
2227          return RFAILED;
2228       }
2229    }
2230
2231    idx = 0;
2232    tagList->list.array[idx]->tag_Id = TAG_ID;
2233    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2234
2235    return ROK;
2236 }
2237
2238 /*******************************************************************
2239  *
2240  * @brief Builds PHR Config
2241  *
2242  * @details
2243  *
2244  *    Function : BuildPhrConfig
2245  *
2246  *    Functionality: Builds phrConfig in MacCellGroupConfig
2247  *
2248  * @params[in] PHR Config *
2249  *
2250  * @return ROK     - success
2251  *         RFAILED - failure
2252  *
2253  * ****************************************************************/
2254 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2255 {
2256
2257    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2258    phrConfig->choice.setup = NULLP;
2259    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2260    if(!phrConfig->choice.setup)
2261    {
2262       DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
2263       return RFAILED;
2264    }
2265
2266    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2267    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2268    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2269    phrConfig->choice.setup->multiplePHR              = false;
2270    phrConfig->choice.setup->dummy                    = false;
2271    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2272    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2273
2274    return ROK;
2275 }
2276
2277 /*******************************************************************
2278  *
2279  * @brief Builds BSR Config
2280  *
2281  * @details
2282  *
2283  *    Function : BuildBsrConfig
2284  *
2285  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2286  *
2287  * @params[in] BSR_Config *bsrConfig
2288  *
2289  * @return ROK     - success
2290  *         RFAILED - failure
2291  *
2292  * ****************************************************************/
2293 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2294 {
2295    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2296    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2297    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2298
2299    return ROK;
2300 }
2301
2302 /*******************************************************************
2303  *
2304  * @brief Builds scheduling request config
2305  *
2306  * @details
2307  *
2308  *    Function : BuildSchedulingReqConfig
2309  *
2310  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2311  *
2312  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2313  *
2314  * @return ROK     - success
2315  *         RFAILED - failure
2316  *
2317  * ****************************************************************/
2318 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2319 {
2320    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2321    uint8_t                     idx, elementCnt;
2322
2323    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2324    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2325          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2326    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2327    {
2328       DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2329       return RFAILED;
2330    }
2331
2332    elementCnt = 1; //ODU_VALUE_ONE;
2333    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2334    schReqList->list.count = elementCnt;
2335    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2336
2337    schReqList->list.array = NULLP;
2338    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2339    if(!schReqList->list.array)
2340    {
2341       DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2342       return RFAILED;
2343    }
2344
2345    for(idx=0;idx<schReqList->list.count; idx++)
2346    {
2347       schReqList->list.array[idx] = NULLP;
2348       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2349       if(!schReqList->list.array[idx])
2350       {
2351          DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2352          return RFAILED;
2353       }
2354    }
2355
2356    idx = 0;
2357    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2358
2359    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2360    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2361    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2362    {
2363       DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
2364       return RFAILED;
2365    }
2366    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2367    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2368    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2369
2370    return ROK;
2371 }
2372
2373 /*******************************************************************
2374  *
2375  * @brief Builds RLC Config
2376  *
2377  * @details
2378  *
2379  *    Function : BuildRlcConfig
2380  *
2381  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2382  *
2383  * @params[in] RLC_Config *rlcConfig
2384  *
2385  * @return ROK     - success
2386  *         RFAILED - failure
2387  *
2388  * ****************************************************************/
2389 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2390 {
2391
2392    rlcConfig->present = RLC_Config_PR_am;
2393
2394    rlcConfig->choice.am = NULLP;
2395    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2396    if(!rlcConfig->choice.am)
2397    {
2398       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2399       return RFAILED;
2400    }
2401
2402    /* UL */
2403    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2404    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2405    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2406    {
2407       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2408       return RFAILED;
2409    }
2410    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2411    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2412    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2413    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2414    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2415
2416    /* DL */
2417    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2418    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2419    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2420    {
2421       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
2422       return RFAILED;
2423    }
2424    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2425    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2426    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2427
2428    return ROK;
2429 }
2430
2431 /*******************************************************************
2432  *
2433  * @brief Builds MAC LC Config
2434  *
2435  * @details
2436  *
2437  *    Function : BuildMacLCConfig
2438  *
2439  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2440  *
2441  * @params[in] struct LogicalChannelConfig macLcConfig
2442  *
2443  * @return ROK     - success
2444  *         RFAILED - failure
2445  *
2446  * ****************************************************************/
2447 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2448 {
2449
2450    macLcConfig->ul_SpecificParameters = NULLP;
2451    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2452    if(!macLcConfig->ul_SpecificParameters)
2453    {
2454       DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2455       return RFAILED;
2456    }
2457
2458    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2459    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
2460    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
2461    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2462    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2463    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
2464    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
2465
2466    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
2467    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
2468    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
2469    {
2470       DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2471       return RFAILED;
2472    }
2473    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
2474
2475    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
2476    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
2477    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
2478    {
2479       DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
2480       return RFAILED;
2481    }
2482    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
2483
2484    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
2485    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
2486    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
2487
2488    return ROK;
2489 }
2490
2491 /*******************************************************************
2492  *
2493  * @brief Builds RLC Bearer to Add/Mod list
2494  *
2495  * @details
2496  *
2497  *    Function :BuildRlcBearerToAddModList
2498  *
2499  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
2500  *
2501  * @params[in] rlc_BearerToAddModList
2502  *
2503  * @return ROK     - success
2504  *         RFAILED - failure
2505  *
2506  * ****************************************************************/
2507 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
2508 {
2509    uint8_t                     idx, elementCnt;
2510
2511    elementCnt = 1;
2512    rlcBearerList->list.count = elementCnt;
2513    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
2514
2515    rlcBearerList->list.array = NULLP;
2516    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
2517    if(!rlcBearerList->list.array)
2518    {
2519       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2520       return RFAILED;
2521    }
2522
2523    for(idx=0; idx<rlcBearerList->list.count; idx++)
2524    {
2525       rlcBearerList->list.array[idx] = NULLP;
2526       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
2527       if(!rlcBearerList->list.array[idx])
2528       {
2529          DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2530          return RFAILED;
2531       }
2532    }
2533
2534    idx = 0;
2535    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
2536
2537    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
2538       sizeof(struct RLC_BearerConfig__servedRadioBearer));
2539    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
2540    {
2541       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2542       return RFAILED;
2543    }
2544
2545    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
2546       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
2547    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
2548       SRB1_LCID;
2549
2550    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
2551    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
2552    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
2553    if(!rlcBearerList->list.array[idx]->rlc_Config)
2554    {
2555       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2556       return RFAILED;
2557    }
2558
2559    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
2560    {
2561       DU_LOG("\nF1AP : BuildRlcConfig failed");
2562       return RFAILED;
2563    }
2564
2565    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
2566    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
2567       sizeof(struct LogicalChannelConfig));
2568    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
2569    {
2570       DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
2571       return RFAILED;
2572    }
2573
2574    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
2575    {
2576       DU_LOG("\nF1AP : BuildMacLCConfig failed");
2577       return RFAILED;
2578    }
2579
2580    return ROK;
2581 }
2582
2583 /*******************************************************************
2584  *
2585  * @brief Build Control resource set to add/modify list
2586  *
2587  * @details
2588  *
2589  *    Function : BuildControlRSetToAddModList
2590  *
2591  *    Functionality: Build Control resource set to add/modify list
2592  *
2593  * @params[in]
2594  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2595  *
2596  * @return ROK     - success
2597  *         RFAILED - failure
2598  *
2599  * ****************************************************************/
2600    uint8_t BuildControlRSetToAddModList
2601 (
2602  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2603  )
2604 {
2605    uint8_t idx;
2606    uint8_t elementCnt;
2607    uint8_t numBytes, bitsUnused;
2608    struct ControlResourceSet *controlRSet;
2609    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2610    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2611
2612
2613    elementCnt = 1;
2614    controlRSetList->list.count = elementCnt;
2615    controlRSetList->list.size = \
2616                                 elementCnt * sizeof(struct ControlResourceSet *);
2617
2618    controlRSetList->list.array = NULLP;
2619    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2620    if(!controlRSetList->list.array)
2621    {
2622       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2623       return RFAILED;
2624    }
2625
2626    for(idx = 0; idx < elementCnt; idx++)
2627    {
2628       controlRSetList->list.array[idx] = NULLP;
2629       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2630       if(!controlRSetList->list.array[idx])
2631       {
2632          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2633          return RFAILED;
2634       }
2635    }
2636
2637    idx=0;
2638    controlRSet = controlRSetList->list.array[idx];
2639
2640    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2641
2642    /* size 6 bytes
2643     * 3 LSBs unsued
2644     * Bit string stored ff0000000000
2645     */
2646    numBytes = 6;
2647    bitsUnused = 3;
2648    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2649
2650    controlRSet->frequencyDomainResources.buf = NULLP;
2651    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2652          controlRSet->frequencyDomainResources.size);
2653    if(!controlRSet->frequencyDomainResources.buf)
2654    {
2655       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2656       return RFAILED;
2657    }
2658
2659    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2660    coreset0EndPrb = CORESET0_END_PRB;
2661    coreset1StartPrb = coreset0EndPrb + 6;
2662    coreset1NumPrb = CORESET1_NUM_PRB;
2663    /* calculate the PRBs */
2664    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2665    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2666    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2667
2668    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2669    controlRSet->cce_REG_MappingType.present = \
2670                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2671
2672    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2673    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2674    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2675    controlRSet->tci_PresentInDCI = NULLP;
2676 #if 0
2677    uint8_t tciStateIdx;
2678
2679    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2680          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2681    if(!controlRset->tci_StatesPDCCH_ToAddList)
2682    {
2683       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2684       return RFAILED;
2685    }
2686
2687    elementCnt = 1;
2688    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2689    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2690    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2691          controlRset->tci_StatesPDCCH_ToAddList->list.size)
2692       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2693       {
2694          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2695          return RFAILED;
2696       }
2697
2698    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2699    {
2700       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2701       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2702       {
2703          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2704          return RFAILED;
2705       }
2706    }
2707
2708    tciStateIdx = 0;
2709    /* TODO */
2710    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2711
2712    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2713    if(!controlRset->tci_PresentInDCI)
2714    {
2715       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2716       return RFAILED;
2717    }
2718    /* TODO */
2719    *(controlRset->tci_PresentInDCI);
2720 #endif
2721
2722    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2723    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2724    if(!controlRSet->pdcch_DMRS_ScramblingID)
2725    {
2726       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2727       return RFAILED;
2728    }
2729    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2730
2731    return ROK;
2732 } /* End BuildControlRSetToAddModList */
2733
2734 /*******************************************************************
2735  *
2736  * @brief Build search space to add/modify list
2737  *
2738  * @details
2739  *
2740  *    Function : BuildSearchSpcToAddModList
2741  *
2742  *    Functionality: Build search space to add/modify list
2743  *
2744  * @params[in]
2745  * @return ROK     - success
2746  *         RFAILED - failure
2747  *
2748  * ****************************************************************/
2749    uint8_t BuildSearchSpcToAddModList
2750 (
2751  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2752  )
2753 {
2754    uint8_t idx;
2755    uint8_t numBytes;
2756    uint8_t byteIdx;
2757    uint8_t bitsUnused;
2758    uint8_t elementCnt;
2759    struct SearchSpace *searchSpc;
2760
2761    elementCnt = 1;
2762    searchSpcList->list.count = elementCnt;
2763    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2764
2765    searchSpcList->list.array = NULLP;
2766    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2767    if(!searchSpcList->list.array)
2768    {
2769       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2770       return RFAILED;
2771    }
2772
2773    for(idx = 0; idx < elementCnt; idx++)
2774    {
2775       searchSpcList->list.array[idx] = NULLP;
2776       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2777       if(!searchSpcList->list.array[idx])
2778       {
2779          DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2780          return RFAILED;
2781       }
2782    }
2783
2784    idx = 0;
2785    searchSpc = searchSpcList->list.array[idx];
2786
2787    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2788
2789    searchSpc->controlResourceSetId = NULLP;
2790    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2791    if(!searchSpc->controlResourceSetId)
2792    {
2793       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2794       return RFAILED;
2795    }
2796    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2797
2798    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2799    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2800          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2801    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2802    {
2803       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2804       return RFAILED;
2805    }
2806    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2807                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2808
2809    searchSpc->duration = NULLP;
2810    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2811    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2812    if(!searchSpc->monitoringSymbolsWithinSlot)
2813    {
2814       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2815       return RFAILED;
2816    }
2817
2818    /* Values taken from reference logs :
2819     * size 2 bytes
2820     * 2 LSBs unsued
2821     * Bit string stores 8000
2822     */
2823    numBytes = 2;
2824    bitsUnused = 2;
2825
2826    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2827    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2828    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2829          searchSpc->monitoringSymbolsWithinSlot->size);
2830    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2831    {
2832       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2833       return RFAILED;
2834    }
2835
2836    byteIdx = 0;
2837    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2838                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2839    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2840    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2841
2842    searchSpc->nrofCandidates = NULLP;
2843    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2844    if(!searchSpc->nrofCandidates)
2845    {
2846       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2847       return RFAILED;
2848    }
2849
2850    searchSpc->nrofCandidates->aggregationLevel1 = \
2851                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
2852    searchSpc->nrofCandidates->aggregationLevel2 = \
2853                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
2854    searchSpc->nrofCandidates->aggregationLevel4 = \
2855                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
2856    searchSpc->nrofCandidates->aggregationLevel8 = \
2857                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
2858    searchSpc->nrofCandidates->aggregationLevel16 = \
2859                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
2860
2861    searchSpc->searchSpaceType = NULLP;
2862    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
2863    if(!searchSpc->searchSpaceType)
2864    {
2865       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2866       return RFAILED;
2867    }
2868
2869    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
2870
2871    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
2872    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
2873          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
2874    if(!searchSpc->searchSpaceType->choice.ue_Specific)
2875    {
2876       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2877       return RFAILED;
2878    }
2879    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
2880                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
2881
2882    return ROK;
2883 }/* End BuildSearchSpcToAddModList */
2884
2885 /*******************************************************************
2886  *
2887  * @brief Builds BWP DL dedicated PDCCH config
2888  *
2889  * @details
2890  *
2891  *    Function : BuildBWPDlDedPdcchCfg
2892  *
2893  *    Functionality: Builds BWP DL dedicated PDCCH config
2894  *
2895  * @params[in] struct PDCCH_Config *pdcchCfg
2896  *
2897  * @return ROK     - success
2898  *         RFAILED - failure
2899  *
2900  * ****************************************************************/
2901 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
2902 {
2903    pdcchCfg->controlResourceSetToAddModList = NULLP;
2904    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
2905          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
2906    if(!pdcchCfg->controlResourceSetToAddModList)
2907    {
2908       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2909       return RFAILED;
2910    }
2911
2912    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
2913    {
2914       return RFAILED;
2915    }
2916
2917    pdcchCfg->controlResourceSetToReleaseList = NULLP;
2918
2919    pdcchCfg->searchSpacesToAddModList = NULLP;
2920    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
2921          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
2922    if(!pdcchCfg->searchSpacesToAddModList)
2923    {
2924       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2925       return RFAILED;
2926    }
2927
2928    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
2929    {
2930       return RFAILED;
2931    }
2932
2933    pdcchCfg->searchSpacesToReleaseList = NULLP;
2934    pdcchCfg->downlinkPreemption = NULLP;
2935    pdcchCfg->tpc_PUSCH = NULLP;
2936    pdcchCfg->tpc_PUCCH = NULLP;
2937    pdcchCfg->tpc_SRS = NULLP;
2938
2939    return ROK;
2940 }
2941
2942 /*******************************************************************
2943  *
2944  * @brief Builds DMRS DL PDSCH Mapping type A
2945  *
2946  * @details
2947  *
2948  *    Function : BuildDMRSDLPdschMapTypeA
2949  *
2950  *    Functionality: Builds DMRS DL PDSCH Mapping type A
2951  *
2952  * @params[in]
2953  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2954  * @return ROK     - success
2955  *         RFAILED - failure
2956  *
2957  * ****************************************************************/
2958    uint8_t BuildDMRSDLPdschMapTypeA
2959 (
2960  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
2961  )
2962 {
2963    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
2964    dmrsDlCfg->choice.setup = NULLP;
2965    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
2966    if(!dmrsDlCfg->choice.setup)
2967    {
2968       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
2969       return RFAILED;
2970    }
2971
2972    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
2973    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
2974    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
2975    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
2976    {
2977       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
2978       return RFAILED;
2979    }
2980    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
2981
2982    dmrsDlCfg->choice.setup->maxLength = NULLP;
2983    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
2984    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
2985    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
2986
2987    return ROK;
2988 }
2989
2990 /*******************************************************************
2991  *
2992  * @brief Builds TCI states to add/modify list
2993  *
2994  * @details
2995  *
2996  *    Function : BuildTCIStatesToAddModList
2997  *
2998  *    Functionality:Builds TCI states to add/modify list
2999  *
3000  * @params[in]
3001  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3002  *
3003  * @return ROK     - success
3004  *         RFAILED - failure
3005  *
3006  * ****************************************************************/
3007 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3008 {
3009    return ROK;
3010 }
3011
3012 /*******************************************************************
3013  *
3014  * @brief Builds PDSCH time domain allocation list
3015  *
3016  * @details
3017  *
3018  *    Function : BuildPdschTimeDomAllocList
3019  *
3020  *    Functionality: Builds PDSCH time domain allocation list
3021  *
3022  * @params[in]
3023  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3024  *
3025  * @return ROK     - success
3026  *         RFAILED - failure
3027  *
3028  * ****************************************************************/
3029    uint8_t BuildPdschTimeDomAllocList
3030 (
3031  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3032  )
3033 {
3034    uint8_t idx;
3035    uint8_t elementCnt;
3036    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3037
3038    timeDomAllocList->present = \
3039                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3040
3041    timeDomAllocList->choice.setup = NULLP;
3042    DU_ALLOC(timeDomAllocList->choice.setup, \
3043          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3044    if(!timeDomAllocList->choice.setup)
3045    {
3046       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3047       return RFAILED;
3048    }
3049
3050    elementCnt = 1;
3051    timeDomAllocList->choice.setup->list.count = elementCnt;
3052    timeDomAllocList->choice.setup->list.size = \
3053                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3054
3055    timeDomAllocList->choice.setup->list.array = NULLP;
3056    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3057          timeDomAllocList->choice.setup->list.size);
3058    if(!timeDomAllocList->choice.setup->list.array)
3059    {
3060       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3061       return RFAILED;
3062    }
3063
3064    for(idx = 0; idx < elementCnt; idx++)
3065    {
3066       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3067       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3068             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3069       if(!timeDomAllocList->choice.setup->list.array[idx])
3070       {
3071          DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3072          return RFAILED;
3073       }
3074    }
3075
3076    idx = 0;
3077    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3078
3079    timeDomAlloc->k0 = NULLP;
3080    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3081    timeDomAlloc->startSymbolAndLength = \
3082                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3083
3084    return ROK;
3085 }
3086
3087 /*******************************************************************
3088  *
3089  * @brief Builds PDSCH PRB Bundling type
3090  *
3091  * @details
3092  *
3093  *    Function : BuildPdschPrbBundlingType
3094  *
3095  *    Functionality: Builds PDSCH PRB Bundling type
3096  *
3097  * @params[in]
3098  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3099  *
3100  * @return ROK     - success
3101  *         RFAILED - failure
3102  *
3103  * ****************************************************************/
3104    uint8_t BuildPdschPrbBundlingType
3105 (
3106  struct PDSCH_Config__prb_BundlingType *prbBndlType
3107  )
3108 {
3109    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3110
3111    prbBndlType->choice.staticBundling = NULLP;
3112    DU_ALLOC(prbBndlType->choice.staticBundling, \
3113          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3114    if(!prbBndlType->choice.staticBundling)
3115    {
3116       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3117       return RFAILED;
3118    }
3119    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3120
3121    return ROK;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Builds BWP DL dedicated PDSCH config
3127  *
3128  * @details
3129  *
3130  *    Function : BuildBWPDlDedPdschCfg
3131  *
3132  *    Functionality: Builds BWP DL dedicated PDSCH config
3133  *
3134  * @params[in] struct PDSCH_Config *pdschCfg
3135  *
3136  * @return ROK     - success
3137  *         RFAILED - failure
3138  *
3139  * ****************************************************************/
3140 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3141 {
3142    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3143
3144    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3145    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3146          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3147    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3148    {
3149       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3150       return RFAILED;
3151    }
3152
3153    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3154    {
3155       return RFAILED;
3156    }
3157
3158    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3159    pdschCfg->tci_StatesToAddModList = NULLP;
3160    pdschCfg->tci_StatesToReleaseList = NULLP;
3161    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3162 #if 0
3163    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3164    if(!pdschCfg->tci_StatesToAddModList)
3165    {
3166       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3167       return RFAILED;
3168    }
3169    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3170    {
3171       return RFAILED;
3172    }
3173 #endif
3174
3175    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3176
3177    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3178    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3179          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3180    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3181    {
3182       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3183       return RFAILED;
3184    }
3185
3186    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3187    {
3188       return RFAILED;
3189    }
3190
3191    pdschCfg->pdsch_AggregationFactor = NULLP;
3192    pdschCfg->rateMatchPatternToAddModList = NULLP;
3193    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3194    pdschCfg->rateMatchPatternGroup1 = NULLP;
3195    pdschCfg->rateMatchPatternGroup2 = NULLP;
3196    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3197    pdschCfg->mcs_Table = NULLP;
3198
3199    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3200    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3201    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3202    {
3203       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3204       return RFAILED;
3205    }
3206    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3207
3208    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3209    {
3210       return RFAILED;
3211    }
3212
3213    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3214    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3215    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3216    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3217    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3218    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3219    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3220
3221    return ROK;
3222 }
3223
3224 /*******************************************************************
3225  *
3226  * @brief Builds intitial DL BWP
3227  * @details
3228  *
3229  *    Function : BuildInitialDlBWP
3230  *
3231  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3232  *
3233  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3234  *
3235  * @return ROK     - success
3236  *         RFAILED - failure
3237  *
3238  * ****************************************************************/
3239 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3240 {
3241    dlBwp->pdcch_Config = NULLP;
3242    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3243    if(!dlBwp->pdcch_Config)
3244    {
3245       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3246       return RFAILED;
3247    }
3248    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3249
3250    dlBwp->pdcch_Config->choice.setup = NULLP;
3251    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3252    if(!dlBwp->pdcch_Config->choice.setup)
3253    {
3254       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3255       return RFAILED;
3256    }
3257    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3258    {
3259       return RFAILED;
3260    }
3261
3262    dlBwp->pdsch_Config = NULLP;
3263    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3264    if(!dlBwp->pdsch_Config)
3265    {
3266       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3267       return RFAILED;
3268    }
3269    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3270
3271    dlBwp->pdsch_Config->choice.setup = NULLP;
3272    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3273    if(!dlBwp->pdsch_Config->choice.setup)
3274    {
3275       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3276       return RFAILED;
3277    }
3278
3279    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3280    {
3281       return RFAILED;
3282    }
3283
3284    dlBwp->sps_Config = NULLP;
3285    dlBwp->radioLinkMonitoringConfig = NULLP;
3286    return ROK;
3287 }
3288
3289 /*******************************************************************
3290  *
3291  * @brief Builds DMRS UL Pusch Mapping type A
3292  *
3293  * @details
3294  *
3295  *    Function : BuildDMRSULPuschMapTypeA
3296  *
3297  *    Functionality: Builds DMRS UL Pusch Mapping type A
3298  *
3299  * @params[in]
3300  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3301  * @return ROK     - success
3302  *         RFAILED - failure
3303  *
3304  * ****************************************************************/
3305    uint8_t BuildDMRSULPuschMapTypeA
3306 (
3307  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3308  )
3309 {
3310    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3311    dmrsUlCfg->choice.setup= NULLP;
3312    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3313    if(!dmrsUlCfg->choice.setup)
3314    {
3315       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3316       return RFAILED;
3317    }
3318
3319    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3320    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3321    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3322    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3323    {
3324       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3325       return RFAILED;
3326    }
3327    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3328
3329    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3330    dmrsUlCfg->choice.setup->maxLength = NULLP;
3331    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3332    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3333          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3334    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3335    {
3336       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3337       return RFAILED;
3338    }
3339
3340    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3341    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3342          sizeof(long));
3343    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3344    {
3345       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3346       return RFAILED;
3347    }
3348    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3349
3350    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3351    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3352    return ROK;
3353 }
3354
3355 /*******************************************************************
3356  *
3357  * @brief Build PUSCH time domain allocation list
3358  *
3359  * @details
3360  *
3361  *    Function : BuildPuschTimeDomAllocList
3362  *
3363  *    Functionality: Build PUSCH time domain allocation list
3364  *
3365  * @params[in]
3366  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3367  *
3368  * @return ROK     - success
3369  *         RFAILED - failure
3370  *
3371  * ****************************************************************/
3372    uint8_t BuildPuschTimeDomAllocList
3373 (
3374  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3375  )
3376 {
3377    uint8_t idx;
3378    uint8_t elementCnt;
3379    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3380
3381    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3382    timeDomAllocList->choice.setup = NULLP;
3383    DU_ALLOC(timeDomAllocList->choice.setup, \
3384          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3385    if(!timeDomAllocList->choice.setup)
3386    {
3387       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3388       return RFAILED;
3389    }
3390
3391    elementCnt = 1;
3392    timeDomAllocList->choice.setup->list.count = elementCnt;
3393    timeDomAllocList->choice.setup->list.size = \
3394                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3395    timeDomAllocList->choice.setup->list.array = NULLP;
3396    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3397          timeDomAllocList->choice.setup->list.size);
3398    if(!timeDomAllocList->choice.setup->list.array)
3399    {
3400       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3401       return RFAILED;
3402    }
3403
3404    for(idx = 0; idx < elementCnt; idx++)
3405    {
3406       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3407       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3408             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3409       if(!timeDomAllocList->choice.setup->list.array[idx])
3410       {
3411          DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3412          return RFAILED;
3413       }
3414    }
3415
3416    idx = 0;
3417    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3418    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3419    if(!timeDomAlloc->k2)
3420    {
3421       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3422       return RFAILED;
3423    }
3424    *(timeDomAlloc->k2) = PUSCH_K2;
3425    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3426    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3427    return ROK;
3428 }
3429
3430 /*******************************************************************
3431  *
3432  * @brief Builds BWP UL dedicated PUSCH Config
3433  *
3434  * @details
3435  *
3436  *    Function : BuildBWPUlDedPuschCfg
3437  *
3438  *    Functionality:
3439  *      Builds BWP UL dedicated PUSCH Config
3440  *
3441  * @params[in] : PUSCH_Config_t *puschCfg
3442  *
3443  * @return ROK     - success
3444  *         RFAILED - failure
3445  *
3446  * ****************************************************************/
3447 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3448 {
3449    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3450    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3451    if(!puschCfg->dataScramblingIdentityPUSCH)
3452    {
3453       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3454       return RFAILED;
3455    }
3456    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3457
3458    puschCfg->txConfig = NULLP;
3459    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3460    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3461          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3462    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3463    {
3464       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3465       return RFAILED;
3466    }
3467
3468    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3469    {
3470       return RFAILED;
3471    }
3472
3473    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3474    puschCfg->pusch_PowerControl = NULLP;
3475    puschCfg->frequencyHopping = NULLP;
3476    puschCfg->frequencyHoppingOffsetLists = NULLP;
3477    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3478
3479    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3480    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3481          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3482    if(!puschCfg->pusch_TimeDomainAllocationList)
3483    {
3484       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3485       return RFAILED;
3486    }
3487
3488    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3489    {
3490       return RFAILED;
3491    }
3492
3493    puschCfg->pusch_AggregationFactor = NULLP;
3494    puschCfg->mcs_Table = NULLP;
3495    puschCfg->mcs_TableTransformPrecoder = NULLP;
3496    puschCfg->transformPrecoder = NULLP;
3497    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3498    if(!puschCfg->transformPrecoder)
3499    {
3500       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3501       return RFAILED;
3502    }
3503    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3504
3505    puschCfg->codebookSubset = NULLP;
3506    puschCfg->maxRank = NULLP;
3507    puschCfg->rbg_Size = NULLP;
3508    puschCfg->uci_OnPUSCH = NULLP;
3509    puschCfg->tp_pi2BPSK = NULLP;
3510
3511    return ROK;
3512 }
3513
3514 /*******************************************************************
3515  *
3516  * @brief Fills SRS resource to add/modify list
3517  *
3518  * @details
3519  *
3520  *    Function : BuildSrsRsrcAddModList
3521  *
3522  *    Functionality: Fills SRS resource to add/modify list
3523  *
3524  * @params[in]
3525  * @return ROK     - success
3526  *         RFAILED - failure
3527  *
3528  * ****************************************************************/
3529 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3530 {
3531    uint8_t   elementCnt;
3532    uint8_t   rsrcIdx;
3533
3534    elementCnt = 1;
3535    resourceList->list.count = elementCnt;
3536    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3537    resourceList->list.array = NULLP;
3538    DU_ALLOC(resourceList->list.array, resourceList->list.size);
3539    if(!resourceList->list.array)
3540    {
3541       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3542       return RFAILED;
3543    }
3544
3545    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3546    {
3547       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3548       if(!resourceList->list.array[rsrcIdx])
3549       {
3550          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3551          return RFAILED;
3552       }
3553    }
3554
3555    rsrcIdx = 0;
3556    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3557    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3558    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3559
3560    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3561    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3562          sizeof(struct SRS_Resource__transmissionComb__n2));
3563    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3564    {
3565       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3566       return RFAILED;
3567    }
3568    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3569       = SRS_COMB_OFFSET_N2;
3570    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3571       = SRS_CYCLIC_SHIFT_N2;
3572
3573    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3574                                                                       PUSCH_START_SYMBOL;
3575    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3576                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
3577    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3578                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
3579
3580    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3581    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3582    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3583    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3584    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3585    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3586                                                                SRS_Resource__groupOrSequenceHopping_neither;
3587
3588    /* Setting resource type to aperiodic for intergration purposes */
3589    resourceList->list.array[rsrcIdx]->resourceType.present = \
3590                                                              SRS_Resource__resourceType_PR_aperiodic;
3591    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3592    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3593          sizeof(struct SRS_Resource__resourceType__aperiodic));
3594    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3595    {
3596       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3597       return RFAILED;
3598    }
3599    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3600
3601    return ROK;
3602 }
3603
3604 /*******************************************************************
3605  *
3606  * @brief Build SRS resource set Add/mod list
3607  *
3608  * @details
3609  *
3610  *    Function : BuildSrsRsrcSetAddModList
3611  *
3612  *    Functionality: Build SRS resource set Add/mod list
3613  *
3614  * @params[in]
3615  * @return ROK     - success
3616  *         RFAILED - failure
3617  *
3618  * ****************************************************************/
3619    uint8_t BuildSrsRsrcSetAddModList
3620 (
3621  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3622  )
3623 {
3624    uint8_t  elementCnt;
3625    uint8_t  rSetIdx;
3626    uint8_t  rsrcIdx;
3627    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3628
3629    elementCnt = 1;
3630    rsrcSetList->list.count = elementCnt;
3631    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3632    rsrcSetList->list.array = NULLP;
3633    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3634    if(!rsrcSetList->list.array)
3635    {
3636       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3637       return RFAILED;
3638    }
3639
3640    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3641    {
3642       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3643       if(!rsrcSetList->list.array[rSetIdx])
3644       {
3645          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3646          return RFAILED;
3647       }
3648    }
3649
3650    rSetIdx = 0;
3651    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3652
3653    /* Fill Resource Id list in resource set */
3654    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3655    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3656          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3657    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3658    {
3659       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3660       return RFAILED;
3661    }
3662
3663    elementCnt = 1;
3664    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3665    rsrcIdList->list.count = elementCnt;
3666    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3667    rsrcIdList->list.array = NULLP;
3668    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3669    if(!rsrcIdList->list.array)
3670    {
3671       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3672       return RFAILED;
3673    }
3674
3675    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3676    {
3677       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3678       if(!rsrcIdList->list.array[rsrcIdx])
3679       {
3680          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3681          return RFAILED;
3682       }
3683    }
3684
3685    rsrcIdx = 0;
3686    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3687
3688    /* Fill resource type */
3689    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3690                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
3691
3692    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3693    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3694          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3695    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3696    {
3697       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3698       return RFAILED;
3699    }
3700    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3701       = APERIODIC_SRS_RESRC_TRIGGER;
3702
3703    /* TODO : Fill values for below IEs as expected by Viavi */
3704    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3705    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3706
3707
3708    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3709    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3710    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3711    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3712    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3713
3714    return ROK;
3715 }
3716
3717 /*******************************************************************
3718  *
3719  * @brief Builds BWP UL dedicated SRS Config
3720  *
3721  * @details
3722  *
3723  *    Function : BuildBWPUlDedSrsCfg
3724  *
3725  *    Functionality: Builds BWP UL dedicated SRS Config
3726  *
3727  * @params[in] SRS Config
3728  * @return ROK     - success
3729  *         RFAILED - failure
3730  *
3731  * ****************************************************************/
3732 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3733 {
3734    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3735    srsCfg->srs_ResourceSetToAddModList = NULLP;
3736    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3737          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3738    if(!srsCfg->srs_ResourceSetToAddModList)
3739    {
3740       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3741       return RFAILED;
3742    }
3743    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3744    {
3745       return RFAILED;
3746    }
3747
3748    srsCfg->srs_ResourceToReleaseList = NULLP;
3749
3750    /* Resource to Add/Modify list */
3751    srsCfg->srs_ResourceToAddModList = NULLP;
3752    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3753          sizeof(struct SRS_Config__srs_ResourceToAddModList));
3754    if(!srsCfg->srs_ResourceToAddModList)
3755    {
3756       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3757       return RFAILED;
3758    }
3759
3760    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3761    {
3762       return RFAILED;
3763    }
3764
3765    srsCfg->tpc_Accumulation = NULLP;
3766
3767    return ROK;
3768 }
3769
3770
3771
3772 /*******************************************************************
3773  *
3774  * @brief Builds Pusch Serving cell Config
3775  *
3776  * @details
3777  *
3778  *    Function : BuildPuschSrvCellCfg
3779  *
3780  *    Functionality: Builds Pusch Serving cell Config
3781  *
3782  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
3783  *
3784  * @return ROK     - success
3785  *         RFAILED - failure
3786  *
3787  * ****************************************************************/
3788 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
3789 {
3790    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
3791    puschCfg->choice.setup = NULLP;
3792    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
3793    if(!puschCfg->choice.setup)
3794    {
3795       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3796       return RFAILED;
3797    }
3798
3799    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3800    puschCfg->choice.setup->rateMatching = NULLP;
3801    puschCfg->choice.setup->xOverhead = NULLP;
3802    puschCfg->choice.setup->ext1 = NULLP;
3803    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
3804    if(!puschCfg->choice.setup->ext1)
3805    {
3806       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3807       return RFAILED;
3808    }
3809
3810    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
3811    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
3812    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
3813    {
3814       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3815       return RFAILED;
3816    }
3817    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
3818
3819    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
3820    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
3821    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
3822    {
3823       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3824       return RFAILED;
3825    }
3826    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
3827    return ROK;
3828 }
3829
3830 /*******************************************************************
3831  *
3832  * @brief Builds inital UL BWP
3833  *
3834  * @details
3835  *
3836  *    Function : BuildInitialUlBWP
3837  *
3838  *    Functionality: Builds initial UL BWP
3839  *
3840  * @params[in] BWP_UplinkDedicated_t *ulBwp
3841  * @return ROK     - success
3842  *         RFAILED - failure
3843  *
3844  * ****************************************************************/
3845 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
3846 {
3847    ulBwp->pucch_Config = NULLP;
3848
3849    /* Fill BWP UL dedicated PUSCH config */
3850    ulBwp->pusch_Config = NULLP;
3851    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
3852    if(!ulBwp->pusch_Config)
3853    {
3854       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3855       return RFAILED;
3856    }
3857
3858    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
3859    ulBwp->pusch_Config->choice.setup = NULLP;
3860    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
3861    if(!ulBwp->pusch_Config->choice.setup)
3862    {
3863       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3864       return RFAILED;
3865    }
3866
3867    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
3868    {
3869       return RFAILED;
3870    }
3871
3872    ulBwp->configuredGrantConfig = NULLP;
3873
3874    /* Fill BPW UL dedicated SRS config */
3875    ulBwp->srs_Config = NULLP;
3876    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
3877    if(!ulBwp->srs_Config)
3878    {
3879       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3880       return RFAILED;
3881    }
3882
3883    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
3884    ulBwp->srs_Config->choice.setup = NULLP;
3885    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
3886    if(!ulBwp->srs_Config->choice.setup)
3887    {
3888       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3889       return RFAILED;
3890    }
3891
3892    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
3893    {
3894       return RFAILED;
3895    }
3896
3897    ulBwp->beamFailureRecoveryConfig = NULLP;
3898
3899    return ROK;
3900 }
3901
3902 /*******************************************************************
3903  *
3904  * @brief Builds UL config
3905  * @details
3906  *
3907  *    Function : BuildUlCfg
3908  *
3909  *    Functionality: Builds UL config in spCellCfgDed
3910  *
3911  * @params[in] UplinkConfig_t *ulCfg
3912  *
3913  * @return ROK     - success
3914  *         RFAILED - failure
3915  *
3916  * ****************************************************************/
3917 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
3918 {
3919    ulCfg->initialUplinkBWP = NULLP;
3920    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
3921    if(!ulCfg->initialUplinkBWP)
3922    {
3923       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3924       return RFAILED;
3925    }
3926
3927    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
3928    {
3929       return RFAILED;
3930    }
3931
3932    ulCfg->uplinkBWP_ToReleaseList = NULLP;
3933    ulCfg->uplinkBWP_ToAddModList = NULLP;
3934    ulCfg->firstActiveUplinkBWP_Id = NULLP;
3935    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
3936    if(!ulCfg->firstActiveUplinkBWP_Id)
3937    {
3938       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3939       return RFAILED;
3940    }
3941    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
3942
3943    ulCfg->pusch_ServingCellConfig = NULLP;
3944    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
3945          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
3946    if(!ulCfg->pusch_ServingCellConfig)
3947    {
3948       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
3949       return RFAILED;
3950    }
3951
3952    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
3953    {
3954       return RFAILED;
3955    }
3956
3957    ulCfg->carrierSwitching = NULLP;
3958    ulCfg->ext1 = NULLP;
3959    return ROK;
3960 }
3961
3962 /*******************************************************************
3963  *
3964  * @brief Builds PDSCH serving cell config
3965  * @details
3966  *
3967  *    Function : BuildPdschSrvCellCfg
3968  *
3969  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
3970  *
3971  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
3972  *
3973  * @return ROK     - success
3974  *         RFAILED - failure
3975  *
3976  * ****************************************************************/
3977 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
3978 {
3979    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
3980    pdschCfg->choice.setup = NULLP;
3981    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
3982    if(!pdschCfg->choice.setup)
3983    {
3984       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
3985       return RFAILED;
3986    }
3987
3988    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3989    pdschCfg->choice.setup->xOverhead = NULLP;
3990    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
3991    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
3992    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
3993    {
3994       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
3995       return RFAILED;
3996    }
3997    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
3998    pdschCfg->choice.setup->pucch_Cell = NULLP;
3999    pdschCfg->choice.setup->ext1 = NULLP;
4000
4001    return ROK;
4002 }
4003
4004 /*******************************************************************
4005  *
4006  * @brief Builds CSI Meas config
4007  * @details
4008  *
4009  *    Function : BuildCsiMeasCfg
4010  *
4011  *    Functionality: Builds CSI Meas config in spCellCfgDed
4012  *
4013  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4014  *
4015  * @return ROK     - success
4016  *         RFAILED - failure
4017  *
4018  * ****************************************************************/
4019 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4020 {
4021
4022    return ROK;
4023 }
4024
4025 /*******************************************************************
4026  *
4027  * @brief Builds Spcell config dedicated
4028  * @details
4029  *
4030  *    Function : BuildSpCellCfgDed
4031  *
4032  *    Functionality: Builds sp cell config dedicated in spCellCfg
4033  *
4034  * @params[in] ServingCellConfig_t srvCellCfg
4035  *
4036  * @return ROK     - success
4037  *         RFAILED - failure
4038  *
4039  * ****************************************************************/
4040 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4041 {
4042    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4043    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4044    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4045    {
4046       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4047       return RFAILED;
4048    }
4049
4050    srvCellCfg->initialDownlinkBWP = NULLP;
4051    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4052    if(!srvCellCfg->initialDownlinkBWP)
4053    {
4054       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4055       return RFAILED;
4056    }
4057
4058    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4059    {
4060       DU_LOG("\nF1AP : BuildInitialDlBWP failed");
4061       return RFAILED;
4062    }
4063    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4064    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4065
4066    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4067    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4068    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4069    {
4070       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4071       return RFAILED;
4072    }
4073    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4074
4075    srvCellCfg->bwp_InactivityTimer = NULLP;
4076
4077    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4078    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4079    if(!srvCellCfg->defaultDownlinkBWP_Id)
4080    {
4081       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4082       return RFAILED;
4083    }
4084    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4085
4086    srvCellCfg->uplinkConfig = NULLP;
4087    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4088    if(!srvCellCfg->uplinkConfig)
4089    {
4090       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4091       return RFAILED;
4092    }
4093
4094    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4095    {
4096       DU_LOG("\nF1AP : BuildUlCfg failed");
4097       return RFAILED;
4098    }
4099    srvCellCfg->supplementaryUplink = NULLP;
4100    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4101
4102    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4103    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4104    if(!srvCellCfg->pdsch_ServingCellConfig)
4105    {
4106       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4107       return RFAILED;
4108    }
4109
4110    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4111    {
4112       DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
4113       return RFAILED;
4114    }
4115
4116    srvCellCfg->csi_MeasConfig = NULLP;
4117 #if 0
4118    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4119       if(!srvCellCfg->csi_MeasConfig)
4120       {
4121          DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4122          return RFAILED;
4123       }
4124
4125    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4126    {
4127       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4128       return RFAILED;
4129    }
4130 #endif
4131    srvCellCfg->sCellDeactivationTimer = NULLP;
4132    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4133    srvCellCfg->tag_Id = TAG_ID;
4134    srvCellCfg->dummy = NULLP;
4135    srvCellCfg->pathlossReferenceLinking = NULLP;
4136    srvCellCfg->servingCellMO = NULLP;
4137    srvCellCfg->ext1 = NULLP;
4138
4139    return ROK;
4140 }
4141 /*******************************************************************
4142  *
4143  * @brief Builds Spcell config
4144  *
4145  * @details
4146  *
4147  *    Function : BuildSpCellCfg
4148  *
4149  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4150  *
4151  * @params[in] SpCellConfig_t spCellCfg
4152  *
4153  * @return ROK     - success
4154  *         RFAILED - failure
4155  *
4156  * ****************************************************************/
4157 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4158 {
4159
4160    spCellCfg->servCellIndex = NULLP;
4161    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4162    if(!spCellCfg->servCellIndex)
4163    {
4164       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4165       return RFAILED;
4166    }
4167    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4168
4169    spCellCfg->reconfigurationWithSync = NULLP;
4170    spCellCfg->rlf_TimersAndConstants = NULLP;
4171    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4172    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4173    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4174    {
4175       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4176       return RFAILED;
4177    }
4178    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4179
4180    spCellCfg->spCellConfigDedicated = NULLP;
4181    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4182    if(!spCellCfg->spCellConfigDedicated)
4183    {
4184       DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4185       return RFAILED;
4186    }
4187    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4188    {
4189       DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
4190       return RFAILED;
4191    }
4192    return ROK;
4193 }
4194 /*******************************************************************
4195  *
4196  * @brief Builds Phy cell group config
4197  *
4198  * @details
4199  *
4200  *    Function : BuildPhyCellGrpCfg
4201  *
4202  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4203  *
4204  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4205  *
4206  * @return ROK     - success
4207  *         RFAILED - failure
4208  *
4209  * ****************************************************************/
4210 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4211 {
4212    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4213    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4214
4215    phyCellGrpCfg->p_NR_FR1 = NULLP;
4216    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4217    if(!phyCellGrpCfg->p_NR_FR1)
4218    {
4219       DU_LOG("\nF1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4220       return RFAILED;
4221    }
4222    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4223    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4224    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4225    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4226    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4227    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4228    phyCellGrpCfg->cs_RNTI = NULLP;
4229    phyCellGrpCfg->ext1 = NULLP;
4230    phyCellGrpCfg->ext2 = NULLP;
4231
4232    return ROK;
4233 }
4234 /*******************************************************************
4235  *
4236  * @brief Builds Mac cell group config
4237  *
4238  * @details
4239  *
4240  *    Function : BuildMacCellGrpCfg
4241  *
4242  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4243  *
4244  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4245  *
4246  * @return ROK     - success
4247  *         RFAILED - failure
4248  *
4249  * ****************************************************************/
4250 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4251 {
4252    macCellGrpCfg->drx_Config = NULLP;
4253    macCellGrpCfg->schedulingRequestConfig = NULLP;
4254    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4255    if(!macCellGrpCfg->schedulingRequestConfig)
4256    {
4257       DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4258       return RFAILED;
4259    }
4260
4261    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4262    {
4263       DU_LOG("\nF1AP : BuildSchedulingReqConfig failed");
4264       return RFAILED;
4265    }
4266
4267    macCellGrpCfg->bsr_Config = NULLP;
4268    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4269    if(!macCellGrpCfg->bsr_Config)
4270    {
4271       DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4272       return RFAILED;
4273    }
4274
4275    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4276    {
4277       DU_LOG("\nF1AP : BuildBsrConfig failed");
4278       return RFAILED;
4279    }
4280
4281    macCellGrpCfg->tag_Config = NULLP;
4282    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4283    if(!macCellGrpCfg->tag_Config)
4284    {
4285       DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4286       return RFAILED;
4287    }
4288
4289    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4290    {
4291       DU_LOG("\nF1AP : BuildTagConfig failed");
4292       return RFAILED;
4293    }
4294
4295    macCellGrpCfg->phr_Config = NULLP;
4296    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4297    if(!macCellGrpCfg->phr_Config)
4298    {
4299       DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4300       return RFAILED;
4301    }
4302
4303    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4304    {
4305       DU_LOG("\nF1AP : BuildPhrConfig failed");
4306       return RFAILED;
4307    }
4308
4309    macCellGrpCfg->skipUplinkTxDynamic = false;
4310    macCellGrpCfg->ext1 = NULLP;
4311
4312    return ROK;
4313 }
4314 /*******************************************************************
4315  *
4316  * @brief Frees memeory allocated for SearchSpcToAddModList
4317  *
4318  * @details
4319  *
4320  *    Function : FreeSearchSpcToAddModList
4321  *
4322  *    Functionality: Deallocating memory of SearchSpcToAddModList
4323  *
4324  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4325  *
4326  * @return void
4327  *
4328  4221 * ****************************************************************/
4329 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4330 {
4331    uint8_t idx1=0;
4332    uint8_t idx2=0;
4333    struct  SearchSpace *searchSpc=NULLP;
4334
4335    if(searchSpcList->list.array)
4336    {
4337       if(searchSpcList->list.array[idx2])
4338       {
4339          searchSpc = searchSpcList->list.array[idx2];
4340          if(searchSpc->controlResourceSetId)
4341          {
4342             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4343             {
4344                if(searchSpc->monitoringSymbolsWithinSlot)
4345                {
4346                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4347                   {
4348                      if(searchSpc->nrofCandidates)
4349                      {
4350                         if(searchSpc->searchSpaceType)
4351                         {
4352                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4353                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4354                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4355                                     SearchSpace__searchSpaceType));
4356                         }
4357                         DU_FREE(searchSpc->nrofCandidates,
4358                               sizeof(struct SearchSpace__nrofCandidates));
4359                      }
4360                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4361                            searchSpc->monitoringSymbolsWithinSlot->size);
4362                   }
4363                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4364                         sizeof(BIT_STRING_t));
4365                }
4366                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4367                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4368             }
4369             DU_FREE(searchSpc->controlResourceSetId,
4370                   sizeof(ControlResourceSetId_t));
4371          }
4372       }
4373       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4374       {
4375          DU_FREE(searchSpcList->list.array[idx1],
4376                sizeof(struct SearchSpace));
4377       }
4378       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4379    }
4380 }
4381 /*******************************************************************
4382  *
4383  * @brief Frees memory allocated for PdschTimeDomAllocList
4384  *
4385  * @details
4386  *
4387  *    Function : FreePdschTimeDomAllocList
4388  *
4389  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4390  *
4391  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4392  *
4393  * @return void
4394  *
4395  4221 * ****************************************************************/
4396 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4397 {
4398    uint8_t idx1=0;
4399
4400    if(timeDomAllocList->choice.setup)
4401    {
4402       if(timeDomAllocList->choice.setup->list.array)
4403       {
4404          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4405          {
4406             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4407                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4408          }
4409          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4410                timeDomAllocList->choice.setup->list.size);
4411       }
4412       DU_FREE(timeDomAllocList->choice.setup,\
4413             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4414    }
4415 }
4416 /*******************************************************************
4417  *
4418  * @brief Frees memory allocated for PuschTimeDomAllocList
4419  *
4420  *@details
4421  *
4422  *    Function : FreePuschTimeDomAllocList
4423  *
4424  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4425  *
4426  * @params[in] PUSCH_Config_t *puschCfg
4427  *
4428  * @return void
4429  *
4430  4221 * ****************************************************************/
4431 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4432 {
4433    uint8_t idx1=0;
4434    uint8_t idx2=0;
4435    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4436
4437    if(puschCfg->pusch_TimeDomainAllocationList)
4438    {
4439       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4440       if(timeDomAllocList_t->choice.setup)
4441       {
4442          if(timeDomAllocList_t->choice.setup->list.array)
4443          {
4444             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4445             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4446             {
4447                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4448                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4449             }
4450             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4451                   timeDomAllocList_t->choice.setup->list.size);
4452          }
4453          DU_FREE(timeDomAllocList_t->choice.setup, \
4454                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4455       }
4456       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4457       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4458             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4459    }
4460
4461 }
4462 /*******************************************************************
4463  *
4464  * @brief Frees memory allocated for InitialUlBWP
4465  *
4466  * @details
4467  *
4468  *    Function : FreeInitialUlBWP
4469  *
4470  *    Functionality: Deallocating memory of InitialUlBWP
4471  *
4472  * @params[in] BWP_UplinkDedicated_t *ulBwp
4473  *
4474  * @return void
4475  *
4476  * ****************************************************************/
4477 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4478 {
4479    uint8_t  rSetIdx, rsrcIdx;
4480    SRS_Config_t   *srsCfg = NULLP;
4481    PUSCH_Config_t *puschCfg = NULLP;
4482    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4483    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4484    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4485    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4486
4487    if(ulBwp->pusch_Config)
4488    {
4489       if(ulBwp->pusch_Config->choice.setup)
4490       {
4491          puschCfg=ulBwp->pusch_Config->choice.setup;
4492          if(puschCfg->dataScramblingIdentityPUSCH)
4493          {
4494             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4495             {
4496                FreePuschTimeDomAllocList(puschCfg);
4497                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4498                if(dmrsUlCfg->choice.setup)
4499                {
4500                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4501                   {
4502                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4503                      {
4504                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4505                               sizeof(long));
4506                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4507                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4508                      }
4509                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4510                            sizeof(long));
4511                   }
4512                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4513                }
4514                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4515                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4516             }
4517             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4518          }
4519          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4520       }
4521       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4522
4523       /* Free SRS-Config */
4524       if(ulBwp->srs_Config)
4525       {
4526          if(ulBwp->srs_Config->choice.setup)
4527          {
4528             srsCfg = ulBwp->srs_Config->choice.setup;
4529
4530             /* Free Resource Set to add/mod list */
4531             if(srsCfg->srs_ResourceSetToAddModList)
4532             {
4533                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4534                if(rsrcSetList->list.array)
4535                {
4536                   rSetIdx = 0;
4537
4538                   /* Free SRS resource Id list in this SRS resource set */
4539                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4540                   {
4541                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4542
4543                      if(rsrcIdList->list.array)
4544                      {
4545                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4546                         {
4547                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4548                         }
4549                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4550                      }
4551                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4552                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4553                   }
4554
4555                   /* Free resource type info for this SRS resource set */
4556                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4557                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4558
4559                   /* Free memory for each resource set */
4560                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4561                   {
4562                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4563                   }
4564                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
4565                }
4566                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
4567                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4568             }
4569
4570             /* Free resource to add/modd list */
4571             if(srsCfg->srs_ResourceToAddModList)
4572             {
4573                resourceList = srsCfg->srs_ResourceToAddModList;
4574                if(resourceList->list.array)
4575                {
4576                   rsrcIdx = 0;
4577                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
4578                         sizeof(struct SRS_Resource__transmissionComb__n2));
4579                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
4580                         sizeof(struct SRS_Resource__resourceType__aperiodic));
4581
4582                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4583                   {
4584                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4585                   }
4586                   DU_FREE(resourceList->list.array, resourceList->list.size);
4587                }
4588                DU_FREE(srsCfg->srs_ResourceToAddModList, \
4589                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
4590             }
4591
4592             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4593          }
4594          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4595       }
4596    }
4597 }
4598 /*******************************************************************
4599  *
4600  * @brief Frees memory allocated for initialUplinkBWP
4601  *
4602  * @details
4603  *
4604  *    Function : FreeinitialUplinkBWP
4605  *
4606  *    Functionality: Deallocating memory of initialUplinkBWP
4607  *
4608  * @params[in] UplinkConfig_t *ulCfg
4609  *
4610  * @return void
4611  *
4612  *
4613  * ****************************************************************/
4614 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
4615 {
4616    BWP_UplinkDedicated_t *ulBwp=NULLP;
4617    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
4618
4619    if(ulCfg->initialUplinkBWP)
4620    {
4621       ulBwp=ulCfg->initialUplinkBWP;
4622       if(ulCfg->firstActiveUplinkBWP_Id)
4623       {
4624          if(ulCfg->pusch_ServingCellConfig)
4625          {
4626             puschCfg=ulCfg->pusch_ServingCellConfig;
4627             if(puschCfg->choice.setup)
4628             {
4629                if(puschCfg->choice.setup->ext1)
4630                {
4631                   DU_FREE(puschCfg->choice.setup->ext1->\
4632                         processingType2Enabled,sizeof(BOOLEAN_t));
4633                   DU_FREE(puschCfg->choice.setup->ext1->\
4634                         maxMIMO_Layers,sizeof(long));
4635                   DU_FREE(puschCfg->choice.setup->ext1, \
4636                         sizeof(struct PUSCH_ServingCellConfig__ext1));
4637                }
4638                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4639             }
4640             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4641          }
4642          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4643       }
4644       FreeInitialUlBWP(ulBwp);
4645       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4646    }
4647 }
4648 /*******************************************************************
4649  *
4650  * @brief Frees emmory allocated for BWPDlDedPdschCfg
4651  *
4652  * @details
4653  *
4654  *    Function : FreeBWPDlDedPdschCfg
4655  *
4656  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
4657  *
4658  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4659  *
4660  * @return void
4661  *
4662  *
4663  * ****************************************************************/
4664 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
4665 {
4666    struct PDSCH_Config *pdschCfg=NULLP;
4667    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
4668    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
4669    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
4670
4671    if(dlBwp->pdsch_Config->choice.setup)
4672    {
4673       pdschCfg=dlBwp->pdsch_Config->choice.setup;
4674       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4675       {
4676          if(pdschCfg->pdsch_TimeDomainAllocationList)
4677          {
4678             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
4679             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
4680             {
4681                prbBndlType=&pdschCfg->prb_BundlingType;
4682                DU_FREE(prbBndlType->choice.staticBundling,\
4683                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4684                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4685             }
4686             FreePdschTimeDomAllocList(timeDomAllocList);
4687             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
4688                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4689          }
4690          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
4691          if(dmrsDlCfg->choice.setup)
4692          {
4693             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
4694                   sizeof(long));
4695             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
4696          }
4697          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4698                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4699       }
4700       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4701    }
4702 }
4703 /*******************************************************************
4704  *
4705  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
4706  *
4707  * @details
4708  *
4709  *    Function : FreeBWPDlDedPdcchCfg
4710  *
4711  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
4712  *
4713  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4714  *
4715  * @return void
4716  *
4717  *
4718  * ****************************************************************/
4719 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
4720 {
4721    uint8_t idx1=0;
4722    uint8_t idx2=0;
4723    struct PDCCH_Config *pdcchCfg=NULLP;
4724    struct ControlResourceSet *controlRSet=NULLP;
4725    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
4726
4727    if(dlBwp->pdcch_Config->choice.setup)
4728    {
4729       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
4730       if(pdcchCfg->controlResourceSetToAddModList)
4731       {
4732          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
4733          if(controlRSetList->list.array)
4734          {
4735             controlRSet = controlRSetList->list.array[idx2];
4736             if(controlRSet)
4737             {
4738                if(controlRSet->frequencyDomainResources.buf)
4739                {
4740                   if(controlRSet->pdcch_DMRS_ScramblingID)
4741                   {
4742                      if(pdcchCfg->searchSpacesToAddModList)
4743                      {
4744                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
4745                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
4746                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
4747                      }
4748                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
4749                   }
4750                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
4751                         controlRSet->frequencyDomainResources.size);
4752                }
4753             }
4754             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
4755             {
4756                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
4757             }
4758             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
4759          }
4760          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
4761                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
4762       }
4763       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4764    }
4765 }
4766
4767 /*******************************************************************
4768  *
4769  * @brief Frees emmory allocated for DUToCURRCContainer
4770  *
4771  * @details
4772  *
4773  *    Function : FreeMemDuToCuRrcCont
4774  *
4775  *    Functionality: Deallocating memory of DuToCuRrcContainer
4776  *
4777  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
4778  *
4779  * @return ROK     - success
4780  *         RFAILED - failure
4781  *
4782  * ****************************************************************/
4783 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
4784 {
4785    uint8_t idx=0;
4786    SpCellConfig_t *spCellCfg=NULLP;
4787    ServingCellConfig_t *srvCellCfg=NULLP;
4788    BWP_DownlinkDedicated_t *dlBwp=NULLP;
4789    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
4790    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
4791    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
4792    struct RLC_Config *rlcConfig=NULLP;
4793    struct LogicalChannelConfig *macLcConfig=NULLP;
4794    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
4795    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
4796    struct TAG_Config *tagConfig=NULLP;
4797    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
4798    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
4799    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
4800
4801    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
4802    if(rlcBearerList)
4803    {
4804       if(rlcBearerList->list.array)
4805       {
4806          for(idx=0; idx<rlcBearerList->list.count; idx++)
4807          {
4808             if(rlcBearerList->list.array[idx])
4809             {
4810                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
4811                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
4812                if(rlcConfig)
4813                {
4814                   if(rlcConfig->choice.am)
4815                   {
4816                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4817                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
4818                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
4819                   }
4820                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
4821                }
4822                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
4823                if(macLcConfig)
4824                {
4825                   if(macLcConfig->ul_SpecificParameters)
4826                   {
4827                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
4828                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
4829                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
4830                   }
4831                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
4832                }
4833                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
4834             }
4835          }
4836          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
4837       }
4838       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
4839    }
4840
4841    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
4842    if(macCellGrpCfg)
4843    {
4844       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
4845       if(schedulingRequestConfig)
4846       {
4847          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4848          if(schReqList)
4849          {
4850             if(schReqList->list.array)
4851             {
4852                for(idx=0;idx<schReqList->list.count; idx++)
4853                {
4854                   if(schReqList->list.array[idx])
4855                   {
4856                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4857                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4858                   }
4859                }
4860                DU_FREE(schReqList->list.array, schReqList->list.size);
4861             }
4862             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
4863                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
4864             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4865       }
4866       if(macCellGrpCfg->bsr_Config)
4867       {
4868          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4869       }
4870       tagConfig = macCellGrpCfg->tag_Config;
4871       if(tagConfig)
4872       {
4873          tagList = tagConfig->tag_ToAddModList;
4874          if(tagList)
4875          {
4876             if(tagList->list.array)
4877             {
4878                for(idx=0; idx<tagList->list.count; idx++)
4879                {
4880                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
4881                }
4882                DU_FREE(tagList->list.array, tagList->list.size);
4883             }
4884             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4885          }
4886          DU_FREE(tagConfig, sizeof(struct TAG_Config));
4887       }
4888
4889       phrConfig = macCellGrpCfg->phr_Config;
4890       if(phrConfig)
4891       {
4892          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
4893          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
4894       }
4895
4896       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
4897    }
4898
4899    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
4900    if(phyCellGrpCfg)
4901    {
4902       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4903       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
4904    }
4905
4906    spCellCfg = cellGrpCfg->spCellConfig;
4907    if(spCellCfg)
4908    {
4909       if(spCellCfg->servCellIndex)
4910       {
4911          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
4912          {
4913             if(spCellCfg->spCellConfigDedicated)
4914             {
4915                srvCellCfg = spCellCfg->spCellConfigDedicated;
4916                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4917                {
4918                   if(srvCellCfg->initialDownlinkBWP)
4919                   {
4920                      dlBwp = srvCellCfg->initialDownlinkBWP;
4921                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
4922                      {
4923                         if(srvCellCfg->defaultDownlinkBWP_Id)
4924                         {
4925                            if(srvCellCfg->uplinkConfig)
4926                            {
4927                               if(srvCellCfg->pdsch_ServingCellConfig)
4928                               {
4929                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
4930                                  if(pdschCfg->choice.setup)
4931                                  {
4932                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
4933                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4934                                  }
4935                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
4936                                        ServingCellConfig__pdsch_ServingCellConfig));
4937                               }
4938                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
4939                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4940                            }
4941                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4942                         }
4943                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4944                      }
4945                      if(dlBwp->pdcch_Config)
4946                      {
4947                         if(dlBwp->pdsch_Config)
4948                         {
4949                            FreeBWPDlDedPdschCfg(dlBwp);
4950                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4951                         }
4952                         FreeBWPDlDedPdcchCfg(dlBwp);
4953                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4954                     }
4955                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4956                   }
4957                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4958                }
4959                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4960             }
4961             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4962          }
4963          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
4964       }
4965       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
4966    }
4967    return ROK;
4968 }
4969 /*******************************************************************
4970  *
4971  * @brief Builds DU To CU RRC Container
4972  *
4973  * @details
4974  *
4975  *    Function : BuildDuToCuRrcContainer
4976  *
4977  *    Functionality: Builds DuToCuRrcContainer
4978  *
4979  * @params[in] idx, index in F1AP msg
4980  *             DuToCuRRCContainer, DuToCuRRCContainer
4981  *
4982  * @return ROK     - success
4983  *         RFAILED - failure
4984  *
4985  * ****************************************************************/
4986 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
4987 {
4988    uint8_t  ret = ROK;
4989    CellGroupConfigRrc_t  cellGrpCfg;
4990    asn_enc_rval_t        encRetVal;
4991    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
4992    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
4993
4994    while(true)
4995    {
4996       cellGrpCfg.cellGroupId = CELL_GRP_ID;
4997
4998       cellGrpCfg.rlc_BearerToAddModList = NULLP;
4999       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5000       if(!cellGrpCfg.rlc_BearerToAddModList)
5001       {
5002          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5003          ret = RFAILED;
5004          break;
5005       }
5006       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5007       {
5008          DU_LOG("\nF1AP : BuildRlcBearerToAddModList failed");
5009          ret = RFAILED;
5010          break;
5011       }
5012
5013       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5014       cellGrpCfg.mac_CellGroupConfig = NULLP;
5015       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5016       if(!cellGrpCfg.mac_CellGroupConfig)
5017       {
5018          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5019          ret = RFAILED;
5020          break;
5021       }
5022       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5023       {
5024          DU_LOG("\nF1AP : BuildMacCellGrpCfg failed");
5025          ret = RFAILED;
5026          break;
5027       }
5028
5029       cellGrpCfg.physicalCellGroupConfig = NULLP;
5030       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5031       if(!cellGrpCfg.physicalCellGroupConfig)
5032       {
5033          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5034          ret = RFAILED;
5035          break;
5036       }
5037       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5038       {
5039          DU_LOG("\nF1AP : BuildPhyCellGrpCfg failed");
5040          ret = RFAILED;
5041          break;
5042       }
5043
5044       cellGrpCfg.spCellConfig = NULLP;
5045       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5046       if(!cellGrpCfg.spCellConfig)
5047       {
5048          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5049          ret = RFAILED;
5050          break;
5051       }
5052       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5053       {
5054          DU_LOG("\nF1AP : BuildSpCellCfg failed");
5055          ret = RFAILED;
5056          break;
5057       }
5058
5059       cellGrpCfg.sCellToAddModList = NULLP;
5060       cellGrpCfg.sCellToReleaseList = NULLP;
5061       cellGrpCfg.ext1 = NULLP;
5062
5063       /* encode cellGrpCfg into duToCuRrcContainer */
5064       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5065       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5066       encBufSize = 0;
5067       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5068       /* Encode results */
5069       if(encRetVal.encoded == ENCODE_FAIL)
5070       {
5071          DU_LOG( "\n F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5072                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5073          ret = RFAILED;
5074          break;
5075       }
5076       else
5077       {
5078          DU_LOG("\n F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5079          for(int i=0; i< encBufSize; i++)
5080          {
5081             printf("%x",encBuf[i]);
5082          }
5083       }
5084
5085       duToCuRrcContainer->size = encBufSize;
5086       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5087       if(!duToCuRrcContainer->buf)
5088       {
5089          DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5090          ret = RFAILED;
5091          break;
5092       }
5093       if(ret == ROK)
5094       {
5095          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5096       }
5097       break;
5098    }
5099    FreeMemDuToCuRrcCont(&cellGrpCfg);
5100    return ret;
5101 }
5102
5103 /*******************************************************************
5104  *
5105  * @brief Free memory allocated in InitialULRRCMessage
5106  *
5107  * @details
5108  *
5109  *    Function : freeInitUlRrcMsgTransfer
5110  *
5111  *    Functionality: Free memory allocated in InitialULRRCMessage
5112  *
5113  * @params[in]F1AP_PDU_t  *f1apMsg)
5114  *
5115  * @return ROK     - success
5116  *         RFAILED - failure
5117  *
5118  * ****************************************************************/
5119
5120 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5121 {
5122    uint8_t ieIdx, arrIdx;
5123    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5124
5125    if(f1apMsg)
5126    {
5127       if(f1apMsg->choice.initiatingMessage)
5128       {
5129          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5130             choice.InitialULRRCMessageTransfer;
5131          if(initULRRCMsg->protocolIEs.list.array)
5132          {
5133             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5134             {
5135                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5136                {
5137                   case ProtocolIE_ID_id_NRCGI:
5138                   {
5139                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5140                      {
5141                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5142                         {
5143                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5144                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5145                         }
5146                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5147                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5148                      }
5149                      break;
5150                   }
5151                   case ProtocolIE_ID_id_RRCContainer:
5152                   {
5153                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5154                      {
5155                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5156                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5157                      }
5158                      break;
5159                   }
5160                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5161                   {
5162                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5163                      {
5164                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5165                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5166                      }
5167                      break;
5168                   }
5169                   default:
5170                      break;
5171                }
5172              }
5173              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5174              {
5175                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5176                 {
5177                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5178                       sizeof(InitialULRRCMessageTransferIEs_t));
5179                 }
5180              }
5181              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5182           }
5183          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5184       }
5185       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5186    }
5187    else
5188    {
5189       DU_LOG("\nDU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5190       return RFAILED;
5191    }
5192    return ROK;
5193 }
5194
5195 /*******************************************************************
5196  *
5197  * @brief Builds and sends the InitialULRRCMessage
5198  *
5199  * @details
5200  *
5201  *    Function : BuildAndSendInitialRrcMsgTransfer
5202  *
5203  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5204  *                   it to the CU through SCTP.
5205  *
5206  * @params[in]
5207  *
5208  * @return ROK     - success
5209  *         RFAILED - failure
5210  *
5211  * ****************************************************************/
5212 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5213       uint16_t rrcContSize, uint8_t *rrcContainer)
5214 {
5215    uint8_t   ret;
5216    uint8_t   elementCnt;
5217    uint8_t   ieIdx;
5218    asn_enc_rval_t  encRetVal;
5219    F1AP_PDU_t  *f1apMsg = NULLP;
5220    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5221    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5222
5223    while(true)
5224    {
5225       DU_LOG("\n F1AP : Building RRC Setup Request\n");
5226       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5227       if(f1apMsg == NULLP)
5228       {
5229          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
5230          break;
5231       }
5232       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5233       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5234       if(f1apMsg->choice.initiatingMessage == NULLP)
5235       {
5236          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
5237          break;
5238       }
5239       f1apMsg->choice.initiatingMessage->procedureCode =\
5240                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5241       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5242       f1apMsg->choice.initiatingMessage->value.present = \
5243                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5244       initULRRCMsg =\
5245                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5246       elementCnt = 5;
5247       initULRRCMsg->protocolIEs.list.count = elementCnt;
5248       initULRRCMsg->protocolIEs.list.size = \
5249                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5250       /* Initialize the F1Setup members */
5251       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5252       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5253       {
5254          DU_LOG(" F1AP : Memory allocation for\
5255                RRCSetupRequestMessageTransferIEs failed");
5256          break;
5257       }
5258       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5259       {
5260          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5261                sizeof(InitialULRRCMessageTransferIEs_t));
5262          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5263          {
5264             break;
5265          }
5266       }
5267       ieIdx = 0;
5268       /*GNB DU UE F1AP ID*/
5269       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5270                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5271       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5272       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5273                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5274       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5275
5276
5277       /*NRCGI*/
5278       ieIdx++;
5279       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5280                                                         ProtocolIE_ID_id_NRCGI;
5281       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5282       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5283                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5284
5285       ret =\
5286            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5287       if(ret!=ROK)
5288       {
5289          break;
5290       }
5291
5292       /*CRNTI*/
5293       ieIdx++;
5294       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5295                                                         ProtocolIE_ID_id_C_RNTI;
5296       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5297       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5298                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5299       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5300
5301       /*RRCContainer*/
5302       ieIdx++;
5303       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5304                                                         ProtocolIE_ID_id_RRCContainer;
5305       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5306       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5307                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5308
5309       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5310       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5311             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5312       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5313       {
5314          DU_LOG(" F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5315          break;
5316
5317       }
5318       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5319             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5320
5321
5322       /*DUtoCURRCContainer*/
5323       ieIdx++;
5324       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5325       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5326       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5327                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5328
5329       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5330       if(ret != ROK)
5331       {
5332          break;
5333       }
5334
5335       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5336
5337       /* Encode the F1SetupRequest type as APER */
5338       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5339       encBufSize = 0;
5340       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5341       /* Encode results */
5342       if(encRetVal.encoded == ENCODE_FAIL)
5343       {
5344          DU_LOG( "\n F1AP : Could not encode Initial UL RRC Message Transfer\
5345                structure (at %s)\n",encRetVal.failed_type ? \
5346                encRetVal.failed_type->name : "unknown");
5347          ret = RFAILED;
5348          break;
5349       }
5350       else
5351       {
5352
5353          DU_LOG("\n F1AP : Created APER encoded buffer for Initial UL RRC\
5354                Message transfer\n");
5355          for(int i=0; i< encBufSize; i++)
5356          {
5357             printf("%x",encBuf[i]);
5358          }
5359       }
5360       /* Sending  msg  */
5361       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5362       {
5363          DU_LOG("\n F1AP : Sending Initial UL RRC Message Transfer Failed");
5364          ret = RFAILED;
5365          break;
5366       }
5367       break;
5368    }
5369    freeInitUlRrcMsgTransfer(f1apMsg);
5370    return ret;
5371 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5372
5373 /*****  UE SETUP REQUEST *****/
5374
5375 /*******************************************************************
5376  *
5377  * @brief Free Qos And Snssai Drb Info
5378  *
5379  * @details
5380  *
5381  *    Function : freeDrbQosAndSnssaiInfo
5382  *
5383  *    Functionality: Free Qos And Snssai Drb Info
5384  *
5385  * @params[in] LcCfg *lcCfg,
5386  * @return void
5387  *
5388  * ****************************************************************/
5389 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5390 {
5391    if(lcCfg->snssai)
5392    {
5393       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5394    }
5395    if(lcCfg->drbQos)
5396    {
5397       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5398    }
5399 }
5400
5401 /******************************************************************
5402 *
5403 * @brief Function to delete the RLC Lc cfg from UE APP DB
5404 *
5405 * @details
5406 *
5407 *  Function : freeRlcLcCfg
5408 *
5409 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5410 *
5411 *
5412  *****************************************************************/
5413
5414 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5415 {
5416    switch(lcCfg->rlcMode)
5417    {
5418       case RLC_AM :
5419       {
5420          if(lcCfg->u.amCfg)
5421          {
5422             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5423             lcCfg->u.amCfg = NULLP;
5424          }
5425          break;
5426       }
5427       case RLC_UM_BI_DIRECTIONAL :
5428       {
5429          if(lcCfg->u.umBiDirCfg)
5430          {
5431             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5432             lcCfg->u.umBiDirCfg = NULLP;
5433          }
5434          break;
5435       }
5436       case RLC_UM_UNI_DIRECTIONAL_UL :
5437       {
5438          if(lcCfg->u.umUniDirUlCfg)
5439          {
5440             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5441             lcCfg->u.umUniDirUlCfg = NULLP;
5442          }
5443          break;
5444
5445       }
5446       case RLC_UM_UNI_DIRECTIONAL_DL :
5447       {
5448          if(lcCfg->u.umUniDirDlCfg)
5449          {
5450             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5451             lcCfg->u.umUniDirDlCfg = NULLP;
5452          }
5453          break;
5454       }
5455       default:
5456          DU_LOG("\nDU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5457          break;
5458    }
5459    memset(lcCfg, 0, sizeof(LcCfg));
5460 }
5461 /*******************************************************************
5462  *
5463  * @brief Function to free MacLcCfg
5464  *
5465  * @details
5466  *
5467  *    Function : freeMacLcCfg
5468  *
5469  *    Functionality: Function to free MacLcCfg
5470  *
5471  * @params[in] LcCfg *lcCfg,
5472  * @return void
5473  *
5474  * ****************************************************************/
5475
5476 void  freeMacLcCfg(LcCfg *lcCfg)
5477 {
5478     /* Deleting DRBQOS */
5479    if(lcCfg->drbQos)
5480    {
5481       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5482       lcCfg->drbQos = NULLP;
5483    }
5484    /* Deleting SNSSAI */
5485    if(lcCfg->snssai)
5486    {
5487       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5488       lcCfg->snssai = NULLP;
5489    }
5490    memset(lcCfg, 0, sizeof(LcCfg));
5491 }
5492
5493 /*******************************************************************
5494  *
5495  * @brief Function to free DuUeCfg
5496  *
5497  * @details
5498  *
5499  *    Function : freeDuUeCfg
5500  *
5501  *    Functionality: Function to free DuUeCfg
5502  *
5503  * @params[in] DuUeCfg *ueCfg
5504  * @return void
5505  *
5506  * ****************************************************************/
5507 void freeDuUeCfg(DuUeCfg *ueCfg)
5508 {
5509    uint8_t lcIdx;
5510
5511    if(ueCfg->cellGrpCfg)
5512    {
5513       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
5514       ueCfg->cellGrpCfg = NULLP;
5515    }
5516    if(ueCfg->maxAggrBitRate)
5517    {
5518       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->maxAggrBitRate, sizeof(MaxAggrBitRate));
5519    }
5520    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
5521    {
5522       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
5523    }
5524    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
5525    {
5526       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
5527    }
5528 }
5529
5530 /*******************************************************************
5531  *
5532  * @brief Function to free UecontextSetupDb
5533  *
5534  * @details
5535  *
5536  *    Function : freeF1UeDb
5537  *
5538  *    Functionality: Function to free UecontextSetupDb
5539  *
5540  * @params[in] UecontextSetupDb *
5541  * @return void
5542  *
5543  * ****************************************************************/
5544
5545 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
5546 {
5547
5548    if(f1UeDb->dlRrcMsg)
5549    {
5550       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
5551       {
5552          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
5553             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
5554       }
5555       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
5556    }
5557    freeDuUeCfg(&f1UeDb->duUeCfg);
5558    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
5559 }
5560
5561 /*******************************************************************
5562  *
5563  * @brief Function to build Am cfg Info
5564  *
5565  * @details
5566  *
5567  *    Function : extractRlcAmCfg
5568  *
5569  *    Functionality: Function to build Am cfg Info
5570  *
5571  * @params[in] AmBearerCfg *
5572  *             void *
5573  *
5574  * @return ROK/RFAILED
5575  *
5576  * ****************************************************************/
5577
5578 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
5579 {
5580    if(rlcAmCfg)
5581    {
5582       /* UL AM */
5583       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
5584       {
5585          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
5586          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
5587          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
5588       }
5589
5590       /* DL AM */
5591       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
5592       {
5593          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
5594          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
5595          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
5596          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
5597          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
5598       }
5599    }
5600 }
5601
5602 /*******************************************************************
5603  *
5604  * @brief Function to build Um Bi Info
5605  *
5606  * @details
5607  *
5608  *    Function : extractRlcUmBiCfg
5609  *
5610  *    Functionality: Function to build Um Bi Info
5611  *
5612  * @params[in] UmBiDirBearerCfg *
5613  *             void *
5614  *
5615  * @return ROK/RFAILED
5616  *
5617  * ****************************************************************/
5618
5619 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
5620 {
5621    if(rlcBiCfg)
5622    {
5623       /* UL UM BI DIR Cfg */
5624       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
5625       {
5626          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
5627          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
5628       }
5629
5630       /* DL UM BI DIR Cfg */
5631       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
5632          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
5633    }
5634 }
5635
5636 /*******************************************************************
5637  *
5638  * @brief Function to build Um Ul Info
5639  *
5640  * @details
5641  *
5642  *    Function : extractRlcUmUlCfg
5643  *
5644  *    Functionality: Function to build Um Ul Info
5645  *
5646  * @params[in] UmUniDirUlBearerCfg *
5647  *             void *
5648  *
5649  * @return ROK/RFAILED
5650  *
5651  * ****************************************************************/
5652
5653 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
5654 {
5655    if(umUlCfg)
5656    {
5657       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
5658       {
5659          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
5660          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
5661       }
5662    }
5663 }
5664
5665 /*******************************************************************
5666  *
5667  * @brief Function to build Um Uni Dl Info
5668  *
5669  * @details
5670  *
5671  *    Function : extractRlcUmDlCfg
5672  *
5673  *    Functionality: Function to build Um Uni Dl Info
5674  *
5675  * @params[in] UmUniDirDlBearerCfg *
5676  *             void *
5677  *
5678  * @return ROK/RFAILED
5679  *
5680  * ****************************************************************/
5681 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
5682 {
5683    if(umDlCfg)
5684    {
5685       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
5686          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
5687    }
5688 }
5689
5690 /*******************************************************************
5691  *
5692  * @brief Function to extractRlcModeCfg
5693  *
5694  * @details
5695  *
5696  *    Function : extractRlcModeCfg
5697  *
5698  *    Functionality: Function to extractRlcModeCfg
5699  *
5700  * @params[in] RLC_Config_t *
5701  *             RlcBearerCfg *
5702  *             void  *
5703  * @return ROK/RFAILED
5704  *
5705  * ****************************************************************/
5706 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
5707 {
5708    if(lcCfg)
5709    {
5710       switch(rlcMode)
5711       {
5712          case RLC_AM :
5713             {
5714                if(lcCfg->choice.am)
5715                {
5716                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
5717                   if(rlcDbCfg->u.amCfg)
5718                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
5719                }
5720                break;
5721             }
5722          case RLC_UM_BI_DIRECTIONAL :
5723             {
5724                if(lcCfg->choice.um_Bi_Directional)
5725                {
5726                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5727                   if(rlcDbCfg->u.umBiDirCfg)
5728                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
5729                }
5730                break;
5731             }
5732          case RLC_UM_UNI_DIRECTIONAL_UL :
5733             {
5734                if(lcCfg->choice.um_Uni_Directional_DL)
5735                {
5736                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5737                   if(rlcDbCfg->u.umUniDirUlCfg)
5738                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
5739                }
5740                break;
5741             }
5742          case RLC_UM_UNI_DIRECTIONAL_DL :
5743             {
5744                if(lcCfg->choice.um_Uni_Directional_UL)
5745                {
5746                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5747                   if(rlcDbCfg->u.umUniDirDlCfg)
5748                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
5749                }
5750                break;
5751             }
5752          default:
5753             DU_LOG("\nDUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
5754             break;
5755       }
5756    }
5757 }
5758
5759 /*******************************************************************
5760  *
5761  * @brief Function to extract extractUlLcCfg
5762  *
5763  * @details
5764  *
5765  *    Function : extractUlLcCfg
5766  *
5767  *    Functionality: Function to extract extractUlLcCfg
5768  *
5769  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
5770  * @return void
5771  *
5772  * ****************************************************************/
5773
5774 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
5775 {
5776    if(ulLcCfg)
5777    {
5778       if(ulLcCfg->ul_SpecificParameters)
5779       {
5780          f1UlLcCfg->priority = \
5781             ulLcCfg->ul_SpecificParameters->priority;
5782       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
5783       {
5784          f1UlLcCfg->lcGroup = \
5785            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
5786       }
5787       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
5788       {
5789          f1UlLcCfg->schReqId = \
5790            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
5791       }
5792       f1UlLcCfg->pbr = \
5793          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
5794       f1UlLcCfg->bsd = \
5795          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
5796       }
5797    }
5798 }
5799
5800 /*******************************************************************
5801  *
5802  * @brief Function to procRlcLcCfg
5803  *
5804  * @details
5805  *
5806  *    Function : procRlcLcCfg
5807  *
5808  *    Functionality: Function to procRlcLcCfg
5809  *
5810  * @params[in] rbId, lcId, rbType, rlcMod
5811  *             RLC_Config_t *, RlcBearerCfg * ,
5812  * @return void
5813  *
5814  * ****************************************************************/
5815
5816 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
5817    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
5818 {
5819
5820    lcCfg->rbId   = rbId;
5821    lcCfg->configType = configType;
5822
5823    if(rbType == RB_TYPE_SRB)
5824    {
5825       lcCfg->rbType = RB_TYPE_SRB;
5826       lcCfg->lcId   = rbId;
5827       lcCfg->lcType = LCH_DCCH;
5828       lcCfg->rlcMode = RLC_AM;
5829    }
5830    else if(rbType == RB_TYPE_DRB)
5831    {
5832       lcCfg->rbType = RB_TYPE_DRB;
5833       lcCfg->lcId   = lcId;
5834       lcCfg->lcType = LCH_DTCH;
5835       lcCfg->rlcMode = rlcMode;
5836    }
5837    if(f1RlcCfg) /* rlc mode config recived */
5838    {
5839       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
5840    }
5841 }
5842
5843
5844
5845 /*******************************************************************
5846  *
5847  * @brief Fills DrbQos Info received by CU
5848  *
5849  * @details
5850  *
5851  *    Function : extractQosInfo
5852  *
5853  *    Functionality: Fills DrbQos Info received  by CU
5854  *
5855  * @params[in] DrbQosInfo *qosToAdd,
5856  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
5857  * @return void
5858  *
5859  * ****************************************************************/
5860
5861 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
5862 {
5863    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
5864    qosToAdd->u.nonDyn5Qi.fiveQi     =\
5865          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
5866    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
5867    {
5868       qosToAdd->u.nonDyn5Qi.avgWindow = \
5869         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
5870    }
5871    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
5872       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
5873    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
5874    {
5875       qosToAdd->u.nonDyn5Qi.priorLevel = \
5876          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
5877    }
5878    qosToAdd->ngRanRetPri.priorityLevel = \
5879       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
5880    qosToAdd->ngRanRetPri.preEmptionCap = \
5881       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
5882    qosToAdd->ngRanRetPri.preEmptionVul = \
5883       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
5884    if(qosFlowCfg->gBR_QoS_Flow_Information)
5885    {
5886       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
5887          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
5888          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
5889       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
5890          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
5891          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
5892       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
5893          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
5894          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
5895       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
5896          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
5897          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
5898    }
5899    qosToAdd->pduSessionId = 0;
5900    qosToAdd->ulPduSessAggMaxBitRate = 0;
5901 }
5902
5903 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, LcCfg *macLcToAdd)
5904 {
5905    DRB_Information_t *drbInfo = NULLP;
5906
5907    if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
5908    {
5909       if(drbItem->qoSInformation.choice.choice_extension->value.present ==
5910             QoSInformation_ExtIEs__value_PR_DRB_Information)
5911       {
5912          drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
5913
5914          if(!macLcToAdd->drbQos)
5915          {
5916             DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
5917             if(macLcToAdd->drbQos == NULLP)
5918             {
5919                DU_LOG("\n DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
5920                return RFAILED;
5921             }
5922
5923          }
5924          if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
5925          {
5926             extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
5927             macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
5928          }
5929          if(!macLcToAdd->snssai)
5930          {
5931             DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
5932             if(macLcToAdd->snssai == NULLP)
5933             {
5934                DU_LOG("\n DUAPP:Memory failed at allocating SNSSAI at extractDrbCfg()");
5935                return RFAILED;
5936             }
5937          }
5938          memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
5939                drbInfo->sNSSAI.sST.size);
5940          if(drbInfo->sNSSAI.sD)
5941          {
5942             memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
5943                   drbInfo->sNSSAI.sD->size);
5944          }
5945       }/*End of DRB Info*/
5946    }
5947    return ROK;
5948 }
5949
5950 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg)
5951 {
5952    uint8_t ret = ROK;
5953
5954    if(drbCfg)
5955    {
5956       ret = extractDrbCfg(drbCfg, lcCfg);
5957       if(ret == RFAILED)
5958       {
5959          DU_LOG("F1AP: Failed to build Drb Qos at extractMacRbCfg()");
5960          return ret;
5961       }
5962    }
5963    else
5964    {
5965       lcCfg->drbQos = NULLP;
5966       lcCfg->snssai = NULLP;
5967       if(lcCfg->lcId == SRB2_LCID)
5968          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
5969       else
5970          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
5971    }
5972    if(ulLcCfg)
5973    {
5974       lcCfg->ulLcCfgPres = true;
5975       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
5976    }
5977    else
5978       lcCfg->ulLcCfgPres = false;
5979    return ret;
5980 }
5981
5982 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
5983    DRBs_ToBeSetup_Item_t *drbItem, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg)
5984 {
5985    uint8_t ret = ROK;
5986
5987    lcCfg->lcId = lcId;
5988    lcCfg->configType = configType;
5989    if(rbType == RB_TYPE_SRB)
5990    {
5991       ret = extractMacRbCfg(lcId, NULL, ulLcCfg, lcCfg);
5992    }
5993    else if(rbType == RB_TYPE_DRB)
5994    {
5995       ret = extractMacRbCfg(lcId, drbItem, ulLcCfg, lcCfg);
5996    }
5997    return ret;
5998 }
5999
6000 /*******************************************************************
6001  *
6002  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
6003  *
6004  * @details
6005  *
6006  *    Function : extractRlcCfgToAddMod
6007  *
6008  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
6009  *
6010  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
6011  *             DuUeCfg Pointer
6012  * @return ROK/RFAILED
6013  *
6014  * ****************************************************************/
6015
6016 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, \
6017    DuUeCfg *ueCfgDb)
6018 {
6019   uint8_t ret, idx, rbId, lcId, rlcMode, rbType;
6020   RLC_Config_t *f1RlcCfg = NULLP;
6021   LogicalChannelConfig_t *macUlLcCfg = NULLP;
6022
6023   for(idx = 0; idx < lcCfg->list.count; idx++)
6024   {
6025      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
6026      if(lcCfg->list.array[idx]->servedRadioBearer)
6027      {
6028         /* RadioBearer for SRB/DRB */
6029         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
6030         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
6031         {
6032            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
6033            rbType = RB_TYPE_SRB;
6034         }
6035         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
6036         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
6037         {
6038            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
6039            rbType = RB_TYPE_DRB;
6040         }
6041         else
6042         {
6043            DU_LOG("\n No components present in Bearer config to ADD/MOD");
6044            return RFAILED;
6045         }
6046         /* MAC UL LC Config */
6047         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
6048         {
6049            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
6050         }
6051      }
6052      else
6053      {
6054         DU_LOG("\nDUAPP: Received RadioBearer config is NULL");
6055         return RFAILED;
6056      }
6057      /* RLC Mode Config */
6058      if(lcCfg->list.array[idx]->rlc_Config)
6059      {
6060         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
6061         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
6062      }
6063
6064      /* Filling RLC/MAC Config*/
6065      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
6066      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
6067      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
6068      ret = procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx]);
6069      if(ret == RFAILED)
6070      {
6071         DU_LOG("\nDUAPP: Failed while filling MAC LC config at extractRlcCfgToAddMod()");
6072         return ret;
6073      }
6074      (ueCfgDb->numRlcLcs)++;
6075      (ueCfgDb->numMacLcs)++;
6076   }
6077   //TODO: To send the failure cause in UeContextSetupRsp
6078   return ret;
6079 }
6080
6081 /*******************************************************************
6082  *
6083  * @brief DeAlloc pdsch serv cell config info
6084  *
6085  * @details
6086  *
6087  *    Function : freeMacPdschServCellInfo
6088  *
6089  *    Functionality: DeAlloc pdsch serv cell config info
6090  *
6091  * @params[in] PdschServCellCfg pointer
6092  * @return void
6093  *
6094  * ****************************************************************/
6095
6096 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
6097 {
6098    if(pdsch->xOverhead)
6099    {
6100       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
6101    }
6102    if(pdsch->codeBlkGrpFlushInd)
6103    {
6104       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
6105    }
6106    if(pdsch->maxCodeBlkGrpPerTb)
6107    {
6108       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
6109    }
6110    if(pdsch->maxMimoLayers)
6111    {
6112       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
6113    }
6114 }
6115
6116 /*******************************************************************
6117  *
6118  * @brief Free Serving cell Info
6119  *
6120  * @details
6121  *
6122  *    Function : freeMacServingCellInfo
6123  *
6124  *    Functionality: Free Serving cell Info
6125  *
6126  * @params[in] ServCellCfgInfo *srvCellCfg
6127  * @return void
6128  *
6129  * ****************************************************************/
6130 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
6131 {
6132    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
6133    if(srvCellCfg->bwpInactivityTmr)
6134    {
6135       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
6136    }
6137 }
6138
6139 /*******************************************************************
6140  *
6141  * @brief Free cell Grp Cfg Info
6142  *
6143  * @details
6144  *
6145  *    Function : freeUeReCfgCellGrpInfo
6146  *
6147  *    Functionality: Free cell Grp Cfg Info
6148  *
6149  * @params[in] MacUeCfg*  duUeCfg
6150  * @return void
6151  *
6152  * ****************************************************************/
6153
6154 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
6155 {
6156    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
6157 }
6158
6159 /*******************************************************************
6160  *
6161  * @brief Fills Reconfig SchReqReConfig
6162  *
6163  * @details
6164  *
6165  *    Function : extractSchReqReConfig
6166  *
6167  *    Functionality: Fills Reconfig SchReqReConfig
6168  *
6169  * @params[in] SchedulingRequestConfig_t *cuSchedReq
6170  *             SchedReqCfg*  macSchedReq
6171  * @return void
6172  *
6173  * ****************************************************************/
6174 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
6175 {
6176    uint8_t schReqIdx = 0;
6177    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
6178    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
6179
6180    if(cuSchedReq->schedulingRequestToAddModList)
6181    {
6182       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
6183       if(schReqListToAdd->list.count)
6184       {
6185          macSchedReq->addModListCount = schReqListToAdd->list.count;
6186          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
6187          {
6188             macSchedReq->addModList[schReqIdx].schedReqId = \
6189                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
6190             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
6191                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
6192             macSchedReq->addModList[schReqIdx].srTransMax    =\
6193                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
6194          }
6195       }
6196    }
6197    /* Scheduling Req To release */
6198    if(cuSchedReq->schedulingRequestToReleaseList)
6199    {
6200       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
6201       if(schReqListToRel->list.count)
6202       {
6203          macSchedReq->relListCount = schReqListToRel->list.count;
6204          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
6205          {
6206             macSchedReq->relList[schReqIdx] = \
6207                *schReqListToRel->list.array[schReqIdx];
6208          }
6209       }
6210    }
6211 }
6212
6213 /*******************************************************************
6214  *
6215  * @brief Fills TagReconfig
6216  *
6217  * @details
6218  *
6219  *    Function : extractTagReconfig
6220  *
6221  *    Functionality: Fills extractTagReconfig
6222  *
6223  * @params[in] TAG_Config_t *cuTagCfg
6224  *             TagCfg *macTagCfg
6225  * @return void
6226  *
6227  * ****************************************************************/
6228
6229 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
6230 {
6231   uint8_t tagIdx = 0;
6232   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
6233   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
6234
6235   /* Tag config to AddMod */
6236   if(cuTagCfg->tag_ToAddModList)
6237   {
6238      tagListToAddMod = cuTagCfg->tag_ToAddModList;
6239      if(tagListToAddMod->list.count)
6240      {
6241         macTagCfg->addModListCount = tagListToAddMod->list.count;
6242         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
6243         {
6244            macTagCfg->addModList[tagIdx].tagId =\
6245               tagListToAddMod->list.array[tagIdx]->tag_Id;
6246            macTagCfg->addModList[tagIdx].timeAlignTimer = \
6247
6248               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
6249         }
6250      }
6251   }
6252   /* Tag config to release */
6253   if(cuTagCfg->tag_ToReleaseList)
6254   {
6255      tagListToRel = cuTagCfg->tag_ToReleaseList;
6256      if(tagListToRel->list.count)
6257      {
6258         macTagCfg->relListCount = tagListToRel->list.count;
6259         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
6260         {
6261            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
6262         }
6263      }
6264   }
6265 }
6266
6267 /*******************************************************************
6268  *
6269  * @brief Fills PdcchCfg received by CU
6270  *
6271  * @details
6272  *
6273  *    Function : extractPdcchCfg
6274  *
6275  *    Functionality: Fills PdcchCfg received  by CU
6276  *
6277  * @params[in] PDCCH_Config_t *cuPdcchCfg,
6278  *             PdcchConfig *duPdcchCfg
6279  * @return void
6280  *
6281  * ****************************************************************/
6282
6283 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
6284 {
6285    uint8_t cRsetIdx = 0;
6286    uint8_t srchSpcIdx = 0;
6287
6288    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
6289    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
6290    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
6291    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
6292
6293
6294    /* Control Resource Set To Add/Mod List */
6295    if(cuPdcchCfg->controlResourceSetToAddModList)
6296    {
6297       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
6298       if(cRsetToAddModList->list.count)
6299       {
6300          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
6301          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
6302          {
6303             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
6304               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
6305             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
6306                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
6307             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
6308               cRsetToAddModList->list.array[cRsetIdx]->duration;
6309
6310             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
6311               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
6312             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
6313             {
6314                //TODO: handle the case for Interleaved
6315             }
6316             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
6317               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
6318             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
6319             {
6320                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
6321                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
6322             }
6323          }
6324       }
6325
6326    }
6327    /* Control Resource Set To Release List */
6328    if(cuPdcchCfg->controlResourceSetToReleaseList)
6329    {
6330       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
6331       if(cRsetToRelList->list.count)
6332       {
6333          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
6334          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
6335          {
6336             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
6337          }
6338       }
6339    }
6340
6341    /* Search space To Add/Mod List */
6342    if(cuPdcchCfg->searchSpacesToAddModList)
6343    {
6344       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
6345       if(srchSpcToAddModList->list.count)
6346       {
6347          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
6348          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
6349          {
6350             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
6351                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
6352             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
6353                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
6354             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
6355             {
6356                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
6357                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
6358             }
6359             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
6360             {
6361                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
6362                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
6363             }
6364             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
6365             {
6366               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
6367                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
6368               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
6369                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
6370               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
6371                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
6372
6373               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
6374                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
6375
6376               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
6377                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
6378             }
6379             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
6380             {
6381                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
6382                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
6383                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
6384                {
6385                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
6386                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
6387                }
6388
6389             }
6390          }
6391       }
6392    }
6393    /* Search space To Rel List */
6394    if(cuPdcchCfg->searchSpacesToReleaseList)
6395    {
6396       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
6397       if(srchSpcToRelList->list.count)
6398       {
6399          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
6400          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
6401          {
6402             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
6403                *(srchSpcToRelList->list.array[srchSpcIdx]);
6404          }
6405       }
6406    }
6407 }
6408
6409 /*******************************************************************
6410  *
6411  * @brief Fills PdschCfg received by CU
6412  *
6413  * @details
6414  *
6415  *    Function : extractPdschCfg
6416  *
6417  *    Functionality: Fills PdschCfg received  by CU
6418  *
6419  * @params[in] PDSCH_Config_t *cuPdschCfg,
6420  *             PdschConfig *macPdschCfg
6421  * @return void
6422  *
6423  * ****************************************************************/
6424
6425 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
6426 {
6427    uint8_t timeDomIdx;
6428    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
6429
6430    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6431    {
6432       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
6433          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
6434       {
6435          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
6436          {
6437             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
6438                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
6439          }
6440       }
6441    }
6442    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
6443    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
6444    {
6445       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
6446       if(timeDomAlloc->present ==\
6447          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
6448       {
6449          if(timeDomAlloc->choice.setup)
6450          {
6451             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
6452             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
6453             {
6454                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
6455                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
6456                //macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbol = \
6457
6458                //macPdschCfg->timeDomRsrcAllociList[timeDomIdx].symbolLength;
6459                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
6460                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
6461             }
6462          }
6463       }
6464    }
6465    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
6466    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
6467       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
6468    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
6469    {
6470       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
6471       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
6472       {
6473          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
6474          {
6475             macPdschCfg->bundlingInfo.StaticBundling.size = \
6476                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
6477          }
6478       }
6479    }
6480    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
6481    {
6482       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
6483    }
6484
6485 }
6486
6487 /*******************************************************************
6488  *
6489  * @brief Fills PdschServingCellCfg received by CU
6490  *
6491  * @details
6492  *
6493  *    Function : extractPdschServingCellCfg
6494  *
6495  *    Functionality: Fills PdschCfg received  by CU
6496  *
6497  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
6498  *             PdschServCellCfg *macUePdschSrvCellCfg
6499  * @return ROK/RFAILED
6500  *
6501  * ****************************************************************/
6502
6503 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
6504 {
6505    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
6506    {
6507       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
6508       {
6509          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
6510          {
6511             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
6512                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
6513          }
6514          else
6515          {
6516             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
6517             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
6518             {
6519                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
6520                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
6521             }
6522             else
6523             {
6524                DU_LOG("\nDUAPP: Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
6525                return RFAILED;
6526             }
6527          }
6528          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
6529          {
6530             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
6531                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
6532          }
6533          else
6534          {
6535             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
6536             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
6537             {
6538                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
6539                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
6540             }
6541             else
6542             {
6543                DU_LOG("\nDUAPP: Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
6544                return RFAILED;
6545             }
6546          }
6547       }
6548    }
6549    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
6550    {
6551       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
6552    }
6553    if(cuPdschSrvCellCfg->ext1)
6554    {
6555       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
6556       {
6557         if(macUePdschSrvCellCfg->maxMimoLayers)
6558         {
6559            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
6560         }
6561         else
6562         {
6563            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
6564            if(macUePdschSrvCellCfg->maxMimoLayers)
6565            {
6566               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
6567            }
6568            else
6569            {
6570               DU_LOG("\nDUAPP: Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
6571               return RFAILED;
6572            }
6573         }
6574       }
6575    }
6576    if(cuPdschSrvCellCfg->xOverhead)
6577    {
6578       if(macUePdschSrvCellCfg->xOverhead)
6579       {
6580          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
6581       }
6582       else
6583       {
6584          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
6585          if(macUePdschSrvCellCfg->xOverhead)
6586          {
6587             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
6588          }
6589          else
6590          {
6591             DU_LOG("\nDUAPP: Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
6592             return RFAILED;
6593          }
6594       }
6595    }
6596    return ROK;
6597 }
6598
6599 /*******************************************************************
6600  *
6601  * @brief Fills PuschCfg received by CU
6602  *
6603  * @details
6604  *
6605  *    Function : extractPuschCfg
6606  *
6607  *    Functionality: Fills PuschCfg received  by CU
6608  *
6609  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
6610  *             PuschCfg *macPuschCfg
6611  * @return void
6612  *
6613  * ****************************************************************/
6614
6615 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
6616 {
6617    uint8_t timeDomIdx = 0;
6618    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
6619    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
6620
6621    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
6622    {
6623       if(cuPuschCfg->choice.setup)
6624       {
6625          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
6626          {
6627              macPuschCfg->dataScramblingId = \
6628                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
6629          }
6630          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
6631          {
6632             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
6633             {
6634                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
6635                {
6636                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
6637                   if(dmrsUlCfg->dmrs_AdditionalPosition)
6638                   {
6639                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
6640                         *(dmrsUlCfg->dmrs_AdditionalPosition);
6641                   }
6642                   if(dmrsUlCfg->transformPrecodingDisabled)
6643                   {
6644                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
6645                      {
6646                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
6647                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
6648                      }
6649                   }
6650                }
6651             }
6652          }
6653          /*Res Alloc Type for UL */
6654          if(cuPuschCfg->choice.setup->resourceAllocation)
6655          {
6656             macPuschCfg->resourceAllocType = \
6657                cuPuschCfg->choice.setup->resourceAllocation;
6658          }
6659          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
6660          {
6661             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
6662             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
6663             {
6664                if(timeDomAllocList->choice.setup)
6665                {
6666                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
6667                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
6668                   {
6669                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
6670                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
6671                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
6672                                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
6673                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
6674                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
6675                     //macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbol = \
6676                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbol;
6677                     //macPuschCfg->timeDomRsrcAllocList[timeDomIdx].symbolLen = \
6678                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->symbolLen;
6679                   }
6680                }
6681             }
6682          }
6683          if(cuPuschCfg->choice.setup->transformPrecoder)
6684             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
6685       }
6686    }
6687 }
6688 /*******************************************************************
6689  *
6690  * @brief Fills ServingCellReconfig received by CU
6691  *
6692  * @details
6693  *
6694  *    Function : extractServingCellReconfig
6695  *
6696  *    Functionality: Fills ServingCellReconfig received  by CU
6697  *
6698  * @params[in] ServingCellConfig_t *cuSrvCellCfg
6699  *             ServCellCfgInfo *macSrvCellCfg
6700  * @return ROK/RFAILD
6701  *
6702  * ****************************************************************/
6703 uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
6704 {
6705    uint8_t ret = ROK;
6706    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6707    BWP_UplinkDedicated_t   *ulBwp = NULLP;
6708
6709    if(cuSrvCellCfg->initialDownlinkBWP)
6710    {
6711       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
6712       if(dlBwp->pdcch_Config)
6713       {
6714          if(dlBwp->pdcch_Config->choice.setup)
6715          {
6716             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
6717          }
6718       }
6719       if(dlBwp->pdsch_Config)
6720       {
6721          if(dlBwp->pdsch_Config->choice.setup)
6722          {
6723             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
6724          }
6725       }
6726    }
6727    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
6728       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
6729    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
6730       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
6731    if(cuSrvCellCfg->bwp_InactivityTimer)
6732    {
6733       if(macSrvCellCfg->bwpInactivityTmr)
6734       {
6735          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
6736       }
6737       else
6738       {
6739          macSrvCellCfg->bwpInactivityTmr = NULLP;
6740          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
6741          if(macSrvCellCfg->bwpInactivityTmr)
6742          {
6743             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
6744          }
6745          else
6746          {
6747             DU_LOG("\nMemory Alloc failed for bwpInactivityTmr at extractServingCellReconfig()");
6748             return RFAILED;
6749          }
6750       }
6751    }
6752    if(cuSrvCellCfg->pdsch_ServingCellConfig)
6753    {
6754       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
6755       {
6756          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
6757          if(ret == RFAILED)
6758          {
6759             DU_LOG("\nFailed at extractPdschServingCellCfg()");
6760             return RFAILED;
6761          }
6762       }
6763    }
6764    if(cuSrvCellCfg->uplinkConfig)
6765    {
6766      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
6767      {
6768         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
6769         if(ulBwp->pusch_Config)
6770         {
6771            macSrvCellCfg->initUlBwp.puschPresent = true;
6772            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
6773         }
6774         if(ulBwp->pucch_Config)
6775         {
6776            macSrvCellCfg->initUlBwp.pucchPresent = true;
6777            //extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
6778         }
6779      }
6780      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
6781         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
6782
6783    }
6784    return ret;
6785 }
6786 /*******************************************************************
6787  *
6788  * @brief Fills Reconfig Cell group Info received by CU
6789  *
6790  * @details
6791  *
6792  *    Function : extractUeReCfgCellInfo
6793  *
6794  *    Functionality: Fills Reconfig Cell group Info received by CU
6795  *
6796  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
6797  *             MacUeCfg*  macUeCfg
6798  * @return ROK/RFAILED
6799  *
6800  * ****************************************************************/
6801 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
6802 {
6803    uint8_t ret = ROK;
6804    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
6805    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6806    SpCellConfig_t            *spcellCfg = NULLP;
6807    ServingCellConfig_t       *servCellCfg = NULLP;
6808
6809    if(cellGrp)
6810    {
6811       /* Fill MacCell Group Reconfig  */
6812       if(cellGrp->mac_CellGroupConfig)
6813       {
6814          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
6815          if(macCellGroup->schedulingRequestConfig)
6816          {
6817             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
6818          }
6819          if(macCellGroup->tag_Config)
6820          {
6821             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
6822          }
6823          if(macCellGroup->bsr_Config)
6824          {
6825             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
6826             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
6827             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
6828             {
6829                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
6830                   *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
6831             }
6832          }
6833          if(macCellGroup->phr_Config)
6834          {
6835             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
6836             {
6837                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
6838                if(macCellGroup->phr_Config->choice.setup)
6839                {
6840                 macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
6841                    macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
6842                 macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
6843                    macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
6844                 macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
6845                    macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
6846                 macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
6847                    macCellGroup->phr_Config->choice.setup->multiplePHR;
6848                 macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
6849                    macCellGroup->phr_Config->choice.setup->dummy;
6850                 macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
6851                    macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
6852                 macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
6853                    macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
6854                }
6855             }
6856
6857
6858          }
6859       }
6860       /* Fill Physical Cell Group Reconfig */
6861       if(cellGrp->physicalCellGroupConfig)
6862       {
6863          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
6864          if(phyCellGrpCfg->p_NR_FR1)
6865          {
6866             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
6867                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
6868          }
6869          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
6870       }
6871       /* Fill SpCell Reconfig */
6872       if(cellGrp->spCellConfig)
6873       {
6874          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
6875          if(spcellCfg->servCellIndex)
6876          {
6877             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
6878          }
6879          /* Fill Serving cell Reconfig info */
6880          if(cellGrp->spCellConfig->spCellConfigDedicated)
6881          {
6882             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
6883             ret = extractServingCellReconfig(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
6884             if(ret == RFAILED)
6885             {
6886                DU_LOG("\n Failed at extractServingCellReconfig()");
6887             }
6888          }
6889       }
6890    }
6891    return ret;
6892 }
6893
6894 /*******************************************************************
6895  *
6896  * @brief builds Mac Cell Cfg
6897  *
6898  * @details
6899  *
6900  *    Function : procUeReCfgCellInfo
6901  *
6902  *    Functionality: builds Mac Cell Cfg
6903  *
6904  * @params[in] MacUeCfg pointer
6905  *             void pointer
6906  *
6907  * @return void
6908  *
6909  * ****************************************************************/
6910 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
6911 {
6912    uint8_t ret = ROK;
6913    CellGroupConfigRrc_t *cellGrp = NULLP;
6914
6915    if(cellInfo)
6916    {
6917       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
6918       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
6919       if(ret == RFAILED)
6920          DU_LOG("\nF1AP: Failed at procUeReCfgCellInfo()");
6921    }
6922    if(ret == RFAILED)
6923    {
6924       freeUeReCfgCellGrpInfo(macUeCfg);
6925    }
6926    return ret;
6927 }
6928
6929 /*******************************************************************
6930  *
6931  * @brief Function to extract cellGrp Info present in cutoDu cont
6932  *
6933  * @details
6934  *
6935  *    Function : extractCellGrpInfo
6936  *
6937  *    Functionality: Function to extract cellGrp Info present
6938  *                   in cutoDu cont
6939  *
6940  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
6941  *
6942  * @return CellGroupConfigRrc_t *
6943  *
6944  * ****************************************************************/
6945
6946 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
6947    DuUeCfg *ueCfgDb)
6948 {
6949    uint8_t idx2;
6950    uint16_t id;
6951    uint16_t recvBufLen;
6952    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
6953    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
6954    asn_dec_rval_t rval; /* Decoder return value */
6955    memset(&rval, 0, sizeof(asn_dec_rval_t));
6956
6957    if(protocolIeExtn)
6958    {
6959       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
6960       {
6961          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
6962          id = extIeInfo->id;
6963          switch(id)
6964          {
6965             case ProtocolIE_ID_id_CellGroupConfig:
6966             {
6967                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
6968                /* decoding the CellGroup Buf received */
6969                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6970                if(cellGrpCfg)
6971                {
6972                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
6973                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
6974                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
6975                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
6976                   {
6977                      DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
6978                      return NULLP;
6979                   }
6980                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
6981                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
6982                      return NULLP;
6983                }
6984                break;
6985             }
6986             default:
6987                DU_LOG("\nF1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
6988                break;
6989          }
6990       }
6991    }
6992    return cellGrpCfg;
6993 }
6994
6995 /*******************************************************************
6996  *
6997  * @brief Fills Srb List received by CU
6998  *
6999  * @details
7000  *
7001  *    Function : procSrbListToSetup
7002  *
7003  *    Functionality: Fills Srb List received  by CU
7004  *
7005  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
7006  *             LcCfg pointer
7007  *             RlcBearerCfg pointer
7008  * @return void
7009  *
7010  * ****************************************************************/
7011 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
7012 {
7013    uint8_t ret = ROK;
7014
7015    /* Filling RLC INFO */
7016    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
7017
7018    /* Filling MAC INFO */
7019    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL, NULL, macLcToAdd);
7020    if(ret == RFAILED)
7021    {
7022       DU_LOG("\nF1AP:Failed at MAC LC Cfg in procSrbListToSetup()");
7023       return ret;
7024    }
7025    return ret;
7026 }
7027
7028
7029
7030 /*******************************************************************
7031  *
7032  * @brief extract Srb List received by CU
7033  *
7034  * @details
7035  *
7036  *    Function : extractSrbListToSetup
7037  *
7038  *    Functionality: extract Srb List received by CU
7039  *                   for both MAC and RLC
7040  *
7041  * @params[in] SRBs_ToBeSetup_Item_t pointer
7042  *             DuUeCfg pointer
7043  * @return ROK/RFAIED
7044  *
7045  * ****************************************************************/
7046
7047 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
7048 {
7049    uint8_t ret, srbIdx;
7050    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
7051
7052    if(srbCfg)
7053    {
7054       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
7055       {
7056          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
7057          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
7058          {
7059             DU_LOG("\nF1AP:  MAX LC Reached in MAC");
7060             ret = RFAILED;
7061             break;
7062          }
7063          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
7064          {
7065             DU_LOG("\nF1AP:  MAX LC Reached in RLC");
7066             ret = RFAILED;
7067             break;
7068          }
7069          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
7070          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
7071          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
7072             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
7073          ueCfgDb->numRlcLcs++;
7074          ueCfgDb->numMacLcs++;
7075          if(ret == RFAILED)
7076          {
7077             DU_LOG("\nF1AP:  Failed at extractSrbListToSetup()");
7078             break;
7079          }
7080       }
7081    }
7082    else
7083       ret = RFAILED;
7084
7085    return ret;
7086 }
7087
7088 /*******************************************************************
7089  *
7090  * @brief Fills Drb List received by CU
7091  *
7092  * @details
7093  *
7094  *    Function : procDrbListToSetup
7095  *
7096  *    Functionality: Fills Drb List received by CU
7097  *                   for both MAC and RLC
7098  *
7099  * @params[in] SRBs_ToBeSetup_Item_t pointer
7100  *             LcCfg pointer,
7101  *             RlcBearerCfg pointer
7102  * @return void
7103  *
7104  * ****************************************************************/
7105
7106 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
7107 {
7108    uint8_t ret = ROK;
7109
7110    /* Filling RLC INFO */
7111    procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
7112
7113    /* Filling MAC INFO */
7114    ret = procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, macLcToAdd);
7115    if(ret == RFAILED)
7116    {
7117       DU_LOG("\nF1AP:Failed at RLC LC Cfg in extractDrbListToSetup()");
7118       return ret;
7119    }
7120
7121    return ret;
7122 }
7123
7124 /*******************************************************************
7125  *
7126  * @brief extract Drb List received by CU
7127  *
7128  * @details
7129  *
7130  *    Function : extractDrbListToSetup
7131  *
7132  *    Functionality: extract Drb List received by CU
7133  *                   for both MAC and RLC
7134  *
7135  * @params[in] DRBs_ToBeSetup_Item_t pointer
7136  *             DuUeCfg pointer
7137  * @return ROK/RFAIED
7138  *
7139  * ****************************************************************/
7140
7141 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg, DuUeCfg *ueCfgDb)
7142 {
7143    uint8_t ret, drbIdx;
7144    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
7145
7146    ret = ROK;
7147    if(drbCfg)
7148    {
7149       for(drbIdx = 0; drbIdx < drbCfg->list.count; drbIdx++)
7150       {
7151          drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
7152          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
7153          {
7154             DU_LOG("\nF1AP:  MAX LC Reached in MAC ");
7155             ret = RFAILED;
7156             break;
7157          }
7158          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
7159          {
7160             DU_LOG("\nF1AP:  MAX LC Reached in RLC");
7161             ret = RFAILED;
7162             break;
7163          }
7164          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
7165          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
7166          ret = procDrbListToSetup(lcId, drbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
7167             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
7168          ueCfgDb->numRlcLcs++;
7169          ueCfgDb->numMacLcs++;
7170          if(ret == RFAILED)
7171          {
7172             DU_LOG("\nF1AP:  Failed at extractDrbListToSetup()");
7173             break;
7174          }
7175       }
7176    }
7177    else
7178       ret = RFAILED;
7179
7180    return ret;
7181 }
7182
7183 /*******************************************************************
7184  *
7185  * @brief Function to extract Dl RRC Msg received from CU
7186  *
7187  * @details
7188  *
7189  *    Function : extractDlRrcMsg
7190  *
7191  *    Functionality: Function to extract Dl RRC Msg received from CU
7192  *
7193  * @params[in] F1AP message
7194  * @return ROK     - success
7195  *         RFAILED - failure
7196  *
7197  * ****************************************************************/
7198
7199 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
7200    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
7201 {
7202    uint8_t ret = ROK;
7203    dlRrcMsg->rrcMsgSize = rrcContainer->size;
7204    if(dlRrcMsg->rrcMsgSize > 0)
7205    {
7206       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
7207       if(!dlRrcMsg->rrcMsgPdu)
7208       {
7209          DU_LOG("\nDU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq");
7210          ret = RFAILED;
7211       }
7212       else
7213       {
7214          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
7215          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
7216          dlRrcMsg->srbId = SRB1_LCID;
7217          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
7218       }
7219    }
7220    return ret;
7221 }
7222
7223 /*******************************************************************
7224  *
7225  * @brief Process UE context setup request from CU
7226  *
7227  * @details
7228  *
7229  *    Function : procF1UeContextSetupReq
7230  *
7231  *    Functionality: Process UE context setup request from CU
7232  *
7233  * @params[in] F1AP message
7234  * @return ROK     - success
7235  *         RFAILED - failure
7236  *
7237  * ****************************************************************/
7238 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
7239 {
7240    uint8_t    ret, ieIdx, ueIdx, lcId, cellIdx;
7241    bool ueCbFound = false;
7242    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
7243    DuUeCb   *duUeCb = NULLP;
7244    UEContextSetupRequest_t   *ueSetReq = NULLP;
7245
7246    ret = ROK;
7247
7248    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
7249    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
7250    {
7251       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
7252       {
7253          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
7254             {
7255                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
7256                break;
7257             }
7258          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
7259             {
7260                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
7261                break;
7262             }
7263          case ProtocolIE_ID_id_ServCellIndex:
7264             {
7265                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
7266                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
7267                {
7268                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
7269                      (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
7270                   {
7271                      ueCbFound = true;
7272                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
7273                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
7274                      if(duUeCb->f1UeDb)
7275                      {
7276                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
7277                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
7278                         duUeCb->f1UeDb->cellIdx = cellIdx;
7279                      }
7280                      else
7281                      {
7282                         DU_LOG("\nF1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
7283                         ret = RFAILED;
7284                      }
7285                   }
7286                   else
7287                      ueCbFound = false;
7288
7289                }
7290                if(!ueCbFound)
7291                {
7292                   DU_LOG("\nF1AP: DuUeCb is not found at procF1UeContextSetupReq()");
7293                   ret = RFAILED;
7294                }
7295                break;
7296             }
7297          case ProtocolIE_ID_id_SpCellULConfigured:
7298             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
7299             UL, SUL or UL+SUL for the indicated cell for the UE */
7300             break;
7301          case ProtocolIE_ID_id_CUtoDURRCInformation:
7302             {
7303                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
7304                {
7305                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
7306                      value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
7307                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
7308                   {
7309                      DU_LOG("\n F1AP: Failed to extract cell Grp Info");
7310                      //TODO: Update the failure cause in ue context Setup Response
7311                      ret = RFAILED;
7312                   }
7313                }
7314                break;
7315             }
7316          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
7317             {
7318                DU_LOG("\nDU_APP: Received SCell to be added");
7319                DU_LOG("\nDU_APP: Not processing the SCell_ToBeSetup_List");
7320             break;
7321             }
7322          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
7323             {
7324                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
7325                   &duUeCb->f1UeDb->duUeCfg))
7326                {
7327                   DU_LOG("\nDU_APP: Failed at extractSrbListToSetup()");
7328                   //TODO: Update the failure cause in ue context Setup Response
7329                   ret = RFAILED;
7330                }
7331                break;
7332             }
7333          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
7334             {
7335                lcId = getDrbLcId(&duUeCb->drbBitMap);
7336                if(lcId != RFAILED)
7337                {
7338                   if(extractDrbListToSetup(lcId, &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List,\
7339                      &duUeCb->f1UeDb->duUeCfg))
7340                   {
7341                      DU_LOG("\nDU_APP: Failed at extractDrbListToSetup()");
7342                      //TODO: Update the failure cause in ue context Setup Response
7343                      ret = RFAILED;
7344                   }
7345                }
7346                else
7347                   ret = RFAILED;
7348                break;
7349             }
7350          case ProtocolIE_ID_id_RRCContainer:
7351             {
7352                /* Filling Dl RRC Msg Info */
7353                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7354                if(!duUeCb->f1UeDb->dlRrcMsg)
7355                {
7356                   DU_LOG("\nDU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
7357                   ret = RFAILED;
7358                }
7359                else
7360                {
7361                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
7362                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
7363                      &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
7364                }
7365                break;
7366             }
7367          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
7368             {
7369                duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
7370                break;
7371             }
7372          //TODO: To handle maxAggrBitRate case,
7373          // Dependency: The protocolIE is not specified in ASN
7374 #if 0
7375          case ProtocolIE_ID_id_ULPDUSessionAggregateMaximumBitRate:            {
7376                /* MaximumBitRate Uplink */
7377                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
7378                if(bitRateSize > 0)
7379                {
7380                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.maxAggrBitRate, bitRateSize);
7381                   if(!duUeCb->f1UeDb->duUeCfg.maxAggrBitRate)
7382                   {
7383                      DU_LOG("\nDU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
7384                      ret = RFAILED;
7385                   }
7386                   else
7387                   {
7388                      duUeCb->f1UeDb->duUeCfg.maxAggrBitRate->ulBits =\
7389                      *ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf;
7390                      duUeCb->f1UeDb->duUeCfg.maxAggrBitRate->dlBits = 0;
7391                   }
7392                }
7393                else
7394                   ret = RFAILED;
7395                break;
7396             }
7397 #endif
7398          default:
7399             {
7400                break;
7401             }
7402       }
7403    }
7404    if(ret == RFAILED)
7405    {
7406       /*TODO : Negative case*/
7407       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
7408       DU_LOG("F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
7409    }
7410    else
7411       ret = duProcUeContextSetupRequest(duUeCb);
7412
7413    return ret;
7414
7415 }
7416
7417 /*******************************************************************
7418  * @brief Free the memory allocated for UE Setup response
7419  *
7420  * @details
7421  *
7422  *    Function : FreeUeContextSetupRsp
7423  *
7424  *    Functionality:
7425  *       Free the memory allocated for UE Setup response
7426  *
7427  * @params[in] F1AP PDU for UE setup response
7428  * @return ROK     - success
7429  *         RFAILED - failure
7430  *
7431  * ****************************************************************/
7432 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
7433 {
7434    uint8_t idx;
7435    UEContextSetupResponse_t *ueSetRsp = NULLP;
7436
7437    if(f1apMsg)
7438    {
7439       if(f1apMsg->choice.successfulOutcome)
7440       {
7441          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
7442                     UEContextSetupResponse;
7443          if(ueSetRsp->protocolIEs.list.array)
7444          {
7445             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
7446             {
7447                if(ueSetRsp->protocolIEs.list.array[idx])
7448                {
7449                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
7450                   {
7451                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
7452                         break;
7453                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
7454                         break;
7455                      case ProtocolIE_ID_id_DUtoCURRCInformation:
7456                         {
7457                            CellGroupConfig_t *cellGrpCfg = NULLP;
7458                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
7459                                          DUtoCURRCInformation.cellGroupConfig;
7460                            if(cellGrpCfg->buf != NULLP)
7461                            {
7462                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
7463                               cellGrpCfg = NULLP;
7464                            }
7465                            break;
7466                         }
7467                      default:
7468                         DU_LOG("\nDUAPP: Invalid Id %ld at FreeUeContextSetupRsp()", ueSetRsp->protocolIEs.list.array[idx]->id);
7469                         break;
7470                   }
7471                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
7472                         sizeof(UEContextSetupResponseIEs_t));
7473                }
7474             }
7475             DU_FREE(ueSetRsp->protocolIEs.list.array, \
7476                   ueSetRsp->protocolIEs.list.size);
7477          }
7478          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
7479       }
7480       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7481    }
7482 }
7483
7484 /*******************************************************************
7485  *
7486  * @brief Builds Ue context Setup Rsp DU To CU Info
7487  *
7488  * @details
7489  *
7490  *    Function : EncodeUeCntxtDuToCuInfo
7491  *
7492  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
7493  *
7494  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
7495  *
7496  * @return ROK     - success
7497  *         RFAILED - failure
7498  *
7499  ******************************************************************/
7500
7501 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
7502 {
7503    asn_enc_rval_t        encRetVal;
7504
7505    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
7506    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7507    encBufSize = 0;
7508    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
7509    /* Encode results */
7510    if(encRetVal.encoded == ENCODE_FAIL)
7511    {
7512       DU_LOG( "\n F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
7513             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7514       return RFAILED;
7515    }
7516    else
7517    {
7518       DU_LOG("\n F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
7519       for(int i=0; i< encBufSize; i++)
7520       {
7521          printf("%x",encBuf[i]);
7522       }
7523    }
7524    duToCuCellGrp->size = encBufSize;
7525    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
7526    if(!duToCuCellGrp->buf)
7527    {
7528       DU_LOG("\nF1AP : Memory allocation failed in UeCntxtDuToCuInfo");
7529    }
7530    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
7531    return ROK;
7532 }
7533
7534 /*******************************************************************
7535  *
7536  * @brief Builds and sends the UE Setup Response
7537  *
7538  * @details
7539  *
7540  *    Function : BuildAndSendUeContextSetupRsp
7541  *
7542  *    Functionality: Constructs the UE Setup Response and sends
7543  *                   it to the DU through SCTP.
7544  *
7545  * @params[in]
7546  *
7547  * @return ROK     - success
7548  *         RFAILED - failure
7549  *
7550  * ****************************************************************/
7551 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
7552 {
7553    uint8_t   idx, ret, cellIdx, elementCnt;
7554    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
7555    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
7556    asn_enc_rval_t  encRetVal;        /* Encoder return value */
7557    F1AP_PDU_t               *f1apMsg = NULLP;
7558    UEContextSetupResponse_t *ueSetRsp = NULLP;
7559    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
7560    DuUeCb                   *ueCb = NULLP;
7561
7562    DU_LOG("\n F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
7563
7564    while(true)
7565    {
7566       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7567       if(f1apMsg == NULLP)
7568       {
7569          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
7570          ret = RFAILED;
7571          break;
7572       }
7573
7574       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
7575       DU_ALLOC(f1apMsg->choice.successfulOutcome,
7576             sizeof(SuccessfulOutcome_t));
7577       if(f1apMsg->choice.successfulOutcome == NULLP)
7578       {
7579          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
7580          ret = RFAILED;
7581          break;
7582       }
7583
7584       f1apMsg->choice.successfulOutcome->procedureCode = \
7585                                                          ProcedureCode_id_UEContextSetup;
7586       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
7587       f1apMsg->choice.successfulOutcome->value.present = \
7588                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
7589
7590       ueSetRsp =
7591          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
7592       elementCnt = 3;
7593       ueSetRsp->protocolIEs.list.count = elementCnt;
7594       ueSetRsp->protocolIEs.list.size = \
7595                                         elementCnt * sizeof(UEContextSetupResponse_t *);
7596
7597       /* Initialize the UESetup members */
7598       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
7599             ueSetRsp->protocolIEs.list.size);
7600       if(ueSetRsp->protocolIEs.list.array == NULLP)
7601       {
7602          DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
7603          ret = RFAILED;
7604          break;
7605       }
7606
7607       for(idx=0; idx<elementCnt; idx++)
7608       {
7609          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
7610                sizeof(UEContextSetupResponseIEs_t));
7611          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
7612          {
7613             DU_LOG(" F1AP : Memory allocation for UE Setup Response failed");
7614             ret = RFAILED;
7615             break;
7616          }
7617       }
7618       /* Fetching Ue Cb Info*/
7619       GET_CELL_IDX(cellId, cellIdx);
7620       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
7621       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
7622       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
7623
7624       idx = 0;
7625       /*GNB CU UE F1AP ID*/
7626       ueSetRsp->protocolIEs.list.array[idx]->id = \
7627                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
7628       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
7629       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
7630                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
7631       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
7632
7633       /*GNB DU UE F1AP ID*/
7634       idx++;
7635       ueSetRsp->protocolIEs.list.array[idx]->id = \
7636                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
7637       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
7638       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
7639                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
7640       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
7641
7642
7643       /*DUtoCURRC Information */
7644       idx++;
7645       ueSetRsp->protocolIEs.list.array[idx]->id  = \
7646                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
7647       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
7648       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
7649                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
7650       if(ueCb->f1UeDb)
7651       {
7652          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
7653          {
7654             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
7655             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
7656                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
7657             /* Free UeContext Db created during Ue context Req */
7658             freeF1UeDb(ueCb->f1UeDb);
7659          }
7660       }
7661       else
7662       {
7663          DU_LOG("\nF1AP: Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
7664          ret = RFAILED;
7665       }
7666       if(ret == RFAILED)
7667          break;
7668
7669       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7670
7671       /* Encode the UE context setup response type as APER */
7672       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
7673       encBufSize = 0;
7674       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
7675             encBuf);
7676       /* Encode results */
7677       if(encRetVal.encoded == ENCODE_FAIL)
7678       {
7679          DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
7680                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7681          ret = RFAILED;
7682          break;
7683       }
7684       else
7685       {
7686          DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
7687          for(int i=0; i< encBufSize; i++)
7688          {
7689             printf("%x",encBuf[i]);
7690          }
7691       }
7692
7693       /* Sending  msg  */
7694       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
7695       {
7696          DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
7697          ret = RFAILED;
7698          break;
7699       }
7700       break;
7701    }
7702    FreeUeContextSetupRsp(f1apMsg);
7703    return ret;
7704 }/* End of BuildAndSendUeContextSetupRsp */
7705
7706
7707 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
7708 {
7709    uint8_t cellIdx = 0, actionType = 0;
7710
7711    GET_CELL_IDX(cellId, cellIdx);
7712    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
7713
7714    switch(actionType)
7715    {
7716       case UE_CTXT_SETUP:
7717          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
7718          break;
7719       case UE_CTXT_MOD:
7720          //TODO: Build Ue context Modification Rsp
7721          break;
7722       default:
7723          DU_LOG("F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
7724          break;
7725
7726    }
7727    return ROK;
7728 }
7729
7730 /*******************************************************************
7731  *
7732  * @brief deallocating the memory of  F1reset msg
7733  *
7734  * @details
7735  *
7736  *    Function : FreeF1ResetReq
7737  *
7738  *    Functionality :
7739  *         - freeing memory of F1reset request msg
7740  *
7741  * @params[in]
7742  * @return void
7743  *
7744  *
7745  * ****************************************************************/
7746 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
7747 {
7748    uint8_t idx =0 ;
7749    Reset_t *f1ResetMsg;
7750
7751    if(f1apMsg)
7752    {
7753       if(f1apMsg->choice.initiatingMessage)
7754       {
7755          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
7756
7757          if(f1ResetMsg->protocolIEs.list.array)
7758          {
7759             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
7760             {
7761                if(f1ResetMsg->protocolIEs.list.array[idx])
7762                {
7763                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
7764                }
7765             }
7766             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
7767          }
7768          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7769       }
7770       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7771    }
7772 }
7773 /*******************************************************************
7774  *
7775  * @brief Build and Send F1reset request
7776  *
7777  * @details
7778  *
7779  *    Function : BuildAndSendF1ResetReq
7780  *
7781  *    Functionality:
7782  *         - Build and Send F1reset request msg
7783  *
7784  * @params[in]
7785  * @return ROK     - success
7786  *         RFAILED - failure
7787  *
7788  * ****************************************************************/
7789 uint8_t BuildAndSendF1ResetReq()
7790 {
7791    uint8_t          elementCnt=0;
7792    uint8_t          idx=0;
7793    uint8_t          ret= RFAILED;
7794    Reset_t          *f1ResetMsg = NULLP;
7795    F1AP_PDU_t       *f1apMsg = NULLP;
7796    asn_enc_rval_t   encRetVal;
7797    DU_LOG("\nF1AP : Building F1 Reset request \n");
7798    do
7799    {
7800       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7801       if(f1apMsg == NULLP)
7802       {
7803          break;
7804       }
7805       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
7806       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
7807       if(f1apMsg->choice.initiatingMessage == NULLP)
7808       {
7809          break;
7810       }
7811       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
7812       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
7813       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
7814
7815       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
7816
7817       elementCnt = 3;
7818       f1ResetMsg->protocolIEs.list.count = elementCnt;
7819       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
7820
7821       /* Initialize the F1Setup members */
7822       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
7823       if(f1ResetMsg->protocolIEs.list.array == NULLP)
7824       {
7825          break;
7826       }
7827       for(idx=0; idx<elementCnt; idx++)
7828       {
7829          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
7830          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
7831          {
7832             break;
7833          }
7834       }
7835
7836       /*TransactionID*/
7837       idx=0;
7838       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
7839       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
7840       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
7841       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
7842
7843       /*Cause*/
7844       idx++;
7845       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
7846       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
7847       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
7848       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
7849       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
7850
7851       /*Reset Type*/
7852       idx++;
7853       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
7854       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
7855       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
7856       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
7857       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
7858
7859       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
7860
7861       /* Encode the F1SetupRequest type as APER */
7862       memset(encBuf, 0, ENC_BUF_MAX_LEN);
7863       encBufSize = 0;
7864       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
7865             encBuf);
7866
7867       /* Encode results */
7868       if(encRetVal.encoded == ENCODE_FAIL)
7869       {
7870          DU_LOG("\nF1AP : Could not encode F1Reset structure (at %s)\n",\
7871                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
7872          break;
7873       }
7874       else
7875       {
7876          DU_LOG("\nF1AP : Created APER encoded buffer for F1Reset\n");
7877          for(idx=0; idx< encBufSize; idx++)
7878          {
7879             printf("%x",encBuf[idx]);
7880          }
7881       }
7882
7883       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
7884       {
7885          DU_LOG("\nF1AP : Sending F1 Reset request failed");
7886          break;
7887       }
7888
7889       ret = ROK;
7890       break;
7891    }while(true);
7892
7893    FreeF1ResetReq(f1apMsg);
7894    return ret;
7895 }
7896 /*******************************************************************
7897  *
7898  * @brief Build And Send F1ResetAck
7899  *
7900  * @details
7901  *
7902  *    Function : BuildAndSendF1ResetAck
7903  *
7904  *    Functionality:
7905  *         - Build And Send  F1ResetRSP
7906  *
7907  * @return ROK     - success
7908  *         RFAILED - failure
7909  *
7910  * ****************************************************************/
7911 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
7912 {
7913    uint8_t idx;
7914    ResetAcknowledge_t *f1ResetAck;
7915
7916    if(f1apMsg)
7917    {
7918       if(f1apMsg->choice.successfulOutcome)
7919       {
7920          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
7921
7922          if(f1ResetAck->protocolIEs.list.array)
7923          {
7924             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
7925             {
7926                if(f1ResetAck->protocolIEs.list.array[idx])
7927                {
7928                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
7929                }
7930             }
7931             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
7932          }
7933          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
7934       }
7935       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
7936    }
7937 }
7938
7939 /*******************************************************************
7940  *
7941  * @brief Build And Send F1ResetAck
7942  *
7943  * @details
7944  *
7945  *    Function : BuildAndSendF1ResetAck
7946  *
7947  *    Functionality:
7948  *         - Build And Send  F1ResetRSP
7949  *
7950  *  @params[in]
7951  * @return ROK     - success
7952  *         RFAILED - failure
7953  *
7954  * ****************************************************************/
7955 uint8_t BuildAndSendF1ResetAck()
7956 {
7957    uint8_t                idx = 0;
7958    uint8_t                elementCnt = 0;
7959    uint8_t                ret = RFAILED;
7960    F1AP_PDU_t             *f1apMsg = NULL;
7961    ResetAcknowledge_t     *f1ResetAck = NULLP;
7962    asn_enc_rval_t         encRetVal;
7963    DU_LOG("\nF1AP : Building F1 Reset Acknowledgment \n");
7964
7965    do{
7966       /* Allocate the memory for F1ResetRequest_t */
7967       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
7968       if(f1apMsg == NULLP)
7969       {
7970          DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
7971          break;
7972       }
7973
7974       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
7975
7976       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
7977       if(f1apMsg->choice.successfulOutcome == NULLP)
7978       {
7979          DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
7980          break;
7981       }
7982       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
7983       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
7984       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
7985
7986       elementCnt = 1;
7987
7988       f1ResetAck->protocolIEs.list.count = elementCnt;
7989       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
7990
7991       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
7992       if(f1ResetAck->protocolIEs.list.array == NULLP)
7993       {
7994          DU_LOG("\nF1AP : Memory allocation for F1ResetAckIEs failed");
7995          break;
7996       }
7997
7998       for(idx=0; idx<elementCnt; idx++)
7999       {
8000          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
8001          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
8002          {
8003             break;
8004          }
8005       }
8006       /*TransactionID*/
8007       idx = 0;
8008       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
8009       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
8010       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
8011       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
8012
8013       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8014
8015       /* Encode the F1SetupRequest type as UPER */
8016       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8017       encBufSize = 0;
8018       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
8019
8020       /* Check encode results */
8021       if(encRetVal.encoded == ENCODE_FAIL)
8022       {
8023          DU_LOG("\nF1AP : Could not encode F1ResetAck structure (at %s)\n",\
8024                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8025          break;
8026       }
8027       else
8028       {
8029          DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck\n");
8030          for(int i=0; i< encBufSize; i++)
8031          {
8032             printf("%x",encBuf[i]);
8033          }
8034       }
8035       /* Sending msg */
8036       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
8037       {
8038          DU_LOG("\nF1AP : Sending F1 Reset Acknowledgement failed");
8039          break;
8040       }
8041
8042       ret = ROK;
8043       break;
8044    }while(true);
8045
8046    FreeF1ResetAck(f1apMsg);
8047    return ret;
8048 }
8049
8050 /******************************************************************
8051  *
8052  * @brief Processes DL RRC Message Transfer  sent by CU
8053  *
8054  * @details
8055  *
8056  *    Function : procF1ResetReq
8057  *
8058  *    Functionality: Processes DL RRC Message Transfer sent by CU
8059  *
8060  * @params[in] F1AP_PDU_t ASN decoded F1AP message
8061  * @return ROK     - success
8062  *         RFAILED - failure
8063  *
8064  * ****************************************************************/
8065 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
8066 {
8067    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
8068    uint8_t       idx = 0;
8069    uint8_t        ret = ROK;
8070    Reset_t       *f1ResetMsg = NULLP;
8071
8072    DU_LOG("\nProcessing F1 reset request");
8073    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
8074
8075    for(idx=0; idx<f1ResetMsg->protocolIEs.list.count; idx++)
8076    {
8077       switch(f1ResetMsg->protocolIEs.list.array[idx]->id)
8078       {
8079          case ProtocolIE_ID_id_TransactionID:
8080             break;
8081
8082          case ProtocolIE_ID_id_Cause:
8083             break;
8084
8085          case ProtocolIE_ID_id_ResetType:
8086             {
8087                DU_LOG("\nReceived F1 Reset request");
8088                break;
8089             }
8090
8091          default:
8092             break;
8093       }
8094    }
8095    ret = BuildAndSendF1ResetAck();
8096    DU_LOG("\nUE release is not supported for now");
8097    return ret;
8098 }
8099
8100 /*******************************************************************
8101  *
8102  * @brief free the RRC delivery report
8103  *
8104  * @details
8105  *
8106  *    Function : freeRrcDeliveryReport
8107  *
8108  *    Functionality: free the RRC delivery report
8109  *
8110  * @params[in]
8111  * @return ROK     - success
8112  *         RFAILED - failure
8113  *
8114  * ****************************************************************/
8115 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
8116 {
8117    uint8_t idx=0;
8118    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
8119
8120    if(f1apMsg)
8121    {
8122       if(f1apMsg->choice.initiatingMessage)
8123       {
8124          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
8125          if(rrcDeliveryReport->protocolIEs.list.array)
8126          {
8127             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
8128                   idx++)
8129             {
8130                if(rrcDeliveryReport->protocolIEs.list.array[idx])
8131                {
8132                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
8133                         sizeof(RRCDeliveryReportIEs_t));
8134                }
8135             }
8136             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
8137                   rrcDeliveryReport->protocolIEs.list.size);
8138          }
8139          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8140       }
8141       DU_FREE(f1apMsg,
8142             sizeof(F1AP_PDU_t));
8143    }
8144 }
8145
8146 /*******************************************************************
8147 *
8148 * @brief Builds and sends the RRC delivery report
8149 *
8150 * @details
8151 *
8152 *    Function : BuildAndSendRrcDeliveryReport
8153 *
8154 *    Functionality: Builds and sends the RRC delivery report
8155 *
8156 * @params[in]
8157 *
8158 * @return ROK     - success
8159 *         RFAILED - failure
8160 *
8161 * ****************************************************************/
8162 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
8163    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
8164 {
8165    uint8_t             ret = RFAILED;
8166    uint8_t             idx    = 0;
8167    uint8_t             idx1   = 0;
8168    uint8_t             elementCnt = 0;
8169    F1AP_PDU_t          *f1apMsg = NULLP;
8170    asn_enc_rval_t      encRetVal;
8171    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
8172
8173    do{
8174
8175       DU_LOG("\nF1AP : Building RRC delivery Message Transfer Message\n");
8176       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8177       if(f1apMsg == NULLP)
8178       {
8179          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
8180          break;
8181       }
8182       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8183       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8184       if(f1apMsg->choice.initiatingMessage == NULLP)
8185       {
8186          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU  failed");
8187          break;
8188       }
8189       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
8190       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
8191       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
8192
8193       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
8194       elementCnt = 4;
8195       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
8196       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
8197
8198       /* Initialize the F1Setup members */
8199       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
8200       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
8201       {
8202          DU_LOG(" F1AP : Memory allocation for RRC Delivery  failed");
8203          break;
8204       }
8205       for(idx =0 ;idx <elementCnt; idx++)
8206       {
8207          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
8208          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
8209          {
8210             break;
8211          }
8212       }
8213
8214       idx1 = 0;
8215
8216       /*GNB CU UE F1AP ID*/
8217       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
8218       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
8219       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
8220       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
8221
8222       /*GNB DU UE F1AP ID*/
8223       idx1++;
8224       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8225       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
8226       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
8227       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
8228
8229       /*RRC delivery status*/
8230       idx1++;
8231       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
8232       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
8233       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
8234       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
8235       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
8236       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
8237       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
8238
8239       /* SRB ID */
8240       idx1++;
8241       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
8242       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
8243       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
8244       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
8245
8246       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8247
8248       /* Encode the RRC DELIVERY REPORT type as APER */
8249       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8250       encBufSize = 0;
8251       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
8252             encBuf);
8253
8254       /* Encode results */
8255       if(encRetVal.encoded == ENCODE_FAIL)
8256       {
8257          DU_LOG("\nF1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
8258                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8259          break;
8260       }
8261       else
8262       {
8263          DU_LOG("\nF1AP : Created APER encoded buffer for RRC Delivery Msg \n");
8264          for(idx=0; idx< encBufSize; idx++)
8265          {
8266             printf("%x",encBuf[idx]);
8267          }
8268       }
8269
8270       /* Sending msg */
8271       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
8272       {
8273          DU_LOG("\nF1AP : Sending RRC delivery  msg request failed");
8274          break;
8275       }
8276       ret = ROK;
8277       break;
8278
8279    }while(true);
8280
8281    freeRrcDeliveryReport(f1apMsg);
8282    return ret;
8283 }
8284
8285 /*******************************************************************
8286  *
8287  * @brief Processes cells to be activated
8288  *
8289  * @details
8290  *
8291  *    Function : extractCellsToBeActivated
8292  *
8293  *    Functionality:
8294  *      - Processes cells to be activated list received in F1SetupRsp
8295  *
8296  * @params[in] void
8297  * @return ROK     - success
8298  *         RFAILED - failure
8299  *
8300  * ****************************************************************/
8301
8302 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
8303 {
8304    uint8_t  ret = ROK;
8305    uint16_t idx, nci, pci = 0;
8306    Cells_to_be_Activated_List_Item_t cell;
8307
8308    for(idx=0; idx<cellsToActivate.list.count; idx++)
8309    {
8310       nci = 0;
8311       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
8312       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
8313
8314       if(nci <= 0 || nci > MAX_NUM_CELL)
8315       {
8316          DU_LOG("\nDU APP : Invalid NCI %d", nci);
8317          return RFAILED;
8318       }
8319       if(cell.nRPCI)
8320       {
8321          pci = *cell.nRPCI;
8322       }
8323       ret = duProcCellsToBeActivated(nci, pci);
8324    }
8325    return ret;
8326 }
8327
8328 /******************************************************************
8329  *
8330  * @brief Processes F1 Setup Response sent by CU
8331  *
8332  * @details
8333  *
8334  *    Function : procF1SetupRsp
8335  *
8336  *    Functionality: Processes F1 Setup Response sent by CU
8337  *
8338  * @params[in] F1AP_PDU_t ASN decoded F1AP message
8339  * @return ROK     - success
8340  *         RFAILED - failure
8341  *
8342  * ****************************************************************/
8343 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
8344 {
8345    uint8_t ret = ROK;
8346    uint16_t idx;
8347    F1SetupResponse_t *f1SetRspMsg = NULLP;
8348    GNB_CU_Name_t     *cuName = NULLP;
8349    RRC_Version_t     *rrc_Ver = NULLP;
8350    F1SetupRsp  f1SetRspDb;
8351    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
8352
8353    DU_LOG("\nF1AP : F1 Setup Response received");
8354    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
8355
8356    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
8357    {
8358       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
8359       {
8360          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
8361             {
8362                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
8363                      value.choice.Cells_to_be_Activated_List);
8364                break;
8365             }
8366          case ProtocolIE_ID_id_TransactionID:
8367             {
8368                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
8369                                     value.choice.TransactionID;
8370                break;
8371             }
8372          case ProtocolIE_ID_id_gNB_CU_Name:
8373             {
8374                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
8375                         value.choice.GNB_CU_Name;
8376                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
8377                break;
8378             }
8379          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
8380             {
8381                rrc_Ver = &f1SetRspMsg->protocolIEs.list.array[idx]->\
8382                          value.choice.RRC_Version;
8383                strcpy(f1SetRspDb.rrcVersion.rrcVer,
8384                      (const char*)rrc_Ver->latest_RRC_Version.buf);
8385                break;
8386             }
8387          default:
8388             DU_LOG("\nDU_APP : Invalid IE received in F1SetupRsp:%ld",
8389                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
8390       }
8391       duProcF1SetupRsp();
8392    }
8393    return ret;
8394 }
8395
8396 /*******************************************************************
8397  *
8398  * @brief Processes GNB DU config update ack
8399  *
8400  * @details
8401  *
8402  *    Function : procF1GNBDUCfgUpdAck
8403  *
8404  *    Functionality: Processes GNB DU config update ack
8405  *
8406  * @params[in] F1AP_PDU_t ASN decoded F1AP message
8407  * @return ROK     - success
8408  *         RFAILED - failure
8409  *
8410  * ****************************************************************/
8411 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
8412 {
8413    uint8_t ieIdx, transId;
8414    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
8415
8416    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
8417
8418    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
8419    {
8420       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
8421       {
8422          case ProtocolIE_ID_id_TransactionID:
8423             transId = gnbDuAck->protocolIEs.list.array[ieIdx]->\
8424                value.choice.TransactionID;
8425             DU_LOG("\nF1AP : GNB-DU config update acknowledgment received for transId %d", transId);
8426             break;
8427          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
8428             break;
8429          default :
8430             DU_LOG("\nF1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
8431             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
8432             break;
8433       }
8434    }
8435    duProcGnbDuCfgUpdAckMsg();
8436 #if 0
8437    if(BuildAndSendF1ResetReq() != ROK)
8438    {
8439       return RFAILED;
8440    }
8441 #endif
8442    return ROK;
8443 }
8444
8445 /******************************************************************
8446  *
8447  * @brief Processes DL RRC Message Transfer  sent by CU
8448  *
8449  * @details
8450  *
8451  *    Function : procF1DlRrcMsgTrans
8452  *
8453  *    Functionality: Processes DL RRC Message Transfer sent by CU
8454  *
8455  * @params[in] F1AP_PDU_t ASN decoded F1AP message
8456  * @return ROK     - success
8457  *         RFAILED - failure
8458  *
8459  * ****************************************************************/
8460 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
8461 {
8462    uint8_t  idx, ret;
8463    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
8464    F1DlRrcMsg dlMsg;
8465    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
8466
8467    DU_LOG("\nDU_APP : DL RRC message transfer Recevied");
8468    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
8469
8470    ret = ROK;
8471
8472    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
8473    {
8474       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
8475       {
8476          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
8477             {
8478                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
8479                break;
8480             }
8481          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
8482             {
8483                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
8484                break;
8485             }
8486          case ProtocolIE_ID_id_SRBID:
8487             {
8488                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
8489                break;
8490             }
8491          case ProtocolIE_ID_id_ExecuteDuplication:
8492             dlMsg.execDup = true;
8493             break;
8494
8495          case ProtocolIE_ID_id_RRCContainer:
8496             {
8497                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
8498                {
8499                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
8500                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
8501                   if(dlMsg.rrcMsgPdu)
8502                   {
8503                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
8504                         dlMsg.rrcMsgSize);
8505                   }
8506                   else
8507                   {
8508                      DU_LOG("\nDU_APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
8509                      return RFAILED;
8510                   }
8511                }
8512                else
8513                {
8514                   DU_LOG("\nDU_APP : RRC Container Size is invalid:%ld",\
8515                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
8516                   return RFAILED;
8517                }
8518                break;
8519             }
8520          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
8521             {
8522                dlMsg.deliveryStatRpt = true;
8523                break;
8524             }
8525          default:
8526             DU_LOG("\nDU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
8527                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
8528       }
8529    }
8530
8531    ret = duProcDlRrcMsg(&dlMsg);
8532    return ret;
8533 }
8534
8535 /*****************************************************************i
8536  *
8537  * @brief Handles received F1AP message and sends back response
8538  *
8539  * @details
8540  *
8541  *    Function : F1APMsgHdlr
8542  *
8543  *    Functionality:
8544  *         - Decodes received F1AP control message
8545  *         - Prepares response message, encodes and sends to SCTP
8546  *
8547  * @params[in]
8548  * @return ROK     - success
8549  *         RFAILED - failure
8550  *
8551  * ****************************************************************/
8552 void F1APMsgHdlr(Buffer *mBuf)
8553 {
8554    int i;
8555    char *recvBuf;
8556    MsgLen copyCnt;
8557    MsgLen recvBufLen;
8558    F1AP_PDU_t *f1apMsg;
8559    asn_dec_rval_t rval; /* Decoder return value */
8560    F1AP_PDU_t f1apasnmsg ;
8561
8562    DU_LOG("\nF1AP : Received F1AP message buffer");
8563    ODU_PRINT_MSG(mBuf, 0,0);
8564
8565    /* Copy mBuf into char array to decode it */
8566    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
8567    DU_ALLOC(recvBuf, (Size)recvBufLen);
8568
8569    if(recvBuf == NULLP)
8570    {
8571       DU_LOG("\nF1AP : Memory allocation failed");
8572       return;
8573    }
8574    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
8575    {
8576       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
8577       return;
8578    }
8579
8580    printf("\nF1AP : Received flat buffer to be decoded : ");
8581    for(i=0; i< recvBufLen; i++)
8582    {
8583       printf("%x",recvBuf[i]);
8584    }
8585
8586    /* Decoding flat buffer into F1AP messsage */
8587    f1apMsg = &f1apasnmsg;
8588    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
8589
8590    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
8591    DU_FREE(recvBuf, (Size)recvBufLen);
8592
8593    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
8594    {
8595       DU_LOG("\nF1AP : ASN decode failed");
8596       return;
8597    }
8598    printf("\n");
8599    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8600
8601    switch(f1apMsg->present)
8602    {
8603       case F1AP_PDU_PR_successfulOutcome:
8604          {
8605             switch(f1apMsg->choice.successfulOutcome->value.present)
8606             {
8607                case SuccessfulOutcome__value_PR_ResetAcknowledge:
8608                   {
8609                      DU_LOG("\nF1AP : F1ResetAcknowledge is received successfully ");
8610                      break;
8611                   }
8612                case SuccessfulOutcome__value_PR_F1SetupResponse:
8613                   {
8614 #ifndef ODU_TEST_STUB
8615                      procF1SetupRsp(f1apMsg);
8616 #endif
8617                      break;
8618                   }
8619
8620                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
8621                   {
8622                      procF1GNBDUCfgUpdAck(f1apMsg);
8623                      break;
8624                   }
8625
8626                default:
8627                   {
8628                      DU_LOG("\nF1AP : Invalid type of successful outcome [%d]", f1apMsg->choice.successfulOutcome->value.present);
8629                      return;
8630                   }
8631             }/* End of switch(successfulOutcome) */
8632             break;
8633          }
8634       case F1AP_PDU_PR_initiatingMessage:
8635          {
8636             switch(f1apMsg->choice.initiatingMessage->value.present)
8637             {
8638                case InitiatingMessage__value_PR_Reset:
8639                   {
8640                      DU_LOG("\nF1AP : F1 reset request received");
8641                      procF1ResetReq(f1apMsg);
8642                      break;
8643                   }
8644                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
8645                   {
8646                      procF1DlRrcMsgTrans(f1apMsg);
8647                      break;
8648                   }
8649                case InitiatingMessage__value_PR_UEContextSetupRequest:
8650                   {
8651                      procF1UeContextSetupReq(f1apMsg);
8652                      break;
8653                   }
8654
8655                default:
8656                   {
8657                      DU_LOG("\nF1AP : Invalid type of initiating message[%d]",
8658                            f1apMsg->choice.initiatingMessage->value.present);
8659                      return;
8660                   }
8661             }/* End of switch(initiatingMessage) */
8662             break;
8663          }
8664
8665       default:
8666          {
8667             DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
8668             return;
8669          }
8670
8671    }/* End of switch(f1apMsg->present) */
8672
8673 } /* End of F1APMsgHdlr */
8674
8675 /**********************************************************************
8676   End of file
8677  **********************************************************************/