################################################################################
*******************************************************************************/
-/* 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"
-
-U8 rlcDlCfg = 0;
-U8 numRlcDlSaps = 0;
-U8 rlcUlCfg = 0;
-U8 numRlcMacSaps = 0;
-U8 macCfg = 0;
-U8 macCfgInst = 0;
+#include "du_utils.h"
+#include "du_cell_mgr.h"
+
+#ifdef O1_ENABLE
+
+#include "AlarmInterface.h"
+#include "CmInterface.h"
+#include "PmInterface.h"
+
+#endif
+
+uint8_t rlcDlCfg = 0;
+uint8_t numRlcDlSaps = 0;
+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 egtpHdlDatInd(EgtpMsg egtpMsg);
+uint8_t BuildAndSendDUConfigUpdate();
+uint16_t getTransId();
+uint8_t cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg);
+uint8_t sendCellDeleteReqToMac(uint16_t cellId);
+
+packMacCellCfgReq packMacCellCfgOpts[] =
+{
+ packMacCellCfg, /* packing for loosely coupled */
+ MacProcCellCfgReq, /* packing for tightly coupled */
+ packMacCellCfg, /* packing for light weight loosly coupled */
+};
-extern DuCfgParams duCfgParam;;
+DuMacCellStart packMacCellStartOpts[] =
+{
+ packMacCellStart, /* Loose coupling */
+ MacProcCellStart, /* TIght coupling */
+ packMacCellStart /* Light weight-loose coupling */
+};
-extern S16 cmPkLkwCfgReq(Pst *pst, KwMngmt *cfg);
-extern S16 cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg);
-extern S16 cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg);
+DuMacCellStop packMacCellStopOpts[] =
+{
+ packMacCellStop, /* Loose coupling */
+ MacProcCellStop, /* TIght coupling */
+ packMacCellStop /* Light weight-loose coupling */
+};
-packMacCellCfgReq packMacCellCfgMt[] =
+DuMacSliceCfgReq packMacSliceCfgReqOpts[] =
{
- packLcMacCellCfg, /* packing for loosely coupled */
- packTcMacCellCfg, /* packing for tightly coupled */
- packLwLcMacCellCfg, /* packing for light weight loosly coupled */
+ packDuMacSliceCfgReq, /* Loose coupling */
+ MacProcSliceCfgReq, /* TIght coupling */
+ packDuMacSliceCfgReq /* Light weight-loose coupling */
};
+
+DuMacSliceRecfgReq packMacSliceReCfgReqOpts[] =
+{
+ packDuMacSliceRecfgReq, /* Loose coupling */
+ MacProcSliceReCfgReq, /* TIght coupling */
+ packDuMacSliceRecfgReq /* Light weight-loose coupling */
+};
/**************************************************************************
* @brief Function to fill configs required by RLC
*
* 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;
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;
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 */
- cmPkLkwCfgReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
}
* 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;
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;
- DU_LOG("\nDU_APP : RLC MAC Lower Sap Cfg Req sent for inst %d", inst);
+ lSap->selector = (inst == RLC_UL_INST) ? ODU_SELECTOR_LWLC : ODU_SELECTOR_TC;
+ 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;
+ RLC_DL_INST : RLC_UL_INST;
lSap->sapId = 0;
- lSap->selector = DU_SELECTOR_LC;
- kwMngmt.hdr.elmId.elmnt = STUDXSAP;
- DU_LOG("\nDU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
+ lSap->selector = ODU_SELECTOR_LC;
+ rlcMngmt.hdr.elmId.elmnt = STUDXSAP;
+ DU_LOG("\nDEBUG --> DU_APP : RLC DL/UL Lower Sap Cfg Req sent for inst %d", inst);
}
- cmPkLkwCfgReq(&pst, &kwMngmt);
+ packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
}
* 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) ?
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);
+ DU_LOG("\nDEBUG --> DU_APP : RLC Kwu Upper Sap Cfg Req sent for inst %d", inst);
+ packRlcConfigReq(&pst, &rlcMngmt);
return ROK;
}
* RFAILED - failure
*
***************************************************************************/
-S16 duProcCfgComplete()
+uint8_t 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
+ uint8_t ret = ROK;
+ uint16_t cellId = 0;
+ uint16_t idx;
+ for(idx=0; idx< DEFAULT_CELLS; idx++)
{
- DuCellCb *cell;
- DU_ALLOC(cell, sizeof(DuCellCb))
+ DuCellCb *cell = NULLP;
+ DU_ALLOC(cell, sizeof(DuCellCb));
if(cell == NULLP)
{
- DU_LOG("\nDU_APP : Memory Allocation failed in duProcCfgComplete");
+ DU_LOG("\nERROR --> DU_APP : Memory Allocation failed in duProcCfgComplete");
ret = RFAILED;
}
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)
+ uint8_t idx1=0;
+ memset(cell, 0, sizeof(DuCellCb));
+ cell->cellId = NR_CELL_ID; //++cellId;
+ memset(&cell->cellInfo.nrEcgi.plmn, 0, sizeof(Plmn));
+ cell->cellInfo.nrEcgi.plmn.mcc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[0];
+ cell->cellInfo.nrEcgi.plmn.mcc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[1];
+ cell->cellInfo.nrEcgi.plmn.mcc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[2];
+ cell->cellInfo.nrEcgi.plmn.mnc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[0];
+ cell->cellInfo.nrEcgi.plmn.mnc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[1];
+ cell->cellInfo.nrEcgi.plmn.mnc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[2];
+ cell->cellInfo.nrEcgi.cellId = cell->cellId;
+ cell->cellInfo.nrPci = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
+ cell->cellInfo.fiveGsTac = duCfgParam.srvdCellLst[0].duCellInfo.tac;
+ memset(&cell->cellInfo.plmn[idx1], 0, sizeof(Plmn));
+ for(idx1=0; idx1<MAX_PLMN; idx1++)
{
- DU_LOG("\nDU_APP : HashListInsert into cellLst failed for [%d]", nci);
- break;
- }
- else
- {
- DU_LOG("\nDU_APP : HashListInsert into cellLst successful for [%d]", nci);
+ cell->cellInfo.plmn[idx1].mcc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[0];
+ cell->cellInfo.plmn[idx1].mcc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[1];
+ cell->cellInfo.plmn[idx1].mcc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mcc[2];
+ cell->cellInfo.plmn[idx1].mnc[0] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[0];
+ cell->cellInfo.plmn[idx1].mnc[1] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[1];
+ cell->cellInfo.plmn[idx1].mnc[2] = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].plmn.mnc[2];
}
+ cell->cellInfo.maxUe = duCfgParam.maxUe;
+ cell->cellStatus = CELL_OUT_OF_SERVICE;
+ gCellStatus = CELL_DOWN;
+ duCb.cfgCellLst[duCb.numCfgCells] = cell;
+ duCb.numCfgCells++;
}
}
if(ret != RFAILED)
* 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;
}
* 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;
}
/**************************************************************************
*
* @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);
* 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("\nDEBUG --> DU_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("\nDEBUG --> DU_APP : BIND OF RLC UL TO MAC (RGU) SAP SUCCESSFUL");
+ macCfgInst++;
+ if(macCfgInst < DEFAULT_CELLS)
+ {
+ duBindUnbindRlcToMacSap((Inst) RLC_UL_INST, ABND);
+ }
+ else
+ {
+ duSendSchCfg();
+ }
+ break;
+ }
+ }
}
}
* 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);
+ 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)
{
- 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);
+ 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;
- numRlcMacSaps = 0;
- //Start configuration of RLC DL
- duSendRlcDlCfg();
+ rlcUlCfg = 0;
+ numRlcMacSaps = 0;
+ //Start configuration of RLC DL
+ duSendRlcDlCfg();
}
}
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;
* 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);
+ 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)
{
- 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);
+ 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;
- //Start configuration of MAC
- duSendMacCfg();
+ rlcDlCfg = 0;
+ //Start configuration of MAC
+ duSendMacCfg();
}
}
else
{
- DU_LOG("\nDU_APP : Config confirm NOK from RLC DL");
+ DU_LOG("\nERROR --> DU_APP : Config confirm NOK from RLC DL");
}
return ROK;
}
* RFAILED - failure
*
***************************************************************************/
-S16 duSendMacCfg()
+uint8_t duSendMacCfg()
{
duBuildMacGenCfg();
duBuildMacUsapCfg(RLC_UL_INST);
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildMacGenCfg()
+uint8_t duBuildMacGenCfg()
{
RgMngmt rgMngmt;
RgGenCfg *genCfg=NULLP;
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;
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;
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;
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);
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildMacUsapCfg(SpId sapId)
+uint8_t duBuildMacUsapCfg(SpId sapId)
{
RgMngmt rgMngmt;
RgUpSapCfg *uSap = NULLP;
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;
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);
* 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);
+ 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");
- macCfgInst = 0;
- duBindUnbindRlcToMacSap(RLC_DL_INST, ABND);
+ macCfg = 0;
+ DU_LOG("\nDEBUG --> DU_APP : Completed sending Configs");
+ macCfgInst = 0;
+ duBindUnbindRlcToMacSap(RLC_DL_INST, ABND);
}
}
else
{
- DU_LOG("\nDU_APP : Config confirm NOK from MAC");
+ DU_LOG("\nERROR --> DU_APP : Config confirm NOK from MAC");
ret = RFAILED;
}
return ret;
* 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)
{
- 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;
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;
}
-/*******************************************************************
- *
- * @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
*
* ****************************************************************/
-S16 duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy)
+uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy)
{
- switch(ntfy->header.nType)
+ if(f1Params.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(BuildAndSendF1SetupReq() != ROK)
+ {
+ return RFAILED;
+ }
+ }
+ else if(ricParams.assocId == ntfy->u.assocChange.assocId)
+ {
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : Invalid assocId %d received", ntfy->u.assocChange.assocId);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* 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;
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;
}
*
* ****************************************************************/
-S16 duBuildEgtpCfgReq()
+uint8_t duBuildEgtpCfgReq()
{
- Pst pst;
- EgtpConfig egtpCfg;
-
- DU_LOG("\nDU_APP : Sending EGTP config request");
+ Pst pst;
+ EgtpConfig egtpCfg;
- cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig));
- cmMemcpy((U8 *)&egtpCfg, (U8 *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig));
-
- duFillEgtpPst(&pst, EVTCFGREQ);
- cmPkEgtpCfgReq(&pst, egtpCfg);
-
- RETVALUE(ROK);
+ DU_LOG("\nDEBUG --> DU_APP : Sending EGTP config request");
+
+ memset(&egtpCfg, 0, sizeof(EgtpConfig));
+ memcpy(&egtpCfg, &duCfgParam.egtpParams, sizeof(EgtpConfig));
+
+ duFillEgtpPst(&pst, EVTCFGREQ);
+ packEgtpCfgReq(&pst, egtpCfg);
+
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 duHdlEgtpCfgComplete(CmStatus cfm)
+uint8_t duHdlEgtpCfgComplete(CmStatus cfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if(cfm.status == LCM_PRIM_OK)
{
- DU_LOG("\nDU_APP : EGTP configuraton complete");
-#ifdef EGTP_TEST
+ DU_LOG("\nDEBUG --> DU_APP : EGTP configuraton complete");
duSendEgtpSrvOpenReq();
-#endif
}
else
{
- DU_LOG("\nDU_APP : EGTP configuraton failed");
+ DU_LOG("\nERROR --> DU_APP : EGTP configuraton failed");
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-
-S16 duSendEgtpSrvOpenReq()
+
+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);
- cmPkEgtpSrvOpenReq(&pst);
+ packEgtpSrvOpenReq(&pst);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
*
*****************************************************************/
-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");
-#ifdef EGTP_TEST
- 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);
+ uint8_t ret = ROK;
+
+ if(cfm.status == LCM_PRIM_OK)
+ {
+ DU_LOG("\nDEBUG --> DU_APP : EGTP server opened successfully");
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : EGTP server opening failed");
+ ret = RFAILED;
+ }
+
+ return (ret);
}
/*******************************************************************
*
* ****************************************************************/
-S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid)
+uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t teIdTobeMod, GtpTnlCfg *ueCbTnlCfg)
{
+ uint8_t ret =ROK;
Pst pst;
EgtpTnlEvt tnlEvt;
+ DU_LOG("\nDEBUG --> DU_APP : Sending EGTP tunnel management request for teId [%d]", ueCbTnlCfg->teId);
+
+ /* ADD/MOD/DEL per tunnel */
tnlEvt.action = action;
- tnlEvt.lclTeid = lclTeid;
- tnlEvt.remTeid = remTeid;
-
- DU_LOG("\nDU_APP : Sending EGTP tunnel management request");
-
+ tnlEvt.remTeid = ueCbTnlCfg->teId;
+ if(action != EGTP_TNL_MGMT_ADD)
+ {
+ tnlEvt.lclTeid = teIdTobeMod;
+ }
+ else
+ {
+ tnlEvt.lclTeid = ueCbTnlCfg->teId;
+ }
duFillEgtpPst(&pst, EVTTNLMGMTREQ);
- cmPkEgtpTnlMgmtReq(&pst, tnlEvt);
-
- RETVALUE(ROK);
+ ret = egtpTnlMgmtReq(&pst, tnlEvt);
+ return ret;
}
/*******************************************************************
* 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
- duSendEgtpDatInd();
-
- /* For testing purpose. TTI thread should actually be in L1 */
- duStartTtiThread();
-#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;
}
- RETVALUE(ret);
+ return (ret);
}
-#ifdef EGTP_TEST
/*******************************************************************
*
- * @brief Simulate RLC to EGTP data indication
+ * @brief Sends UL user data over to EGTP
*
* @details
*
* Function : duSendEgtpDatInd
*
- * Functionality:
- * Simulate RLC to EGTP data indication
+ * Functionality: Sends UL user data over to EGTP
*
- * @params[in]
+ * @params[in] UL data buffer
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-S16 duSendEgtpDatInd()
+uint8_t duSendEgtpDatInd(Buffer *mBuf)
{
- 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
- {
- DU_LOG("\nDU_APP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
- RETVALUE(RFAILED);
- }
- }
- else
- {
- DU_LOG("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
- }
-
- /* filling IPv4 header */
- CmIpv4Hdr ipv4Hdr;
- MsgLen mLen;
-
- mLen = 0;
- SFndLenMsg(mBuf, &mLen);
-
- cmMemset((U8 *)&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 */
- S16 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);
-
- /* 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 = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf);
-
-
+ /* Fill EGTP header */
egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
egtpMsg.msgHdr.nPdu.pres = FALSE;
egtpMsg.msgHdr.seqNum.pres = FALSE;
egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
egtpMsg.msgHdr.teId = 1;
egtpMsg.msg = mBuf;
+
+ egtpHdlDatInd(egtpMsg);
- SPrntMsg(mBuf, 0, 0);
+ return ROK;
- egtpHdlDatInd(egtpMsg);
-
- RETVALUE(ROK);
}
-#endif /* EGTP_TEST */
-
/**************************************************************************
* @brief Function to send configs to SCH
* RFAILED - failure
*
***************************************************************************/
-S16 duSendSchCfg()
+uint8_t duSendSchCfg()
{
RgMngmt rgMngmt;
RgSchInstCfg *cfg = NULLP;
/* 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
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;
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);
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
+ *
+ ***************************************************************************/
+uint8_t duLayerConfigComplete()
+{
+ uint8_t ret = ROK;
+
+ DU_LOG("\nINFO --> DU_APP : Configuring all Layer is complete");
+
+ if((ret = duSctpCfgReq(duCfgParam.sctpParams)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed configuring Sctp Params");
+ ret = RFAILED;
+ }
+ if((ret = duSctpAssocReq(F1_INTERFACE)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq F1");
+ ret = RFAILED;
+ }
+ if((ret = duSctpAssocReq(E2_INTERFACE)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to send AssocReq E2");
+ ret = RFAILED;
+ }
+
+ return (ret);
+}
+
/**************************************************************************
* @brief Function to handle SCH Config Confirm from MAC
*
* 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("\nDEBUG --> DU_APP : Received SCH CFG CFM at DU APP");
+ break;
+ }
+ default:
+ break;
}
}
- duSctpStartReq();
-
+ duLayerConfigComplete();
duBuildEgtpCfgReq();
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
*
* 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 *pMacCellCfg = NULLP;
+ MacCellCfg *duMacCellCfg = NULLP;
- DU_ALLOC(pMacCellCfg, sizeof(MacCellCfg));
- if(pMacCellCfg == NULLP)
+ 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.ptrMacCellCfg = pMacCellCfg;
+ /* store the address in the duCellCb so that we can free on confirm msg */
+ if(duCb.actvCellLst[cellId-1])
+ duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg;
+ else
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duMacCellCfg, sizeof(MacCellCfg));
+ return RFAILED;
+ }
/* copy the mac config structure from duCfgParams */
- memcpy(pMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
+ memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
- pMacCellCfg->transId = cmGetTransId(); /* 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 (*packMacCellCfgMt[pst.selector])(&pst, pMacCellCfg);
+ return (*packMacCellCfgOpts[pst.selector])(&pst, duMacCellCfg);
}
/**************************************************************************
* 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.ptrMacCellCfg->transId)
+ for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++)
+ {
+ if((duCb.actvCellLst[actvCellIdx]) && (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.ptrMacCellCfg,sizeof(MacCellCfg));
- duCb.ptrMacCellCfg = NULLP;
-
/* Build and send GNB-DU config update */
- ret = BuildAndSendDUConfigUpdate();
+ ret = BuildAndSendDUConfigUpdate(SERV_CELL_TO_MODIFY);
+
+ /* 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("\nERROR --> DU_APP : Mac 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("\nINFO --> DU 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("\nERROR --> DU 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])
+ {
+ 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(uint16_t cellId)
+{
+ Pst pst;
+ uint16_t cellIdx=0;
+ OduCellId *oduCellId = NULL;
+
+ DU_LOG("\nINFO --> DU APP : Building and Sending cell stop request to MAC");
+
+ GET_CELL_IDX(cellId, cellIdx);
+ if(duCb.actvCellLst[cellIdx] != NULLP)
+ {
+ /* Send Cell Stop Request to MAC */
+ DU_ALLOC_SHRABL_BUF(oduCellId, sizeof(OduCellId));
+ if(!oduCellId)
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): Memory allocation failed ");
+ return RFAILED;
+ }
+ memset(oduCellId, 0, sizeof(OduCellId));
+ oduCellId->cellId = duCb.actvCellLst[cellIdx]->cellId;
+
+ /* Fill Pst */
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP);
+
+ return (*packMacCellStopOpts[pst.selector])(&pst, oduCellId);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): cellId[%d] doesnot exists", cellId);
+ return RFAILED;
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @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("\nERROR --> DU APP : Invalid Cell Id %d in duHandleStopInd()", cellId->cellId);
+ }
+
+ if(duGetCellCb(cellId->cellId, &cellCb) != ROK)
+ return RFAILED;
+
+ if((cellCb->cellStatus == ACTIVATED) || (cellCb->cellStatus == DELETION_IN_PROGRESS))
+ {
+ DU_LOG("\nINFO --> DU APP : 5G-NR Cell %d is DOWN", cellId->cellId);
+ if(sendCellDeleteReqToMac(cellId->cellId) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU APP : duHandleStopInd(): Failed to send Cell delete req to MAC for\
+ cellId[%d]", cellId->cellId);
+ return RFAILED;
+ }
+
+
+#ifdef O1_ENABLE
+ DU_LOG("\nINFO --> DU APP : Raise cell down alarm for cell id=%d", cellId->cellId);
+ raiseCellAlrm(CELL_DOWN_ALARM_ID, cellId->cellId);
+ setCellOpState(cellId->cellId, DISABLED, INACTIVE);
+#endif
+ }
+
+ if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
+ DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, 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("\nINFO --> DU 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->ueId > 0)
+ {
+ ueCb = cellCb->ueCb[ulRrcMsgInfo->ueId -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->ueId -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 teIdx = 0;
+ EgtpMsg egtpMsg;
+ Buffer *mBuf;
+
+ DU_LOG("\nDEBUG --> DU APP : Received UL user data");
+
+ /* Fill EGTP header */
+ egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
+ egtpMsg.msgHdr.nPdu.pres = FALSE;
+ egtpMsg.msgHdr.seqNum.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
+
+ /* Fetch EGTP tunnel info */
+ for(teIdx = 0; teIdx < duCb.numTeId; teIdx++)
+ {
+ /*TODO: If multiple Cell Support is enables then CellId also needs to be validated alongwith ueId and DrbId*/
+ if((duCb.upTnlCfg[teIdx] != NULLP) && (duCb.upTnlCfg[teIdx]->ueId == ulUserData->ueId) && \
+ (duCb.upTnlCfg[teIdx]->drbId == ulUserData->rbId))
+ {
+ if(duCb.upTnlCfg[teIdx]->tnlCfg1)
+ {
+ egtpMsg.msgHdr.teId = duCb.upTnlCfg[teIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/
+ break;
+ }
+ }
+ }
+
+ if (ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) != ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : Failed to allocated buffer memory in DuProcRlcUlUserDataTrans");
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
+ return RFAILED;
+ }
+ oduCpyFixBufToMsg(ulUserData->userData, mBuf, ulUserData->msgLen);
+ ODU_PRINT_MSG(mBuf, 0, 0);
+ egtpMsg.msg = mBuf;
+ egtpHdlDatInd(egtpMsg);
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Free tempSLiceCfg stored in duCfgParams
+ *
+ * @details
+ *
+ * Function : duFreeTempSliceCfg
+ *
+ * Functionality: Free tempSLiceCfg stored in duCfgParams
+ *
+ * @params[in] Post structure,
+ *
+ * @return Void
+ *
+ * ****************************************************************/
+
+void duFreeTempSliceCfg()
+{
+ uint8_t policyIdx = 0, memberListTdx =0;
+ CopyOfRecvdSliceCfg *tempSliceCfg = &duCfgParam.tempSliceCfg;
+
+ if(tempSliceCfg->totalRrmPolicy)
+ {
+ for(policyIdx = 0; policyIdx<tempSliceCfg->totalRrmPolicy; policyIdx++)
+ {
+ if(tempSliceCfg->rrmPolicy[policyIdx]->numMemberList)
+ {
+ for(memberListTdx = 0; memberListTdx<tempSliceCfg->rrmPolicy[policyIdx]->numMemberList; memberListTdx++)
+ {
+ DU_FREE(tempSliceCfg->rrmPolicy[policyIdx]->memberList[memberListTdx], sizeof(PolicyMemberList));
+ }
+ DU_FREE(tempSliceCfg->rrmPolicy[policyIdx]->memberList, (tempSliceCfg->rrmPolicy[policyIdx]->numMemberList) * sizeof(PolicyMemberList*));
+ }
+ DU_FREE(tempSliceCfg->rrmPolicy[policyIdx], sizeof(RrmPolicy));
+ }
+ DU_FREE(tempSliceCfg->rrmPolicy, tempSliceCfg->totalRrmPolicy* sizeof(RrmPolicy*));
+ }
+ memset(tempSliceCfg, 0, sizeof(CopyOfRecvdSliceCfg));
+}
+
+/*******************************************************************
+ *
+ * @brief free the slice cfg rsp
+ *
+ * @details
+ *
+ * Function : duFreeSliceCfgRsp
+ *
+ * Functionality: free the slice cfg rsp
+ *
+ * @params[in] Post structure, MacSliceCfgRsp *cfgRsp
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+void duFreeSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
+{
+ uint8_t cfgIdx;
+
+ if(cfgRsp)
+ {
+ if(cfgRsp->numSliceCfgRsp)
+ {
+ for(cfgIdx = 0; cfgIdx<cfgRsp->numSliceCfgRsp; cfgIdx++)
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(MacSliceRsp));
+ }
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp->listOfSliceCfgRsp, cfgRsp->numSliceCfgRsp * sizeof(MacSliceRsp*));
+ }
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief process the slice cfg rsp received from MAC
+ *
+ * @details
+ *
+ * Function : DuProcMacSliceCfgRsp
+ *
+ * Functionality: process the slice cfg rsp received from MAC
+ *
+ * @params[in] Post structure, MacSliceCfgRsp *cfgRsp
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
+{
+ uint8_t cfgIdx = 0;
+
+ if(cfgRsp)
+ {
+ if(cfgRsp->listOfSliceCfgRsp)
+ {
+ for(cfgIdx = 0; cfgIdx<cfgRsp->numSliceCfgRsp; cfgIdx++)
+ {
+ if(cfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == MAC_DU_APP_RSP_OK)
+ {
+ duCb.sliceState = SLICE_CONFIGURED;
+ }
+ }
+ DU_LOG("\nINFO --> DU_APP : Slice Configuration is done sucessfully ");
+ }
+ duFreeSliceCfgRsp(pst, cfgRsp);
+ }
+ duFreeTempSliceCfg();
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill the slice configration and rrm policy ratio
+ * information received form O1
+ *
+ * @details
+ *
+ * Function : fillSliceCfgReCfgInfo
+ *
+ * Functionality: Fill the slice configration and recfg info
+ *
+ * @params[in] Post structure
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t fillSliceCfgReCfgInfo(MacSliceCfgReq *sliceCfgReq, RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
+{
+ uint8_t sliceIdx = 0, cfgIdx = 0, memberListIdx = 0;
+
+ if(totalRrmPolicy)
+ {
+ DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg, totalSliceCount*sizeof(MacSliceRrmPolicy*));
+ if(sliceCfgReq->listOfSliceCfg == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
+ return RFAILED;
+ }
+
+ for(sliceIdx = 0; sliceIdx<totalRrmPolicy; sliceIdx++)
+ {
+ for(memberListIdx = 0; memberListIdx<rrmPolicy[sliceIdx]->numMemberList; memberListIdx++)
+ {
+ DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy));
+ if(sliceCfgReq->listOfSliceCfg[cfgIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
+ return RFAILED;
+ }
+
+
+ memcpy(&sliceCfgReq->listOfSliceCfg[cfgIdx]->snssai, &rrmPolicy[sliceIdx]->memberList[memberListIdx]->snssai, sizeof(Snssai));
+
+ DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio));
+ if(sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
+ return RFAILED;
+ }
+
+ sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMaxRatio = rrmPolicy[sliceIdx]->policyMaxRatio;
+ sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMinRatio = rrmPolicy[sliceIdx]->policyMinRatio;
+ sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyDedicatedRatio = rrmPolicy[sliceIdx]->policyDedicatedRatio;
+ sliceCfgReq->numOfConfiguredSlice++;
+ cfgIdx++;
+ }
+ }
+ }
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill the slice configration and rrm policy related
+ * information received form O1
+ *
+ * @details
+ *
+ * Function : BuildAndSendSliceConfigReq
+ *
+ * Functionality: Fill the slice configration and rrm policy related
+ *
+ * @params[in] RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t
+ * totalSliceCnt
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendSliceConfigReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCnt)
+{
+ Pst pst;
+ MacSliceCfgReq *sliceCfgReq;
+
+ DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq));
+ if(sliceCfgReq == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq");
+ return RFAILED;
+ }
+ else
+ {
+ if(fillSliceCfgReCfgInfo(sliceCfgReq, rrmPolicy, totalRrmPolicy, totalSliceCnt) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to fill slice Configuration info in MacSliceCfgReq");
+ return RFAILED;
+ }
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_CFG_REQ);
+
+ DU_LOG("\nDEBUG --> DU_APP : Sending Slice Cfg Request to MAC ");
+ if((*packMacSliceCfgReqOpts[pst.selector])(&pst, sliceCfgReq) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to send Slice Cfg Req to MAC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceCfgReq, sizeof(MacSliceCfgReq));
+ }
+ }
+ return ROK;
+}
+
+
+/*******************************************************************
+ *
+ * @brief Fill the slice configration and rrm policy related
+ * information received form O1
+ *
+ * @details
+ *
+ * Function : BuildAndSendSliceReCfgReq
+ *
+ * Functionality: Fill the slice configration and rrm policy related
+ *
+ * @params[in] RrmPolicy rrmPolicy[], uint8_t totalSliceCount
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
+{
+ Pst pst;
+ MacSliceCfgReq *sliceReCfgReq = NULLP;
+
+ DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received");
+
+ DU_ALLOC_SHRABL_BUF(sliceReCfgReq, sizeof(MacSliceCfgReq));
+ if(sliceReCfgReq == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceReCfgReq");
+ return RFAILED;
+ }
+ else
+ {
+ if(fillSliceCfgReCfgInfo(sliceReCfgReq, rrmPolicy, totalRrmPolicy, totalSliceCount) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP: Failed to fill slice cfg request info");
+ return RFAILED;
+ }
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ);
+
+ DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC ");
+ if( (*packMacSliceReCfgReqOpts[pst.selector])(&pst, sliceReCfgReq) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceReCfgReq, sizeof(MacSliceCfgReq));
+ }
+ }
+ return ROK;
+}
+/*******************************************************************
+ *
+ * @brief process the slice ReCfg rsp received from MAC
+ *
+ * @details
+ *
+ * Function : DuProcMacSliceReCfgRsp
+ *
+ * Functionality: process the slice ReCfg rsp received from MAC
+ *
+ * @params[in] Post structure, MacSliceCfgRsp *ReCfgRsp
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+uint8_t DuProcMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *reCfgRsp)
+{
+ uint8_t cfgIdx = 0;
+
+ if(reCfgRsp)
+ {
+ if(reCfgRsp->listOfSliceCfgRsp)
+ {
+ for(cfgIdx = 0; cfgIdx < reCfgRsp->numSliceCfgRsp; cfgIdx++)
+ {
+ if(reCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == MAC_DU_APP_RSP_OK)
+ {
+ duCb.sliceState = SLICE_RECONFIGURED;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : Slice not available");
+ }
+ }
+ DU_LOG("\nINFO --> DU_APP : Slice ReCOnfiguration response received");
+ }
+ duFreeSliceCfgRsp(pst, reCfgRsp);
+ }
+ duFreeTempSliceCfg();
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Handles received Slice Metrics from RLC and forward it to O1
+*
+* @details
+*
+* Function : DuProcRlcSliceMetrics
+*
+* Functionality:
+* Handles received Slice Metrics from RLC and forward it to O1
+*
+* @params[in] Post structure pointer
+* SlicePmList *sliceStats
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t DuProcRlcSliceMetrics(Pst *pst, SlicePmList *sliceStats)
+{
+ uint8_t sliceRecord = 0;
+
+ DU_LOG("\nDEBUG --> DU APP : Received Slice Metrics");
+ if(sliceStats == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP : Empty Metrics");
+ return RFAILED;
+ }
+
+ for(sliceRecord = 0; sliceRecord < sliceStats->numSlice; sliceRecord++)
+ {
+ DU_LOG("\nINFO --> DU_APP: SliceIndx:%d, DlTput %.5lf, UlTput:%.5lf", sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier,\
+ sliceStats->sliceRecord[sliceRecord].ThpDl, sliceStats->sliceRecord[sliceRecord].ThpUl);
+ }
+#ifdef O1_ENABLE
+ if(sliceStats)
+ {
+ sendSliceMetric((SliceMetricList*) sliceStats);
+ }
+#endif
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool,sliceStats->sliceRecord, (sliceStats->numSlice) * (sizeof(SlicePm)));
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool,sliceStats, sizeof(SlicePmList));
+
+ return ROK;
+}
+
/**********************************************************************
End of file
**********************************************************************/