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    else
1208    {
1209       DU_LOG("\nDU_APP : Tunnel management failed");
1210       ret = RFAILED;
1211    }
1212
1213    return (ret);
1214 }
1215
1216 uint8_t duSendEgtpDatInd(Buffer *mBuf)
1217 {
1218    EgtpMsg  egtpMsg;
1219
1220    /* Fill EGTP header */
1221    egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
1222    egtpMsg.msgHdr.nPdu.pres = FALSE;
1223    egtpMsg.msgHdr.seqNum.pres = FALSE;
1224    egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
1225    egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
1226    egtpMsg.msgHdr.teId = 1;
1227    egtpMsg.msg = mBuf;
1228
1229    egtpHdlDatInd(egtpMsg);
1230
1231    return ROK;
1232
1233 }
1234
1235 #ifdef EGTP_TEST
1236 /*******************************************************************
1237  *
1238  * @brief Simulate UL Data for intial test
1239  *
1240  * @details
1241  *
1242  *    Function : duSendEgtpTestData
1243  *
1244  *    Functionality:
1245  *      Simulate UL data for initial test
1246  *
1247  * @params[in]
1248  * @return ROK     - success
1249  *         RFAILED - failure
1250  *
1251  * ****************************************************************/
1252 uint8_t duSendEgtpTestData()
1253 {
1254    char data[30] = "This is EGTP data from DU";
1255    int datSize = 30;
1256
1257    Buffer   *mBuf;
1258
1259    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1260    {
1261       if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
1262       {
1263          DU_LOG("\nDU_APP : ODU_ADD_POST_MSG_MULT failed");
1264          ODU_PUT_MSG_BUF(mBuf);
1265          return RFAILED;
1266       }
1267    }
1268    else
1269    {
1270       DU_LOG("\nDU_APP : Failed to allocate memory");
1271       return RFAILED;
1272    }
1273
1274    /* filling IPv4 header */
1275    CmIpv4Hdr ipv4Hdr;
1276    MsgLen    mLen;
1277
1278    mLen = 0;
1279    ODU_GET_MSG_LEN(mBuf, &mLen);
1280
1281    memset((uint8_t *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
1282    ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
1283    ipv4Hdr.hdrVer = 0x45;
1284    ipv4Hdr.proto = 1;
1285    ipv4Hdr.srcAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.localIp.ipV4Addr);
1286    ipv4Hdr.destAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.destIp.ipV4Addr);
1287
1288    /* Packing IPv4 header into buffer */
1289    uint8_t          ret, cnt, idx;
1290    Data         revPkArray[CM_IPV4_HDRLEN];
1291    Data         pkArray[CM_IPV4_HDRLEN];
1292
1293    /* initialize locals */
1294    cnt = 0;
1295    memset(revPkArray, 0, CM_IPV4_HDRLEN);
1296    memset(pkArray, 0, CM_IPV4_HDRLEN);
1297
1298    /* Pack Header Version */
1299    pkArray[cnt++] = ipv4Hdr.hdrVer;
1300
1301    /* Pack TOS */
1302    pkArray[cnt++] = ipv4Hdr.tos;
1303
1304    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
1305    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
1306
1307    /* Pack Id */
1308    pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
1309    pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
1310
1311    /* Pack Offset */
1312    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
1313    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
1314
1315    /* Pack TTL */
1316    pkArray[cnt++] = ipv4Hdr.ttl;
1317
1318    /* Pack Protocol */
1319    pkArray[cnt++] = ipv4Hdr.proto;
1320
1321    /* Pack Checksum */
1322    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
1323    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
1324
1325    /* Pack Source Address */
1326    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
1327    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
1328    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
1329    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
1330
1331    /* Pack Destination Address */
1332    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
1333    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
1334    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
1335    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
1336
1337    for (idx = 0;  idx < CM_IPV4_HDRLEN;  idx++)
1338       revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
1339
1340    /* this function automatically reverses revPkArray */
1341    ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
1342
1343    duSendEgtpDatInd(mBuf);
1344
1345    return ROK;
1346 }
1347 #endif /* EGTP_TEST */
1348
1349
1350 /**************************************************************************
1351  * @brief Function to send configs to SCH
1352  *
1353  * @details
1354  *
1355  *      Function : duSendSchCfg
1356  *
1357  *      Functionality:
1358  *           Sends general config to Scheduler via MAC layer
1359  *
1360  * @param[in]  void
1361  * @return ROK     - success
1362  *         RFAILED - failure
1363  *
1364  ***************************************************************************/
1365 uint8_t duSendSchCfg()
1366 {
1367    RgMngmt       rgMngmt;
1368    RgSchInstCfg  *cfg = NULLP;
1369    Pst           pst;
1370
1371    DU_SET_ZERO(&pst, sizeof(Pst));
1372    DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt));
1373
1374    cfg = &(rgMngmt.t.cfg.s.schInstCfg);
1375
1376    /* Filling of Instance Id */
1377    cfg->instId = DEFAULT_CELLS + 1;
1378    /* Filling of Gen config */
1379    cfg->genCfg.mem.region = MAC_MEM_REGION;
1380    cfg->genCfg.mem.pool = MAC_POOL;
1381    cfg->genCfg.tmrRes = 10;
1382
1383 #ifdef LTE_ADV
1384    cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE;
1385    cfg->genCfg.isSCellActDeactAlgoEnable = TRUE;
1386 #endif/*LTE_ADV*/
1387    cfg->genCfg.startCellId     = 1;
1388    cfg->genCfg.lmPst.dstProcId = DU_PROC;
1389    cfg->genCfg.lmPst.srcProcId = DU_PROC;
1390    cfg->genCfg.lmPst.dstEnt    = ENTDUAPP;
1391    cfg->genCfg.lmPst.dstInst   = DU_INST;
1392    cfg->genCfg.lmPst.srcEnt    = ENTMAC;
1393    cfg->genCfg.lmPst.srcInst   = DEFAULT_CELLS + 1;
1394    cfg->genCfg.lmPst.prior     = PRIOR0;
1395    cfg->genCfg.lmPst.route     = RTESPEC;
1396    cfg->genCfg.lmPst.region    = MAC_MEM_REGION;
1397    cfg->genCfg.lmPst.pool      = MAC_POOL;
1398    cfg->genCfg.lmPst.selector  = ODU_SELECTOR_LC;
1399
1400    /* Fill Header */
1401    rgMngmt.hdr.msgType             = TCFG;
1402    rgMngmt.hdr.entId.ent           = ENTMAC;
1403    rgMngmt.hdr.entId.inst          = DU_INST;
1404    rgMngmt.hdr.elmId.elmnt         = STSCHINST;
1405    rgMngmt.hdr.response.mem.region = MAC_MEM_REGION;
1406    rgMngmt.hdr.response.mem.pool   = MAC_POOL;
1407
1408    /* Fill Pst */
1409    pst.selector  = ODU_SELECTOR_LC;
1410    pst.srcEnt    = ENTDUAPP;
1411    pst.dstEnt    = ENTMAC;
1412    pst.dstProcId = DU_PROC;
1413    pst.srcProcId = DU_PROC;
1414    pst.srcInst   = DU_INST;
1415    pst.dstInst   = 0;
1416    pst.region    = duCb.init.region;
1417    pst.event    = (Event) EVTMACSCHGENCFGREQ;
1418
1419    DU_LOG("\nDU_APP : MAC Sch Cfg sent");
1420
1421    /* Send the request to MAC */
1422    cmPkLrgSchCfgReq(&pst, &rgMngmt);
1423
1424    return ROK;
1425 }
1426
1427
1428 /**************************************************************************
1429  * @brief Function to configure SCTP params and
1430  *  responsible for F1 and E2 interfaces
1431  *
1432  * @details
1433  *
1434  *      Function : duLayerConfigComplete
1435  *
1436  *      Functionality:
1437  *           Configures SCTP Params and responsible for handling
1438  *           F1 and E2 interface.
1439  *
1440  * @param[in]  void
1441  * @return ROK     - success
1442  *         RFAILED - failure
1443  *
1444  ***************************************************************************/
1445 uint8_t duLayerConfigComplete()
1446 {
1447    uint8_t ret = ROK;
1448
1449    DU_LOG("\nDU_APP : Configuring all Layer is complete");
1450
1451    if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
1452    {
1453       DU_LOG("\nDU_APP : Failed configuring Sctp Params");
1454       ret = RFAILED;
1455    }
1456    if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
1457    {
1458       DU_LOG("\nDU_APP : Failed to send AssocReq F1");
1459       ret = RFAILED;
1460    }
1461    if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
1462    {
1463       DU_LOG("\nDU_APP : Failed to send AssocReq E2");
1464       ret = RFAILED;
1465    }
1466
1467    return (ret);
1468 }
1469
1470 /**************************************************************************
1471  * @brief Function to handle  SCH Config Confirm from MAC
1472  *
1473  * @details
1474  *
1475  *      Function : duHdlSchCfgComplete
1476  *
1477  *      Functionality:
1478  *           Handles Scheduler Gen Config Confirm from MAC
1479  *
1480  * @param[in]  Pst     *pst, Post structure of the primitive.
1481  * @param[in]  RgMngmt *cfm, Unpacked primitive info received from MAC
1482  * @return ROK     - success
1483  *         RFAILED - failure
1484  *
1485  ***************************************************************************/
1486 uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm)
1487 {
1488    if (cfm->cfm.status == LCM_PRIM_OK)
1489    {
1490       switch (cfm->hdr.elmId.elmnt)
1491       {
1492          case STSCHINST:
1493             {
1494                DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP");
1495                break;
1496             }
1497          default:
1498             break;
1499       }
1500    }
1501    duLayerConfigComplete();
1502    duBuildEgtpCfgReq();
1503    return ROK;
1504 }
1505
1506 /*******************************************************************
1507  *
1508  * @brief Sends Slot indication to EGTP
1509  *
1510  * @details
1511  *
1512  *    Function : duSendEgtpSlotInd
1513  *
1514  *    Functionality:
1515  *     Sends Slot indication to EGTP
1516  *
1517  * @params[in]
1518  * @return ROK     - success
1519  *         RFAILED - failure
1520  *
1521  * ****************************************************************/
1522 uint8_t duSendEgtpSlotInd()
1523 {
1524    Pst pst;
1525
1526    duFillEgtpPst(&pst, EVTSLOTIND);
1527    packEgtpSlotInd(&pst);
1528
1529    return ROK;
1530
1531 }
1532
1533 /**************************************************************************
1534  * @brief Function to fill and send MacCellconfig
1535  *
1536  * @details
1537  *
1538  *      Function : duBuildAndSendMacCellCfg
1539  *
1540  *      Functionality:
1541  *           Initiates MAC Configs towards MAC
1542  *
1543  * @param[in] void
1544  * @return ROK     - success
1545  *         RFAILED - failure
1546  *
1547  ***************************************************************************/
1548 uint8_t duBuildAndSendMacCellCfg()
1549 {
1550    Pst pst;
1551    DU_SET_ZERO(&pst, sizeof(Pst));
1552    MacCellCfg *duMacCellCfg = NULLP;
1553
1554    DU_ALLOC_SHRABL_BUF(duMacCellCfg, sizeof(MacCellCfg));
1555    if(duMacCellCfg == NULLP)
1556    {
1557       return RFAILED;
1558    }
1559
1560    /* store the address in the duCb so that we can free on confirm msg */
1561    duCb.duMacCellCfg = duMacCellCfg;
1562
1563    /* copy the mac config structure from duCfgParams */
1564    memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
1565
1566    /* Fill Pst */
1567    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_CONFIG_REQ);
1568
1569    /* Send MAC cell config to MAC */
1570    return (*packMacCellCfgOpts[pst.selector])(&pst, duMacCellCfg);
1571 }
1572
1573 /**************************************************************************
1574  * @brief Function to Handle MAC cell config confirm
1575  *
1576  * @details
1577  *
1578  *      Function : duHandleMacCellCfgCfm
1579  *
1580  *      Functionality:
1581  *           Initiates general Configs towards MAC
1582  *
1583  * @param[in] void
1584  * @return ROK     - success
1585  *         RFAILED - failure
1586  *
1587  ***************************************************************************/
1588 uint8_t  duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm)
1589 {
1590    uint8_t actvCellIdx  = 0;
1591    uint8_t ret          = ROK;
1592
1593    if(macCellCfgCfm->rsp == ROK)
1594    {
1595         for(actvCellIdx = 0 ; actvCellIdx <duCb.numActvCells ; actvCellIdx++)
1596         {
1597             if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId)
1598             {
1599                 duCb.duMacCellCfg = NULLP;
1600                 /* Build and send GNB-DU config update */
1601                 ret = BuildAndSendDUConfigUpdate();
1602
1603                 /* TODO: Trigger cell start req once cell up slot ind is received*/
1604                 /* Build and Send Cell Start Req to MAC */
1605                 ret = duBuildAndSendMacCellStartReq();
1606
1607             }
1608         }
1609     }
1610     else
1611     {
1612         DU_LOG("\nMac cell cfg failed");
1613         ret = RFAILED;
1614     }
1615     return ret;
1616 }
1617
1618 /*******************************************************************
1619  *
1620  * @brief Handles slot indication from MAC
1621  *
1622  * @details
1623  *
1624  *    Function : duHandleSlotInd
1625  *
1626  *    Functionality:
1627  *      Handles slot indication from MAC
1628  *
1629  * @params[in] Post structure pointer
1630  *             Slot Info pointer
1631  * @return ROK     - success
1632  *         RFAILED - failure
1633  *
1634  * ****************************************************************/
1635 uint8_t duHandleSlotInd(Pst *pst, SlotIndInfo *slotInfo)
1636 {
1637
1638    DU_LOG("\nDU APP : Slot Indication received");
1639
1640    if(slotInfo->cellId <=0 || slotInfo->cellId > MAX_NUM_CELL)
1641    {
1642       DU_LOG("\nDU APP : Invalid Cell Id %d", slotInfo->cellId);
1643    }
1644    if(!duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd)
1645    {
1646       duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd = true;
1647       if((duCb.actvCellLst[slotInfo->cellId-1] != NULL) && \
1648             (duCb.actvCellLst[slotInfo->cellId-1]->cellStatus == \
1649              ACTIVATION_IN_PROGRESS))
1650       {
1651          DU_LOG("\nDU APP : 5G-NR Cell %d is UP", slotInfo->cellId);
1652          duCb.actvCellLst[slotInfo->cellId-1]->cellStatus = ACTIVATED;
1653       }
1654
1655    }
1656
1657    /* TODO : Slot Indication to be moved out of EGTP_TEST when
1658     * data path is established */
1659 #ifdef EGTP_TEST
1660    duSendEgtpSlotInd();
1661 #endif
1662
1663    if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
1664       DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, slotInfo, sizeof(SlotIndInfo));
1665
1666    return ROK;
1667 }
1668
1669 /*******************************************************************
1670  *
1671  * @brief Builds and sends cell start request to MAC
1672  *
1673  * @details
1674  *
1675  *    Function : duBuildAndSendMacCellStartReq
1676  *
1677  *    Functionality:
1678  *       Builds and sends cell start request to MAC
1679  *
1680  * @params[in]
1681  * @return ROK     - success
1682  *         RFAILED - failure
1683  *
1684  * ****************************************************************/
1685 uint8_t duBuildAndSendMacCellStartReq()
1686 {
1687    Pst pst;
1688    MacCellStartInfo *cellStartInfo = NULL;
1689
1690    DU_LOG("\nDU APP : Building and Sending cell start request to MAC");
1691
1692    /* Send Cell Start Request to MAC */
1693    DU_ALLOC_SHRABL_BUF(cellStartInfo, sizeof(MacCellStartInfo));
1694    if(!cellStartInfo)
1695    {
1696       DU_LOG("\nDU APP : Memory alloc failed while building cell start request");
1697       return RFAILED;
1698    }
1699
1700    for(uint8_t id = 0; id < MAX_NUM_CELL; id++)
1701    {
1702       if(duCb.actvCellLst[id])
1703       {
1704          duCb.actvCellLst[id]->firstSlotIndRcvd = FALSE;
1705          cellStartInfo->cellId = duCb.actvCellLst[id]->cellInfo.nrEcgi.cellId;
1706
1707          /* Fill Pst */
1708          FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START_REQ);
1709
1710          return (*packMacCellStartReqOpts[pst.selector])(&pst, cellStartInfo);
1711       }
1712    }
1713    return ROK;
1714 }
1715
1716 /*******************************************************************
1717  *
1718  * @brief Builds and sends cell stop request to MAC
1719  *
1720  * @details
1721  *
1722  *    Function : duBuildAndSendMacCellStopReq
1723  *
1724  *    Functionality:
1725  *       Builds and sends cell stop request to MAC
1726  *
1727  * @params[in]
1728  * @return ROK     - success
1729  *         RFAILED - failure
1730  *
1731  * ****************************************************************/
1732 uint8_t duBuildAndSendMacCellStopReq()
1733 {
1734    Pst pst;
1735    MacCellStopInfo *cellStopInfo = NULL;
1736
1737    DU_LOG("\nDU APP : Building and Sending cell stop request to MAC");
1738
1739    /* Send Cell Stop Request to MAC */
1740    DU_ALLOC_SHRABL_BUF(cellStopInfo, sizeof(MacCellStopInfo));
1741    if(!cellStopInfo)
1742    {
1743       DU_LOG("\nDU APP : Memory alloc failed while building cell stop request");
1744       return RFAILED;
1745    }
1746    cellStopInfo->cellId = duCb.actvCellLst[0]->cellId;
1747
1748    /* Fill Pst */
1749    FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP_REQ);
1750
1751    return (*packMacCellStopReqOpts[pst.selector])(&pst, cellStopInfo);
1752 }
1753
1754 /*******************************************************************
1755  *
1756  * @brief Handles stop indication from MAC
1757  *
1758  * @details
1759  *
1760  *    Function : duHandleStopInd
1761  *
1762  *    Functionality:
1763  *      Handles stop indication from MAC
1764  *
1765  * @params[in] Post structure pointer
1766  * @return ROK     - success
1767  *         RFAILED - failure
1768  *
1769  * ****************************************************************/
1770 uint8_t duHandleStopInd(Pst *pst, MacCellStopInfo *cellStopId)
1771 {
1772    if(cellStopId->cellId <=0 || cellStopId->cellId > MAX_NUM_CELL)
1773    {
1774       DU_LOG("\nDU APP : Invalid Cell Id %d", cellStopId->cellId);
1775    }
1776    if(duCb.actvCellLst[cellStopId->cellId-1] != NULL)
1777    {
1778       if(duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd)
1779       {
1780          duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd = false;
1781          if((duCb.actvCellLst[cellStopId->cellId-1]->cellStatus == \
1782                   ACTIVATED))
1783          {
1784             DU_LOG("\nDU APP : 5G-NR Cell %d is DOWN", cellStopId->cellId);
1785             duCb.actvCellLst[cellStopId->cellId-1]->cellStatus = DELETION_IN_PROGRESS;
1786          }
1787       }
1788    }
1789    if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
1790       DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, cellStopId, sizeof(MacCellStopInfo));
1791
1792    return ROK;
1793 }
1794
1795 /*******************************************************************
1796  *
1797  * @brief Handles slot indication from MAC
1798  *
1799  * @details
1800  *
1801  *    Function : duHandleUlCcchInd
1802  *
1803  *    Functionality:
1804  *      Handles UL CCCH indication from MAC
1805  *
1806  * @params[in] Post structure pointer
1807  *             UL CCCH Ind pointer
1808  * @return ROK     - success
1809  *         RFAILED - failure
1810  *
1811  * ****************************************************************/
1812 uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo)
1813 {
1814
1815    DU_LOG("\nDU APP : UL CCCH Indication received");
1816
1817    return (duProcUlCcchInd(ulCcchIndInfo));
1818 }
1819
1820 /*******************************************************************
1821  *
1822  * @brief Process UL RRC Message from RLC
1823  *
1824  * @details
1825  *
1826  *    Function : DuProcRlcUlRrcMsgTrans
1827  *
1828  *    Functionality: Process UL RRC Message from RLC
1829  *
1830  * @params[in] Post structure
1831  *             UL RRC Message Info
1832  * @return ROK     - success
1833  *         RFAILED - failure
1834  *
1835  * ****************************************************************/
1836 uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo)
1837 {
1838    DuUeCb   ueCb;
1839
1840    ueCb = duCb.actvCellLst[ulRrcMsgInfo->cellId -1]->ueCb[ulRrcMsgInfo->ueIdx -1];
1841    BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \
1842       ulRrcMsgInfo->rrcMsg);
1843
1844    DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo->rrcMsg, ulRrcMsgInfo->msgLen);
1845    DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
1846    return ROK;
1847 }
1848
1849 /*******************************************************************
1850 *
1851 * @brief Process RRC delivery report from RLC
1852 *
1853 * @details
1854 *
1855 *    Function : DuProcRlcRrcDeliveryReport
1856 *
1857 *    Functionality: Process RRC delivery Message from RLC
1858 *
1859 * @params[in] Post structure
1860 *             UL RRC Message Info
1861 * @return ROK     - success
1862 *         RFAILED - failure
1863 *
1864 * ****************************************************************/
1865 uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryReport)
1866 {
1867        DuUeCb   ueCb;
1868        uint8_t  ret = RFAILED;
1869
1870        ueCb = duCb.actvCellLst[rrcDeliveryReport->cellId -1]->ueCb[rrcDeliveryReport->ueIdx -1];
1871        ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport);
1872
1873        DU_FREE_SHRABL_BUF(pst->region, pst->pool, rrcDeliveryReport, sizeof(RrcDeliveryReport));
1874        return ret;
1875 }
1876
1877
1878 /**********************************************************************
1879   End of file
1880  **********************************************************************/