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