/* This file contains message handling functionality for DU APP */
#include "common_def.h"
#include "lrg.h"
+#include "du_tmr.h"
#include "legtp.h"
#include "lkw.h"
#include "kwu.h"
#include "kwu.x"
#include "du_app_mac_inf.h"
#include "du_app_rlc_inf.h"
+#include "du_e2ap_mgr.h"
+#include "du_e2ap_msg_hdl.h"
#include "du_cfg.h"
#include "du_app_rlc_inf.h"
#include "du_mgr.h"
#ifdef O1_ENABLE
#include "AlarmInterface.h"
-#include "ConfigInterface.h"
+#include "CmInterface.h"
+#include "PmInterface.h"
#endif
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();
};
-DuMacSliceRecfgReq packMacSliceReCfgReqOpts[] =
+DuMacSliceRecfgReq packMacSliceRecfgReqOpts[] =
{
- packDuMacSliceRecfgReq, /* Loose coupling */
- MacProcSliceReCfgReq, /* TIght coupling */
- packDuMacSliceRecfgReq /* Light weight-loose coupling */
+ packDuMacSliceRecfgReq, /* Loose coupling */
+ MacProcSliceRecfgReq, /* TIght coupling */
+ packDuMacSliceRecfgReq /* Light weight-loose coupling */
};
+
+DuMacStatsReqFunc packMacStatsReqOpts[]=
+{
+ packDuMacStatsReq, /* Loose Coupling */
+ MacProcStatsReq, /* Tight Coupling */
+ packDuMacStatsReq /* Light weight-loose coupling */
+};
+
/**************************************************************************
* @brief Function to fill configs required by RLC
*
uint8_t duProcCfgComplete()
{
uint8_t ret = ROK;
- uint16_t cellId = 0;
uint16_t idx;
for(idx=0; idx< DEFAULT_CELLS; idx++)
{
{
uint8_t idx1=0;
memset(cell, 0, sizeof(DuCellCb));
- cell->cellId = ++cellId;
+ cell->cellId = NR_CELL_ID; //++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.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 = NR_PCI;
- cell->cellInfo.fiveGsTac = DU_TAC;
+ 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++)
{
- cell->cellInfo.plmn[idx1].mcc[0] = PLMN_MCC0;
- cell->cellInfo.plmn[idx1].mcc[1] = PLMN_MCC1;
- cell->cellInfo.plmn[idx1].mcc[2] = PLMN_MCC2;
- cell->cellInfo.plmn[idx1].mnc[0] = PLMN_MNC0;
- cell->cellInfo.plmn[idx1].mnc[1] = PLMN_MNC1;
+ cell->cellInfo.plmn[idx1].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;
- cell->gnbDuUeF1apIdGenerator = 0;
duCb.cfgCellLst[duCb.numCfgCells] = cell;
duCb.numCfgCells++;
}
/*----------- Fill General Configuration Parameters ---------*/
genCfg->mem.region = MAC_MEM_REGION;
genCfg->mem.pool = MAC_POOL;
- genCfg->tmrRes = 10;
+ genCfg->tmrRes = 1;
genCfg->numRguSaps = 2;
genCfg->lmPst.dstProcId = DU_PROC;
{
if(BuildAndSendF1SetupReq() != ROK)
{
- return RFAILED;
+ return RFAILED;
}
}
else if(ricParams.assocId == ntfy->u.assocChange.assocId)
{
- if(BuildAndSendE2SetupReq() != ROK)
- {
- return RFAILED;
- }
+ return ROK;
}
else
{
/* Filling of Gen config */
cfg->genCfg.mem.region = MAC_MEM_REGION;
cfg->genCfg.mem.pool = MAC_POOL;
- cfg->genCfg.tmrRes = 10;
+ cfg->genCfg.tmrRes = 1;
#ifdef LTE_ADV
cfg->genCfg.forceCntrlSrbBoOnPCel = FALSE;
}
/* store the address in the duCellCb so that we can free on confirm msg */
- duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg;
+ if(duCb.actvCellLst[cellId-1])
+ duCb.actvCellLst[cellId-1]->duMacCellCfg = duMacCellCfg;
+ else
+ {
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, duMacCellCfg, sizeof(MacCellCfg));
+ return RFAILED;
+ }
/* copy the mac config structure from duCfgParams */
memcpy(duMacCellCfg,&duCfgParam.macCellCfg,sizeof(MacCellCfg));
for(actvCellIdx = 0; actvCellIdx < MAX_NUM_CELL; actvCellIdx++)
{
- if(macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId)
+ if((duCb.actvCellLst[actvCellIdx]) && (macCellCfgCfm->cellId == duCb.actvCellLst[actvCellIdx]->cellId))
{
duCb.actvCellLst[actvCellIdx]->duMacCellCfg = NULLP;
}
uint8_t duBuildAndSendMacCellStart()
{
Pst pst;
- OduCellId *cellId = NULL;
+ CellStartInfo *cellStart = 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_ALLOC_SHRABL_BUF(cellStart, sizeof(CellStartInfo));
+ if(!cellStart)
{
DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request");
return RFAILED;
}
- for(uint8_t id = 0; id < duCb.numActvCells; id++)
+ for(uint8_t id = 0; id < MAX_NUM_CELL; id++)
{
if(duCb.actvCellLst[id])
{
- cellId->cellId = duCb.actvCellLst[id]->cellId;
+ cellStart->cellId = duCb.actvCellLst[id]->cellId;
- /* Fill Pst */
- FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START);
+ /* Fill Pst */
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START);
- return (*packMacCellStartOpts[pst.selector])(&pst, cellId);
+ return (*packMacCellStartOpts[pst.selector])(&pst, cellStart);
}
}
return ROK;
{
Pst pst;
uint16_t cellIdx=0;
- OduCellId *oduCellId = NULL;
-
+ CellStopInfo *cellStop = 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_ALLOC_SHRABL_BUF(cellStop, sizeof(CellStopInfo));
+ if(!cellStop)
{
- DU_LOG("\nERROR --> DU APP : duBuildAndSendMacCellStop(): Memory allocation failed ");
+ DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell stop request");
return RFAILED;
}
- memset(oduCellId, 0, sizeof(OduCellId));
- oduCellId->cellId = duCb.actvCellLst[cellIdx]->cellId;
+ memset(cellStop, 0, sizeof(CellStopInfo));
+ cellStop->cellId = duCb.actvCellLst[cellIdx]->cellId;
/* Fill Pst */
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_STOP);
- return (*packMacCellStopOpts[pst.selector])(&pst, oduCellId);
+ return (*packMacCellStopOpts[pst.selector])(&pst, cellStop);
}
else
{
* ****************************************************************/
uint8_t DuProcRlcUlRrcMsgTrans(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo)
{
+ uint8_t ret = ROK;
DuCellCb *cellCb = NULLP;
- DuUeCb ueCb ={0};
+ DuUeCb *ueCb = NULLP;
- if(duGetCellCb(ulRrcMsgInfo->cellId, &cellCb) != ROK)
- return RFAILED;
- if(ulRrcMsgInfo->ueIdx > 0)
+ duGetCellCb(ulRrcMsgInfo->cellId, &cellCb);
+ if(cellCb)
{
- ueCb = cellCb->ueCb[ulRrcMsgInfo->ueIdx -1];
+ if(ulRrcMsgInfo->ueId > 0)
+ {
+ if(cellCb->ueCb[ulRrcMsgInfo->ueId -1].gnbDuUeF1apId == ulRrcMsgInfo->ueId)
+ ueCb = &cellCb->ueCb[ulRrcMsgInfo->ueId -1];
+ if(ueCb)
+ {
+ /* If UL message is received for a UE in handover, it signifies that UE is now
+ * attached to GNB. Hence marking this UE as active and requesting MAC to
+ * release the dedicated RACH resources */
+ if(ueCb->ueState == UE_HANDIN_IN_PROGRESS)
+ {
+ ueCb->ueState = UE_ACTIVE;
+ cellCb->numActvUes++;
+
+ /* Release RACH resources */
+ memset(&ueCb->cfraResource, 0, sizeof(MacCfraResource));
+ if(duBuildAndSendRachRsrcRelToMac(ulRrcMsgInfo->cellId, ueCb) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to send RACH resource release to MAC");
+ }
+ }
- BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, \
- ulRrcMsgInfo->rrcMsg);
+ if(BuildAndSendULRRCMessageTransfer(ueCb, ulRrcMsgInfo->lcId, ulRrcMsgInfo->msgLen, ulRrcMsgInfo->rrcMsg) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Failed to build and send UL RRC Message Transfer");
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : UE ID [%d] not found", ulRrcMsgInfo->ueId);
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Invalid UE ID [%d]", ulRrcMsgInfo->ueId);
+ ret = RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcRlcUlRrcMsgTrans() : Cell ID [%d] not found", ulRrcMsgInfo->cellId);
+ ret = RFAILED;
+ }
DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo->rrcMsg, ulRrcMsgInfo->msgLen);
DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
- }
- return ROK;
+ return ret;
}
/*******************************************************************
if(duGetCellCb(rrcDeliveryReport->cellId, &cellCb) != ROK)
return RFAILED;
- ueCb = cellCb->ueCb[rrcDeliveryReport->ueIdx -1];
+ ueCb = cellCb->ueCb[rrcDeliveryReport->ueId -1];
ret = BuildAndSendRrcDeliveryReport(ueCb.gnbCuUeF1apId, ueCb.gnbDuUeF1apId,rrcDeliveryReport);
DU_FREE_SHRABL_BUF(pst->region, pst->pool, rrcDeliveryReport, sizeof(RrcDeliveryReport));
* ****************************************************************/
uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData)
{
- uint8_t rbIdx;
+ uint8_t teIdx = 0;
EgtpMsg egtpMsg;
Buffer *mBuf;
egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
/* Fetch EGTP tunnel info */
- for(rbIdx = 0; rbIdx < duCb.numDrb; rbIdx++)
+ for(teIdx = 0; teIdx < duCb.numTeId; teIdx++)
{
- if((duCb.upTnlCfg[rbIdx] != NULLP) && (duCb.upTnlCfg[rbIdx]->ueIdx == ulUserData->ueIdx) && \
- (duCb.upTnlCfg[rbIdx]->drbId == ulUserData->rbId))
+ /*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[rbIdx]->tnlCfg1)
+ if(duCb.upTnlCfg[teIdx]->tnlCfg1)
{
- egtpMsg.msgHdr.teId = duCb.upTnlCfg[rbIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/
+ egtpMsg.msgHdr.teId = duCb.upTnlCfg[teIdx]->tnlCfg1->teId; /*As we are supporting only 1 tunnel per DRB*/
break;
}
}
/*******************************************************************
*
- * @brief Free tempSLiceCfg stored in duCfgParams
+ * @brief process the slice cfg rsp received from MAC
*
* @details
*
- * Function : duFreeTempSliceCfg
+ * Function : DuProcMacSliceCfgRsp
*
- * Functionality: Free tempSLiceCfg stored in duCfgParams
+ * Functionality: process the slice cfg rsp received from MAC
*
- * @params[in] Post structure,
+ * @params[in] Post structure, MacSliceCfgRsp *cfgRsp
*
- * @return Void
+ * @return ROK - success
+ * RFAILED - failure
*
- * ****************************************************************/
-
-void duFreeTempSliceCfg()
+ **********************************************************************/
+uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
{
- uint8_t policyIdx = 0, memberListTdx =0;
- CopyOfRecvdSliceCfg *tempSliceCfg = &duCfgParam.tempSliceCfg;
-
- if(tempSliceCfg->totalRrmPolicy)
+ if(cfgRsp)
{
- for(policyIdx = 0; policyIdx<tempSliceCfg->totalRrmPolicy; policyIdx++)
+ if(cfgRsp->rsp == MAC_DU_APP_RSP_OK)
+ {
+ duCb.sliceState = SLICE_CONFIGURED;
+ DU_LOG("\nINFO --> DU_APP : Slice configured successfully ");
+ }
+ else
{
- 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_LOG("\nERROR --> DU_APP : Slice not available");
}
- DU_FREE(tempSliceCfg->rrmPolicy, tempSliceCfg->totalRrmPolicy* sizeof(RrmPolicy*));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp));
}
- memset(tempSliceCfg, 0, sizeof(CopyOfRecvdSliceCfg));
+ return ROK;
}
/*******************************************************************
*
- * @brief free the slice cfg rsp
+ * @brief Fill the slice configration and rrm policy related
+ * information received form O1
*
* @details
*
- * Function : duFreeSliceCfgRsp
+ * Function : BuildAndSendSliceConfigReq
*
- * Functionality: free the slice cfg rsp
+ * Functionality: Fill the slice configration and rrm policy related
*
- * @params[in] Post structure, MacSliceCfgRsp *cfgRsp
+ * @params[in] RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t
+ * totalSliceCnt
*
* @return ROK - success
* RFAILED - failure
*
- **********************************************************************/
-void duFreeSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
+ * ****************************************************************/
+uint8_t BuildAndSendSliceConfigReq()
{
- uint8_t cfgIdx;
+ Pst pst;
+ MacSliceCfgReq *sliceCfgReq;
- if(cfgRsp)
+ DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq));
+ if(sliceCfgReq == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq");
+ return RFAILED;
+ }
+ else
{
- if(cfgRsp->numSliceCfgRsp)
+ memcpy(sliceCfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceCfgReq));
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_CFG_REQ);
+
+ DU_LOG("\nDEBUG --> DU_APP : Sending Slice Cfg Request to MAC ");
+ if((*packMacSliceCfgReqOpts[pst.selector])(&pst, sliceCfgReq) == RFAILED)
{
- 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_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));
}
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacSliceCfgRsp));
}
- return ROK;
+ return ROK;
}
/*******************************************************************
*
- * @brief process the slice cfg rsp received from MAC
+ * @brief Fill the slice configration and rrm policy related
+ * information received form O1
*
* @details
*
- * Function : DuProcMacSliceCfgRsp
+ * Function : BuildAndSendSliceRecfgReq
*
- * Functionality: process the slice cfg rsp received from MAC
+ * Functionality: Fill the slice configration and rrm policy related
*
- * @params[in] Post structure, MacSliceCfgRsp *cfgRsp
+ * @params[in] RrmPolicy rrmPolicy[], uint8_t totalSliceCount
*
* @return ROK - success
* RFAILED - failure
*
- **********************************************************************/
-uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
+ * ****************************************************************/
+uint8_t BuildAndSendSliceRecfgReq()
{
- 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();
-}
+ Pst pst;
+ MacSliceRecfgReq *sliceRecfgReq = NULLP;
+
+ DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received");
+
+ DU_ALLOC_SHRABL_BUF(sliceRecfgReq, sizeof(MacSliceRecfgReq));
+ if(sliceRecfgReq == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceRecfgReq");
+ return RFAILED;
+ }
+ else
+ {
+ memcpy(sliceRecfgReq, &duCfgParam.tempSliceCfg, sizeof(MacSliceRecfgReq));
+
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ);
+ DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC ");
+ if( (*packMacSliceRecfgReqOpts[pst.selector])(&pst, sliceRecfgReq) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceRecfgReq, sizeof(MacSliceRecfgReq));
+ }
+ }
+ return ROK;
+}
/*******************************************************************
*
- * @brief Fill the slice configration and rrm policy ratio
- * information received form O1
+ * @brief process the slice ReCfg rsp received from MAC
*
* @details
*
- * Function : fillSliceCfgReCfgInfo
+ * Function : DuProcMacSliceRecfgRsp
*
- * Functionality: Fill the slice configration and recfg info
+ * Functionality: process the slice ReCfg rsp received from MAC
*
- * @params[in] Post structure
+ * @params[in] Post structure, MacSliceRecfgRsp *ReCfgRsp
*
* @return ROK - success
* RFAILED - failure
*
- * ****************************************************************/
-
-uint8_t fillSliceCfgReCfgInfo(MacSliceCfgReq *sliceCfgReq, RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
+ **********************************************************************/
+uint8_t DuProcMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *recfgRsp)
{
- uint8_t sliceIdx = 0, cfgIdx = 0, memberListIdx = 0;
-
- if(totalRrmPolicy)
+ if(recfgRsp)
{
- DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg, totalSliceCount*sizeof(MacSliceRrmPolicy*));
- if(sliceCfgReq->listOfSliceCfg == NULLP)
+ if(recfgRsp->rsp == MAC_DU_APP_RSP_OK)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
- return RFAILED;
+ duCb.sliceState = SLICE_RECONFIGURED;
+ DU_LOG("\nINFO --> DU_APP : Slice Reconfigured successfully ");
}
-
- for(sliceIdx = 0; sliceIdx<totalRrmPolicy; sliceIdx++)
+ else
{
- 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;
- }
+ DU_LOG("\nERROR --> DU_APP : Slice not available");
+ }
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, recfgRsp, sizeof(MacSliceCfgRsp));
+ }
+ return ROK;
+}
+/*******************************************************************
+*
+* @brief Handles received Slice Metrics from RLC and forward it to O1
+*
+* @details
+*
+* Function : DuProcRlcSliceMetrics
+*
+* Functionality:
+* Handles received Slice Metrics from RLC and forward it to O1
+*
+* @params[in] Post structure pointer
+* SlicePmList *sliceStats
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t DuProcRlcSliceMetrics(Pst *pst, SlicePmList *sliceStats)
+{
+ uint8_t sliceRecord = 0;
- memcpy(&sliceCfgReq->listOfSliceCfg[cfgIdx]->snssai, &rrmPolicy[sliceIdx]->memberList[memberListIdx]->snssai, sizeof(Snssai));
+ DU_LOG("\nDEBUG --> DU APP : Received Slice Metrics");
+ if(sliceStats == NULLP)
+ {
+ DU_LOG("\nERROR --> DU APP : Empty Metrics");
+ return RFAILED;
+ }
+
+ for(sliceRecord = 0; sliceRecord < sliceStats->numSlice; sliceRecord++)
+ {
+ DU_LOG("\nINFO --> DU_APP: SliceId[SST-SD]:%d-%d, DlTput %.5lf, UlTput:%.5lf", sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sst,\
+ sliceStats->sliceRecord[sliceRecord].networkSliceIdentifier.sd,sliceStats->sliceRecord[sliceRecord].ThpDl,\
+ sliceStats->sliceRecord[sliceRecord].ThpUl);
+ }
+#ifdef O1_ENABLE
+ if(sliceStats)
+ {
+ sendSliceMetric((SliceMetricList*) sliceStats);
+ }
+#endif
- DU_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;
- }
+ 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));
- 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
+ * @brief Send Statistics request to MAC
*
* @details
*
- * Function : BuildAndSendSliceConfigReq
+ * Function : BuildAndSendStatsReqToMac()
*
- * Functionality: Fill the slice configration and rrm policy related
+ * Functionality: Send Statistics Request To Mac
*
- * @params[in] RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t
- * totalSliceCnt
+ * @params[in]
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendSliceConfigReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCnt)
+uint8_t BuildAndSendStatsReqToMac(uint64_t subscriptionId, RicSubscription *ricSubscriptionInfo)
{
Pst pst;
- MacSliceCfgReq *sliceCfgReq;
-
- DU_ALLOC_SHRABL_BUF(sliceCfgReq, sizeof(MacSliceCfgReq));
- if(sliceCfgReq == NULLP)
+ uint8_t actionIdx = 0, grpIdx = 0, statsIdx = 0;
+ ActionInfo *actionDb = NULLP;
+ ActionDefFormat1 *format1Action = NULLP;
+ MacStatsReq *macStatsReq = NULLP;
+
+ /* Fill MAC statistics request */
+ DU_ALLOC_SHRABL_BUF(macStatsReq, sizeof(MacStatsReq));
+ if(macStatsReq == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed in BuildAndSendSliceConfigReq");
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed for macStatsReq in BuildAndSendStatsReqToMac");
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)
+ macStatsReq->subscriptionId = subscriptionId;
+ for(actionIdx = 0; actionIdx < ricSubscriptionInfo->numOfActions; actionIdx++)
+ {
+ if(ricSubscriptionInfo->actionSequence[actionIdx].action == CONFIG_ADD)
{
- 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));
+ actionDb = &ricSubscriptionInfo->actionSequence[actionIdx];
+ macStatsReq->statsGrpList[grpIdx].groupId = actionDb->id;
+ switch(actionDb->definition.formatType)
+ {
+ case 1:
+ {
+ format1Action = &actionDb->definition.choice.format1;
+ macStatsReq->statsGrpList[grpIdx].periodicity = format1Action->granularityPeriod;
+
+ CmLList *node = NULLP;
+ MeasurementInfo *measInfo = NULLP;
+ statsIdx = 0;
+ /* Update DL PRB Usage for all stats group which requested for DL Total PRB Usage */
+ node = cmLListFirst(&format1Action->measurementInfoList);
+ while(node)
+ {
+ measInfo = (MeasurementInfo *)(node->node);
+ switch(measInfo->measurementTypeId)
+ {
+ case 1:
+ {
+ macStatsReq->statsGrpList[grpIdx].statsList[statsIdx++] = MAC_DL_TOTAL_PRB_USAGE;
+ break;
+ }
+ case 2:
+ {
+ macStatsReq->statsGrpList[grpIdx].statsList[statsIdx++] = MAC_UL_TOTAL_PRB_USAGE;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> DU_APP : Invalid measurement name BuildAndSendStatsReqToMac");
+ break;
+ }
+ }
+ node = node->next;
+ }
+ macStatsReq->statsGrpList[grpIdx].numStats = statsIdx;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nERROR --> DU_APP : BuildAndSendStatsReqToMac: Only Action Definition Format 1 supported");
+ break;
+ }
+ }
+ if(macStatsReq->statsGrpList[grpIdx].numStats)
+ grpIdx++;
}
}
- return ROK;
+ macStatsReq->numStatsGroup = grpIdx;
+
+ if(macStatsReq->numStatsGroup)
+ {
+ DU_LOG("\nDEBUG --> DU_APP: Sending Statistics Request to MAC ");
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_STATISTICS_REQ);
+
+ if( (*packMacStatsReqOpts[pst.selector])(&pst, macStatsReq) == ROK)
+ return ROK;
+
+ DU_LOG("\nERROR --> DU_APP: Failed to send Statistics Request to MAC");
+ }
+
+ DU_LOG("\nERROR --> DU_APP: No Statistics group found valid. Hence statistics request is not sent to MAC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macStatsReq, sizeof(MacStatsReq));
+ return RFAILED;
}
+/*******************************************************************
+ *
+ * @brief Fetch statistics details from Action Definition Format 1
+ *
+ * @details
+ *
+ * Function : FetchStatsFromActionDefFormat1()
+ *
+ * Functionality: Fetch statistics details from Action
+ * Definition Format 1 received in an E2 message from
+ * RIC.
+ *
+ * @params[in] ActionDefFormat1
+ *
+ * @return Statistics
+ *
+ * ****************************************************************/
+Statistics FetchStatsFromActionDefFormat1(ActionDefFormat1 format1)
+{
+ Statistics stats;
+
+ /* TODO : When E2AP subscription procedure is implemented:
+ * Measurement info list is traveresed
+ * Based on KPI type, stats.macStatsReq or stats.rlcstatsReq is filled */
+
+ /* Hardcoding values for now for testing purpose
+ * Will be removed in next gerrit */
+ stats.macStatsReq.subscriptionId = 1;
+ stats.macStatsReq.numStatsGroup = 1;
+ stats.macStatsReq.statsGrpList[0].groupId = 1;
+ stats.macStatsReq.statsGrpList[0].periodicity = 100;
+ stats.macStatsReq.statsGrpList[0].numStats = 2;
+ stats.macStatsReq.statsGrpList[0].statsList[0] = MAC_DL_TOTAL_PRB_USAGE;
+ stats.macStatsReq.statsGrpList[0].statsList[1] = MAC_UL_TOTAL_PRB_USAGE;
+
+ return stats;
+}
/*******************************************************************
*
- * @brief Fill the slice configration and rrm policy related
- * information received form O1
+ * @brief Send Statistics request to DU layers
*
* @details
*
- * Function : BuildAndSendSliceReCfgReq
+ * Function : BuildAndSendStatsReq()
*
- * Functionality: Fill the slice configration and rrm policy related
+ * Functionality: Check if there is an update in statistics
+ * reporting configuration. If so, send the update to
+ * respective layer.
*
- * @params[in] RrmPolicy rrmPolicy[], uint8_t totalSliceCount
+ * @params[in] Subscription Info
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
+uint8_t BuildAndSendStatsReq(uint16_t ranFuncId, RicSubscription *ricSubscriptionInfo)
{
- Pst pst;
- MacSliceCfgReq *sliceReCfgReq = NULLP;
-
- DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received");
+ uint64_t subscriptionId = 0;
+
+ /* Calculate 64 bit subscription-ID :
+ * First 16 MSB is unused
+ * Next 16 MSB = RAN-Function-ID
+ * Next 16 MSB = Requestor-ID in RIC-Request-ID
+ * Last 16 LSB = Instance-ID in RIC-Request-ID
+ */
+ subscriptionId = ricSubscriptionInfo->requestId.instanceId;
+ subscriptionId |= ((uint64_t)ricSubscriptionInfo->requestId.requestorId << 16);
+ subscriptionId |= ((uint64_t)ranFuncId << 32);
+
+ /* Build and sent subscription information to MAC in Statistics Request */
+ if(BuildAndSendStatsReqToMac(subscriptionId, ricSubscriptionInfo) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToMac()");
+ return RFAILED;
+ }
- DU_ALLOC_SHRABL_BUF(sliceReCfgReq, sizeof(MacSliceCfgReq));
- if(sliceReCfgReq == NULLP)
+/* TODO : When KPI collection from RLC will be supported, this function will be
+ * called to configure KPIs to be colled */
+#if 0
+ if(BuildAndSendStatsReqToRlc() != ROK)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceReCfgReq");
+ DU_LOG("\nERROR --> DU_APP : Failed at BuildAndSendStatsReqToRlc()");
return RFAILED;
}
- else
+#endif
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Converts DU specific failure cause to E2 interface
+ * failure cause
+ *
+ * @details
+ *
+ * Function : convertDuCauseToE2Cause
+ *
+ * Functionality: Converts DU specific failure cause to E2
+ * interface failure cause
+ *
+ * @params[in] DU specific failure cause
+ * E2 specific failure cause
+ *
+ * @return void
+ *
+ * ****************************************************************/
+void convertDuCauseToE2Cause(CauseOfResult l2Cause, E2FailureCause *failureCause)
+{
+ switch(l2Cause)
+ {
+ case PARAM_INVALID:
+ {
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_ACTION_NOT_SUPPORTED;
+ break;
+ }
+ case RESOURCE_UNAVAILABLE:
+ {
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_FUNCTION_RESOURCE_LIMIT;
+ break;
+ }
+ default:
+ {
+ failureCause->causeType = E2_RIC_REQUEST;
+ failureCause->cause = E2_RIC_REQUEST_CAUSE_UNSPECIFIED;
+ break;
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Rejects all actions received in a subscription request
+ *
+ * @details
+ *
+ * Function : duRejectAllStatsGroup
+ *
+ * Functionality: Rejects all actions received in a subscription
+ * request by :
+ * a. Removing the subscription entry from RAN function
+ * b. Sending RIC Subscription Failure to RIC with appropriate
+ * cause of failure
+ *
+ * @params[in] RAN Function DB
+ * Subscription entry in RAN Function subscription list
+ * Statistics Response from MAC
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t duRejectAllStatsGroup(RanFunction *ranFuncDb, CmLList *ricSubscriptionNode, MacStatsRsp *statsRsp)
+{
+ uint8_t ret = ROK;
+ RicRequestId requestId;
+ E2FailureCause failureCause;
+
+ /* Delete subcription from RAN Function */
+ memcpy(&requestId, &((RicSubscription *)ricSubscriptionNode->node)->requestId, sizeof(RicRequestId));
+ cmLListDelFrm(&ranFuncDb->subscriptionList, ricSubscriptionNode);
+ DU_FREE(ricSubscriptionNode->node, sizeof(RicSubscription));
+ DU_FREE(ricSubscriptionNode, sizeof(CmLList));
+
+ convertDuCauseToE2Cause(statsRsp->statsGrpRejectedList[0].cause, &failureCause);
+
+ /* Send RIC subscription failure to RIC */
+ ret = BuildAndSendRicSubscriptionFailure(requestId, ranFuncDb->id, failureCause);
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Process statistics response from MAC
+ *
+ * @details
+ *
+ * Function : DuProcMacStatsRsp
+ *
+ * Functionality: Processes statistics configuration response
+ * from MAC. If configuration is succsessful, DUAPP starts
+ * reporting period timer for this subscription request
+ * from RIC
+ *
+ * @params[in]
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t DuProcMacStatsRsp(Pst *pst, MacStatsRsp *statsRsp)
+{
+ uint16_t ranFuncId = 0;
+ RicRequestId ricReqId;
+ RanFunction *ranFuncDb = NULLP;
+ CmLList *ricSubscriptionNode = NULLP;
+ RicSubscription *ricSubscriptionInfo = NULLP;
+
+ DU_LOG("\nINFO --> DU_APP : DuProcMacStatsRsp: Received Statistics Response from MAC");
+
+ if(statsRsp)
{
- if(fillSliceCfgReCfgInfo(sliceReCfgReq, rrmPolicy, totalRrmPolicy, totalSliceCount) != ROK)
+#ifdef DEBUG_PRINT
+ uint8_t idx = 0;
+ DU_LOG("\n Subscription Id [%ld]", statsRsp->subscriptionId);
+
+ DU_LOG("\n Number of Accepted Groups [%d]", statsRsp->numGrpAccepted);
+ for(idx=0; idx<statsRsp->numGrpAccepted; idx++)
{
- DU_LOG("\nERROR --> DU_APP: Failed to fill slice cfg request info");
+ DU_LOG("\n Group Id [%d]", statsRsp->statsGrpAcceptedList[idx]);
+ }
+
+ DU_LOG("\n Number of Rejected Groups [%d]", statsRsp->numGrpRejected);
+ for(idx=0; idx<statsRsp->numGrpRejected; idx++)
+ {
+ DU_LOG("\n Group Id [%d]", statsRsp->statsGrpRejectedList[idx]);
+ }
+#endif
+
+ /* Extract following from 64 bit subscription-ID :
+ * First 16 MSB is unused
+ * Next 16 MSB = RAN-Function-ID
+ * Next 16 MSB = Requestor-ID in RIC-Request-ID
+ * Last 16 LSB = Instance-ID in RIC-Request-ID
+ */
+ ricReqId.instanceId = statsRsp->subscriptionId & 0xFFFF;
+ ricReqId.requestorId = (statsRsp->subscriptionId >> 16) & 0xFFFF;
+ ranFuncId = (statsRsp->subscriptionId >> 32) & 0xFFFF;
+
+ /* Fetch RAN Function DB */
+ if(duCb.e2apDb.ranFunction[ranFuncId-1].id == ranFuncId)
+ {
+ ranFuncDb = &duCb.e2apDb.ranFunction[ranFuncId-1];
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcMacStatsRsp: Invalid RAN Function ID[%d] with Subscription ID [%ld]", \
+ ranFuncId, statsRsp->subscriptionId);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsRsp, sizeof(MacStatsRsp));
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)
+ /* Fetch subscription detail in RAN Function DB */
+ CM_LLIST_FIRST_NODE(&ranFuncDb->subscriptionList, ricSubscriptionNode);
+ while(ricSubscriptionNode)
{
- 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));
+ ricSubscriptionInfo = (RicSubscription *)ricSubscriptionNode->node;
+ if(ricSubscriptionInfo && (ricSubscriptionInfo->requestId.requestorId == ricReqId.requestorId) &&
+ (ricSubscriptionInfo->requestId.instanceId == ricReqId.instanceId))
+ {
+ break;
+ }
+ ricSubscriptionNode = ricSubscriptionNode->next;
}
+
+ if(ricSubscriptionNode == NULLP)
+ {
+ DU_LOG("\nERROR --> DU_APP : DuProcMacStatsRsp: Subscription not found for Requestor ID [%d] Instance ID [%d]",\
+ ricReqId.requestorId, ricReqId.instanceId);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsRsp, sizeof(MacStatsRsp));
+ return RFAILED;
+ }
+
+ /* If no action is accepted
+ * a. Remove subcription entry from RAN Function
+ * b. Send RIC subscription failure */
+ if(statsRsp->numGrpAccepted == 0)
+ {
+ duRejectAllStatsGroup(ranFuncDb, ricSubscriptionNode, statsRsp);
+ }
+
+ /* TODO :
+ * If even 1 action is accepted :
+ *
+ * For accepted groups:
+ * Mark scubscrbed-action's -> action = CONFIG_UNKNOWN
+ * Add action ID to accpeted-action-list in Subscription response
+ *
+ * For rejected groups:
+ * Remove entry from DU's RAN Function->subscription->actionList
+ * Add Rejected action Id to reject-action-list created by DU APP while
+ * processing of subscription request.
+ *
+ * Send subscription response with accepted and rejected action lists to
+ * RIC
+ */
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsRsp, sizeof(MacStatsRsp));
+ return ROK;
}
- return ROK;
+
+ DU_LOG("\nERROR --> DU_APP : DuProcMacStatsRsp: Received NULL Pointer");
+ return RFAILED;
}
+
/*******************************************************************
*
- * @brief process the slice ReCfg rsp received from MAC
+ * @brief Process statistics indication from MAC
*
* @details
*
- * Function : DuProcMacSliceReCfgRsp
+ * Function : DuProcMacStatsInd
*
- * Functionality: process the slice ReCfg rsp received from MAC
+ * Functionality: Processes statistics indication from MAC.
+ *
+ * @params[in]
*
- * @params[in] Post structure, MacSliceCfgRsp *ReCfgRsp
- *
* @return ROK - success
* RFAILED - failure
*
- **********************************************************************/
-uint8_t DuProcMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *reCfgRsp)
+ * ****************************************************************/
+uint8_t DuProcMacStatsInd(Pst *pst, MacStatsInd *statsInd)
{
- uint8_t cfgIdx = 0, sliceIdx =0;
-
- if(reCfgRsp)
+ if(statsInd)
{
- if(reCfgRsp->listOfSliceCfgRsp)
+#ifdef DEBUG_PRINT
+ DU_LOG("\nDEBUG --> DU_APP : DuProcMacStatsInd: Received Statistics Indication");
+ DU_LOG("\n Subscription Id [%ld]", statsInd->subscriptionId);
+ DU_LOG("\n Group Id [%d]", statsInd->groupId);
+ for(int idx = 0; idx < statsInd->numStats; idx++)
{
- 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");
+ DU_LOG("\n Meas type [%d] Meas Value [%lf]", statsInd->measuredStatsList[idx].type,\
+ statsInd->measuredStatsList[idx].value);
}
- duFreeSliceCfgRsp(pst, reCfgRsp);
+#endif
+
+ /* TODO : When stats indication is received
+ * DU APP searches for the message type in E2AP RIC subscription database
+ * and stores in the value in the list of subscribed measurements
+ *
+ * This will be implemented in next gerrit.
+ */
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, statsInd, sizeof(MacStatsInd));
+ return ROK;
}
- duFreeTempSliceCfg();
- return ROK;
+
+ DU_LOG("\nINFO --> DU_APP : DuProcMacStatsInd: Received NULL Pointer");
+ return RFAILED;
}
+
/**********************************************************************
End of file
**********************************************************************/