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