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    switch(ntfy->header.nType)
 925    {
 926       case CM_INET_SCTP_ASSOC_CHANGE:
 927          switch(ntfy->u.assocChange.state)
 928          {
 929             case CM_INET_SCTP_COMM_UP:
 930                {
 931                   DU_LOG("\nDU_APP : SCTP communication UP");
 932                   //Setup F1-C
 933                   if(ntfy->u.assocChange.assocId == f1Params.assocId)
 934                   {
 935                      /* Build and send F1 Setup response */
 936                      if(BuildAndSendF1SetupReq() != ROK)
 937                      {
 938                         RETVALUE(RFAILED);
 939                      }
 940                   }
 941                   //Setup E2
 942                   if(ntfy->u.assocChange.assocId == ricParams.assocId)
 943                   {
 944                      /* Build and send F1 Setup response */
 945                      if(BuildAndSendE2SetupReq() != ROK)
 946                      {
 947                         RETVALUE(RFAILED);
 948                      }
 949                   }
 950
 951                   break;
 952                }
 953          }
 954          break;
 955    }
 956    RETVALUE(ROK);
 957 }
 958
 959 /*******************************************************************
 960  *
 961  * @brief  Fills Pst struct for ENTEGTP
 962  *
 963  * @details
 964  *
 965  *    Function : duFillEgtpPst
 966  *
 967  *    Functionality:
 968  *       Fills Pst struct for ENTEGTP
 969  *
 970  * @params[in]
 971  * @return ROK     - success
 972  *         RFAILED - failure
 973  *
 974  * ****************************************************************/
 975 S16 duFillEgtpPst(Pst *pst, Event event)
 976 {
 977    cmMemset((U8 *)pst, 0, sizeof(Pst));
 978    pst->srcEnt = (Ent)ENTDUAPP;
 979    pst->srcInst = (Inst)DU_INST;
 980    pst->srcProcId = DU_PROC;
 981    pst->dstEnt = (Ent)ENTEGTP;
 982    pst->dstInst = (Inst)EGTP_INST;
 983    pst->dstProcId = pst->srcProcId;
 984    pst->event = event;
 985    pst->selector = DU_SELECTOR_LC;
 986    pst->pool= DU_POOL;
 987
 988    RETVALUE(ROK);
 989 }
 990
 991
 992 /*******************************************************************
 993  *
 994  * @brief  Function to configure EGTP
 995  *
 996  * @details
 997  *
 998  *    Function : duBuildEgtpCfgReq
 999  *
1000  *    Functionality:
1001  *       Function to configure EGTP
1002  *
1003  * @params[in]
1004  * @return ROK     - success
1005  *         RFAILED - failure
1006  *
1007  * ****************************************************************/
1008
1009 S16 duBuildEgtpCfgReq()
1010 {
1011     Pst pst;
1012     EgtpConfig egtpCfg;
1013
1014     DU_LOG("\nDU_APP : Sending EGTP config request");
1015
1016     cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig));
1017     cmMemcpy((U8 *)&egtpCfg, (U8 *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig));
1018
1019     duFillEgtpPst(&pst, EVTCFGREQ);
1020     cmPkEgtpCfgReq(&pst, egtpCfg);
1021
1022     RETVALUE(ROK);
1023 }
1024
1025 /*******************************************************************
1026  *
1027  * @brief  Function to configure EGTP
1028  *
1029  * @details
1030  *
1031  *    Function : duBuildEgtpCfgReq
1032  *
1033  *    Functionality:
1034  *       Function to configure EGTP
1035  *
1036  * @params[in]
1037  * @return ROK     - success
1038  *         RFAILED - failure
1039  *
1040  * ****************************************************************/
1041 S16 duHdlEgtpCfgComplete(CmStatus cfm)
1042 {
1043    S16 ret = ROK;
1044
1045    if(cfm.status == LCM_PRIM_OK)
1046    {
1047       DU_LOG("\nDU_APP : EGTP configuraton complete");
1048 #ifdef EGTP_TEST
1049       duSendEgtpSrvOpenReq();
1050 #endif
1051    }
1052    else
1053    {
1054       DU_LOG("\nDU_APP : EGTP configuraton failed");
1055       ret = RFAILED;
1056    }
1057
1058    RETVALUE(ret);
1059 }
1060
1061 /*******************************************************************
1062  *
1063  * @brief  Sends server open request to EGTP
1064  *
1065  * @details
1066  *
1067  *    Function : duSendEgtpSrvOpenReq
1068  *
1069  *    Functionality:
1070  *       Sends server open request to EGTP
1071  *
1072  * @params[in]
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077
1078 S16 duSendEgtpSrvOpenReq()
1079 {
1080    Pst pst;
1081
1082    DU_LOG("\nDU_APP : Sending EGTP server open request");
1083
1084    duFillEgtpPst(&pst, EVTSRVOPENREQ);
1085    cmPkEgtpSrvOpenReq(&pst);
1086
1087    RETVALUE(ROK);
1088 }
1089
1090 /*******************************************************************
1091  *
1092  * @brief Handles server open confirmation
1093  *
1094  * @details
1095  *
1096  *    Function : duHdlEgtpSrvOpenComplete
1097  *
1098  *    Functionality:
1099  *        Handles server open confirmation
1100  *
1101  * @params[in]
1102  * @return ROK     - success
1103  *         RFAILED - failure
1104  *
1105  *****************************************************************/
1106
1107 S16 duHdlEgtpSrvOpenComplete(CmStatus cfm)
1108 {
1109     S16 ret = ROK;
1110
1111     if(cfm.status == LCM_PRIM_OK)
1112     {
1113        DU_LOG("\nDU_APP : EGTP server opened successfully");
1114 #ifdef EGTP_TEST
1115        duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, EGTP_LCL_TEID, EGTP_REM_TEID);
1116 #endif
1117     }
1118     else
1119     {
1120        DU_LOG("\nDU_APP : EGTP server opening failed");
1121        ret = RFAILED;
1122     }
1123
1124     RETVALUE(ret);
1125 }
1126
1127 /*******************************************************************
1128  *
1129  * @brief Sends tunnel management request
1130  *
1131  * @details
1132  *
1133  *    Function : duSendEgtpTnlMgmtReq
1134  *
1135  *    Functionality:
1136  *        Builds and sends tunnel management request to EGTP
1137  *
1138  * @params[in] Action
1139  *             Local tunnel endpoint id
1140  *             Remote tunnel endpoint id
1141  * @return ROK     - success
1142  *         RFAILED - failure
1143  *
1144  * ****************************************************************/
1145
1146 S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid)
1147 {
1148    Pst pst;
1149    EgtpTnlEvt tnlEvt;
1150
1151    tnlEvt.action = action;
1152    tnlEvt.lclTeid = lclTeid;
1153    tnlEvt.remTeid = remTeid;
1154
1155    DU_LOG("\nDU_APP : Sending EGTP tunnel management request");
1156
1157    duFillEgtpPst(&pst, EVTTNLMGMTREQ);
1158    cmPkEgtpTnlMgmtReq(&pst, tnlEvt);
1159
1160    RETVALUE(ROK);
1161 }
1162
1163 /*******************************************************************
1164  *
1165  * @brief Handles Tunnel management confirm
1166  *
1167  * @details
1168  *
1169  *    Function : duHdlEgtpTnlMgmtCfm
1170  *
1171  *    Functionality:
1172  *      Handles tunnel management confirm received from Egtp
1173  *
1174  * @params[in] Tunnel Event
1175  * @return ROK     - success
1176  *         RFAILED - failure
1177  *
1178  * ****************************************************************/
1179 S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm)
1180 {
1181    S16 ret = ROK;
1182
1183    if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK)
1184    {
1185       DU_LOG("\nDU_APP : Tunnel management confirm OK");
1186
1187 #ifdef EGTP_TEST
1188       duSendUeCreateReqToRlc();
1189
1190       duSendEgtpTestData();
1191
1192       /* For testing purpose. TTI thread should actually be in L1 */
1193       duStartTtiThread();
1194 #endif
1195    }
1196    else
1197    {
1198       DU_LOG("\nDU_APP : Tunnel management failed");
1199       ret = RFAILED;
1200    }
1201
1202    RETVALUE(ret);
1203 }
1204
1205 S16 duSendEgtpDatInd(Buffer *mBuf)
1206 {
1207    EgtpMsg  egtpMsg;
1208
1209    /* Fill EGTP header */
1210    egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
1211    egtpMsg.msgHdr.nPdu.pres = FALSE;
1212    egtpMsg.msgHdr.seqNum.pres = FALSE;
1213    egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
1214    egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
1215    egtpMsg.msgHdr.teId = 1;
1216    egtpMsg.msg = mBuf;
1217
1218    egtpHdlDatInd(egtpMsg);
1219
1220    return ROK;
1221
1222 }
1223
1224 #ifdef EGTP_TEST
1225 /*******************************************************************
1226  *
1227  * @brief Simulate UL Data for intial test
1228  *
1229  * @details
1230  *
1231  *    Function : duSendEgtpTestData
1232  *
1233  *    Functionality:
1234  *      Simulate UL data for initial test
1235  *
1236  * @params[in]
1237  * @return ROK     - success
1238  *         RFAILED - failure
1239  *
1240  * ****************************************************************/
1241 S16 duSendEgtpTestData()
1242 {
1243    char data[30] = "This is EGTP data from DU";
1244    int datSize = 30;
1245
1246    Buffer   *mBuf;
1247
1248    if(SGetMsg(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1249    {
1250       if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK)
1251       {
1252          DU_LOG("\nDU_APP : SAddPstMsgMult failed");
1253          SPutMsg(mBuf);
1254          RETVALUE(RFAILED);
1255       }
1256    }
1257    else
1258    {
1259       DU_LOG("\nDU_APP : Failed to allocate memory");
1260       RETVALUE(RFAILED);
1261    }
1262
1263    /* filling IPv4 header */
1264    CmIpv4Hdr ipv4Hdr;
1265    MsgLen    mLen;
1266
1267    mLen = 0;
1268    SFndLenMsg(mBuf, &mLen);
1269
1270    cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
1271    ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
1272    ipv4Hdr.hdrVer = 0x45;
1273    ipv4Hdr.proto = 1;
1274    ipv4Hdr.srcAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.localIp.ipV4Addr);
1275    ipv4Hdr.destAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.destIp.ipV4Addr);
1276
1277    /* Packing IPv4 header into buffer */
1278    S16          ret, cnt, idx;
1279    Data         revPkArray[CM_IPV4_HDRLEN];
1280    Data         pkArray[CM_IPV4_HDRLEN];
1281
1282    /* initialize locals */
1283    cnt = 0;
1284    cmMemset(revPkArray, 0, CM_IPV4_HDRLEN);
1285    cmMemset(pkArray, 0, CM_IPV4_HDRLEN);
1286
1287    /* Pack Header Version */
1288    pkArray[cnt++] = ipv4Hdr.hdrVer;
1289
1290    /* Pack TOS */
1291    pkArray[cnt++] = ipv4Hdr.tos;
1292
1293    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
1294    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
1295
1296    /* Pack Id */
1297    pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
1298    pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
1299
1300    /* Pack Offset */
1301    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
1302    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
1303
1304    /* Pack TTL */
1305    pkArray[cnt++] = ipv4Hdr.ttl;
1306
1307    /* Pack Protocol */
1308    pkArray[cnt++] = ipv4Hdr.proto;
1309
1310    /* Pack Checksum */
1311    pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
1312    pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
1313
1314    /* Pack Source Address */
1315    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
1316    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
1317    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
1318    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
1319
1320    /* Pack Destination Address */
1321    pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
1322    pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
1323    pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
1324    pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
1325
1326    for (idx = 0;  idx < CM_IPV4_HDRLEN;  idx++)
1327       revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
1328
1329    /* this function automatically reverses revPkArray */
1330    ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf);
1331
1332    duSendEgtpDatInd(mBuf);
1333
1334    RETVALUE(ROK);
1335 }
1336 #endif /* EGTP_TEST */
1337
1338
1339 /**************************************************************************
1340  * @brief Function to send configs to SCH
1341  *
1342  * @details
1343  *
1344  *      Function : duSendSchCfg
1345  *
1346  *      Functionality:
1347  *           Sends general config to Scheduler via MAC layer
1348  *
1349  * @param[in]  void
1350  * @return ROK     - success
1351  *         RFAILED - failure
1352  *
1353  ***************************************************************************/
1354 S16 duSendSchCfg()
1355 {
1356    RgMngmt       rgMngmt;
1357    RgSchInstCfg  *cfg = NULLP;
1358    Pst           pst;
1359
1360    DU_SET_ZERO(&pst, sizeof(Pst));
1361    DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt));
1362
1363    cfg = &(rgMngmt.t.cfg.s.schInstCfg);
1364
1365    /* Filling of Instance Id */
1366    cfg->instId = DEFAULT_CELLS + 1;
1367    /* Filling of Gen config */
1368    cfg->genCfg.mem.region = RG_MEM_REGION;
1369    cfg->genCfg.mem.pool = RG_POOL;
1370    cfg->genCfg.tmrRes = 10;
1371
1372 #ifdef LTE_ADV
1373    cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE;
1374    cfg->genCfg.isSCellActDeactAlgoEnable = TRUE;
1375 #endif/*LTE_ADV*/
1376    cfg->genCfg.startCellId     = 1;
1377    cfg->genCfg.lmPst.dstProcId = DU_PROC;
1378    cfg->genCfg.lmPst.srcProcId = DU_PROC;
1379    cfg->genCfg.lmPst.dstEnt    = ENTDUAPP;
1380    cfg->genCfg.lmPst.dstInst   = DU_INST;
1381    cfg->genCfg.lmPst.srcEnt    = ENTRG;
1382    cfg->genCfg.lmPst.srcInst   = DEFAULT_CELLS + 1;
1383    cfg->genCfg.lmPst.prior     = PRIOR0;
1384    cfg->genCfg.lmPst.route     = RTESPEC;
1385    cfg->genCfg.lmPst.region    = RG_MEM_REGION;
1386    cfg->genCfg.lmPst.pool      = RG_POOL;
1387    cfg->genCfg.lmPst.selector  = DU_SELECTOR_LC;
1388
1389    /* Fill Header */
1390    rgMngmt.hdr.msgType             = TCFG;
1391    rgMngmt.hdr.entId.ent           = ENTRG;
1392    rgMngmt.hdr.entId.inst          = DU_INST;
1393    rgMngmt.hdr.elmId.elmnt         = STSCHINST;
1394    rgMngmt.hdr.response.mem.region = RG_MEM_REGION;
1395    rgMngmt.hdr.response.mem.pool   = RG_POOL;
1396
1397    /* Fill Pst */
1398    pst.selector  = DU_SELECTOR_LC;
1399    pst.srcEnt    = ENTDUAPP;
1400    pst.dstEnt    = ENTRG;
1401    pst.dstProcId = DU_PROC;
1402    pst.srcProcId = DU_PROC;
1403    pst.srcInst   = DU_INST;
1404    pst.dstInst   = 0;
1405    pst.region    = duCb.init.region;
1406    pst.event    = (Event) EVTMACSCHGENCFGREQ;
1407
1408    DU_LOG("\nDU_APP : MAC Sch Cfg sent");
1409
1410    /* Send the request to MAC */
1411    cmPkLrgSchCfgReq(&pst, &rgMngmt);
1412
1413    return ROK;
1414 }
1415
1416
1417 /**************************************************************************
1418  * @brief Function to configure SCTP params and
1419  *  responsible for F1 and E2 interfaces
1420  *
1421  * @details
1422  *
1423  *      Function : duLayerConfigComplete
1424  *
1425  *      Functionality:
1426  *           Configures SCTP Params and responsible for handling
1427  *           F1 and E2 interface.
1428  *
1429  * @param[in]  void
1430  * @return ROK     - success
1431  *         RFAILED - failure
1432  *
1433  ***************************************************************************/
1434 S16 duLayerConfigComplete()
1435 {
1436    S16 ret = ROK;
1437
1438    DU_LOG("\nDU_APP : Configuring all Layer is complete");
1439
1440    if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
1441    {
1442       DU_LOG("\nDU_APP : Failed configuring Sctp Params");
1443       ret = RFAILED;
1444    }
1445         if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
1446    {
1447       DU_LOG("\nDU_APP : Failed to send AssocReq F1");
1448       ret = RFAILED;
1449    }
1450    if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
1451    {
1452       DU_LOG("\nDU_APP : Failed to send AssocReq E2");
1453       ret = RFAILED;
1454    }
1455
1456    RETVALUE(ret);
1457 }
1458
1459 /**************************************************************************
1460  * @brief Function to handle  SCH Config Confirm from MAC
1461  *
1462  * @details
1463  *
1464  *      Function : duHdlSchCfgComplete
1465  *
1466  *      Functionality:
1467  *           Handles Scheduler Gen Config Confirm from MAC
1468  *
1469  * @param[in]  Pst     *pst, Post structure of the primitive.
1470  * @param[in]  RgMngmt *cfm, Unpacked primitive info received from MAC
1471  * @return ROK     - success
1472  *         RFAILED - failure
1473  *
1474  ***************************************************************************/
1475 S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm)
1476 {
1477    if (cfm->cfm.status == LCM_PRIM_OK)
1478    {
1479       switch (cfm->hdr.elmId.elmnt)
1480       {
1481          case STSCHINST:
1482             {
1483                DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP");
1484                break;
1485             }
1486          default:
1487             break;
1488       }
1489    }
1490    duLayerConfigComplete();
1491    duBuildEgtpCfgReq();
1492    return ROK;
1493 }
1494
1495 /*******************************************************************
1496  *
1497  * @brief Handles TTI indication
1498  *
1499  * @details
1500  *
1501  *    Function : duSendEgtpTTIInd
1502  *
1503  *    Functionality:
1504  *     Handles TTI indication received from PHY
1505  *
1506  * @params[in]
1507  * @return ROK     - success
1508  *         RFAILED - failure
1509  *
1510  * ****************************************************************/
1511 S16 duSendEgtpTTIInd()
1512 {
1513    Pst pst;
1514
1515    duFillEgtpPst(&pst, EVTTTIIND);
1516    cmPkEgtpTTIInd(&pst);
1517
1518    RETVALUE(ROK);
1519
1520 }
1521
1522 /**************************************************************************
1523  * @brief Function to fill and send MacCellconfig
1524  *
1525  * @details
1526  *
1527  *      Function : duBuildAndSendMacCellCfg
1528  *
1529  *      Functionality:
1530  *           Initiates MAC Configs towards MAC
1531  *
1532  * @param[in] void
1533  * @return ROK     - success
1534  *         RFAILED - failure
1535  *
1536  ***************************************************************************/
1537 S16 duBuildAndSendMacCellCfg()
1538 {
1539    Pst pst;
1540    DU_SET_ZERO(&pst, sizeof(Pst));
1541    MacCellCfg *duMacCellCfg = NULLP;
1542
1543    DU_ALLOC(duMacCellCfg, sizeof(MacCellCfg));
1544    if(duMacCellCfg == NULLP)
1545    {
1546       return RFAILED;
1547    }
1548
1549    /* store the address in the duCb so that we can free on confirm msg */
1550    duCb.duMacCellCfg = duMacCellCfg;
1551
1552    /* copy the mac config structure from duCfgParams */
1553    memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
1554
1555    duMacCellCfg->transId = getTransId(); /* transaction ID */
1556
1557    /* Fill Pst */
1558    pst.selector  = DU_SELECTOR_LWLC;
1559    pst.srcEnt    = ENTDUAPP;
1560    pst.dstEnt    = ENTRG;
1561    pst.dstInst   = 0;
1562    pst.srcInst   = 0;
1563    pst.dstProcId = DU_PROC;
1564    pst.srcProcId = DU_PROC;
1565    pst.region = duCb.init.region;
1566    pst.event = EVENT_MAC_CELL_CONFIG_REQ;
1567
1568    /* Send MAC cell config to MAC */
1569    return (*packMacCellCfgOpts[pst.selector])(&pst, duMacCellCfg);
1570 }
1571
1572 /**************************************************************************
1573  * @brief Function to Handle MAC cell config confirm
1574  *
1575  * @details
1576  *
1577  *      Function : duHandleMacCellCfgCfm
1578  *
1579  *      Functionality:
1580  *           Initiates general Configs towards MAC
1581  *
1582  * @param[in] void
1583  * @return ROK     - success
1584  *         RFAILED - failure
1585  *
1586  ***************************************************************************/
1587 S16 duHandleMacCellCfgCfm(MacCellCfgCfm *macCellCfgCfm)
1588 {
1589    S16 ret = ROK;
1590
1591    if(macCellCfgCfm->transId == duCb.duMacCellCfg->transId)
1592    {
1593       /* free the memory allocated during sending macCellCfg request */
1594       DU_FREE(duCb.duMacCellCfg,sizeof(MacCellCfg));
1595       duCb.duMacCellCfg = NULLP;
1596
1597       /* Build and send GNB-DU config update */
1598       ret = BuildAndSendDUConfigUpdate();
1599    }
1600    else
1601    {
1602       /* transaction ID missmatch */
1603       DU_LOG("\n transaction ID mismatch in macCellCfg");
1604       ret = RFAILED;
1605    }
1606
1607    return ret;
1608 }
1609
1610 /**********************************************************************
1611   End of file
1612  **********************************************************************/