X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_msg_hdl.c;h=6dcb15a12c0bbd13cc28a45ca394da19b707167e;hb=45d134510deb6902b870b4a0fb574b6075fba601;hp=2fae37af2381d7d9644f460bfce78b58d2bb6d0e;hpb=18fbca81feebe0cf45f205c1c580c574741292b0;p=o-du%2Fl2.git diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index 2fae37af2..6dcb15a12 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -16,13 +16,23 @@ ################################################################################ *******************************************************************************/ -/* This file contains message handling functionality for DU cell management */ - +/* This file contains message handling functionality for DU APP */ +#include "common_def.h" +#include "lrg.h" +#include "legtp.h" +#include "lkw.h" +#include "lrg.x" +#include "lkw.x" +#include "du_app_mac_inf.h" +#include "du_cfg.h" +#include "du_mgr.h" #include "du_sctp.h" #include "du_f1ap_msg_hdl.h" +#include "du_ue_mgr.h" #include "lsctp.h" #include "legtp.h" #include "lphy_stub.h" +#include "du_utils.h" U8 rlcDlCfg = 0; U8 numRlcDlSaps = 0; @@ -31,19 +41,37 @@ U8 numRlcMacSaps = 0; U8 macCfg = 0; U8 macCfgInst = 0; -extern DuCfgParams duCfgParam;; - +extern DuCfgParams duCfgParam; extern S16 cmPkLkwCfgReq(Pst *pst, KwMngmt *cfg); extern S16 cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg); extern S16 cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg); +extern S16 BuildAndSendE2SetupReq(); +extern S16 egtpHdlDatInd(EgtpMsg egtpMsg); +extern uint8_t BuildAndSendDUConfigUpdate(); +extern U16 getTransId(); +extern S16 cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg); packMacCellCfgReq packMacCellCfgOpts[] = { packMacCellCfg, /* packing for loosely coupled */ - MacHdlCellCfgReq, /* packing for tightly coupled */ + MacProcCellCfgReq, /* packing for tightly coupled */ packMacCellCfg, /* packing for light weight loosly coupled */ }; +DuMacCellStartReq packMacCellStartReqOpts[] = +{ + packMacCellStartReq, /* Loose coupling */ + MacProcCellStartReq, /* TIght coupling */ + packMacCellStartReq /* Light weight-loose coupling */ +}; + +DuMacCellStopReq packMacCellStopReqOpts[] = +{ + packMacCellStopReq, /* Loose coupling */ + MacProcCellStopReq, /* TIght coupling */ + packMacCellStopReq /* Light weight-loose coupling */ +}; + /************************************************************************** * @brief Function to fill configs required by RLC * @@ -92,9 +120,9 @@ S16 duBuildRlcCfg(Inst inst) genCfg->lmPst.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; genCfg->lmPst.pool = RLC_POOL; - genCfg->lmPst.selector = DU_SELECTOR_LC; + genCfg->lmPst.selector = ODU_SELECTOR_LC; - /* Fill Header */ + /* Fill Header */ kwMngmt.hdr.msgType = TCFG; kwMngmt.hdr.msgLen = 0; kwMngmt.hdr.entId.ent = ENTKW; @@ -108,10 +136,10 @@ S16 duBuildRlcCfg(Inst inst) kwMngmt.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 = DU_SELECTOR_LC; + kwMngmt.hdr.response.selector = ODU_SELECTOR_LC; /* Fill Pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTKW; pst.dstInst = inst; @@ -161,7 +189,7 @@ S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst) kwMngmt.hdr.response.mem.pool = RLC_POOL; /* Fill Pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTKW; pst.dstProcId = DU_PROC; @@ -183,7 +211,7 @@ S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst) lSap->ent = ENTRG; lSap->inst = lsapInst; lSap->sapId = lsapInst; /* SapId will be stored as suId in MAC */ - lSap->selector = (inst == RLC_UL_INST) ? DU_SELECTOR_LWLC : DU_SELECTOR_TC; + 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); @@ -193,9 +221,9 @@ S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst) lSap->procId = DU_PROC; lSap->ent = ENTKW; lSap->inst = (inst == RLC_UL_INST) ? - RLC_DL_INST : RLC_UL_INST; + RLC_DL_INST : RLC_UL_INST; lSap->sapId = 0; - lSap->selector = DU_SELECTOR_LC; + 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); } @@ -230,7 +258,7 @@ S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst) uSap = &(kwMngmt.t.cfg.s.sap); - uSap->selector = DU_SELECTOR_LC; + uSap->selector = ODU_SELECTOR_LC; uSap->mem.region = (inst == RLC_UL_INST) ? RLC_UL_MEM_REGION:RLC_DL_MEM_REGION; uSap->mem.pool = RLC_POOL; @@ -256,7 +284,7 @@ S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst) kwMngmt.hdr.response.mem.pool = RLC_POOL; /* Fill Pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTKW; pst.dstProcId = DU_PROC; @@ -291,38 +319,47 @@ S16 duProcCfgComplete() S16 ret = ROK; static U16 cellId = 0; U16 idx; - for(idx=0; idx< DEFAULT_CELLS; idx++) //TODO: the length of this loop must be determined + for(idx=0; idx< DEFAULT_CELLS; idx++) { - DuCellCb *cell; + DuCellCb *cell = NULLP; DU_ALLOC(cell, sizeof(DuCellCb)) - if(cell == NULLP) - { - DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete"); - ret = RFAILED; + if(cell == NULLP) + { + DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete"); + ret = RFAILED; + } + else + { + U32 nci; + U8 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 = (U16)cell->cellInfo.nrEcgi.cellId; + + duCb.cfgCellLst[nci-1] = cell; + duCb.numCfgCells++; + } } - else - { - U16 nci; - - cell->cellId = cellId++; - memcpy((void*)&cell->cellInfo, (void*)&duCfgParam.cellCfg[idx],\ - sizeof(CellCfgParams)); - cell->cellStatus = OOS; - nci = cell->cellInfo.nrEcgi.cellId; - ret = cmHashListInsert(&(duCb.cellLst), (PTR)(cell), - (U8 *)&(nci), (U16) sizeof(nci)); - - if(ret != ROK) - { - DU_LOG("\nDU_APP : HashListInsert into cellLst failed for [%d]", nci); - break; - } - else - { - DU_LOG("\nDU_APP : HashListInsert into cellLst successful for [%d]", nci); - } - } - } if(ret != RFAILED) { //Start layer configs @@ -355,7 +392,7 @@ S16 duSendRlcUlCfg() duBuildRlcLsapCfg(ENTRG, (Inst)RLC_UL_INST, cellIdx); } duBuildRlcLsapCfg(ENTKW, (Inst)RLC_UL_INST, 0); - + return ROK; } @@ -384,7 +421,7 @@ S16 duSendRlcDlCfg() { duBuildRlcLsapCfg(ENTRG, (Inst)RLC_DL_INST, cellIdx); } - + return ROK; } /************************************************************************** @@ -441,37 +478,37 @@ S16 duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl) { switch (cntrl->hdr.elmId.elmnt) { - case STRGUSAP: - { - if (pst->srcInst == RLC_DL_INST) - { - DU_LOG("\nDU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL"); - macCfgInst++; - if(macCfgInst < DEFAULT_CELLS) - { - macCfgInst = 0; - duBindUnbindRlcToMacSap((Inst) RLC_DL_INST, ABND); - } - else - { - duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND); - } - } - else - { - DU_LOG("\nDU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL"); - macCfgInst++; - if(macCfgInst < DEFAULT_CELLS) - { - duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND); - } - else - { - duSendSchCfg(); - } - break; - } - } + case STRGUSAP: + { + if (pst->srcInst == RLC_DL_INST) + { + DU_LOG("\nDU_APP : BIND OF RLC DL TO MAC (RGU) SAP SUCCESSFUL"); + macCfgInst++; + if(macCfgInst < DEFAULT_CELLS) + { + macCfgInst = 0; + duBindUnbindRlcToMacSap((Inst) RLC_DL_INST, ABND); + } + else + { + duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND); + } + } + else + { + DU_LOG("\nDU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL"); + macCfgInst++; + if(macCfgInst < DEFAULT_CELLS) + { + duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND); + } + else + { + duSendSchCfg(); + } + break; + } + } } } @@ -502,37 +539,37 @@ S16 duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm) { switch(cfm->hdr.elmId.elmnt) { - case STGEN: - { - rlcUlCfg |= RLC_GEN_CFG; - break; - } - case STRGUSAP: - { - numRlcMacSaps++; - if(numRlcMacSaps == DEFAULT_CELLS) - { - rlcUlCfg |= RLC_MAC_SAP_CFG; - numRlcMacSaps = 0; - } - break; - } - case STUDXSAP: - { - rlcUlCfg |= RLC_UDX_SAP_CFG; - break; - - } - default: - break; + case STGEN: + { + rlcUlCfg |= RLC_GEN_CFG; + break; + } + case STRGUSAP: + { + numRlcMacSaps++; + if(numRlcMacSaps == DEFAULT_CELLS) + { + rlcUlCfg |= RLC_MAC_SAP_CFG; + numRlcMacSaps = 0; + } + break; + } + case STUDXSAP: + { + rlcUlCfg |= RLC_UDX_SAP_CFG; + break; + + } + default: + break; } DU_LOG("\nDU_APP : RLC UL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); if(rlcUlCfg == DU_RLC_UL_CONFIGURED) { - rlcUlCfg = 0; - numRlcMacSaps = 0; - //Start configuration of RLC DL - duSendRlcDlCfg(); + rlcUlCfg = 0; + numRlcMacSaps = 0; + //Start configuration of RLC DL + duSendRlcDlCfg(); } } @@ -567,37 +604,37 @@ S16 duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm) { switch(cfm->hdr.elmId.elmnt) { - case STGEN: - { - rlcDlCfg |= RLC_GEN_CFG; - break; - } - case STRGUSAP: - { - numRlcMacSaps++; - if(numRlcMacSaps == DEFAULT_CELLS) - { - rlcDlCfg |= RLC_MAC_SAP_CFG; - numRlcMacSaps = 0; - } - break; - } - case STUDXSAP: - { - rlcDlCfg |= RLC_UDX_SAP_CFG; - break; - - } - default: - break; + case STGEN: + { + rlcDlCfg |= RLC_GEN_CFG; + break; + } + case STRGUSAP: + { + numRlcMacSaps++; + if(numRlcMacSaps == DEFAULT_CELLS) + { + rlcDlCfg |= RLC_MAC_SAP_CFG; + numRlcMacSaps = 0; + } + break; + } + case STUDXSAP: + { + rlcDlCfg |= RLC_UDX_SAP_CFG; + break; + + } + default: + break; } DU_LOG("\nDU_APP : RLC DL Cfg Cfm received for the element %d ",cfm->hdr.elmId.elmnt); if(rlcDlCfg == DU_RLC_DL_CONFIGURED) { - rlcDlCfg = 0; - //Start configuration of MAC - duSendMacCfg(); + rlcDlCfg = 0; + //Start configuration of MAC + duSendMacCfg(); } } @@ -657,10 +694,10 @@ S16 duBuildMacGenCfg() DU_SET_ZERO(&rgMngmt, sizeof(RgMngmt)); genCfg = &(rgMngmt.t.cfg.s.genCfg); - + /*----------- Fill General Configuration Parameters ---------*/ - genCfg->mem.region = RG_MEM_REGION; - genCfg->mem.pool = RG_POOL; + genCfg->mem.region = MAC_MEM_REGION; + genCfg->mem.pool = MAC_POOL; genCfg->tmrRes = 10; genCfg->numRguSaps = 2; @@ -672,11 +709,11 @@ S16 duBuildMacGenCfg() genCfg->lmPst.srcInst = macCfgInst; genCfg->lmPst.prior = PRIOR0; genCfg->lmPst.route = RTESPEC; - genCfg->lmPst.region = RG_MEM_REGION; - genCfg->lmPst.pool = RG_POOL; - genCfg->lmPst.selector = DU_SELECTOR_LC; + genCfg->lmPst.region = MAC_MEM_REGION; + genCfg->lmPst.pool = MAC_POOL; + genCfg->lmPst.selector = ODU_SELECTOR_LC; - /* Fill Header */ + /* Fill Header */ rgMngmt.hdr.msgType = TCFG; rgMngmt.hdr.msgLen = 0; rgMngmt.hdr.entId.ent = ENTRG; @@ -688,12 +725,12 @@ S16 duBuildMacGenCfg() rgMngmt.hdr.response.prior = PRIOR0; rgMngmt.hdr.response.route = RTESPEC; - rgMngmt.hdr.response.mem.region = RG_MEM_REGION; - rgMngmt.hdr.response.mem.pool = RG_POOL; - rgMngmt.hdr.response.selector = DU_SELECTOR_LC; + rgMngmt.hdr.response.mem.region = MAC_MEM_REGION; + rgMngmt.hdr.response.mem.pool = MAC_POOL; + rgMngmt.hdr.response.selector = ODU_SELECTOR_LC; /* Fill Pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTRG; pst.dstInst = macCfgInst; @@ -735,8 +772,8 @@ S16 duBuildMacUsapCfg(SpId sapId) uSap = &(rgMngmt.t.cfg.s.rguSap); - uSap->mem.region = RG_MEM_REGION; - uSap->mem.pool = RG_POOL; + uSap->mem.region = MAC_MEM_REGION; + uSap->mem.pool = MAC_POOL; uSap->suId = 0; uSap->spId = sapId; uSap->procId = DU_PROC; @@ -744,18 +781,18 @@ S16 duBuildMacUsapCfg(SpId sapId) uSap->inst = sapId; uSap->prior = PRIOR0; uSap->route = RTESPEC; - uSap->selector = DU_SELECTOR_LC ; + uSap->selector = ODU_SELECTOR_LC ; /* fill header */ rgMngmt.hdr.msgType = TCFG; rgMngmt.hdr.entId.ent = ENTRG; rgMngmt.hdr.entId.inst = (Inst)0; rgMngmt.hdr.elmId.elmnt = STRGUSAP; - rgMngmt.hdr.response.mem.region = RG_MEM_REGION; - rgMngmt.hdr.response.mem.pool = RG_POOL; - + rgMngmt.hdr.response.mem.region = MAC_MEM_REGION; + rgMngmt.hdr.response.mem.pool = MAC_POOL; + /* fill pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTRG; pst.dstInst = macCfgInst; @@ -795,27 +832,27 @@ S16 duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) { switch (cfm->hdr.elmId.elmnt) { - case STGEN: - { - macCfg |= MAC_GEN_CFG; - break; - } - case STRGUSAP: - { - macCfg |= MAC_SAP_CFG; - numRlcMacSaps++; - break; - } - default: - break; + case STGEN: + { + macCfg |= MAC_GEN_CFG; + break; + } + case STRGUSAP: + { + macCfg |= MAC_SAP_CFG; + numRlcMacSaps++; + break; + } + default: + break; } DU_LOG("\nDU_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"); - macCfgInst = 0; - duBindUnbindRlcToMacSap(RLC_DL_INST, ABND); + macCfg = 0; + DU_LOG("\nDU_APP : Completed sending Configs"); + macCfgInst = 0; + duBindUnbindRlcToMacSap(RLC_DL_INST, ABND); } } @@ -851,7 +888,7 @@ S16 duBindUnbindRlcToMacSap(U8 inst, U8 action) TRC2(smBindKwToRguSap) - DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt)); + DU_SET_ZERO(&kwMngmt, sizeof(KwMngmt)); DU_SET_ZERO(&pst, sizeof(Pst)); if (action == ABND) @@ -879,7 +916,7 @@ S16 duBindUnbindRlcToMacSap(U8 inst, U8 action) kwMngmt.hdr.response.mem.pool = RLC_POOL; /* Fill pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTKW; pst.dstProcId = DU_PROC; @@ -891,42 +928,6 @@ S16 duBindUnbindRlcToMacSap(U8 inst, U8 action) return ROK; } -/******************************************************************* - * - * @brief Function to start SCTP - * - * @details - * - * Function : duSctpStartReq - * - * Functionality: - * Function to start SCTP - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -S16 duSctpStartReq() -{ - Pst pst; - - cmMemset((U8 *)&(pst), 0, sizeof(Pst)); - pst.srcEnt = (Ent)ENTDUAPP; - pst.srcInst = (Inst)DU_INST; - pst.srcProcId = DU_PROC; - pst.dstEnt = (Ent)ENTSCTP; - pst.dstInst = (Inst)SCTP_INST; - pst.dstProcId = pst.srcProcId; - pst.event = EVTSCTPSTRT; - pst.selector = DU_SELECTOR_LC; - pst.pool= DU_POOL; - - cmPkSctpAssocReq(&pst, duCfgParam.sctpParams); - - RETVALUE(ROK); -} - /******************************************************************* * * @brief Handles SCTP notifications @@ -948,34 +949,26 @@ S16 duSctpStartReq() S16 duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) { - switch(ntfy->header.nType) + if(f1Params.assocId == ntfy->u.assocChange.assocId) + { + if(BuildAndSendF1SetupReq() != ROK) + { + return RFAILED; + } + } + else if(ricParams.assocId == ntfy->u.assocChange.assocId) { - case CM_INET_SCTP_ASSOC_CHANGE: - switch(ntfy->u.assocChange.state) - { - case CM_INET_SCTP_COMM_UP: - { - DU_LOG("\nDU_APP : SCTP communication UP"); - //Setup F1-C - if(!duCb.f1Status) - { - /* Build and send F1 Setup response */ - if(BuildAndSendF1SetupReq() != ROK) - { - RETVALUE(RFAILED); - } - } - else - { - //Only SCTP is down, when SCTP comes up again, no need to - //start from setting up F1 link - } - break; - } - } - break; + if(BuildAndSendE2SetupReq() != ROK) + { + return RFAILED; + } } - RETVALUE(ROK); + else + { + DU_LOG("\nDU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId); + return RFAILED; + } + return ROK; } /******************************************************************* @@ -1004,9 +997,9 @@ S16 duFillEgtpPst(Pst *pst, Event event) pst->dstInst = (Inst)EGTP_INST; pst->dstProcId = pst->srcProcId; pst->event = event; - pst->selector = DU_SELECTOR_LC; + pst->selector = ODU_SELECTOR_LC; pst->pool= DU_POOL; - + RETVALUE(ROK); } @@ -1030,18 +1023,18 @@ S16 duFillEgtpPst(Pst *pst, Event event) S16 duBuildEgtpCfgReq() { - Pst pst; - EgtpConfig egtpCfg; - - DU_LOG("\nDU_APP : Sending EGTP config request"); - - cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig)); - cmMemcpy((U8 *)&egtpCfg, (U8 *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig)); - - duFillEgtpPst(&pst, EVTCFGREQ); - cmPkEgtpCfgReq(&pst, egtpCfg); - - RETVALUE(ROK); + Pst pst; + EgtpConfig egtpCfg; + + DU_LOG("\nDU_APP : Sending EGTP config request"); + + cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig)); + cmMemcpy((U8 *)&egtpCfg, (U8 *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig)); + + duFillEgtpPst(&pst, EVTCFGREQ); + packEgtpCfgReq(&pst, egtpCfg); + + RETVALUE(ROK); } /******************************************************************* @@ -1096,7 +1089,7 @@ S16 duHdlEgtpCfgComplete(CmStatus cfm) * RFAILED - failure * * ****************************************************************/ - + S16 duSendEgtpSrvOpenReq() { Pst pst; @@ -1104,7 +1097,7 @@ S16 duSendEgtpSrvOpenReq() DU_LOG("\nDU_APP : Sending EGTP server open request"); duFillEgtpPst(&pst, EVTSRVOPENREQ); - cmPkEgtpSrvOpenReq(&pst); + packEgtpSrvOpenReq(&pst); RETVALUE(ROK); } @@ -1128,22 +1121,22 @@ S16 duSendEgtpSrvOpenReq() S16 duHdlEgtpSrvOpenComplete(CmStatus cfm) { - S16 ret = ROK; - - if(cfm.status == LCM_PRIM_OK) - { - DU_LOG("\nDU_APP : EGTP server opened successfully"); + S16 ret = ROK; + + 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); + duSendEgtpTnlMgmtReq(EGTP_TNL_MGMT_ADD, EGTP_LCL_TEID, EGTP_REM_TEID); #endif - } - else - { - DU_LOG("\nDU_APP : EGTP server opening failed"); - ret = RFAILED; - } - - RETVALUE(ret); + } + else + { + DU_LOG("\nDU_APP : EGTP server opening failed"); + ret = RFAILED; + } + + RETVALUE(ret); } /******************************************************************* @@ -1173,12 +1166,12 @@ S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid) tnlEvt.action = action; tnlEvt.lclTeid = lclTeid; tnlEvt.remTeid = remTeid; - + DU_LOG("\nDU_APP : Sending EGTP tunnel management request"); - + duFillEgtpPst(&pst, EVTTNLMGMTREQ); - cmPkEgtpTnlMgmtReq(&pst, tnlEvt); - + packEgtpTnlMgmtReq(&pst, tnlEvt); + RETVALUE(ROK); } @@ -1207,10 +1200,9 @@ S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) DU_LOG("\nDU_APP : Tunnel management confirm OK"); #ifdef EGTP_TEST - duSendEgtpDatInd(); - - /* For testing purpose. TTI thread should actually be in L1 */ - duStartTtiThread(); + duSendUeCreateReqToRlc(); + + duSendEgtpTestData(); #endif } else @@ -1222,42 +1214,56 @@ S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) RETVALUE(ret); } +S16 duSendEgtpDatInd(Buffer *mBuf) +{ + EgtpMsg egtpMsg; + + /* 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; + egtpMsg.msgHdr.teId = 1; + egtpMsg.msg = mBuf; + + egtpHdlDatInd(egtpMsg); + + return ROK; + +} + #ifdef EGTP_TEST /******************************************************************* * - * @brief Simulate RLC to EGTP data indication + * @brief Simulate UL Data for intial test * * @details * - * Function : duSendEgtpDatInd + * Function : duSendEgtpTestData * * Functionality: - * Simulate RLC to EGTP data indication + * Simulate UL data for initial test * * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 duSendEgtpDatInd() +S16 duSendEgtpTestData() { char data[30] = "This is EGTP data from DU"; int datSize = 30; Buffer *mBuf; - EgtpMsg egtpMsg; if(SGetMsg(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK) { - if(SAddPstMsgMult((Data *)data, datSize, mBuf) == ROK) - { - SPrntMsg(mBuf, 0,0); - } - else + if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK) { - DU_LOG("\nDU_APP : SAddPstMsgMult failed"); - SPutMsg(mBuf); - RETVALUE(RFAILED); + DU_LOG("\nDU_APP : SAddPstMsgMult failed"); + SPutMsg(mBuf); + RETVALUE(RFAILED); } } else @@ -1284,7 +1290,7 @@ S16 duSendEgtpDatInd() S16 ret, cnt, idx; Data revPkArray[CM_IPV4_HDRLEN]; Data pkArray[CM_IPV4_HDRLEN]; - + /* initialize locals */ cnt = 0; cmMemset(revPkArray, 0, CM_IPV4_HDRLEN); @@ -1335,19 +1341,8 @@ S16 duSendEgtpDatInd() /* this function automatically reverses revPkArray */ ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf); + duSendEgtpDatInd(mBuf); - 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; - egtpMsg.msgHdr.teId = 1; - egtpMsg.msg = mBuf; - - SPrntMsg(mBuf, 0, 0); - - egtpHdlDatInd(egtpMsg); - RETVALUE(ROK); } #endif /* EGTP_TEST */ @@ -1382,8 +1377,8 @@ S16 duSendSchCfg() /* Filling of Instance Id */ cfg->instId = DEFAULT_CELLS + 1; /* Filling of Gen config */ - cfg->genCfg.mem.region = RG_MEM_REGION; - cfg->genCfg.mem.pool = RG_POOL; + cfg->genCfg.mem.region = MAC_MEM_REGION; + cfg->genCfg.mem.pool = MAC_POOL; cfg->genCfg.tmrRes = 10; #ifdef LTE_ADV @@ -1399,20 +1394,20 @@ S16 duSendSchCfg() cfg->genCfg.lmPst.srcInst = DEFAULT_CELLS + 1; cfg->genCfg.lmPst.prior = PRIOR0; cfg->genCfg.lmPst.route = RTESPEC; - cfg->genCfg.lmPst.region = RG_MEM_REGION; - cfg->genCfg.lmPst.pool = RG_POOL; - cfg->genCfg.lmPst.selector = DU_SELECTOR_LC; + cfg->genCfg.lmPst.region = MAC_MEM_REGION; + cfg->genCfg.lmPst.pool = MAC_POOL; + cfg->genCfg.lmPst.selector = ODU_SELECTOR_LC; /* Fill Header */ rgMngmt.hdr.msgType = TCFG; rgMngmt.hdr.entId.ent = ENTRG; rgMngmt.hdr.entId.inst = DU_INST; rgMngmt.hdr.elmId.elmnt = STSCHINST; - rgMngmt.hdr.response.mem.region = RG_MEM_REGION; - rgMngmt.hdr.response.mem.pool = RG_POOL; + rgMngmt.hdr.response.mem.region = MAC_MEM_REGION; + rgMngmt.hdr.response.mem.pool = MAC_POOL; /* Fill Pst */ - pst.selector = DU_SELECTOR_LC; + pst.selector = ODU_SELECTOR_LC; pst.srcEnt = ENTDUAPP; pst.dstEnt = ENTRG; pst.dstProcId = DU_PROC; @@ -1430,6 +1425,49 @@ S16 duSendSchCfg() return ROK; } + +/************************************************************************** + * @brief Function to configure SCTP params and + * responsible for F1 and E2 interfaces + * + * @details + * + * Function : duLayerConfigComplete + * + * Functionality: + * Configures SCTP Params and responsible for handling + * F1 and E2 interface. + * + * @param[in] void + * @return ROK - success + * RFAILED - failure + * + ***************************************************************************/ +S16 duLayerConfigComplete() +{ + S16 ret = ROK; + + DU_LOG("\nDU_APP : Configuring all Layer is complete"); + + if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK) + { + DU_LOG("\nDU_APP : Failed configuring Sctp Params"); + ret = RFAILED; + } + if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK) + { + DU_LOG("\nDU_APP : Failed to send AssocReq F1"); + ret = RFAILED; + } + if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK) + { + DU_LOG("\nDU_APP : Failed to send AssocReq E2"); + ret = RFAILED; + } + + RETVALUE(ret); +} + /************************************************************************** * @brief Function to handle SCH Config Confirm from MAC * @@ -1452,46 +1490,45 @@ S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm) { switch (cfm->hdr.elmId.elmnt) { - case STSCHINST: - { - DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP"); - break; - } - default: - break; + case STSCHINST: + { + DU_LOG("\nDU_APP : Received SCH CFG CFM at DU APP"); + break; + } + default: + break; } } - duSctpStartReq(); - + duLayerConfigComplete(); duBuildEgtpCfgReq(); return ROK; } /******************************************************************* * - * @brief Handles TTI indication + * @brief Sends Slot indication to EGTP * * @details * - * Function : duSendEgtpTTIInd + * Function : duSendEgtpSlotInd * * Functionality: - * Handles TTI indication received from PHY + * Sends Slot indication to EGTP * * @params[in] * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 duSendEgtpTTIInd() +S16 duSendEgtpSlotInd() { Pst pst; - duFillEgtpPst(&pst, EVTTTIIND); - cmPkEgtpTTIInd(&pst); - + duFillEgtpPst(&pst, EVTSLOTIND); + packEgtpSlotInd(&pst); + RETVALUE(ROK); - + } /************************************************************************** @@ -1515,7 +1552,7 @@ S16 duBuildAndSendMacCellCfg() DU_SET_ZERO(&pst, sizeof(Pst)); MacCellCfg *duMacCellCfg = NULLP; - DU_ALLOC(duMacCellCfg, sizeof(MacCellCfg)); + DU_ALLOC_SHRABL_BUF(duMacCellCfg, sizeof(MacCellCfg)); if(duMacCellCfg == NULLP) { return RFAILED; @@ -1527,18 +1564,8 @@ S16 duBuildAndSendMacCellCfg() /* copy the mac config structure from duCfgParams */ memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg)); - duMacCellCfg->transId = getTransId(); /* transaction ID */ - /* Fill Pst */ - pst.selector = DU_SELECTOR_LWLC; - pst.srcEnt = ENTDUAPP; - pst.dstEnt = ENTRG; - pst.dstInst = 0; - pst.srcInst = 0; - pst.dstProcId = DU_PROC; - pst.srcProcId = DU_PROC; - pst.region = duCb.init.region; - pst.event = EVENT_MAC_CELL_CONFIG_REQ; + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_CONFIG_REQ); /* Send MAC cell config to MAC */ return (*packMacCellCfgOpts[pst.selector])(&pst, duMacCellCfg); @@ -1559,29 +1586,239 @@ S16 duBuildAndSendMacCellCfg() * RFAILED - failure * ***************************************************************************/ -S16 duHandleMacCellCfgCfm(MacCellCfgCfm *macCellCfgCfm) +uint8_t duHandleMacCellCfgCfm(Pst *pst, MacCellCfgCfm *macCellCfgCfm) { - S16 ret = ROK; + uint8_t actvCellIdx = 0; + uint8_t ret = ROK; - if(macCellCfgCfm->transId == duCb.duMacCellCfg->transId) + if(macCellCfgCfm->rsp == ROK) { - /* free the memory allocated during sending macCellCfg request */ - DU_FREE(duCb.duMacCellCfg,sizeof(MacCellCfg)); - duCb.duMacCellCfg = NULLP; + 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; +} - /* Build and send GNB-DU config update */ - ret = BuildAndSendDUConfigUpdate(); +/******************************************************************* + * + * @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); } - else + if(!duCb.actvCellLst[slotInfo->cellId-1]->firstSlotIndRcvd) { - /* transaction ID missmatch */ - DU_LOG("\n transaction ID mismatch in macCellCfg"); - ret = RFAILED; + 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; + } + } - return ret; + /* 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 + * + * Functionality: + * Builds and sends cell start request to MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duBuildAndSendMacCellStartReq() +{ + Pst pst; + MacCellStartInfo *cellStartInfo = NULL; + + DU_LOG("\nDU 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_LOG("\nDU APP : Memory alloc failed while building cell start request"); + return RFAILED; + } + + for(uint8_t id = 0; id < MAX_NUM_CELL; id++) + { + if(duCb.actvCellLst[id]) + { + duCb.actvCellLst[id]->firstSlotIndRcvd = FALSE; + cellStartInfo->cellId = duCb.actvCellLst[id]->cellInfo.nrEcgi.cellId; + + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START_REQ); + + return (*packMacCellStartReqOpts[pst.selector])(&pst, cellStartInfo); + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Builds and sends cell stop request to MAC + * + * @details + * + * Function : duBuildAndSendMacCellStopReq + * + * Functionality: + * Builds and sends cell stop request to MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duBuildAndSendMacCellStopReq() +{ + Pst pst; + MacCellStopInfo *cellStopInfo = NULL; + + DU_LOG("\nDU 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_LOG("\nDU APP : Memory alloc failed while building cell stop request"); + return RFAILED; + } + cellStopInfo->cellId = duCb.actvCellLst[0]->cellId; + + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP_REQ); + + return (*packMacCellStopReqOpts[pst.selector])(&pst, cellStopInfo); +} + +/******************************************************************* + * + * @brief Handles stop indication from MAC + * + * @details + * + * Function : duHandleStopInd + * + * Functionality: + * Handles stop indication from MAC + * + * @params[in] Post structure pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duHandleStopInd(Pst *pst, MacCellStopInfo *cellStopId) +{ + if(cellStopId->cellId <=0 || cellStopId->cellId > MAX_NUM_CELL) + { + DU_LOG("\nDU APP : Invalid Cell Id %d", cellStopId->cellId); + } + if(duCb.actvCellLst[cellStopId->cellId-1] != NULL) + { + 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; + } + } + } + if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC)) + DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, cellStopId, sizeof(MacCellStopInfo)); + + return ROK; +} + +/******************************************************************* + * + * @brief Handles slot indication from MAC + * + * @details + * + * Function : duHandleUlCcchInd + * + * Functionality: + * Handles UL CCCH indication from MAC + * + * @params[in] Post structure pointer + * UL CCCH Ind pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duHandleUlCcchInd(Pst *pst, UlCcchIndInfo *ulCcchIndInfo) +{ + + DU_LOG("\nDU APP : UL CCCH Indication received"); + + return (duProcUlCcchInd(ulCcchIndInfo)); +} + + /********************************************************************** End of file **********************************************************************/