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 "RAT-Type.h"
  31 #include "FeatureSetUplinkPerCC.h"
  32 #include "FeatureSetDownlinkPerCC.h"
  33 #include "FeatureSets.h"
  34 #include "UE-NR-Capability.h"
  35 #include "UE-CapabilityRAT-Container.h"
  36 #include "UE-CapabilityRAT-ContainerListRRC.h"
  37 #include "GNB-DU-System-Information.h"
  38 #include "CellGroupConfigRrc.h"
  39 #include "MAC-CellGroupConfig.h"
  40 #include "SchedulingRequestConfig.h"
  41 #include "SchedulingRequestToAddMod.h"
  42 #include "BSR-Config.h"
  43 #include "TAG-Config.h"
  44 #include "TAG.h"
  45 #include "PHR-Config.h"
  46 #include "RLC-Config.h"
  47 #include "UL-AM-RLC.h"
  48 #include "DL-AM-RLC.h"
  49 #include "LogicalChannelConfig.h"
  50 #include "RLC-BearerConfig.h"
  51 #include "PhysicalCellGroupConfig.h"
  52 #include "SpCellConfig.h"
  53 #include "TDD-UL-DL-ConfigDedicated.h"
  54 #include "ServingCellConfig.h"
  55 #include "ControlResourceSet.h"
  56 #include "SearchSpace.h"
  57 #include "PDCCH-Config.h"
  58 #include "PDSCH-TimeDomainResourceAllocation.h"
  59 #include "PDSCH-TimeDomainResourceAllocationList.h"
  60 #include "PDSCH-CodeBlockGroupTransmission.h"
  61 #include "PDSCH-ServingCellConfig.h"
  62 #include "DMRS-DownlinkConfig.h"
  63 #include "PDSCH-Config.h"
  64 #include "BWP-DownlinkDedicated.h"
  65 #include "PUSCH-TimeDomainResourceAllocation.h"
  66 #include "PUSCH-TimeDomainResourceAllocationList.h"
  67 #include "DMRS-UplinkConfig.h"
  68 #include "PUSCH-Config.h"
  69 #include "SRS-ResourceId.h"
  70 #include "SRS-Resource.h"
  71 #include "SRS-ResourceSet.h"
  72 #include "SRS-Config.h"
  73 #include "BWP-UplinkDedicated.h"
  74 #include "PUSCH-ServingCellConfig.h"
  75 #include "UplinkConfig.h"
  76 #include "DUtoCURRCContainer.h"
  77 #include "GBR-QoSFlowInformation.h"
  78 #include "QoSFlowLevelQoSParameters.h"
  79 #include "PUCCH-Config.h"
  80 #include "PUCCH-ResourceSet.h"
  81 #include "PUCCH-Resource.h"
  82 #include "PUCCH-PowerControl.h"
  83 #include "P0-PUCCH.h"
  84 #include "PUCCH-PathlossReferenceRS.h"
  85 #include "PUCCH-format0.h"
  86 #include "PUCCH-format1.h"
  87 #include "PUCCH-format2.h"
  88 #include "PUCCH-format3.h"
  89 #include "PUCCH-format4.h"
  90 #include "PUCCH-FormatConfig.h"
  91 #include "SchedulingRequestResourceConfig.h"
  92 #include<ProtocolIE-Field.h>
  93 #include "ProtocolExtensionField.h"
  94 #include "F1AP-PDU.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99
 100 DuCfgParams duCfgParam;
 101
 102 /************************************************************************
 103  *
 104  * @brief Converts enum values into actual value of Poll retransmit timer
 105  *
 106  * @details
 107  *
 108  *    Function : getPollPdu
 109  *
 110  *    Functionality: Converts enum values into actual value of poll
 111  *    retransmit timer
 112  *
 113  * @params[in] Enum value of pollPdu
 114  * @return Actual value of pollPdu
 115  *
 116  * **********************************************************************/
 117
 118 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 119 {
 120    uint16_t pollRetxTmr;
 121
 122    /* All values of poll retx timer are at interval of 5ms.
 123     * This is valid upto 250ms
 124     * Hence converting the enum value to actual value by multiplying it to 5
 125     */
 126    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 127       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 128    else
 129    {
 130       switch(pollRetxTmrCfg)
 131       {
 132          case T_PollRetransmit_ms300:
 133             pollRetxTmr = 300;
 134             break;
 135          case T_PollRetransmit_ms350:
 136             pollRetxTmr = 350;
 137             break;
 138          case T_PollRetransmit_ms400:
 139             pollRetxTmr = 400;
 140             break;
 141          case T_PollRetransmit_ms450:
 142             pollRetxTmr = 450;
 143             break;
 144          case T_PollRetransmit_ms500:
 145             pollRetxTmr = 500;
 146             break;
 147          case T_PollRetransmit_ms800:
 148             pollRetxTmr = 800;
 149             break;
 150          default:
 151             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 152             pollRetxTmr = 0;
 153       }
 154    }
 155    return pollRetxTmr;
 156 }
 157
 158 /*******************************************************************
 159  *
 160  * @brief Converts enum values into actual value of PollPdu
 161  *
 162  * @details
 163  *
 164  *    Function : getPollPdu
 165  *
 166  *    Functionality: Converts enum values into actual value of PollPdu
 167  *
 168  * @params[in] Enum value of pollPdu
 169  * @return Actual value of pollPdu
 170  *
 171  * ****************************************************************/
 172 int16_t getPollPdu(uint8_t pollPduCfg)
 173 {
 174    int16_t pollPdu;
 175    switch(pollPduCfg)
 176    {
 177       case PollPDU_p4:
 178          pollPdu = 4;
 179          break;
 180       case PollPDU_p8:
 181          pollPdu = 8;
 182          break;
 183       case PollPDU_p16:
 184          pollPdu = 16;
 185          break;
 186       case PollPDU_p32:
 187          pollPdu = 32;
 188          break;
 189       case PollPDU_p64:
 190          pollPdu = 64;
 191          break;
 192       case PollPDU_p128:
 193          pollPdu = 128;
 194          break;
 195       case PollPDU_p256:
 196          pollPdu = 256;
 197          break;
 198       case PollPDU_p512:
 199          pollPdu = 512;
 200          break;
 201       case PollPDU_p1024:
 202          pollPdu = 1024;
 203          break;
 204       case PollPDU_p2048:
 205          pollPdu = 2048;
 206          break;
 207       case PollPDU_p4096:
 208          pollPdu = 4096;
 209          break;
 210       case PollPDU_p6144:
 211          pollPdu = 6144;
 212          break;
 213       case PollPDU_p8192:
 214          pollPdu = 8192;
 215          break;
 216       case PollPDU_p12288:
 217          pollPdu = 12288;
 218          break;
 219       case PollPDU_p16384:
 220          pollPdu = 16384;
 221          break;
 222       case PollPDU_p20480:
 223          pollPdu = 20480;
 224          break;
 225       case PollPDU_p24576:
 226          pollPdu = 24576;
 227          break;
 228       case PollPDU_p28672:
 229          pollPdu = 28672;
 230          break;
 231       case PollPDU_p32768:
 232          pollPdu = 32768;
 233          break;
 234       case PollPDU_p40960:
 235          pollPdu = 40960;
 236          break;
 237       case PollPDU_p49152:
 238          pollPdu = 49152;
 239          break;
 240       case PollPDU_p57344:
 241          pollPdu = 57344;
 242          break;
 243       case PollPDU_p65536:
 244          pollPdu = 65536;
 245          break;
 246       case PollPDU_infinity:
 247          pollPdu = -1;
 248          break;
 249       default:
 250          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 251          pollPdu = 0;
 252          break;
 253    }
 254    return pollPdu;
 255 }
 256
 257 /*******************************************************************
 258  *
 259  * @brief Converts enum values into actual value of poll bytes
 260  *
 261  * @details
 262  *
 263  *    Function : getPollByte
 264  *
 265  *    Functionality: Converts enum values into actual value of pollBytes
 266  *
 267  * @params[in] Enum value
 268  * @return Actual value
 269  *
 270  * ****************************************************************/
 271 int32_t getPollByte(uint16_t pollBytesCfg)
 272 {
 273    int32_t pollBytes;
 274    switch(pollBytesCfg)
 275    {
 276       case PollByte_kB1:
 277          pollBytes = 1000;
 278          break;
 279       case PollByte_kB2:
 280          pollBytes = 2000;
 281          break;
 282       case PollByte_kB5:
 283          pollBytes = 5000;
 284          break;
 285       case PollByte_kB8:
 286          pollBytes = 8000;
 287          break;
 288       case PollByte_kB10:
 289          pollBytes = 10000;
 290          break;
 291       case PollByte_kB15:
 292          pollBytes = 15000;
 293          break;
 294       case PollByte_kB25:
 295          pollBytes = 25000;
 296          break;
 297       case PollByte_kB50:
 298          pollBytes = 50000;
 299          break;
 300       case PollByte_kB75:
 301          pollBytes = 75000;
 302          break;
 303       case PollByte_kB100:
 304          pollBytes = 100000;
 305          break;
 306       case PollByte_kB125:
 307          pollBytes = 125000;
 308          break;
 309       case PollByte_kB250:
 310          pollBytes = 250000;
 311          break;
 312       case PollByte_kB375:
 313          pollBytes = 375000;
 314          break;
 315       case PollByte_kB500:
 316          pollBytes = 500000;
 317          break;
 318       case PollByte_kB750:
 319          pollBytes = 750000;
 320          break;
 321       case PollByte_kB1000:
 322          pollBytes = 1000000;
 323          break;
 324       case PollByte_kB1250:
 325          pollBytes = 1250000;
 326          break;
 327       case PollByte_kB1500:
 328          pollBytes = 1500000;
 329          break;
 330       case PollByte_kB2000:
 331          pollBytes = 2000000;
 332          break;
 333       case PollByte_kB3000:
 334          pollBytes = 3000000;
 335          break;
 336       case PollByte_kB4000:
 337          pollBytes = 4000000;
 338          break;
 339       case PollByte_kB4500:
 340          pollBytes = 4500000;
 341          break;
 342       case PollByte_kB5000:
 343          pollBytes = 5000000;
 344          break;
 345       case PollByte_kB5500:
 346          pollBytes = 5500000;
 347          break;
 348       case PollByte_kB6000:
 349          pollBytes = 6000000;
 350          break;
 351       case PollByte_kB6500:
 352          pollBytes = 6500000;
 353          break;
 354       case PollByte_kB7000:
 355          pollBytes = 7000000;
 356          break;
 357       case PollByte_kB7500:
 358          pollBytes = 7500000;
 359          break;
 360       case PollByte_mB8:
 361          pollBytes = 8000000;
 362          break;
 363       case PollByte_mB9:
 364          pollBytes = 9000000;
 365          break;
 366       case PollByte_mB10:
 367          pollBytes = 10000000;
 368          break;
 369       case PollByte_mB11:
 370          pollBytes = 11000000;
 371          break;
 372       case PollByte_mB12:
 373          pollBytes = 12000000;
 374          break;
 375       case PollByte_mB13:
 376          pollBytes = 13000000;
 377          break;
 378       case PollByte_mB14:
 379          pollBytes = 14000000;
 380          break;
 381       case PollByte_mB15:
 382          pollBytes = 15000000;
 383          break;
 384       case PollByte_mB16:
 385          pollBytes = 16000000;
 386          break;
 387       case PollByte_mB17:
 388          pollBytes = 17000000;
 389          break;
 390       case PollByte_mB18:
 391          pollBytes = 18000000;
 392          break;
 393       case PollByte_mB20:
 394          pollBytes = 20000000;
 395          break;
 396       case PollByte_mB25:
 397          pollBytes = 25000000;
 398          break;
 399       case PollByte_mB30:
 400          pollBytes = 30000000;
 401          break;
 402       case PollByte_mB40:
 403          pollBytes = 40000000;
 404          break;
 405       case PollByte_infinity:
 406          pollBytes = -1;
 407          break;
 408       default:
 409          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 410          pollBytes = 0;
 411    }
 412    return pollBytes;
 413 }
 414
 415 /*******************************************************************
 416  *
 417  * @brief Converts enum values into actual value of maxRetx
 418  *
 419  * @details
 420  *
 421  *    Function : getMaxRetx
 422  *
 423  *    Functionality: Converts enum values into actual value of maxRetx
 424  *
 425  * @params[in] Enum value
 426  * @return Actual value
 427  *
 428  * ****************************************************************/
 429 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 430 {
 431    uint8_t maxRetx;
 432    switch(maxRetxCfg)
 433    {
 434       case UL_AM_RLC__maxRetxThreshold_t1:
 435          maxRetx = 1;
 436          break;
 437       case UL_AM_RLC__maxRetxThreshold_t2:
 438          maxRetx = 2;
 439          break;
 440       case UL_AM_RLC__maxRetxThreshold_t3:
 441          maxRetx = 3;
 442          break;
 443       case UL_AM_RLC__maxRetxThreshold_t4:
 444          maxRetx = 4;
 445          break;
 446       case UL_AM_RLC__maxRetxThreshold_t6:
 447          maxRetx = 6;
 448          break;
 449       case UL_AM_RLC__maxRetxThreshold_t8:
 450          maxRetx = 8;
 451          break;
 452       case UL_AM_RLC__maxRetxThreshold_t16:
 453          maxRetx = 16;
 454          break;
 455       case UL_AM_RLC__maxRetxThreshold_t32:
 456          maxRetx = 32;
 457          break;
 458       default:
 459          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 460          maxRetx = 0;
 461    }
 462    return maxRetx;
 463 }
 464
 465 /*******************************************************************
 466  * @brief Converts enum values into actual value of reassembly timer
 467  *
 468  * @details
 469  *
 470  *    Function : getReAsmblTmr
 471  *
 472  *    Functionality: Converts enum values into actual value of reassembly
 473  *    timer
 474  *
 475  * @params[in] Enum value of reassembly timer
 476  * @return Actual value of reassembly timer
 477  *
 478  * **********************************************************************/
 479
 480 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 481 {
 482    int8_t reAsmblTmr = 0;
 483
 484    if(reAsmblTmrCfg == T_Reassembly_ms0)
 485    {
 486       reAsmblTmr = 0;
 487    }
 488    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 489    {
 490      /* All values of re assembly timer are at interval of 5ms.
 491       * This is valid upto 100ms
 492       * Hence converting the enum value to actual value by multiplying it to 5
 493       */
 494       reAsmblTmr = reAsmblTmrCfg * 5;
 495    }
 496    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 497    {
 498      /* All values of re assembly timer are at interval of 10ms.
 499       * This is valid upto 200ms
 500       * since enum value starts from 20 for 100ms, subtracting 10 and
 501       * converting the enum value to actual value by multiplying it to 10
 502       */
 503       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 504    }
 505    else
 506    {
 507       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 508       reAsmblTmr = -1;
 509    }
 510    return reAsmblTmr;
 511 }
 512
 513 /************************************************************************
 514  *
 515  * @brief Converts enum values into actual value of status prohibit timer
 516  *
 517  * @details
 518  *
 519  *    Function : getStatProhTmr
 520  *
 521  *    Functionality: Converts enum values into actual value of status prohibit
 522  *    timer
 523  *
 524  * @params[in] Enum value of status prohibit timer
 525  * @return Actual value of status prohibit timer
 526  *
 527  * **********************************************************************/
 528
 529 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 530 {
 531    int16_t statProhTmr =0;
 532
 533    if(statProhTmrCfg == T_StatusProhibit_ms0)
 534    {
 535       statProhTmr = 0;
 536    }
 537    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 538    {
 539       /* All values of re assembly timer are at interval of 5ms.
 540        * This is valid upto 250ms
 541        * Hence converting the enum value to actual value by multiplying it to 5
 542        */
 543       statProhTmr = statProhTmrCfg * 5;
 544    }
 545    else
 546    {
 547       switch(statProhTmrCfg)
 548       {
 549          case T_StatusProhibit_ms300:
 550             statProhTmr = 300;
 551             break;
 552          case T_StatusProhibit_ms350:
 553             statProhTmr = 350;
 554             break;
 555          case T_StatusProhibit_ms400:
 556             statProhTmr = 400;
 557             break;
 558          case T_StatusProhibit_ms450:
 559             statProhTmr = 450;
 560             break;
 561          case T_StatusProhibit_ms500:
 562             statProhTmr = 500;
 563             break;
 564          case T_StatusProhibit_ms800:
 565             statProhTmr = 800;
 566             break;
 567          case T_StatusProhibit_ms1000:
 568             statProhTmr = 1000;
 569             break;
 570          case T_StatusProhibit_ms1200:
 571             statProhTmr = 1200;
 572             break;
 573          case T_StatusProhibit_ms1600:
 574             statProhTmr = 1600;
 575             break;
 576          case T_StatusProhibit_ms2000:
 577             statProhTmr = 2000;
 578             break;
 579          case T_StatusProhibit_ms2400:
 580             statProhTmr = 2400;
 581             break;
 582          default:
 583             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 584             statProhTmr = -1;
 585             break;
 586       }
 587    }
 588    return statProhTmr;
 589 }
 590
 591 /*******************************************************************
 592  *
 593  * @brief Builds Uplink Info for NR
 594  *
 595  * @details
 596  *
 597  *    Function : BuildULNRInfo
 598  *
 599  *    Functionality: Building NR Uplink Info
 600  *
 601  * @params[in] NRFreqInfo_t *ulnrfreq
 602  * @return ROK     - success
 603  *         RFAILED - failure
 604  *
 605  * ****************************************************************/
 606 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 607 {
 608    uint8_t idx=0;
 609    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 610                        fdd.ulNrFreqInfo.nrArfcn;
 611    ulnrfreq->freqBandListNr.list.count = 1;
 612    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 613    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 614    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 615    {
 616       return RFAILED;
 617    }
 618    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 619    {
 620       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 621       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 622       {
 623          return RFAILED;
 624       }
 625    }
 626    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 627                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 628                                                                  freqBand[0].nrFreqBand;
 629    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 630    return ROK;
 631 }
 632 /*******************************************************************
 633  *
 634  * @brief Builds Downlink NR Info
 635  *
 636  * @details
 637  *
 638  *    Function : BuildDLNRInfo
 639  *
 640  *    Functionality: Building Downlink NR Info
 641  *
 642  * @params[in] NRFreqInfo_t *dlnrfreq
 643  * @return ROK     - success
 644  *         RFAILED - failure
 645  *
 646  * ****************************************************************/
 647 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 648 {
 649    uint8_t idx=0;
 650    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 651                        fdd.dlNrFreqInfo.nrArfcn;
 652    dlnrfreq->freqBandListNr.list.count = 1;
 653    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 654    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 655    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 656    {
 657       return RFAILED;
 658    }
 659    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 660    {
 661       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 662       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 663       {
 664          return RFAILED;
 665       }
 666    }
 667    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 668                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 669                                                                  freqBand[0].nrFreqBand;
 670    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 671
 672    return ROK;
 673 }
 674
 675 /*******************************************************************
 676  *
 677  * @brief Builds NRCell ID
 678  *
 679  * @details
 680  *
 681  *    Function : BuildNrCellId
 682  *
 683  *    Functionality: Building the NR Cell ID
 684  *
 685  * @params[in] BIT_STRING_t *nrcell
 686  * @return ROK     - success
 687  *         RFAILED - failure
 688  *
 689  * ****************************************************************/
 690
 691 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 692 {
 693    memset(nrcell->buf, 0, nrcell->size);
 694    nrcell->buf[4]   = 16;
 695    nrcell->bits_unused = 4;
 696    return ROK;
 697 }
 698
 699 /*******************************************************************
 700  *
 701  * @brief Builds Nrcgi
 702  *
 703  * @details
 704  *
 705  *    Function : BuildNrcgi
 706  *
 707  *    Functionality: Building the PLMN ID and NR Cell id
 708  *
 709  * @params[in] NRCGI_t *nrcgi
 710  * @return ROK     - success
 711  *         RFAILED - failure
 712  *
 713  * ****************************************************************/
 714 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 715 {
 716    uint8_t ret;
 717    uint8_t byteSize = 5;
 718    /* Allocate Buffer Memory */
 719    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 720    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 721    if(nrcgi->pLMN_Identity.buf == NULLP)
 722    {
 723       return RFAILED;
 724    }
 725    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 726          nrcgi->pLMN_Identity.buf); // Building PLMN function
 727    if(ret != ROK)
 728    {
 729       return RFAILED;
 730    }
 731    /*nrCellIdentity*/
 732    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 733    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 734    if(nrcgi->nRCellIdentity.buf == NULLP)
 735    {
 736       return RFAILED;
 737    }
 738    BuildNrCellId(&nrcgi->nRCellIdentity);
 739
 740    return ROK;
 741 }
 742 /*******************************************************************
 743  *
 744  * @brief Builds FiveGStac
 745  *
 746  * @details
 747  *
 748  *    Function : BuildFiveGSTac
 749  *
 750  *    Functionality: Building the FiveGSTac
 751  *
 752  * @params[in] OCTET_STRING_t *fivegsTac
 753  * @return ROK     - success
 754  *         RFAILED - failure
 755  *
 756  * ****************************************************************/
 757 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 758 {
 759    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 760    if(servcell->fiveGS_TAC == NULLP)
 761    {
 762       return RFAILED;
 763    }
 764    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 765    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 766          sizeof(servcell->fiveGS_TAC->size));
 767    if(servcell->fiveGS_TAC->buf == NULLP)
 768    {
 769       return RFAILED;
 770    }
 771    servcell->fiveGS_TAC->buf[0] = 0;
 772    servcell->fiveGS_TAC->buf[1] = 0;
 773    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 774    return ROK;
 775 }
 776 /*******************************************************************
 777  *
 778  * @brief Builds NR Mode
 779  *
 780  * @details
 781  *
 782  *    Function : BuildNrMode
 783  *
 784  *    Functionality: Building the NR Mode
 785  *
 786  * @params[in] NR_Mode_Info_t *fdd
 787  * @return ROK     - success
 788  *         RFAILED - failure
 789  *
 790  * ****************************************************************/
 791 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 792 {
 793    uint8_t BuildDLNRInforet=0;
 794    uint8_t BuildULNRInforet=0;
 795    /* FDD Mode */
 796    mode->present = NR_Mode_Info_PR_fDD;
 797    if(mode->present == NR_Mode_Info_PR_fDD)
 798    {
 799       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 800       if(mode->choice.fDD == NULLP)
 801       {
 802          return RFAILED;
 803       }
 804       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 805       if(BuildULNRInforet != ROK)
 806       {
 807          return RFAILED;
 808       }
 809       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 810       if(BuildDLNRInforet != ROK)
 811       {
 812          return RFAILED;
 813       }
 814    }
 815    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 816                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 817                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 818    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 819                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 820                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 821    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 822                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 823                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 824    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 825                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 826                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 827    return ROK;
 828 }
 829 /*******************************************************************
 830  *
 831  * @brief Builds IE Extensions for Served PLMNs
 832  *
 833  * @details
 834  *
 835  *    Function : BuildExtensions
 836  *
 837  *    Functionality: Building the IE Extensions
 838  *
 839  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 840  * @return ROK     - success
 841  *         RFAILED - failure
 842  *
 843  * ****************************************************************/
 844 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 845 {
 846    uint8_t idx;
 847    uint8_t plmnidx;
 848    uint8_t extensionCnt=1;
 849    uint8_t sliceId=0;
 850    uint8_t sdId;
 851    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 852    if((*ieExtend) == NULLP)
 853    {
 854       return RFAILED;
 855    }
 856    (*ieExtend)->list.count = extensionCnt;
 857    (*ieExtend)->list.size = \
 858                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 859    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 860    if((*ieExtend)->list.array == NULLP)
 861    {
 862       return RFAILED;
 863    }
 864    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 865    {
 866       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 867             sizeof(ServedPLMNs_ItemExtIEs_t));
 868       if((*ieExtend)->list.array[plmnidx] == NULLP)
 869       {
 870          return RFAILED;
 871       }
 872    }
 873    idx = 0;
 874    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 875    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 876    (*ieExtend)->list.array[idx]->extensionValue.present = \
 877                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 878    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 879       list.count = 1;
 880    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 881       list.size = sizeof(SliceSupportItem_t *);
 882    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 883          list.array,sizeof(SliceSupportItem_t *));
 884    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 885          list.array == NULLP)
 886    {
 887       return RFAILED;
 888    }
 889    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 890          list.array[sliceId],sizeof(SliceSupportItem_t));
 891    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 892          list.array[sliceId] == NULLP)
 893    {
 894       return RFAILED;
 895    }
 896    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 897       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
 898    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 899          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 900          extensionValue.choice.SliceSupportList.\
 901          list.array[sliceId]->sNSSAI.sST.size);
 902    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 903          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
 904    {
 905       return RFAILED;
 906    }
 907    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 908       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
 909    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 910          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 911    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 912          list.array[sliceId]->sNSSAI.sD == NULLP)
 913    {
 914       return RFAILED;
 915    }
 916    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 917       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
 918    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 919          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
 920          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
 921    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 922          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
 923    {
 924       return RFAILED;
 925    }
 926    sdId = 0;
 927    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 928       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
 929    sdId++;
 930    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 931       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
 932    sdId++;
 933    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 934       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
 935    return ROK;
 936 }
 937 /*******************************************************************
 938  *
 939  * @brief Builds Served PLMN
 940  *
 941  * @details
 942  *
 943  *    Function : BuildServedPlmn
 944  *
 945  *    Functionality: Building the Served PLMN
 946  *
 947  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 948  * @return ROK     - success
 949  *         RFAILED - failure
 950  *
 951  * ****************************************************************/
 952 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 953 {
 954    uint8_t  plmnidx;
 955    uint8_t  servPlmnCnt=1;
 956    uint8_t buildPlmnIdret=0;
 957    uint8_t BuildExtensionsret=0;
 958    srvplmn->list.count = servPlmnCnt;
 959    srvplmn->list.size = \
 960                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 961    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 962    if(srvplmn->list.array == NULLP)
 963    {
 964       return RFAILED;
 965    }
 966    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 967    {
 968       DU_ALLOC(srvplmn->list.array[plmnidx],\
 969             sizeof(ServedPLMNs_Item_t));
 970       if(srvplmn->list.array[plmnidx] == NULLP)
 971       {
 972          return RFAILED;
 973       }
 974    }
 975    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 976    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 977    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 978          srvplmn->list.array[0]->pLMN_Identity.buf);
 979    if(buildPlmnIdret!= ROK)
 980    {
 981       return RFAILED;
 982    }
 983    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 984    if(BuildExtensionsret!= ROK)
 985    {
 986       return RFAILED;
 987    }
 988    return ROK;
 989 }
 990 /*******************************************************************
 991  *
 992  * @brief Builds Served Cell List
 993  *
 994  * @details
 995  *
 996  *    Function : BuildServedCellList
 997  *
 998  *    Functionality: Building Served Cell List
 999  *
1000  * @params[in] PLMNID plmn
1001  * @return ROK     - success
1002  *         RFAILED - failure
1003  *
1004  * ****************************************************************/
1005
1006 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1007 {
1008    uint8_t  BuildNrcgiret=0;
1009    uint8_t  BuildFiveGSTacret=0;
1010    uint8_t  BuildServedPlmnret=0;
1011    uint8_t  BuildNrModeret=0;
1012    uint8_t  idx;
1013    uint8_t  plmnidx;
1014    uint8_t  plmnCnt=1;
1015    GNB_DU_Served_Cells_Item_t *srvCellItem;
1016    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1017    duServedCell->list.count = plmnCnt;
1018
1019    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1020    if(duServedCell->list.array == NULLP)
1021    {
1022       return RFAILED;
1023    }
1024    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1025    {
1026       DU_ALLOC(duServedCell->list.array[plmnidx],\
1027             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1028       if(duServedCell->list.array[plmnidx] == NULLP)
1029       {
1030          return RFAILED;
1031       }
1032    }
1033    idx = 0;
1034    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1035    duServedCell->list.array[idx]->criticality = Criticality_reject;
1036    duServedCell->list.array[idx]->value.present = \
1037                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1038    srvCellItem = \
1039                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1040    /*nRCGI*/
1041    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1042    if(BuildNrcgiret != ROK)
1043    {
1044       return RFAILED;
1045    }
1046    /*nRPCI*/
1047    srvCellItem->served_Cell_Information.nRPCI = \
1048                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1049
1050    /*fiveGS_TAC*/
1051    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1052    if(BuildFiveGSTacret != ROK)
1053    {
1054       return RFAILED;
1055    }
1056    /*Served PLMNs*/
1057    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1058    if(BuildServedPlmnret !=ROK)
1059    {
1060       return RFAILED;
1061    }
1062    /*nR Mode Info with FDD*/
1063    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1064    if(BuildNrModeret != ROK)
1065    {
1066       return RFAILED;
1067    }
1068    /*Measurement timing Config*/
1069    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1070       size = sizeof(uint8_t);
1071    DU_ALLOC(srvCellItem->served_Cell_Information.\
1072          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1073    if(srvCellItem->served_Cell_Information.\
1074          measurementTimingConfiguration.buf == NULLP)
1075    {
1076       return RFAILED;
1077    }
1078    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1079                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1080
1081    /* GNB DU System Information */
1082    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1083          sizeof(GNB_DU_System_Information_t));
1084    if(!srvCellItem->gNB_DU_System_Information)
1085    {
1086       return RFAILED;
1087    }
1088    /* MIB */
1089    srvCellItem->gNB_DU_System_Information->mIB_message.size =\
1090                                                              strlen(( char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
1091    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1092          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1093    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1094    {
1095       return RFAILED;
1096    }
1097    strcpy((char *)srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1098          (char *)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg);
1099
1100    /* SIB1 */
1101    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1102                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1103
1104    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1105          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1106    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1107    {
1108       return RFAILED;
1109    }
1110    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1111    {
1112       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1113                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1114    }
1115    return ROK;
1116 }
1117 /*******************************************************************
1118  *
1119  * @brief Builds RRC Version
1120  *
1121  * @details
1122  *
1123  *    Function : BuildRrcVer
1124  *
1125  *    Functionality: Building RRC Version
1126  *
1127  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1128  * @return ROK     - success
1129  *         RFAILED - failure
1130  *
1131  * ****************************************************************/
1132 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1133 {
1134    uint8_t rrcExt;
1135    uint8_t rrcLatest;
1136    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1137    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1138    if(rrcVer->latest_RRC_Version.buf == NULLP)
1139    {
1140       return RFAILED;
1141    }
1142    rrcVer->latest_RRC_Version.buf[0] = 0;
1143    rrcVer->latest_RRC_Version.bits_unused = 5;
1144    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1145    if(rrcVer->iE_Extensions == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    rrcVer->iE_Extensions->list.count = 1;
1150    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1151    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1152    if(rrcVer->iE_Extensions->list.array == NULLP)
1153    {
1154       return RFAILED;
1155    }
1156    rrcExt = 0;
1157    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1158          sizeof(RRC_Version_ExtIEs_t));
1159    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1160    {
1161       return RFAILED;
1162    }
1163    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1164                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1165    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1166    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1167                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1168    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1169       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1170    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1171          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1172          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1173    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1174          .Latest_RRC_Version_Enhanced.buf == NULLP)
1175    {
1176       return RFAILED;
1177    }
1178    rrcLatest = 0;
1179    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1180       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1181    rrcLatest++;
1182    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1183       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1184    rrcLatest++;
1185    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1186       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1187    return ROK;
1188 }
1189 /*******************************************************************
1190  *
1191  * @brief Sends F1 msg over SCTP
1192  *
1193  * @details
1194  *
1195  *    Function : SendF1APMsg
1196  *
1197  *    Functionality: Sends F1 msg over SCTP
1198  *
1199  * @params[in] Region region
1200  *             Pool pool
1201  * @return ROK     - success
1202  *         RFAILED - failure
1203  *
1204  * ****************************************************************/
1205 uint8_t SendF1APMsg(Region region, Pool pool)
1206 {
1207    Buffer *mBuf = NULLP;
1208
1209    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
1210    {
1211       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1212       {
1213             ODU_PRINT_MSG(mBuf, 0,0);
1214
1215             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1216             {
1217                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1218                ODU_PUT_MSG_BUF(mBuf);
1219                return RFAILED;
1220             }
1221       }
1222       else
1223       {
1224          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1225          ODU_PUT_MSG_BUF(mBuf);
1226          return RFAILED;
1227       }
1228       ODU_PUT_MSG_BUF(mBuf);
1229    }
1230    else
1231    {
1232       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1233       return RFAILED;
1234    }
1235    return ROK;
1236 } /* SendF1APMsg */
1237
1238 /*******************************************************************
1239  *
1240  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1241  *
1242  * @details
1243  *
1244  *    Function :  FreeRrcVer
1245  *
1246  *    Functionality: deallocating the memory of function BuildRrcVer
1247  *
1248  * @params[in] RRC_Version_t *rrcVer
1249  *
1250  * @return void
1251  *
1252  *****************************************************************/
1253 void FreeRrcVer(RRC_Version_t *rrcVer)
1254 {
1255    if(rrcVer->latest_RRC_Version.buf != NULLP)
1256    {
1257       if(rrcVer->iE_Extensions != NULLP)
1258       {
1259          if(rrcVer->iE_Extensions->list.array != NULLP)
1260          {
1261             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1262             {
1263                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1264                      != NULLP)
1265                {
1266                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1267                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1268                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1269                }
1270                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1271             }
1272             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1273          }
1274          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1275       }
1276       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1277    }
1278 }
1279 /*******************************************************************
1280  *
1281  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1282  *
1283  * @details
1284  *
1285  *    Function :  FreeServedCellList
1286  *
1287  *    Functionality:  deallocating the memory of function BuildServedCellList
1288
1289  *
1290  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1291  *
1292  * @return void
1293  *
1294  * ****************************************************************/
1295 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1296 {
1297    uint8_t   plmnCnt=1;
1298    uint8_t  servId=0;
1299    uint8_t sliceId=0;
1300    uint8_t  ieId=0;
1301    uint8_t   extensionCnt=1;
1302    uint8_t plmnidx=0;
1303    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1304    if(duServedCell->list.array!=NULLP)
1305    {
1306       if(duServedCell->list.array[0]!=NULLP)
1307       {
1308          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1309          {
1310             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1311             {
1312                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1313                {
1314                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1315                   {
1316                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1317                      {
1318                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1319                         {
1320                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1321                            {
1322                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1323                               {
1324                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1325                                  {
1326                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1327                                     {
1328                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1329                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1330                                        {
1331                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1332                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
1333                                           {
1334                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1335                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
1336                                              {
1337                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1338                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1339                                                 {
1340                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1341                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1342                                                    {
1343                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1344                                                       {
1345                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1346                                                                freqBandListNr.list.array!=NULLP)
1347                                                          {
1348                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1349                                                                   freqBandListNr.list.array[0]!=NULLP)
1350                                                             {
1351                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1352                                                                      freqBandListNr.list.array)
1353                                                                {
1354                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1355                                                                         freqBandListNr.list.array[0]!=NULLP)
1356                                                                   {
1357                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1358                                                                      {
1359                                                                         if(!srvCellItem->gNB_DU_System_Information)
1360                                                                         {
1361                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1362                                                                            {
1363                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1364                                                                               {
1365                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1366                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1367                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1368                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1369                                                                               }
1370                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1371                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1372                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1373                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1374                                                                            }
1375                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1376                                                                         }
1377                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1378                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1379                                                                      }
1380                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1381                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1382                                                                   }
1383                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1384                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1385                                                                }
1386                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1387                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1388                                                             }
1389                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1390                                                                   list.array,sizeof(FreqBandNrItem_t*));
1391                                                          }
1392                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1393                                                       }
1394                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1395                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1396                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1397                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1398                                                    }
1399                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1400                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1401                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1402                                                 }
1403                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1404                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1405                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1406                                              }
1407                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1408                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1409                                           }
1410                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1411                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1412                                        }
1413                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1414                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1415                                     }
1416                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1417                                           array[servId]->iE_Extensions->list.array,\
1418                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1419                                  }
1420                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1421                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1422                               }
1423                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1424                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1425                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1426                                     * sizeof(uint8_t));
1427                            }
1428                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1429                                  sizeof(ServedPLMNs_Item_t *));
1430                         }
1431                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1432                               sizeof(ServedPLMNs_Item_t *));
1433                      }
1434                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1435                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1436                   }
1437                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1438                }
1439                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1440                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1441                      sizeof(uint8_t));
1442             }
1443             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1444                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1445                   sizeof(uint8_t));
1446          }
1447          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1448       }
1449       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1450    }
1451 }
1452 /*******************************************************************
1453  *
1454  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1455  *
1456  * @details
1457  *
1458  *    Function :  FreeF1SetupReq
1459  *
1460  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1461  *
1462  * @params[in] F1AP_PDU_t *f1apMsg
1463  *
1464  * @return void
1465  *
1466  * ****************************************************************/
1467 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1468 {
1469    uint8_t ieIdx, ieIdx2;
1470    F1SetupRequest_t *f1SetupReq=NULLP;
1471
1472    if(f1apMsg != NULLP)
1473    {
1474       if(f1apMsg->choice.initiatingMessage != NULLP)
1475       {
1476          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1477          if(f1SetupReq->protocolIEs.list.array != NULLP)
1478          {
1479             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1480             {
1481                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1482                {
1483                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1484                   {
1485                      case ProtocolIE_ID_id_TransactionID:
1486                         break;
1487                      case ProtocolIE_ID_id_gNB_DU_ID:
1488                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1489                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1490                         break;
1491                      case ProtocolIE_ID_id_gNB_DU_Name:
1492                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1493                               strlen((char *)duCfgParam.duName));
1494                         break;
1495                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1496                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1497                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1498                         break;
1499                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1500                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1501                         break;
1502                      default:
1503                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1504                         break;
1505                   }
1506                }
1507                break;
1508             }
1509             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1510             {
1511                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1512             }
1513             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1514                   f1SetupReq->protocolIEs.list.size);
1515          }
1516          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1517       }
1518       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1519    }
1520 }
1521 /*******************************************************************
1522  *
1523  * @brief Builds and Send the F1SetupRequest
1524  *
1525  * @details
1526  *
1527  *    Function : BuildAndSendF1SetupReq
1528  *
1529  * Functionality:Fills the F1SetupRequest
1530  *
1531  * @return ROK     - success
1532  *         RFAILED - failure
1533  *
1534  ******************************************************************/
1535 uint8_t BuildAndSendF1SetupReq()
1536 {
1537    uint8_t   ret, ieIdx, elementCnt;
1538    F1AP_PDU_t                 *f1apMsg = NULLP;
1539    F1SetupRequest_t           *f1SetupReq=NULLP;
1540    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1541    RRC_Version_t              *rrcVer=NULLP;
1542    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1543    ret= RFAILED;
1544
1545    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1546    do
1547    {
1548       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1549       if(f1apMsg == NULLP)
1550       {
1551          break;
1552       }
1553       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1554       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1555       if(f1apMsg->choice.initiatingMessage == NULLP)
1556       {
1557          break;
1558       }
1559       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1560       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1561       f1apMsg->choice.initiatingMessage->value.present = \
1562                                                          InitiatingMessage__value_PR_F1SetupRequest;
1563
1564       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1565
1566       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1567
1568       f1SetupReq->protocolIEs.list.count = elementCnt;
1569       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1570
1571       /* Initialize the F1Setup members */
1572       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1573       if(f1SetupReq->protocolIEs.list.array == NULLP)
1574       {
1575          break;
1576       }
1577       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1578       {
1579          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1580                sizeof(F1SetupRequestIEs_t));
1581          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1582          {
1583             break;
1584          }
1585       }
1586
1587       ieIdx = 0;
1588       /*TransactionID*/
1589       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1590       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1591       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1592                                                                F1SetupRequestIEs__value_PR_TransactionID;
1593       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1594                                                                              TRANS_ID;
1595
1596       /*DU ID*/
1597       ieIdx++;
1598       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1599       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1600       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1601                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1602       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1603                                                                              sizeof(uint8_t);
1604
1605       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1606             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1607       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1608             NULLP)
1609       {
1610          break;
1611       }
1612
1613       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1614          duCfgParam.duId;
1615
1616       /*DU Name*/
1617       if(duCfgParam.duName != NULL)
1618       {
1619          ieIdx++;
1620          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1621          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1622          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1623          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1624             strlen((char *)duCfgParam.duName);
1625          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1626                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1627          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1628                buf == NULLP)
1629          {
1630             break;
1631          }
1632          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1633                choice.GNB_DU_Name.buf,
1634                (char*)&duCfgParam.duName);
1635
1636       }
1637
1638       /*Served Cell list */
1639       ieIdx++;
1640       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1641                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1642       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1643       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1644                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1645       duServedCell = &f1SetupReq->protocolIEs.list.\
1646                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1647       if(BuildServedCellList(duServedCell))
1648       {
1649          break;
1650       }
1651       /*RRC Version*/
1652       ieIdx++;
1653       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1654                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1655       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1656       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1657                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1658       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1659       if(BuildRrcVer(rrcVer))
1660       {
1661          break;
1662       }
1663       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1664
1665       /* Encode the F1SetupRequest type as APER */
1666       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1667       encBufSize = 0;
1668       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1669             encBuf);
1670
1671       /* Encode results */
1672       if(encRetVal.encoded == ENCODE_FAIL)
1673       {
1674          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1675                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1676          break;
1677       }
1678       else
1679       {
1680          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1681          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1682          {
1683             printf("%x",encBuf[ieIdx]);
1684          }
1685       }
1686
1687       /* Sending msg */
1688       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
1689       {
1690          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1691          break;
1692       }
1693
1694       ret=ROK;
1695       break;
1696    }while(true);
1697
1698    FreeF1SetupReq(f1apMsg);
1699
1700    return ret;
1701 }/* End of BuildAndSendF1SetupReq */
1702
1703 /*******************************************************************
1704  *
1705  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1706  *
1707  * @details
1708  *
1709  *    Function : FreeDUConfigUpdate
1710  *
1711  *    Functionality: Deallocating memory of variables allocated in
1712  *                    BuildAndSendDUConfigUpdate function
1713  *
1714  * @params[in]  F1AP_PDU_t *f1apDuCfg
1715  *
1716  * @return ROK     - void
1717  *
1718  * ****************************************************************/
1719 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1720 {
1721    uint8_t  i;
1722    uint8_t  idx;
1723    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1724    Served_Cells_To_Modify_List_t  *cellsToModify;
1725    Served_Cells_To_Modify_Item_t *modifyItem;
1726    idx=0;
1727    i=1;
1728    if(f1apDuCfg != NULLP)
1729    {
1730       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1731       {
1732          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1733                        value.choice.GNBDUConfigurationUpdate;
1734          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1735          {
1736             if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
1737             {
1738                cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
1739                                value.choice.Served_Cells_To_Modify_List;
1740                if(cellsToModify->list.array != NULLP)
1741                {
1742                   if(cellsToModify->list.array[idx] != NULLP)
1743                   {
1744                      modifyItem=&cellsToModify->list.array[idx]->value.choice.\
1745                                 Served_Cells_To_Modify_Item;
1746                      if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1747                      {
1748                         if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1749                         {
1750                            if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1751                            {
1752                               if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1753                                     != NULLP)
1754                               {
1755                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1756                                        != NULLP)
1757                                  {
1758                                     if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
1759                                     {
1760                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1761                                              array[idx]->pLMN_Identity.buf != NULLP)
1762                                        {
1763                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1764                                                 array[idx]->iE_Extensions!= NULLP)
1765                                           {
1766                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1767                                                    array[idx]->iE_Extensions->list.array != NULLP)
1768                                              {
1769                                                 if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1770                                                       array[idx]->iE_Extensions->list.array[idx])
1771                                                 {
1772                                                    if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1773                                                          iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1774                                                          list.array !=NULLP)
1775                                                    {
1776                                                       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1777                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1778                                                             list.array[idx]!=NULLP)
1779                                                       {
1780                                                          if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1781                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1782                                                                list.array[idx]->sNSSAI.sST.buf!=NULLP)
1783                                                          {
1784                                                             if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1785                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1786                                                                   list.array[idx]->sNSSAI.sD != NULLP)
1787                                                             {
1788                                                                if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1789                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1790                                                                      list.array[idx]->sNSSAI.sD->buf!=NULLP)
1791                                                                {
1792                                                                   if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1793                                                                         !=NULLP)
1794                                                                   {
1795                                                                      if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1796                                                                            fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1797                                                                      {
1798                                                                         if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1799                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
1800                                                                         {
1801                                                                            if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1802                                                                                  fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1803                                                                            {
1804                                                                               if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1805                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1806                                                                                     array[idx]!= NULLP)
1807                                                                               {
1808                                                                                  if(modifyItem->served_Cell_Information.\
1809                                                                                        measurementTimingConfiguration.buf !=NULLP)
1810                                                                                  {
1811                                                                                     idx=2;
1812                                                                                     if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
1813                                                                                           choice.GNB_DU_ID.buf!=NULLP)
1814                                                                                     {
1815                                                                                        DU_FREE(duCfgUpdate->protocolIEs.list.\
1816                                                                                              array[idx]->value.choice.GNB_DU_ID.buf,\
1817                                                                                              duCfgUpdate->protocolIEs.list.array[idx]->\
1818                                                                                              value.choice.GNB_DU_ID.size);
1819                                                                                     }
1820                                                                                     idx=0;
1821                                                                                     DU_FREE(modifyItem->served_Cell_Information.\
1822                                                                                           measurementTimingConfiguration.\
1823                                                                                           buf,modifyItem->served_Cell_Information.\
1824                                                                                           measurementTimingConfiguration.size);
1825                                                                                  }
1826                                                                                  DU_FREE(modifyItem->served_Cell_Information.\
1827                                                                                        nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
1828                                                                                        list.array[idx],sizeof(FreqBandNrItem_t));
1829                                                                               }
1830                                                                               DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1831                                                                                     .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1832                                                                                     modifyItem->served_Cell_Information.nR_Mode_Info.\
1833                                                                                     choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1834                                                                            }
1835                                                                            DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1836                                                                                  choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1837                                                                                  array[idx],sizeof(FreqBandNrItem_t));
1838                                                                         }
1839                                                                         DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1840                                                                               choice.\
1841                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.\
1842                                                                               array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1843                                                                               fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1844                                                                      }
1845                                                                      DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1846                                                                            fDD,sizeof(FDD_Info_t));
1847                                                                   }
1848                                                                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1849                                                                         array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1850                                                                         SliceSupportList.\
1851                                                                         list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
1852                                                                         servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
1853                                                                         extensionValue.choice.SliceSupportList.list.array[idx]->\
1854                                                                         sNSSAI.sD->size);
1855
1856                                                                }
1857                                                                DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1858                                                                      array[idx]->\
1859                                                                      iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1860                                                                      list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1861                                                             }
1862                                                             DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1863                                                                   iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1864                                                                   list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1865                                                                   servedPLMNs.\
1866                                                                   list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
1867                                                                   SliceSupportList.list.array[idx]->sNSSAI.sST.size);
1868                                                          }
1869                                                          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1870                                                                iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1871                                                                list.array[idx],sizeof(SliceSupportItem_t));
1872                                                       }
1873                                                       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1874                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
1875                                                             list.array,\
1876                                                             modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
1877                                                             iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
1878                                                    }
1879                                                 }
1880                                                 for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1881                                                       array[idx]->iE_Extensions->list.count;i++)
1882                                                 {
1883                                                    DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1884                                                          array[idx]->iE_Extensions->list.array[i],\
1885                                                          sizeof(ServedPLMNs_ItemExtIEs_t ));
1886                                                 }
1887                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1888                                                       array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
1889                                                       list.array[idx]->iE_Extensions->list.size);
1890                                              }
1891                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1892                                                    array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1893                                           }
1894                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1895                                                 array[idx]->pLMN_Identity.buf,
1896                                                 modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
1897                                        }
1898                                     }
1899                                     for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1900                                     {
1901                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1902                                              != NULLP)
1903                                        {
1904                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1905                                                 sizeof(ServedPLMNs_Item_t));
1906                                        }
1907                                     }
1908                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1909                                           modifyItem->served_Cell_Information.servedPLMNs.list.size);
1910                                  }
1911                                  DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1912                                        modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1913                               }
1914                               DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1915                                     modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1916                            }
1917                            DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
1918                                  modifyItem->oldNRCGI.nRCellIdentity.size);
1919                         }
1920                         DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
1921                               modifyItem->oldNRCGI.pLMN_Identity.size);
1922                      }
1923                   }
1924                   for(i=0; i<cellsToModify->list.count ;i++)
1925                   {
1926                      if(cellsToModify->list.array[i] != NULLP)
1927                      {
1928                         DU_FREE(cellsToModify->list.array[i],\
1929                               sizeof(Served_Cells_To_Modify_ItemIEs_t));
1930                      }
1931                   }
1932                   DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1933                }
1934             }
1935             for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
1936             {
1937                if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
1938                {
1939                   DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
1940                         sizeof(GNBDUConfigurationUpdateIEs_t));
1941                }
1942             }
1943             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1944          }
1945          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1946       }
1947       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1948    }
1949 }
1950
1951 /*******************************************************************
1952  *
1953  * @brief Fills Served Plmns required in ServCellInfo IE
1954  *
1955  * @details
1956  *
1957  *    Function : fillServedPlmns
1958  *
1959  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1960  *
1961  * @params[in] Pointer to ServedPLMNs_List_t *
1962  *
1963  * @return ROK     - success
1964  *         RFAILED - failure
1965  *
1966  *****************************************************************/
1967
1968 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1969 {
1970    uint8_t ieIdx, ieListCnt;
1971
1972    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
1973    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
1974          array[0]->pLMN_Identity.size);
1975    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
1976    {
1977       return RFAILED;
1978    }
1979    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
1980          servedPlmn->list.array[0]->pLMN_Identity.buf);
1981    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1982    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
1983    {
1984       return RFAILED;
1985    }
1986
1987    ieListCnt=1;
1988    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
1989    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1990    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
1991          iE_Extensions->list.size);
1992    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
1993    {
1994       return RFAILED;
1995    }
1996    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
1997    {
1998       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
1999             sizeof(ServedPLMNs_ItemExtIEs_t));
2000       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2001       {
2002          return RFAILED;
2003       }
2004    }
2005    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2006    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2007    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2008    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2009       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2010    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2011       list.count = 1;
2012    servedPlmn->list.array[0]->\
2013       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2014       list.size = sizeof(SliceSupportItem_t *);
2015    DU_ALLOC(servedPlmn->list.array[0]->\
2016          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2017          list.array,servedPlmn->list.array[0]->\
2018          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2019    if(servedPlmn->list.array[0]->\
2020          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2021          list.array == NULLP)
2022    {
2023       return RFAILED;
2024    }
2025
2026    DU_ALLOC(servedPlmn->list.array[0]->\
2027          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2028          list.array[0],sizeof( SliceSupportItem_t));
2029    if(servedPlmn->list.array[0]->\
2030          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2031          list.array[0] == NULLP)
2032    {
2033       return RFAILED;
2034    }
2035    servedPlmn->list.array[0]->\
2036       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2037       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2038    DU_ALLOC(servedPlmn->list.array[0]->\
2039          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2040          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2041          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2042    if(servedPlmn->list.array[0]->\
2043          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2044          list.array[0]->sNSSAI.sST.buf == NULLP)
2045    {
2046       return RFAILED;
2047    }
2048    servedPlmn->list.array[0]->\
2049       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2050       list.array[0]->sNSSAI.sST.buf[0] = 3;
2051    DU_ALLOC(servedPlmn->list.array[0]->\
2052          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2053          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2054    if(servedPlmn->list.array[0]->\
2055          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2056          list.array[0]->sNSSAI.sD == NULLP)
2057    {
2058       return RFAILED;
2059    }
2060    servedPlmn->list.array[0]->\
2061       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2062       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2063    DU_ALLOC(servedPlmn->list.array[0]->\
2064          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2065          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2066          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2067          list.array[0]->sNSSAI.sD->size);
2068    if(servedPlmn->list.array[0]->\
2069          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2070          list.array[0]->sNSSAI.sD->buf == NULLP)
2071    {
2072       return RFAILED;
2073    }
2074    servedPlmn->list.array[0]->\
2075       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2076       list.array[0]->sNSSAI.sD->buf[0] = 3;
2077    servedPlmn->list.array[0]->\
2078       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2079       list.array[0]->sNSSAI.sD->buf[1] = 6;
2080    servedPlmn->list.array[0]->\
2081       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2082       list.array[0]->sNSSAI.sD->buf[2] = 9;
2083    return ROK;
2084 }
2085
2086 /*******************************************************************
2087  *
2088  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2089  *
2090  * @details
2091  *
2092  *    Function : fillNrFddInfo
2093  *
2094  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2095  *
2096  * @params[in] Pointer to NR_Mode_Info_t *
2097  *
2098  * @return ROK     - success
2099  *         RFAILED - failure
2100  *
2101  *****************************************************************/
2102
2103 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2104 {
2105    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2106       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2107    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2108    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2109    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2110          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2111    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2112    {
2113       return RFAILED;
2114    }
2115    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2116       sizeof(FreqBandNrItem_t));
2117    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2118    {
2119       return RFAILED;
2120    }
2121    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2122       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2123       freqBand[0].nrFreqBand;
2124    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2125    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2126       dlNrFreqInfo.nrArfcn;
2127    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2128    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2129    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2130          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2131    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2132    {
2133       return RFAILED;
2134    }
2135    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2136          sizeof(FreqBandNrItem_t));
2137    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2138    {
2139       return RFAILED;
2140    }
2141    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2142       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2143       freqBand[0].nrFreqBand;
2144    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2145
2146    /*Transmission Bandwidth*/
2147    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2148       f1Mode.mode.fdd.ulTxBw.nrScs;
2149    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2150       f1Mode.mode.fdd.ulTxBw.nrb;
2151    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2152       f1Mode.mode.fdd.dlTxBw.nrScs;
2153    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2154       f1Mode.mode.fdd.dlTxBw.nrb;
2155
2156    return ROK;
2157 }
2158
2159 /*******************************************************************
2160  *
2161  * @brief Fills ServCellInfo IE
2162  *
2163  * @details
2164  *
2165  *    Function : fillServedCellInfo
2166  *
2167  *    Functionality: Fills ServCellInfo
2168  *
2169  * @params[in] Pointer to Served_Cell_Information_t *
2170  *
2171  * @return ROK     - success
2172  *         RFAILED - failure
2173  *
2174  *****************************************************************/
2175
2176 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2177 {
2178    uint8_t tmp, ieIdx, ieListCnt;
2179
2180    /*nRCGI*/
2181    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2182    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2183          srvCellInfo->nRCGI.pLMN_Identity.size);
2184    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2185    {
2186       return RFAILED;
2187    }
2188    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2189          srvCellInfo->nRCGI.pLMN_Identity.buf);
2190    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2191    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2192          srvCellInfo->nRCGI.nRCellIdentity.size);
2193    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2194    {
2195       return RFAILED;
2196    }
2197    for (tmp = 0 ; tmp < srvCellInfo->\
2198          nRCGI.nRCellIdentity.size-1 ; tmp++)
2199    {
2200       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2201    }
2202    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2203    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2204
2205    /*nRPCI*/
2206    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2207
2208    /*servedPLMNs*/
2209    ieListCnt = 1;
2210    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2211    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2212    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2213          srvCellInfo->servedPLMNs.list.size);
2214    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2215    {
2216       return RFAILED;
2217    }
2218    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2219    {
2220       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2221             sizeof(ServedPLMNs_Item_t));
2222       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2223       {
2224          return RFAILED;
2225       }
2226    }
2227    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2228    {
2229       return RFAILED;
2230    }
2231
2232    /*nR Mode Info with FDD*/
2233    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2234    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2235          sizeof(FDD_Info_t));
2236    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2237    {
2238       return RFAILED;
2239    }
2240    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2241       return RFAILED;
2242
2243    /*Measurement timing Config*/
2244    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2245    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2246          buf,srvCellInfo->measurementTimingConfiguration.size);
2247    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2248    {
2249       return RFAILED;
2250    }
2251    srvCellInfo->measurementTimingConfiguration.\
2252          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2253
2254    return ROK;
2255 }
2256
2257 /*******************************************************************
2258  *
2259  * @brief Fills ServCellToModItem IE
2260  *
2261  * @details
2262  *
2263  *    Function : fillServCellToModItem
2264  *
2265  *    Functionality: Fills ServCellToModItem IE
2266  *
2267  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2268  *
2269  * @return ROK     - success
2270  *         RFAILED - failure
2271  *
2272  *****************************************************************/
2273
2274 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2275 {
2276    uint8_t ieIdx;
2277
2278    /*pLMN_Identity*/
2279    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2280    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2281    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2282    {
2283       return RFAILED;
2284    }
2285    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2286          modifyItem->oldNRCGI.pLMN_Identity.buf);
2287
2288    /*nRCellIdentity*/
2289    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2290    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2291          modifyItem->oldNRCGI.nRCellIdentity.size);
2292    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2293    {
2294       return RFAILED;
2295    }
2296    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2297    {
2298       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2299    }
2300    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2301    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2302
2303    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2304       return RFAILED;
2305    else
2306       return ROK;
2307 }
2308
2309 /*******************************************************************
2310  *
2311  * @brief Builds ServCellToModList
2312  *
2313  * @details
2314  *
2315  *    Function : buildServCellToModList
2316  *
2317  *    Functionality: Builds the serv cell to Mod List
2318  *
2319  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2320  *
2321  * @return ROK     - success
2322  *         RFAILED - failure
2323  *
2324  *****************************************************************/
2325
2326 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2327 {
2328    uint8_t ieListCnt, ieIdx;
2329    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2330
2331    ieListCnt = 1;
2332    cellsToModify->list.count = ieListCnt;
2333    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2334    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2335    if(cellsToModify->list.array == NULLP)
2336    {
2337       return RFAILED;
2338    }
2339    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2340    {
2341       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2342       if(cellsToModify->list.array[ieIdx] == NULLP)
2343       {
2344          return RFAILED;
2345       }
2346    }
2347    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2348    cellsToModify->list.array[0]->criticality = Criticality_reject;
2349    cellsToModify->list.array[0]->value.present =\
2350       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2351    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2352
2353    if(fillServCellToModItem(modifyItem))
2354       return RFAILED;
2355    else
2356       return ROK;
2357 }
2358
2359 /*******************************************************************
2360  *
2361  * @brief Builds and sends the DUConfigUpdate
2362  *
2363  * @details
2364  *
2365  *    Function : BuildAndSendDUConfigUpdate
2366  *
2367  *    Functionality: Constructs the DU Update message and sends
2368  *                   it to the CU through SCTP.
2369  *
2370  * @params[in] void **buf,Buffer to which encoded pattern is written into
2371  * @params[in] int *size,size of buffer
2372  *
2373  * @return ROK     - success
2374  *         RFAILED - failure
2375  *
2376  * ****************************************************************/
2377 uint8_t BuildAndSendDUConfigUpdate()
2378 {
2379    uint8_t ret, ieIdx, elementCnt;
2380    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2381    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2382    asn_enc_rval_t encRetVal;     /* Encoder return value */
2383    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2384    ret= RFAILED;
2385
2386    while(true)
2387    {
2388       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2389       /* Allocate the memory for F1DuCfg */
2390       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2391       if(f1apDuCfg == NULLP)
2392       {
2393          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2394          break;
2395       }
2396
2397       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2398       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2399       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2400       {
2401          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2402          break;
2403       }
2404
2405       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2406                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2407       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2408       f1apDuCfg->choice.initiatingMessage->value.present = \
2409                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2410       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2411                     choice.GNBDUConfigurationUpdate;
2412       elementCnt = 3;
2413       duCfgUpdate->protocolIEs.list.count = elementCnt;
2414       duCfgUpdate->protocolIEs.list.size = \
2415                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2416
2417       /* Initialize the F1Setup members */
2418       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2419       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2420       {
2421          DU_LOG("ERROR  -->  F1AP : Memory allocation for F1RequestIEs failed");
2422          break;
2423       }
2424       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2425       {
2426          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2427          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2428          {
2429             break;
2430          }
2431       }
2432
2433       /*TransactionID*/
2434       ieIdx = 0;
2435       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2436       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2437       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2438          GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2439       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2440
2441       /*Served Cell to Modify */
2442       ieIdx++;
2443       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2444                                                       ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2445       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2446       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2447          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2448       if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2449          Served_Cells_To_Modify_List))
2450          break;
2451
2452       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2453       /*GNB DU ID */
2454       ieIdx++;
2455       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2456       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2457       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2458         GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2459       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2460       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2461             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2462       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2463       {
2464          break;
2465       }
2466       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2467
2468       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2469
2470       /* Encode the DU Config Update type as APER */
2471       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2472       encBufSize = 0;
2473       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2474
2475       /* Checking encode results */
2476       if(encRetVal.encoded == ENCODE_FAIL)
2477       {
2478          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2479          encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2480          break;
2481       }
2482       else
2483       {
2484          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2485          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2486          {
2487             printf("%x",encBuf[ieIdx]);
2488          }
2489       }
2490       /* Sending msg */
2491       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
2492       {
2493          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2494          break;
2495       }
2496
2497       ret = ROK;
2498       break;
2499    }
2500    FreeDUConfigUpdate(f1apDuCfg);
2501
2502    return ret;
2503 }
2504
2505
2506 /*******************************************************************
2507  *
2508  * @brief free the ULRRCMessageTransfer
2509  *
2510  * @details
2511  *
2512  *    Function : FreeULRRCMessageTransfer
2513  *
2514  *    Functionality: Deallocating the memory of variable allocated in
2515  *                      FreeULRRCMessageTransfer
2516  *
2517  * @params[in]
2518  *
2519  * @return ROK     - void
2520  *
2521  ******************************************************************/
2522 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2523 {
2524    uint8_t idx1;
2525    ULRRCMessageTransfer_t  *ulRRCMsg;
2526
2527    if(f1apMsg != NULLP)
2528    {
2529       if(f1apMsg->choice.initiatingMessage != NULLP)
2530       {
2531          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2532          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2533          {
2534             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2535             {
2536                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2537                {
2538                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2539                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2540                   {
2541                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2542                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2543                   }
2544                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2545                }
2546             }
2547             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2548          }
2549          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2550       }
2551       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2552    }
2553 }
2554 /*******************************************************************
2555  *
2556  * @brief Builds and sends the ULRRCMessageTransfer
2557  *
2558  * @details
2559  *
2560  *    Function : BuildAndSendULRRCMessageTransfer
2561  *
2562  *    Functionality: Constructs the UL RRC Message Transfer and sends
2563  *                   it to the CU through SCTP.
2564  *
2565  * @params[in]
2566  *
2567  * @return ROK     - success
2568  *         RFAILED - failure
2569  *
2570  * ****************************************************************/
2571 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2572       uint16_t msgLen, uint8_t *rrcMsg)
2573 {
2574    uint8_t   elementCnt =0;
2575    uint8_t   idx1 =0;
2576    uint8_t   idx =0;
2577    F1AP_PDU_t                   *f1apMsg = NULLP;
2578    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2579    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2580    uint8_t ret =RFAILED;
2581
2582    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2583
2584    while(true)
2585    {
2586       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2587
2588       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2589       if(f1apMsg == NULLP)
2590       {
2591          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2592          break;
2593       }
2594       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2595       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2596       if(f1apMsg->choice.initiatingMessage == NULLP)
2597       {
2598          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2599          break;
2600       }
2601       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2602       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2603       f1apMsg->choice.initiatingMessage->value.present = \
2604                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2605       ulRRCMsg =
2606          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2607       elementCnt = 4;
2608       ulRRCMsg->protocolIEs.list.count = elementCnt;
2609       ulRRCMsg->protocolIEs.list.size = \
2610                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2611
2612       /* Initialize the F1Setup members */
2613       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2614       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2615       {
2616          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2617          break;
2618       }
2619       for(idx=0; idx<elementCnt; idx++)
2620       {
2621          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2622          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2623          {
2624             break;
2625          }
2626       }
2627
2628       idx1 = 0;
2629
2630       /*GNB CU UE F1AP ID*/
2631       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2632       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2633       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2634                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2635       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2636
2637       /*GNB DU UE F1AP ID*/
2638       idx1++;
2639       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2640       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2641       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2642                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2643       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2644
2645       /*SRBID*/
2646       idx1++;
2647       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2648       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2649       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2650                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2651       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2652
2653       /*RRCContainer*/
2654       idx1++;
2655       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2656       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2657       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2658                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2659       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2660       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2661             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2662       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2663       {
2664          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2665          break;
2666       }
2667       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2668       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2669             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2670
2671       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2672
2673       /* Encode the F1SetupRequest type as APER */
2674       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2675       encBufSize = 0;
2676       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2677             encBuf);
2678       /* Encode results */
2679       if(encRetVal.encoded == ENCODE_FAIL)
2680       {
2681          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2682                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2683          break;
2684       }
2685       else
2686       {
2687          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2688          for(int i=0; i< encBufSize; i++)
2689          {
2690             printf("%x",encBuf[i]);
2691          }
2692       }
2693
2694       /* Sending  msg  */
2695       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) !=      ROK)
2696       {
2697          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2698          break;
2699       }
2700       ret = ROK;
2701       break;
2702    }
2703    FreeULRRCMessageTransfer(f1apMsg);
2704
2705    return ret;
2706 }/* End of BuildAndSendULRRCMessageTransfer*/
2707
2708 /*******************************************************************
2709  *
2710  * @brief Builds tag config
2711  *
2712  * @details
2713  *
2714  *    Function : BuildTagConfig
2715  *
2716  *    Functionality: Builds tag config in MacCellGroupConfig
2717  *
2718  * @params[in] TAG_Config *tag_Config
2719  *
2720  * @return ROK     - success
2721  *         RFAILED - failure
2722  *
2723  * ****************************************************************/
2724 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2725 {
2726    struct TAG_Config__tag_ToAddModList *tagList;
2727    uint8_t                     idx, elementCnt;
2728
2729    tagConfig->tag_ToReleaseList = NULLP;
2730    tagConfig->tag_ToAddModList = NULLP;
2731    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2732    if(!tagConfig->tag_ToAddModList)
2733    {
2734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2735       return RFAILED;
2736    }
2737
2738    elementCnt = 1; //ODU_VALUE_ONE;
2739    tagList = tagConfig->tag_ToAddModList;
2740    tagList->list.count = elementCnt;
2741    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2742
2743    tagList->list.array = NULLP;
2744    DU_ALLOC(tagList->list.array, tagList->list.size);
2745    if(!tagList->list.array)
2746    {
2747       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2748       return RFAILED;
2749    }
2750
2751    for(idx=0; idx<tagList->list.count; idx++)
2752    {
2753       tagList->list.array[idx] = NULLP;
2754       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2755       if(!tagList->list.array[idx])
2756       {
2757          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2758          return RFAILED;
2759       }
2760    }
2761
2762    idx = 0;
2763    tagList->list.array[idx]->tag_Id = TAG_ID;
2764    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2765
2766    return ROK;
2767 }
2768
2769 /*******************************************************************
2770  *
2771  * @brief Builds PHR Config
2772  *
2773  * @details
2774  *
2775  *    Function : BuildPhrConfig
2776  *
2777  *    Functionality: Builds phrConfig in MacCellGroupConfig
2778  *
2779  * @params[in] PHR Config *
2780  *
2781  * @return ROK     - success
2782  *         RFAILED - failure
2783  *
2784  * ****************************************************************/
2785 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2786 {
2787
2788    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2789    phrConfig->choice.setup = NULLP;
2790    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2791    if(!phrConfig->choice.setup)
2792    {
2793       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2794       return RFAILED;
2795    }
2796
2797    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2798    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2799    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2800    phrConfig->choice.setup->multiplePHR              = false;
2801    phrConfig->choice.setup->dummy                    = false;
2802    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2803    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2804
2805    return ROK;
2806 }
2807
2808 /*******************************************************************
2809  *
2810  * @brief Builds BSR Config
2811  *
2812  * @details
2813  *
2814  *    Function : BuildBsrConfig
2815  *
2816  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2817  *
2818  * @params[in] BSR_Config *bsrConfig
2819  *
2820  * @return ROK     - success
2821  *         RFAILED - failure
2822  *
2823  * ****************************************************************/
2824 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2825 {
2826    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2827    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2828    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2829
2830    return ROK;
2831 }
2832
2833 /*******************************************************************
2834  *
2835  * @brief Builds scheduling request config
2836  *
2837  * @details
2838  *
2839  *    Function : BuildSchedulingReqConfig
2840  *
2841  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2842  *
2843  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2844  *
2845  * @return ROK     - success
2846  *         RFAILED - failure
2847  *
2848  * ****************************************************************/
2849 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
2850 {
2851    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2852    uint8_t                     idx, elementCnt;
2853
2854    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2855    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2856          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2857    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2858    {
2859       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2860       return RFAILED;
2861    }
2862
2863    elementCnt = 1; //ODU_VALUE_ONE;
2864    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2865    schReqList->list.count = elementCnt;
2866    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2867
2868    schReqList->list.array = NULLP;
2869    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2870    if(!schReqList->list.array)
2871    {
2872       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2873       return RFAILED;
2874    }
2875
2876    for(idx=0;idx<schReqList->list.count; idx++)
2877    {
2878       schReqList->list.array[idx] = NULLP;
2879       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2880       if(!schReqList->list.array[idx])
2881       {
2882          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2883          return RFAILED;
2884       }
2885    }
2886
2887    idx = 0;
2888    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2889
2890    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2891    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2892    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2893    {
2894       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2895       return RFAILED;
2896    }
2897    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2898    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2899    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2900
2901    return ROK;
2902 }
2903
2904 /*******************************************************************
2905  *
2906  * @brief Builds RLC Config
2907  *
2908  * @details
2909  *
2910  *    Function : BuildRlcConfig
2911  *
2912  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
2913  *
2914  * @params[in] RLC_Config *rlcConfig
2915  *
2916  * @return ROK     - success
2917  *         RFAILED - failure
2918  *
2919  * ****************************************************************/
2920 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
2921 {
2922
2923    rlcConfig->present = RLC_Config_PR_am;
2924
2925    rlcConfig->choice.am = NULLP;
2926    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
2927    if(!rlcConfig->choice.am)
2928    {
2929       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2930       return RFAILED;
2931    }
2932
2933    /* UL */
2934    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
2935    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2936    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
2937    {
2938       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2939       return RFAILED;
2940    }
2941    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2942    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
2943    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
2944    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
2945    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
2946
2947    /* DL */
2948    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
2949    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
2950    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
2951    {
2952       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
2953       return RFAILED;
2954    }
2955    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
2956    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
2957    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
2958
2959    return ROK;
2960 }
2961
2962 /*******************************************************************
2963  *
2964  * @brief Builds MAC LC Config
2965  *
2966  * @details
2967  *
2968  *    Function : BuildMacLCConfig
2969  *
2970  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
2971  *
2972  * @params[in] struct LogicalChannelConfig macLcConfig
2973  *
2974  * @return ROK     - success
2975  *         RFAILED - failure
2976  *
2977  * ****************************************************************/
2978 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
2979 {
2980
2981    macLcConfig->ul_SpecificParameters = NULLP;
2982    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
2983    if(!macLcConfig->ul_SpecificParameters)
2984    {
2985       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
2986       return RFAILED;
2987    }
2988
2989    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
2990    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
2991    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
2992    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
2993    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
2994    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
2995    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
2996
2997    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
2998    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
2999    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3000    {
3001       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3002       return RFAILED;
3003    }
3004    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3005
3006    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3007    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3008    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3009    {
3010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3011       return RFAILED;
3012    }
3013    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3014
3015    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3016    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3017    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3018
3019    return ROK;
3020 }
3021
3022 /*******************************************************************
3023  *
3024  * @brief Builds RLC Bearer to Add/Mod list
3025  *
3026  * @details
3027  *
3028  *    Function :BuildRlcBearerToAddModList
3029  *
3030  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3031  *
3032  * @params[in] rlc_BearerToAddModList
3033  *
3034  * @return ROK     - success
3035  *         RFAILED - failure
3036  *
3037  * ****************************************************************/
3038 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3039 {
3040    uint8_t                     idx, elementCnt;
3041
3042    elementCnt = 1;
3043    rlcBearerList->list.count = elementCnt;
3044    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3045
3046    rlcBearerList->list.array = NULLP;
3047    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3048    if(!rlcBearerList->list.array)
3049    {
3050       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3051       return RFAILED;
3052    }
3053
3054    for(idx=0; idx<rlcBearerList->list.count; idx++)
3055    {
3056       rlcBearerList->list.array[idx] = NULLP;
3057       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3058       if(!rlcBearerList->list.array[idx])
3059       {
3060          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3061          return RFAILED;
3062       }
3063    }
3064
3065    idx = 0;
3066    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3067
3068    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3069       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3070    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3071    {
3072       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3073       return RFAILED;
3074    }
3075
3076    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3077       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3078    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3079       SRB1_LCID;
3080
3081    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3082    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3083    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3084    if(!rlcBearerList->list.array[idx]->rlc_Config)
3085    {
3086       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3087       return RFAILED;
3088    }
3089
3090    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3091    {
3092       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3093       return RFAILED;
3094    }
3095
3096    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3097    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3098       sizeof(struct LogicalChannelConfig));
3099    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3100    {
3101       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3102       return RFAILED;
3103    }
3104
3105    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3106    {
3107       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3108       return RFAILED;
3109    }
3110
3111    return ROK;
3112 }
3113
3114 /*******************************************************************
3115  *
3116  * @brief Build Control resource set to add/modify list
3117  *
3118  * @details
3119  *
3120  *    Function : BuildControlRSetToAddModList
3121  *
3122  *    Functionality: Build Control resource set to add/modify list
3123  *
3124  * @params[in]
3125  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3126  *
3127  * @return ROK     - success
3128  *         RFAILED - failure
3129  *
3130  * ****************************************************************/
3131    uint8_t BuildControlRSetToAddModList
3132 (
3133  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3134  )
3135 {
3136    uint8_t idx;
3137    uint8_t elementCnt;
3138    uint8_t numBytes, bitsUnused;
3139    struct ControlResourceSet *controlRSet;
3140    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3141    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3142
3143
3144    elementCnt = 1;
3145    controlRSetList->list.count = elementCnt;
3146    controlRSetList->list.size = \
3147                                 elementCnt * sizeof(struct ControlResourceSet *);
3148
3149    controlRSetList->list.array = NULLP;
3150    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3151    if(!controlRSetList->list.array)
3152    {
3153       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3154       return RFAILED;
3155    }
3156
3157    for(idx = 0; idx < elementCnt; idx++)
3158    {
3159       controlRSetList->list.array[idx] = NULLP;
3160       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3161       if(!controlRSetList->list.array[idx])
3162       {
3163          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3164          return RFAILED;
3165       }
3166    }
3167
3168    idx=0;
3169    controlRSet = controlRSetList->list.array[idx];
3170
3171    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3172
3173    /* size 6 bytes
3174     * 3 LSBs unsued
3175     * Bit string stored ff0000000000
3176     */
3177    numBytes = 6;
3178    bitsUnused = 3;
3179    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3180
3181    controlRSet->frequencyDomainResources.buf = NULLP;
3182    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3183          controlRSet->frequencyDomainResources.size);
3184    if(!controlRSet->frequencyDomainResources.buf)
3185    {
3186       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3187       return RFAILED;
3188    }
3189
3190    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3191    coreset0EndPrb = CORESET0_END_PRB;
3192    coreset1StartPrb = coreset0EndPrb + 6;
3193    coreset1NumPrb = CORESET1_NUM_PRB;
3194    /* calculate the PRBs */
3195    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3196    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3197    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3198
3199    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3200    controlRSet->cce_REG_MappingType.present = \
3201                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3202
3203    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3204    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3205    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3206    controlRSet->tci_PresentInDCI = NULLP;
3207 #if 0
3208    uint8_t tciStateIdx;
3209
3210    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3211          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3212    if(!controlRset->tci_StatesPDCCH_ToAddList)
3213    {
3214       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3215       return RFAILED;
3216    }
3217
3218    elementCnt = 1;
3219    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3220    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3221    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3222          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3223       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3224       {
3225          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3226          return RFAILED;
3227       }
3228
3229    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3230    {
3231       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3232       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3233       {
3234          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3235          return RFAILED;
3236       }
3237    }
3238
3239    tciStateIdx = 0;
3240    /* TODO */
3241    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3242
3243    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3244    if(!controlRset->tci_PresentInDCI)
3245    {
3246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3247       return RFAILED;
3248    }
3249    /* TODO */
3250    *(controlRset->tci_PresentInDCI);
3251 #endif
3252
3253    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3254    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3255    if(!controlRSet->pdcch_DMRS_ScramblingID)
3256    {
3257       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3258       return RFAILED;
3259    }
3260    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3261
3262    return ROK;
3263 } /* End BuildControlRSetToAddModList */
3264
3265 /*******************************************************************
3266  *
3267  * @brief Build search space to add/modify list
3268  *
3269  * @details
3270  *
3271  *    Function : BuildSearchSpcToAddModList
3272  *
3273  *    Functionality: Build search space to add/modify list
3274  *
3275  * @params[in]
3276  * @return ROK     - success
3277  *         RFAILED - failure
3278  *
3279  * ****************************************************************/
3280    uint8_t BuildSearchSpcToAddModList
3281 (
3282  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3283  )
3284 {
3285    uint8_t idx;
3286    uint8_t numBytes;
3287    uint8_t byteIdx;
3288    uint8_t bitsUnused;
3289    uint8_t elementCnt;
3290    struct SearchSpace *searchSpc;
3291
3292    elementCnt = 1;
3293    searchSpcList->list.count = elementCnt;
3294    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3295
3296    searchSpcList->list.array = NULLP;
3297    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3298    if(!searchSpcList->list.array)
3299    {
3300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3301       return RFAILED;
3302    }
3303
3304    for(idx = 0; idx < elementCnt; idx++)
3305    {
3306       searchSpcList->list.array[idx] = NULLP;
3307       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3308       if(!searchSpcList->list.array[idx])
3309       {
3310          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3311          return RFAILED;
3312       }
3313    }
3314
3315    idx = 0;
3316    searchSpc = searchSpcList->list.array[idx];
3317
3318    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3319
3320    searchSpc->controlResourceSetId = NULLP;
3321    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3322    if(!searchSpc->controlResourceSetId)
3323    {
3324       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3325       return RFAILED;
3326    }
3327    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3328
3329    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3330    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3331          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3332    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3333    {
3334       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3335       return RFAILED;
3336    }
3337    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3338                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3339
3340    searchSpc->duration = NULLP;
3341    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3342    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3343    if(!searchSpc->monitoringSymbolsWithinSlot)
3344    {
3345       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3346       return RFAILED;
3347    }
3348
3349    /* Values taken from reference logs :
3350     * size 2 bytes
3351     * 2 LSBs unsued
3352     * Bit string stores 8000
3353     */
3354    numBytes = 2;
3355    bitsUnused = 2;
3356
3357    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3358    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3359    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3360          searchSpc->monitoringSymbolsWithinSlot->size);
3361    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3362    {
3363       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3364       return RFAILED;
3365    }
3366
3367    byteIdx = 0;
3368    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3369                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3370    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3371    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3372
3373    searchSpc->nrofCandidates = NULLP;
3374    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3375    if(!searchSpc->nrofCandidates)
3376    {
3377       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3378       return RFAILED;
3379    }
3380
3381    searchSpc->nrofCandidates->aggregationLevel1 = \
3382                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3383    searchSpc->nrofCandidates->aggregationLevel2 = \
3384                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3385    searchSpc->nrofCandidates->aggregationLevel4 = \
3386                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3387    searchSpc->nrofCandidates->aggregationLevel8 = \
3388                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3389    searchSpc->nrofCandidates->aggregationLevel16 = \
3390                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3391
3392    searchSpc->searchSpaceType = NULLP;
3393    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3394    if(!searchSpc->searchSpaceType)
3395    {
3396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3397       return RFAILED;
3398    }
3399
3400    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3401
3402    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3403    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3404          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3405    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3406    {
3407       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3408       return RFAILED;
3409    }
3410    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3411                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3412
3413    return ROK;
3414 }/* End BuildSearchSpcToAddModList */
3415
3416 /*******************************************************************
3417  *
3418  * @brief Builds BWP DL dedicated PDCCH config
3419  *
3420  * @details
3421  *
3422  *    Function : BuildBWPDlDedPdcchCfg
3423  *
3424  *    Functionality: Builds BWP DL dedicated PDCCH config
3425  *
3426  * @params[in] struct PDCCH_Config *pdcchCfg
3427  *
3428  * @return ROK     - success
3429  *         RFAILED - failure
3430  *
3431  * ****************************************************************/
3432 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3433 {
3434    pdcchCfg->controlResourceSetToAddModList = NULLP;
3435    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3436          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3437    if(!pdcchCfg->controlResourceSetToAddModList)
3438    {
3439       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3440       return RFAILED;
3441    }
3442
3443    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3444    {
3445       return RFAILED;
3446    }
3447
3448    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3449
3450    pdcchCfg->searchSpacesToAddModList = NULLP;
3451    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3452          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3453    if(!pdcchCfg->searchSpacesToAddModList)
3454    {
3455       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3456       return RFAILED;
3457    }
3458
3459    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3460    {
3461       return RFAILED;
3462    }
3463
3464    pdcchCfg->searchSpacesToReleaseList = NULLP;
3465    pdcchCfg->downlinkPreemption = NULLP;
3466    pdcchCfg->tpc_PUSCH = NULLP;
3467    pdcchCfg->tpc_PUCCH = NULLP;
3468    pdcchCfg->tpc_SRS = NULLP;
3469
3470    return ROK;
3471 }
3472
3473 /*******************************************************************
3474  *
3475  * @brief Builds DMRS DL PDSCH Mapping type A
3476  *
3477  * @details
3478  *
3479  *    Function : BuildDMRSDLPdschMapTypeA
3480  *
3481  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3482  *
3483  * @params[in]
3484  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3485  * @return ROK     - success
3486  *         RFAILED - failure
3487  *
3488  * ****************************************************************/
3489    uint8_t BuildDMRSDLPdschMapTypeA
3490 (
3491  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3492  )
3493 {
3494    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3495    dmrsDlCfg->choice.setup = NULLP;
3496    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3497    if(!dmrsDlCfg->choice.setup)
3498    {
3499       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3500       return RFAILED;
3501    }
3502
3503    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3504    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3505    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3506    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3509       return RFAILED;
3510    }
3511    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3512
3513    dmrsDlCfg->choice.setup->maxLength = NULLP;
3514    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3515    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3516    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3517
3518    return ROK;
3519 }
3520
3521 /*******************************************************************
3522  *
3523  * @brief Builds TCI states to add/modify list
3524  *
3525  * @details
3526  *
3527  *    Function : BuildTCIStatesToAddModList
3528  *
3529  *    Functionality:Builds TCI states to add/modify list
3530  *
3531  * @params[in]
3532  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3533  *
3534  * @return ROK     - success
3535  *         RFAILED - failure
3536  *
3537  * ****************************************************************/
3538 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3539 {
3540    return ROK;
3541 }
3542
3543 /*******************************************************************
3544  *
3545  * @brief Builds PDSCH time domain allocation list
3546  *
3547  * @details
3548  *
3549  *    Function : BuildPdschTimeDomAllocList
3550  *
3551  *    Functionality: Builds PDSCH time domain allocation list
3552  *
3553  * @params[in]
3554  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3555  *
3556  * @return ROK     - success
3557  *         RFAILED - failure
3558  *
3559  * ****************************************************************/
3560    uint8_t BuildPdschTimeDomAllocList
3561 (
3562  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3563  )
3564 {
3565    uint8_t idx;
3566    uint8_t elementCnt;
3567    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3568
3569    timeDomAllocList->present = \
3570                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3571
3572    timeDomAllocList->choice.setup = NULLP;
3573    DU_ALLOC(timeDomAllocList->choice.setup, \
3574          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3575    if(!timeDomAllocList->choice.setup)
3576    {
3577       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3578       return RFAILED;
3579    }
3580
3581    elementCnt = 1;
3582    timeDomAllocList->choice.setup->list.count = elementCnt;
3583    timeDomAllocList->choice.setup->list.size = \
3584                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3585
3586    timeDomAllocList->choice.setup->list.array = NULLP;
3587    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3588          timeDomAllocList->choice.setup->list.size);
3589    if(!timeDomAllocList->choice.setup->list.array)
3590    {
3591       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3592       return RFAILED;
3593    }
3594
3595    for(idx = 0; idx < elementCnt; idx++)
3596    {
3597       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3598       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3599             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3600       if(!timeDomAllocList->choice.setup->list.array[idx])
3601       {
3602          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3603          return RFAILED;
3604       }
3605    }
3606
3607    idx = 0;
3608    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3609
3610    timeDomAlloc->k0 = NULLP;
3611    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3612    timeDomAlloc->startSymbolAndLength = \
3613                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3614
3615    return ROK;
3616 }
3617
3618 /*******************************************************************
3619  *
3620  * @brief Builds PDSCH PRB Bundling type
3621  *
3622  * @details
3623  *
3624  *    Function : BuildPdschPrbBundlingType
3625  *
3626  *    Functionality: Builds PDSCH PRB Bundling type
3627  *
3628  * @params[in]
3629  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3630  *
3631  * @return ROK     - success
3632  *         RFAILED - failure
3633  *
3634  * ****************************************************************/
3635    uint8_t BuildPdschPrbBundlingType
3636 (
3637  struct PDSCH_Config__prb_BundlingType *prbBndlType
3638  )
3639 {
3640    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3641
3642    prbBndlType->choice.staticBundling = NULLP;
3643    DU_ALLOC(prbBndlType->choice.staticBundling, \
3644          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3645    if(!prbBndlType->choice.staticBundling)
3646    {
3647       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3648       return RFAILED;
3649    }
3650    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3651
3652    return ROK;
3653 }
3654
3655 /*******************************************************************
3656  *
3657  * @brief Builds BWP DL dedicated PDSCH config
3658  *
3659  * @details
3660  *
3661  *    Function : BuildBWPDlDedPdschCfg
3662  *
3663  *    Functionality: Builds BWP DL dedicated PDSCH config
3664  *
3665  * @params[in] struct PDSCH_Config *pdschCfg
3666  *
3667  * @return ROK     - success
3668  *         RFAILED - failure
3669  *
3670  * ****************************************************************/
3671 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3672 {
3673    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3674
3675    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3676    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3677          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3678    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3679    {
3680       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3681       return RFAILED;
3682    }
3683
3684    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3685    {
3686       return RFAILED;
3687    }
3688
3689    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3690    pdschCfg->tci_StatesToAddModList = NULLP;
3691    pdschCfg->tci_StatesToReleaseList = NULLP;
3692    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3693 #if 0
3694    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3695    if(!pdschCfg->tci_StatesToAddModList)
3696    {
3697       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3698       return RFAILED;
3699    }
3700    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3701    {
3702       return RFAILED;
3703    }
3704 #endif
3705
3706    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3707
3708    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3709    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3710          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3711    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3712    {
3713       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3714       return RFAILED;
3715    }
3716
3717    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3718    {
3719       return RFAILED;
3720    }
3721
3722    pdschCfg->pdsch_AggregationFactor = NULLP;
3723    pdschCfg->rateMatchPatternToAddModList = NULLP;
3724    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3725    pdschCfg->rateMatchPatternGroup1 = NULLP;
3726    pdschCfg->rateMatchPatternGroup2 = NULLP;
3727    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3728    pdschCfg->mcs_Table = NULLP;
3729
3730    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3731    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3732    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3733    {
3734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3735       return RFAILED;
3736    }
3737    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3738
3739    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3740    {
3741       return RFAILED;
3742    }
3743
3744    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3745    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3746    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3747    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3748    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3749    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3750    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3751
3752    return ROK;
3753 }
3754
3755 /*******************************************************************
3756  *
3757  * @brief Builds intitial DL BWP
3758  * @details
3759  *
3760  *    Function : BuildInitialDlBWP
3761  *
3762  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3763  *
3764  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3765  *
3766  * @return ROK     - success
3767  *         RFAILED - failure
3768  *
3769  * ****************************************************************/
3770 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3771 {
3772    dlBwp->pdcch_Config = NULLP;
3773    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3774    if(!dlBwp->pdcch_Config)
3775    {
3776       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3777       return RFAILED;
3778    }
3779    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3780
3781    dlBwp->pdcch_Config->choice.setup = NULLP;
3782    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3783    if(!dlBwp->pdcch_Config->choice.setup)
3784    {
3785       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3786       return RFAILED;
3787    }
3788    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3789    {
3790       return RFAILED;
3791    }
3792
3793    dlBwp->pdsch_Config = NULLP;
3794    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3795    if(!dlBwp->pdsch_Config)
3796    {
3797       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3798       return RFAILED;
3799    }
3800    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3801
3802    dlBwp->pdsch_Config->choice.setup = NULLP;
3803    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3804    if(!dlBwp->pdsch_Config->choice.setup)
3805    {
3806       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3807       return RFAILED;
3808    }
3809
3810    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3811    {
3812       return RFAILED;
3813    }
3814
3815    dlBwp->sps_Config = NULLP;
3816    dlBwp->radioLinkMonitoringConfig = NULLP;
3817    return ROK;
3818 }
3819
3820 /*******************************************************************
3821  *
3822  * @brief Builds DMRS UL Pusch Mapping type A
3823  *
3824  * @details
3825  *
3826  *    Function : BuildDMRSULPuschMapTypeA
3827  *
3828  *    Functionality: Builds DMRS UL Pusch Mapping type A
3829  *
3830  * @params[in]
3831  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3832  * @return ROK     - success
3833  *         RFAILED - failure
3834  *
3835  * ****************************************************************/
3836    uint8_t BuildDMRSULPuschMapTypeA
3837 (
3838  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3839  )
3840 {
3841    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3842    dmrsUlCfg->choice.setup= NULLP;
3843    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3844    if(!dmrsUlCfg->choice.setup)
3845    {
3846       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3847       return RFAILED;
3848    }
3849
3850    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3851    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3852    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3853    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3854    {
3855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3856       return RFAILED;
3857    }
3858    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3859
3860    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3861    dmrsUlCfg->choice.setup->maxLength = NULLP;
3862    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3863    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3864          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3865    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3866    {
3867       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3868       return RFAILED;
3869    }
3870
3871    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3872    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3873          sizeof(long));
3874    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3875    {
3876       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3877       return RFAILED;
3878    }
3879    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3880
3881    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3882    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3883    return ROK;
3884 }
3885
3886 /*******************************************************************
3887  *
3888  * @brief Build PUSCH time domain allocation list
3889  *
3890  * @details
3891  *
3892  *    Function : BuildPuschTimeDomAllocList
3893  *
3894  *    Functionality: Build PUSCH time domain allocation list
3895  *
3896  * @params[in]
3897  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3898  *
3899  * @return ROK     - success
3900  *         RFAILED - failure
3901  *
3902  * ****************************************************************/
3903    uint8_t BuildPuschTimeDomAllocList
3904 (
3905  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3906  )
3907 {
3908    uint8_t idx;
3909    uint8_t elementCnt;
3910    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3911
3912    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3913    timeDomAllocList->choice.setup = NULLP;
3914    DU_ALLOC(timeDomAllocList->choice.setup, \
3915          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3916    if(!timeDomAllocList->choice.setup)
3917    {
3918       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3919       return RFAILED;
3920    }
3921
3922    elementCnt = 1;
3923    timeDomAllocList->choice.setup->list.count = elementCnt;
3924    timeDomAllocList->choice.setup->list.size = \
3925                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3926    timeDomAllocList->choice.setup->list.array = NULLP;
3927    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3928          timeDomAllocList->choice.setup->list.size);
3929    if(!timeDomAllocList->choice.setup->list.array)
3930    {
3931       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3932       return RFAILED;
3933    }
3934
3935    for(idx = 0; idx < elementCnt; idx++)
3936    {
3937       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3938       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3939             sizeof(PUSCH_TimeDomainResourceAllocation_t));
3940       if(!timeDomAllocList->choice.setup->list.array[idx])
3941       {
3942          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3943          return RFAILED;
3944       }
3945    }
3946
3947    idx = 0;
3948    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3949    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
3950    if(!timeDomAlloc->k2)
3951    {
3952       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3953       return RFAILED;
3954    }
3955    *(timeDomAlloc->k2) = PUSCH_K2;
3956    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3957    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
3958    return ROK;
3959 }
3960
3961 /*******************************************************************
3962  *
3963  * @brief Builds BWP UL dedicated PUSCH Config
3964  *
3965  * @details
3966  *
3967  *    Function : BuildBWPUlDedPuschCfg
3968  *
3969  *    Functionality:
3970  *      Builds BWP UL dedicated PUSCH Config
3971  *
3972  * @params[in] : PUSCH_Config_t *puschCfg
3973  *
3974  * @return ROK     - success
3975  *         RFAILED - failure
3976  *
3977  * ****************************************************************/
3978 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3979 {
3980    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3981    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3982    if(!puschCfg->dataScramblingIdentityPUSCH)
3983    {
3984       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3985       return RFAILED;
3986    }
3987    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3988
3989    puschCfg->txConfig = NULLP;
3990    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3991    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3992          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3993    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3994    {
3995       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
3996       return RFAILED;
3997    }
3998
3999    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4000    {
4001       return RFAILED;
4002    }
4003
4004    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4005    puschCfg->pusch_PowerControl = NULLP;
4006    puschCfg->frequencyHopping = NULLP;
4007    puschCfg->frequencyHoppingOffsetLists = NULLP;
4008    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4009
4010    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4011    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4012          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4013    if(!puschCfg->pusch_TimeDomainAllocationList)
4014    {
4015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4016       return RFAILED;
4017    }
4018
4019    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4020    {
4021       return RFAILED;
4022    }
4023
4024    puschCfg->pusch_AggregationFactor = NULLP;
4025    puschCfg->mcs_Table = NULLP;
4026    puschCfg->mcs_TableTransformPrecoder = NULLP;
4027    puschCfg->transformPrecoder = NULLP;
4028    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4029    if(!puschCfg->transformPrecoder)
4030    {
4031       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4032       return RFAILED;
4033    }
4034    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4035
4036    puschCfg->codebookSubset = NULLP;
4037    puschCfg->maxRank = NULLP;
4038    puschCfg->rbg_Size = NULLP;
4039    puschCfg->uci_OnPUSCH = NULLP;
4040    puschCfg->tp_pi2BPSK = NULLP;
4041
4042    return ROK;
4043 }
4044
4045 /*******************************************************************
4046  *
4047  * @brief Fills SRS resource to add/modify list
4048  *
4049  * @details
4050  *
4051  *    Function : BuildSrsRsrcAddModList
4052  *
4053  *    Functionality: Fills SRS resource to add/modify list
4054  *
4055  * @params[in]
4056  * @return ROK     - success
4057  *         RFAILED - failure
4058  *
4059  * ****************************************************************/
4060 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4061 {
4062    uint8_t   elementCnt;
4063    uint8_t   rsrcIdx;
4064
4065    elementCnt = 1;
4066    resourceList->list.count = elementCnt;
4067    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4068    resourceList->list.array = NULLP;
4069    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4070    if(!resourceList->list.array)
4071    {
4072       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4073       return RFAILED;
4074    }
4075
4076    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4077    {
4078       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4079       if(!resourceList->list.array[rsrcIdx])
4080       {
4081          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4082          return RFAILED;
4083       }
4084    }
4085
4086    rsrcIdx = 0;
4087    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4088    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4089    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4090
4091    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4092    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4093          sizeof(struct SRS_Resource__transmissionComb__n2));
4094    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4095    {
4096       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4097       return RFAILED;
4098    }
4099    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4100       = SRS_COMB_OFFSET_N2;
4101    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4102       = SRS_CYCLIC_SHIFT_N2;
4103
4104    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4105                                                                       PUSCH_START_SYMBOL;
4106    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4107                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4108    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4109                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4110
4111    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4112    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4113    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4114    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4115    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4116    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4117                                                                SRS_Resource__groupOrSequenceHopping_neither;
4118
4119    /* Setting resource type to aperiodic for intergration purposes */
4120    resourceList->list.array[rsrcIdx]->resourceType.present = \
4121                                                              SRS_Resource__resourceType_PR_aperiodic;
4122    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4123    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4124          sizeof(struct SRS_Resource__resourceType__aperiodic));
4125    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4126    {
4127       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4128       return RFAILED;
4129    }
4130    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4131
4132    return ROK;
4133 }
4134
4135 /*******************************************************************
4136  *
4137  * @brief Build SRS resource set Add/mod list
4138  *
4139  * @details
4140  *
4141  *    Function : BuildSrsRsrcSetAddModList
4142  *
4143  *    Functionality: Build SRS resource set Add/mod list
4144  *
4145  * @params[in]
4146  * @return ROK     - success
4147  *         RFAILED - failure
4148  *
4149  * ****************************************************************/
4150    uint8_t BuildSrsRsrcSetAddModList
4151 (
4152  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4153  )
4154 {
4155    uint8_t  elementCnt;
4156    uint8_t  rSetIdx;
4157    uint8_t  rsrcIdx;
4158    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4159
4160    elementCnt = 1;
4161    rsrcSetList->list.count = elementCnt;
4162    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4163    rsrcSetList->list.array = NULLP;
4164    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4165    if(!rsrcSetList->list.array)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4168       return RFAILED;
4169    }
4170
4171    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4172    {
4173       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4174       if(!rsrcSetList->list.array[rSetIdx])
4175       {
4176          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4177          return RFAILED;
4178       }
4179    }
4180
4181    rSetIdx = 0;
4182    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4183
4184    /* Fill Resource Id list in resource set */
4185    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4186    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4187          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4188    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4189    {
4190       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4191       return RFAILED;
4192    }
4193
4194    elementCnt = 1;
4195    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4196    rsrcIdList->list.count = elementCnt;
4197    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4198    rsrcIdList->list.array = NULLP;
4199    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4200    if(!rsrcIdList->list.array)
4201    {
4202       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4203       return RFAILED;
4204    }
4205
4206    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4207    {
4208       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4209       if(!rsrcIdList->list.array[rsrcIdx])
4210       {
4211          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4212          return RFAILED;
4213       }
4214    }
4215
4216    rsrcIdx = 0;
4217    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4218
4219    /* Fill resource type */
4220    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4221                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4222
4223    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4224    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4225          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4226    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4227    {
4228       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4229       return RFAILED;
4230    }
4231    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4232       = APERIODIC_SRS_RESRC_TRIGGER;
4233
4234    /* TODO : Fill values for below IEs as expected by Viavi */
4235    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4236    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4237
4238
4239    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4240    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4241    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4242    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4243    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4244
4245    return ROK;
4246 }
4247
4248 /*******************************************************************
4249  *
4250  * @brief Builds BWP UL dedicated SRS Config
4251  *
4252  * @details
4253  *
4254  *    Function : BuildBWPUlDedSrsCfg
4255  *
4256  *    Functionality: Builds BWP UL dedicated SRS Config
4257  *
4258  * @params[in] SRS Config
4259  * @return ROK     - success
4260  *         RFAILED - failure
4261  *
4262  * ****************************************************************/
4263 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4264 {
4265    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4266    srsCfg->srs_ResourceSetToAddModList = NULLP;
4267    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4268          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4269    if(!srsCfg->srs_ResourceSetToAddModList)
4270    {
4271       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4272       return RFAILED;
4273    }
4274    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4275    {
4276       return RFAILED;
4277    }
4278
4279    srsCfg->srs_ResourceToReleaseList = NULLP;
4280
4281    /* Resource to Add/Modify list */
4282    srsCfg->srs_ResourceToAddModList = NULLP;
4283    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4284          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4285    if(!srsCfg->srs_ResourceToAddModList)
4286    {
4287       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4288       return RFAILED;
4289    }
4290
4291    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4292    {
4293       return RFAILED;
4294    }
4295
4296    srsCfg->tpc_Accumulation = NULLP;
4297
4298    return ROK;
4299 }
4300
4301
4302
4303 /*******************************************************************
4304  *
4305  * @brief Builds Pusch Serving cell Config
4306  *
4307  * @details
4308  *
4309  *    Function : BuildPuschSrvCellCfg
4310  *
4311  *    Functionality: Builds Pusch Serving cell Config
4312  *
4313  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4314  *
4315  * @return ROK     - success
4316  *         RFAILED - failure
4317  *
4318  * ****************************************************************/
4319 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4320 {
4321    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4322    puschCfg->choice.setup = NULLP;
4323    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4324    if(!puschCfg->choice.setup)
4325    {
4326       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4327       return RFAILED;
4328    }
4329
4330    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4331    puschCfg->choice.setup->rateMatching = NULLP;
4332    puschCfg->choice.setup->xOverhead = NULLP;
4333    puschCfg->choice.setup->ext1 = NULLP;
4334    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4335    if(!puschCfg->choice.setup->ext1)
4336    {
4337       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4338       return RFAILED;
4339    }
4340
4341    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4342    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4343    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4344    {
4345       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4346       return RFAILED;
4347    }
4348    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4349
4350    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4351    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4352    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4353    {
4354       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4355       return RFAILED;
4356    }
4357    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4358    return ROK;
4359 }
4360
4361 /*******************************************************************
4362  *
4363  * @brief Builds inital UL BWP
4364  *
4365  * @details
4366  *
4367  *    Function : BuildInitialUlBWP
4368  *
4369  *    Functionality: Builds initial UL BWP
4370  *
4371  * @params[in] BWP_UplinkDedicated_t *ulBwp
4372  * @return ROK     - success
4373  *         RFAILED - failure
4374  *
4375  * ****************************************************************/
4376 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4377 {
4378    ulBwp->pucch_Config = NULLP;
4379
4380    /* Fill BWP UL dedicated PUSCH config */
4381    ulBwp->pusch_Config = NULLP;
4382    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4383    if(!ulBwp->pusch_Config)
4384    {
4385       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4386       return RFAILED;
4387    }
4388
4389    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4390    ulBwp->pusch_Config->choice.setup = NULLP;
4391    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4392    if(!ulBwp->pusch_Config->choice.setup)
4393    {
4394       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4395       return RFAILED;
4396    }
4397
4398    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4399    {
4400       return RFAILED;
4401    }
4402
4403    ulBwp->configuredGrantConfig = NULLP;
4404
4405    /* Fill BPW UL dedicated SRS config */
4406    ulBwp->srs_Config = NULLP;
4407    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4408    if(!ulBwp->srs_Config)
4409    {
4410       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4411       return RFAILED;
4412    }
4413
4414    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4415    ulBwp->srs_Config->choice.setup = NULLP;
4416    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4417    if(!ulBwp->srs_Config->choice.setup)
4418    {
4419       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4420       return RFAILED;
4421    }
4422
4423    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4424    {
4425       return RFAILED;
4426    }
4427
4428    ulBwp->beamFailureRecoveryConfig = NULLP;
4429
4430    return ROK;
4431 }
4432
4433 /*******************************************************************
4434  *
4435  * @brief Builds UL config
4436  * @details
4437  *
4438  *    Function : BuildUlCfg
4439  *
4440  *    Functionality: Builds UL config in spCellCfgDed
4441  *
4442  * @params[in] UplinkConfig_t *ulCfg
4443  *
4444  * @return ROK     - success
4445  *         RFAILED - failure
4446  *
4447  * ****************************************************************/
4448 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4449 {
4450    ulCfg->initialUplinkBWP = NULLP;
4451    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4452    if(!ulCfg->initialUplinkBWP)
4453    {
4454       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4455       return RFAILED;
4456    }
4457
4458    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4459    {
4460       return RFAILED;
4461    }
4462
4463    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4464    ulCfg->uplinkBWP_ToAddModList = NULLP;
4465    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4466    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4467    if(!ulCfg->firstActiveUplinkBWP_Id)
4468    {
4469       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4470       return RFAILED;
4471    }
4472    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4473
4474    ulCfg->pusch_ServingCellConfig = NULLP;
4475    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4476          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4477    if(!ulCfg->pusch_ServingCellConfig)
4478    {
4479       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4480       return RFAILED;
4481    }
4482
4483    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4484    {
4485       return RFAILED;
4486    }
4487
4488    ulCfg->carrierSwitching = NULLP;
4489    ulCfg->ext1 = NULLP;
4490    return ROK;
4491 }
4492
4493 /*******************************************************************
4494  *
4495  * @brief Builds PDSCH serving cell config
4496  * @details
4497  *
4498  *    Function : BuildPdschSrvCellCfg
4499  *
4500  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4501  *
4502  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4503  *
4504  * @return ROK     - success
4505  *         RFAILED - failure
4506  *
4507  * ****************************************************************/
4508 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4509 {
4510    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4511    pdschCfg->choice.setup = NULLP;
4512    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4513    if(!pdschCfg->choice.setup)
4514    {
4515       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4516       return RFAILED;
4517    }
4518
4519    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4520    pdschCfg->choice.setup->xOverhead = NULLP;
4521    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4522    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4523    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4524    {
4525       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4526       return RFAILED;
4527    }
4528    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4529    pdschCfg->choice.setup->pucch_Cell = NULLP;
4530    pdschCfg->choice.setup->ext1 = NULLP;
4531
4532    return ROK;
4533 }
4534
4535 /*******************************************************************
4536  *
4537  * @brief Builds CSI Meas config
4538  * @details
4539  *
4540  *    Function : BuildCsiMeasCfg
4541  *
4542  *    Functionality: Builds CSI Meas config in spCellCfgDed
4543  *
4544  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4545  *
4546  * @return ROK     - success
4547  *         RFAILED - failure
4548  *
4549  * ****************************************************************/
4550 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4551 {
4552
4553    return ROK;
4554 }
4555
4556 /*******************************************************************
4557  *
4558  * @brief Builds Spcell config dedicated
4559  * @details
4560  *
4561  *    Function : BuildSpCellCfgDed
4562  *
4563  *    Functionality: Builds sp cell config dedicated in spCellCfg
4564  *
4565  * @params[in] ServingCellConfig_t srvCellCfg
4566  *
4567  * @return ROK     - success
4568  *         RFAILED - failure
4569  *
4570  * ****************************************************************/
4571 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4572 {
4573    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4574    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4575    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4576    {
4577       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4578       return RFAILED;
4579    }
4580
4581    srvCellCfg->initialDownlinkBWP = NULLP;
4582    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4583    if(!srvCellCfg->initialDownlinkBWP)
4584    {
4585       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4586       return RFAILED;
4587    }
4588
4589    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4590    {
4591       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4592       return RFAILED;
4593    }
4594    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4595    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4596
4597    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4598    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4599    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4600    {
4601       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4602       return RFAILED;
4603    }
4604    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4605
4606    srvCellCfg->bwp_InactivityTimer = NULLP;
4607
4608    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4609    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4610    if(!srvCellCfg->defaultDownlinkBWP_Id)
4611    {
4612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4613       return RFAILED;
4614    }
4615    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4616
4617    srvCellCfg->uplinkConfig = NULLP;
4618    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4619    if(!srvCellCfg->uplinkConfig)
4620    {
4621       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4622       return RFAILED;
4623    }
4624
4625    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4626    {
4627       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4628       return RFAILED;
4629    }
4630    srvCellCfg->supplementaryUplink = NULLP;
4631    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4632
4633    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4634    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4635    if(!srvCellCfg->pdsch_ServingCellConfig)
4636    {
4637       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4638       return RFAILED;
4639    }
4640
4641    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4642    {
4643       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4644       return RFAILED;
4645    }
4646
4647    srvCellCfg->csi_MeasConfig = NULLP;
4648 #if 0
4649    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4650       if(!srvCellCfg->csi_MeasConfig)
4651       {
4652          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4653          return RFAILED;
4654       }
4655
4656    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4657    {
4658       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4659       return RFAILED;
4660    }
4661 #endif
4662    srvCellCfg->sCellDeactivationTimer = NULLP;
4663    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4664    srvCellCfg->tag_Id = TAG_ID;
4665    srvCellCfg->dummy = NULLP;
4666    srvCellCfg->pathlossReferenceLinking = NULLP;
4667    srvCellCfg->servingCellMO = NULLP;
4668    srvCellCfg->ext1 = NULLP;
4669
4670    return ROK;
4671 }
4672 /*******************************************************************
4673  *
4674  * @brief Builds Spcell config
4675  *
4676  * @details
4677  *
4678  *    Function : BuildSpCellCfg
4679  *
4680  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4681  *
4682  * @params[in] SpCellConfig_t spCellCfg
4683  *
4684  * @return ROK     - success
4685  *         RFAILED - failure
4686  *
4687  * ****************************************************************/
4688 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4689 {
4690
4691    spCellCfg->servCellIndex = NULLP;
4692    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4693    if(!spCellCfg->servCellIndex)
4694    {
4695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4696       return RFAILED;
4697    }
4698    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4699
4700    spCellCfg->reconfigurationWithSync = NULLP;
4701    spCellCfg->rlf_TimersAndConstants = NULLP;
4702    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4703    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4704    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4705    {
4706       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4707       return RFAILED;
4708    }
4709    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4710
4711    spCellCfg->spCellConfigDedicated = NULLP;
4712    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4713    if(!spCellCfg->spCellConfigDedicated)
4714    {
4715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4716       return RFAILED;
4717    }
4718    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4719    {
4720       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4721       return RFAILED;
4722    }
4723    return ROK;
4724 }
4725 /*******************************************************************
4726  *
4727  * @brief Builds Phy cell group config
4728  *
4729  * @details
4730  *
4731  *    Function : BuildPhyCellGrpCfg
4732  *
4733  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4734  *
4735  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4736  *
4737  * @return ROK     - success
4738  *         RFAILED - failure
4739  *
4740  * ****************************************************************/
4741 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4742 {
4743    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4744    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4745
4746    phyCellGrpCfg->p_NR_FR1 = NULLP;
4747    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4748    if(!phyCellGrpCfg->p_NR_FR1)
4749    {
4750       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4751       return RFAILED;
4752    }
4753    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4754    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4755    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4756    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4757    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4758    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4759    phyCellGrpCfg->cs_RNTI = NULLP;
4760    phyCellGrpCfg->ext1 = NULLP;
4761    phyCellGrpCfg->ext2 = NULLP;
4762
4763    return ROK;
4764 }
4765 /*******************************************************************
4766  *
4767  * @brief Builds Mac cell group config
4768  *
4769  * @details
4770  *
4771  *    Function : BuildMacCellGrpCfg
4772  *
4773  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4774  *
4775  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4776  *
4777  * @return ROK     - success
4778  *         RFAILED - failure
4779  *
4780  * ****************************************************************/
4781 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4782 {
4783    macCellGrpCfg->drx_Config = NULLP;
4784    macCellGrpCfg->schedulingRequestConfig = NULLP;
4785    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4786    if(!macCellGrpCfg->schedulingRequestConfig)
4787    {
4788       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4789       return RFAILED;
4790    }
4791
4792    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4793    {
4794       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4795       return RFAILED;
4796    }
4797
4798    macCellGrpCfg->bsr_Config = NULLP;
4799    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4800    if(!macCellGrpCfg->bsr_Config)
4801    {
4802       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4803       return RFAILED;
4804    }
4805
4806    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4807    {
4808       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4809       return RFAILED;
4810    }
4811
4812    macCellGrpCfg->tag_Config = NULLP;
4813    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4814    if(!macCellGrpCfg->tag_Config)
4815    {
4816       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4817       return RFAILED;
4818    }
4819
4820    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4821    {
4822       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4823       return RFAILED;
4824    }
4825
4826    macCellGrpCfg->phr_Config = NULLP;
4827    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4828    if(!macCellGrpCfg->phr_Config)
4829    {
4830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4831       return RFAILED;
4832    }
4833
4834    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4835    {
4836       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
4837       return RFAILED;
4838    }
4839
4840    macCellGrpCfg->skipUplinkTxDynamic = false;
4841    macCellGrpCfg->ext1 = NULLP;
4842
4843    return ROK;
4844 }
4845 /*******************************************************************
4846  *
4847  * @brief Frees memeory allocated for SearchSpcToAddModList
4848  *
4849  * @details
4850  *
4851  *    Function : FreeSearchSpcToAddModList
4852  *
4853  *    Functionality: Deallocating memory of SearchSpcToAddModList
4854  *
4855  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4856  *
4857  * @return void
4858  *
4859  4221 * ****************************************************************/
4860 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4861 {
4862    uint8_t idx1=0;
4863    uint8_t idx2=0;
4864    struct  SearchSpace *searchSpc=NULLP;
4865
4866    if(searchSpcList->list.array)
4867    {
4868       if(searchSpcList->list.array[idx2])
4869       {
4870          searchSpc = searchSpcList->list.array[idx2];
4871          if(searchSpc->controlResourceSetId)
4872          {
4873             if(searchSpc->monitoringSlotPeriodicityAndOffset)
4874             {
4875                if(searchSpc->monitoringSymbolsWithinSlot)
4876                {
4877                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
4878                   {
4879                      if(searchSpc->nrofCandidates)
4880                      {
4881                         if(searchSpc->searchSpaceType)
4882                         {
4883                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4884                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4885                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
4886                                     SearchSpace__searchSpaceType));
4887                         }
4888                         DU_FREE(searchSpc->nrofCandidates,
4889                               sizeof(struct SearchSpace__nrofCandidates));
4890                      }
4891                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4892                            searchSpc->monitoringSymbolsWithinSlot->size);
4893                   }
4894                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4895                         sizeof(BIT_STRING_t));
4896                }
4897                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4898                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4899             }
4900             DU_FREE(searchSpc->controlResourceSetId,
4901                   sizeof(ControlResourceSetId_t));
4902          }
4903       }
4904       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4905       {
4906          DU_FREE(searchSpcList->list.array[idx1],
4907                sizeof(struct SearchSpace));
4908       }
4909       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4910    }
4911 }
4912 /*******************************************************************
4913  *
4914  * @brief Frees memory allocated for PdschTimeDomAllocList
4915  *
4916  * @details
4917  *
4918  *    Function : FreePdschTimeDomAllocList
4919  *
4920  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4921  *
4922  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4923  *
4924  * @return void
4925  *
4926  4221 * ****************************************************************/
4927 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4928 {
4929    uint8_t idx1=0;
4930
4931    if(timeDomAllocList->choice.setup)
4932    {
4933       if(timeDomAllocList->choice.setup->list.array)
4934       {
4935          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4936          {
4937             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4938                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
4939          }
4940          DU_FREE(timeDomAllocList->choice.setup->list.array, \
4941                timeDomAllocList->choice.setup->list.size);
4942       }
4943       DU_FREE(timeDomAllocList->choice.setup,\
4944             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4945    }
4946 }
4947 /*******************************************************************
4948  *
4949  * @brief Frees memory allocated for PuschTimeDomAllocList
4950  *
4951  *@details
4952  *
4953  *    Function : FreePuschTimeDomAllocList
4954  *
4955  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4956  *
4957  * @params[in] PUSCH_Config_t *puschCfg
4958  *
4959  * @return void
4960  *
4961  * ****************************************************************/
4962 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4963 {
4964    uint8_t idx1=0;
4965    uint8_t idx2=0;
4966    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4967
4968    if(puschCfg->pusch_TimeDomainAllocationList)
4969    {
4970       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4971       if(timeDomAllocList_t->choice.setup)
4972       {
4973          if(timeDomAllocList_t->choice.setup->list.array)
4974          {
4975             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4976             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4977             {
4978                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4979                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
4980             }
4981             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4982                   timeDomAllocList_t->choice.setup->list.size);
4983          }
4984          DU_FREE(timeDomAllocList_t->choice.setup, \
4985                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4986       }
4987       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
4988       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4989             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4990    }
4991
4992 }
4993 /*******************************************************************
4994  *
4995  * @brief Frees memory allocated for InitialUlBWP
4996  *
4997  * @details
4998  *
4999  *    Function : FreeInitialUlBWP
5000  *
5001  *    Functionality: Deallocating memory of InitialUlBWP
5002  *
5003  * @params[in] BWP_UplinkDedicated_t *ulBwp
5004  *
5005  * @return void
5006  *
5007  * ****************************************************************/
5008 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5009 {
5010    uint8_t  rSetIdx, rsrcIdx;
5011    SRS_Config_t   *srsCfg = NULLP;
5012    PUSCH_Config_t *puschCfg = NULLP;
5013    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5014    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5015    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5016    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5017
5018    if(ulBwp->pusch_Config)
5019    {
5020       if(ulBwp->pusch_Config->choice.setup)
5021       {
5022          puschCfg=ulBwp->pusch_Config->choice.setup;
5023          if(puschCfg->dataScramblingIdentityPUSCH)
5024          {
5025             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5026             {
5027                FreePuschTimeDomAllocList(puschCfg);
5028                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5029                if(dmrsUlCfg->choice.setup)
5030                {
5031                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5032                   {
5033                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5034                      {
5035                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5036                               sizeof(long));
5037                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5038                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5039                      }
5040                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5041                            sizeof(long));
5042                   }
5043                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5044                }
5045                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5046                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5047             }
5048             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5049          }
5050          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5051       }
5052       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5053
5054       /* Free SRS-Config */
5055       if(ulBwp->srs_Config)
5056       {
5057          if(ulBwp->srs_Config->choice.setup)
5058          {
5059             srsCfg = ulBwp->srs_Config->choice.setup;
5060
5061             /* Free Resource Set to add/mod list */
5062             if(srsCfg->srs_ResourceSetToAddModList)
5063             {
5064                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5065                if(rsrcSetList->list.array)
5066                {
5067                   rSetIdx = 0;
5068
5069                   /* Free SRS resource Id list in this SRS resource set */
5070                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5071                   {
5072                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5073
5074                      if(rsrcIdList->list.array)
5075                      {
5076                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5077                         {
5078                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5079                         }
5080                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5081                      }
5082                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5083                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5084                   }
5085
5086                   /* Free resource type info for this SRS resource set */
5087                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5088                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5089
5090                   /* Free memory for each resource set */
5091                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5092                   {
5093                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5094                   }
5095                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5096                }
5097                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5098                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5099             }
5100
5101             /* Free resource to add/modd list */
5102             if(srsCfg->srs_ResourceToAddModList)
5103             {
5104                resourceList = srsCfg->srs_ResourceToAddModList;
5105                if(resourceList->list.array)
5106                {
5107                   rsrcIdx = 0;
5108                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5109                         sizeof(struct SRS_Resource__transmissionComb__n2));
5110                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5111                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5112
5113                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5114                   {
5115                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5116                   }
5117                   DU_FREE(resourceList->list.array, resourceList->list.size);
5118                }
5119                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5120                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5121             }
5122
5123             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5124          }
5125          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5126       }
5127    }
5128 }
5129 /*******************************************************************
5130  *
5131  * @brief Frees memory allocated for initialUplinkBWP
5132  *
5133  * @details
5134  *
5135  *    Function : FreeinitialUplinkBWP
5136  *
5137  *    Functionality: Deallocating memory of initialUplinkBWP
5138  *
5139  * @params[in] UplinkConfig_t *ulCfg
5140  *
5141  * @return void
5142  *
5143  *
5144  * ****************************************************************/
5145 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5146 {
5147    BWP_UplinkDedicated_t *ulBwp=NULLP;
5148    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5149
5150    if(ulCfg->initialUplinkBWP)
5151    {
5152       ulBwp=ulCfg->initialUplinkBWP;
5153       if(ulCfg->firstActiveUplinkBWP_Id)
5154       {
5155          if(ulCfg->pusch_ServingCellConfig)
5156          {
5157             puschCfg=ulCfg->pusch_ServingCellConfig;
5158             if(puschCfg->choice.setup)
5159             {
5160                if(puschCfg->choice.setup->ext1)
5161                {
5162                   DU_FREE(puschCfg->choice.setup->ext1->\
5163                         processingType2Enabled,sizeof(BOOLEAN_t));
5164                   DU_FREE(puschCfg->choice.setup->ext1->\
5165                         maxMIMO_Layers,sizeof(long));
5166                   DU_FREE(puschCfg->choice.setup->ext1, \
5167                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5168                }
5169                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5170             }
5171             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5172          }
5173          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5174       }
5175       FreeInitialUlBWP(ulBwp);
5176       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5177    }
5178 }
5179 /*******************************************************************
5180  *
5181  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5182  *
5183  * @details
5184  *
5185  *    Function : FreeBWPDlDedPdschCfg
5186  *
5187  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5188  *
5189  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5190  *
5191  * @return void
5192  *
5193  *
5194  * ****************************************************************/
5195 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5196 {
5197    struct PDSCH_Config *pdschCfg=NULLP;
5198    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5199    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5200    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5201
5202    if(dlBwp->pdsch_Config->choice.setup)
5203    {
5204       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5205       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5206       {
5207          if(pdschCfg->pdsch_TimeDomainAllocationList)
5208          {
5209             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5210             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5211             {
5212                prbBndlType=&pdschCfg->prb_BundlingType;
5213                DU_FREE(prbBndlType->choice.staticBundling,\
5214                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5215                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5216             }
5217             FreePdschTimeDomAllocList(timeDomAllocList);
5218             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5219                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5220          }
5221          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5222          if(dmrsDlCfg->choice.setup)
5223          {
5224             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5225                   sizeof(long));
5226             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5227          }
5228          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5229                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5230       }
5231       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5232    }
5233 }
5234 /*******************************************************************
5235  *
5236  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5237  *
5238  * @details
5239  *
5240  *    Function : FreeBWPDlDedPdcchCfg
5241  *
5242  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5243  *
5244  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5245  *
5246  * @return void
5247  *
5248  *
5249  * ****************************************************************/
5250 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5251 {
5252    uint8_t idx1=0;
5253    uint8_t idx2=0;
5254    struct PDCCH_Config *pdcchCfg=NULLP;
5255    struct ControlResourceSet *controlRSet=NULLP;
5256    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5257
5258    if(dlBwp->pdcch_Config->choice.setup)
5259    {
5260       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5261       if(pdcchCfg->controlResourceSetToAddModList)
5262       {
5263          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5264          if(controlRSetList->list.array)
5265          {
5266             controlRSet = controlRSetList->list.array[idx2];
5267             if(controlRSet)
5268             {
5269                if(controlRSet->frequencyDomainResources.buf)
5270                {
5271                   if(controlRSet->pdcch_DMRS_ScramblingID)
5272                   {
5273                      if(pdcchCfg->searchSpacesToAddModList)
5274                      {
5275                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5276                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5277                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5278                      }
5279                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5280                   }
5281                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5282                         controlRSet->frequencyDomainResources.size);
5283                }
5284             }
5285             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5286             {
5287                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5288             }
5289             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5290          }
5291          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5292                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5293       }
5294       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5295    }
5296 }
5297
5298 /*******************************************************************
5299  *
5300  * @brief Frees emmory allocated for DUToCURRCContainer
5301  *
5302  * @details
5303  *
5304  *    Function : FreeMemDuToCuRrcCont
5305  *
5306  *    Functionality: Deallocating memory of DuToCuRrcContainer
5307  *
5308  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5309  *
5310  * @return ROK     - success
5311  *         RFAILED - failure
5312  *
5313  * ****************************************************************/
5314 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5315 {
5316    uint8_t idx=0;
5317    SpCellConfig_t *spCellCfg=NULLP;
5318    ServingCellConfig_t *srvCellCfg=NULLP;
5319    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5320    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5321    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5322    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5323    struct RLC_Config *rlcConfig=NULLP;
5324    struct LogicalChannelConfig *macLcConfig=NULLP;
5325    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5326    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5327    struct TAG_Config *tagConfig=NULLP;
5328    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5329    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5330    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5331
5332    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5333    if(rlcBearerList)
5334    {
5335       if(rlcBearerList->list.array)
5336       {
5337          for(idx=0; idx<rlcBearerList->list.count; idx++)
5338          {
5339             if(rlcBearerList->list.array[idx])
5340             {
5341                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5342                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5343                if(rlcConfig)
5344                {
5345                   if(rlcConfig->choice.am)
5346                   {
5347                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5348                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5349                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5350                   }
5351                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5352                }
5353                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5354                if(macLcConfig)
5355                {
5356                   if(macLcConfig->ul_SpecificParameters)
5357                   {
5358                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5359                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5360                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5361                   }
5362                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5363                }
5364                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5365             }
5366          }
5367          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5368       }
5369       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5370    }
5371
5372    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5373    if(macCellGrpCfg)
5374    {
5375       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5376       if(schedulingRequestConfig)
5377       {
5378          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5379          if(schReqList)
5380          {
5381             if(schReqList->list.array)
5382             {
5383                for(idx=0;idx<schReqList->list.count; idx++)
5384                {
5385                   if(schReqList->list.array[idx])
5386                   {
5387                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5388                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5389                   }
5390                }
5391                DU_FREE(schReqList->list.array, schReqList->list.size);
5392             }
5393             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5394                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5395             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5396       }
5397       if(macCellGrpCfg->bsr_Config)
5398       {
5399          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5400       }
5401       tagConfig = macCellGrpCfg->tag_Config;
5402       if(tagConfig)
5403       {
5404          tagList = tagConfig->tag_ToAddModList;
5405          if(tagList)
5406          {
5407             if(tagList->list.array)
5408             {
5409                for(idx=0; idx<tagList->list.count; idx++)
5410                {
5411                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5412                }
5413                DU_FREE(tagList->list.array, tagList->list.size);
5414             }
5415             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5416          }
5417          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5418       }
5419
5420       phrConfig = macCellGrpCfg->phr_Config;
5421       if(phrConfig)
5422       {
5423          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5424          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5425       }
5426
5427       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5428    }
5429
5430    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5431    if(phyCellGrpCfg)
5432    {
5433       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5434       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5435    }
5436
5437    spCellCfg = cellGrpCfg->spCellConfig;
5438    if(spCellCfg)
5439    {
5440       if(spCellCfg->servCellIndex)
5441       {
5442          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5443          {
5444             if(spCellCfg->spCellConfigDedicated)
5445             {
5446                srvCellCfg = spCellCfg->spCellConfigDedicated;
5447                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5448                {
5449                   if(srvCellCfg->initialDownlinkBWP)
5450                   {
5451                      dlBwp = srvCellCfg->initialDownlinkBWP;
5452                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5453                      {
5454                         if(srvCellCfg->defaultDownlinkBWP_Id)
5455                         {
5456                            if(srvCellCfg->uplinkConfig)
5457                            {
5458                               if(srvCellCfg->pdsch_ServingCellConfig)
5459                               {
5460                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5461                                  if(pdschCfg->choice.setup)
5462                                  {
5463                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5464                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5465                                  }
5466                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5467                                        ServingCellConfig__pdsch_ServingCellConfig));
5468                               }
5469                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5470                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5471                            }
5472                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5473                         }
5474                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5475                      }
5476                      if(dlBwp->pdcch_Config)
5477                      {
5478                         if(dlBwp->pdsch_Config)
5479                         {
5480                            FreeBWPDlDedPdschCfg(dlBwp);
5481                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5482                         }
5483                         FreeBWPDlDedPdcchCfg(dlBwp);
5484                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5485                     }
5486                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5487                   }
5488                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5489                }
5490                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5491             }
5492             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5493          }
5494          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5495       }
5496       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5497    }
5498    return ROK;
5499 }
5500 /*******************************************************************
5501  *
5502  * @brief Builds DU To CU RRC Container
5503  *
5504  * @details
5505  *
5506  *    Function : BuildDuToCuRrcContainer
5507  *
5508  *    Functionality: Builds DuToCuRrcContainer
5509  *
5510  * @params[in] idx, index in F1AP msg
5511  *             DuToCuRRCContainer, DuToCuRRCContainer
5512  *
5513  * @return ROK     - success
5514  *         RFAILED - failure
5515  *
5516  * ****************************************************************/
5517 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5518 {
5519    uint8_t  ret = ROK;
5520    CellGroupConfigRrc_t  cellGrpCfg;
5521    asn_enc_rval_t        encRetVal;
5522    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5523    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5524
5525    while(true)
5526    {
5527       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5528
5529       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5530       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5531       if(!cellGrpCfg.rlc_BearerToAddModList)
5532       {
5533          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5534          ret = RFAILED;
5535          break;
5536       }
5537       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5538       {
5539          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5540          ret = RFAILED;
5541          break;
5542       }
5543
5544       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5545       cellGrpCfg.mac_CellGroupConfig = NULLP;
5546       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5547       if(!cellGrpCfg.mac_CellGroupConfig)
5548       {
5549          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5550          ret = RFAILED;
5551          break;
5552       }
5553       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5554       {
5555          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5556          ret = RFAILED;
5557          break;
5558       }
5559
5560       cellGrpCfg.physicalCellGroupConfig = NULLP;
5561       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5562       if(!cellGrpCfg.physicalCellGroupConfig)
5563       {
5564          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5565          ret = RFAILED;
5566          break;
5567       }
5568       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5569       {
5570          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5571          ret = RFAILED;
5572          break;
5573       }
5574
5575       cellGrpCfg.spCellConfig = NULLP;
5576       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5577       if(!cellGrpCfg.spCellConfig)
5578       {
5579          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5580          ret = RFAILED;
5581          break;
5582       }
5583       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5584       {
5585          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5586          ret = RFAILED;
5587          break;
5588       }
5589
5590       cellGrpCfg.sCellToAddModList = NULLP;
5591       cellGrpCfg.sCellToReleaseList = NULLP;
5592       cellGrpCfg.ext1 = NULLP;
5593
5594       /* encode cellGrpCfg into duToCuRrcContainer */
5595       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5596       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5597       encBufSize = 0;
5598       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5599       /* Encode results */
5600       if(encRetVal.encoded == ENCODE_FAIL)
5601       {
5602          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5603                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5604          ret = RFAILED;
5605          break;
5606       }
5607       else
5608       {
5609          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5610          for(int i=0; i< encBufSize; i++)
5611          {
5612             printf("%x",encBuf[i]);
5613          }
5614       }
5615
5616       duToCuRrcContainer->size = encBufSize;
5617       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5618       if(!duToCuRrcContainer->buf)
5619       {
5620          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5621          ret = RFAILED;
5622          break;
5623       }
5624       if(ret == ROK)
5625       {
5626          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5627       }
5628       break;
5629    }
5630    FreeMemDuToCuRrcCont(&cellGrpCfg);
5631    return ret;
5632 }
5633
5634 /*******************************************************************
5635  *
5636  * @brief Free memory allocated in InitialULRRCMessage
5637  *
5638  * @details
5639  *
5640  *    Function : freeInitUlRrcMsgTransfer
5641  *
5642  *    Functionality: Free memory allocated in InitialULRRCMessage
5643  *
5644  * @params[in]F1AP_PDU_t  *f1apMsg)
5645  *
5646  * @return ROK     - success
5647  *         RFAILED - failure
5648  *
5649  * ****************************************************************/
5650
5651 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5652 {
5653    uint8_t ieIdx, arrIdx;
5654    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5655
5656    if(f1apMsg)
5657    {
5658       if(f1apMsg->choice.initiatingMessage)
5659       {
5660          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5661             choice.InitialULRRCMessageTransfer;
5662          if(initULRRCMsg->protocolIEs.list.array)
5663          {
5664             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5665             {
5666                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5667                {
5668                   case ProtocolIE_ID_id_NRCGI:
5669                   {
5670                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5671                      {
5672                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5673                         {
5674                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5675                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5676                         }
5677                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5678                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5679                      }
5680                      break;
5681                   }
5682                   case ProtocolIE_ID_id_RRCContainer:
5683                   {
5684                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5685                      {
5686                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5687                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5688                      }
5689                      break;
5690                   }
5691                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5692                   {
5693                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5694                      {
5695                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5696                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5697                      }
5698                      break;
5699                   }
5700                   default:
5701                      break;
5702                }
5703              }
5704              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5705              {
5706                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5707                 {
5708                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5709                       sizeof(InitialULRRCMessageTransferIEs_t));
5710                 }
5711              }
5712              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5713           }
5714          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5715       }
5716       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5717    }
5718    else
5719    {
5720       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5721       return RFAILED;
5722    }
5723    return ROK;
5724 }
5725
5726 /*******************************************************************
5727  *
5728  * @brief Builds and sends the InitialULRRCMessage
5729  *
5730  * @details
5731  *
5732  *    Function : BuildAndSendInitialRrcMsgTransfer
5733  *
5734  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5735  *                   it to the CU through SCTP.
5736  *
5737  * @params[in]
5738  *
5739  * @return ROK     - success
5740  *         RFAILED - failure
5741  *
5742  * ****************************************************************/
5743 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5744       uint16_t rrcContSize, uint8_t *rrcContainer)
5745 {
5746    uint8_t   ret;
5747    uint8_t   elementCnt;
5748    uint8_t   ieIdx;
5749    asn_enc_rval_t  encRetVal;
5750    F1AP_PDU_t  *f1apMsg = NULLP;
5751    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5752    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5753
5754    while(true)
5755    {
5756       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5757       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5758       if(f1apMsg == NULLP)
5759       {
5760          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5761          break;
5762       }
5763       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5764       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5765       if(f1apMsg->choice.initiatingMessage == NULLP)
5766       {
5767          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5768          break;
5769       }
5770       f1apMsg->choice.initiatingMessage->procedureCode =\
5771                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5772       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5773       f1apMsg->choice.initiatingMessage->value.present = \
5774                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5775       initULRRCMsg =\
5776                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5777       elementCnt = 5;
5778       initULRRCMsg->protocolIEs.list.count = elementCnt;
5779       initULRRCMsg->protocolIEs.list.size = \
5780                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5781       /* Initialize the F1Setup members */
5782       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5783       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5784       {
5785          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5786                RRCSetupRequestMessageTransferIEs failed");
5787          break;
5788       }
5789       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5790       {
5791          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5792                sizeof(InitialULRRCMessageTransferIEs_t));
5793          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5794          {
5795             break;
5796          }
5797       }
5798       ieIdx = 0;
5799       /*GNB DU UE F1AP ID*/
5800       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5801                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5802       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5803       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5804                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5805       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5806
5807
5808       /*NRCGI*/
5809       ieIdx++;
5810       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5811                                                         ProtocolIE_ID_id_NRCGI;
5812       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5813       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5814                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5815
5816       ret =\
5817            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5818       if(ret!=ROK)
5819       {
5820          break;
5821       }
5822
5823       /*CRNTI*/
5824       ieIdx++;
5825       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5826                                                         ProtocolIE_ID_id_C_RNTI;
5827       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5828       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5829                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
5830       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
5831
5832       /*RRCContainer*/
5833       ieIdx++;
5834       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5835                                                         ProtocolIE_ID_id_RRCContainer;
5836       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5837       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5838                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
5839
5840       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
5841       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
5842             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
5843       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5844       {
5845          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
5846          break;
5847
5848       }
5849       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
5850             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5851
5852
5853       /*DUtoCURRCContainer*/
5854       ieIdx++;
5855       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
5856       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
5857       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
5858                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
5859
5860       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
5861       if(ret != ROK)
5862       {
5863          break;
5864       }
5865
5866       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5867
5868       /* Encode the F1SetupRequest type as APER */
5869       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5870       encBufSize = 0;
5871       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
5872       /* Encode results */
5873       if(encRetVal.encoded == ENCODE_FAIL)
5874       {
5875          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
5876                structure (at %s)\n",encRetVal.failed_type ? \
5877                encRetVal.failed_type->name : "unknown");
5878          ret = RFAILED;
5879          break;
5880       }
5881       else
5882       {
5883
5884          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
5885                Message transfer\n");
5886          for(int i=0; i< encBufSize; i++)
5887          {
5888             printf("%x",encBuf[i]);
5889          }
5890       }
5891       /* Sending  msg  */
5892       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
5893       {
5894          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
5895          ret = RFAILED;
5896          break;
5897       }
5898       break;
5899    }
5900    freeInitUlRrcMsgTransfer(f1apMsg);
5901    return ret;
5902 }/* End of BuildAndSendInitialRrcMsgTransfer*/
5903
5904 /*****  UE SETUP REQUEST *****/
5905
5906 /*******************************************************************
5907  *
5908  * @brief Free Qos And Snssai Drb Info
5909  *
5910  * @details
5911  *
5912  *    Function : freeDrbQosAndSnssaiInfo
5913  *
5914  *    Functionality: Free Qos And Snssai Drb Info
5915  *
5916  * @params[in] LcCfg *lcCfg,
5917  * @return void
5918  *
5919  * ****************************************************************/
5920 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
5921 {
5922    if(lcCfg->snssai)
5923    {
5924       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
5925    }
5926    if(lcCfg->drbQos)
5927    {
5928       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
5929    }
5930 }
5931
5932 /******************************************************************
5933 *
5934 * @brief Function to delete the RLC Lc cfg from UE APP DB
5935 *
5936 * @details
5937 *
5938 *  Function : freeRlcLcCfg
5939 *
5940 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
5941 *
5942 *
5943  *****************************************************************/
5944
5945 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
5946 {
5947    switch(lcCfg->rlcMode)
5948    {
5949       case RLC_AM :
5950       {
5951          if(lcCfg->u.amCfg)
5952          {
5953             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
5954             lcCfg->u.amCfg = NULLP;
5955          }
5956          break;
5957       }
5958       case RLC_UM_BI_DIRECTIONAL :
5959       {
5960          if(lcCfg->u.umBiDirCfg)
5961          {
5962             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
5963             lcCfg->u.umBiDirCfg = NULLP;
5964          }
5965          break;
5966       }
5967       case RLC_UM_UNI_DIRECTIONAL_UL :
5968       {
5969          if(lcCfg->u.umUniDirUlCfg)
5970          {
5971             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
5972             lcCfg->u.umUniDirUlCfg = NULLP;
5973          }
5974          break;
5975
5976       }
5977       case RLC_UM_UNI_DIRECTIONAL_DL :
5978       {
5979          if(lcCfg->u.umUniDirDlCfg)
5980          {
5981             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
5982             lcCfg->u.umUniDirDlCfg = NULLP;
5983          }
5984          break;
5985       }
5986       default:
5987          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
5988          break;
5989    }
5990    memset(lcCfg, 0, sizeof(LcCfg));
5991 }
5992 /*******************************************************************
5993  *
5994  * @brief Function to free MacLcCfg
5995  *
5996  * @details
5997  *
5998  *    Function : freeMacLcCfg
5999  *
6000  *    Functionality: Function to free MacLcCfg
6001  *
6002  * @params[in] LcCfg *lcCfg,
6003  * @return void
6004  *
6005  * ****************************************************************/
6006
6007 void  freeMacLcCfg(LcCfg *lcCfg)
6008 {
6009     /* Deleting DRBQOS */
6010    if(lcCfg->drbQos)
6011    {
6012       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6013       lcCfg->drbQos = NULLP;
6014    }
6015    /* Deleting SNSSAI */
6016    if(lcCfg->snssai)
6017    {
6018       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6019       lcCfg->snssai = NULLP;
6020    }
6021    memset(lcCfg, 0, sizeof(LcCfg));
6022 }
6023 /*******************************************************************
6024  *
6025  * @brief Free UE NR Capability received in UE Context setup request
6026  *
6027  * @details
6028  *
6029  *    Function : freeAperDecodeUeNrCapability
6030  *
6031  *    Functionality:
6032  *       Free UE NR Capability received in UE Context setup request
6033  *
6034  * @params[in]
6035  * @return ROK     - success
6036  *         RFAILED - failure
6037  *
6038  * ****************************************************************/
6039 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6040 {
6041    uint8_t arrIdx =0;
6042    FeatureSets_t *featureSets =NULLP;
6043    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6044
6045    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6046    {
6047       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6048       {
6049          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6050             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6051       }
6052       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6053    }
6054
6055    if(ueNrCap->featureSets)
6056    {
6057       featureSets = ueNrCap->featureSets;
6058       if(featureSets->featureSetsDownlinkPerCC)
6059       {
6060          if(featureSets->featureSetsDownlinkPerCC->list.array)
6061          {
6062             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6063             {
6064                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6065                {
6066                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6067                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6068                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6069                }
6070             }
6071             free(featureSets->featureSetsDownlinkPerCC->list.array);
6072          }
6073          free(featureSets->featureSetsDownlinkPerCC);
6074       }
6075       if(featureSets->featureSetsUplinkPerCC)
6076       {
6077          if(featureSets->featureSetsUplinkPerCC->list.array)
6078          {
6079             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6080             {
6081                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6082                {
6083                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6084                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6085                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6086                }
6087             }
6088             free(featureSets->featureSetsUplinkPerCC->list.array);
6089          }
6090          free(featureSets->featureSetsUplinkPerCC);
6091       }
6092       free(ueNrCap->featureSets);
6093    }
6094 }
6095
6096 /*******************************************************************
6097 *
6098 * @brief Function to free PdcchSearchSpcToAddModList
6099          where memory allocated by aper_decoder
6100 *
6101 * @details
6102 *
6103 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6104 *
6105 *    Functionality: Function to free PdcchSearchSpcToAddModList
6106 *
6107 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6108 * @return void
6109 *
6110 * ****************************************************************/
6111
6112 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6113 {
6114    uint8_t searchSpcArrIdx=0;
6115    uint8_t searchSpcArrIdx1=0;
6116    struct  SearchSpace *searchSpc=NULLP;
6117
6118
6119    if(searchSpcList->list.array)
6120    {
6121       if(searchSpcList->list.array[searchSpcArrIdx1])
6122       {
6123          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6124          if(searchSpc->controlResourceSetId)
6125          {
6126             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6127             {
6128                if(searchSpc->monitoringSymbolsWithinSlot)
6129                {
6130                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6131                   {
6132                      if(searchSpc->nrofCandidates)
6133                      {
6134                         if(searchSpc->searchSpaceType)
6135                         {
6136                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6137                            free(searchSpc->searchSpaceType);
6138                         }
6139                         free(searchSpc->nrofCandidates);
6140                      }
6141                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6142                   }
6143                   free(searchSpc->monitoringSymbolsWithinSlot);
6144                }
6145                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6146             }
6147             free(searchSpc->controlResourceSetId);
6148          }
6149       }
6150       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6151       {
6152          free(searchSpcList->list.array[searchSpcArrIdx]);
6153       }
6154       free(searchSpcList->list.array);
6155    }
6156 }
6157 /*******************************************************************
6158 *
6159 * @brief Function for free part for the memory allocated by aper_decoder
6160 *
6161 * @details
6162 *
6163 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6164 *
6165 *    Functionality: Function to free BWPDlDedPdcchConfig
6166 *
6167 * @params[in]
6168 * @return void
6169 *
6170 * ****************************************************************/
6171
6172
6173 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6174 {
6175    uint8_t arrIdx1=0;
6176    uint8_t arrIdx2=0;
6177    struct PDCCH_Config *pdcchCfg=NULLP;
6178    struct ControlResourceSet *controlRSet=NULLP;
6179    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6180
6181    if(dlBwp->pdcch_Config->choice.setup)
6182    {
6183       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6184       if(pdcchCfg->controlResourceSetToAddModList)
6185       {
6186          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6187          if(controlRSetList->list.array)
6188          {
6189             controlRSet = controlRSetList->list.array[arrIdx2];
6190             if(controlRSet)
6191             {
6192                if(controlRSet->frequencyDomainResources.buf)
6193                {
6194                   if(controlRSet->pdcch_DMRS_ScramblingID)
6195                   {
6196                      if(pdcchCfg->searchSpacesToAddModList)
6197                      {
6198                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6199                         free(pdcchCfg->searchSpacesToAddModList);
6200                      }
6201                      free(controlRSet->pdcch_DMRS_ScramblingID);
6202                   }
6203                   free(controlRSet->frequencyDomainResources.buf);
6204                }
6205             }
6206             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6207             {
6208                free(controlRSetList->list.array[arrIdx1]);
6209             }
6210             free(controlRSetList->list.array);
6211          }
6212          free(pdcchCfg->controlResourceSetToAddModList);
6213       }
6214       free(dlBwp->pdcch_Config->choice.setup);
6215    }
6216 }
6217 /*******************************************************************
6218 *
6219 * @brief Function to free PdschTimeDomAllocationList
6220 *     where the memory allocated by aper_decoder
6221 *
6222 * @details
6223 *
6224 *    Function : freeAperDecodePdschTimeDomAllocationList
6225 *
6226 *    Functionality: Function to free PdschTimeDomAllocationList
6227 *
6228 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6229 * @return void
6230 *
6231 * ****************************************************************/
6232
6233
6234 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6235 {
6236    uint8_t arrIdx=0;
6237
6238    if(timeDomAllocList->choice.setup)
6239    {
6240       if(timeDomAllocList->choice.setup->list.array)
6241       {
6242          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6243          {
6244             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6245          }
6246          free(timeDomAllocList->choice.setup->list.array);
6247       }
6248       free(timeDomAllocList->choice.setup);
6249    }
6250 }
6251
6252 /*******************************************************************
6253 *
6254 * @brief Function to free BWPDlDedPdschConfig
6255 *        where the memory allocated by aper_decoder
6256 *
6257 * @details
6258 *
6259 *    Function : freeAperDecodeBWPDlDedPdschConfig
6260 *
6261 *    Functionality: Function to free BWPDlDedPdschConfig
6262 *
6263 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6264 * @return void
6265 *
6266 * ****************************************************************/
6267
6268
6269 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6270 {
6271    struct PDSCH_Config *pdschCfg=NULLP;
6272    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6273    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6274    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6275
6276    if(dlBwp->pdsch_Config->choice.setup)
6277    {
6278       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6279       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6280       {
6281          if(pdschCfg->pdsch_TimeDomainAllocationList)
6282          {
6283             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6284             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6285             {
6286                prbBndlType=&pdschCfg->prb_BundlingType;
6287                free(prbBndlType->choice.staticBundling);
6288                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6289             }
6290             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6291             free(pdschCfg->pdsch_TimeDomainAllocationList);
6292          }
6293          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6294          if(dmrsDlCfg->choice.setup)
6295          {
6296             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6297             free(dmrsDlCfg->choice.setup);
6298          }
6299          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6300       }
6301       free(dlBwp->pdsch_Config->choice.setup);
6302    }
6303 }
6304 /*******************************************************************
6305 *
6306 * @brief Function to free PuschTimeDomAllocListCfg
6307                  where the memory allocated by aper_decoder
6308 *
6309 * @details
6310 *
6311 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6312 *
6313 *    Functionality: Function to free PuschTimeDomAllocListCfg
6314 *
6315 * @params[in] PUSCH_Config_t *puschCfg
6316 * @return void
6317 *
6318 * ****************************************************************/
6319
6320
6321 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6322 {
6323    uint8_t arrIdx=0;
6324    uint8_t arrIdx1=0;
6325    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6326
6327    if(puschCfg->pusch_TimeDomainAllocationList)
6328    {
6329       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6330       if(timeDomAllocList_t->choice.setup)
6331       {
6332          if(timeDomAllocList_t->choice.setup->list.array)
6333          {
6334             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6335             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6336             {
6337                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6338             }
6339             free(timeDomAllocList_t->choice.setup->list.array);
6340          }
6341          free(timeDomAllocList_t->choice.setup);
6342       }
6343       free(puschCfg->transformPrecoder);
6344       free(puschCfg->pusch_TimeDomainAllocationList);
6345    }
6346 }
6347 /*******************************************************************
6348 *
6349 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6350 *
6351 * @details
6352 *
6353 *    Function : freeAperDecodeInitialUlBWPConfig
6354 *
6355 *    Functionality: Function to free InitialUlBWPConfig
6356 *
6357 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6358 * @return void
6359 *
6360 * ****************************************************************/
6361
6362
6363 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6364 {
6365    uint8_t  rSetIdx =0;
6366    uint8_t  rsrcIdx =0;
6367    SRS_Config_t   *srsCfg = NULLP;
6368    PUSCH_Config_t *puschCfg = NULLP;
6369    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6370    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6371    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6372    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6373
6374    if(ulBwp->pusch_Config)
6375    {
6376       if(ulBwp->pusch_Config->choice.setup)
6377       {
6378          puschCfg=ulBwp->pusch_Config->choice.setup;
6379          if(puschCfg->dataScramblingIdentityPUSCH)
6380          {
6381             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6382             {
6383                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6384                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6385                if(dmrsUlCfg->choice.setup)
6386                {
6387                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6388                   {
6389                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6390                      {
6391                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6392                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6393                      }
6394                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6395                   }
6396                   free(dmrsUlCfg->choice.setup);
6397                }
6398                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6399             }
6400             free(puschCfg->dataScramblingIdentityPUSCH);
6401          }
6402          free(ulBwp->pusch_Config->choice.setup);
6403       }
6404       free(ulBwp->pusch_Config);
6405
6406       /* Free SRS-Config */
6407       if(ulBwp->srs_Config)
6408       {
6409          if(ulBwp->srs_Config->choice.setup)
6410          {
6411             srsCfg = ulBwp->srs_Config->choice.setup;
6412
6413             /* Free Resource Set to add/mod list */
6414             if(srsCfg->srs_ResourceSetToAddModList)
6415             {
6416                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6417                if(rsrcSetList->list.array)
6418                {
6419                   rSetIdx = 0;
6420
6421                   /* Free SRS resource Id list in this SRS resource set */
6422                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6423                   {
6424                      rsrcIdList =
6425                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6426
6427                      if(rsrcIdList->list.array)
6428                      {
6429                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6430                               rsrcIdx++)
6431                         {
6432                            free(rsrcIdList->list.array[rsrcIdx]);
6433                         }
6434                         free(rsrcIdList->list.array);
6435                      }
6436                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6437                   }
6438
6439                   /* Free resource type info for this SRS resource set */
6440
6441                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6442
6443                   /* Free memory for each resource set */
6444                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6445                   {
6446                      free(rsrcSetList->list.array[rSetIdx]);
6447                   }
6448                   free(rsrcSetList->list.array);
6449                }
6450                free(srsCfg->srs_ResourceSetToAddModList);
6451             }
6452
6453             /* Free resource to add/modd list */
6454             if(srsCfg->srs_ResourceToAddModList)
6455             {
6456                resourceList = srsCfg->srs_ResourceToAddModList;
6457                if(resourceList->list.array)
6458                {
6459                   rsrcIdx = 0;
6460
6461                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6462                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6463
6464                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6465                   {
6466                      free(resourceList->list.array[rsrcIdx]);
6467                   }
6468                   free(resourceList->list.array);
6469                }
6470                free(srsCfg->srs_ResourceToAddModList);
6471             }
6472
6473             free(ulBwp->srs_Config->choice.setup);
6474          }
6475          free(ulBwp->srs_Config);
6476       }
6477    }
6478 }
6479 /*******************************************************************
6480 *
6481 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6482 *
6483 * @details
6484 *
6485 *    Function : freeAperDecodeinitialUplinkBWPConfig
6486 *
6487 *    Functionality: Function to free initialUplinkBWPConfig
6488 *
6489 * @params[in] UplinkConfig_t *ulCfg
6490 * @return void
6491 *
6492 * ****************************************************************/
6493
6494
6495 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6496 {
6497    BWP_UplinkDedicated_t *ulBwp=NULLP;
6498    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6499
6500    if(ulCfg->initialUplinkBWP)
6501    {
6502       ulBwp=ulCfg->initialUplinkBWP;
6503       if(ulCfg->firstActiveUplinkBWP_Id)
6504       {
6505          if(ulCfg->pusch_ServingCellConfig)
6506          {
6507             puschCfg=ulCfg->pusch_ServingCellConfig;
6508             if(puschCfg->choice.setup)
6509             {
6510                if(puschCfg->choice.setup->ext1)
6511                {
6512                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6513                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6514                   free(puschCfg->choice.setup->ext1);
6515                }
6516                free(puschCfg->choice.setup);
6517             }
6518             free(ulCfg->pusch_ServingCellConfig);
6519          }
6520          free(ulCfg->firstActiveUplinkBWP_Id);
6521       }
6522       freeAperDecodeInitialUlBWPConfig(ulBwp);
6523       free(ulCfg->initialUplinkBWP);
6524    }
6525 }
6526
6527 /*******************************************************************
6528  *
6529  * @brief Function to free DuUeCfg
6530  *
6531  * @details
6532  *
6533  *    Function : freeDuUeCfg
6534  *
6535  *    Functionality: Function to free DuUeCfg
6536  *
6537  * @params[in] DuUeCfg *ueCfg
6538  * @return void
6539  *
6540  * ****************************************************************/
6541 void freeDuUeCfg(DuUeCfg *ueCfg)
6542 {
6543    uint8_t lcIdx = 0;
6544    uint8_t arrIdx = 0;
6545    SpCellConfig_t *spCellCfg = NULLP;
6546    ServingCellConfig_t *srvCellCfg = NULLP;
6547    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6548    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6549    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6550    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6551    struct RLC_Config *rlcConfig = NULLP;
6552    struct LogicalChannelConfig *macLcConfig = NULLP;
6553    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6554    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6555    struct TAG_Config *tagConfig = NULLP;
6556    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6557    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6558    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6559    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6560
6561    if(ueCfg->ueNrCapability)
6562    {
6563       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6564       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6565       ueCfg->ueNrCapability = NULLP;
6566    }
6567
6568    if(ueCfg->cellGrpCfg)
6569    {
6570
6571       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6572       if(rlcBearerList)
6573       {
6574          if(rlcBearerList->list.array)
6575          {
6576             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6577             {
6578                if(rlcBearerList->list.array[arrIdx])
6579                {
6580                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6581                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6582
6583                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6584                   {
6585                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6586                   }
6587                   if(rlcConfig)
6588                   {
6589                      if(rlcConfig->choice.am)
6590                      {
6591                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6592                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6593                         free(rlcConfig->choice.am);
6594                      }
6595                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6596                   }
6597                   if(macLcConfig)
6598                   {
6599                      if(macLcConfig->ul_SpecificParameters)
6600                      {
6601                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6602                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6603                         free(macLcConfig->ul_SpecificParameters);
6604                      }
6605                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6606                   }
6607                   free(rlcBearerList->list.array[arrIdx]);
6608                }
6609             }
6610             free(rlcBearerList->list.array);
6611          }
6612          free(cellGrpCfg->rlc_BearerToAddModList);
6613       }
6614
6615       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6616       if(macCellGrpCfg)
6617       {
6618          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6619          if(schedulingRequestConfig)
6620          {
6621             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6622             if(schReqList)
6623             {
6624                if(schReqList->list.array)
6625                {
6626                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6627                   {
6628                      if(schReqList->list.array[arrIdx])
6629                      {
6630                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6631                         free(schReqList->list.array[arrIdx]);
6632                      }
6633                   }
6634                   free(schReqList->list.array);
6635                }
6636                free(schedulingRequestConfig->schedulingRequestToAddModList);
6637             }
6638             free(macCellGrpCfg->schedulingRequestConfig);
6639          }
6640          if(macCellGrpCfg->bsr_Config)
6641          {
6642             free(macCellGrpCfg->bsr_Config);
6643          }
6644          tagConfig = macCellGrpCfg->tag_Config;
6645          if(tagConfig)
6646          {
6647             tagList = tagConfig->tag_ToAddModList;
6648             if(tagList)
6649             {
6650                if(tagList->list.array)
6651                {
6652                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6653                   {
6654                      free(tagList->list.array[arrIdx]);
6655                   }
6656                   free(tagList->list.array);
6657                }
6658                free(tagConfig->tag_ToAddModList);
6659             }
6660             free(tagConfig);
6661          }
6662
6663          phrConfig = macCellGrpCfg->phr_Config;
6664          if(phrConfig)
6665          {
6666             free(phrConfig->choice.setup);
6667             free(phrConfig);
6668          }
6669
6670          free(macCellGrpCfg);
6671       }
6672
6673       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6674       if(phyCellGrpCfg)
6675       {
6676          free(phyCellGrpCfg->p_NR_FR1);
6677          free(phyCellGrpCfg);
6678       }
6679
6680       spCellCfg = cellGrpCfg->spCellConfig;
6681       if(spCellCfg)
6682       {
6683          if(spCellCfg->servCellIndex)
6684          {
6685             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6686             {
6687                if(spCellCfg->spCellConfigDedicated)
6688                {
6689                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6690                   if(srvCellCfg->initialDownlinkBWP)
6691                   {
6692                      dlBwp = srvCellCfg->initialDownlinkBWP;
6693                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6694                      {
6695                         if(srvCellCfg->defaultDownlinkBWP_Id)
6696                         {
6697                            if(srvCellCfg->uplinkConfig)
6698                            {
6699
6700                               if(srvCellCfg->pdsch_ServingCellConfig)
6701                               {
6702                                  pdschCfg=
6703                                     srvCellCfg->pdsch_ServingCellConfig;
6704                                  if(pdschCfg->choice.setup)
6705                                  {
6706
6707                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6708                                     free(pdschCfg->choice.setup);
6709                                  }
6710
6711                                  free(srvCellCfg->pdsch_ServingCellConfig);
6712                               }
6713
6714                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6715                               free(srvCellCfg->uplinkConfig);
6716                            }
6717                            free(srvCellCfg->defaultDownlinkBWP_Id);
6718                         }
6719
6720                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6721                      }
6722                      if(dlBwp->pdcch_Config)
6723                      {
6724                         if(dlBwp->pdsch_Config)
6725                         {
6726                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6727                            free(dlBwp->pdsch_Config);
6728                         }
6729                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6730                         free(dlBwp->pdcch_Config);
6731                      }
6732                      free(srvCellCfg->initialDownlinkBWP);
6733                   }
6734
6735                   free(spCellCfg->spCellConfigDedicated);
6736                }
6737                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6738             }
6739             free(spCellCfg->servCellIndex);
6740          }
6741          free(spCellCfg);
6742       }
6743       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6744       ueCfg->cellGrpCfg = NULLP;
6745    }
6746    if(ueCfg->ambrCfg)
6747    {
6748       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
6749       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6750    }
6751    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6752    {
6753       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6754    }
6755    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6756    {
6757       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6758    }
6759 }
6760
6761 /*******************************************************************
6762  *
6763  * @brief Function to free UecontextSetupDb
6764  *
6765  * @details
6766  *
6767  *    Function : freeF1UeDb
6768  *
6769  *    Functionality: Function to free UecontextSetupDb
6770  *
6771  * @params[in] UecontextSetupDb *
6772  * @return void
6773  *
6774  * ****************************************************************/
6775
6776 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6777 {
6778
6779    if(f1UeDb->dlRrcMsg)
6780    {
6781       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6782       {
6783          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6784             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6785       }
6786       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
6787    }
6788    freeDuUeCfg(&f1UeDb->duUeCfg);
6789    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6790    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6791 }
6792
6793 /*******************************************************************
6794  *
6795  * @brief Function to build Am cfg Info
6796  *
6797  * @details
6798  *
6799  *    Function : extractRlcAmCfg
6800  *
6801  *    Functionality: Function to build Am cfg Info
6802  *
6803  * @params[in] AmBearerCfg *
6804  *             void *
6805  *
6806  * @return ROK/RFAILED
6807  *
6808  * ****************************************************************/
6809
6810 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6811 {
6812    if(rlcAmCfg)
6813    {
6814       /* UL AM */
6815       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6816       {
6817          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6818          /*TODO: Check the timer value when sent by real CU */
6819          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6820          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6821       }
6822
6823       /* DL AM */
6824       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6825       {
6826          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6827          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6828          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6829          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
6830          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
6831       }
6832    }
6833 }
6834
6835 /*******************************************************************
6836  *
6837  * @brief Function to build Um Bi Info
6838  *
6839  * @details
6840  *
6841  *    Function : extractRlcUmBiCfg
6842  *
6843  *    Functionality: Function to build Um Bi Info
6844  *
6845  * @params[in] UmBiDirBearerCfg *
6846  *             void *
6847  *
6848  * @return ROK/RFAILED
6849  *
6850  * ****************************************************************/
6851
6852 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
6853 {
6854    if(rlcBiCfg)
6855    {
6856       /* UL UM BI DIR Cfg */
6857       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
6858       {
6859          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
6860          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
6861       }
6862
6863       /* DL UM BI DIR Cfg */
6864       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
6865          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
6866    }
6867 }
6868
6869 /*******************************************************************
6870  *
6871  * @brief Function to build Um Ul Info
6872  *
6873  * @details
6874  *
6875  *    Function : extractRlcUmUlCfg
6876  *
6877  *    Functionality: Function to build Um Ul Info
6878  *
6879  * @params[in] UmUniDirUlBearerCfg *
6880  *             void *
6881  *
6882  * @return ROK/RFAILED
6883  *
6884  * ****************************************************************/
6885
6886 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
6887 {
6888    if(umUlCfg)
6889    {
6890       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
6891       {
6892          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
6893          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
6894       }
6895    }
6896 }
6897
6898 /*******************************************************************
6899  *
6900  * @brief Function to build Um Uni Dl Info
6901  *
6902  * @details
6903  *
6904  *    Function : extractRlcUmDlCfg
6905  *
6906  *    Functionality: Function to build Um Uni Dl Info
6907  *
6908  * @params[in] UmUniDirDlBearerCfg *
6909  *             void *
6910  *
6911  * @return ROK/RFAILED
6912  *
6913  * ****************************************************************/
6914 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
6915 {
6916    if(umDlCfg)
6917    {
6918       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
6919          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
6920    }
6921 }
6922
6923 /*******************************************************************
6924  *
6925  * @brief Function to extractRlcModeCfg
6926  *
6927  * @details
6928  *
6929  *    Function : extractRlcModeCfg
6930  *
6931  *    Functionality: Function to extractRlcModeCfg
6932  *
6933  * @params[in] RLC_Config_t *
6934  *             RlcBearerCfg *
6935  *             void  *
6936  * @return ROK/RFAILED
6937  *
6938  * ****************************************************************/
6939 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
6940 {
6941    if(lcCfg)
6942    {
6943       switch(rlcMode)
6944       {
6945          case RLC_AM :
6946             {
6947                if(lcCfg->choice.am)
6948                {
6949                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
6950                   if(rlcDbCfg->u.amCfg)
6951                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
6952                }
6953                break;
6954             }
6955          case RLC_UM_BI_DIRECTIONAL :
6956             {
6957                if(lcCfg->choice.um_Bi_Directional)
6958                {
6959                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6960                   if(rlcDbCfg->u.umBiDirCfg)
6961                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
6962                }
6963                break;
6964             }
6965          case RLC_UM_UNI_DIRECTIONAL_UL :
6966             {
6967                if(lcCfg->choice.um_Uni_Directional_DL)
6968                {
6969                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6970                   if(rlcDbCfg->u.umUniDirUlCfg)
6971                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
6972                }
6973                break;
6974             }
6975          case RLC_UM_UNI_DIRECTIONAL_DL :
6976             {
6977                if(lcCfg->choice.um_Uni_Directional_UL)
6978                {
6979                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6980                   if(rlcDbCfg->u.umUniDirDlCfg)
6981                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
6982                }
6983                break;
6984             }
6985          default:
6986             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
6987             break;
6988       }
6989    }
6990 }
6991
6992 /*******************************************************************
6993  *
6994  * @brief Function to extract extractUlLcCfg
6995  *
6996  * @details
6997  *
6998  *    Function : extractUlLcCfg
6999  *
7000  *    Functionality: Function to extract extractUlLcCfg
7001  *
7002  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7003  * @return void
7004  *
7005  * ****************************************************************/
7006
7007 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7008 {
7009    if(ulLcCfg)
7010    {
7011       if(ulLcCfg->ul_SpecificParameters)
7012       {
7013          f1UlLcCfg->priority = \
7014             ulLcCfg->ul_SpecificParameters->priority;
7015       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7016       {
7017          f1UlLcCfg->lcGroup = \
7018            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7019       }
7020       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7021       {
7022          f1UlLcCfg->schReqId = \
7023            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7024       }
7025       f1UlLcCfg->pbr = \
7026          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7027       f1UlLcCfg->bsd = \
7028          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7029       }
7030    }
7031 }
7032
7033 /*******************************************************************
7034  *
7035  * @brief Function to procRlcLcCfg
7036  *
7037  * @details
7038  *
7039  *    Function : procRlcLcCfg
7040  *
7041  *    Functionality: Function to procRlcLcCfg
7042  *
7043  * @params[in] rbId, lcId, rbType, rlcMod
7044  *             RLC_Config_t *, RlcBearerCfg * ,
7045  * @return void
7046  *
7047  * ****************************************************************/
7048
7049 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7050    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7051 {
7052
7053    lcCfg->rbId   = rbId;
7054    lcCfg->configType = configType;
7055
7056    if(rbType == RB_TYPE_SRB)
7057    {
7058       lcCfg->rbType = RB_TYPE_SRB;
7059       lcCfg->lcId   = rbId;
7060       lcCfg->lcType = LCH_DCCH;
7061       lcCfg->rlcMode = RLC_AM;
7062    }
7063    else if(rbType == RB_TYPE_DRB)
7064    {
7065       lcCfg->rbType = RB_TYPE_DRB;
7066       lcCfg->lcId   = lcId;
7067       lcCfg->lcType = LCH_DTCH;
7068       lcCfg->rlcMode = rlcMode;
7069    }
7070    if(f1RlcCfg) /* rlc mode config recived */
7071    {
7072       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7073    }
7074 }
7075
7076
7077
7078 /*******************************************************************
7079  *
7080  * @brief Fills DrbQos Info received by CU
7081  *
7082  * @details
7083  *
7084  *    Function : extractQosInfo
7085  *
7086  *    Functionality: Fills DrbQos Info received  by CU
7087  *
7088  * @params[in] DrbQosInfo *qosToAdd,
7089  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7090  * @return void
7091  *
7092  * ****************************************************************/
7093
7094 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7095 {
7096    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7097    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7098          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7099    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7100    {
7101       qosToAdd->u.nonDyn5Qi.avgWindow = \
7102         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7103    }
7104    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7105       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7106    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7107    {
7108       qosToAdd->u.nonDyn5Qi.priorLevel = \
7109          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7110    }
7111    qosToAdd->ngRanRetPri.priorityLevel = \
7112       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7113    qosToAdd->ngRanRetPri.preEmptionCap = \
7114       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7115    qosToAdd->ngRanRetPri.preEmptionVul = \
7116       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7117    if(qosFlowCfg->gBR_QoS_Flow_Information)
7118    {
7119       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7120          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7121          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7122       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7123          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7124          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7125       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7126          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7127          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7128       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7129          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7130          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7131    }
7132    qosToAdd->pduSessionId = 0;
7133    qosToAdd->ulPduSessAggMaxBitRate = 0;
7134 }
7135
7136 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, LcCfg *macLcToAdd)
7137 {
7138    DRB_Information_t *drbInfo = NULLP;
7139
7140    if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7141    {
7142       if(drbItem->qoSInformation.choice.choice_extension->value.present ==
7143             QoSInformation_ExtIEs__value_PR_DRB_Information)
7144       {
7145          drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7146
7147          if(!macLcToAdd->drbQos)
7148          {
7149             DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7150             if(macLcToAdd->drbQos == NULLP)
7151             {
7152                DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7153                return RFAILED;
7154             }
7155
7156          }
7157          if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7158          {
7159             extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7160             macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7161          }
7162          if(!macLcToAdd->snssai)
7163          {
7164             DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7165             if(macLcToAdd->snssai == NULLP)
7166             {
7167                DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7168                return RFAILED;
7169             }
7170          }
7171          memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7172                drbInfo->sNSSAI.sST.size);
7173          if(drbInfo->sNSSAI.sD)
7174          {
7175             memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7176                   drbInfo->sNSSAI.sD->size);
7177          }
7178       }/*End of DRB Info*/
7179    }
7180    return ROK;
7181 }
7182
7183 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg)
7184 {
7185    uint8_t ret = ROK;
7186
7187    if(drbCfg)
7188    {
7189       ret = extractDrbCfg(drbCfg, lcCfg);
7190       if(ret == RFAILED)
7191       {
7192          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7193          return ret;
7194       }
7195    }
7196    else
7197    {
7198       lcCfg->drbQos = NULLP;
7199       lcCfg->snssai = NULLP;
7200       if(lcCfg->lcId == SRB2_LCID)
7201          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7202       else
7203          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7204    }
7205    if(ulLcCfg)
7206    {
7207       lcCfg->ulLcCfgPres = true;
7208       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7209    }
7210    else
7211       lcCfg->ulLcCfgPres = false;
7212    return ret;
7213 }
7214
7215 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7216    DRBs_ToBeSetup_Item_t *drbItem, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg)
7217 {
7218    uint8_t ret = ROK;
7219
7220    lcCfg->lcId = lcId;
7221    lcCfg->configType = configType;
7222    if(rbType == RB_TYPE_SRB)
7223    {
7224       ret = extractMacRbCfg(lcId, NULL, ulLcCfg, lcCfg);
7225    }
7226    else if(rbType == RB_TYPE_DRB)
7227    {
7228       ret = extractMacRbCfg(lcId, drbItem, ulLcCfg, lcCfg);
7229    }
7230    return ret;
7231 }
7232
7233 /*******************************************************************
7234  *
7235  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7236  *
7237  * @details
7238  *
7239  *    Function : extractRlcCfgToAddMod
7240  *
7241  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7242  *
7243  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7244  *             DuUeCfg Pointer
7245  * @return ROK/RFAILED
7246  *
7247  * ****************************************************************/
7248
7249 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, \
7250    DuUeCfg *ueCfgDb)
7251 {
7252   uint8_t ret, idx, rbId, lcId, rlcMode, rbType;
7253   RLC_Config_t *f1RlcCfg = NULLP;
7254   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7255
7256   for(idx = 0; idx < lcCfg->list.count; idx++)
7257   {
7258      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7259      if(lcCfg->list.array[idx]->servedRadioBearer)
7260      {
7261         /* RadioBearer for SRB/DRB */
7262         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7263         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7264         {
7265            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7266            rbType = RB_TYPE_SRB;
7267         }
7268         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7269         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7270         {
7271            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7272            rbType = RB_TYPE_DRB;
7273         }
7274         else
7275         {
7276            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7277            return RFAILED;
7278         }
7279         /* MAC UL LC Config */
7280         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7281         {
7282            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7283         }
7284      }
7285      else
7286      {
7287         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7288         return RFAILED;
7289      }
7290      /* RLC Mode Config */
7291      if(lcCfg->list.array[idx]->rlc_Config)
7292      {
7293         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7294         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7295      }
7296
7297      /* Filling RLC/MAC Config*/
7298      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7299      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7300      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7301      ret = procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx]);
7302      if(ret == RFAILED)
7303      {
7304         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7305         return ret;
7306      }
7307      (ueCfgDb->numRlcLcs)++;
7308      (ueCfgDb->numMacLcs)++;
7309   }
7310   //TODO: To send the failure cause in UeContextSetupRsp
7311   return ret;
7312 }
7313
7314 /*******************************************************************
7315  *
7316  * @brief DeAlloc pdsch serv cell config info
7317  *
7318  * @details
7319  *
7320  *    Function : freeMacPdschServCellInfo
7321  *
7322  *    Functionality: DeAlloc pdsch serv cell config info
7323  *
7324  * @params[in] PdschServCellCfg pointer
7325  * @return void
7326  *
7327  * ****************************************************************/
7328
7329 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7330 {
7331    if(pdsch->xOverhead)
7332    {
7333       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(uint8_t));
7334    }
7335    if(pdsch->codeBlkGrpFlushInd)
7336    {
7337       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7338    }
7339    if(pdsch->maxCodeBlkGrpPerTb)
7340    {
7341       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7342    }
7343    if(pdsch->maxMimoLayers)
7344    {
7345       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7346    }
7347 }
7348
7349 /*******************************************************************
7350  *
7351  * @brief Free Serving cell Info
7352  *
7353  * @details
7354  *
7355  *    Function : freeMacServingCellInfo
7356  *
7357  *    Functionality: Free Serving cell Info
7358  *
7359  * @params[in] ServCellCfgInfo *srvCellCfg
7360  * @return void
7361  *
7362  * ****************************************************************/
7363 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7364 {
7365    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7366    if(srvCellCfg->bwpInactivityTmr)
7367    {
7368       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7369    }
7370 }
7371
7372 /*******************************************************************
7373  *
7374  * @brief Free cell Grp Cfg Info
7375  *
7376  * @details
7377  *
7378  *    Function : freeUeReCfgCellGrpInfo
7379  *
7380  *    Functionality: Free cell Grp Cfg Info
7381  *
7382  * @params[in] MacUeCfg*  duUeCfg
7383  * @return void
7384  *
7385  * ****************************************************************/
7386
7387 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7388 {
7389    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7390 }
7391
7392 /*******************************************************************
7393  *
7394  * @brief Fills Reconfig SchReqReConfig
7395  *
7396  * @details
7397  *
7398  *    Function : extractSchReqReConfig
7399  *
7400  *    Functionality: Fills Reconfig SchReqReConfig
7401  *
7402  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7403  *             SchedReqCfg*  macSchedReq
7404  * @return void
7405  *
7406  * ****************************************************************/
7407 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7408 {
7409    uint8_t schReqIdx = 0;
7410    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7411    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7412
7413    if(cuSchedReq->schedulingRequestToAddModList)
7414    {
7415       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7416       if(schReqListToAdd->list.count)
7417       {
7418          macSchedReq->addModListCount = schReqListToAdd->list.count;
7419          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7420          {
7421             macSchedReq->addModList[schReqIdx].schedReqId = \
7422                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7423             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7424                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7425             macSchedReq->addModList[schReqIdx].srTransMax    =\
7426                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7427          }
7428       }
7429    }
7430    /* Scheduling Req To release */
7431    if(cuSchedReq->schedulingRequestToReleaseList)
7432    {
7433       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7434       if(schReqListToRel->list.count)
7435       {
7436          macSchedReq->relListCount = schReqListToRel->list.count;
7437          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7438          {
7439             macSchedReq->relList[schReqIdx] = \
7440                *schReqListToRel->list.array[schReqIdx];
7441          }
7442       }
7443    }
7444 }
7445
7446 /*******************************************************************
7447  *
7448  * @brief Fills TagReconfig
7449  *
7450  * @details
7451  *
7452  *    Function : extractTagReconfig
7453  *
7454  *    Functionality: Fills extractTagReconfig
7455  *
7456  * @params[in] TAG_Config_t *cuTagCfg
7457  *             TagCfg *macTagCfg
7458  * @return void
7459  *
7460  * ****************************************************************/
7461
7462 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7463 {
7464   uint8_t tagIdx = 0;
7465   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7466   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7467
7468   /* Tag config to AddMod */
7469   if(cuTagCfg->tag_ToAddModList)
7470   {
7471      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7472      if(tagListToAddMod->list.count)
7473      {
7474         macTagCfg->addModListCount = tagListToAddMod->list.count;
7475         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7476         {
7477            macTagCfg->addModList[tagIdx].tagId =\
7478               tagListToAddMod->list.array[tagIdx]->tag_Id;
7479            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7480
7481               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7482         }
7483      }
7484   }
7485   /* Tag config to release */
7486   if(cuTagCfg->tag_ToReleaseList)
7487   {
7488      tagListToRel = cuTagCfg->tag_ToReleaseList;
7489      if(tagListToRel->list.count)
7490      {
7491         macTagCfg->relListCount = tagListToRel->list.count;
7492         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7493         {
7494            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7495         }
7496      }
7497   }
7498 }
7499
7500 /*******************************************************************
7501  *
7502  * @brief Fills PdcchCfg received by CU
7503  *
7504  * @details
7505  *
7506  *    Function : extractPdcchCfg
7507  *
7508  *    Functionality: Fills PdcchCfg received  by CU
7509  *
7510  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7511  *             PdcchConfig *duPdcchCfg
7512  * @return void
7513  *
7514  * ****************************************************************/
7515
7516 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7517 {
7518    uint8_t cRsetIdx = 0;
7519    uint8_t srchSpcIdx = 0;
7520
7521    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7522    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7523    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7524    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7525
7526
7527    /* Control Resource Set To Add/Mod List */
7528    if(cuPdcchCfg->controlResourceSetToAddModList)
7529    {
7530       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7531       if(cRsetToAddModList->list.count)
7532       {
7533          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7534          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7535          {
7536             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7537               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7538             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7539                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7540             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7541               cRsetToAddModList->list.array[cRsetIdx]->duration;
7542
7543             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7544               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7545             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7546             {
7547                //TODO: handle the case for Interleaved
7548             }
7549             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7550               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7551             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7552             {
7553                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7554                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7555             }
7556          }
7557       }
7558
7559    }
7560    /* Control Resource Set To Release List */
7561    if(cuPdcchCfg->controlResourceSetToReleaseList)
7562    {
7563       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7564       if(cRsetToRelList->list.count)
7565       {
7566          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7567          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7568          {
7569             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7570          }
7571       }
7572    }
7573
7574    /* Search space To Add/Mod List */
7575    if(cuPdcchCfg->searchSpacesToAddModList)
7576    {
7577       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7578       if(srchSpcToAddModList->list.count)
7579       {
7580          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7581          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7582          {
7583             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7584                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7585             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7586                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7587             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7588             {
7589                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7590                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7591             }
7592             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7593             {
7594                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7595                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7596             }
7597             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7598             {
7599               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7600                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7601               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7602                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7603               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7604                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7605
7606               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7607                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7608
7609               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7610                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7611             }
7612             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7613             {
7614                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7615                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7616                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7617                {
7618                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7619                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7620                }
7621
7622             }
7623          }
7624       }
7625    }
7626    /* Search space To Rel List */
7627    if(cuPdcchCfg->searchSpacesToReleaseList)
7628    {
7629       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7630       if(srchSpcToRelList->list.count)
7631       {
7632          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7633          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7634          {
7635             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7636                *(srchSpcToRelList->list.array[srchSpcIdx]);
7637          }
7638       }
7639    }
7640 }
7641
7642 /*******************************************************************
7643  *
7644  * @brief Fills PdschCfg received by CU
7645  *
7646  * @details
7647  *
7648  *    Function : extractPdschCfg
7649  *
7650  *    Functionality: Fills PdschCfg received  by CU
7651  *
7652  * @params[in] PDSCH_Config_t *cuPdschCfg,
7653  *             PdschConfig *macPdschCfg
7654  * @return void
7655  *
7656  * ****************************************************************/
7657
7658 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7659 {
7660    uint8_t timeDomIdx;
7661    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7662
7663    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7664    {
7665       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7666          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7667       {
7668          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
7669          {
7670             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
7671                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
7672          }
7673       }
7674    }
7675    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
7676    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
7677    {
7678       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
7679       if(timeDomAlloc->present ==\
7680          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
7681       {
7682          if(timeDomAlloc->choice.setup)
7683          {
7684             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
7685             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
7686             {
7687                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
7688                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
7689                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
7690                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7691             }
7692          }
7693       }
7694    }
7695    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
7696    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
7697       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
7698    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
7699    {
7700       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7701       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
7702       {
7703          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
7704          {
7705             macPdschCfg->bundlingInfo.StaticBundling.size = \
7706                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
7707          }
7708       }
7709    }
7710    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
7711    {
7712       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
7713    }
7714
7715 }
7716
7717 /*******************************************************************
7718  *
7719  * @brief Fills PdschServingCellCfg received by CU
7720  *
7721  * @details
7722  *
7723  *    Function : extractPdschServingCellCfg
7724  *
7725  *    Functionality: Fills PdschCfg received  by CU
7726  *
7727  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
7728  *             PdschServCellCfg *macUePdschSrvCellCfg
7729  * @return ROK/RFAILED
7730  *
7731  * ****************************************************************/
7732
7733 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
7734 {
7735    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
7736    {
7737       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
7738       {
7739          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7740          {
7741             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7742                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7743          }
7744          else
7745          {
7746             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(uint8_t));
7747             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
7748             {
7749                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
7750                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
7751             }
7752             else
7753             {
7754                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
7755                return RFAILED;
7756             }
7757          }
7758          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7759          {
7760             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7761                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7762          }
7763          else
7764          {
7765             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(bool));
7766             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
7767             {
7768                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
7769                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
7770             }
7771             else
7772             {
7773                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
7774                return RFAILED;
7775             }
7776          }
7777       }
7778    }
7779    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
7780    {
7781       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
7782    }
7783    if(cuPdschSrvCellCfg->ext1)
7784    {
7785       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
7786       {
7787         if(macUePdschSrvCellCfg->maxMimoLayers)
7788         {
7789            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7790         }
7791         else
7792         {
7793            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
7794            if(macUePdschSrvCellCfg->maxMimoLayers)
7795            {
7796               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
7797            }
7798            else
7799            {
7800               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
7801               return RFAILED;
7802            }
7803         }
7804       }
7805    }
7806    if(cuPdschSrvCellCfg->xOverhead)
7807    {
7808       if(macUePdschSrvCellCfg->xOverhead)
7809       {
7810          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7811       }
7812       else
7813       {
7814          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(uint8_t));
7815          if(macUePdschSrvCellCfg->xOverhead)
7816          {
7817             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
7818          }
7819          else
7820          {
7821             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
7822             return RFAILED;
7823          }
7824       }
7825    }
7826    return ROK;
7827 }
7828
7829 /*******************************************************************
7830  *
7831  * @brief Fills PuschCfg received by CU
7832  *
7833  * @details
7834  *
7835  *    Function : extractPuschCfg
7836  *
7837  *    Functionality: Fills PuschCfg received  by CU
7838  *
7839  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
7840  *             PuschCfg *macPuschCfg
7841  * @return void
7842  *
7843  * ****************************************************************/
7844
7845 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
7846 {
7847    uint8_t timeDomIdx = 0;
7848    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
7849    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
7850
7851    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
7852    {
7853       if(cuPuschCfg->choice.setup)
7854       {
7855          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
7856          {
7857              macPuschCfg->dataScramblingId = \
7858                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
7859          }
7860          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
7861          {
7862             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
7863             {
7864                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
7865                {
7866                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
7867                   if(dmrsUlCfg->dmrs_AdditionalPosition)
7868                   {
7869                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
7870                         *(dmrsUlCfg->dmrs_AdditionalPosition);
7871                   }
7872                   if(dmrsUlCfg->transformPrecodingDisabled)
7873                   {
7874                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
7875                      {
7876                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
7877                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
7878                      }
7879                   }
7880                }
7881             }
7882          }
7883          /*Res Alloc Type for UL */
7884          if(cuPuschCfg->choice.setup->resourceAllocation)
7885          {
7886             macPuschCfg->resourceAllocType = \
7887                cuPuschCfg->choice.setup->resourceAllocation;
7888          }
7889          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
7890          {
7891             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
7892             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
7893             {
7894                if(timeDomAllocList->choice.setup)
7895                {
7896                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
7897                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
7898                   {
7899                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
7900                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
7901                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
7902                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
7903                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
7904                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
7905                   }
7906                }
7907             }
7908          }
7909          if(cuPuschCfg->choice.setup->transformPrecoder)
7910             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
7911       }
7912    }
7913 }
7914
7915 /*******************************************************************
7916  *
7917  * @brief Function to fill pucch Power Control
7918  *
7919  * @details
7920  *
7921  *    Function : extractPucchPowerControl
7922  *
7923  *    Functionality: Function to fill pucch Power Control
7924  *
7925  * @params[in] PucchPowerControl *pwrCtrl,
7926  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
7927  * @return void
7928  *
7929  * ****************************************************************/
7930
7931 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
7932 {
7933    uint8_t arrIdx;
7934
7935    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
7936       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
7937    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
7938       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
7939    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
7940       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
7941    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
7942       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
7943    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
7944       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
7945    if(cuPwrCtrlCfg->p0_Set)
7946    {
7947       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
7948       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
7949       {
7950          pwrCtrl->p0Set[arrIdx].p0PucchId =\
7951             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
7952          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
7953             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
7954       }
7955    }
7956    if(cuPwrCtrlCfg->pathlossReferenceRSs)
7957    {
7958       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
7959       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
7960       {
7961          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
7962             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
7963       }
7964    }
7965 }
7966
7967  /*******************************************************************
7968  *
7969  * @brief Function to extractResrcSetToAddModList sent by CU
7970  *
7971  * @details
7972  *
7973  *    Function : extractResrcSetToAddModList
7974  *
7975  *    Functionality: Fucntion to extractResrcSetToAddModList
7976  *
7977  * @params[in] PucchResrcSetCfg pointer,
7978  *             struct PUCCH_Config__resourceSetToAddModList pointer
7979  * @return void
7980  *
7981  * ****************************************************************/
7982
7983 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
7984 {
7985    uint8_t arrIdx, rsrcListIdx;
7986
7987    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
7988    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
7989    {
7990       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
7991          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
7992       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
7993          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
7994       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
7995       {
7996          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
7997             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
7998       }
7999       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8000          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8001    }
8002 }/* End of extractResrcSetToAddModList */
8003
8004 /*******************************************************************
8005  *
8006  * @brief Fills extractResrcToAddModList sent by CU
8007  *
8008  * @details
8009  *
8010  *    Function : extractResrcToAddModList
8011  *
8012  *    Functionality: Fills extractResrcToAddModList
8013  *
8014  * @params[in] PucchResrcCfg pointer,
8015  *             struct PUCCH_Config__resourceToAddModList pointer
8016  * @return ROk/RFAILED
8017  *
8018  * ****************************************************************/
8019
8020 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8021 {
8022    uint8_t arrIdx;
8023
8024    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8025    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8026    {
8027       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8028         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8029       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8030         cuResrcList->list.array[arrIdx]->startingPRB;
8031       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8032       {
8033          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8034            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8035       }
8036       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8037       {
8038          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8039            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8040       }
8041       /* PUCCH RSRC FORMAT */
8042       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8043       {
8044          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8045          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8046          {
8047             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8048             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8049             {
8050                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8051                return RFAILED;
8052             }
8053             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8054                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8055             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8056                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8057             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8058                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8059          }
8060       }
8061       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8062       {
8063          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8064          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8065          {
8066             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8067             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8068             {
8069                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8070                return RFAILED;
8071             }
8072             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8073                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8074             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8075                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8076             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8077                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8078             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8079                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8080          }
8081       }
8082       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8083       {
8084          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8085          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8086          {
8087             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8088             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8089             {
8090                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8091                return RFAILED;
8092             }
8093             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8094                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8095             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8096                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8097             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8098                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8099          }
8100       }
8101       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8102       {
8103          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8104          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8105          {
8106             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8107             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8108             {
8109                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8110                return RFAILED;
8111             }
8112             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8113                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8114             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8115                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8116             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8117                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8118          }
8119       }
8120       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8121       {
8122          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8123          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8124          {
8125             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8126             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8127             {
8128                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8129                return RFAILED;
8130             }
8131             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8132                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8133             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8134                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8135             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8136                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8137             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8138                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8139          }
8140       }
8141    }
8142    return ROK;
8143
8144 }/* End of extractResrcToAddModList */
8145
8146 /*******************************************************************
8147  *
8148  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8149  *
8150  * @details
8151  *
8152  *    Function : fillPucchSchedReqPeriodAndOffset
8153  *
8154  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8155  *
8156  * @params[in] macPeriodicty,
8157  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8158  * @return void
8159  *
8160  * ****************************************************************/
8161
8162 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8163    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8164 {
8165    macPeriodicty = cuPeriodicty->present;
8166    switch(macPeriodicty)
8167    {
8168       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8169          {
8170             macOffset     = cuPeriodicty->choice.sym2;
8171             break;
8172          }
8173       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8174          {
8175             macOffset     = cuPeriodicty->choice.sym6or7;
8176             break;
8177          }
8178       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8179          {
8180             macOffset     = cuPeriodicty->choice.sl1;
8181             break;
8182          }
8183       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8184          {
8185             macOffset = cuPeriodicty->choice.sl2;
8186             break;
8187          }
8188       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8189          {
8190             macOffset = cuPeriodicty->choice.sl4;
8191             break;
8192          }
8193       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8194          {
8195             macOffset = cuPeriodicty->choice.sl5;
8196             break;
8197          }
8198       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8199          {
8200             macOffset = cuPeriodicty->choice.sl8;
8201             break;
8202          }
8203       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8204          {
8205             macOffset = cuPeriodicty->choice.sl10;
8206             break;
8207          }
8208       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8209          {
8210             macOffset = cuPeriodicty->choice.sl16;
8211             break;
8212          }
8213       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8214          {
8215             macOffset = cuPeriodicty->choice.sl20;
8216             break;
8217          }
8218       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8219          {
8220             macOffset = cuPeriodicty->choice.sl40;
8221             break;
8222          }
8223       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8224          {
8225             macOffset = cuPeriodicty->choice.sl80;
8226             break;
8227          }
8228       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8229          {
8230             macOffset = cuPeriodicty->choice.sl160;
8231             break;
8232          }
8233       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8234          {
8235             macOffset = cuPeriodicty->choice.sl320;
8236             break;
8237          }
8238       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8239          {
8240             macOffset = cuPeriodicty->choice.sl640;
8241             break;
8242          }
8243       default :
8244          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8245    }
8246 }
8247
8248 /*******************************************************************
8249  *
8250  * @brief Function to extractPucchFormatCfg sent by CU
8251  *
8252  * @details
8253  *
8254  *    Function : extractPucchFormatCfg
8255  *
8256  *    Functionality: Function to extractPucchFormatCfg
8257  *
8258  * @params[in] PucchFormatCfg pointer,
8259  *             PUCCH_FormatConfig_t pointer
8260  * @return void
8261  *
8262  * ****************************************************************/
8263
8264 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8265  {
8266     if(cuFormatCfg->interslotFrequencyHopping)
8267        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8268     if(cuFormatCfg->additionalDMRS)
8269        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8270     if(cuFormatCfg->maxCodeRate)
8271        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8272     if(cuFormatCfg->nrofSlots)
8273        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8274     if(cuFormatCfg->pi2BPSK)
8275        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8276     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8277        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8278  }/* End of extractPucchFormatCfg */
8279
8280 /*******************************************************************
8281  *
8282  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8283  *
8284  * @details
8285  *
8286  *    Function : extractSchedReqCfgToAddMod
8287  *
8288  *    Functionality: Function to extractSchedReqCfgToAddMod
8289  *
8290  * @params[in] PucchSchedReqCfg pointer,
8291  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8292  * @return void
8293  *
8294  * ****************************************************************/
8295
8296 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8297 {
8298    uint8_t arrIdx;
8299
8300    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8301    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8302    {
8303       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8304          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8305       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8306          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8307       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8308       {
8309          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8310             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8311       }
8312       if(cuSchedReqList->list.array[arrIdx]->resource)
8313       {
8314          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8315             *cuSchedReqList->list.array[arrIdx]->resource;
8316       }
8317    }
8318
8319 }/* End of extractSchedReqCfgToAddMod */
8320
8321  /*******************************************************************
8322  *
8323  * @brief Fills PucchCfg received by CU
8324  *
8325  * @details
8326  *
8327  *    Function : extractPucchCfg
8328  *
8329  *    Functionality: Fills PucchCfg received  by CU
8330  *
8331  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8332  *             PucchCfg *macPucchCfg
8333  * @return ROK/RFAILED
8334  *
8335  * ****************************************************************/
8336
8337 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8338 {
8339    uint8_t arrIdx;
8340
8341    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8342    {
8343       if(cuPucchCfg->choice.setup)
8344       {
8345          /* Resource Set Cfg */
8346          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8347          {
8348             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8349             if(macPucchCfg->resrcSet == NULLP)
8350             {
8351                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8352                return RFAILED;
8353             }
8354             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8355             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8356          }
8357
8358          /* Resource Cfg */
8359          if(cuPucchCfg->choice.setup->resourceToAddModList)
8360          {
8361             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8362             if(macPucchCfg->resrc == NULLP)
8363             {
8364                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8365                return RFAILED;
8366             }
8367             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8368             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8369          }
8370
8371          /* Format 1 Cfg */
8372          if(cuPucchCfg->choice.setup->format1)
8373          {
8374             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8375             if(macPucchCfg->format1 == NULLP)
8376             {
8377                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8378                return RFAILED;
8379             }
8380             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8381             extractPucchFormatCfg(macPucchCfg->format1,\
8382                cuPucchCfg->choice.setup->format1->choice.setup);
8383          }
8384
8385          /* Format 2 Cfg */
8386          if(cuPucchCfg->choice.setup->format2)
8387          {
8388             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8389             if(macPucchCfg->format2 == NULLP)
8390             {
8391                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8392                return RFAILED;
8393             }
8394             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8395             extractPucchFormatCfg(macPucchCfg->format2,\
8396                cuPucchCfg->choice.setup->format2->choice.setup);
8397          }
8398
8399          /* Format 3 Cfg */
8400          if(cuPucchCfg->choice.setup->format3)
8401          {
8402             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8403             if(macPucchCfg->format3 == NULLP)
8404             {
8405                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8406                return RFAILED;
8407             }
8408             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8409             extractPucchFormatCfg(macPucchCfg->format3,\
8410                cuPucchCfg->choice.setup->format3->choice.setup);
8411          }
8412
8413          /* Format 4 Cfg */
8414          if(cuPucchCfg->choice.setup->format4)
8415          {
8416             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8417             if(macPucchCfg->format4 == NULLP)
8418             {
8419                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8420                return RFAILED;
8421             }
8422             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8423             extractPucchFormatCfg(macPucchCfg->format4,\
8424                cuPucchCfg->choice.setup->format4->choice.setup);
8425          }
8426
8427          /* Sched Req List */
8428          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8429          {
8430             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8431             if(macPucchCfg->schedReq == NULLP)
8432             {
8433                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8434                return RFAILED;
8435             }
8436             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8437             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8438             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8439          }
8440
8441          /*TODO: Add support for  Spatial Info */
8442
8443          /* MultiCsiCfg */
8444          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8445          {
8446             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8447             if(macPucchCfg->multiCsiCfg == NULLP)
8448             {
8449                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8450                return RFAILED;
8451             }
8452             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8453             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8454             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8455             {
8456                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8457                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8458             }
8459          }
8460
8461          /* Dl_DataToUL_ACK */
8462          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8463          {
8464             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8465             if(macPucchCfg->dlDataToUlAck == NULLP)
8466             {
8467                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8468                return RFAILED;
8469             }
8470             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8471             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8472             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8473             {
8474                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8475                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8476             }
8477          }
8478
8479          /* Power Control */
8480          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8481          {
8482             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8483             if(macPucchCfg->powerControl == NULLP)
8484             {
8485                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8486                return RFAILED;
8487             }
8488             extractPucchPowerControl(macPucchCfg->powerControl,\
8489                cuPucchCfg->choice.setup->pucch_PowerControl);
8490          }
8491       }
8492    }
8493    return ROK;
8494 }
8495
8496 /*******************************************************************
8497  *
8498  * @brief Fills ServingCellReconfig received by CU
8499  *
8500  * @details
8501  *
8502  *    Function : extractSpCellDedicatedCfg
8503  *
8504  *    Functionality: Fills ServingCellReconfig received  by CU
8505  *
8506  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8507  *             ServCellCfgInfo *macSrvCellCfg
8508  * @return ROK/RFAILD
8509  *
8510  * ****************************************************************/
8511 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8512 {
8513    uint8_t ret = ROK;
8514    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8515    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8516
8517    if(cuSrvCellCfg->initialDownlinkBWP)
8518    {
8519       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8520       if(dlBwp->pdcch_Config)
8521       {
8522          if(dlBwp->pdcch_Config->choice.setup)
8523          {
8524             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8525             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8526          }
8527       }
8528       if(dlBwp->pdsch_Config)
8529       {
8530          if(dlBwp->pdsch_Config->choice.setup)
8531          {
8532             macSrvCellCfg->initDlBwp.pdschPresent = true;
8533             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8534          }
8535       }
8536    }
8537    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8538       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8539    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8540       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8541    if(cuSrvCellCfg->bwp_InactivityTimer)
8542    {
8543       if(macSrvCellCfg->bwpInactivityTmr)
8544       {
8545          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8546       }
8547       else
8548       {
8549          macSrvCellCfg->bwpInactivityTmr = NULLP;
8550          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8551          if(macSrvCellCfg->bwpInactivityTmr)
8552          {
8553             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8554          }
8555          else
8556          {
8557             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8558             return RFAILED;
8559          }
8560       }
8561    }
8562    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8563    {
8564       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8565       {
8566          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8567          if(ret == RFAILED)
8568          {
8569             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8570             return RFAILED;
8571          }
8572       }
8573    }
8574    if(cuSrvCellCfg->uplinkConfig)
8575    {
8576      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8577      {
8578         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8579         if(ulBwp->pusch_Config)
8580         {
8581            macSrvCellCfg->initUlBwp.puschPresent = true;
8582            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8583         }
8584         if(ulBwp->pucch_Config)
8585         {
8586            macSrvCellCfg->initUlBwp.pucchPresent = true;
8587            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8588            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8589         }
8590      }
8591      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8592         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8593    }
8594    return ret;
8595 }
8596 /*******************************************************************
8597  *
8598  * @brief Fills Reconfig Cell group Info received by CU
8599  *
8600  * @details
8601  *
8602  *    Function : extractUeReCfgCellInfo
8603  *
8604  *    Functionality: Fills Reconfig Cell group Info received by CU
8605  *
8606  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8607  *             MacUeCfg*  macUeCfg
8608  * @return ROK/RFAILED
8609  *
8610  * ****************************************************************/
8611 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8612 {
8613    uint8_t ret = ROK;
8614    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8615    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8616    SpCellConfig_t            *spcellCfg = NULLP;
8617    ServingCellConfig_t       *servCellCfg = NULLP;
8618
8619    if(cellGrp)
8620    {
8621       /* Fill MacCell Group Reconfig  */
8622       if(cellGrp->mac_CellGroupConfig)
8623       {
8624          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8625          if(macCellGroup->schedulingRequestConfig)
8626          {
8627             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8628          }
8629          if(macCellGroup->tag_Config)
8630          {
8631             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8632          }
8633          if(macCellGroup->bsr_Config)
8634          {
8635             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8636             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8637             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8638             {
8639                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8640                   *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8641             }
8642          }
8643          if(macCellGroup->phr_Config)
8644          {
8645             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8646             {
8647                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8648                if(macCellGroup->phr_Config->choice.setup)
8649                {
8650                 macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8651                    macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8652                 macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8653                    macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8654                 macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8655                    macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8656                 macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8657                    macCellGroup->phr_Config->choice.setup->multiplePHR;
8658                 macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8659                    macCellGroup->phr_Config->choice.setup->dummy;
8660                 macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8661                    macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8662                 macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8663                    macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8664                }
8665             }
8666          }
8667       }
8668       /* Fill Physical Cell Group Reconfig */
8669       if(cellGrp->physicalCellGroupConfig)
8670       {
8671          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
8672          if(phyCellGrpCfg->p_NR_FR1)
8673          {
8674             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
8675                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
8676          }
8677          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
8678       }
8679       /* Fill SpCell Reconfig */
8680       if(cellGrp->spCellConfig)
8681       {
8682          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
8683          if(spcellCfg->servCellIndex)
8684          {
8685             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
8686          }
8687          /* Fill Serving cell Reconfig info */
8688          if(cellGrp->spCellConfig->spCellConfigDedicated)
8689          {
8690             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
8691             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
8692             if(ret == RFAILED)
8693             {
8694                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
8695             }
8696          }
8697       }
8698    }
8699    return ret;
8700 }
8701 /*******************************************************************
8702 *
8703 * @brief free the memory allocated by decoder
8704 *
8705 * @details
8706 *
8707 *    Function : freeAperDecodeNrcgi
8708 *
8709 *    Functionality: Free Nrcgi values
8710 *
8711 * @params[in] NRCGI_t *nrcgi
8712 * @return void
8713 *
8714 * ****************************************************************/
8715
8716
8717 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
8718 {
8719     if(nrcgi->pLMN_Identity.buf != NULLP)
8720     {
8721        free(nrcgi->pLMN_Identity.buf);
8722     }
8723     if(nrcgi->nRCellIdentity.buf != NULLP)
8724     {
8725        free(nrcgi->nRCellIdentity.buf);
8726     }
8727 }
8728 /*******************************************************************
8729 *
8730 * @brief free the memory allocated by decoder
8731 *
8732 * @details
8733 *
8734 *    Function : freeAperDecodeCuToDuInfo
8735 *
8736 *    Functionality:  Free Cu To Du Information
8737 *
8738 * @params[in] CUtoDURRCInformation_t *rrcMsg
8739 * @return void
8740 *
8741 * ****************************************************************/
8742
8743
8744 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
8745 {
8746    uint8_t ieIdx =0;
8747    uint8_t arrIdx =0;
8748
8749    if(rrcMsg->uE_CapabilityRAT_ContainerList)
8750    {
8751       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
8752          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
8753       free(rrcMsg->uE_CapabilityRAT_ContainerList);
8754    }
8755
8756    if(rrcMsg->iE_Extensions)
8757    {
8758       if(rrcMsg->iE_Extensions->list.array)
8759       {
8760          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
8761          {
8762             if(rrcMsg->iE_Extensions->list.array[ieIdx])
8763             {
8764                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
8765                {
8766                   case ProtocolIE_ID_id_CellGroupConfig:
8767                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
8768                      {
8769                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
8770                      }
8771                      break;
8772                   default:
8773                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
8774                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
8775                      break;
8776                }
8777             }
8778          }
8779          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8780          {
8781             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
8782          }
8783          free(rrcMsg->iE_Extensions->list.array);
8784
8785       }
8786
8787       free(rrcMsg->iE_Extensions);
8788    }
8789 }
8790 /*******************************************************************
8791 *
8792 * @brief free the memory allocated by decoder
8793 *
8794 * @details
8795 *
8796 *    Function : freeAperDecodeSplCellList
8797 *
8798 *    Functionality: Free Spl Cell List
8799                     where memory allocated by aper_decoder
8800 *
8801 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
8802 * @return void
8803 *
8804 * ****************************************************************/
8805
8806
8807 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
8808 {
8809     uint8_t  cellIdx =0;
8810
8811     if(spCellLst->list.array != NULLP)
8812     {
8813        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
8814        {
8815           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
8816           {
8817              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
8818           }
8819           if(spCellLst->list.array[cellIdx]!=NULLP)
8820           {
8821              free(spCellLst->list.array[cellIdx]);
8822           }
8823        }
8824        free(spCellLst->list.array);
8825     }
8826 }
8827 /*******************************************************************
8828 *
8829 * @brief free the memory allocated by decoder
8830 *
8831 * @details
8832 *
8833 *    Function : freeAperDecodeSRBSetup
8834 *
8835 *    Functionality: added free part for the memory allocated by aper_decoder
8836 *
8837 * @params[in] SRBs_ToBeSetup_List_t *srbSet
8838 * @return void
8839 *
8840 ****************************************************************/
8841
8842
8843 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
8844 {
8845     uint8_t srbIdx =0;
8846     if(srbSet->list.array != NULLP)
8847     {
8848        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
8849        {
8850           if(srbSet->list.array[srbIdx]!=NULLP)
8851           {
8852              free(srbSet->list.array[srbIdx]);
8853           }
8854        }
8855        free(srbSet->list.array);
8856     }
8857 }
8858
8859 /*******************************************************************
8860 *
8861 * @brief free the memory allocated by decoder
8862 *
8863 * @details
8864 *
8865 *    Function : freeAperDecodeULTnlInfo
8866 *
8867 *    Functionality: added free part for the memory allocated by aper_decoder
8868 *
8869 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
8870 * @return void
8871 *
8872 * ****************************************************************/
8873
8874
8875 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
8876 {
8877    uint8_t ulIdx=0;
8878    if(ulInfo->list.array != NULLP)
8879    {
8880       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
8881       {
8882          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
8883          {
8884             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
8885             {
8886                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
8887                      transportLayerAddress.buf != NULLP)
8888                {
8889                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
8890                         !=NULLP)
8891                   {
8892                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
8893                   }
8894                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
8895                         transportLayerAddress.buf);
8896                }
8897                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
8898             }
8899          }
8900          if(ulInfo->list.array[ulIdx]!=NULLP)
8901          {
8902             free(ulInfo->list.array[ulIdx]);
8903          }
8904       }
8905       free(ulInfo->list.array);
8906    }
8907 }
8908 /*******************************************************************
8909 *
8910 * @brief free the memory allocated by decoder
8911 *
8912 * @details
8913 *
8914 *    Function : freeAperDecodeDRBSetup
8915 *
8916 *    Functionality: free DRBSetup which is allocated by decoder
8917 *
8918 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
8919 * @return void
8920 *
8921 * ****************************************************************/
8922
8923 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
8924 {
8925    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
8926    uint8_t  flowIdx =0;
8927    uint8_t  drbIdx =0;
8928
8929    if(drbSet->list.array != NULLP)
8930    {
8931       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
8932       {
8933          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
8934          {
8935             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
8936             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
8937             {
8938                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8939                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
8940                {
8941                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8942                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
8943                   {
8944                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
8945                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
8946                      {
8947
8948                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
8949                         {
8950
8951                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
8952                            {
8953
8954                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
8955                               buf!=NULLP)
8956                               {
8957
8958                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
8959                                        flows_Mapped_To_DRB_List.list.array != NULLP)
8960                                  {
8961
8962                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8963                                     DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
8964                                     {
8965
8966                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8967                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
8968                                        {
8969                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8970                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8971                                                 qoSFlowLevelQoSParameters.\
8972                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
8973                                           {
8974                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8975                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8976                                                    qoSFlowLevelQoSParameters.\
8977                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
8978                                              {
8979
8980                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8981                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8982                                                       qoSFlowLevelQoSParameters.\
8983                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
8984                                                 {
8985                                                    freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
8986                                                    free(drbSetItem->uLConfiguration);
8987
8988
8989                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8990                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8991                                                          qoSFlowLevelQoSParameters.\
8992                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
8993                                                 }
8994
8995                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
8996                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
8997                                                       qoSFlowLevelQoSParameters.\
8998                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
8999                                              }
9000
9001                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9002
9003                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9004                                                    qoSFlowLevelQoSParameters.\
9005                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9006                                           }
9007                                        }
9008                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9009                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9010                                        {
9011
9012                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9013                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9014                                        }
9015                                     }
9016
9017                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9018                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9019                                  }
9020
9021                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9022                                  DRB_Information.sNSSAI.sD->buf);
9023                               }
9024
9025                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9026                            }
9027
9028                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9029
9030                         }
9031
9032                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9033
9034                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9035                      }
9036
9037                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9038                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9039                   }
9040
9041                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9042                         qoS_Characteristics.choice.non_Dynamic_5QI);
9043                }
9044                free(drbSetItem->qoSInformation.choice.choice_extension);
9045             }
9046          }
9047          if(drbSet->list.array[drbIdx]!=NULLP)
9048          {
9049             free(drbSet->list.array[drbIdx]);
9050          }
9051       }
9052       free(drbSet->list.array);
9053    }
9054 }
9055
9056
9057 /*******************************************************************
9058  *
9059  * @brief builds Mac Cell Cfg
9060  *
9061  * @details
9062  *
9063  *    Function : procUeReCfgCellInfo
9064  *
9065  *    Functionality: builds Mac Cell Cfg
9066  *
9067  * @params[in] MacUeCfg pointer
9068  *             void pointer
9069  *
9070  * @return void
9071  *
9072  * ****************************************************************/
9073 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9074 {
9075    uint8_t ret = ROK;
9076    CellGroupConfigRrc_t *cellGrp = NULLP;
9077
9078    if(cellInfo)
9079    {
9080       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9081       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9082       if(ret == RFAILED)
9083          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9084    }
9085    if(ret == RFAILED)
9086    {
9087       freeUeReCfgCellGrpInfo(macUeCfg);
9088    }
9089    return ret;
9090 }
9091
9092 /*******************************************************************
9093  *
9094  * @brief Filling modulation info in mac ue cfg
9095  *
9096  * @details
9097  *
9098  *    Function : duFillModulationDetails
9099  *
9100  *    Functionality: Filling modulation info in mac ue cfg
9101  *
9102  * @params[in] MAC UE Config to be updated
9103  *             Current UE configuration
9104  *             UE NR capability from CU
9105  * @return ROK     - success
9106  *         RFAILED - failure
9107  *
9108  * ****************************************************************/
9109 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9110 {
9111    UE_NR_Capability_t *ueNrCap;
9112
9113    if(ueCap)
9114       ueNrCap = (UE_NR_Capability_t *)ueCap;
9115
9116    /* Filling DL modulation info */
9117    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9118          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9119          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9120    {
9121       switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9122       {
9123          case ModulationOrder_qpsk:
9124             {
9125                ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9126                break;
9127             }
9128          case ModulationOrder_qam16:
9129             {
9130                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9131                break;
9132             }
9133          case ModulationOrder_qam64:
9134             {
9135                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9136                ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9137                ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9138                break;
9139             }
9140          case ModulationOrder_qam256:
9141             {
9142                ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9143                break;
9144             }
9145          default:
9146             {
9147                DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9148                memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9149                break;
9150             }
9151       }
9152    }
9153    else
9154    {
9155       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9156    }
9157
9158    /* Filling UL modulation info */
9159    if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9160          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9161          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9162    {
9163       switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9164       {
9165          case ModulationOrder_qpsk:
9166             {
9167                ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9168                break;
9169             }
9170          case ModulationOrder_qam16:
9171             {
9172                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9173                ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9174                ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9175                break;
9176             }
9177          case ModulationOrder_qam64:
9178             {
9179                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9180                break;
9181             }
9182          case ModulationOrder_qam256:
9183             {
9184                ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9185                break;
9186             }
9187          default:
9188             {
9189                DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9190                memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9191                break;
9192             }
9193       }
9194    }
9195    else
9196    {
9197       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9198    }
9199 }
9200
9201 /*******************************************************************
9202  *
9203  * @brief Function to extract cellGrp Info present in cutoDu cont
9204  *
9205  * @details
9206  *
9207  *    Function : extractCellGrpInfo
9208  *
9209  *    Functionality: Function to extract cellGrp Info present
9210  *                   in cutoDu cont
9211  *
9212  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9213  *
9214  * @return CellGroupConfigRrc_t *
9215  *
9216  * ****************************************************************/
9217
9218 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9219    DuUeCfg *ueCfgDb)
9220 {
9221    uint8_t idx2 =0;
9222    uint16_t id =0;
9223    uint16_t recvBufLen =0;
9224    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9225    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9226    asn_dec_rval_t rval; /* Decoder return value */
9227    memset(&rval, 0, sizeof(asn_dec_rval_t));
9228
9229    if(protocolIeExtn)
9230    {
9231       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9232       {
9233          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9234          id = extIeInfo->id;
9235          switch(id)
9236          {
9237             case ProtocolIE_ID_id_CellGroupConfig:
9238             {
9239                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9240                /* decoding the CellGroup Buf received */
9241                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9242                if(cellGrpCfg)
9243                {
9244                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9245                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9246                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9247                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9248                   {
9249                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9250                      return NULLP;
9251                   }
9252                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9253                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9254                      return NULLP;
9255                }
9256                break;
9257             }
9258             default:
9259                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9260                break;
9261          }
9262       }
9263    }
9264    return cellGrpCfg;
9265 }
9266
9267 /*******************************************************************
9268  *
9269  * @brief Fills Srb List received by CU
9270  *
9271  * @details
9272  *
9273  *    Function : procSrbListToSetup
9274  *
9275  *    Functionality: Fills Srb List received  by CU
9276  *
9277  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9278  *             LcCfg pointer
9279  *             RlcBearerCfg pointer
9280  * @return void
9281  *
9282  * ****************************************************************/
9283 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9284 {
9285    uint8_t ret = ROK;
9286
9287    /* Filling RLC INFO */
9288    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9289
9290    /* Filling MAC INFO */
9291    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL, NULL, macLcToAdd);
9292    if(ret == RFAILED)
9293    {
9294       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9295       return ret;
9296    }
9297    return ret;
9298 }
9299
9300
9301
9302 /*******************************************************************
9303  *
9304  * @brief extract Srb List received by CU
9305  *
9306  * @details
9307  *
9308  *    Function : extractSrbListToSetup
9309  *
9310  *    Functionality: extract Srb List received by CU
9311  *                   for both MAC and RLC
9312  *
9313  * @params[in] SRBs_ToBeSetup_Item_t pointer
9314  *             DuUeCfg pointer
9315  * @return ROK/RFAIED
9316  *
9317  * ****************************************************************/
9318
9319 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9320 {
9321    uint8_t ret, srbIdx;
9322    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9323
9324    if(srbCfg)
9325    {
9326       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9327       {
9328          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9329          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9330          {
9331             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9332             ret = RFAILED;
9333             break;
9334          }
9335          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9336          {
9337             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9338             ret = RFAILED;
9339             break;
9340          }
9341          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9342          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9343          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9344             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9345          ueCfgDb->numRlcLcs++;
9346          ueCfgDb->numMacLcs++;
9347          if(ret == RFAILED)
9348          {
9349             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9350             break;
9351          }
9352       }
9353    }
9354    else
9355       ret = RFAILED;
9356
9357    return ret;
9358 }
9359
9360 /*******************************************************************
9361  *
9362  * @brief Fills Drb List received by CU
9363  *
9364  * @details
9365  *
9366  *    Function : procDrbListToSetup
9367  *
9368  *    Functionality: Fills Drb List received by CU
9369  *                   for both MAC and RLC
9370  *
9371  * @params[in] SRBs_ToBeSetup_Item_t pointer
9372  *             LcCfg pointer,
9373  *             RlcBearerCfg pointer
9374  * @return void
9375  *
9376  * ****************************************************************/
9377
9378 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9379 {
9380    uint8_t ret = ROK;
9381
9382    /* Filling RLC INFO */
9383    procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9384
9385    /* Filling MAC INFO */
9386    ret = procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, macLcToAdd);
9387    if(ret == RFAILED)
9388    {
9389       DU_LOG("\nERROR  -->  F1AP : Failed at RLC LC Cfg in extractDrbListToSetup()");
9390       return ret;
9391    }
9392
9393    return ret;
9394 }
9395
9396 /*******************************************************************
9397  *
9398  * @brief extract Drb List received by CU
9399  *
9400  * @details
9401  *
9402  *    Function : extractDrbListToSetup
9403  *
9404  *    Functionality: extract Drb List received by CU
9405  *                   for both MAC and RLC
9406  *
9407  * @params[in] DRBs_ToBeSetup_Item_t pointer
9408  *             DuUeCfg pointer
9409  * @return ROK/RFAIED
9410  *
9411  * ****************************************************************/
9412
9413 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg, DuUeCfg *ueCfgDb)
9414 {
9415    uint8_t ret, drbIdx;
9416    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9417
9418    ret = ROK;
9419    if(drbCfg)
9420    {
9421       for(drbIdx = 0; drbIdx < drbCfg->list.count; drbIdx++)
9422       {
9423          drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9424          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9425          {
9426             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC ");
9427             ret = RFAILED;
9428             break;
9429          }
9430          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9431          {
9432             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9433             ret = RFAILED;
9434             break;
9435          }
9436          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9437          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9438          ret = procDrbListToSetup(lcId, drbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9439             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9440          ueCfgDb->numRlcLcs++;
9441          ueCfgDb->numMacLcs++;
9442          if(ret == RFAILED)
9443          {
9444             DU_LOG("\nERROR  -->  F1AP :  Failed at extractDrbListToSetup()");
9445             break;
9446          }
9447       }
9448    }
9449    else
9450       ret = RFAILED;
9451
9452    return ret;
9453 }
9454
9455 /*******************************************************************
9456  *
9457  * @brief Function to extract Dl RRC Msg received from CU
9458  *
9459  * @details
9460  *
9461  *    Function : extractDlRrcMsg
9462  *
9463  *    Functionality: Function to extract Dl RRC Msg received from CU
9464  *
9465  * @params[in] F1AP message
9466  * @return ROK     - success
9467  *         RFAILED - failure
9468  *
9469  * ****************************************************************/
9470
9471 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9472    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9473 {
9474    uint8_t ret = ROK;
9475    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9476    if(dlRrcMsg->rrcMsgSize > 0)
9477    {
9478       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9479       if(!dlRrcMsg->rrcMsgPdu)
9480       {
9481          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RRC Msg in procUeCtxtSetupReq");
9482          ret = RFAILED;
9483       }
9484       else
9485       {
9486          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9487          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9488          dlRrcMsg->srbId = SRB1_LCID;
9489          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9490       }
9491    }
9492    return ret;
9493 }
9494
9495 /*******************************************************************
9496  *
9497  * @brief Extract UE capability info
9498  *
9499  * @details
9500  *
9501  *    Function : extractUeCapability
9502  *
9503  *    Functionality: Extract UE capability info and stores in ue Cb
9504  *
9505  * @params[in] Octet string of UE capability RAT container list
9506  * @return ROK     - success
9507  *         RFAILED - failure
9508  *
9509  * ****************************************************************/
9510 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9511 {
9512    uint8_t  idx;
9513    uint16_t recvBufLen;
9514    asn_dec_rval_t rval;
9515    UE_NR_Capability_t  *ueNrCap = NULLP;
9516    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9517
9518    /* Decoding UE Capability RAT Container List */
9519    recvBufLen = ueCapablityListBuf->size;
9520    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9521    if(!ueCapRatContList)
9522    {
9523       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9524       return NULLP;
9525    }
9526    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9527    memset(&rval, 0, sizeof(asn_dec_rval_t));
9528    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9529           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9530    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9531    {
9532       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9533       return NULLP;
9534    }
9535    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9536
9537    /* Free encoded buffer after decoding */
9538
9539    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9540    {
9541       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9542       {
9543          /* Decoding UE NR Capability */
9544           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9545           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9546           if(!ueNrCap)
9547           {
9548              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9549              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9550              return NULLP;
9551           }
9552           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9553           memset(&rval, 0, sizeof(asn_dec_rval_t));
9554           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9555                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9556           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9557           {
9558              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9559              return NULLP;
9560           }
9561           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9562
9563           /* Free encoded buffer after decoding */
9564           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9565       }
9566       free(ueCapRatContList->list.array[idx]);
9567    }
9568
9569    /* Free Memory*/
9570    free(ueCapRatContList->list.array);
9571    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9572    return ueNrCap;
9573 }
9574
9575 /*******************************************************************
9576 *
9577 * @brief free UE context setup request from CU
9578 *
9579 * @details
9580 *
9581 *    Function : freeAperDecodeF1UeContextSetupReq
9582 *
9583 *    Functionality: freeing part for the memory allocated by aper_decoder
9584 *
9585 * @params[in] F1AP message
9586 * @return ROK     - success
9587 *         RFAILED - failure
9588 *
9589 * ****************************************************************/
9590 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9591 {
9592    uint8_t ieIdx = 0;
9593
9594    if(ueSetReq->protocolIEs.list.array != NULLP)
9595    {
9596       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9597       {
9598          if(ueSetReq->protocolIEs.list.array[ieIdx])
9599          {
9600             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9601             {
9602                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9603                   break;
9604                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9605                   break;
9606                case ProtocolIE_ID_id_SpCell_ID:
9607                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9608                   break;
9609                case ProtocolIE_ID_id_ServCellIndex:
9610                   break;
9611                case ProtocolIE_ID_id_SpCellULConfigured:
9612                   break;
9613                case ProtocolIE_ID_id_CUtoDURRCInformation:
9614
9615                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9616                   break;
9617                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9618
9619                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
9620                   break;
9621                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9622
9623                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
9624                   break;
9625                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9626
9627                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
9628                   break;
9629                case ProtocolIE_ID_id_RRCContainer:
9630                   {
9631
9632                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
9633                      {
9634
9635                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
9636                      }
9637                      break;
9638                   }
9639                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9640                   break;
9641                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9642                   {
9643                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
9644                      {
9645                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
9646                      }
9647                      break;
9648                   }
9649                default:
9650                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
9651             }
9652             free(ueSetReq->protocolIEs.list.array[ieIdx]);
9653          }
9654       }
9655       free(ueSetReq->protocolIEs.list.array);
9656    }
9657 }
9658 /*******************************************************************
9659  *
9660  * @brief Process UE context setup request from CU
9661  *
9662  * @details
9663  *
9664  *    Function : procF1UeContextSetupReq
9665  *
9666  *    Functionality: Process UE context setup request from CU
9667  *
9668  * @params[in] F1AP message
9669  * @return ROK     - success
9670  *         RFAILED - failure
9671  *
9672  * ****************************************************************/
9673 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
9674 {
9675    uint8_t  ret, ieIdx, ueIdx, lcId, cellIdx;
9676    bool ueCbFound = false;
9677    uint32_t gnbCuUeF1apId, gnbDuUeF1apId, bitRateSize;
9678    DuUeCb   *duUeCb = NULLP;
9679    UEContextSetupRequest_t   *ueSetReq = NULLP;
9680
9681    ret = ROK;
9682
9683    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
9684    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
9685    {
9686       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9687       {
9688          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9689             {
9690                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
9691                break;
9692             }
9693          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9694             {
9695                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
9696                break;
9697             }
9698          case ProtocolIE_ID_id_ServCellIndex:
9699             {
9700                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
9701                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
9702                {
9703                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
9704                      (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
9705                   {
9706                      ueCbFound = true;
9707                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
9708                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
9709                      if(duUeCb->f1UeDb)
9710                      {
9711                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
9712                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
9713                         duUeCb->f1UeDb->cellIdx = cellIdx;
9714                      }
9715                      else
9716                      {
9717                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
9718                         ret = RFAILED;
9719                      }
9720                   }
9721                   else
9722                      ueCbFound = false;
9723
9724                }
9725                if(!ueCbFound)
9726                {
9727                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
9728                   ret = RFAILED;
9729                }
9730                break;
9731             }
9732          case ProtocolIE_ID_id_SpCellULConfigured:
9733             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
9734             UL, SUL or UL+SUL for the indicated cell for the UE */
9735             break;
9736          case ProtocolIE_ID_id_CUtoDURRCInformation:
9737             {
9738                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
9739                {
9740                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
9741                      extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
9742                         uE_CapabilityRAT_ContainerList, duUeCb);
9743                }
9744                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
9745                {
9746                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
9747                      value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
9748                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
9749                   {
9750                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
9751                      //TODO: Update the failure cause in ue context Setup Response
9752                      ret = RFAILED;
9753                   }
9754                }
9755                break;
9756             }
9757          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9758             {
9759                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
9760             break;
9761             }
9762          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
9763             {
9764                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
9765                   &duUeCb->f1UeDb->duUeCfg))
9766                {
9767                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
9768                   //TODO: Update the failure cause in ue context Setup Response
9769                   ret = RFAILED;
9770                }
9771                break;
9772             }
9773          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
9774             {
9775                lcId = getDrbLcId(&duUeCb->drbBitMap);
9776                if(lcId != RFAILED)
9777                {
9778                   if(extractDrbListToSetup(lcId, &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List,\
9779                      &duUeCb->f1UeDb->duUeCfg))
9780                   {
9781                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
9782                      //TODO: Update the failure cause in ue context Setup Response
9783                      ret = RFAILED;
9784                   }
9785                }
9786                else
9787                   ret = RFAILED;
9788                break;
9789             }
9790          case ProtocolIE_ID_id_RRCContainer:
9791             {
9792                /* Filling Dl RRC Msg Info */
9793                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9794                if(!duUeCb->f1UeDb->dlRrcMsg)
9795                {
9796                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
9797                   ret = RFAILED;
9798                }
9799                else
9800                {
9801                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
9802                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
9803                      &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
9804                }
9805                break;
9806             }
9807          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
9808             {
9809                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
9810                {
9811                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
9812                }
9813                else
9814                {
9815                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
9816                }
9817                break;
9818             }
9819          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
9820              {
9821                /* MaximumBitRate Uplink */
9822                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
9823                if(bitRateSize > 0)
9824                {
9825                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
9826                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
9827                   {
9828                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
9829                      ret = RFAILED;
9830                   }
9831                   else
9832                   {
9833                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
9834                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
9835                      ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
9836                      duUeCb->f1UeDb->duUeCfg.ambrCfg->dlBr = 0;
9837                   }
9838                }
9839                else
9840                   ret = RFAILED;
9841                break;
9842             }
9843          default:
9844             {
9845                break;
9846             }
9847       }
9848    }
9849    if(ret == RFAILED)
9850    {
9851       /*TODO : Negative case*/
9852       // BuildAndSendUeContextSetupRsp(ueIdx, cellId);
9853       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
9854    }
9855    else
9856       ret = duProcUeContextSetupRequest(duUeCb);
9857
9858    freeAperDecodeF1UeContextSetupReq(ueSetReq);
9859    return ret;
9860
9861 }
9862
9863 /*******************************************************************
9864  * @brief Free the memory allocated for UE Setup response
9865  *
9866  * @details
9867  *
9868  *    Function : FreeUeContextSetupRsp
9869  *
9870  *    Functionality:
9871  *       Free the memory allocated for UE Setup response
9872  *
9873  * @params[in] F1AP PDU for UE setup response
9874  * @return ROK     - success
9875  *         RFAILED - failure
9876  *
9877  * ****************************************************************/
9878 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
9879 {
9880    uint8_t idx;
9881    UEContextSetupResponse_t *ueSetRsp = NULLP;
9882
9883    if(f1apMsg)
9884    {
9885       if(f1apMsg->choice.successfulOutcome)
9886       {
9887          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
9888                     UEContextSetupResponse;
9889          if(ueSetRsp->protocolIEs.list.array)
9890          {
9891             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
9892             {
9893                if(ueSetRsp->protocolIEs.list.array[idx])
9894                {
9895                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
9896                   {
9897                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9898                         break;
9899                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9900                         break;
9901                      case ProtocolIE_ID_id_DUtoCURRCInformation:
9902                         {
9903                            CellGroupConfig_t *cellGrpCfg = NULLP;
9904                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
9905                                          DUtoCURRCInformation.cellGroupConfig;
9906                            if(cellGrpCfg->buf != NULLP)
9907                            {
9908                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
9909                               cellGrpCfg = NULLP;
9910                            }
9911                            break;
9912                         }
9913                      default:
9914                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
9915                         ueSetRsp->protocolIEs.list.array[idx]->id);
9916                         break;
9917                   }
9918                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
9919                         sizeof(UEContextSetupResponseIEs_t));
9920                }
9921             }
9922             DU_FREE(ueSetRsp->protocolIEs.list.array, \
9923                   ueSetRsp->protocolIEs.list.size);
9924          }
9925          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
9926       }
9927       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
9928    }
9929 }
9930
9931 /*******************************************************************
9932  *
9933  * @brief Builds Ue context Setup Rsp DU To CU Info
9934  *
9935  * @details
9936  *
9937  *    Function : EncodeUeCntxtDuToCuInfo
9938  *
9939  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
9940  *
9941  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
9942  *
9943  * @return ROK     - success
9944  *         RFAILED - failure
9945  *
9946  ******************************************************************/
9947
9948 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
9949 {
9950    asn_enc_rval_t        encRetVal;
9951
9952    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
9953    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
9954    encBufSize = 0;
9955    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
9956    /* Encode results */
9957    if(encRetVal.encoded == ENCODE_FAIL)
9958    {
9959       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
9960             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
9961       return RFAILED;
9962    }
9963    else
9964    {
9965       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
9966       for(int i=0; i< encBufSize; i++)
9967       {
9968          printf("%x",encBuf[i]);
9969       }
9970    }
9971    duToCuCellGrp->size = encBufSize;
9972    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
9973    if(!duToCuCellGrp->buf)
9974    {
9975       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
9976    }
9977    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
9978    return ROK;
9979 }
9980
9981 /*******************************************************************
9982  *
9983  * @brief Builds and sends the UE Setup Response
9984  *
9985  * @details
9986  *
9987  *    Function : BuildAndSendUeContextSetupRsp
9988  *
9989  *    Functionality: Constructs the UE Setup Response and sends
9990  *                   it to the DU through SCTP.
9991  *
9992  * @params[in]
9993  *
9994  * @return ROK     - success
9995  *         RFAILED - failure
9996  *
9997  * ****************************************************************/
9998 uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
9999 {
10000    uint8_t   idx, ret, cellIdx, elementCnt;
10001    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10002    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10003    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10004    F1AP_PDU_t               *f1apMsg = NULLP;
10005    UEContextSetupResponse_t *ueSetRsp = NULLP;
10006    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10007    DuUeCb                   *ueCb = NULLP;
10008
10009    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10010
10011    while(true)
10012    {
10013       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10014       if(f1apMsg == NULLP)
10015       {
10016          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10017          ret = RFAILED;
10018          break;
10019       }
10020
10021       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10022       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10023             sizeof(SuccessfulOutcome_t));
10024       if(f1apMsg->choice.successfulOutcome == NULLP)
10025       {
10026          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10027          ret = RFAILED;
10028          break;
10029       }
10030
10031       f1apMsg->choice.successfulOutcome->procedureCode = \
10032                                                          ProcedureCode_id_UEContextSetup;
10033       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10034       f1apMsg->choice.successfulOutcome->value.present = \
10035                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10036
10037       ueSetRsp =
10038          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10039       elementCnt = 3;
10040       ueSetRsp->protocolIEs.list.count = elementCnt;
10041       ueSetRsp->protocolIEs.list.size = \
10042                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10043
10044       /* Initialize the UESetup members */
10045       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10046             ueSetRsp->protocolIEs.list.size);
10047       if(ueSetRsp->protocolIEs.list.array == NULLP)
10048       {
10049          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10050          ret = RFAILED;
10051          break;
10052       }
10053
10054       for(idx=0; idx<elementCnt; idx++)
10055       {
10056          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10057                sizeof(UEContextSetupResponseIEs_t));
10058          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10059          {
10060             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10061             ret = RFAILED;
10062             break;
10063          }
10064       }
10065       /* Fetching Ue Cb Info*/
10066       GET_CELL_IDX(cellId, cellIdx);
10067       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10068       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10069       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10070
10071       idx = 0;
10072       /*GNB CU UE F1AP ID*/
10073       ueSetRsp->protocolIEs.list.array[idx]->id = \
10074                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10075       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10076       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10077                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10078       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10079
10080       /*GNB DU UE F1AP ID*/
10081       idx++;
10082       ueSetRsp->protocolIEs.list.array[idx]->id = \
10083                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10084       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10085       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10086                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10087       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10088
10089
10090       /*DUtoCURRC Information */
10091       idx++;
10092       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10093                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10094       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10095       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10096                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10097       if(ueCb->f1UeDb)
10098       {
10099          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10100          {
10101             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10102             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10103                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10104             /* Free UeContext Db created during Ue context Req */
10105             freeF1UeDb(ueCb->f1UeDb);
10106             ueCb->f1UeDb = NULLP;
10107          }
10108       }
10109       else
10110       {
10111          DU_LOG("\nERROR  -->  F1AP: Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10112          ret = RFAILED;
10113       }
10114       if(ret == RFAILED)
10115          break;
10116
10117       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10118
10119       /* Encode the UE context setup response type as APER */
10120       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10121       encBufSize = 0;
10122       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10123             encBuf);
10124       /* Encode results */
10125       if(encRetVal.encoded == ENCODE_FAIL)
10126       {
10127          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
10128                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10129          ret = RFAILED;
10130          break;
10131       }
10132       else
10133       {
10134          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Request\n");
10135          for(int i=0; i< encBufSize; i++)
10136          {
10137             printf("%x",encBuf[i]);
10138          }
10139       }
10140
10141       /* Sending  msg  */
10142       if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
10143       {
10144          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Request Failed");
10145          ret = RFAILED;
10146          break;
10147       }
10148       break;
10149    }
10150    FreeUeContextSetupRsp(f1apMsg);
10151    return ret;
10152 }/* End of BuildAndSendUeContextSetupRsp */
10153 /*******************************************************************
10154 *
10155 * @brief  Build And Send Ue Context Rsp
10156 *
10157 * @details
10158 *
10159 *    Function : BuildAndSendUeCtxtRsp
10160 *
10161 *    Functionality : Build And Send Ue Context Rsp
10162
10163 * @params[in]
10164 * @return sucess = ROK
10165 *         failure = RFAILED
10166 *
10167 * ****************************************************************/
10168 uint8_t BuildAndSendUeCtxtRsp(uint8_t ueIdx, uint8_t cellId)
10169 {
10170    uint8_t cellIdx = 0, actionType = 0;
10171
10172    GET_CELL_IDX(cellId, cellIdx);
10173    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10174
10175    switch(actionType)
10176    {
10177       case UE_CTXT_SETUP:
10178          BuildAndSendUeContextSetupRsp(ueIdx, cellId);
10179          break;
10180       case UE_CTXT_MOD:
10181          //TODO: Build Ue context Modification Rsp
10182          break;
10183       default:
10184          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10185          break;
10186
10187    }
10188    return ROK;
10189 }
10190
10191 /*******************************************************************
10192  *
10193  * @brief deallocating the memory of  F1reset msg
10194  *
10195  * @details
10196  *
10197  *    Function : FreeF1ResetReq
10198  *
10199  *    Functionality :
10200  *         - freeing memory of F1reset request msg
10201  *
10202  * @params[in]
10203  * @return void
10204  *
10205  *
10206  * ****************************************************************/
10207 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10208 {
10209    uint8_t idx =0 ;
10210    Reset_t *f1ResetMsg;
10211
10212    if(f1apMsg)
10213    {
10214       if(f1apMsg->choice.initiatingMessage)
10215       {
10216          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10217
10218          if(f1ResetMsg->protocolIEs.list.array)
10219          {
10220             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10221             {
10222                if(f1ResetMsg->protocolIEs.list.array[idx])
10223                {
10224                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10225                }
10226             }
10227             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10228          }
10229          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10230       }
10231       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10232    }
10233 }
10234 /*******************************************************************
10235  *
10236  * @brief Build and Send F1reset request
10237  *
10238  * @details
10239  *
10240  *    Function : BuildAndSendF1ResetReq
10241  *
10242  *    Functionality:
10243  *         - Build and Send F1reset request msg
10244  *
10245  * @params[in]
10246  * @return ROK     - success
10247  *         RFAILED - failure
10248  *
10249  * ****************************************************************/
10250 uint8_t BuildAndSendF1ResetReq()
10251 {
10252    uint8_t          elementCnt=0;
10253    uint8_t          idx=0;
10254    uint8_t          ret= RFAILED;
10255    Reset_t          *f1ResetMsg = NULLP;
10256    F1AP_PDU_t       *f1apMsg = NULLP;
10257    asn_enc_rval_t   encRetVal;
10258    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10259    do
10260    {
10261       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10262       if(f1apMsg == NULLP)
10263       {
10264          break;
10265       }
10266       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10267       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10268       if(f1apMsg->choice.initiatingMessage == NULLP)
10269       {
10270          break;
10271       }
10272       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10273       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10274       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10275
10276       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10277
10278       elementCnt = 3;
10279       f1ResetMsg->protocolIEs.list.count = elementCnt;
10280       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10281
10282       /* Initialize the F1Setup members */
10283       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10284       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10285       {
10286          break;
10287       }
10288       for(idx=0; idx<elementCnt; idx++)
10289       {
10290          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10291          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10292          {
10293             break;
10294          }
10295       }
10296
10297       /*TransactionID*/
10298       idx=0;
10299       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10300       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10301       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10302       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10303
10304       /*Cause*/
10305       idx++;
10306       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10307       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10308       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10309       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10310       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10311
10312       /*Reset Type*/
10313       idx++;
10314       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10315       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10316       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10317       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10318       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10319
10320       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10321
10322       /* Encode the F1SetupRequest type as APER */
10323       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10324       encBufSize = 0;
10325       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10326             encBuf);
10327
10328       /* Encode results */
10329       if(encRetVal.encoded == ENCODE_FAIL)
10330       {
10331          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10332                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10333          break;
10334       }
10335       else
10336       {
10337          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10338          for(idx=0; idx< encBufSize; idx++)
10339          {
10340             printf("%x",encBuf[idx]);
10341          }
10342       }
10343
10344       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10345       {
10346          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10347          break;
10348       }
10349
10350       ret = ROK;
10351       break;
10352    }while(true);
10353
10354    FreeF1ResetReq(f1apMsg);
10355    return ret;
10356 }
10357 /*******************************************************************
10358  *
10359  * @brief Build And Send F1ResetAck
10360  *
10361  * @details
10362  *
10363  *    Function : BuildAndSendF1ResetAck
10364  *
10365  *    Functionality:
10366  *         - Build And Send  F1ResetRSP
10367  *
10368  * @return ROK     - success
10369  *         RFAILED - failure
10370  *
10371  * ****************************************************************/
10372 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
10373 {
10374    uint8_t idx;
10375    ResetAcknowledge_t *f1ResetAck;
10376
10377    if(f1apMsg)
10378    {
10379       if(f1apMsg->choice.successfulOutcome)
10380       {
10381          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10382
10383          if(f1ResetAck->protocolIEs.list.array)
10384          {
10385             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
10386             {
10387                if(f1ResetAck->protocolIEs.list.array[idx])
10388                {
10389                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10390                }
10391             }
10392             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10393          }
10394          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10395       }
10396       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10397    }
10398 }
10399
10400 /*******************************************************************
10401  *
10402  * @brief Build And Send F1ResetAck
10403  *
10404  * @details
10405  *
10406  *    Function : BuildAndSendF1ResetAck
10407  *
10408  *    Functionality:
10409  *         - Build And Send  F1ResetRSP
10410  *
10411  *  @params[in]
10412  * @return ROK     - success
10413  *         RFAILED - failure
10414  *
10415  * ****************************************************************/
10416 uint8_t BuildAndSendF1ResetAck()
10417 {
10418    uint8_t                idx = 0;
10419    uint8_t                elementCnt = 0;
10420    uint8_t                ret = RFAILED;
10421    F1AP_PDU_t             *f1apMsg = NULL;
10422    ResetAcknowledge_t     *f1ResetAck = NULLP;
10423    asn_enc_rval_t         encRetVal;
10424    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
10425
10426    do{
10427       /* Allocate the memory for F1ResetRequest_t */
10428       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10429       if(f1apMsg == NULLP)
10430       {
10431          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10432          break;
10433       }
10434
10435       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
10436
10437       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10438       if(f1apMsg->choice.successfulOutcome == NULLP)
10439       {
10440          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10441          break;
10442       }
10443       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
10444       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
10445       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
10446
10447       elementCnt = 1;
10448
10449       f1ResetAck->protocolIEs.list.count = elementCnt;
10450       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
10451
10452       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
10453       if(f1ResetAck->protocolIEs.list.array == NULLP)
10454       {
10455          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
10456          break;
10457       }
10458
10459       for(idx=0; idx<elementCnt; idx++)
10460       {
10461          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
10462          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
10463          {
10464             break;
10465          }
10466       }
10467       /*TransactionID*/
10468       idx = 0;
10469       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10470       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10471       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
10472       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
10473
10474       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10475
10476       /* Encode the F1SetupRequest type as UPER */
10477       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10478       encBufSize = 0;
10479       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
10480
10481       /* Check encode results */
10482       if(encRetVal.encoded == ENCODE_FAIL)
10483       {
10484          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
10485                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10486          break;
10487       }
10488       else
10489       {
10490          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
10491          for(int i=0; i< encBufSize; i++)
10492          {
10493             printf("%x",encBuf[i]);
10494          }
10495       }
10496       /* Sending msg */
10497       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10498       {
10499          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
10500          break;
10501       }
10502
10503       ret = ROK;
10504       break;
10505    }while(true);
10506
10507    FreeF1ResetAck(f1apMsg);
10508    return ret;
10509 }
10510 /******************************************************************
10511 *
10512 * @brief free F1 reset msg allocated by aper_decoder
10513 *
10514 * @details
10515 *
10516 *    Function : freeAperDecodeF1ResetMsg
10517 *
10518 *    Functionality: free F1 reset msg allocated by aper_decoder
10519 *
10520 * @params[in] Reset_t *f1ResetMsg
10521 * @return void
10522 *
10523 * ****************************************************************/
10524
10525 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
10526 {
10527    uint8_t ieIdx =0;
10528    if(f1ResetMsg->protocolIEs.list.array)
10529    {
10530       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
10531       {
10532          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
10533          {
10534             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
10535          }
10536       }
10537       free(f1ResetMsg->protocolIEs.list.array);
10538    }
10539 }
10540
10541 /******************************************************************
10542  *
10543  * @brief Processes DL RRC Message Transfer  sent by CU
10544  *
10545  * @details
10546  *
10547  *    Function : procF1ResetReq
10548  *
10549  *    Functionality: Processes DL RRC Message Transfer sent by CU
10550  *
10551  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10552  * @return ROK     - success
10553  *         RFAILED - failure
10554  *
10555  * ****************************************************************/
10556 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
10557 {
10558    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
10559    uint8_t       ieIdx = 0;
10560    uint8_t        ret = ROK;
10561    Reset_t       *f1ResetMsg = NULLP;
10562
10563    DU_LOG("\nINFO   -->  Processing F1 reset request");
10564    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10565
10566    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
10567    {
10568       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
10569       {
10570          case ProtocolIE_ID_id_TransactionID:
10571             break;
10572
10573          case ProtocolIE_ID_id_Cause:
10574             break;
10575
10576          case ProtocolIE_ID_id_ResetType:
10577             {
10578                break;
10579             }
10580
10581          default:
10582             break;
10583       }
10584    }
10585    ret = BuildAndSendF1ResetAck();
10586    DU_LOG("\nINFO   -->  UE release is not supported for now");
10587
10588    freeAperDecodeF1ResetMsg(f1ResetMsg);
10589
10590    return ret;
10591 }
10592
10593 /*******************************************************************
10594  *
10595  * @brief free the RRC delivery report
10596  *
10597  * @details
10598  *
10599  *    Function : freeRrcDeliveryReport
10600  *
10601  *    Functionality: free the RRC delivery report
10602  *
10603  * @params[in]
10604  * @return ROK     - success
10605  *         RFAILED - failure
10606  *
10607  * ****************************************************************/
10608 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
10609 {
10610    uint8_t idx=0;
10611    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
10612
10613    if(f1apMsg)
10614    {
10615       if(f1apMsg->choice.initiatingMessage)
10616       {
10617          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
10618          if(rrcDeliveryReport->protocolIEs.list.array)
10619          {
10620             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
10621                   idx++)
10622             {
10623                if(rrcDeliveryReport->protocolIEs.list.array[idx])
10624                {
10625                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
10626                         sizeof(RRCDeliveryReportIEs_t));
10627                }
10628             }
10629             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
10630                   rrcDeliveryReport->protocolIEs.list.size);
10631          }
10632          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
10633       }
10634       DU_FREE(f1apMsg,
10635             sizeof(F1AP_PDU_t));
10636    }
10637 }
10638
10639 /*******************************************************************
10640 *
10641 * @brief Builds and sends the RRC delivery report
10642 *
10643 * @details
10644 *
10645 *    Function : BuildAndSendRrcDeliveryReport
10646 *
10647 *    Functionality: Builds and sends the RRC delivery report
10648 *
10649 * @params[in]
10650 *
10651 * @return ROK     - success
10652 *         RFAILED - failure
10653 *
10654 * ****************************************************************/
10655 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
10656    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
10657 {
10658    uint8_t             ret = RFAILED;
10659    uint8_t             idx    = 0;
10660    uint8_t             idx1   = 0;
10661    uint8_t             elementCnt = 0;
10662    F1AP_PDU_t          *f1apMsg = NULLP;
10663    asn_enc_rval_t      encRetVal;
10664    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
10665
10666    do{
10667
10668       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
10669       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10670       if(f1apMsg == NULLP)
10671       {
10672          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10673          break;
10674       }
10675       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10676       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
10677       if(f1apMsg->choice.initiatingMessage == NULLP)
10678       {
10679          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
10680          break;
10681       }
10682       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
10683       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
10684       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
10685
10686       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
10687       elementCnt = 4;
10688       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
10689       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
10690
10691       /* Initialize the F1Setup members */
10692       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
10693       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
10694       {
10695          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
10696          break;
10697       }
10698       for(idx =0 ;idx <elementCnt; idx++)
10699       {
10700          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
10701          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
10702          {
10703             break;
10704          }
10705       }
10706
10707       idx1 = 0;
10708
10709       /*GNB CU UE F1AP ID*/
10710       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10711       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
10712       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
10713       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10714
10715       /*GNB DU UE F1AP ID*/
10716       idx1++;
10717       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10718       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
10719       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
10720       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10721
10722       /*RRC delivery status*/
10723       idx1++;
10724       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
10725       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
10726       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
10727       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
10728       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
10729       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
10730       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
10731
10732       /* SRB ID */
10733       idx1++;
10734       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
10735       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
10736       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
10737       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
10738
10739       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10740
10741       /* Encode the RRC DELIVERY REPORT type as APER */
10742       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10743       encBufSize = 0;
10744       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10745             encBuf);
10746
10747       /* Encode results */
10748       if(encRetVal.encoded == ENCODE_FAIL)
10749       {
10750          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
10751                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10752          break;
10753       }
10754       else
10755       {
10756          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
10757          for(idx=0; idx< encBufSize; idx++)
10758          {
10759             printf("%x",encBuf[idx]);
10760          }
10761       }
10762
10763       /* Sending msg */
10764       if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
10765       {
10766          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
10767          break;
10768       }
10769       ret = ROK;
10770       break;
10771
10772    }while(true);
10773
10774    freeRrcDeliveryReport(f1apMsg);
10775    return ret;
10776 }
10777
10778 /*******************************************************************
10779  *
10780  * @brief Processes cells to be activated
10781  *
10782  * @details
10783  *
10784  *    Function : extractCellsToBeActivated
10785  *
10786  *    Functionality:
10787  *      - Processes cells to be activated list received in F1SetupRsp
10788  *
10789  * @params[in] void
10790  * @return ROK     - success
10791  *         RFAILED - failure
10792  *
10793  * ****************************************************************/
10794
10795 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
10796 {
10797    uint8_t  ret = ROK;
10798    uint16_t idx, nci, pci = 0;
10799    Cells_to_be_Activated_List_Item_t cell;
10800
10801    for(idx=0; idx<cellsToActivate.list.count; idx++)
10802    {
10803       nci = 0;
10804       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
10805       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
10806
10807       if(cell.nRPCI)
10808       {
10809          pci = *cell.nRPCI;
10810       }
10811       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
10812    }
10813    return ret;
10814 }
10815 /******************************************************************
10816 *
10817 * @brief Processes F1 Setup Response allocated by aper_decoder
10818 *
10819 * @details
10820 *
10821 *    Function : freeF1SetupRsp
10822 *
10823 *    Functionality: free F1 Setup Response allocated by aper_decoder
10824 *
10825 * @params[in] F1SetupResponse_t *f1SetRspMsg
10826 * @return void
10827 *
10828 * ****************************************************************/
10829
10830 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
10831 {
10832    uint8_t ieIdx =0;
10833    uint8_t arrIdx =0;
10834    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
10835    RRC_Version_t      *rrcVer =NULLP;
10836
10837    if(f1SetRspMsg->protocolIEs.list.array)
10838    {
10839       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
10840       {
10841          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
10842          {
10843             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
10844             {
10845                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
10846                   {
10847                      cellToActivate =
10848                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
10849                      if(cellToActivate->list.array)
10850                      {
10851                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
10852                         {
10853                            if(cellToActivate->list.array[arrIdx])
10854                            {
10855
10856                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
10857                               pLMN_Identity.buf)
10858                               {
10859                                  if(cellToActivate->list.array[0]->value.choice.\
10860                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
10861                                  {
10862                                     free(cellToActivate->list.array[0]->value.choice.\
10863                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
10864                                  }
10865
10866                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
10867                                        nRCGI.pLMN_Identity.buf);
10868                               }
10869                               free(cellToActivate->list.array[arrIdx]);
10870                            }
10871                         }
10872                         free(cellToActivate->list.array);
10873                      }
10874                      break;
10875                   }
10876                case ProtocolIE_ID_id_TransactionID:
10877                   {
10878                      break;
10879                   }
10880                case ProtocolIE_ID_id_gNB_CU_Name:
10881                   {
10882                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
10883                      break;
10884                   }
10885                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
10886                   {
10887                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
10888                      if(rrcVer->latest_RRC_Version.buf)
10889                      {
10890                         if(rrcVer->iE_Extensions)
10891                         {
10892                            if(rrcVer->iE_Extensions->list.array)
10893                            {
10894                               if(rrcVer->iE_Extensions->list.array[0])
10895                               {
10896                                  if(rrcVer->iE_Extensions->list.\
10897                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
10898                                  {
10899                                     free(rrcVer->iE_Extensions->list.\
10900                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
10901                                  }
10902                                  free(rrcVer->iE_Extensions->list.array[0]);
10903                               }
10904                               free(rrcVer->iE_Extensions->list.array);
10905                            }
10906                            free(rrcVer->iE_Extensions);
10907                         }
10908                         free(rrcVer->latest_RRC_Version.buf);
10909                      }
10910                      break;
10911
10912                   }
10913                default:
10914                   {
10915                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
10916                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
10917                   }
10918             }
10919             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
10920          }
10921       }
10922       free(f1SetRspMsg->protocolIEs.list.array);
10923    }
10924 }
10925 /******************************************************************
10926  *
10927  * @brief Processes F1 Setup Response sent by CU
10928  *
10929  * @details
10930  *
10931  *    Function : procF1SetupRsp
10932  *
10933  *    Functionality: Processes F1 Setup Response sent by CU
10934  *
10935  * @params[in] F1AP_PDU_t ASN decoded F1AP message
10936  * @return ROK     - success
10937  *         RFAILED - failure
10938  *
10939  * ****************************************************************/
10940 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
10941 {
10942    uint8_t ret = ROK;
10943    uint16_t idx =0;
10944    F1SetupResponse_t *f1SetRspMsg = NULLP;
10945    GNB_CU_Name_t     *cuName = NULLP;
10946    F1SetupRsp  f1SetRspDb;
10947    RRC_Version_t      *rrcVer =NULLP;
10948
10949    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
10950
10951    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
10952    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
10953
10954    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
10955    {
10956       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
10957       {
10958          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
10959             {
10960                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
10961                      value.choice.Cells_to_be_Activated_List);
10962                break;
10963             }
10964          case ProtocolIE_ID_id_TransactionID:
10965             {
10966                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
10967                                     value.choice.TransactionID;
10968                break;
10969             }
10970          case ProtocolIE_ID_id_gNB_CU_Name:
10971             {
10972                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
10973                         value.choice.GNB_CU_Name;
10974                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
10975                break;
10976             }
10977          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
10978             {
10979                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
10980                strcpy(f1SetRspDb.rrcVersion.rrcVer,
10981                      (const char*)rrcVer->latest_RRC_Version.buf);
10982                break;
10983             }
10984          default:
10985             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
10986                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
10987       }
10988       duProcF1SetupRsp();
10989    }
10990
10991    freeAperDecodeF1SetupRsp(f1SetRspMsg);
10992    return ret;
10993 }
10994 /*******************************************************************
10995 *
10996 * @brief free GNB DU config update ack
10997 *
10998 * @details
10999 *
11000 *    Function : freeAperDecodeGnbDuAck
11001 *
11002 *    Functionality: Processes GNB DU config update ack And
11003 *                     added free part for the memory allocated by aper_decoder
11004 *
11005 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11006 * @return ROK     - success
11007 *         RFAILED - failure
11008 *
11009 * ****************************************************************/
11010
11011 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11012 {
11013    uint8_t ieIdx = 0;
11014
11015    if(gnbDuAck->protocolIEs.list.array)
11016    {
11017       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11018       {
11019          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11020          {
11021             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11022          }
11023       }
11024       free(gnbDuAck->protocolIEs.list.array);
11025    }
11026 }
11027 /*******************************************************************
11028 *
11029 * @brief Processes GNB DU config update ack
11030 *
11031 * @details
11032 *
11033 *    Function : procF1GNBDUCfgUpdAck
11034 *
11035 *    Functionality: added free part for the memory allocated by aper_decoder
11036 *
11037 * @params[in] F1AP_PDU_t *f1apMsg
11038 * @return void
11039 *
11040 * ****************************************************************/
11041 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11042 {
11043    uint8_t ieIdx;
11044    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11045
11046    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11047    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11048
11049    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11050    {
11051       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11052       {
11053          case ProtocolIE_ID_id_TransactionID:
11054             break;
11055          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11056             break;
11057          default :
11058             DU_LOG("\nERROR  -->  F1AP: Invalid IE Received: %ld, at procF1GNBDUCfgUpdAck()", \
11059             gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11060             break;
11061       }
11062    }
11063    duProcGnbDuCfgUpdAckMsg();
11064 #if 0
11065    if(BuildAndSendF1ResetReq() != ROK)
11066    {
11067       return RFAILED;
11068    }
11069 #endif
11070
11071    freeAperDecodeGnbDuAck(gnbDuAck);
11072    return ROK;
11073 }
11074 /******************************************************************
11075 *
11076 * @brief free DL RRC Message Transfer allocated by aper_decoder
11077 *
11078 * @details
11079 *
11080 *    Function : freeAperDecodef1DlRrcMsg
11081 *
11082 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11083 *
11084 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11085 * @return ROK     - success
11086 *         RFAILED - failure
11087 *
11088 * ****************************************************************/
11089
11090 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11091 {
11092    uint8_t ieIdx =0;
11093    RRCContainer_t *rrcContainer = NULLP;
11094
11095    if(f1DlRrcMsg->protocolIEs.list.array)
11096    {
11097       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11098       {
11099          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11100          {
11101             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11102             {
11103                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11104                   break;
11105                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11106                   break;
11107                case ProtocolIE_ID_id_SRBID:
11108                   break;
11109                case ProtocolIE_ID_id_RRCContainer:
11110                   {
11111                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11112                      free(rrcContainer->buf);
11113                   }
11114                case ProtocolIE_ID_id_ExecuteDuplication:
11115                   break;
11116                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11117                   break;
11118                   break;
11119             }
11120             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11121          }
11122       }
11123       free(f1DlRrcMsg->protocolIEs.list.array);
11124    }
11125 }
11126 /******************************************************************
11127  *
11128  * @brief Processes DL RRC Message Transfer  sent by CU
11129  *
11130  * @details
11131  *
11132  *    Function : procF1DlRrcMsgTrans
11133  *
11134  *    Functionality: Processes DL RRC Message Transfer sent by CU
11135  *
11136  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11137  * @return ROK     - success
11138  *         RFAILED - failure
11139  *
11140  * ****************************************************************/
11141 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11142 {
11143    uint8_t  idx, ret;
11144    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11145    F1DlRrcMsg dlMsg;
11146    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11147
11148    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11149    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11150
11151    ret = ROK;
11152
11153    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11154    {
11155       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11156       {
11157          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11158             {
11159                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11160                break;
11161             }
11162          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11163             {
11164                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11165                break;
11166             }
11167          case ProtocolIE_ID_id_SRBID:
11168             {
11169                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11170                break;
11171             }
11172          case ProtocolIE_ID_id_ExecuteDuplication:
11173             dlMsg.execDup = true;
11174             break;
11175
11176          case ProtocolIE_ID_id_RRCContainer:
11177             {
11178                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11179                {
11180                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11181                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11182                   if(dlMsg.rrcMsgPdu)
11183                   {
11184                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11185                         dlMsg.rrcMsgSize);
11186                   }
11187                   else
11188                   {
11189                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11190                      return RFAILED;
11191                   }
11192                }
11193                else
11194                {
11195                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11196                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11197                   return RFAILED;
11198                }
11199                break;
11200             }
11201          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11202             {
11203                dlMsg.deliveryStatRpt = true;
11204                break;
11205             }
11206          default:
11207             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11208                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11209       }
11210    }
11211
11212    ret = duProcDlRrcMsg(&dlMsg);
11213
11214    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11215    return ret;
11216 }
11217
11218 /*****************************************************************i
11219  *
11220  * @brief Handles received F1AP message and sends back response
11221  *
11222  * @details
11223  *
11224  *    Function : F1APMsgHdlr
11225  *
11226  *    Functionality:
11227  *         - Decodes received F1AP control message
11228  *         - Prepares response message, encodes and sends to SCTP
11229  *
11230  * @params[in]
11231  * @return ROK     - success
11232  *         RFAILED - failure
11233  *
11234  * ****************************************************************/
11235 void F1APMsgHdlr(Buffer *mBuf)
11236 {
11237    int i =0;
11238    char *recvBuf =NULLP;
11239    MsgLen copyCnt =0;
11240    MsgLen recvBufLen =0;
11241    F1AP_PDU_t *f1apMsg =NULLP;
11242    asn_dec_rval_t rval; /* Decoder return value */
11243    F1AP_PDU_t f1apasnmsg ;
11244    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
11245    ODU_PRINT_MSG(mBuf, 0,0);
11246
11247    /* Copy mBuf into char array to decode it */
11248    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
11249    DU_ALLOC(recvBuf, (Size)recvBufLen);
11250
11251    if(recvBuf == NULLP)
11252    {
11253       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
11254       return;
11255    }
11256    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
11257    {
11258       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
11259       return;
11260    }
11261
11262    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
11263    for(i=0; i< recvBufLen; i++)
11264    {
11265       printf("%x",recvBuf[i]);
11266    }
11267
11268    /* Decoding flat buffer into F1AP messsage */
11269    f1apMsg = &f1apasnmsg;
11270    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
11271
11272    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
11273    DU_FREE(recvBuf, (Size)recvBufLen);
11274
11275    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
11276    {
11277       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
11278       return;
11279    }
11280    printf("\n");
11281    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11282
11283    switch(f1apMsg->present)
11284    {
11285       case F1AP_PDU_PR_successfulOutcome:
11286          {
11287             switch(f1apMsg->choice.successfulOutcome->value.present)
11288             {
11289                case SuccessfulOutcome__value_PR_ResetAcknowledge:
11290                   {
11291                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
11292                      break;
11293                   }
11294                case SuccessfulOutcome__value_PR_F1SetupResponse:
11295                   {
11296 #ifndef ODU_TEST_STUB
11297                      procF1SetupRsp(f1apMsg);
11298 #endif
11299                      break;
11300                   }
11301
11302                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
11303                   {
11304                      procF1GNBDUCfgUpdAck(f1apMsg);
11305                      break;
11306                   }
11307
11308                default:
11309                   {
11310                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
11311                      f1apMsg->choice.successfulOutcome->value.present);
11312                      return;
11313                   }
11314             }/* End of switch(successfulOutcome) */
11315             free(f1apMsg->choice.successfulOutcome);
11316             break;
11317          }
11318       case F1AP_PDU_PR_initiatingMessage:
11319          {
11320             switch(f1apMsg->choice.initiatingMessage->value.present)
11321             {
11322                case InitiatingMessage__value_PR_Reset:
11323                   {
11324                      procF1ResetReq(f1apMsg);
11325                      break;
11326                   }
11327                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
11328                   {
11329                      procF1DlRrcMsgTrans(f1apMsg);
11330                      break;
11331                   }
11332                case InitiatingMessage__value_PR_UEContextSetupRequest:
11333                   {
11334                      procF1UeContextSetupReq(f1apMsg);
11335                      break;
11336                   }
11337                default:
11338                   {
11339                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
11340                            f1apMsg->choice.initiatingMessage->value.present);
11341                      return;
11342                   }
11343             }/* End of switch(initiatingMessage) */
11344             free(f1apMsg->choice.initiatingMessage);
11345             break;
11346          }
11347
11348       default:
11349          {
11350             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
11351             return;
11352          }
11353          free(f1apMsg);
11354
11355    }/* End of switch(f1apMsg->present) */
11356
11357 } /* End of F1APMsgHdlr */
11358
11359 /**********************************************************************
11360   End of file
11361  **********************************************************************/