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