X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_msg_hdl.c;h=3887cc8a3b1e0becbb4a75c0e05943745bbb63d8;hb=refs%2Fchanges%2F91%2F5391%2F11;hp=21782c5f78540f061c2940813e5dc8f6aadeddbc;hpb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;p=o-du%2Fl2.git diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index 21782c5f7..3887cc8a3 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -38,6 +38,14 @@ #include "legtp.h" #include "lphy_stub.h" #include "du_utils.h" +#include "du_cell_mgr.h" + +#ifdef O1_ENABLE + +#include "GlobalDefs.h" +#include "AlarmInterface.h" + +#endif uint8_t rlcDlCfg = 0; uint8_t numRlcDlSaps = 0; @@ -46,15 +54,15 @@ uint8_t numRlcMacSaps = 0; uint8_t macCfg = 0; uint8_t macCfgInst = 0; -extern DuCfgParams duCfgParam; -extern uint8_t packRlcConfigReq(Pst *pst, KwMngmt *cfg); -extern uint8_t cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg); -extern uint8_t cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg); -extern uint8_t BuildAndSendE2SetupReq(); -extern uint8_t egtpHdlDatInd(EgtpMsg egtpMsg); -extern uint8_t BuildAndSendDUConfigUpdate(); -extern uint16_t getTransId(); -extern uint8_t cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg); +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); packMacCellCfgReq packMacCellCfgOpts[] = { @@ -63,18 +71,18 @@ packMacCellCfgReq packMacCellCfgOpts[] = packMacCellCfg, /* packing for light weight loosly coupled */ }; -DuMacCellStartReq packMacCellStartReqOpts[] = +DuMacCellStart packMacCellStartOpts[] = { - packMacCellStartReq, /* Loose coupling */ - MacProcCellStartReq, /* TIght coupling */ - packMacCellStartReq /* Light weight-loose coupling */ + packMacCellStart, /* Loose coupling */ + MacProcCellStart, /* TIght coupling */ + packMacCellStart /* Light weight-loose coupling */ }; -DuMacCellStopReq packMacCellStopReqOpts[] = +DuMacCellStop packMacCellStopOpts[] = { - packMacCellStopReq, /* Loose coupling */ - MacProcCellStopReq, /* TIght coupling */ - packMacCellStopReq /* Light weight-loose coupling */ + packMacCellStop, /* Loose coupling */ + MacProcCellStop, /* TIght coupling */ + packMacCellStop /* Light weight-loose coupling */ }; /************************************************************************** @@ -94,14 +102,14 @@ DuMacCellStopReq packMacCellStopReqOpts[] = ***************************************************************************/ uint8_t duBuildRlcCfg(Inst inst) { - KwMngmt kwMngmt; - KwGenCfg *genCfg = NULLP; + RlcMngmt rlcMngmt; + RlcGenCfg *genCfg = NULLP; Pst pst; - DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt)); + DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt)); DU_SET_ZERO(&pst, sizeof(Pst)); - genCfg = &(kwMngmt.t.cfg.s.gen); + genCfg = &(rlcMngmt.t.cfg.s.gen); /*----------- Fill General Configuration Parameters ---------*/ genCfg->maxUe = duCfgParam.maxUe; @@ -118,7 +126,7 @@ uint8_t duBuildRlcCfg(Inst inst) genCfg->lmPst.srcProcId = DU_PROC; genCfg->lmPst.dstEnt = ENTDUAPP; genCfg->lmPst.dstInst = DU_INST; - genCfg->lmPst.srcEnt = ENTKW; + genCfg->lmPst.srcEnt = ENTRLC; genCfg->lmPst.srcInst = inst; genCfg->lmPst.prior = PRIOR0; genCfg->lmPst.route = RTESPEC; @@ -128,34 +136,34 @@ uint8_t duBuildRlcCfg(Inst inst) genCfg->lmPst.selector = ODU_SELECTOR_LC; /* Fill Header */ - kwMngmt.hdr.msgType = TCFG; - kwMngmt.hdr.msgLen = 0; - kwMngmt.hdr.entId.ent = ENTKW; - kwMngmt.hdr.entId.inst = (Inst)0; - kwMngmt.hdr.elmId.elmnt = STGEN; - kwMngmt.hdr.seqNmb = 0; - kwMngmt.hdr.version = 0; - kwMngmt.hdr.transId = 0; - kwMngmt.hdr.response.prior = PRIOR0; - kwMngmt.hdr.response.route = RTESPEC; - kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? + rlcMngmt.hdr.msgType = TCFG; + rlcMngmt.hdr.msgLen = 0; + rlcMngmt.hdr.entId.ent = ENTRLC; + rlcMngmt.hdr.entId.inst = (Inst)0; + rlcMngmt.hdr.elmId.elmnt = STGEN; + rlcMngmt.hdr.seqNmb = 0; + rlcMngmt.hdr.version = 0; + rlcMngmt.hdr.transId = 0; + rlcMngmt.hdr.response.prior = PRIOR0; + rlcMngmt.hdr.response.route = RTESPEC; + rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; - kwMngmt.hdr.response.mem.pool = DU_POOL; - kwMngmt.hdr.response.selector = ODU_SELECTOR_LC; + rlcMngmt.hdr.response.mem.pool = DU_POOL; + rlcMngmt.hdr.response.selector = ODU_SELECTOR_LC; /* Fill Pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTKW; + pst.dstEnt = ENTRLC; pst.dstInst = inst; pst.dstProcId = DU_PROC; 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, &kwMngmt); + packRlcConfigReq(&pst, &rlcMngmt); return ROK; } @@ -178,30 +186,30 @@ uint8_t duBuildRlcCfg(Inst inst) uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst) { - KwMngmt kwMngmt; - KwSapCfg *lSap = NULLP; + RlcMngmt rlcMngmt; + RlcSapCfg *lSap = NULLP; Pst pst; - DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt)); + DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt)); DU_SET_ZERO(&pst, sizeof(Pst)); /* Fill Header */ - kwMngmt.hdr.msgType = TCFG; - kwMngmt.hdr.entId.ent = ENTKW; - kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? + rlcMngmt.hdr.msgType = TCFG; + rlcMngmt.hdr.entId.ent = ENTRLC; + rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; - kwMngmt.hdr.response.mem.pool = RLC_POOL; + rlcMngmt.hdr.response.mem.pool = RLC_POOL; /* Fill Pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTKW; + pst.dstEnt = ENTRLC; pst.dstProcId = DU_PROC; pst.dstInst = inst; pst.srcProcId = DU_PROC; pst.region = duCb.init.region; - lSap = &(kwMngmt.t.cfg.s.sap); + lSap = &(rlcMngmt.t.cfg.s.sap); lSap->mem.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; @@ -210,30 +218,30 @@ uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst) lSap->bndTmrIntvl = 10; lSap->priority = PRIOR0; lSap->route = RTESPEC; - if (ent == ENTRG) + if (ent == ENTMAC) { lSap->procId = DU_PROC; - lSap->ent = ENTRG; + lSap->ent = ENTMAC; lSap->inst = lsapInst; lSap->sapId = lsapInst; /* SapId will be stored as suId in MAC */ lSap->selector = (inst == RLC_UL_INST) ? ODU_SELECTOR_LWLC : ODU_SELECTOR_TC; - kwMngmt.hdr.elmId.elmnt = STRGUSAP; - DU_LOG("\nDU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst); + rlcMngmt.hdr.elmId.elmnt = STRGUSAP; + DU_LOG("\nDEBUG --> DU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst); } else { lSap->procId = DU_PROC; - lSap->ent = ENTKW; + lSap->ent = ENTRLC; lSap->inst = (inst == RLC_UL_INST) ? RLC_DL_INST : RLC_UL_INST; lSap->sapId = 0; lSap->selector = ODU_SELECTOR_LC; - kwMngmt.hdr.elmId.elmnt = STUDXSAP; - DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst); + rlcMngmt.hdr.elmId.elmnt = STUDXSAP; + DU_LOG("\nDEBUG --> DU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst); } - packRlcConfigReq(&pst, &kwMngmt); + packRlcConfigReq(&pst, &rlcMngmt); return ROK; } @@ -254,14 +262,14 @@ uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst) ***************************************************************************/ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) { - KwMngmt kwMngmt; - KwSapCfg *uSap = NULLP; + RlcMngmt rlcMngmt; + RlcSapCfg *uSap = NULLP; Pst pst; - DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt)); + DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt)); DU_SET_ZERO(&pst, sizeof(Pst)); - uSap = &(kwMngmt.t.cfg.s.sap); + uSap = &(rlcMngmt.t.cfg.s.sap); uSap->selector = ODU_SELECTOR_LC; uSap->mem.region = (inst == RLC_UL_INST) ? @@ -270,7 +278,7 @@ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) uSap->mem.spare = 0; uSap->procId = DU_PROC; - uSap->ent = ENTKW; + uSap->ent = ENTRLC; uSap->sapId = 0; uSap->inst = (inst == RLC_UL_INST) ? @@ -280,25 +288,25 @@ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) uSap->route = RTESPEC; /* Fill Header */ - kwMngmt.hdr.msgType = TCFG; - kwMngmt.hdr.entId.ent = ENTKW; - kwMngmt.hdr.elmId.elmnt = STUDXSAP; - kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? + rlcMngmt.hdr.msgType = TCFG; + rlcMngmt.hdr.entId.ent = ENTRLC; + rlcMngmt.hdr.elmId.elmnt = STUDXSAP; + rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; - kwMngmt.hdr.response.mem.pool = RLC_POOL; + rlcMngmt.hdr.response.mem.pool = RLC_POOL; /* Fill Pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTKW; + pst.dstEnt = ENTRLC; pst.dstProcId = DU_PROC; pst.dstInst = 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); - packRlcConfigReq(&pst, &kwMngmt); + DU_LOG("\nDEBUG --> DU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst); + packRlcConfigReq(&pst, &rlcMngmt); return ROK; } @@ -321,50 +329,48 @@ uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst) ***************************************************************************/ uint8_t duProcCfgComplete() { - uint8_t ret = ROK; + uint8_t ret = ROK; static uint16_t cellId = 0; - uint16_t idx; + uint16_t idx; for(idx=0; idx< DEFAULT_CELLS; idx++) { DuCellCb *cell = NULLP; DU_ALLOC(cell, sizeof(DuCellCb)) - if(cell == NULLP) + 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 = ++cellId; + memset(&cell->cellInfo.nrEcgi.plmn, 0, sizeof(Plmn)); + 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.cellId = NR_CELL_ID; + cell->cellInfo.nrPci = NR_PCI; + cell->cellInfo.fiveGsTac = DU_TAC; + memset(&cell->cellInfo.plmn[idx1], 0, sizeof(Plmn)); + 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; } - 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; + cell->cellInfo.maxUe = duCfgParam.maxUe; + cell->cellStatus = CELL_OUT_OF_SERVICE; - duCb.cfgCellLst[nci-1] = cell; - duCb.numCfgCells++; - } + duCb.cfgCellLst[duCb.numCfgCells] = cell; + duCb.numCfgCells++; } + } if(ret != RFAILED) { //Start layer configs @@ -394,9 +400,9 @@ uint8_t duSendRlcUlCfg() duBuildRlcCfg((Inst)RLC_UL_INST); for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++) { - duBuildRlcLsapCfg(ENTRG, (Inst)RLC_UL_INST, cellIdx); + duBuildRlcLsapCfg(ENTMAC, (Inst)RLC_UL_INST, cellIdx); } - duBuildRlcLsapCfg(ENTKW, (Inst)RLC_UL_INST, 0); + duBuildRlcLsapCfg(ENTRLC, (Inst)RLC_UL_INST, 0); return ROK; } @@ -421,10 +427,10 @@ uint8_t duSendRlcDlCfg() uint8_t cellIdx; duBuildRlcCfg((Inst)RLC_DL_INST); - duBuildRlcUsapCfg(STUDXSAP, ENTKW, (Inst)RLC_DL_INST); + duBuildRlcUsapCfg(STUDXSAP, ENTRLC, (Inst)RLC_DL_INST); for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++) { - duBuildRlcLsapCfg(ENTRG, (Inst)RLC_DL_INST, cellIdx); + duBuildRlcLsapCfg(ENTMAC, (Inst)RLC_DL_INST, cellIdx); } return ROK; @@ -440,12 +446,12 @@ uint8_t duSendRlcDlCfg() * Handles Gen Config Confirm from RLC * * @param[in] Pst *pst, Post structure of the primitive. - * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC + * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC * @return ROK - success * RFAILED - failure * ***************************************************************************/ -uint8_t DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm) +uint8_t DuHdlRlcCfgComplete(Pst *pst, RlcMngmt *cfm) { uint8_t ret = ROK; if (pst->srcInst == RLC_UL_INST) @@ -470,12 +476,12 @@ uint8_t DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm) * Handles Control Config Confirm from RLC * * @param[in] Pst *pst, Post structure of the primitive. - * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC + * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC * @return ROK - success * RFAILED - failure * ***************************************************************************/ -uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl) +uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cntrl) { uint8_t ret = ROK; @@ -487,7 +493,7 @@ uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *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 +507,7 @@ uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *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) { @@ -530,16 +536,16 @@ uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl) * Handles Config Confirm from RLC UL * * @param[in] Pst *pst, Post structure of the primitive. - * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC UL + * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC UL * @return ROK - success * RFAILED - failure * ***************************************************************************/ -uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm) +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 +574,7 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *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 +586,7 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *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; @@ -597,14 +603,14 @@ uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm) * Handles Config Confirm from RLC DL * * @param[in] Pst *pst, Post structure of the primitive. - * @param[in] KwMngmt *cfm, Unpacked primitive info received from RLC DL + * @param[in] RlcMngmt *cfm, Unpacked primitive info received from RLC DL * @return ROK - success * RFAILED - failure * ***************************************************************************/ -uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *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 +640,7 @@ uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *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 +651,7 @@ uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *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; } @@ -710,7 +716,7 @@ uint8_t duBuildMacGenCfg() genCfg->lmPst.srcProcId = DU_PROC; genCfg->lmPst.dstEnt = ENTDUAPP; genCfg->lmPst.dstInst = 0; - genCfg->lmPst.srcEnt = ENTRG; + genCfg->lmPst.srcEnt = ENTMAC; genCfg->lmPst.srcInst = macCfgInst; genCfg->lmPst.prior = PRIOR0; genCfg->lmPst.route = RTESPEC; @@ -721,7 +727,7 @@ uint8_t duBuildMacGenCfg() /* Fill Header */ rgMngmt.hdr.msgType = TCFG; rgMngmt.hdr.msgLen = 0; - rgMngmt.hdr.entId.ent = ENTRG; + rgMngmt.hdr.entId.ent = ENTMAC; rgMngmt.hdr.entId.inst = (Inst)0; rgMngmt.hdr.elmId.elmnt = STGEN; rgMngmt.hdr.seqNmb = 0; @@ -737,13 +743,13 @@ uint8_t duBuildMacGenCfg() /* Fill Pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTRG; + pst.dstEnt = ENTMAC; pst.dstInst = macCfgInst; pst.dstProcId = DU_PROC; 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); @@ -782,7 +788,7 @@ uint8_t duBuildMacUsapCfg(SpId sapId) uSap->suId = 0; uSap->spId = sapId; uSap->procId = DU_PROC; - uSap->ent = ENTKW; + uSap->ent = ENTRLC; uSap->inst = sapId; uSap->prior = PRIOR0; uSap->route = RTESPEC; @@ -790,7 +796,7 @@ uint8_t duBuildMacUsapCfg(SpId sapId) /* fill header */ rgMngmt.hdr.msgType = TCFG; - rgMngmt.hdr.entId.ent = ENTRG; + rgMngmt.hdr.entId.ent = ENTMAC; rgMngmt.hdr.entId.inst = (Inst)0; rgMngmt.hdr.elmId.elmnt = STRGUSAP; rgMngmt.hdr.response.mem.region = MAC_MEM_REGION; @@ -799,13 +805,13 @@ uint8_t duBuildMacUsapCfg(SpId sapId) /* fill pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTRG; + pst.dstEnt = ENTMAC; pst.dstInst = macCfgInst; pst.dstProcId = DU_PROC; 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 +857,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 +869,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; @@ -887,24 +893,23 @@ uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) ***************************************************************************/ uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action) { - KwCntrl *cntrl = NULLP; - KwMngmt kwMngmt; + RlcCntrl *cntrl = NULLP; + RlcMngmt rlcMngmt; Pst pst; - TRC2(smBindKwToRguSap) - DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt)); + DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt)); DU_SET_ZERO(&pst, sizeof(Pst)); 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 = &(kwMngmt.t.cntrl); + cntrl = &(rlcMngmt.t.cntrl); cntrl->action = action; cntrl->subAction = DU_ZERO_VAL; @@ -912,24 +917,24 @@ uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action) cntrl->s.sapCntrl.spId = inst; /* Fill header */ - kwMngmt.hdr.msgType = TCNTRL; - kwMngmt.hdr.entId.ent = ENTKW; - kwMngmt.hdr.entId.inst = inst; - kwMngmt.hdr.elmId.elmnt = 186; /* ambiguous defines in lkw.h and lrg.h so direct hardcoded*/ - kwMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? + rlcMngmt.hdr.msgType = TCNTRL; + rlcMngmt.hdr.entId.ent = ENTRLC; + rlcMngmt.hdr.entId.inst = inst; + rlcMngmt.hdr.elmId.elmnt = 186; /* ambiguous defines in lkw.h and lrg.h so direct hardcoded*/ + rlcMngmt.hdr.response.mem.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; - kwMngmt.hdr.response.mem.pool = RLC_POOL; + rlcMngmt.hdr.response.mem.pool = RLC_POOL; /* Fill pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTKW; + pst.dstEnt = ENTRLC; pst.dstProcId = DU_PROC; pst.dstInst = inst; pst.srcProcId = DU_PROC; pst.region = duCb.init.region; - cmPkLkwCntrlReq(&pst, &kwMngmt); + cmPkLkwCntrlReq(&pst, &rlcMngmt); return ROK; } @@ -970,7 +975,7 @@ uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) } 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; @@ -994,7 +999,7 @@ uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) * ****************************************************************/ uint8_t duFillEgtpPst(Pst *pst, Event event) { - memset((uint8_t *)pst, 0, sizeof(Pst)); + memset(pst, 0, sizeof(Pst)); pst->srcEnt = (Ent)ENTDUAPP; pst->srcInst = (Inst)DU_INST; pst->srcProcId = DU_PROC; @@ -1031,10 +1036,10 @@ 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((uint8_t *)&egtpCfg, 0, sizeof(EgtpConfig)); - memcpy((uint8_t *)&egtpCfg, (uint8_t *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig)); + memset(&egtpCfg, 0, sizeof(EgtpConfig)); + memcpy(&egtpCfg, &duCfgParam.egtpParams, sizeof(EgtpConfig)); duFillEgtpPst(&pst, EVTCFGREQ); packEgtpCfgReq(&pst, egtpCfg); @@ -1064,14 +1069,14 @@ uint8_t duHdlEgtpCfgComplete(CmStatus cfm) if(cfm.status == LCM_PRIM_OK) { - DU_LOG("\nDU_APP : EGTP configuraton complete"); + DU_LOG("\nDEBUG --> DU_APP : EGTP configuraton complete"); #ifdef EGTP_TEST duSendEgtpSrvOpenReq(); #endif } else { - DU_LOG("\nDU_APP : EGTP configuraton failed"); + DU_LOG("\nERROR --> DU_APP : EGTP configuraton failed"); ret = RFAILED; } @@ -1099,7 +1104,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); @@ -1130,14 +1135,14 @@ uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm) if(cfm.status == LCM_PRIM_OK) { - DU_LOG("\nDU_APP : EGTP server opened successfully"); + DU_LOG("\nDEBUG --> DU_APP : EGTP server opened successfully"); #ifdef EGTP_TEST duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, EGTP_LCL_TEID, EGTP_REM_TEID); #endif } else { - DU_LOG("\nDU_APP : EGTP server opening failed"); + DU_LOG("\nERROR --> DU_APP : EGTP server opening failed"); ret = RFAILED; } @@ -1172,11 +1177,9 @@ uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid) 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"); duFillEgtpPst(&pst, EVTTNLMGMTREQ); - packEgtpTnlMgmtReq(&pst, tnlEvt); - + egtpTnlMgmtReq(&pst, tnlEvt); return ROK; } @@ -1202,23 +1205,32 @@ uint8_t duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK) { - DU_LOG("\nDU_APP : Tunnel management confirm OK"); - -#ifdef EGTP_TEST - duSendUeCreateReqToRlc(); - - duSendEgtpTestData(); -#endif + 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; @@ -1238,121 +1250,6 @@ uint8_t duSendEgtpDatInd(Buffer *mBuf) } -#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(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(mBuf); - return RFAILED; - } - } - else - { - DU_LOG("\nDU_APP : Failed to allocate memory"); - return RFAILED; - } - - /* filling IPv4 header */ - CmIpv4Hdr ipv4Hdr; - MsgLen mLen; - - mLen = 0; - ODU_FIND_MSG_LEN(mBuf, &mLen); - - memset((uint8_t *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr)); - ipv4Hdr.length = CM_IPV4_HDRLEN + mLen; - ipv4Hdr.hdrVer = 0x45; - ipv4Hdr.proto = 1; - ipv4Hdr.srcAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.localIp.ipV4Addr); - ipv4Hdr.destAddr = CM_INET_NTOH_U32(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 * @@ -1395,7 +1292,7 @@ uint8_t duSendSchCfg() cfg->genCfg.lmPst.srcProcId = DU_PROC; cfg->genCfg.lmPst.dstEnt = ENTDUAPP; cfg->genCfg.lmPst.dstInst = DU_INST; - cfg->genCfg.lmPst.srcEnt = ENTRG; + cfg->genCfg.lmPst.srcEnt = ENTMAC; cfg->genCfg.lmPst.srcInst = DEFAULT_CELLS + 1; cfg->genCfg.lmPst.prior = PRIOR0; cfg->genCfg.lmPst.route = RTESPEC; @@ -1405,7 +1302,7 @@ uint8_t duSendSchCfg() /* Fill Header */ rgMngmt.hdr.msgType = TCFG; - rgMngmt.hdr.entId.ent = ENTRG; + rgMngmt.hdr.entId.ent = ENTMAC; rgMngmt.hdr.entId.inst = DU_INST; rgMngmt.hdr.elmId.elmnt = STSCHINST; rgMngmt.hdr.response.mem.region = MAC_MEM_REGION; @@ -1414,7 +1311,7 @@ uint8_t duSendSchCfg() /* Fill Pst */ pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTRG; + pst.dstEnt = ENTMAC; pst.dstProcId = DU_PROC; pst.srcProcId = DU_PROC; pst.srcInst = DU_INST; @@ -1422,7 +1319,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); @@ -1452,21 +1349,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; } @@ -1497,7 +1394,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: @@ -1509,33 +1406,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 * @@ -1546,15 +1416,14 @@ uint8_t duSendEgtpSlotInd() * Functionality: * Initiates MAC Configs towards MAC * - * @param[in] void + * @param[in]cell id * @return ROK - success * RFAILED - failure * ***************************************************************************/ -uint8_t duBuildAndSendMacCellCfg() +uint8_t duBuildAndSendMacCellCfg(uint16_t cellId) { Pst pst; - DU_SET_ZERO(&pst, sizeof(Pst)); MacCellCfg *duMacCellCfg = NULLP; DU_ALLOC_SHRABL_BUF(duMacCellCfg, sizeof(MacCellCfg)); @@ -1563,8 +1432,8 @@ uint8_t duBuildAndSendMacCellCfg() return RFAILED; } - /* store the address in the duCb so that we can free on confirm msg */ - duCb.duMacCellCfg = duMacCellCfg; + /* store the address in the duCellCb so that we can free on confirm msg */ + duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg; /* copy the mac config structure from duCfgParams */ memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg)); @@ -1593,83 +1462,33 @@ uint8_t duBuildAndSendMacCellCfg() ***************************************************************************/ uint8_t duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm) { - uint8_t actvCellIdx = 0; - uint8_t ret = ROK; + uint8_t actvCellIdx = 0; + uint8_t ret = ROK; - if(macCellCfgCfm->rsp == ROK) + for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++) { - for(actvCellIdx = 0 ; actvCellIdx cellId == duCb.actvCellLst[actvCellIdx]->cellId) - { - duCb.duMacCellCfg = NULLP; - /* Build and send GNB-DU config update */ - ret = BuildAndSendDUConfigUpdate(); - - /* TODO: Trigger cell start req once cell up slot ind is received*/ - /* Build and Send Cell Start Req to MAC */ - ret = duBuildAndSendMacCellStartReq(); - - } - } - } - else - { - DU_LOG("\nMac 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) -{ - - DU_LOG("\nDU APP : Slot Indication received"); - - 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) - { - duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd = true; - if((duCb.actvCellLst[slotInfo->cellId-1] != NULL) && \ - (duCb.actvCellLst[slotInfo->cellId-1]->cellStatus == \ - ACTIVATION_IN_PROGRESS)) + if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId) { - DU_LOG("\nDU APP : 5G-NR Cell %d is UP", slotInfo->cellId); - duCb.actvCellLst[slotInfo->cellId-1]->cellStatus = ACTIVATED; + duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP; } - } + if(macCellCfgCfm->rsp == ROK) + { + /* Build and send GNB-DU config update */ + ret = BuildAndSendDUConfigUpdate(); - /* 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)); + /* Build and Send Cell Start Req to MAC */ + ret = duBuildAndSendMacCellStart(); + } + else + { + /* TODO : Action to be taken if cell configuration fails. + * Should CU be informed? */ - return ROK; + DU_LOG("\nERROR --> DU_APP : Mac cell cfg failed"); + ret = RFAILED; + } + return ret; } /******************************************************************* @@ -1678,7 +1497,7 @@ uint8_t duHandleSlotInd(Pst *pst, SlotIndInfo *slotInfo) * * @details * - * Function : duBuildAndSendMacCellStartReq + * Function : duBuildAndSendMacCellStart * * Functionality: * Builds and sends cell start request to MAC @@ -1688,32 +1507,31 @@ uint8_t duHandleSlotInd(Pst *pst, SlotIndInfo *slotInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t duBuildAndSendMacCellStartReq() +uint8_t duBuildAndSendMacCellStart() { Pst pst; - MacCellStartInfo *cellStartInfo = NULL; + OduCellId *cellId = 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(cellId, sizeof(OduCellId)); + if(!cellId) { - 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; } - for(uint8_t id = 0; id < MAX_NUM_CELL; id++) + for(uint8_t id = 0; id < duCb.numActvCells; id++) { if(duCb.actvCellLst[id]) { - duCb.actvCellLst[id]->firstSlotIndRcvd = FALSE; - cellStartInfo->cellId = duCb.actvCellLst[id]->cellInfo.nrEcgi.cellId; + cellId->cellId = duCb.actvCellLst[id]->cellId; /* Fill Pst */ - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START_REQ); + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START); - return (*packMacCellStartReqOpts[pst.selector])(&pst, cellStartInfo); + return (*packMacCellStartOpts[pst.selector])(&pst, cellId); } } return ROK; @@ -1725,7 +1543,7 @@ uint8_t duBuildAndSendMacCellStartReq() * * @details * - * Function : duBuildAndSendMacCellStopReq + * Function : duBuildAndSendMacCellStop * * Functionality: * Builds and sends cell stop request to MAC @@ -1735,26 +1553,26 @@ uint8_t duBuildAndSendMacCellStartReq() * RFAILED - failure * * ****************************************************************/ -uint8_t duBuildAndSendMacCellStopReq() +uint8_t duBuildAndSendMacCellStop() { Pst pst; - MacCellStopInfo *cellStopInfo = NULL; + OduCellId *cellId = 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) + DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId)); + if(!cellId) { - DU_LOG("\nDU APP : Memory alloc failed while building cell stop request"); + DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell stop request"); return RFAILED; } - cellStopInfo->cellId = duCb.actvCellLst[0]->cellId; + cellId->cellId = duCb.actvCellLst[0]->cellId; /* Fill Pst */ - FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP_REQ); + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP); - return (*packMacCellStopReqOpts[pst.selector])(&pst, cellStopInfo); + return (*packMacCellStopOpts[pst.selector])(&pst, cellId); } /******************************************************************* @@ -1773,27 +1591,34 @@ 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)) { - if(duCb.actvCellLst[cellStopId->cellId-1]->firstSlotIndRcvd) - { - 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("\nINFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId); + cellCb->cellStatus = DELETION_IN_PROGRESS; + +#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); +#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; } @@ -1818,7 +1643,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)); } @@ -1841,14 +1666,123 @@ 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]; + DuCellCb *cellCb = NULLP; + DuUeCb ueCb ={0}; + + if(duGetCellCb(ulRrcMsgInfo->cellId, &cellCb) != ROK) + return RFAILED; + if(ulRrcMsgInfo->ueIdx > 0) + { + ueCb = cellCb->ueCb[ulRrcMsgInfo->ueIdx -1]; + + BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \ ulRrcMsgInfo->rrcMsg); 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; +} + +/******************************************************************* +* +* @brief Process RRC delivery report from RLC +* +* @details +* +* Function : DuProcRlcRrcDeliveryReport +* +* Functionality: Process RRC delivery Message from RLC +* +* @params[in] Post structure +* UL RRC Message Info +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryReport) +{ + DuCellCb *cellCb = NULLP; + DuUeCb ueCb; + uint8_t ret = RFAILED; + + if(duGetCellCb(rrcDeliveryReport->cellId, &cellCb) != ROK) + return RFAILED; + + ueCb = cellCb->ueCb[rrcDeliveryReport->ueIdx -1]; + ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport); + + 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 rbIdx; + DuCellCb *cellCb; + DuUeCb ueCb; + EgtpMsg egtpMsg; + Buffer *mBuf; + + if(duGetCellCb(ulUserData->cellId, &cellCb) != ROK) + return RFAILED; + + ueCb = cellCb->ueCb[ulUserData->ueIdx -1]; + + 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 */ + /* TODO : keep the "#if 0" code block and test once DL User data changes are submitted */ +#if 0 + for(rbIdx = 0; rbIdx < MAX_NUM_DRB; rbIdx++) + { + if(ueCb.ulTnlCfg[rbIx]->drbId == ulUserData->rbId) + { + egtpMsg.msgHdr.teId = ueCb.ulTnlCfg[rbIx]->tnlCfg.teId; + } + } +#else + egtpMsg.msgHdr.teId = 1; +#endif + + 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; }