X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_msg_hdl.c;h=e29aa3b0dec6bdd419fc5c67e4b96ea78c8ca238;hb=f73456bd55152c329601f8286ae67fe9875025bc;hp=2a677d1c2b57a081d86ccdb810583475896e4f28;hpb=65443172dd60a6ea312bd3a15959dbf54ad7f045;p=o-du%2Fl2.git diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index 2a677d1c2..e29aa3b0d 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -19,6 +19,7 @@ /* This file contains message handling functionality for DU APP */ #include "common_def.h" #include "lrg.h" +#include "du_tmr.h" #include "legtp.h" #include "lkw.h" #include "kwu.h" @@ -27,6 +28,7 @@ #include "kwu.x" #include "du_app_mac_inf.h" #include "du_app_rlc_inf.h" +#include "du_e2ap_mgr.h" #include "du_cfg.h" #include "du_app_rlc_inf.h" #include "du_mgr.h" @@ -36,8 +38,16 @@ #include "du_ue_mgr.h" #include "lsctp.h" #include "legtp.h" -#include "lphy_stub.h" #include "du_utils.h" +#include "du_cell_mgr.h" + +#ifdef O1_ENABLE + +#include "AlarmInterface.h" +#include "CmInterface.h" +#include "PmInterface.h" + +#endif uint8_t rlcDlCfg = 0; uint8_t numRlcDlSaps = 0; @@ -50,11 +60,11 @@ DuCfgParams duCfgParam; uint8_t packRlcConfigReq(Pst *pst, RlcMngmt *cfg); uint8_t cmPkLkwCntrlReq(Pst *pst, RlcMngmt *cfg); uint8_t cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg); -uint8_t BuildAndSendE2SetupReq(); uint8_t egtpHdlDatInd(EgtpMsg egtpMsg); uint8_t BuildAndSendDUConfigUpdate(); uint16_t getTransId(); uint8_t cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg); +uint8_t sendCellDeleteReqToMac(uint16_t cellId); packMacCellCfgReq packMacCellCfgOpts[] = { @@ -63,18 +73,40 @@ packMacCellCfgReq packMacCellCfgOpts[] = packMacCellCfg, /* packing for light weight loosly coupled */ }; -DuMacCellStartReq packMacCellStartReqOpts[] = +DuMacCellStart packMacCellStartOpts[] = +{ + packMacCellStart, /* Loose coupling */ + MacProcCellStart, /* TIght coupling */ + packMacCellStart /* Light weight-loose coupling */ +}; + +DuMacCellStop packMacCellStopOpts[] = +{ + packMacCellStop, /* Loose coupling */ + MacProcCellStop, /* TIght coupling */ + packMacCellStop /* Light weight-loose coupling */ +}; + +DuMacSliceCfgReq packMacSliceCfgReqOpts[] = +{ + packDuMacSliceCfgReq, /* Loose coupling */ + MacProcSliceCfgReq, /* TIght coupling */ + packDuMacSliceCfgReq /* Light weight-loose coupling */ +}; + + +DuMacSliceRecfgReq packMacSliceRecfgReqOpts[] = { - packMacCellStartReq, /* Loose coupling */ - MacProcCellStartReq, /* TIght coupling */ - packMacCellStartReq /* Light weight-loose coupling */ + packDuMacSliceRecfgReq, /* Loose coupling */ + MacProcSliceRecfgReq, /* TIght coupling */ + packDuMacSliceRecfgReq /* Light weight-loose coupling */ }; -DuMacCellStopReq packMacCellStopReqOpts[] = +DuMacStatsReqFunc packMacStatsReqOpts[]= { - packMacCellStopReq, /* Loose coupling */ - MacProcCellStopReq, /* TIght coupling */ - packMacCellStopReq /* Light weight-loose coupling */ + packDuMacStatsReq, /* Loose Coupling */ + MacProcStatsReq, /* Tight Coupling */ + packDuMacStatsReq /* Light weight-loose coupling */ }; /************************************************************************** @@ -152,7 +184,7 @@ uint8_t duBuildRlcCfg(Inst inst) pst.srcProcId = DU_PROC; pst.region = duCb.init.region; - DU_LOG("\nDU_APP : RLC Gen Cfg Req sent for inst %d", inst); + DU_LOG("\nDEBUG --> DU_APP : RLC Gen Cfg Req sent for inst %d", inst); /* Send the request to RLC */ packRlcConfigReq(&pst, &rlcMngmt); @@ -218,7 +250,7 @@ uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst) lSap->sapId = lsapInst; /* SapId will be stored as suId in MAC */ lSap->selector = (inst == RLC_UL_INST) ? ODU_SELECTOR_LWLC : ODU_SELECTOR_TC; rlcMngmt.hdr.elmId.elmnt = STRGUSAP; - DU_LOG("\nDU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst); + DU_LOG("\nDEBUG --> DU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst); } else @@ -230,7 +262,7 @@ uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst) lSap->sapId = 0; lSap->selector = ODU_SELECTOR_LC; rlcMngmt.hdr.elmId.elmnt = STUDXSAP; - DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst); + DU_LOG("\nDEBUG --> DU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst); } packRlcConfigReq(&pst, &rlcMngmt); @@ -297,7 +329,7 @@ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) pst.srcProcId = DU_PROC; pst.region = duCb.init.region; - DU_LOG("\nDU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst); + DU_LOG("\nDEBUG --> DU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst); packRlcConfigReq(&pst, &rlcMngmt); return ROK; @@ -322,49 +354,48 @@ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) uint8_t duProcCfgComplete() { uint8_t ret = ROK; - static uint16_t cellId = 0; uint16_t idx; for(idx=0; idx< DEFAULT_CELLS; idx++) { DuCellCb *cell = NULLP; - DU_ALLOC(cell, sizeof(DuCellCb)) - if(cell == NULLP) - { - DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete"); - ret = RFAILED; - } - else - { - uint32_t nci; - uint8_t idx1; - memset(cell, 0, sizeof(DuCellCb)); - cell->cellId = ++cellId; - cell->cellInfo.nrEcgi.plmn.mcc[0] = PLMN_MCC0; - cell->cellInfo.nrEcgi.plmn.mcc[1] = PLMN_MCC1; - cell->cellInfo.nrEcgi.plmn.mcc[2] = PLMN_MCC2; - cell->cellInfo.nrEcgi.plmn.mnc[0] = PLMN_MNC0; - cell->cellInfo.nrEcgi.plmn.mnc[1] = PLMN_MNC1; - cell->cellInfo.nrEcgi.plmn.mnc[2] = PLMN_MNC2; - cell->cellInfo.nrEcgi.cellId = NR_CELL_ID; - cell->cellInfo.nrPci = NR_PCI; - cell->cellInfo.fiveGsTac = DU_TAC; - for(idx1=0; idx1cellInfo.plmn[idx1].mcc[0] = PLMN_MCC0; - cell->cellInfo.plmn[idx1].mcc[1] = PLMN_MCC1; - cell->cellInfo.plmn[idx1].mcc[2] = PLMN_MCC2; - cell->cellInfo.plmn[idx1].mnc[0] = PLMN_MNC0; - cell->cellInfo.plmn[idx1].mnc[1] = PLMN_MNC1; - cell->cellInfo.plmn[idx1].mnc[2] = PLMN_MNC2; - } - cell->cellInfo.maxUe = duCfgParam.maxUe; - cell->cellStatus = CELL_OUT_OF_SERVICE; - nci = (uint16_t)cell->cellInfo.nrEcgi.cellId; - - duCb.cfgCellLst[nci-1] = cell; - duCb.numCfgCells++; - } + DU_ALLOC(cell, sizeof(DuCellCb)); + if(cell == NULLP) + { + DU_LOG("\nERROR --> DU_APP : Memory Allocation failed in duProcCfgComplete"); + ret = RFAILED; } + else + { + uint8_t idx1=0; + memset(cell, 0, sizeof(DuCellCb)); + cell->cellId = NR_CELL_ID; //++cellId; + memset(&cell->cellInfo.nrEcgi.plmn, 0, sizeof(Plmn)); + cell->cellInfo.nrEcgi.plmn.mcc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[0]; + cell->cellInfo.nrEcgi.plmn.mcc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[1]; + cell->cellInfo.nrEcgi.plmn.mcc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[2]; + cell->cellInfo.nrEcgi.plmn.mnc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[0]; + cell->cellInfo.nrEcgi.plmn.mnc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[1]; + cell->cellInfo.nrEcgi.plmn.mnc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[2]; + cell->cellInfo.nrEcgi.cellId = cell->cellId; + cell->cellInfo.nrPci = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci; + cell->cellInfo.fiveGsTac = duCfgParam.srvdCellLst[0].duCellInfo.tac; + memset(&cell->cellInfo.plmn[idx1], 0, sizeof(Plmn)); + for(idx1=0; idx1cellInfo.plmn[idx1].mcc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[0]; + cell->cellInfo.plmn[idx1].mcc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[1]; + cell->cellInfo.plmn[idx1].mcc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[2]; + cell->cellInfo.plmn[idx1].mnc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[0]; + cell->cellInfo.plmn[idx1].mnc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[1]; + cell->cellInfo.plmn[idx1].mnc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[2]; + } + cell->cellInfo.maxUe = duCfgParam.maxUe; + cell->cellStatus = CELL_OUT_OF_SERVICE; + gCellStatus = CELL_DOWN; + duCb.cfgCellLst[duCb.numCfgCells] = cell; + duCb.numCfgCells++; + } + } if(ret != RFAILED) { //Start layer configs @@ -487,7 +518,7 @@ uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cntrl) { if (pst->srcInst == RLC_DL_INST) { - DU_LOG("\nDU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL"); + DU_LOG("\nDEBUG --> DU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL"); macCfgInst++; if(macCfgInst < DEFAULT_CELLS) { @@ -501,7 +532,7 @@ uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cntrl) } else { - DU_LOG("\nDU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL"); + DU_LOG("\nDEBUG --> DU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL"); macCfgInst++; if(macCfgInst < DEFAULT_CELLS) { @@ -539,7 +570,7 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm) { uint8_t ret; - DU_LOG("\nDU_APP : RLC UL Cfg Status %d", cfm->cfm.status); + DU_LOG("\nDEBUG --> DU_APP : RLC UL Cfg Status %d", cfm->cfm.status); if (cfm->cfm.status == LCM_PRIM_OK) { switch(cfm->hdr.elmId.elmnt) @@ -568,7 +599,7 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm) default: break; } - DU_LOG("\nDU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); + DU_LOG("\nDEBUG --> DU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); if(rlcUlCfg == DU_RLC_UL_CONFIGURED) { rlcUlCfg = 0; @@ -580,7 +611,7 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm) } else { - DU_LOG("\nDU_APP : Config confirm NOK from RLC UL"); + DU_LOG("\nERROR --> DU_APP : Config confirm NOK from RLC UL"); ret = RFAILED; } return ret; @@ -604,7 +635,7 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm) ***************************************************************************/ uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm) { - DU_LOG("\nDU_APP : RLC DL Cfg Status %d", cfm->cfm.status); + DU_LOG("\nDEBUG --> DU_APP : RLC DL Cfg Status %d", cfm->cfm.status); if (cfm->cfm.status == LCM_PRIM_OK) { switch(cfm->hdr.elmId.elmnt) @@ -634,7 +665,7 @@ uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm) break; } - DU_LOG("\nDU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); + DU_LOG("\nDEBUG --> DU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); if(rlcDlCfg == DU_RLC_DL_CONFIGURED) { rlcDlCfg = 0; @@ -645,7 +676,7 @@ uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm) } else { - DU_LOG("\nDU_APP : Config confirm NOK from RLC DL"); + DU_LOG("\nERROR --> DU_APP : Config confirm NOK from RLC DL"); } return ROK; } @@ -703,7 +734,7 @@ uint8_t duBuildMacGenCfg() /*----------- Fill General Configuration Parameters ---------*/ genCfg->mem.region = MAC_MEM_REGION; genCfg->mem.pool = MAC_POOL; - genCfg->tmrRes = 10; + genCfg->tmrRes = 1; genCfg->numRguSaps = 2; genCfg->lmPst.dstProcId = DU_PROC; @@ -743,7 +774,7 @@ uint8_t duBuildMacGenCfg() pst.srcProcId = DU_PROC; pst.region = duCb.init.region; - DU_LOG("\nDU_APP : MAC Gen Cfg Req sent"); + DU_LOG("\nDEBUG --> DU_APP : MAC Gen Cfg Req sent"); /* Send the request to MAC */ cmPkLrgCfgReq(&pst, &rgMngmt); @@ -805,7 +836,7 @@ uint8_t duBuildMacUsapCfg(SpId sapId) pst.srcProcId = DU_PROC; pst.region = duCb.init.region; - DU_LOG("\nDU_APP : MAC Rgu USap Cfg Req sent"); + DU_LOG("\nDEBUG --> DU_APP : MAC Rgu USap Cfg Req sent"); /* Send the request to MAC */ cmPkLrgCfgReq(&pst, &rgMngmt); @@ -851,11 +882,11 @@ uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) default: break; } - DU_LOG("\nDU_APP : MAC Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); + DU_LOG("\nDEBUG --> DU_APP : MAC Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); if(macCfg == MAC_CONFIGURED && numRlcMacSaps == MAX_MAC_SAP) { macCfg = 0; - DU_LOG("\nDU_APP : Completed sending Configs"); + DU_LOG("\nDEBUG --> DU_APP : Completed sending Configs"); macCfgInst = 0; duBindUnbindRlcToMacSap(RLC_DL_INST, ABND); } @@ -863,7 +894,7 @@ uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) } else { - DU_LOG("\nDU_APP : Config confirm NOK from MAC"); + DU_LOG("\nERROR --> DU_APP : Config confirm NOK from MAC"); ret = RFAILED; } return ret; @@ -897,11 +928,11 @@ uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action) if (action == ABND) { - DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst); + DU_LOG("\nDEBUG --> DU_APP : Cntrl Req to RLC inst %d to bind MAC sap", inst); } else { - DU_LOG("\nDU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst); + DU_LOG("\nDEBUG --> DU_APP : Cntrl Req to RLC inst %d to unbind MAC sap", inst); } cntrl = &(rlcMngmt.t.cntrl); @@ -957,19 +988,16 @@ uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) { if(BuildAndSendF1SetupReq() != ROK) { - return RFAILED; + return RFAILED; } } else if(ricParams.assocId == ntfy->u.assocChange.assocId) { - if(BuildAndSendE2SetupReq() != ROK) - { - return RFAILED; - } + return ROK; } else { - DU_LOG("\nDU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId); + DU_LOG("\nERROR --> DU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId); return RFAILED; } return ROK; @@ -1030,7 +1058,7 @@ uint8_t duBuildEgtpCfgReq() Pst pst; EgtpConfig egtpCfg; - DU_LOG("\nDU_APP : Sending EGTP config request"); + DU_LOG("\nDEBUG --> DU_APP : Sending EGTP config request"); memset(&egtpCfg, 0, sizeof(EgtpConfig)); memcpy(&egtpCfg, &duCfgParam.egtpParams, sizeof(EgtpConfig)); @@ -1063,14 +1091,12 @@ uint8_t duHdlEgtpCfgComplete(CmStatus cfm) if(cfm.status == LCM_PRIM_OK) { - DU_LOG("\nDU_APP : EGTP configuraton complete"); -#ifdef EGTP_TEST + DU_LOG("\nDEBUG --> DU_APP : EGTP configuraton complete"); duSendEgtpSrvOpenReq(); -#endif } else { - DU_LOG("\nDU_APP : EGTP configuraton failed"); + DU_LOG("\nERROR --> DU_APP : EGTP configuraton failed"); ret = RFAILED; } @@ -1098,7 +1124,7 @@ uint8_t duSendEgtpSrvOpenReq() { Pst pst; - DU_LOG("\nDU_APP : Sending EGTP server open request"); + DU_LOG("\nDEBUG --> DU_APP : Sending EGTP server open request"); duFillEgtpPst(&pst, EVTSRVOPENREQ); packEgtpSrvOpenReq(&pst); @@ -1129,14 +1155,11 @@ uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm) if(cfm.status == LCM_PRIM_OK) { - DU_LOG("\nDU_APP : EGTP server opened successfully"); -#ifdef EGTP_TEST - duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, EGTP_LCL_TEID, EGTP_REM_TEID); -#endif + DU_LOG("\nDEBUG --> DU_APP : EGTP server opened successfully"); } else { - DU_LOG("\nDU_APP : EGTP server opening failed"); + DU_LOG("\nERROR --> DU_APP : EGTP server opening failed"); ret = RFAILED; } @@ -1162,21 +1185,28 @@ uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm) * * ****************************************************************/ -uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid) +uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t teIdTobeMod, GtpTnlCfg *ueCbTnlCfg) { + uint8_t ret =ROK; Pst pst; EgtpTnlEvt tnlEvt; - tnlEvt.action = action; - tnlEvt.lclTeid = lclTeid; - tnlEvt.remTeid = remTeid; - - DU_LOG("\nDU_APP : Sending EGTP tunnel management request"); + DU_LOG("\nDEBUG --> DU_APP : Sending EGTP tunnel management request for teId [%d]", ueCbTnlCfg->teId); + /* ADD/MOD/DEL per tunnel */ + tnlEvt.action = action; + tnlEvt.remTeid = ueCbTnlCfg->teId; + if(action != EGTP_TNL_MGMT_ADD) + { + tnlEvt.lclTeid = teIdTobeMod; + } + else + { + tnlEvt.lclTeid = ueCbTnlCfg->teId; + } duFillEgtpPst(&pst, EVTTNLMGMTREQ); - packEgtpTnlMgmtReq(&pst, tnlEvt); - - return ROK; + ret = egtpTnlMgmtReq(&pst, tnlEvt); + return ret; } /******************************************************************* @@ -1201,17 +1231,32 @@ uint8_t duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK) { - DU_LOG("\nDU_APP : Tunnel management confirm OK"); + DU_LOG("\nDEBUG --> DU_APP: Tunnel management confirm OK"); } else { - DU_LOG("\nDU_APP : Tunnel management failed"); + DU_LOG("\nERROR --> DU_APP: Tunnel management failed"); ret = RFAILED; } return (ret); } +/******************************************************************* + * + * @brief Sends UL user data over to EGTP + * + * @details + * + * Function : duSendEgtpDatInd + * + * Functionality: Sends UL user data over to EGTP + * + * @params[in] UL data buffer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ uint8_t duSendEgtpDatInd(Buffer *mBuf) { EgtpMsg egtpMsg; @@ -1224,128 +1269,13 @@ uint8_t duSendEgtpDatInd(Buffer *mBuf) egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE; egtpMsg.msgHdr.teId = 1; egtpMsg.msg = mBuf; - + egtpHdlDatInd(egtpMsg); return ROK; } -#ifdef EGTP_TEST -/******************************************************************* - * - * @brief Simulate UL Data for intial test - * - * @details - * - * Function : duSendEgtpTestData - * - * Functionality: - * Simulate UL data for initial test - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t duSendEgtpTestData() -{ - char data[30] = "This is EGTP data from DU"; - int datSize = 30; - - Buffer *mBuf; - - if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK) - { - if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK) - { - DU_LOG("\nDU_APP : ODU_ADD_POST_MSG_MULT failed"); - ODU_PUT_MSG_BUF(mBuf); - return RFAILED; - } - } - else - { - DU_LOG("\nDU_APP : Failed to allocate memory"); - return RFAILED; - } - - /* filling IPv4 header */ - CmIpv4Hdr ipv4Hdr; - MsgLen mLen; - - mLen = 0; - ODU_GET_MSG_LEN(mBuf, &mLen); - - memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr)); - ipv4Hdr.length = CM_IPV4_HDRLEN + mLen; - ipv4Hdr.hdrVer = 0x45; - ipv4Hdr.proto = 1; - ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(duCfgParam.egtpParams.localIp.ipV4Addr); - ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(duCfgParam.egtpParams.destIp.ipV4Addr); - - /* Packing IPv4 header into buffer */ - uint8_t ret, cnt, idx; - Data revPkArray[CM_IPV4_HDRLEN]; - Data pkArray[CM_IPV4_HDRLEN]; - - /* initialize locals */ - cnt = 0; - memset(revPkArray, 0, CM_IPV4_HDRLEN); - memset(pkArray, 0, CM_IPV4_HDRLEN); - - /* Pack Header Version */ - pkArray[cnt++] = ipv4Hdr.hdrVer; - - /* Pack TOS */ - pkArray[cnt++] = ipv4Hdr.tos; - - pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length); - pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length); - - /* Pack Id */ - pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id); - pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id); - - /* Pack Offset */ - pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off); - pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off); - - /* Pack TTL */ - pkArray[cnt++] = ipv4Hdr.ttl; - - /* Pack Protocol */ - pkArray[cnt++] = ipv4Hdr.proto; - - /* Pack Checksum */ - pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum); - pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum); - - /* Pack Source Address */ - pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr)); - pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr)); - pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr)); - pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr)); - - /* Pack Destination Address */ - pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr)); - pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr)); - pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr)); - pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr)); - - for (idx = 0; idx < CM_IPV4_HDRLEN; idx++) - revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1]; - - /* this function automatically reverses revPkArray */ - ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf); - - duSendEgtpDatInd(mBuf); - - return ROK; -} -#endif /* EGTP_TEST */ - - /************************************************************************** * @brief Function to send configs to SCH * @@ -1377,7 +1307,7 @@ uint8_t duSendSchCfg() /* Filling of Gen config */ cfg->genCfg.mem.region = MAC_MEM_REGION; cfg->genCfg.mem.pool = MAC_POOL; - cfg->genCfg.tmrRes = 10; + cfg->genCfg.tmrRes = 1; #ifdef LTE_ADV cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE; @@ -1415,7 +1345,7 @@ uint8_t duSendSchCfg() pst.region = duCb.init.region; pst.event = (Event) EVTMACSCHGENCFGREQ; - DU_LOG("\nDU_APP : MAC Sch Cfg sent"); + DU_LOG("\nDEBUG --> DU_APP : MAC Sch Cfg sent"); /* Send the request to MAC */ cmPkLrgSchCfgReq(&pst, &rgMngmt); @@ -1445,21 +1375,21 @@ uint8_t duLayerConfigComplete() { uint8_t ret = ROK; - DU_LOG("\nDU_APP : Configuring all Layer is complete"); + DU_LOG("\nINFO --> DU_APP : Configuring all Layer is complete"); if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK) { - DU_LOG("\nDU_APP : Failed configuring Sctp Params"); + DU_LOG("\nERROR --> DU_APP : Failed configuring Sctp Params"); ret = RFAILED; } if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK) { - DU_LOG("\nDU_APP : Failed to send AssocReq F1"); + DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq F1"); ret = RFAILED; } if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK) { - DU_LOG("\nDU_APP : Failed to send AssocReq E2"); + DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq E2"); ret = RFAILED; } @@ -1490,7 +1420,7 @@ uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm) { case STSCHINST: { - DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP"); + DU_LOG("\nDEBUG --> DU_APP : Received SCH CFG CFM at DU APP"); break; } default: @@ -1502,33 +1432,6 @@ uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm) return ROK; } -/******************************************************************* - * - * @brief Sends Slot indication to EGTP - * - * @details - * - * Function : duSendEgtpSlotInd - * - * Functionality: - * Sends Slot indication to EGTP - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t duSendEgtpSlotInd() -{ - Pst pst; - - duFillEgtpPst(&pst, EVTSLOTIND); - packEgtpSlotInd(&pst); - - return ROK; - -} - /************************************************************************** * @brief Function to fill and send MacCellconfig * @@ -1556,7 +1459,13 @@ uint8_t duBuildAndSendMacCellCfg(uint16_t cellId) } /* store the address in the duCellCb so that we can free on confirm msg */ - duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg; + if(duCb.actvCellLst[cellId-1]) + duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg; + else + { + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duMacCellCfg, sizeof(MacCellCfg)); + return RFAILED; + } /* copy the mac config structure from duCfgParams */ memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg)); @@ -1585,93 +1494,42 @@ uint8_t duBuildAndSendMacCellCfg(uint16_t cellId) ***************************************************************************/ uint8_t duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm) { - uint8_t actvCellIdx = 0; - uint8_t ret = ROK; + uint8_t actvCellIdx = 0; + uint8_t ret = ROK; for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++) { - if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId) + if((duCb.actvCellLst[actvCellIdx]) && (macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId)) { - duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP; + duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP; } } if(macCellCfgCfm->rsp == ROK) { /* Build and send GNB-DU config update */ - ret = BuildAndSendDUConfigUpdate(); + ret = BuildAndSendDUConfigUpdate(SERV_CELL_TO_MODIFY); /* Build and Send Cell Start Req to MAC */ - ret = duBuildAndSendMacCellStartReq(); + ret = duBuildAndSendMacCellStart(); } else { /* TODO : Action to be taken if cell configuration fails. * Should CU be informed? */ - DU_LOG("\nMac cell cfg failed"); + DU_LOG("\nERROR --> DU_APP : Mac cell cfg failed"); ret = RFAILED; } return ret; } -/******************************************************************* - * - * @brief Handles slot indication from MAC - * - * @details - * - * Function : duHandleSlotInd - * - * Functionality: - * Handles slot indication from MAC - * - * @params[in] Post structure pointer - * Slot Info pointer - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t duHandleSlotInd(Pst *pst, SlotIndInfo *slotInfo) -{ - if(slotInfo->cellId <=0 || slotInfo->cellId > MAX_NUM_CELL) - { - DU_LOG("\nDU APP : Invalid Cell Id %d", slotInfo->cellId); - } - if(!duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd) - { -#ifdef ODU_SLOT_IND_DEBUG_LOG - DU_LOG("\nDU APP : Slot Indication received"); -#endif - duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd = true; - if((duCb.actvCellLst[slotInfo->cellId-1] != NULL) && \ - (duCb.actvCellLst[slotInfo->cellId-1]->cellStatus == \ - ACTIVATION_IN_PROGRESS)) - { - DU_LOG("\nDU APP : 5G-NR Cell %d is UP", slotInfo->cellId); - duCb.actvCellLst[slotInfo->cellId-1]->cellStatus = ACTIVATED; - } - - } - - /* TODO : Slot Indication to be moved out of EGTP_TEST when - * data path is established */ -#ifdef EGTP_TEST - duSendEgtpSlotInd(); -#endif - - if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC)) - DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, slotInfo, sizeof(SlotIndInfo)); - - return ROK; -} - /******************************************************************* * * @brief Builds and sends cell start request to MAC * * @details * - * Function : duBuildAndSendMacCellStartReq + * Function : duBuildAndSendMacCellStart * * Functionality: * Builds and sends cell start request to MAC @@ -1681,18 +1539,18 @@ uint8_t duHandleSlotInd(Pst *pst, SlotIndInfo *slotInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t duBuildAndSendMacCellStartReq() +uint8_t duBuildAndSendMacCellStart() { Pst pst; - MacCellStartInfo *cellStartInfo = NULL; + CellStartInfo *cellStart = NULL; - DU_LOG("\nDU APP : Building and Sending cell start request to MAC"); + DU_LOG("\nINFO --> DU APP : Building and Sending cell start request to MAC"); /* Send Cell Start Request to MAC */ - DU_ALLOC_SHRABL_BUF(cellStartInfo, sizeof(MacCellStartInfo)); - if(!cellStartInfo) + DU_ALLOC_SHRABL_BUF(cellStart, sizeof(CellStartInfo)); + if(!cellStart) { - DU_LOG("\nDU APP : Memory alloc failed while building cell start request"); + DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request"); return RFAILED; } @@ -1700,13 +1558,12 @@ uint8_t duBuildAndSendMacCellStartReq() { if(duCb.actvCellLst[id]) { - duCb.actvCellLst[id]->firstSlotIndRcvd = FALSE; - cellStartInfo->cellId = duCb.actvCellLst[id]->cellInfo.nrEcgi.cellId; + cellStart->cellId = duCb.actvCellLst[id]->cellId; - /* Fill Pst */ - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START_REQ); + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START); - return (*packMacCellStartReqOpts[pst.selector])(&pst, cellStartInfo); + return (*packMacCellStartOpts[pst.selector])(&pst, cellStart); } } return ROK; @@ -1718,7 +1575,7 @@ uint8_t duBuildAndSendMacCellStartReq() * * @details * - * Function : duBuildAndSendMacCellStopReq + * Function : duBuildAndSendMacCellStop * * Functionality: * Builds and sends cell stop request to MAC @@ -1728,26 +1585,38 @@ uint8_t duBuildAndSendMacCellStartReq() * RFAILED - failure * * ****************************************************************/ -uint8_t duBuildAndSendMacCellStopReq() +uint8_t duBuildAndSendMacCellStop(uint16_t cellId) { Pst pst; - MacCellStopInfo *cellStopInfo = NULL; + uint16_t cellIdx=0; + CellStopInfo *cellStop = NULL; - DU_LOG("\nDU APP : Building and Sending cell stop request to MAC"); + DU_LOG("\nINFO --> DU APP : Building and Sending cell stop request to MAC"); - /* Send Cell Stop Request to MAC */ - DU_ALLOC_SHRABL_BUF(cellStopInfo, sizeof(MacCellStopInfo)); - if(!cellStopInfo) + GET_CELL_IDX(cellId, cellIdx); + if(duCb.actvCellLst[cellIdx] != NULLP) { - DU_LOG("\nDU APP : Memory alloc failed while building cell stop request"); - return RFAILED; - } - cellStopInfo->cellId = duCb.actvCellLst[0]->cellId; + /* Send Cell Stop Request to MAC */ + DU_ALLOC_SHRABL_BUF(cellStop, sizeof(CellStopInfo)); + if(!cellStop) + { + DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell stop request"); + return RFAILED; + } + memset(cellStop, 0, sizeof(CellStopInfo)); + cellStop->cellId = duCb.actvCellLst[cellIdx]->cellId; - /* Fill Pst */ - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP_REQ); + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP); - return (*packMacCellStopReqOpts[pst.selector])(&pst, cellStopInfo); + return (*packMacCellStopOpts[pst.selector])(&pst, cellStop); + } + else + { + DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): cellId[%d] doesnot exists", cellId); + return RFAILED; + } + return ROK; } /******************************************************************* @@ -1766,27 +1635,41 @@ uint8_t duBuildAndSendMacCellStopReq() * RFAILED - failure * * ****************************************************************/ -uint8_t duHandleStopInd(Pst *pst, MacCellStopInfo *cellStopId) +uint8_t duHandleStopInd(Pst *pst, OduCellId *cellId) { - if(cellStopId->cellId <=0 || cellStopId->cellId > MAX_NUM_CELL) + DuCellCb *cellCb = NULLP; + + if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL) { - DU_LOG("\nDU APP : Invalid Cell Id %d", cellStopId->cellId); + DU_LOG("\nERROR --> DU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId); } - if(duCb.actvCellLst[cellStopId->cellId-1] != NULL) + + if(duGetCellCb(cellId->cellId, &cellCb) != ROK) + return RFAILED; + + if((cellCb->cellStatus == ACTIVATED) || (cellCb->cellStatus == DELETION_IN_PROGRESS)) { - if(duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd) + DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId); + if(sendCellDeleteReqToMac(cellId->cellId) == RFAILED) { - duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd = false; - if((duCb.actvCellLst[cellStopId->cellId-1]->cellStatus == \ - ACTIVATED)) - { - DU_LOG("\nDU APP : 5G-NR Cell %d is DOWN", cellStopId->cellId); - duCb.actvCellLst[cellStopId->cellId-1]->cellStatus = DELETION_IN_PROGRESS; - } + DU_LOG("\nERROR --> DU APP : duHandleStopInd(): Failed to send Cell delete req to MAC for\ + cellId[%d]", cellId->cellId); + return RFAILED; } + + +#ifdef O1_ENABLE + DU_LOG("\nINFO --> DU APP : Raise cell down alarm for cell id=%d", cellId->cellId); + raiseCellAlrm(CELL_DOWN_ALARM_ID, cellId->cellId); + setCellOpState(cellId->cellId, DISABLED, INACTIVE); +#endif } + if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC)) - DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, cellStopId, sizeof(MacCellStopInfo)); + DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, cellId, sizeof(OduCellId)); + + cellCb->cellStatus = CELL_OUT_OF_SERVICE; //TODO: cell status must be set to OOS after all UE and cell cleanup which is not + //supported now return ROK; } @@ -1811,7 +1694,7 @@ uint8_t duHandleStopInd(Pst *pst, MacCellStopInfo *cellStopId) uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo) { - DU_LOG("\nDU APP : UL CCCH Indication received"); + DU_LOG("\nINFO --> DU APP : UL CCCH Indication received"); return (duProcUlCcchInd(ulCcchIndInfo)); } @@ -1834,15 +1717,63 @@ uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo) * ****************************************************************/ uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo) { - DuUeCb ueCb; - - ueCb = duCb.actvCellLst[ulRrcMsgInfo->cellId -1]->ueCb[ulRrcMsgInfo->ueIdx -1]; - BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \ - ulRrcMsgInfo->rrcMsg); + uint8_t ret = ROK; + DuCellCb *cellCb = NULLP; + DuUeCb *ueCb = NULLP; + + duGetCellCb(ulRrcMsgInfo->cellId, &cellCb); + if(cellCb) + { + if(ulRrcMsgInfo->ueId > 0) + { + if(cellCb->ueCb[ulRrcMsgInfo->ueId -1].gnbDuUeF1apId == ulRrcMsgInfo->ueId) + ueCb = &cellCb->ueCb[ulRrcMsgInfo->ueId -1]; + + if(ueCb) + { + /* If UL message is received for a UE in handover, it signifies that UE is now + * attached to GNB. Hence marking this UE as active and requesting MAC to + * release the dedicated RACH resources */ + if(ueCb->ueState == UE_HANDIN_IN_PROGRESS) + { + ueCb->ueState = UE_ACTIVE; + cellCb->numActvUes++; + + /* Release RACH resources */ + memset(&ueCb->cfraResource, 0, sizeof(MacCfraResource)); + if(duBuildAndSendRachRsrcRelToMac(ulRrcMsgInfo->cellId, ueCb) != ROK) + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to send RACH resource release to MAC"); + } + } + + if(BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, ulRrcMsgInfo->rrcMsg) != ROK) + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to build and send UL RRC Message Transfer"); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : UE ID [%d] not found", ulRrcMsgInfo->ueId); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Invalid UE ID [%d]", ulRrcMsgInfo->ueId); + ret = RFAILED; + } + } + else + { + DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Cell ID [%d] not found", ulRrcMsgInfo->cellId); + ret = RFAILED; + } DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo->rrcMsg, ulRrcMsgInfo->msgLen); DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo)); - return ROK; + return ret; } /******************************************************************* @@ -1863,16 +1794,428 @@ uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo) * ****************************************************************/ uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryReport) { - DuUeCb ueCb; - uint8_t ret = RFAILED; + DuCellCb *cellCb = NULLP; + DuUeCb ueCb; + uint8_t ret = RFAILED; - ueCb = duCb.actvCellLst[rrcDeliveryReport->cellId -1]->ueCb[rrcDeliveryReport->ueIdx -1]; - ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport); + if(duGetCellCb(rrcDeliveryReport->cellId, &cellCb) != ROK) + return RFAILED; + + ueCb = cellCb->ueCb[rrcDeliveryReport->ueId -1]; + ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport); - DU_FREE_SHRABL_BUF(pst->region, pst->pool, rrcDeliveryReport, sizeof(RrcDeliveryReport)); - return ret; + DU_FREE_SHRABL_BUF(pst->region, pst->pool, rrcDeliveryReport, sizeof(RrcDeliveryReport)); + return ret; } +/******************************************************************* + * + * @brief Process UL user data from RLC + * + * @details + * + * Function : DuProcRlcUlUserDataTrans + * + * Functionality: Process UL user data from RLC + * + * @params[in] Post structure + * UL user data + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData) +{ + uint8_t teIdx = 0; + EgtpMsg egtpMsg; + Buffer *mBuf; + + DU_LOG("\nDEBUG --> DU APP : Received UL user data"); + + /* Fill EGTP header */ + egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU; + egtpMsg.msgHdr.nPdu.pres = FALSE; + egtpMsg.msgHdr.seqNum.pres = FALSE; + egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE; + egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE; + + /* Fetch EGTP tunnel info */ + for(teIdx = 0; teIdx < duCb.numTeId; teIdx++) + { + /*TODO: If multiple Cell Support is enables then CellId also needs to be validated alongwith ueId and DrbId*/ + if((duCb.upTnlCfg[teIdx] != NULLP) && (duCb.upTnlCfg[teIdx]->ueId == ulUserData->ueId) && \ + (duCb.upTnlCfg[teIdx]->drbId == ulUserData->rbId)) + { + if(duCb.upTnlCfg[teIdx]->tnlCfg1) + { + egtpMsg.msgHdr.teId = duCb.upTnlCfg[teIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/ + break; + } + } + } + + if (ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) != ROK) + { + DU_LOG("\nERROR --> DU APP : Failed to allocated buffer memory in DuProcRlcUlUserDataTrans"); + DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen); + DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo)); + return RFAILED; + } + oduCpyFixBufToMsg(ulUserData->userData, mBuf, ulUserData->msgLen); + ODU_PRINT_MSG(mBuf, 0, 0); + egtpMsg.msg = mBuf; + egtpHdlDatInd(egtpMsg); + + DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen); + DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo)); + return ROK; +} + +/******************************************************************* + * + * @brief process the slice cfg rsp received from MAC + * + * @details + * + * Function : DuProcMacSliceCfgRsp + * + * Functionality: process the slice cfg rsp received from MAC + * + * @params[in] Post structure, MacSliceCfgRsp *cfgRsp + * + * @return ROK - success + * RFAILED - failure + * + **********************************************************************/ +uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp) +{ + if(cfgRsp) + { + if(cfgRsp->rsp == MAC_DU_APP_RSP_OK) + { + duCb.sliceState = SLICE_CONFIGURED; + DU_LOG("\nINFO --> DU_APP : Slice configured successfully "); + } + else + { + DU_LOG("\nERROR --> DU_APP : Slice not available"); + } + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp)); + } + return ROK; +} + +/******************************************************************* + * + * @brief Fill the slice configration and rrm policy related + * information received form O1 + * + * @details + * + * Function : BuildAndSendSliceConfigReq + * + * Functionality: Fill the slice configration and rrm policy related + * + * @params[in] RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t + * totalSliceCnt + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendSliceConfigReq() +{ + Pst pst; + MacSliceCfgReq *sliceCfgReq; + + DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq)); + if(sliceCfgReq == NULLP) + { + DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq"); + return RFAILED; + } + else + { + memcpy(sliceCfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceCfgReq)); + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_CFG_REQ); + + DU_LOG("\nDEBUG --> DU_APP : Sending Slice Cfg Request to MAC "); + if((*packMacSliceCfgReqOpts[pst.selector])(&pst, sliceCfgReq) == RFAILED) + { + DU_LOG("\nERROR --> DU_APP : Failed to send Slice Cfg Req to MAC"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceCfgReq, sizeof(MacSliceCfgReq)); + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Fill the slice configration and rrm policy related + * information received form O1 + * + * @details + * + * Function : BuildAndSendSliceRecfgReq + * + * Functionality: Fill the slice configration and rrm policy related + * + * @params[in] RrmPolicy rrmPolicy[], uint8_t totalSliceCount + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendSliceRecfgReq() +{ + Pst pst; + MacSliceRecfgReq *sliceRecfgReq = NULLP; + + DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received"); + + DU_ALLOC_SHRABL_BUF(sliceRecfgReq, sizeof(MacSliceRecfgReq)); + if(sliceRecfgReq == NULLP) + { + DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceRecfgReq"); + return RFAILED; + } + else + { + memcpy(sliceRecfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceRecfgReq)); + + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ); + + DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC "); + if( (*packMacSliceRecfgReqOpts[pst.selector])(&pst, sliceRecfgReq) == RFAILED) + { + DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceRecfgReq, sizeof(MacSliceRecfgReq)); + } + } + return ROK; +} +/******************************************************************* + * + * @brief process the slice ReCfg rsp received from MAC + * + * @details + * + * Function : DuProcMacSliceRecfgRsp + * + * Functionality: process the slice ReCfg rsp received from MAC + * + * @params[in] Post structure, MacSliceRecfgRsp *ReCfgRsp + * + * @return ROK - success + * RFAILED - failure + * + **********************************************************************/ +uint8_t DuProcMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *recfgRsp) +{ + if(recfgRsp) + { + if(recfgRsp->rsp == MAC_DU_APP_RSP_OK) + { + duCb.sliceState = SLICE_RECONFIGURED; + DU_LOG("\nINFO --> DU_APP : Slice Reconfigured successfully "); + } + else + { + DU_LOG("\nERROR --> DU_APP : Slice not available"); + } + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, recfgRsp, sizeof(MacSliceCfgRsp)); + } + return ROK; +} + +/******************************************************************* +* +* @brief Handles received Slice Metrics from RLC and forward it to O1 +* +* @details +* +* Function : DuProcRlcSliceMetrics +* +* Functionality: +* Handles received Slice Metrics from RLC and forward it to O1 +* +* @params[in] Post structure pointer +* SlicePmList *sliceStats +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +uint8_t DuProcRlcSliceMetrics(Pst *pst, SlicePmList *sliceStats) +{ + uint8_t sliceRecord = 0; + + DU_LOG("\nDEBUG --> DU APP : Received Slice Metrics"); + if(sliceStats == NULLP) + { + DU_LOG("\nERROR --> DU APP : Empty Metrics"); + return RFAILED; + } + + for(sliceRecord = 0; sliceRecord < sliceStats->numSlice; sliceRecord++) + { + DU_LOG("\nINFO --> DU_APP: SliceId[SST-SD]:%d-%d, DlTput %.5lf, UlTput:%.5lf", sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sst,\ + sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sd,sliceStats->sliceRecord[sliceRecord].ThpDl,\ + sliceStats->sliceRecord[sliceRecord].ThpUl); + } +#ifdef O1_ENABLE + if(sliceStats) + { + sendSliceMetric((SliceMetricList*) sliceStats); + } +#endif + + DU_FREE_SHRABL_BUF(pst->region, pst->pool,sliceStats->sliceRecord, (sliceStats->numSlice) * (sizeof(SlicePm))); + DU_FREE_SHRABL_BUF(pst->region, pst->pool,sliceStats, sizeof(SlicePmList)); + + return ROK; +} + + +/******************************************************************* + * + * @brief Send Statistics request to MAC + * + * @details + * + * Function : BuildAndSendStatsReqToMac() + * + * Functionality: Send Statistics Request To Mac + * + * @params[in] + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendStatsReqToMac(MacStatsReq duMacStatsReq) +{ + Pst pst; + MacStatsReq *macStatsReq = NULLP; + + DU_LOG("\nINFO --> DU_APP : Builds Statistics Request to send to MAC"); + + DU_ALLOC_SHRABL_BUF(macStatsReq, sizeof(MacStatsReq)); + if(macStatsReq == NULLP) + { + DU_LOG("\nERROR --> DU_APP : Memory allocation failed for macStatsReq in BuildAndSendStatsReqToMac"); + return RFAILED; + } + else + { + memcpy(macStatsReq, &duMacStatsReq, sizeof(MacStatsReq)); + + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_STATISTICS_REQ); + + DU_LOG("\nDEBUG --> DU_APP: Sending Statistics Request to MAC "); + if( (*packMacStatsReqOpts[pst.selector])(&pst, macStatsReq) == RFAILED) + { + DU_LOG("\nERROR --> DU_APP: Failed to send Statistics Request to MAC"); + DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macStatsReq, sizeof(MacStatsReq)); + return RFAILED; + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Fetch statistics details from Action Definition Format 1 + * + * @details + * + * Function : FetchStatsFromActionDefFormat1() + * + * Functionality: Fetch statistics details from Action + * Definition Format 1 received in an E2 message from + * RIC. + * + * @params[in] ActionDefFormat1 + * + * @return Statistics + * + * ****************************************************************/ +Statistics FetchStatsFromActionDefFormat1(ActionDefFormat1 format1) +{ + Statistics stats; + + /* TODO : When E2AP subscription procedure is implemented: + * Measurement info list is traveresed + * Based on KPI type, stats.macStatsReq or stats.rlcstatsReq is filled */ + + /* Hardcoding values for now for testing purpose + * Will be removed in next gerrit */ + stats.macStatsReq.numStats = 2; + stats.macStatsReq.statsList[0].type = MAC_DL_TOTAL_PRB_USAGE; + stats.macStatsReq.statsList[0].periodicity = 100; + stats.macStatsReq.statsList[1].type = MAC_UL_TOTAL_PRB_USAGE; + stats.macStatsReq.statsList[1].periodicity = 100; + + return stats; +} + +/******************************************************************* + * + * @brief Send Statistics request to DU layers + * + * @details + * + * Function : BuildAndSendStatsReq() + * + * Functionality: Check if there is an update in statistics + * reporting configuration. If so, send the update to + * respective layer. + * + * @params[in] + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendStatsReq(ActionDefinition subscribedAction) +{ + Statistics stats; + + switch(subscribedAction.styleType) + { + case 1: + stats = FetchStatsFromActionDefFormat1(subscribedAction.choice.format1); + case 2: + case 3: + case 4: + case 5: + default: + break; + } + + if(BuildAndSendStatsReqToMac(stats.macStatsReq) != ROK) + { + DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToMac()"); + return RFAILED; + } + +/* TODO : When KPI collection from RLC will be supported, this function will be + * called to configure KPIs to be colled */ +#if 0 + if(BuildAndSendStatsReqToRlc(macStatsReq->rlcStatsReq) != ROK) + { + DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToRlc()"); + return RFAILED; + } +#endif + + /* TODO : In the caller of this function, change ActionDefinition->action + * from CONFIG_ADD to CONFIG_UNKNOWN once configuration is sent + * To be done in next gerrit*/ + + + return ROK; +} /********************************************************************** End of file