src/du_app/du_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 message handling functionality for DU APP */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.h"
  24 #include "kwu.h"
  25 #include "lrg.x"
  26 #include "lkw.x"
  27 #include "kwu.x"
  28 #include "du_app_mac_inf.h"
  29 #include "du_app_rlc_inf.h"
  30 #include "du_cfg.h"
  31 #include "du_app_rlc_inf.h"
  32 #include "du_mgr.h"
  33 #include "du_sctp.h"
  34 #include "F1AP-PDU.h"
  35 #include "du_f1ap_msg_hdl.h"
  36 #include "du_ue_mgr.h"
  37 #include "lsctp.h"
  38 #include "legtp.h"
  39 #include "lphy_stub.h"
  40 #include "du_utils.h"
  41
  42 uint8_t rlcDlCfg = 0;
  43 uint8_t numRlcDlSaps = 0;
  44 uint8_t rlcUlCfg = 0;
  45 uint8_t numRlcMacSaps = 0;
  46 uint8_t macCfg = 0;
  47 uint8_t macCfgInst = 0;
  48
  49 extern DuCfgParams duCfgParam;
  50 extern uint8_t packRlcConfigReq(Pst *pst, RlcMngmt *cfg);
  51 extern uint8_t cmPkLkwCntrlReq(Pst *pst, RlcMngmt *cfg);
  52 extern uint8_t cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg);
  53 extern uint8_t BuildAndSendE2SetupReq();
  54 extern uint8_t egtpHdlDatInd(EgtpMsg egtpMsg);
  55 extern uint8_t BuildAndSendDUConfigUpdate();
  56 extern uint16_t getTransId();
  57 extern uint8_t cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg);
  58
  59 packMacCellCfgReq packMacCellCfgOpts[] =
  60 {
  61    packMacCellCfg, /* packing for loosely coupled */
  62    MacProcCellCfgReq, /* packing for tightly coupled */
  63    packMacCellCfg, /* packing for light weight loosly coupled */
  64 };
  65
  66 DuMacCellStartReq packMacCellStartReqOpts[] =
  67 {
  68    packMacCellStartReq,   /* Loose coupling */
  69    MacProcCellStartReq,    /* TIght coupling */
  70    packMacCellStartReq    /* Light weight-loose coupling */
  71 };
  72
  73 DuMacCellStopReq packMacCellStopReqOpts[] =
  74 {
  75    packMacCellStopReq,   /* Loose coupling */
  76    MacProcCellStopReq,    /* TIght coupling */
  77    packMacCellStopReq    /* Light weight-loose coupling */
  78 };
  79
  80 /**************************************************************************
  81  * @brief Function to fill configs required by RLC
  82  *
  83  * @details
  84  *
  85  *      Function : duBuildRlcCfg
  86  *
  87  *      Functionality:
  88  *           Initiates general Configs towards RLC
  89  *
  90  * @param[in] Inst  Specifies if RLC UL or RLC DL instance
  91  * @return ROK     - success
  92  *         RFAILED - failure
  93  *
  94  ***************************************************************************/
  95 uint8_t duBuildRlcCfg(Inst inst)
  96 {
  97    RlcMngmt   rlcMngmt;
  98    RlcGenCfg  *genCfg = NULLP;
  99    Pst pst;
 100
 101    DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
 102    DU_SET_ZERO(&pst, sizeof(Pst));
 103
 104    genCfg   = &(rlcMngmt.t.cfg.s.gen);
 105
 106    /*----------- Fill General Configuration Parameters ---------*/
 107    genCfg->maxUe       = duCfgParam.maxUe;
 108    genCfg->maxKwuSaps  = 2;
 109    genCfg->maxUdxSaps  = 1;
 110    genCfg->rlcMode     = (inst == RLC_UL_INST) ?
 111       LKW_RLC_MODE_UL : LKW_RLC_MODE_DL;
 112    genCfg->timeRes     = 1;
 113    genCfg->maxRguSaps  = DEFAULT_CELLS;
 114
 115    /*----------- Fill lmPst
 116     * Parameters ---------*/
 117    genCfg->lmPst.dstProcId = DU_PROC;
 118    genCfg->lmPst.srcProcId = DU_PROC;
 119    genCfg->lmPst.dstEnt    = ENTDUAPP;
 120    genCfg->lmPst.dstInst   = DU_INST;
 121    genCfg->lmPst.srcEnt    = ENTRLC;
 122    genCfg->lmPst.srcInst   = inst;
 123    genCfg->lmPst.prior     = PRIOR0;
 124    genCfg->lmPst.route     = RTESPEC;
 125    genCfg->lmPst.region    = (inst == RLC_UL_INST) ?
 126       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 127    genCfg->lmPst.pool      = RLC_POOL;
 128    genCfg->lmPst.selector  = ODU_SELECTOR_LC;
 129
 130    /* Fill Header */
 131    rlcMngmt.hdr.msgType             = TCFG;
 132    rlcMngmt.hdr.msgLen              = 0;
 133    rlcMngmt.hdr.entId.ent           = ENTRLC;
 134    rlcMngmt.hdr.entId.inst          = (Inst)0;
 135    rlcMngmt.hdr.elmId.elmnt         = STGEN;
 136    rlcMngmt.hdr.seqNmb              = 0;
 137    rlcMngmt.hdr.version             = 0;
 138    rlcMngmt.hdr.transId             = 0;
 139    rlcMngmt.hdr.response.prior      = PRIOR0;
 140    rlcMngmt.hdr.response.route      = RTESPEC;
 141    rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
 142       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 143    rlcMngmt.hdr.response.mem.pool   = DU_POOL;
 144    rlcMngmt.hdr.response.selector   = ODU_SELECTOR_LC;
 145
 146    /* Fill Pst */
 147    pst.selector  = ODU_SELECTOR_LC;
 148    pst.srcEnt    = ENTDUAPP;
 149    pst.dstEnt    = ENTRLC;
 150    pst.dstInst   = inst;
 151    pst.dstProcId = DU_PROC;
 152    pst.srcProcId = DU_PROC;
 153    pst.region    = duCb.init.region;
 154
 155    DU_LOG("\nDU_APP : RLC Gen Cfg Req sent for inst %d", inst);
 156
 157    /* Send the request to RLC */
 158    packRlcConfigReq(&pst, &rlcMngmt);
 159
 160    return ROK;
 161 }
 162
 163 /**************************************************************************
 164  * @brief Function to fill configs required by RLC
 165  *
 166  * @details
 167  *
 168  *      Function : duBuildRlcLsapCfg
 169  *
 170  *      Functionality:
 171  *           Initiates general Configs towards RLC
 172  *
 173  * @param[in] Inst  Specifies if RLC UL or RLC DL instance
 174  * @return ROK     - success
 175  *         RFAILED - failure
 176  *
 177  ***************************************************************************/
 178 uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst)
 179 {
 180
 181    RlcMngmt    rlcMngmt;
 182    RlcSapCfg   *lSap = NULLP;
 183    Pst        pst;
 184
 185    DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
 186    DU_SET_ZERO(&pst, sizeof(Pst));
 187
 188    /* Fill Header */
 189    rlcMngmt.hdr.msgType             = TCFG;
 190    rlcMngmt.hdr.entId.ent           = ENTRLC;
 191    rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
 192       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 193
 194    rlcMngmt.hdr.response.mem.pool   = RLC_POOL;
 195
 196    /* Fill Pst */
 197    pst.selector  = ODU_SELECTOR_LC;
 198    pst.srcEnt    = ENTDUAPP;
 199    pst.dstEnt    = ENTRLC;
 200    pst.dstProcId = DU_PROC;
 201    pst.dstInst   = inst;
 202    pst.srcProcId = DU_PROC;
 203    pst.region    = duCb.init.region;
 204    lSap   = &(rlcMngmt.t.cfg.s.sap);
 205
 206    lSap->mem.region = (inst == RLC_UL_INST) ?
 207       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 208    lSap->mem.pool    = RLC_POOL;
 209    lSap->mem.spare   = 0;
 210    lSap->bndTmrIntvl = 10;
 211    lSap->priority    = PRIOR0;
 212    lSap->route       = RTESPEC;
 213    if (ent == ENTMAC)
 214    {
 215       lSap->procId      = DU_PROC;
 216       lSap->ent         = ENTMAC;
 217       lSap->inst        = lsapInst;
 218       lSap->sapId       = lsapInst;      /* SapId will be stored as suId in MAC */
 219       lSap->selector    = (inst == RLC_UL_INST) ? ODU_SELECTOR_LWLC : ODU_SELECTOR_TC;
 220       rlcMngmt.hdr.elmId.elmnt  = STRGUSAP;
 221       DU_LOG("\nDU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst);
 222
 223    }
 224    else
 225    {
 226       lSap->procId    = DU_PROC;
 227       lSap->ent       = ENTRLC;
 228       lSap->inst      = (inst == RLC_UL_INST) ?
 229          RLC_DL_INST : RLC_UL_INST;
 230       lSap->sapId       = 0;
 231       lSap->selector = ODU_SELECTOR_LC;
 232       rlcMngmt.hdr.elmId.elmnt  = STUDXSAP;
 233       DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
 234    }
 235
 236    packRlcConfigReq(&pst, &rlcMngmt);
 237    return ROK;
 238 }
 239
 240 /**************************************************************************
 241  * @brief Function to fill configs required by RLC
 242  *
 243  * @details
 244  *
 245  *      Function : duBuildRlcUsapCfg
 246  *
 247  *      Functionality:
 248  *           Initiates general Configs towards RLC
 249  *
 250  * @param[in] Inst  Specifies if RLC UL or RLC DL instance
 251  * @return ROK     - success
 252  *         RFAILED - failure
 253  *
 254  ***************************************************************************/
 255 uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst)
 256 {
 257    RlcMngmt    rlcMngmt;
 258    RlcSapCfg   *uSap = NULLP;
 259    Pst        pst;
 260
 261    DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
 262    DU_SET_ZERO(&pst, sizeof(Pst));
 263
 264    uSap   = &(rlcMngmt.t.cfg.s.sap);
 265
 266    uSap->selector   = ODU_SELECTOR_LC;
 267    uSap->mem.region = (inst == RLC_UL_INST) ?
 268       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 269    uSap->mem.pool = RLC_POOL;
 270    uSap->mem.spare = 0;
 271
 272    uSap->procId = DU_PROC;
 273    uSap->ent = ENTRLC;
 274    uSap->sapId = 0;
 275
 276    uSap->inst = (inst == RLC_UL_INST) ?
 277       RLC_DL_INST : RLC_UL_INST;
 278    uSap->bndTmrIntvl = 1000;
 279    uSap->priority = PRIOR0;
 280    uSap->route = RTESPEC;
 281
 282    /* Fill Header */
 283    rlcMngmt.hdr.msgType             = TCFG;
 284    rlcMngmt.hdr.entId.ent           = ENTRLC;
 285    rlcMngmt.hdr.elmId.elmnt         = STUDXSAP;
 286    rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
 287       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 288
 289    rlcMngmt.hdr.response.mem.pool   = RLC_POOL;
 290
 291    /* Fill Pst */
 292    pst.selector  = ODU_SELECTOR_LC;
 293    pst.srcEnt    = ENTDUAPP;
 294    pst.dstEnt    = ENTRLC;
 295    pst.dstProcId = DU_PROC;
 296    pst.dstInst = inst;
 297    pst.srcProcId = DU_PROC;
 298    pst.region = duCb.init.region;
 299
 300    DU_LOG("\nDU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
 301    packRlcConfigReq(&pst, &rlcMngmt);
 302
 303    return ROK;
 304 }
 305
 306 /**************************************************************************
 307  * @brief Function to populate internal DS of DU APP
 308  *
 309  * @details
 310  *
 311  *      Function : duProcCfgComplete
 312  *
 313  *      Functionality:
 314  *           Populates internal data structures of DU APP after
 315  *           receiving configurations.
 316  *
 317  * @param[in]  void
 318  * @return ROK     - success
 319  *         RFAILED - failure
 320  *
 321  ***************************************************************************/
 322 uint8_t duProcCfgComplete()
 323 {
 324    uint8_t ret = ROK;
 325    static uint16_t cellId = 0;
 326    uint16_t idx;
 327    for(idx=0; idx< DEFAULT_CELLS; idx++)
 328    {
 329       DuCellCb *cell = NULLP;
 330       DU_ALLOC(cell, sizeof(DuCellCb))
 331          if(cell == NULLP)
 332          {
 333             DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete");
 334             ret = RFAILED;
 335          }
 336          else
 337          {
 338             uint32_t nci;
 339             uint8_t idx1;
 340             memset(cell, 0, sizeof(DuCellCb));
 341             cell->cellId = ++cellId;
 342             cell->cellInfo.nrEcgi.plmn.mcc[0] = PLMN_MCC0;
 343             cell->cellInfo.nrEcgi.plmn.mcc[1] = PLMN_MCC1;
 344             cell->cellInfo.nrEcgi.plmn.mcc[2] = PLMN_MCC2;
 345             cell->cellInfo.nrEcgi.plmn.mnc[0] = PLMN_MNC0;
 346             cell->cellInfo.nrEcgi.plmn.mnc[1] = PLMN_MNC1;
 347             cell->cellInfo.nrEcgi.plmn.mnc[2] = PLMN_MNC2;
 348             cell->cellInfo.nrEcgi.cellId = NR_CELL_ID;
 349             cell->cellInfo.nrPci = NR_PCI;
 350             cell->cellInfo.fiveGsTac = DU_TAC;
 351             for(idx1=0; idx1<MAX_PLMN; idx1++)
 352             {
 353                cell->cellInfo.plmn[idx1].mcc[0] = PLMN_MCC0;
 354                cell->cellInfo.plmn[idx1].mcc[1] = PLMN_MCC1;
 355                cell->cellInfo.plmn[idx1].mcc[2] = PLMN_MCC2;
 356                cell->cellInfo.plmn[idx1].mnc[0] = PLMN_MNC0;
 357                cell->cellInfo.plmn[idx1].mnc[1] = PLMN_MNC1;
 358                cell->cellInfo.plmn[idx1].mnc[2] = PLMN_MNC2;
 359             }
 360             cell->cellInfo.maxUe = duCfgParam.maxUe;
 361             cell->cellStatus = CELL_OUT_OF_SERVICE;
 362             nci = (uint16_t)cell->cellInfo.nrEcgi.cellId;
 363
 364             duCb.cfgCellLst[nci-1] = cell;
 365             duCb.numCfgCells++;
 366          }
 367       }
 368    if(ret != RFAILED)
 369    {
 370       //Start layer configs
 371       ret = duSendRlcUlCfg();
 372    }
 373    return ret;
 374 }
 375 /**************************************************************************
 376  * @brief Function to invoke DU Layer Configs
 377  *
 378  * @details
 379  *
 380  *      Function : duSendRlcUlCfg
 381  *
 382  *      Functionality:
 383  *           Initiates Configs towards layers of DU
 384  *
 385  * @param[in]  void
 386  * @return ROK     - success
 387  *         RFAILED - failure
 388  *
 389  ***************************************************************************/
 390 uint8_t duSendRlcUlCfg()
 391 {
 392    uint8_t cellIdx;
 393
 394    duBuildRlcCfg((Inst)RLC_UL_INST);
 395    for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++)
 396    {
 397       duBuildRlcLsapCfg(ENTMAC, (Inst)RLC_UL_INST, cellIdx);
 398    }
 399    duBuildRlcLsapCfg(ENTRLC, (Inst)RLC_UL_INST, 0);
 400
 401    return ROK;
 402 }
 403
 404 /**************************************************************************
 405  * @brief Function to invoke DU Layer Configs
 406  *
 407  * @details
 408  *
 409  *      Function : duSendRlcDlCfg
 410  *
 411  *      Functionality:
 412  *           Initiates Configs towards layers of DU
 413  *
 414  * @param[in]  void
 415  * @return ROK     - success
 416  *         RFAILED - failure
 417  *
 418  ***************************************************************************/
 419 uint8_t duSendRlcDlCfg()
 420 {
 421    uint8_t cellIdx;
 422
 423    duBuildRlcCfg((Inst)RLC_DL_INST);
 424    duBuildRlcUsapCfg(STUDXSAP, ENTRLC, (Inst)RLC_DL_INST);
 425    for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++)
 426    {
 427       duBuildRlcLsapCfg(ENTMAC, (Inst)RLC_DL_INST, cellIdx);
 428    }
 429
 430    return ROK;
 431 }
 432 /**************************************************************************
 433  * @brief Function to handle Config Confirm from RLC
 434  *
 435  * @details
 436  *
 437  *      Function : DuHdlRlcCfgComplete
 438  *
 439  *      Functionality:
 440  *           Handles Gen Config Confirm from RLC
 441  *
 442  * @param[in]  Pst     *pst, Post structure of the primitive.
 443  * @param[in]  RlcMngmt *cfm, Unpacked primitive info received from RLC
 444  * @return ROK     - success
 445  *         RFAILED - failure
 446  *
 447  ***************************************************************************/
 448 uint8_t DuHdlRlcCfgComplete(Pst *pst, RlcMngmt *cfm)
 449 {
 450    uint8_t ret = ROK;
 451    if (pst->srcInst == RLC_UL_INST)
 452    {
 453       ret = duProcRlcUlCfgComplete(pst, cfm);
 454    }
 455    else
 456    {
 457       ret = duProcRlcDlCfgComplete(pst, cfm);
 458    }
 459    return ret;
 460 }
 461
 462 /**************************************************************************
 463  * @brief Function to handle Control Config Confirm from RLC
 464  *
 465  * @details
 466  *
 467  *      Function : duHdlRlcCntrlCfgComplete
 468  *
 469  *      Functionality:
 470  *           Handles Control Config Confirm from RLC
 471  *
 472  * @param[in]  Pst     *pst, Post structure of the primitive.
 473  * @param[in]  RlcMngmt *cfm, Unpacked primitive info received from RLC
 474  * @return ROK     - success
 475  *         RFAILED - failure
 476  *
 477  ***************************************************************************/
 478 uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cntrl)
 479 {
 480    uint8_t ret = ROK;
 481
 482    if (cntrl->cfm.status == LCM_PRIM_OK)
 483    {
 484       switch (cntrl->hdr.elmId.elmnt)
 485       {
 486          case  STRGUSAP:
 487             {
 488                if (pst->srcInst == RLC_DL_INST)
 489                {
 490                   DU_LOG("\nDU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL");
 491                   macCfgInst++;
 492                   if(macCfgInst < DEFAULT_CELLS)
 493                   {
 494                      macCfgInst = 0;
 495                      duBindUnbindRlcToMacSap((Inst) RLC_DL_INST, ABND);
 496                   }
 497                   else
 498                   {
 499                      duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND);
 500                   }
 501                }
 502                else
 503                {
 504                   DU_LOG("\nDU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL");
 505                   macCfgInst++;
 506                   if(macCfgInst < DEFAULT_CELLS)
 507                   {
 508                      duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND);
 509                   }
 510                   else
 511                   {
 512                      duSendSchCfg();
 513                   }
 514                   break;
 515                }
 516             }
 517
 518       }
 519    }
 520    return ret;
 521 }
 522 /**************************************************************************
 523  * @brief Function to handle Config Confirm from RLC UL
 524  *
 525  * @details
 526  *
 527  *      Function : duHdlRlcUlCfgComplete
 528  *
 529  *      Functionality:
 530  *           Handles Config Confirm from RLC UL
 531  *
 532  * @param[in]  Pst     *pst, Post structure of the primitive.
 533  * @param[in]  RlcMngmt *cfm, Unpacked primitive info received from RLC UL
 534  * @return ROK     - success
 535  *         RFAILED - failure
 536  *
 537  ***************************************************************************/
 538 uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm)
 539 {
 540    uint8_t ret;
 541
 542    DU_LOG("\nDU_APP : RLC UL Cfg Status %d", cfm->cfm.status);
 543    if (cfm->cfm.status == LCM_PRIM_OK)
 544    {
 545       switch(cfm->hdr.elmId.elmnt)
 546       {
 547          case STGEN:
 548             {
 549                rlcUlCfg |= RLC_GEN_CFG;
 550                break;
 551             }
 552          case STRGUSAP:
 553             {
 554                numRlcMacSaps++;
 555                if(numRlcMacSaps == DEFAULT_CELLS)
 556                {
 557                   rlcUlCfg |= RLC_MAC_SAP_CFG;
 558                   numRlcMacSaps = 0;
 559                }
 560                break;
 561             }
 562          case STUDXSAP:
 563             {
 564                rlcUlCfg |= RLC_UDX_SAP_CFG;
 565                break;
 566
 567             }
 568          default:
 569             break;
 570       }
 571       DU_LOG("\nDU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
 572       if(rlcUlCfg == DU_RLC_UL_CONFIGURED)
 573       {
 574          rlcUlCfg = 0;
 575          numRlcMacSaps = 0;
 576          //Start configuration of RLC DL
 577          duSendRlcDlCfg();
 578
 579       }
 580    }
 581    else
 582    {
 583       DU_LOG("\nDU_APP : Config confirm NOK from RLC UL");
 584       ret = RFAILED;
 585    }
 586    return ret;
 587 }
 588
 589 /**************************************************************************
 590  * @brief Function to handle Config Confirm from RLC DL
 591  *
 592  * @details
 593  *
 594  *      Function : duHdlRlcDlCfgComplete
 595  *
 596  *      Functionality:
 597  *           Handles Config Confirm from RLC DL
 598  *
 599  * @param[in]  Pst     *pst, Post structure of the primitive.
 600  * @param[in]  RlcMngmt *cfm, Unpacked primitive info received from RLC DL
 601  * @return ROK     - success
 602  *         RFAILED - failure
 603  *
 604  ***************************************************************************/
 605 uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm)
 606 {
 607    DU_LOG("\nDU_APP : RLC DL Cfg Status %d", cfm->cfm.status);
 608    if (cfm->cfm.status == LCM_PRIM_OK)
 609    {
 610       switch(cfm->hdr.elmId.elmnt)
 611       {
 612          case STGEN:
 613             {
 614                rlcDlCfg |= RLC_GEN_CFG;
 615                break;
 616             }
 617          case STRGUSAP:
 618             {
 619                numRlcMacSaps++;
 620                if(numRlcMacSaps == DEFAULT_CELLS)
 621                {
 622                   rlcDlCfg |= RLC_MAC_SAP_CFG;
 623                   numRlcMacSaps = 0;
 624                }
 625                break;
 626             }
 627          case STUDXSAP:
 628             {
 629                rlcDlCfg |= RLC_UDX_SAP_CFG;
 630                break;
 631
 632             }
 633          default:
 634             break;
 635
 636       }
 637       DU_LOG("\nDU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
 638       if(rlcDlCfg == DU_RLC_DL_CONFIGURED)
 639       {
 640          rlcDlCfg = 0;
 641          //Start configuration of MAC
 642          duSendMacCfg();
 643
 644       }
 645    }
 646    else
 647    {
 648       DU_LOG("\nDU_APP : Config confirm NOK from RLC DL");
 649    }
 650    return ROK;
 651 }
 652
 653 /**************************************************************************
 654  * @brief Function to send configs to MAC
 655  *
 656  * @details
 657  *
 658  *      Function : duSendMacCfg
 659  *
 660  *      Functionality:
 661  *           Initiates Configs towards MAC layer
 662  *
 663  * @param[in]  void
 664  * @return ROK     - success
 665  *         RFAILED - failure
 666  *
 667  ***************************************************************************/
 668 uint8_t duSendMacCfg()
 669 {
 670    duBuildMacGenCfg();
 671    duBuildMacUsapCfg(RLC_UL_INST);
 672    duBuildMacUsapCfg(RLC_DL_INST);
 673
 674    return ROK;
 675 }
 676
 677 /**************************************************************************
 678  * @brief Function to fill gen config required by MAC
 679  *
 680  * @details
 681  *
 682  *      Function : duBuildMacGenCfg
 683  *
 684  *      Functionality:
 685  *           Initiates general Configs towards MAC
 686  *
 687  * @param[in] void
 688  * @return ROK     - success
 689  *         RFAILED - failure
 690  *
 691  ***************************************************************************/
 692 uint8_t duBuildMacGenCfg()
 693 {
 694    RgMngmt       rgMngmt;
 695    RgGenCfg      *genCfg=NULLP;
 696    Pst           pst;
 697
 698    DU_SET_ZERO(&pst, sizeof(Pst));
 699    DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt));
 700
 701    genCfg   = &(rgMngmt.t.cfg.s.genCfg);
 702
 703    /*----------- Fill General Configuration Parameters ---------*/
 704    genCfg->mem.region = MAC_MEM_REGION;
 705    genCfg->mem.pool   = MAC_POOL;
 706    genCfg->tmrRes     = 10;
 707    genCfg->numRguSaps = 2;
 708
 709    genCfg->lmPst.dstProcId = DU_PROC;
 710    genCfg->lmPst.srcProcId = DU_PROC;
 711    genCfg->lmPst.dstEnt    = ENTDUAPP;
 712    genCfg->lmPst.dstInst   = 0;
 713    genCfg->lmPst.srcEnt    = ENTMAC;
 714    genCfg->lmPst.srcInst   = macCfgInst;
 715    genCfg->lmPst.prior     = PRIOR0;
 716    genCfg->lmPst.route     = RTESPEC;
 717    genCfg->lmPst.region    = MAC_MEM_REGION;
 718    genCfg->lmPst.pool      = MAC_POOL;
 719    genCfg->lmPst.selector  = ODU_SELECTOR_LC;
 720
 721    /* Fill Header */
 722    rgMngmt.hdr.msgType             = TCFG;
 723    rgMngmt.hdr.msgLen              = 0;
 724    rgMngmt.hdr.entId.ent           = ENTMAC;
 725    rgMngmt.hdr.entId.inst          = (Inst)0;
 726    rgMngmt.hdr.elmId.elmnt         = STGEN;
 727    rgMngmt.hdr.seqNmb              = 0;
 728    rgMngmt.hdr.version             = 0;
 729    rgMngmt.hdr.transId             = 0;
 730
 731    rgMngmt.hdr.response.prior      = PRIOR0;
 732    rgMngmt.hdr.response.route      = RTESPEC;
 733    rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
 734    rgMngmt.hdr.response.mem.pool   = MAC_POOL;
 735    rgMngmt.hdr.response.selector   = ODU_SELECTOR_LC;
 736
 737    /* Fill Pst */
 738    pst.selector  = ODU_SELECTOR_LC;
 739    pst.srcEnt    = ENTDUAPP;
 740    pst.dstEnt    = ENTMAC;
 741    pst.dstInst   = macCfgInst;
 742    pst.dstProcId = DU_PROC;
 743    pst.srcProcId = DU_PROC;
 744    pst.region = duCb.init.region;
 745
 746    DU_LOG("\nDU_APP : MAC Gen Cfg Req sent");
 747
 748    /* Send the request to MAC */
 749    cmPkLrgCfgReq(&pst, &rgMngmt);
 750
 751    return ROK;
 752 }
 753
 754 /**************************************************************************
 755  * @brief Function to fill USAP config required by MAC
 756  *
 757  * @details
 758  *
 759  *      Function : duBuildMacUsapCfg
 760  *
 761  *      Functionality:
 762  *           Initiates USAP Configs towards MAC
 763  *
 764  * @param[in] SpId  Specifies if RLC UL or RLC DL instance
 765  * @return ROK     - success
 766  *         RFAILED - failure
 767  *
 768  ***************************************************************************/
 769 uint8_t duBuildMacUsapCfg(SpId sapId)
 770 {
 771    RgMngmt     rgMngmt;
 772    RgUpSapCfg  *uSap = NULLP;
 773    Pst         pst;
 774
 775    DU_SET_ZERO(&pst, sizeof(Pst));
 776    DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt));
 777
 778    uSap   = &(rgMngmt.t.cfg.s.rguSap);
 779
 780    uSap->mem.region = MAC_MEM_REGION;
 781    uSap->mem.pool   = MAC_POOL;
 782    uSap->suId       = 0;
 783    uSap->spId       = sapId;
 784    uSap->procId     = DU_PROC;
 785    uSap->ent        = ENTRLC;
 786    uSap->inst       = sapId;
 787    uSap->prior      = PRIOR0;
 788    uSap->route      = RTESPEC;
 789    uSap->selector   = ODU_SELECTOR_LC ;
 790
 791    /* fill header */
 792    rgMngmt.hdr.msgType             = TCFG;
 793    rgMngmt.hdr.entId.ent           = ENTMAC;
 794    rgMngmt.hdr.entId.inst          = (Inst)0;
 795    rgMngmt.hdr.elmId.elmnt         = STRGUSAP;
 796    rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
 797    rgMngmt.hdr.response.mem.pool   = MAC_POOL;
 798
 799    /* fill pst */
 800    pst.selector  = ODU_SELECTOR_LC;
 801    pst.srcEnt    = ENTDUAPP;
 802    pst.dstEnt    = ENTMAC;
 803    pst.dstInst   = macCfgInst;
 804    pst.dstProcId = DU_PROC;
 805    pst.srcProcId = DU_PROC;
 806    pst.region    = duCb.init.region;
 807
 808    DU_LOG("\nDU_APP : MAC Rgu USap Cfg Req sent");
 809
 810    /* Send the request to MAC */
 811    cmPkLrgCfgReq(&pst, &rgMngmt);
 812
 813    return ROK;
 814 }
 815
 816 /**************************************************************************
 817  * @brief Function to handle Config Confirm from MAC
 818  *
 819  * @details
 820  *
 821  *      Function : duHdlMacCfgComplete
 822  *
 823  *      Functionality:
 824  *           Handles Gen Config Confirm from MAC
 825  *
 826  * @param[in]  Pst     *pst, Post structure of the primitive.
 827  * @param[in]  RgMngmt *cfm, Unpacked primitive info received from MAC
 828  * @return ROK     - success
 829  *         RFAILED - failure
 830  *
 831  ***************************************************************************/
 832 uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm)
 833 {
 834    uint8_t ret = ROK;
 835
 836    if (cfm->cfm.status == LCM_PRIM_OK)
 837    {
 838       switch (cfm->hdr.elmId.elmnt)
 839       {
 840          case STGEN:
 841             {
 842                macCfg |= MAC_GEN_CFG;
 843                break;
 844             }
 845          case STRGUSAP:
 846             {
 847                macCfg |= MAC_SAP_CFG;
 848                numRlcMacSaps++;
 849                break;
 850             }
 851          default:
 852             break;
 853       }
 854       DU_LOG("\nDU_APP : MAC Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt);
 855       if(macCfg == MAC_CONFIGURED && numRlcMacSaps == MAX_MAC_SAP)
 856       {
 857          macCfg = 0;
 858          DU_LOG("\nDU_APP : Completed sending Configs");
 859          macCfgInst = 0;
 860          duBindUnbindRlcToMacSap(RLC_DL_INST, ABND);
 861       }
 862
 863    }
 864    else
 865    {
 866       DU_LOG("\nDU_APP : Config confirm NOK from MAC");
 867       ret = RFAILED;
 868    }
 869    return ret;
 870 }
 871
 872 /**************************************************************************
 873  * @brief Function to bind/unbind RLC to MAC SAP
 874  *
 875  * @details
 876  *
 877  *      Function : duBindUnbindRlcToMacSap
 878  *
 879  *      Functionality:
 880  *           Initiates Bind/Unbind from RLC to MAC
 881  *
 882  * @param[in] Inst   Specifies if RLC UL or RLC DL instance
 883  * @param[in] action Specifies if action is bind or unbind
 884  * @return ROK     - success
 885  *         RFAILED - failure
 886  *
 887  ***************************************************************************/
 888 uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action)
 889 {
 890    RlcCntrl  *cntrl = NULLP;
 891    RlcMngmt  rlcMngmt;
 892    Pst      pst;
 893
 894    TRC2(smBindKwToRguSap)
 895
 896       DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
 897    DU_SET_ZERO(&pst, sizeof(Pst));
 898
 899    if (action == ABND)
 900    {
 901       DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst);
 902    }
 903    else
 904    {
 905       DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst);
 906    }
 907    cntrl = &(rlcMngmt.t.cntrl);
 908
 909    cntrl->action            =  action;
 910    cntrl->subAction         =  DU_ZERO_VAL;
 911    cntrl->s.sapCntrl.suId   =  macCfgInst;
 912    cntrl->s.sapCntrl.spId   =  inst;
 913
 914    /* Fill header */
 915    rlcMngmt.hdr.msgType             = TCNTRL;
 916    rlcMngmt.hdr.entId.ent           = ENTRLC;
 917    rlcMngmt.hdr.entId.inst          = inst;
 918    rlcMngmt.hdr.elmId.elmnt         = 186; /* ambiguous defines in lkw.h and lrg.h so direct hardcoded*/
 919    rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ?
 920       RLC_UL_MEM_REGION:RLC_DL_MEM_REGION;
 921    rlcMngmt.hdr.response.mem.pool   = RLC_POOL;
 922
 923    /* Fill pst */
 924    pst.selector  = ODU_SELECTOR_LC;
 925    pst.srcEnt    = ENTDUAPP;
 926    pst.dstEnt    = ENTRLC;
 927    pst.dstProcId = DU_PROC;
 928    pst.dstInst   = inst;
 929    pst.srcProcId = DU_PROC;
 930    pst.region    = duCb.init.region;
 931
 932    cmPkLkwCntrlReq(&pst, &rlcMngmt);
 933
 934    return ROK;
 935 }
 936 /*******************************************************************
 937  *
 938  * @brief Handles SCTP notifications
 939  *
 940  * @details
 941  *
 942  *    Function : duSctpNtfyHdl
 943  *
 944  *    Functionality:
 945  *         Handles SCTP notification
 946  *
 947  * @params[in] Message Buffer
 948  *             SCTP notification
 949  *
 950  * @return ROK     - success
 951  *         RFAILED - failure
 952  *
 953  * ****************************************************************/
 954
 955 uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy)
 956 {
 957    if(f1Params.assocId == ntfy->u.assocChange.assocId)
 958    {
 959       if(BuildAndSendF1SetupReq() != ROK)
 960       {
 961          return RFAILED;
 962       }
 963    }
 964    else if(ricParams.assocId == ntfy->u.assocChange.assocId)
 965    {
 966       if(BuildAndSendE2SetupReq() != ROK)
 967       {
 968          return RFAILED;
 969       }
 970    }
 971    else
 972    {
 973       DU_LOG("\nDU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId);
 974       return RFAILED;
 975    }
 976    return ROK;
 977 }
 978
 979 /*******************************************************************
 980  *
 981  * @brief  Fills Pst struct for ENTEGTP
 982  *
 983  * @details
 984  *
 985  *    Function : duFillEgtpPst
 986  *
 987  *    Functionality:
 988  *       Fills Pst struct for ENTEGTP
 989  *
 990  * @params[in]
 991  * @return ROK     - success
 992  *         RFAILED - failure
 993  *
 994  * ****************************************************************/
 995 uint8_t duFillEgtpPst(Pst *pst, Event event)
 996 {
 997    memset((uint8_t *)pst, 0, sizeof(Pst));
 998    pst->srcEnt = (Ent)ENTDUAPP;
 999    pst->srcInst = (Inst)DU_INST;
1000    pst->srcProcId = DU_PROC;
1001    pst->dstEnt = (Ent)ENTEGTP;
1002    pst->dstInst = (Inst)EGTP_INST;
1003    pst->dstProcId = pst->srcProcId;
1004    pst->event = event;
1005    pst->selector = ODU_SELECTOR_LC;
1006    pst->pool= DU_POOL;
1007
1008    return ROK;
1009 }
1010
1011
1012 /*******************************************************************
1013  *
1014  * @brief  Function to configure EGTP
1015  *
1016  * @details
1017  *
1018  *    Function : duBuildEgtpCfgReq
1019  *
1020  *    Functionality:
1021  *       Function to configure EGTP
1022  *
1023  * @params[in]
1024  * @return ROK     - success
1025  *         RFAILED - failure
1026  *
1027  * ****************************************************************/
1028
1029 uint8_t duBuildEgtpCfgReq()
1030 {
1031    Pst pst;
1032    EgtpConfig egtpCfg;
1033
1034    DU_LOG("\nDU_APP : Sending EGTP config request");
1035
1036    memset((uint8_t *)&egtpCfg, 0, sizeof(EgtpConfig));
1037    memcpy((uint8_t *)&egtpCfg, (uint8_t *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig));
1038
1039    duFillEgtpPst(&pst, EVTCFGREQ);
1040    packEgtpCfgReq(&pst, egtpCfg);
1041
1042    return ROK;
1043 }
1044
1045 /*******************************************************************
1046  *
1047  * @brief  Function to configure EGTP
1048  *
1049  * @details
1050  *
1051  *    Function : duBuildEgtpCfgReq
1052  *
1053  *    Functionality:
1054  *       Function to configure EGTP
1055  *
1056  * @params[in]
1057  * @return ROK     - success
1058  *         RFAILED - failure
1059  *
1060  * ****************************************************************/
1061 uint8_t duHdlEgtpCfgComplete(CmStatus cfm)
1062 {
1063    uint8_t ret = ROK;
1064
1065    if(cfm.status == LCM_PRIM_OK)
1066    {
1067       DU_LOG("\nDU_APP : EGTP configuraton complete");
1068 #ifdef EGTP_TEST
1069       duSendEgtpSrvOpenReq();
1070 #endif
1071    }
1072    else
1073    {
1074       DU_LOG("\nDU_APP : EGTP configuraton failed");
1075       ret = RFAILED;
1076    }
1077
1078    return (ret);
1079 }
1080
1081 /*******************************************************************
1082  *
1083  * @brief  Sends server open request to EGTP
1084  *
1085  * @details
1086  *
1087  *    Function : duSendEgtpSrvOpenReq
1088  *
1089  *    Functionality:
1090  *       Sends server open request to EGTP
1091  *
1092  * @params[in]
1093  * @return ROK     - success
1094  *         RFAILED - failure
1095  *
1096  * ****************************************************************/
1097
1098 uint8_t duSendEgtpSrvOpenReq()
1099 {
1100    Pst pst;
1101
1102    DU_LOG("\nDU_APP : Sending EGTP server open request");
1103
1104    duFillEgtpPst(&pst, EVTSRVOPENREQ);
1105    packEgtpSrvOpenReq(&pst);
1106
1107    return ROK;
1108 }
1109
1110 /*******************************************************************
1111  *
1112  * @brief Handles server open confirmation
1113  *
1114  * @details
1115  *
1116  *    Function : duHdlEgtpSrvOpenComplete
1117  *
1118  *    Functionality:
1119  *        Handles server open confirmation
1120  *
1121  * @params[in]
1122  * @return ROK     - success
1123  *         RFAILED - failure
1124  *
1125  *****************************************************************/
1126
1127 uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm)
1128 {
1129    uint8_t ret = ROK;
1130
1131    if(cfm.status == LCM_PRIM_OK)
1132    {
1133       DU_LOG("\nDU_APP : EGTP server opened successfully");
1134 #ifdef EGTP_TEST
1135       duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, EGTP_LCL_TEID, EGTP_REM_TEID);
1136 #endif
1137    }
1138    else
1139    {
1140       DU_LOG("\nDU_APP : EGTP server opening failed");
1141       ret = RFAILED;
1142    }
1143
1144    return (ret);
1145 }
1146
1147 /*******************************************************************
1148  *
1149  * @brief Sends tunnel management request
1150  *
1151  * @details
1152  *
1153  *    Function : duSendEgtpTnlMgmtReq
1154  *
1155  *    Functionality:
1156  *        Builds and sends tunnel management request to EGTP
1157  *
1158  * @params[in] Action
1159  *             Local tunnel endpoint id
1160  *             Remote tunnel endpoint id
1161  * @return ROK     - success
1162  *         RFAILED - failure
1163  *
1164  * ****************************************************************/
1165
1166 uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid)
1167 {
1168    Pst pst;
1169    EgtpTnlEvt tnlEvt;
1170
1171    tnlEvt.action = action;
1172    tnlEvt.lclTeid = lclTeid;
1173    tnlEvt.remTeid = remTeid;
1174
1175    DU_LOG("\nDU_APP : Sending EGTP tunnel management request");
1176
1177    duFillEgtpPst(&pst, EVTTNLMGMTREQ);
1178    packEgtpTnlMgmtReq(&pst, tnlEvt);
1179
1180    return ROK;
1181 }
1182
1183 /*******************************************************************
1184  *
1185  * @brief Handles Tunnel management confirm
1186  *
1187  * @details
1188  *
1189  *    Function : duHdlEgtpTnlMgmtCfm
1190  *
1191  *    Functionality:
1192  *      Handles tunnel management confirm received from Egtp
1193  *
1194  * @params[in] Tunnel Event
1195  * @return ROK     - success
1196  *         RFAILED - failure
1197  *
1198  * ****************************************************************/
1199 uint8_t duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm)
1200 {
1201    uint8_t ret = ROK;
1202
1203    if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK)
1204    {
1205       DU_LOG("\nDU_APP : Tunnel management confirm OK");
1206
1207 #ifdef EGTP_TEST
1208       duSendUeCreateReqToRlc();
1209
1210       duSendEgtpTestData();
1211 #endif
1212    }
1213    else
1214    {
1215       DU_LOG("\nDU_APP : Tunnel management failed");
1216       ret = RFAILED;
1217    }
1218
1219    return (ret);
1220 }
1221
1222 uint8_t duSendEgtpDatInd(Buffer *mBuf)
1223 {
1224    EgtpMsg  egtpMsg;
1225
1226    /* Fill EGTP header */
1227    egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
1228    egtpMsg.msgHdr.nPdu.pres = FALSE;
1229    egtpMsg.msgHdr.seqNum.pres = FALSE;
1230    egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
1231    egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
1232    egtpMsg.msgHdr.teId = 1;
1233    egtpMsg.msg = mBuf;
1234
1235    egtpHdlDatInd(egtpMsg);
1236
1237    return ROK;
1238
1239 }
1240
1241 #ifdef EGTP_TEST
1242 /*******************************************************************
1243  *
1244  * @brief Simulate UL Data for intial test
1245  *
1246  * @details
1247  *
1248  *    Function : duSendEgtpTestData
1249  *
1250  *    Functionality:
1251  *      Simulate UL data for initial test
1252  *
1253  * @params[in]
1254  * @return ROK     - success
1255  *         RFAILED - failure
1256  *
1257  * ****************************************************************/
1258 uint8_t duSendEgtpTestData()
1259 {
1260    char data[30] = "This is EGTP data from DU";
1261    int datSize = 30;
1262
1263    Buffer   *mBuf;
1264
1265    if(ODU_GET_MSG(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1266    {
1267       if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
1268       {
1269          DU_LOG("\nDU_APP : ODU_ADD_POST_MSG_MULT failed");
1270          ODU_PUT_MSG(mBuf);
1271          return RFAILED;
1272       }
1273    }
1274    else
1275    {
1276       DU_LOG("\nDU_APP : Failed to allocate memory");
1277       return RFAILED;
1278    }
1279
1280    /* filling IPv4 header */
1281    CmIpv4Hdr ipv4Hdr;
1282    MsgLen    mLen;
1283
1284    mLen = 0;
1285    ODU_FIND_MSG_LEN(mBuf, &mLen);
1286
1287    memset((uint8_t *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
1288    ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
1289    ipv4Hdr.hdrVer = 0x45;
1290    ipv4Hdr.proto = 1;
1291    ipv4Hdr.srcAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.localIp.ipV4Addr);
1292    ipv4Hdr.destAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.destIp.ipV4Addr);
1293
1294    /* Packing IPv4 header into buffer */
1295    uint8_t          ret, cnt, idx;
1296    Data         revPkArray[CM_IPV4_HDRLEN];
1297    Data         pkArray[CM_IPV4_HDRLEN];
1298
1299    /* initialize locals */
1300    cnt = 0;
1301    memset(revPkArray, 0, CM_IPV4_HDRLEN);
1302    memset(pkArray, 0, CM_IPV4_HDRLEN);
1303
1304    /* Pack Header Version */
1305    pkArray[cnt++] = ipv4Hdr.hdrVer;
1306
1307    /* Pack TOS */
1308    pkArray[cnt++] = ipv4Hdr.tos;
1309
1310    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
1311    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
1312
1313    /* Pack Id */
1314    pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
1315    pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
1316
1317    /* Pack Offset */
1318    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
1319    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
1320
1321    /* Pack TTL */
1322    pkArray[cnt++] = ipv4Hdr.ttl;
1323
1324    /* Pack Protocol */
1325    pkArray[cnt++] = ipv4Hdr.proto;
1326
1327    /* Pack Checksum */
1328    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
1329    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
1330
1331    /* Pack Source Address */
1332    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
1333    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
1334    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
1335    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
1336
1337    /* Pack Destination Address */
1338    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
1339    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
1340    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
1341    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
1342
1343    for (idx = 0;  idx < CM_IPV4_HDRLEN;  idx++)
1344       revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
1345
1346    /* this function automatically reverses revPkArray */
1347    ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
1348
1349    duSendEgtpDatInd(mBuf);
1350
1351    return ROK;
1352 }
1353 #endif /* EGTP_TEST */
1354
1355
1356 /**************************************************************************
1357  * @brief Function to send configs to SCH
1358  *
1359  * @details
1360  *
1361  *      Function : duSendSchCfg
1362  *
1363  *      Functionality:
1364  *           Sends general config to Scheduler via MAC layer
1365  *
1366  * @param[in]  void
1367  * @return ROK     - success
1368  *         RFAILED - failure
1369  *
1370  ***************************************************************************/
1371 uint8_t duSendSchCfg()
1372 {
1373    RgMngmt       rgMngmt;
1374    RgSchInstCfg  *cfg = NULLP;
1375    Pst           pst;
1376
1377    DU_SET_ZERO(&pst, sizeof(Pst));
1378    DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt));
1379
1380    cfg = &(rgMngmt.t.cfg.s.schInstCfg);
1381
1382    /* Filling of Instance Id */
1383    cfg->instId = DEFAULT_CELLS + 1;
1384    /* Filling of Gen config */
1385    cfg->genCfg.mem.region = MAC_MEM_REGION;
1386    cfg->genCfg.mem.pool = MAC_POOL;
1387    cfg->genCfg.tmrRes = 10;
1388
1389 #ifdef LTE_ADV
1390    cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE;
1391    cfg->genCfg.isSCellActDeactAlgoEnable = TRUE;
1392 #endif/*LTE_ADV*/
1393    cfg->genCfg.startCellId     = 1;
1394    cfg->genCfg.lmPst.dstProcId = DU_PROC;
1395    cfg->genCfg.lmPst.srcProcId = DU_PROC;
1396    cfg->genCfg.lmPst.dstEnt    = ENTDUAPP;
1397    cfg->genCfg.lmPst.dstInst   = DU_INST;
1398    cfg->genCfg.lmPst.srcEnt    = ENTMAC;
1399    cfg->genCfg.lmPst.srcInst   = DEFAULT_CELLS + 1;
1400    cfg->genCfg.lmPst.prior     = PRIOR0;
1401    cfg->genCfg.lmPst.route     = RTESPEC;
1402    cfg->genCfg.lmPst.region    = MAC_MEM_REGION;
1403    cfg->genCfg.lmPst.pool      = MAC_POOL;
1404    cfg->genCfg.lmPst.selector  = ODU_SELECTOR_LC;
1405
1406    /* Fill Header */
1407    rgMngmt.hdr.msgType             = TCFG;
1408    rgMngmt.hdr.entId.ent           = ENTMAC;
1409    rgMngmt.hdr.entId.inst          = DU_INST;
1410    rgMngmt.hdr.elmId.elmnt         = STSCHINST;
1411    rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
1412    rgMngmt.hdr.response.mem.pool   = MAC_POOL;
1413
1414    /* Fill Pst */
1415    pst.selector  = ODU_SELECTOR_LC;
1416    pst.srcEnt    = ENTDUAPP;
1417    pst.dstEnt    = ENTMAC;
1418    pst.dstProcId = DU_PROC;
1419    pst.srcProcId = DU_PROC;
1420    pst.srcInst   = DU_INST;
1421    pst.dstInst   = 0;
1422    pst.region    = duCb.init.region;
1423    pst.event    = (Event) EVTMACSCHGENCFGREQ;
1424
1425    DU_LOG("\nDU_APP : MAC Sch Cfg sent");
1426
1427    /* Send the request to MAC */
1428    cmPkLrgSchCfgReq(&pst, &rgMngmt);
1429
1430    return ROK;
1431 }
1432
1433
1434 /**************************************************************************
1435  * @brief Function to configure SCTP params and
1436  *  responsible for F1 and E2 interfaces
1437  *
1438  * @details
1439  *
1440  *      Function : duLayerConfigComplete
1441  *
1442  *      Functionality:
1443  *           Configures SCTP Params and responsible for handling
1444  *           F1 and E2 interface.
1445  *
1446  * @param[in]  void
1447  * @return ROK     - success
1448  *         RFAILED - failure
1449  *
1450  ***************************************************************************/
1451 uint8_t duLayerConfigComplete()
1452 {
1453    uint8_t ret = ROK;
1454
1455    DU_LOG("\nDU_APP : Configuring all Layer is complete");
1456
1457    if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
1458    {
1459       DU_LOG("\nDU_APP : Failed configuring Sctp Params");
1460       ret = RFAILED;
1461    }
1462    if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
1463    {
1464       DU_LOG("\nDU_APP : Failed to send AssocReq F1");
1465       ret = RFAILED;
1466    }
1467    if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
1468    {
1469       DU_LOG("\nDU_APP : Failed to send AssocReq E2");
1470       ret = RFAILED;
1471    }
1472
1473    return (ret);
1474 }
1475
1476 /**************************************************************************
1477  * @brief Function to handle  SCH Config Confirm from MAC
1478  *
1479  * @details
1480  *
1481  *      Function : duHdlSchCfgComplete
1482  *
1483  *      Functionality:
1484  *           Handles Scheduler Gen Config Confirm from MAC
1485  *
1486  * @param[in]  Pst     *pst, Post structure of the primitive.
1487  * @param[in]  RgMngmt *cfm, Unpacked primitive info received from MAC
1488  * @return ROK     - success
1489  *         RFAILED - failure
1490  *
1491  ***************************************************************************/
1492 uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm)
1493 {
1494    if (cfm->cfm.status == LCM_PRIM_OK)
1495    {
1496       switch (cfm->hdr.elmId.elmnt)
1497       {
1498          case STSCHINST:
1499             {
1500                DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP");
1501                break;
1502             }
1503          default:
1504             break;
1505       }
1506    }
1507    duLayerConfigComplete();
1508    duBuildEgtpCfgReq();
1509    return ROK;
1510 }
1511
1512 /*******************************************************************
1513  *
1514  * @brief Sends Slot indication to EGTP
1515  *
1516  * @details
1517  *
1518  *    Function : duSendEgtpSlotInd
1519  *
1520  *    Functionality:
1521  *     Sends Slot indication to EGTP
1522  *
1523  * @params[in]
1524  * @return ROK     - success
1525  *         RFAILED - failure
1526  *
1527  * ****************************************************************/
1528 uint8_t duSendEgtpSlotInd()
1529 {
1530    Pst pst;
1531
1532    duFillEgtpPst(&pst, EVTSLOTIND);
1533    packEgtpSlotInd(&pst);
1534
1535    return ROK;
1536
1537 }
1538
1539 /**************************************************************************
1540  * @brief Function to fill and send MacCellconfig
1541  *
1542  * @details
1543  *
1544  *      Function : duBuildAndSendMacCellCfg
1545  *
1546  *      Functionality:
1547  *           Initiates MAC Configs towards MAC
1548  *
1549  * @param[in] void
1550  * @return ROK     - success
1551  *         RFAILED - failure
1552  *
1553  ***************************************************************************/
1554 uint8_t duBuildAndSendMacCellCfg()
1555 {
1556    Pst pst;
1557    DU_SET_ZERO(&pst, sizeof(Pst));
1558    MacCellCfg *duMacCellCfg = NULLP;
1559
1560    DU_ALLOC_SHRABL_BUF(duMacCellCfg, sizeof(MacCellCfg));
1561    if(duMacCellCfg == NULLP)
1562    {
1563       return RFAILED;
1564    }
1565
1566    /* store the address in the duCb so that we can free on confirm msg */
1567    duCb.duMacCellCfg = duMacCellCfg;
1568
1569    /* copy the mac config structure from duCfgParams */
1570    memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
1571
1572    /* Fill Pst */
1573    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_CONFIG_REQ);
1574
1575    /* Send MAC cell config to MAC */
1576    return (*packMacCellCfgOpts[pst.selector])(&pst, duMacCellCfg);
1577 }
1578
1579 /**************************************************************************
1580  * @brief Function to Handle MAC cell config confirm
1581  *
1582  * @details
1583  *
1584  *      Function : duHandleMacCellCfgCfm
1585  *
1586  *      Functionality:
1587  *           Initiates general Configs towards MAC
1588  *
1589  * @param[in] void
1590  * @return ROK     - success
1591  *         RFAILED - failure
1592  *
1593  ***************************************************************************/
1594 uint8_t  duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm)
1595 {
1596    uint8_t actvCellIdx  = 0;
1597    uint8_t ret          = ROK;
1598
1599    if(macCellCfgCfm->rsp == ROK)
1600    {
1601         for(actvCellIdx = 0 ; actvCellIdx <duCb.numActvCells ; actvCellIdx++)
1602         {
1603             if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId)
1604             {
1605                 duCb.duMacCellCfg = NULLP;
1606                 /* Build and send GNB-DU config update */
1607                 ret = BuildAndSendDUConfigUpdate();
1608
1609                 /* TODO: Trigger cell start req once cell up slot ind is received*/
1610                 /* Build and Send Cell Start Req to MAC */
1611                 ret = duBuildAndSendMacCellStartReq();
1612
1613             }
1614         }
1615     }
1616     else
1617     {
1618         DU_LOG("\nMac cell cfg failed");
1619         ret = RFAILED;
1620     }
1621     return ret;
1622 }
1623
1624 /*******************************************************************
1625  *
1626  * @brief Handles slot indication from MAC
1627  *
1628  * @details
1629  *
1630  *    Function : duHandleSlotInd
1631  *
1632  *    Functionality:
1633  *      Handles slot indication from MAC
1634  *
1635  * @params[in] Post structure pointer
1636  *             Slot Info pointer
1637  * @return ROK     - success
1638  *         RFAILED - failure
1639  *
1640  * ****************************************************************/
1641 uint8_t duHandleSlotInd(Pst *pst, SlotIndInfo *slotInfo)
1642 {
1643
1644    DU_LOG("\nDU APP : Slot Indication received");
1645
1646    if(slotInfo->cellId <=0 || slotInfo->cellId > MAX_NUM_CELL)
1647    {
1648       DU_LOG("\nDU APP : Invalid Cell Id %d", slotInfo->cellId);
1649    }
1650    if(!duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd)
1651    {
1652       duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd = true;
1653       if((duCb.actvCellLst[slotInfo->cellId-1] != NULL) && \
1654             (duCb.actvCellLst[slotInfo->cellId-1]->cellStatus == \
1655              ACTIVATION_IN_PROGRESS))
1656       {
1657          DU_LOG("\nDU APP : 5G-NR Cell %d is UP", slotInfo->cellId);
1658          duCb.actvCellLst[slotInfo->cellId-1]->cellStatus = ACTIVATED;
1659       }
1660
1661    }
1662
1663    /* TODO : Slot Indication to be moved out of EGTP_TEST when
1664     * data path is established */
1665 #ifdef EGTP_TEST
1666    duSendEgtpSlotInd();
1667 #endif
1668
1669    if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
1670       DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, slotInfo, sizeof(SlotIndInfo));
1671
1672    return ROK;
1673 }
1674
1675 /*******************************************************************
1676  *
1677  * @brief Builds and sends cell start request to MAC
1678  *
1679  * @details
1680  *
1681  *    Function : duBuildAndSendMacCellStartReq
1682  *
1683  *    Functionality:
1684  *       Builds and sends cell start request to MAC
1685  *
1686  * @params[in]
1687  * @return ROK     - success
1688  *         RFAILED - failure
1689  *
1690  * ****************************************************************/
1691 uint8_t duBuildAndSendMacCellStartReq()
1692 {
1693    Pst pst;
1694    MacCellStartInfo *cellStartInfo = NULL;
1695
1696    DU_LOG("\nDU APP : Building and Sending cell start request to MAC");
1697
1698    /* Send Cell Start Request to MAC */
1699    DU_ALLOC_SHRABL_BUF(cellStartInfo, sizeof(MacCellStartInfo));
1700    if(!cellStartInfo)
1701    {
1702       DU_LOG("\nDU APP : Memory alloc failed while building cell start request");
1703       return RFAILED;
1704    }
1705
1706    for(uint8_t id = 0; id < MAX_NUM_CELL; id++)
1707    {
1708       if(duCb.actvCellLst[id])
1709       {
1710          duCb.actvCellLst[id]->firstSlotIndRcvd = FALSE;
1711          cellStartInfo->cellId = duCb.actvCellLst[id]->cellInfo.nrEcgi.cellId;
1712
1713          /* Fill Pst */
1714          FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START_REQ);
1715
1716          return (*packMacCellStartReqOpts[pst.selector])(&pst, cellStartInfo);
1717       }
1718    }
1719    return ROK;
1720 }
1721
1722 /*******************************************************************
1723  *
1724  * @brief Builds and sends cell stop request to MAC
1725  *
1726  * @details
1727  *
1728  *    Function : duBuildAndSendMacCellStopReq
1729  *
1730  *    Functionality:
1731  *       Builds and sends cell stop request to MAC
1732  *
1733  * @params[in]
1734  * @return ROK     - success
1735  *         RFAILED - failure
1736  *
1737  * ****************************************************************/
1738 uint8_t duBuildAndSendMacCellStopReq()
1739 {
1740    Pst pst;
1741    MacCellStopInfo *cellStopInfo = NULL;
1742
1743    DU_LOG("\nDU APP : Building and Sending cell stop request to MAC");
1744
1745    /* Send Cell Stop Request to MAC */
1746    DU_ALLOC_SHRABL_BUF(cellStopInfo, sizeof(MacCellStopInfo));
1747    if(!cellStopInfo)
1748    {
1749       DU_LOG("\nDU APP : Memory alloc failed while building cell stop request");
1750       return RFAILED;
1751    }
1752    cellStopInfo->cellId = duCb.actvCellLst[0]->cellId;
1753
1754    /* Fill Pst */
1755    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP_REQ);
1756
1757    return (*packMacCellStopReqOpts[pst.selector])(&pst, cellStopInfo);
1758 }
1759
1760 /*******************************************************************
1761  *
1762  * @brief Handles stop indication from MAC
1763  *
1764  * @details
1765  *
1766  *    Function : duHandleStopInd
1767  *
1768  *    Functionality:
1769  *      Handles stop indication from MAC
1770  *
1771  * @params[in] Post structure pointer
1772  * @return ROK     - success
1773  *         RFAILED - failure
1774  *
1775  * ****************************************************************/
1776 uint8_t duHandleStopInd(Pst *pst, MacCellStopInfo *cellStopId)
1777 {
1778    if(cellStopId->cellId <=0 || cellStopId->cellId > MAX_NUM_CELL)
1779    {
1780       DU_LOG("\nDU APP : Invalid Cell Id %d", cellStopId->cellId);
1781    }
1782    if(duCb.actvCellLst[cellStopId->cellId-1] != NULL)
1783    {
1784       if(duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd)
1785       {
1786          duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd = false;
1787          if((duCb.actvCellLst[cellStopId->cellId-1]->cellStatus == \
1788                   ACTIVATED))
1789          {
1790             DU_LOG("\nDU APP : 5G-NR Cell %d is DOWN", cellStopId->cellId);
1791             duCb.actvCellLst[cellStopId->cellId-1]->cellStatus = DELETION_IN_PROGRESS;
1792          }
1793       }
1794    }
1795    if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
1796       DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, cellStopId, sizeof(MacCellStopInfo));
1797
1798    return ROK;
1799 }
1800
1801 /*******************************************************************
1802  *
1803  * @brief Handles slot indication from MAC
1804  *
1805  * @details
1806  *
1807  *    Function : duHandleUlCcchInd
1808  *
1809  *    Functionality:
1810  *      Handles UL CCCH indication from MAC
1811  *
1812  * @params[in] Post structure pointer
1813  *             UL CCCH Ind pointer
1814  * @return ROK     - success
1815  *         RFAILED - failure
1816  *
1817  * ****************************************************************/
1818 uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo)
1819 {
1820
1821    DU_LOG("\nDU APP : UL CCCH Indication received");
1822
1823    return (duProcUlCcchInd(ulCcchIndInfo));
1824 }
1825
1826 /*******************************************************************
1827  *
1828  * @brief Process UL RRC Message from RLC
1829  *
1830  * @details
1831  *
1832  *    Function : DuProcRlcUlRrcMsgTrans
1833  *
1834  *    Functionality: Process UL RRC Message from RLC
1835  *
1836  * @params[in] Post structure
1837  *             UL RRC Message Info
1838  * @return ROK     - success
1839  *         RFAILED - failure
1840  *
1841  * ****************************************************************/
1842 uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo)
1843 {
1844    DuUeCb   ueCb;
1845
1846    ueCb = duCb.actvCellLst[ulRrcMsgInfo->cellId -1]->ueCb[ulRrcMsgInfo->ueIdx -1];
1847    BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \
1848       ulRrcMsgInfo->rrcMsg);
1849
1850    DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo->rrcMsg, ulRrcMsgInfo->msgLen);
1851    DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
1852    return ROK;
1853 }
1854
1855 /**********************************************************************
1856   End of file
1857  **********************************************************************/