X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_msg_hdl.c;h=90fe20bfa9995ce927a7206c016088f03b99ea0e;hb=ba2574ac618b40905509604da8d3a2b1b9e39664;hp=dfd0e7dc9056b9e9cb75b5892e19d77ec3900de7;hpb=43f9a063a851c5318a609e9966cdc0b30f0abaf5;p=o-du%2Fl2.git diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index dfd0e7dc9..90fe20bfa 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -16,34 +16,75 @@ ################################################################################ *******************************************************************************/ -/* 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 "kwu.h" +#include "lrg.x" +#include "lkw.x" +#include "kwu.x" +#include "du_app_mac_inf.h" +#include "du_app_rlc_inf.h" +#include "du_cfg.h" +#include "du_app_rlc_inf.h" #include "du_mgr.h" #include "du_sctp.h" +#include "F1AP-PDU.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" +#include "du_cell_mgr.h" + +#ifdef O1_ENABLE + +#include "GlobalDefs.h" +#include "AlarmInterface.h" -U8 rlcDlCfg = 0; -U8 numRlcDlSaps = 0; -U8 rlcUlCfg = 0; -U8 numRlcMacSaps = 0; -U8 macCfg = 0; -U8 macCfgInst = 0; +#endif -extern DuCfgParams duCfgParam; -extern S16 cmPkLkwCfgReq(Pst *pst, KwMngmt *cfg); -extern S16 cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg); -extern S16 cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg); +uint8_t rlcDlCfg = 0; +uint8_t numRlcDlSaps = 0; +uint8_t rlcUlCfg = 0; +uint8_t numRlcMacSaps = 0; +uint8_t macCfg = 0; +uint8_t macCfgInst = 0; + +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[] = { packMacCellCfg, /* packing for loosely coupled */ - MacHdlCellCfgReq, /* packing for tightly coupled */ + MacProcCellCfgReq, /* packing for tightly coupled */ packMacCellCfg, /* packing for light weight loosly coupled */ }; +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 */ +}; + /************************************************************************** * @brief Function to fill configs required by RLC * @@ -59,16 +100,16 @@ packMacCellCfgReq packMacCellCfgOpts[] = * RFAILED - failure * ***************************************************************************/ -S16 duBuildRlcCfg(Inst inst) +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; @@ -85,35 +126,35 @@ S16 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; 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; - - /* 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) ? + genCfg->lmPst.selector = ODU_SELECTOR_LC; + + /* Fill Header */ + 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 = DU_SELECTOR_LC; + rlcMngmt.hdr.response.mem.pool = DU_POOL; + rlcMngmt.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.dstEnt = ENTRLC; pst.dstInst = inst; pst.dstProcId = DU_PROC; pst.srcProcId = DU_PROC; @@ -122,7 +163,7 @@ S16 duBuildRlcCfg(Inst inst) DU_LOG("\nDU_APP : RLC Gen Cfg Req sent for inst %d", inst); /* Send the request to RLC */ - cmPkLkwCfgReq(&pst, &kwMngmt); + packRlcConfigReq(&pst, &rlcMngmt); return ROK; } @@ -142,33 +183,33 @@ S16 duBuildRlcCfg(Inst inst) * RFAILED - failure * ***************************************************************************/ -S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst) +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 = DU_SELECTOR_LC; + 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; @@ -177,30 +218,30 @@ S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 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) ? DU_SELECTOR_LWLC : DU_SELECTOR_TC; - kwMngmt.hdr.elmId.elmnt = STRGUSAP; + 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); } else { lSap->procId = DU_PROC; - lSap->ent = ENTKW; + lSap->ent = ENTRLC; 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; - kwMngmt.hdr.elmId.elmnt = STUDXSAP; + 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); } - cmPkLkwCfgReq(&pst, &kwMngmt); + packRlcConfigReq(&pst, &rlcMngmt); return ROK; } @@ -219,25 +260,25 @@ S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst) * RFAILED - failure * ***************************************************************************/ -S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst) +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 = 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; uSap->mem.spare = 0; uSap->procId = DU_PROC; - uSap->ent = ENTKW; + uSap->ent = ENTRLC; uSap->sapId = 0; uSap->inst = (inst == RLC_UL_INST) ? @@ -247,25 +288,25 @@ S16 duBuildRlcUsapCfg(U8 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 = DU_SELECTOR_LC; + 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); - cmPkLkwCfgReq(&pst, &kwMngmt); + packRlcConfigReq(&pst, &rlcMngmt); return ROK; } @@ -286,50 +327,48 @@ S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst) * RFAILED - failure * ***************************************************************************/ -S16 duProcCfgComplete() +uint8_t duProcCfgComplete() { - S16 ret = ROK; - static U16 cellId = 0; - U16 idx; + uint8_t ret = ROK; + static uint16_t cellId = 0; + uint16_t idx; 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; + DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete"); + ret = RFAILED; } else { - U32 nci; - U8 idx; - - 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(idx=0; idxcellInfo.plmn[idx].mcc[0] = PLMN_MCC0; - cell->cellInfo.plmn[idx].mcc[1] = PLMN_MCC1; - cell->cellInfo.plmn[idx].mcc[2] = PLMN_MCC2; - cell->cellInfo.plmn[idx].mnc[0] = PLMN_MNC0; - cell->cellInfo.plmn[idx].mnc[1] = PLMN_MNC1; - cell->cellInfo.plmn[idx].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; + 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; + } + cell->cellInfo.maxUe = duCfgParam.maxUe; + cell->cellStatus = CELL_OUT_OF_SERVICE; + + duCb.cfgCellLst[duCb.numCfgCells] = cell; + duCb.numCfgCells++; } } if(ret != RFAILED) @@ -354,17 +393,17 @@ S16 duProcCfgComplete() * RFAILED - failure * ***************************************************************************/ -S16 duSendRlcUlCfg() +uint8_t duSendRlcUlCfg() { - U8 cellIdx; + uint8_t cellIdx; 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; } @@ -383,17 +422,17 @@ S16 duSendRlcUlCfg() * RFAILED - failure * ***************************************************************************/ -S16 duSendRlcDlCfg() +uint8_t duSendRlcDlCfg() { - U8 cellIdx; + 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; } /************************************************************************** @@ -401,20 +440,20 @@ S16 duSendRlcDlCfg() * * @details * - * Function : duHdlRlcCfgComplete + * Function : DuHdlRlcCfgComplete * * Functionality: * 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 * ***************************************************************************/ -S16 duHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm) +uint8_t DuHdlRlcCfgComplete(Pst *pst, RlcMngmt *cfm) { - S16 ret = ROK; + uint8_t ret = ROK; if (pst->srcInst == RLC_UL_INST) { ret = duProcRlcUlCfgComplete(pst, cfm); @@ -437,50 +476,50 @@ S16 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 * ***************************************************************************/ -S16 duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl) +uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, RlcMngmt *cntrl) { - S16 ret = ROK; + uint8_t ret = ROK; if (cntrl->cfm.status == LCM_PRIM_OK) { 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; + } + } } } @@ -497,51 +536,51 @@ S16 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 * ***************************************************************************/ -S16 duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm) +uint8_t duProcRlcUlCfgComplete(Pst *pst, RlcMngmt *cfm) { - S16 ret; + uint8_t ret; DU_LOG("\nDU_APP : RLC UL Cfg Status %d", cfm->cfm.status); if (cfm->cfm.status == LCM_PRIM_OK) { 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(); } } @@ -564,49 +603,49 @@ S16 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 * ***************************************************************************/ -S16 duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm) +uint8_t duProcRlcDlCfgComplete(Pst *pst, RlcMngmt *cfm) { DU_LOG("\nDU_APP : RLC DL Cfg Status %d", cfm->cfm.status); if (cfm->cfm.status == LCM_PRIM_OK) { 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(); } } @@ -632,7 +671,7 @@ S16 duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm) * RFAILED - failure * ***************************************************************************/ -S16 duSendMacCfg() +uint8_t duSendMacCfg() { duBuildMacGenCfg(); duBuildMacUsapCfg(RLC_UL_INST); @@ -656,7 +695,7 @@ S16 duSendMacCfg() * RFAILED - failure * ***************************************************************************/ -S16 duBuildMacGenCfg() +uint8_t duBuildMacGenCfg() { RgMngmt rgMngmt; RgGenCfg *genCfg=NULLP; @@ -666,10 +705,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; @@ -677,18 +716,18 @@ S16 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; - 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; + rgMngmt.hdr.entId.ent = ENTMAC; rgMngmt.hdr.entId.inst = (Inst)0; rgMngmt.hdr.elmId.elmnt = STGEN; rgMngmt.hdr.seqNmb = 0; @@ -697,14 +736,14 @@ 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.dstEnt = ENTMAC; pst.dstInst = macCfgInst; pst.dstProcId = DU_PROC; pst.srcProcId = DU_PROC; @@ -733,7 +772,7 @@ S16 duBuildMacGenCfg() * RFAILED - failure * ***************************************************************************/ -S16 duBuildMacUsapCfg(SpId sapId) +uint8_t duBuildMacUsapCfg(SpId sapId) { RgMngmt rgMngmt; RgUpSapCfg *uSap = NULLP; @@ -744,29 +783,29 @@ 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; - uSap->ent = ENTKW; + uSap->ent = ENTRLC; 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.ent = ENTMAC; 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.dstEnt = ENTMAC; pst.dstInst = macCfgInst; pst.dstProcId = DU_PROC; pst.srcProcId = DU_PROC; @@ -796,35 +835,35 @@ S16 duBuildMacUsapCfg(SpId sapId) * RFAILED - failure * ***************************************************************************/ -S16 duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) +uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) { - S16 ret = ROK; + uint8_t ret = ROK; if (cfm->cfm.status == LCM_PRIM_OK) { 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); } } @@ -852,15 +891,14 @@ S16 duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm) * RFAILED - failure * ***************************************************************************/ -S16 duBindUnbindRlcToMacSap(U8 inst, U8 action) +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) @@ -871,7 +909,7 @@ S16 duBindUnbindRlcToMacSap(U8 inst, U8 action) { DU_LOG("\nDU_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; @@ -879,24 +917,24 @@ S16 duBindUnbindRlcToMacSap(U8 inst, U8 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 = DU_SELECTOR_LC; + 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; } @@ -919,27 +957,27 @@ S16 duBindUnbindRlcToMacSap(U8 inst, U8 action) * * ****************************************************************/ -S16 duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) +uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) { if(f1Params.assocId == ntfy->u.assocChange.assocId) { if(BuildAndSendF1SetupReq() != ROK) { - return RFAILED; + return RFAILED; } } else if(ricParams.assocId == ntfy->u.assocChange.assocId) { if(BuildAndSendE2SetupReq() != ROK) { - return RFAILED; + return RFAILED; } } else - { + { DU_LOG("\nDU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId); - return RFAILED; - } + return RFAILED; + } return ROK; } @@ -959,9 +997,9 @@ S16 duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy) * RFAILED - failure * * ****************************************************************/ -S16 duFillEgtpPst(Pst *pst, Event event) +uint8_t duFillEgtpPst(Pst *pst, Event event) { - cmMemset((U8 *)pst, 0, sizeof(Pst)); + memset(pst, 0, sizeof(Pst)); pst->srcEnt = (Ent)ENTDUAPP; pst->srcInst = (Inst)DU_INST; pst->srcProcId = DU_PROC; @@ -969,10 +1007,10 @@ 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); + + return ROK; } @@ -993,20 +1031,20 @@ S16 duFillEgtpPst(Pst *pst, Event event) * * ****************************************************************/ -S16 duBuildEgtpCfgReq() +uint8_t 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"); + + memset(&egtpCfg, 0, sizeof(EgtpConfig)); + memcpy(&egtpCfg, &duCfgParam.egtpParams, sizeof(EgtpConfig)); + + duFillEgtpPst(&pst, EVTCFGREQ); + packEgtpCfgReq(&pst, egtpCfg); + + return ROK; } /******************************************************************* @@ -1025,9 +1063,9 @@ S16 duBuildEgtpCfgReq() * RFAILED - failure * * ****************************************************************/ -S16 duHdlEgtpCfgComplete(CmStatus cfm) +uint8_t duHdlEgtpCfgComplete(CmStatus cfm) { - S16 ret = ROK; + uint8_t ret = ROK; if(cfm.status == LCM_PRIM_OK) { @@ -1042,7 +1080,7 @@ S16 duHdlEgtpCfgComplete(CmStatus cfm) ret = RFAILED; } - RETVALUE(ret); + return (ret); } /******************************************************************* @@ -1061,17 +1099,17 @@ S16 duHdlEgtpCfgComplete(CmStatus cfm) * RFAILED - failure * * ****************************************************************/ - -S16 duSendEgtpSrvOpenReq() + +uint8_t duSendEgtpSrvOpenReq() { Pst pst; DU_LOG("\nDU_APP : Sending EGTP server open request"); duFillEgtpPst(&pst, EVTSRVOPENREQ); - cmPkEgtpSrvOpenReq(&pst); + packEgtpSrvOpenReq(&pst); - RETVALUE(ROK); + return ROK; } /******************************************************************* @@ -1091,24 +1129,24 @@ S16 duSendEgtpSrvOpenReq() * *****************************************************************/ -S16 duHdlEgtpSrvOpenComplete(CmStatus cfm) +uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm) { - S16 ret = ROK; - - if(cfm.status == LCM_PRIM_OK) - { - DU_LOG("\nDU_APP : EGTP server opened successfully"); + uint8_t 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; + } + + return (ret); } /******************************************************************* @@ -1130,7 +1168,7 @@ S16 duHdlEgtpSrvOpenComplete(CmStatus cfm) * * ****************************************************************/ -S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid) +uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid) { Pst pst; EgtpTnlEvt tnlEvt; @@ -1138,13 +1176,11 @@ 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); - - RETVALUE(ROK); + egtpTnlMgmtReq(&pst, tnlEvt); + return ROK; } /******************************************************************* @@ -1163,22 +1199,16 @@ S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid) * RFAILED - failure * * ****************************************************************/ -S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) +uint8_t duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) { - S16 ret = ROK; + uint8_t ret = ROK; if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK) { DU_LOG("\nDU_APP : Tunnel management confirm OK"); - -#ifdef EGTP_TEST - duSendUeCreateReqToRlc(); - +#ifdef EGTP_TEST duSendEgtpTestData(); - - /* For testing purpose. TTI thread should actually be in L1 */ - duStartTtiThread(); -#endif +#endif } else { @@ -1186,10 +1216,25 @@ S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm) ret = RFAILED; } - RETVALUE(ret); + return (ret); } -S16 duSendEgtpDatInd(Buffer *mBuf) +/******************************************************************* + * + * @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; @@ -1201,7 +1246,7 @@ S16 duSendEgtpDatInd(Buffer *mBuf) egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE; egtpMsg.msgHdr.teId = 1; egtpMsg.msg = mBuf; - + egtpHdlDatInd(egtpMsg); return ROK; @@ -1225,26 +1270,26 @@ S16 duSendEgtpDatInd(Buffer *mBuf) * RFAILED - failure * * ****************************************************************/ -S16 duSendEgtpTestData() +uint8_t duSendEgtpTestData() { char data[30] = "This is EGTP data from DU"; int datSize = 30; Buffer *mBuf; - if(SGetMsg(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK) + if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK) { - if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK) + if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK) { - DU_LOG("\nDU_APP : SAddPstMsgMult failed"); - SPutMsg(mBuf); - RETVALUE(RFAILED); + 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"); - RETVALUE(RFAILED); + return RFAILED; } /* filling IPv4 header */ @@ -1252,24 +1297,24 @@ S16 duSendEgtpTestData() MsgLen mLen; mLen = 0; - SFndLenMsg(mBuf, &mLen); + ODU_GET_MSG_LEN(mBuf, &mLen); - cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr)); + memset(&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); + 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 */ - S16 ret, cnt, idx; + uint8_t ret, cnt, idx; Data revPkArray[CM_IPV4_HDRLEN]; Data pkArray[CM_IPV4_HDRLEN]; - + /* initialize locals */ cnt = 0; - cmMemset(revPkArray, 0, CM_IPV4_HDRLEN); - cmMemset(pkArray, 0, CM_IPV4_HDRLEN); + memset(revPkArray, 0, CM_IPV4_HDRLEN); + memset(pkArray, 0, CM_IPV4_HDRLEN); /* Pack Header Version */ pkArray[cnt++] = ipv4Hdr.hdrVer; @@ -1314,11 +1359,11 @@ S16 duSendEgtpTestData() revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1]; /* this function automatically reverses revPkArray */ - ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf); - + ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf); + duSendEgtpDatInd(mBuf); - - RETVALUE(ROK); + + return ROK; } #endif /* EGTP_TEST */ @@ -1338,7 +1383,7 @@ S16 duSendEgtpTestData() * RFAILED - failure * ***************************************************************************/ -S16 duSendSchCfg() +uint8_t duSendSchCfg() { RgMngmt rgMngmt; RgSchInstCfg *cfg = NULLP; @@ -1352,8 +1397,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 @@ -1365,26 +1410,26 @@ S16 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; - 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.ent = ENTMAC; 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.dstEnt = ENTMAC; pst.dstProcId = DU_PROC; pst.srcProcId = DU_PROC; pst.srcInst = DU_INST; @@ -1418,9 +1463,9 @@ S16 duSendSchCfg() * RFAILED - failure * ***************************************************************************/ -S16 duLayerConfigComplete() +uint8_t duLayerConfigComplete() { - S16 ret = ROK; + uint8_t ret = ROK; DU_LOG("\nDU_APP : Configuring all Layer is complete"); @@ -1440,7 +1485,7 @@ S16 duLayerConfigComplete() ret = RFAILED; } - RETVALUE(ret); + return (ret); } /************************************************************************** @@ -1459,19 +1504,19 @@ S16 duLayerConfigComplete() * RFAILED - failure * ***************************************************************************/ -S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm) +uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm) { if (cfm->cfm.status == LCM_PRIM_OK) { 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; } } duLayerConfigComplete(); @@ -1479,33 +1524,6 @@ S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm) return ROK; } -/******************************************************************* - * - * @brief Handles TTI indication - * - * @details - * - * Function : duSendEgtpTTIInd - * - * Functionality: - * Handles TTI indication received from PHY - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -S16 duSendEgtpTTIInd() -{ - Pst pst; - - duFillEgtpPst(&pst, EVTTTIIND); - cmPkEgtpTTIInd(&pst); - - RETVALUE(ROK); - -} - /************************************************************************** * @brief Function to fill and send MacCellconfig * @@ -1516,41 +1534,30 @@ S16 duSendEgtpTTIInd() * Functionality: * Initiates MAC Configs towards MAC * - * @param[in] void + * @param[in]cell id * @return ROK - success * RFAILED - failure * ***************************************************************************/ -S16 duBuildAndSendMacCellCfg() +uint8_t duBuildAndSendMacCellCfg(uint16_t cellId) { Pst pst; - 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; } - /* 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)); - 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); @@ -1571,31 +1578,264 @@ 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) + for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++) + { + if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId) + { + duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP; + } + } + if(macCellCfgCfm->rsp == ROK) { - /* free the memory allocated during sending macCellCfg request */ - DU_FREE(duCb.duMacCellCfg,sizeof(MacCellCfg)); - duCb.duMacCellCfg = NULLP; - DU_LOG("\nDU-APP : MAC CELL config confirm recieved\n"); - - /* Build and send GNB-DU config update */ ret = BuildAndSendDUConfigUpdate(); + + /* Build and Send Cell Start Req to MAC */ + ret = duBuildAndSendMacCellStart(); } else { - /* transaction ID missmatch */ - DU_LOG("\n transaction ID mismatch in macCellCfg"); + /* TODO : Action to be taken if cell configuration fails. + * Should CU be informed? */ + + DU_LOG("\nMac cell cfg failed"); ret = RFAILED; } + return ret; +} +/******************************************************************* + * + * @brief Builds and sends cell start request to MAC + * + * @details + * + * Function : duBuildAndSendMacCellStart + * + * Functionality: + * Builds and sends cell start request to MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duBuildAndSendMacCellStart() +{ + Pst pst; + OduCellId *cellId = NULL; + + DU_LOG("\nDU APP : Building and Sending cell start request to MAC"); + + /* Send Cell Start Request to MAC */ + DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId)); + if(!cellId) + { + DU_LOG("\nDU APP : Memory alloc failed while building cell start request"); + return RFAILED; + } + + for(uint8_t id = 0; id < duCb.numActvCells; id++) + { + if(duCb.actvCellLst[id]) + { + cellId->cellId = duCb.actvCellLst[id]->cellId; + + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START); + + return (*packMacCellStartOpts[pst.selector])(&pst, cellId); + } + } + return ROK; +} + +/******************************************************************* + * + * @brief Builds and sends cell stop request to MAC + * + * @details + * + * Function : duBuildAndSendMacCellStop + * + * Functionality: + * Builds and sends cell stop request to MAC + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t duBuildAndSendMacCellStop() +{ + Pst pst; + OduCellId *cellId = NULL; + + DU_LOG("\nDU APP : Building and Sending cell stop request to MAC"); + + /* Send Cell Stop Request to MAC */ + DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId)); + if(!cellId) + { + DU_LOG("\nDU APP : Memory alloc failed while building cell stop request"); + return RFAILED; + } + cellId->cellId = duCb.actvCellLst[0]->cellId; + + /* Fill Pst */ + FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP); + + return (*packMacCellStopOpts[pst.selector])(&pst, cellId); +} + +/******************************************************************* + * + * @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, OduCellId *cellId) +{ + DuCellCb *cellCb = NULLP; + + if(cellId->cellId <=0 || cellId->cellId > MAX_NUM_CELL) + { + DU_LOG("\nDU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId); + } + + if(duGetCellCb(cellId->cellId, &cellCb) != ROK) + return RFAILED; + + if((cellCb->cellStatus == ACTIVATED)) + { + DU_LOG("\nDU APP : 5G-NR Cell %d is DOWN", cellId->cellId); + cellCb->cellStatus = DELETION_IN_PROGRESS; + +#ifdef O1_ENABLE + DU_LOG("\nDU 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, 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; +} + +/******************************************************************* + * + * @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)); +} + +/******************************************************************* + * + * @brief Process UL RRC Message from RLC + * + * @details + * + * Function : DuProcRlcUlRrcMsgTrans + * + * Functionality: Process UL RRC Message from RLC + * + * @params[in] Post structure + * UL RRC Message Info + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo) +{ + 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; } + /********************************************************************** End of file **********************************************************************/