/* This file contains UE management handling functionality for DU APP */
#include "common_def.h"
#include "lrg.h"
+#include "du_tmr.h"
#include "lrg.x"
#include "ckw.h"
#include "ckw.x"
#include "legtp.h"
#include "du_app_mac_inf.h"
#include "du_app_rlc_inf.h"
+#include "du_e2ap_mgr.h"
#include "du_cfg.h"
#include "du_mgr.h"
#include "du_utils.h"
#include "CmInterface.h"
#endif
+DuRlcUeReestablishReq packRlcUeReestablishReqOpts[] =
+{
+ packDuRlcUeReestablishReq, /* Loose coupling */
+ RlcProcUeReestablishReq, /* TIght coupling */
+ packDuRlcUeReestablishReq /* Light weight-loose coupling */
+};
+
DuMacDlCcchInd packMacDlCcchIndOpts[] =
{
packMacDlCcchInd, /* Loose coupling */
packDuRlcUeDeleteReq /* Light weight-loose coupling */
};
+DuMacUeResetReq packMacUeResetReqOpts[] =
+{
+ packDuMacUeResetReq, /* Loose coupling */
+ MacProcUeResetReq, /* TIght coupling */
+ packDuMacUeResetReq /* Light weight-loose coupling */
+};
+
+/*******************************************************************
+ *
+ * @brief Processes UE's max retransmission information received from RLC
+ *
+ * @details
+ *
+ * Function : DuProcRlcMaxRetransInd
+ *
+ * Functionality:
+ * Processes max retransmission reached information received from RLC
+ *
+ * @params[in] Post structure
+ * Pointer to RlcMaxRetransInfo
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * *****************************************************************/
+
+uint8_t DuProcRlcMaxRetransInd(Pst *pst, RlcMaxRetransInfo *maxRetransInfo)
+{
+ uint8_t ueId = 0, ret = RFAILED;
+ uint16_t cellIdx = 0,crnti=0;
+
+ if(maxRetransInfo)
+ {
+ GET_CELL_IDX(maxRetransInfo->cellId, cellIdx);
+
+ if(duCb.actvCellLst[cellIdx]!=NULLP)
+ {
+ ueId = maxRetransInfo->ueId;
+ GET_CRNTI(crnti, ueId);
+ if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti == crnti)
+ {
+ /*TODO: complete the processing of max retransmission */
+ ret = ROK;
+ }
+ else
+ DU_LOG("\nERROR --> DU APP : DuProcRlcMaxRetransInd(): CRNTI [%d] not found", crnti);
+ }
+ else
+ DU_LOG("\nERROR --> DU APP : DuProcRlcMaxRetransInd(): Cell Id[%d] is not found", maxRetransInfo->cellId);
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, maxRetransInfo, sizeof(RlcMaxRetransInfo));
+
+ }
+ return ret;
+}
+
/******************************************************************
*
* @brief Function to return Drb LcId
DU_LOG("\nCall Flow: ENTEGTP -> ENTDUAPP : EVENT_HDL_RECV_DL_DATA\n");
#endif
- DU_LOG("\nDEBUG --> DU_APP : Processing DL data in duHdlEgtpDlData()");
+ DU_LOG("\nDEBUG --> DU_APP : Processing DL data in duHdlEgtpDlData()");
if(!egtpMsg->msg)
{
* RFAILED - failure
*
* ****************************************************************/
-uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, RlcUeCfg ueCfg, F1DlRrcMsg *f1DlRrcMsg)
+uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, DuRlcUeCfg ueCfg, F1DlRrcMsg *f1DlRrcMsg)
{
Pst pst;
uint8_t ret;
dlRrcMsgInfo->ueId = ueCfg.ueId;
for(lcIdx = 0; lcIdx <= MAX_NUM_LC; lcIdx++)
{
- if(ueCfg.rlcLcCfg[lcIdx].lcId == f1DlRrcMsg->srbId)
+ if(ueCfg.rlcLcCfg[lcIdx].rlcBearerCfg.lcId == f1DlRrcMsg->srbId)
{
dlRrcMsgInfo->lcId = f1DlRrcMsg->srbId;
break;
/* Filling post structure and sending msg */
FILL_PST_DUAPP_TO_RLC(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_TRANS_TO_RLC);
- DU_LOG("\nDEBUG --> DU_APP: Sending Dl RRC Msg to RLC \n");
+ DU_LOG("\nDEBUG --> DU_APP: Sending Dl RRC Msg to RLC \n");
ret = (*duSendDlRrcMsgToRlcOpts[pst.selector])(&pst, dlRrcMsgInfo);
if(ret != ROK)
{
{
ueFound = true;
ret = duBuildAndSendDlRrcMsgToRlc(duCb.actvCellLst[cellIdx]->cellId, \
- duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, dlRrcMsg);
+ duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg, dlRrcMsg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU_APP: duBuildAndSendDlRrcMsgToRlc() Failed for UE ID:%d", dlRrcMsg->gnbDuUeF1apId);
return RFAILED;
}
if(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0)
+ {
*(initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].k0) = 1;
+ }
initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].mappingType = MAPPING_TYPEA;
initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].startSymbol = PDSCH_START_SYMBOL;
initDlBwp->pdschCfg.timeDomRsrcAllociList[idx].symbolLength = PDSCH_LENGTH_SYMBOL;
*
*****************************************************************/
-uint8_t fillRlcSrb1LcCfg(RlcBearerCfg *rlcLcCfg)
+uint8_t fillRlcSrb1LcCfg(DuRlcBearerCfg *rlcLcCfg)
{
uint8_t ret = ROK;
- rlcLcCfg->rbId = SRB1_LCID;
- rlcLcCfg->rbType = RB_TYPE_SRB;
- rlcLcCfg->lcId = SRB1_LCID;
- rlcLcCfg->lcType = LCH_DCCH;
- rlcLcCfg->rlcMode = RLC_AM;
+ rlcLcCfg->rlcBearerCfg.rbId = SRB1_LCID;
+ rlcLcCfg->rlcBearerCfg.rbType = RB_TYPE_SRB;
+ rlcLcCfg->rlcBearerCfg.lcId = SRB1_LCID;
+ rlcLcCfg->rlcBearerCfg.lcType = LCH_DCCH;
+ rlcLcCfg->rlcBearerCfg.rlcMode = RLC_AM;
rlcLcCfg->configType = CONFIG_ADD;
- ret = fillDefaultRlcModeCfg(rlcLcCfg->rlcMode, rlcLcCfg);
- rlcLcCfg->isLcAddModRspSent = true;
+ ret = fillDefaultRlcModeCfg(rlcLcCfg->rlcBearerCfg.rlcMode, &rlcLcCfg->rlcBearerCfg);
+ rlcLcCfg->rlcBearerCfg.isLcAddModRspSent = true;
return ret;
}
* Functionality:
* Processes UE Reconfig Req to RLC UL
*
- * @params[in] Pointer to RlcUeCfg
+ * @params[in] Pointer to RlcUeRecfg
* @return ROK - success
* RFAILED - failure
*
*****************************************************************/
-uint8_t sendUeRecfgReqToRlc(RlcUeCfg *rlcUeCfg)
+uint8_t sendUeRecfgReqToRlc(RlcUeRecfg *rlcUeRecfg)
{
uint8_t ret;
Pst pst;
FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_REQ);
- if(rlcUeCfg)
+ if(rlcUeRecfg)
{
/* Processing one Ue at a time to RLC */
DU_LOG("\nDEBUG --> DU_APP: Sending Ue Reconfig Request to RLC UL");
- ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeCfg);
+ ret = (*packRlcUeReconfigReqOpts[pst.selector])(&pst, rlcUeRecfg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU_APP : Failed to send Ue Reconfig Req to RLC at sendUeRecfgReqToRlc()");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeRecfg, sizeof(RlcUeRecfg));
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: Received RlcUeCfg is NULL at sendUeRecfgReqToRlc()");
+ DU_LOG("\nERROR --> DU_APP: Received RlcUeRecfg is NULL at sendUeRecfgReqToRlc()");
ret = RFAILED;
}
return ret;
*
* @details
*
- * Function : fillRlcUeCfg
+ * Function : updateRlcUeCfg
*
* Functionality: Fills Rlc Bearer Cfg
*
*
*****************************************************************/
-uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t duUeF1apId, DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
+uint8_t updateRlcUeCfg(uint16_t cellId, uint8_t duUeF1apId, DuUeCfg *ueCfgDb, DuRlcUeCfg *rlcUeCfg)
{
uint8_t ret, dbIdx, lcIdx, cellIdx;
bool lcIdFound = false;
- RlcUeCfg *duRlcDb = NULLP;
+ DuRlcUeCfg *duRlcDb = NULLP;
ret = ROK;
rlcUeCfg->cellId = cellId;
if(ret == ROK)
rlcUeCfg->numLcs++;
else
- memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
+ memset(rlcUeCfg, 0, sizeof(DuRlcUeCfg));
}
else
{
/* Fetch RlcDb from DuUeCb */
GET_CELL_IDX(cellId, cellIdx);
- duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[rlcUeCfg->ueId-1].rlcUeCfg;
+ duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[rlcUeCfg->ueId-1].duRlcUeCfg;
duRlcDb->rlcUeCfgState = UE_CFG_INPROGRESS;
for(dbIdx = 0; (dbIdx < ueCfgDb->numRlcLcs && ret == ROK); dbIdx++)
{
- ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcMode, &ueCfgDb->rlcLcCfg[dbIdx]);
+ ret = fillDefaultRlcModeCfg(ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg.rlcMode, &ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg);
if(ret == RFAILED)
{
DU_LOG("\n ERROR --> DU APP : Failed to fill Rlc Mode at fillRlcUeCfg()");
- memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
+ memset(rlcUeCfg, 0, sizeof(DuRlcUeCfg));
return ret;
}
/* Fill Rlc Ue Cfg List for ADD/MOD/DEL */
for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++)
{
- if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId)
+ if(ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg.lcId == duRlcDb->rlcLcCfg[lcIdx].rlcBearerCfg.lcId)
{
lcIdFound = true;
if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)||
{
/* MOD */
ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */
- memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
- fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].snssai, ueCfgDb->rlcLcCfg[dbIdx].snssai,\
- &duRlcDb->rlcLcCfg[lcIdx].snssai,false);
+ memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(DuRlcBearerCfg));
+ fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].rlcBearerCfg.snssai, ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg.snssai,\
+ &duRlcDb->rlcLcCfg[lcIdx].rlcBearerCfg.snssai,false);
}
}
else
if(!lcIdFound)
{
/* ADD/ DEL Config Type */
- memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
- fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].snssai, ueCfgDb->rlcLcCfg[dbIdx].snssai, NULL, false);
+ memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(DuRlcBearerCfg));
+ fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].rlcBearerCfg.snssai, ueCfgDb->rlcLcCfg[dbIdx].rlcBearerCfg.snssai, NULL, false);
}
rlcUeCfg->numLcs++;
}
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
/* Filling Rlc Ue Config */
- memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, 0, sizeof(RlcUeCfg));
+ memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg, 0, sizeof(DuRlcUeCfg));
ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, NULL,
- &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg);
+ &duCb.actvCellLst[cellIdx]->ueCb[ueIdx].duRlcUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
/**********************************************************************************
*
- * @brief Fills Ue Cfg from DU DB to MacUeCfg
+ * @brief Fills Ue Cfg from DU DB to MacUeCreateReq
*
* @details
*
* Functionality: fills ue Cfg to be sent to MAC
*
* @params[in] DuMacUeCfg Pointer
- * MacUeCfg Pointer
+ * MacUeCreateReq Pointer
*
* @return ROK - success
* RFAILED - failure
* *******************************************************************************/
-void fillMacUeCfg(DuMacUeCfg *duMacUeCfg, MacUeCfg *macUeCfg)
+void fillMacUeCfg(DuMacUeCfg *duMacUeCfg, MacUeCreateReq *macUeCfg)
{
uint8_t lcIdx = 0;
}
}
+/**********************************************************************************
+ *
+ * @brief Fills Ue Cfg from DU DB to RLCUeCfg
+ *
+ * @details
+ *
+ * Function : fillRlcUeCfg
+ *
+ * Functionality: fills ue Cfg to be sent to RLC
+ *
+ * @params[in] DuRlcUeCfg Pointer
+ * RlcUeCreate Pointer
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ * *******************************************************************************/
+void fillRlcUeCfg(DuRlcUeCfg *duRlcUeCfg, RlcUeCreate *rlcUeCfg)
+{
+ uint8_t lcIdx = 0;
+
+ rlcUeCfg->cellId = duRlcUeCfg->cellId;
+ rlcUeCfg->ueId = duRlcUeCfg->ueId;
+
+ rlcUeCfg->numLcsToAdd = 0;
+ for(lcIdx = 0; lcIdx < duRlcUeCfg->numLcs; lcIdx++)
+ {
+ if(duRlcUeCfg->rlcLcCfg[lcIdx].configType == CONFIG_ADD)
+ {
+ memcpy(&rlcUeCfg->rlcLcCfgAdd[rlcUeCfg->numLcsToAdd], &duRlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg, sizeof(RlcBearerCfg));
+ rlcUeCfg->numLcsToAdd++;
+ }
+ }
+ return;
+}
+
/******************************************************************
*
* @brief Builds and Send UE Create Request to MAC
uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t gnbDuUeF1apId, uint16_t crnti, DuUeCfg *ueCfgDb, DuMacUeCfg *duMacUeCfg)
{
uint8_t ret = ROK;
- MacUeCfg *macUeCfg = NULLP;
+ MacUeCreateReq *macUeCfg = NULLP;
Pst pst;
memset(&pst, 0, sizeof(Pst));
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_CREATE_REQ);
/* Copying ueCb to a sharable buffer */
- DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCfg));
+ DU_ALLOC_SHRABL_BUF(macUeCfg, sizeof(MacUeCreateReq));
if(macUeCfg)
{
- memset(macUeCfg, 0, sizeof(MacUeCfg));
+ memset(macUeCfg, 0, sizeof(MacUeCreateReq));
fillMacUeCfg(duMacUeCfg, macUeCfg);
DU_LOG("\nDEBUG --> DU_APP: Sending UE create request to MAC");
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU_APP : Failure in sending Ue Create Req to MAC at duBuildAndSendUeCreateReqToMac()");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCfg));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macUeCfg, sizeof(MacUeCreateReq));
}
}
else
return ret;
}
+/*******************************************************************
+ *
+ * @brief fill k0 value in duCb
+ *
+ * @details
+ *
+ * Function : fillK0Values
+ * Functionality: update k0 value in duCb
+ *
+ * @params[in] PdschConfig *cuPdschCfg, PdschConfig *storePdschCfg
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t fillK0Values(PdschConfig *cuPdschCfg, PdschConfig *storePdschCfg)
+{
+ uint8_t numTimeDomRsrcAlloc, rsrcIdx;
+
+ if(cuPdschCfg)
+ {
+ if(storePdschCfg->numTimeDomRsrcAlloc)
+ {
+ numTimeDomRsrcAlloc = cuPdschCfg->numTimeDomRsrcAlloc;
+ for(rsrcIdx =0 ; rsrcIdx<numTimeDomRsrcAlloc; rsrcIdx++)
+ {
+ if(cuPdschCfg->timeDomRsrcAllociList[rsrcIdx].k0)
+ {
+ if(storePdschCfg->timeDomRsrcAllociList[rsrcIdx].k0)
+ {
+ *(storePdschCfg->timeDomRsrcAllociList[rsrcIdx].k0) = *(cuPdschCfg->timeDomRsrcAllociList[rsrcIdx].k0);
+ if(storePdschCfg->timeDomRsrcAllociList[rsrcIdx].k0 != cuPdschCfg->timeDomRsrcAllociList[rsrcIdx].k0)
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cuPdschCfg->timeDomRsrcAllociList[rsrcIdx].k0, sizeof(uint8_t));
+ }
+ else
+ {
+ (storePdschCfg->timeDomRsrcAllociList[rsrcIdx].k0) = (cuPdschCfg->timeDomRsrcAllociList[rsrcIdx].k0);
+ }
+ }
+ }
+ }
+ }
+ return ROK;
+}
+
/*******************************************************************
*
* @brief To update DuUeCb Mac Cfg
{
if(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschPresent)
{
+ /* update k0 values */
+ fillK0Values(&f1UeDb->duUeCfg.copyOfmacUeCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfg, &macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg);
fillStartSymbolAndLen(macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg.numTimeDomRsrcAlloc,\
&macUeCfg->spCellCfg.servCellCfg.initDlBwp.pdschCfg, NULL);
}
*
*****************************************************************/
-uint8_t fillRlcCfgToAddMod(RlcBearerCfg *lcCfg, RlcBearerCfg *f1UeDbLcCfg)
+uint8_t fillRlcCfgToAddMod(DuRlcBearerCfg *lcCfg, DuRlcBearerCfg *f1UeDbLcCfg)
{
lcCfg->configType = f1UeDbLcCfg->configType;
- lcCfg->rbId = f1UeDbLcCfg->rbId;
- lcCfg->rbType = f1UeDbLcCfg->rbType;
- lcCfg->lcId = f1UeDbLcCfg->lcId;
- lcCfg->lcType = f1UeDbLcCfg->lcType;
- lcCfg->rlcMode = f1UeDbLcCfg->rlcMode;
+ lcCfg->rlcBearerCfg.rbId = f1UeDbLcCfg->rlcBearerCfg.rbId;
+ lcCfg->rlcBearerCfg.rbType = f1UeDbLcCfg->rlcBearerCfg.rbType;
+ lcCfg->rlcBearerCfg.lcId = f1UeDbLcCfg->rlcBearerCfg.lcId;
+ lcCfg->rlcBearerCfg.lcType = f1UeDbLcCfg->rlcBearerCfg.lcType;
+ lcCfg->rlcBearerCfg.rlcMode = f1UeDbLcCfg->rlcBearerCfg.rlcMode;
- switch(lcCfg->rlcMode)
+ switch(lcCfg->rlcBearerCfg.rlcMode)
{
case RLC_AM :
{
- if(!lcCfg->u.amCfg)
+ if(!lcCfg->rlcBearerCfg.u.amCfg)
{
- DU_ALLOC_SHRABL_BUF(lcCfg->u.amCfg, sizeof(AmBearerCfg));
- if(!lcCfg->u.amCfg)
+ DU_ALLOC_SHRABL_BUF(lcCfg->rlcBearerCfg.u.amCfg, sizeof(AmBearerCfg));
+ if(!lcCfg->rlcBearerCfg.u.amCfg)
return RFAILED;
}
/* DL AM */
- lcCfg->u.amCfg->dlAmCfg.snLenDl = f1UeDbLcCfg->u.amCfg->dlAmCfg.snLenDl;
- lcCfg->u.amCfg->dlAmCfg.pollRetxTmr = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollRetxTmr;
- lcCfg->u.amCfg->dlAmCfg.pollPdu = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollPdu;
- lcCfg->u.amCfg->dlAmCfg.pollByte = f1UeDbLcCfg->u.amCfg->dlAmCfg.pollByte;
- lcCfg->u.amCfg->dlAmCfg.maxRetxTh = f1UeDbLcCfg->u.amCfg->dlAmCfg.maxRetxTh;
+ lcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.snLenDl = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.snLenDl;
+ lcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.pollRetxTmr = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.pollRetxTmr;
+ lcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.pollPdu = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.pollPdu;
+ lcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.pollByte = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.pollByte;
+ lcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.maxRetxTh = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->dlAmCfg.maxRetxTh;
/* UL AM */
- lcCfg->u.amCfg->ulAmCfg.snLenUl = f1UeDbLcCfg->u.amCfg->ulAmCfg.snLenUl;
- lcCfg->u.amCfg->ulAmCfg.reAssemTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.reAssemTmr;
- lcCfg->u.amCfg->ulAmCfg.statProhTmr = f1UeDbLcCfg->u.amCfg->ulAmCfg.statProhTmr;
+ lcCfg->rlcBearerCfg.u.amCfg->ulAmCfg.snLenUl = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->ulAmCfg.snLenUl;
+ lcCfg->rlcBearerCfg.u.amCfg->ulAmCfg.reAssemTmr = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->ulAmCfg.reAssemTmr;
+ lcCfg->rlcBearerCfg.u.amCfg->ulAmCfg.statProhTmr = f1UeDbLcCfg->rlcBearerCfg.u.amCfg->ulAmCfg.statProhTmr;
break;
}
case RLC_UM_BI_DIRECTIONAL :
{
- if(!lcCfg->u.umBiDirCfg)
+ if(!lcCfg->rlcBearerCfg.u.umBiDirCfg)
{
- DU_ALLOC_SHRABL_BUF(lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
- if(!lcCfg->u.umBiDirCfg)
+ DU_ALLOC_SHRABL_BUF(lcCfg->rlcBearerCfg.u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
+ if(!lcCfg->rlcBearerCfg.u.umBiDirCfg)
return RFAILED;
}
/* UL UM BI DIR INFO */
- lcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
- lcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr;
+ lcCfg->rlcBearerCfg.u.umBiDirCfg->ulUmCfg.snLenUlUm = f1UeDbLcCfg->rlcBearerCfg.u.umBiDirCfg->ulUmCfg.snLenUlUm;
+ lcCfg->rlcBearerCfg.u.umBiDirCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->rlcBearerCfg.u.umBiDirCfg->ulUmCfg.reAssemTmr;
/* DL UM BI DIR INFO */
- lcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm = f1UeDbLcCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm;
+ lcCfg->rlcBearerCfg.u.umBiDirCfg->dlUmCfg.snLenDlUm = f1UeDbLcCfg->rlcBearerCfg.u.umBiDirCfg->dlUmCfg.snLenDlUm;
break;
}
case RLC_UM_UNI_DIRECTIONAL_UL :
{
- if(!lcCfg->u.umUniDirUlCfg)
+ if(!lcCfg->rlcBearerCfg.u.umUniDirUlCfg)
{
- DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
- if(!lcCfg->u.umUniDirUlCfg)
+ DU_ALLOC_SHRABL_BUF(lcCfg->rlcBearerCfg.u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
+ if(!lcCfg->rlcBearerCfg.u.umUniDirUlCfg)
return RFAILED;
}
- lcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.snLenUlUm;
- lcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->u.umUniDirUlCfg->ulUmCfg.reAssemTmr;
+ lcCfg->rlcBearerCfg.u.umUniDirUlCfg->ulUmCfg.snLenUlUm = f1UeDbLcCfg->rlcBearerCfg.u.umUniDirUlCfg->ulUmCfg.snLenUlUm;
+ lcCfg->rlcBearerCfg.u.umUniDirUlCfg->ulUmCfg.reAssemTmr = f1UeDbLcCfg->rlcBearerCfg.u.umUniDirUlCfg->ulUmCfg.reAssemTmr;
break;
}
case RLC_UM_UNI_DIRECTIONAL_DL :
{
- if(!lcCfg->u.umUniDirDlCfg)
+ if(!lcCfg->rlcBearerCfg.u.umUniDirDlCfg)
{
- DU_ALLOC_SHRABL_BUF(lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
- if(!lcCfg->u.umUniDirDlCfg)
+ DU_ALLOC_SHRABL_BUF(lcCfg->rlcBearerCfg.u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
+ if(!lcCfg->rlcBearerCfg.u.umUniDirDlCfg)
return RFAILED;
}
- lcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm = f1UeDbLcCfg->u.umUniDirDlCfg->dlUmCfg.snLenDlUm;
+ lcCfg->rlcBearerCfg.u.umUniDirDlCfg->dlUmCfg.snLenDlUm = f1UeDbLcCfg->rlcBearerCfg.u.umUniDirDlCfg->dlUmCfg.snLenDlUm;
break;
}
default:
- DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcMode);
+ DU_LOG("\nERROR --> DU_APP: Invalid Rlc Mode %d at fillRlcCfgToAddMod()", lcCfg->rlcBearerCfg.rlcMode);
return RFAILED;
}
return ROK;
*
* ****************************************************************/
-uint8_t duUpdateRlcLcCfg(RlcUeCfg *rlcUeCfg, F1UeContextSetupDb *f1UeDb)
+uint8_t duUpdateRlcLcCfg(DuRlcUeCfg *rlcUeCfg, F1UeContextSetupDb *f1UeDb)
{
uint8_t ret, lcIdx, dbIdx, numLcs, lcDelIdx;
numLcs = rlcUeCfg->numLcs;
for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
{
- if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].lcId == rlcUeCfg->rlcLcCfg[lcIdx].lcId)
+ if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].rlcBearerCfg.lcId == rlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg.lcId)
{
if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_MOD)
{
DU_LOG("\nERROR --> DU APP : Failed to modify LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
break;
}
- fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].snssai, &rlcUeCfg->rlcLcCfg[lcIdx].snssai, true);
+ fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].rlcBearerCfg.snssai,\
+ &rlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg.snssai, true);
}
else if(f1UeDb->duUeCfg.rlcLcCfg[dbIdx].configType == CONFIG_DEL)
{
/* Free memory at matched lcIdx index */
- freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcIdx]);
+ freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg);
rlcUeCfg->numLcs--;
for(lcDelIdx = lcIdx; lcDelIdx < rlcUeCfg->numLcs; lcDelIdx++)
{
ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcDelIdx], &rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
- fillSnssaiInfo(NULL, rlcUeCfg->rlcLcCfg[lcDelIdx+1].snssai, &rlcUeCfg->rlcLcCfg[lcDelIdx].snssai,\
- true);
- freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1]);
+ fillSnssaiInfo(NULL, rlcUeCfg->rlcLcCfg[lcDelIdx+1].rlcBearerCfg.snssai,\
+ &rlcUeCfg->rlcLcCfg[lcDelIdx].rlcBearerCfg.snssai, true);
+ freeRlcLcCfg(&rlcUeCfg->rlcLcCfg[lcDelIdx+1].rlcBearerCfg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to delete LC at Idx %d in duUpdateRlcCfg()", lcDelIdx);
ret = fillRlcCfgToAddMod(&rlcUeCfg->rlcLcCfg[lcIdx], &f1UeDb->duUeCfg.rlcLcCfg[dbIdx]);
if(ret == ROK)
{
- fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].snssai, &rlcUeCfg->rlcLcCfg[ rlcUeCfg->numLcs].snssai,\
- true);
+ fillSnssaiInfo(NULL, f1UeDb->duUeCfg.rlcLcCfg[dbIdx].rlcBearerCfg.snssai,\
+ &rlcUeCfg->rlcLcCfg[rlcUeCfg->numLcs].rlcBearerCfg.snssai, true);
rlcUeCfg->numLcs++;
}
}
uint8_t duUpdateDuUeCbCfg(uint8_t ueId, uint8_t cellId)
{
- uint8_t ret = ROK, cellIdx = 0, crnti=0;
+ uint8_t ret = ROK;
+ uint16_t cellIdx = 0, crnti=0;
DuUeCb *ueCb = NULLP;
GET_CELL_IDX(cellId, cellIdx);
ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
/*Filling RLC Ue Cfg */
- ueCb->rlcUeCfg.cellId = cellId;
- ueCb->rlcUeCfg.ueId = ueId;
- ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb);
+ ueCb->duRlcUeCfg.cellId = cellId;
+ ueCb->duRlcUeCfg.ueId = ueId;
+ ret = duUpdateRlcLcCfg(&ueCb->duRlcUeCfg, ueCb->f1UeDb);
if(ret == ROK)
{
/*Filling MAC Ue Cfg */
/*******************************************************************
*
- * @brief Handle UE config response from MAC
+ * @brief Handle UE create response from MAC
*
* @details
*
- * Function : DuProcMacUeCfgRsp
+ * Function : DuProcMacUeCreateRsp
*
- * Functionality: Handle UE Config response from MAC
+ * Functionality: Handle UE Create response from MAC
*
- * @params[in] Pointer to MacUeCfgRsp and Pst
+ * @params[in] Pointer to MacUeCreateRsp and Pst
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t DuProcMacUeCfgRsp(Pst *pst, MacUeCfgRsp *cfgRsp)
+uint8_t DuProcMacUeCreateRsp(Pst *pst, MacUeCreateRsp *cfgRsp)
{
uint8_t ret = ROK;
uint16_t cellIdx;
if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].ueState == UE_HANDIN_IN_PROGRESS) &&
(duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duMacUeCfg.macUeCfgState == UE_CREATE_COMPLETE) &&
- (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_CREATE_COMPLETE))
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState == UE_CREATE_COMPLETE))
{
if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
{
if((duBuildAndSendRachRsrcReqToMac(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
{
DU_LOG("\nERROR --> DU APP : Failed to send RACH Resource Request to MAC");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCreateRsp));
return RFAILED;
}
}
else
{
DU_LOG("\nERROR -> DU APP : Failure in updating DU UE CB");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCreateRsp));
return RFAILED;
}
}
DU_LOG("\nERROR --> DU APP : MAC UE CFG Response for EVENT[%d]: FAILURE [DU UE F1AP ID : %d]", pst->event, cfgRsp->ueId);
ret = RFAILED;
}
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCreateRsp));
}
else
{
- DU_LOG("\nERROR --> DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCfgRsp()");
+ DU_LOG("\nERROR --> DU APP : Received MAC Ue Config Response is NULL at DuProcMacUeCreateRsp()");
ret = RFAILED;
}
return ret;
{
duCb.actvCellLst[cellIdx]->ueCb[reCfgRsp->ueId -1].duMacUeCfg.macUeCfgState = UE_RECFG_COMPLETE;
if((duCb.actvCellLst[cellIdx]->ueCb[reCfgRsp->ueId -1].duMacUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
- (duCb.actvCellLst[reCfgRsp->cellId -1]->ueCb[reCfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
+ (duCb.actvCellLst[reCfgRsp->cellId -1]->ueCb[reCfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
{
if((ret = duUpdateDuUeCbCfg(reCfgRsp->ueId, reCfgRsp->cellId)) == ROK)
{
*
* @params[in] cellId,
* ueId,
- * Pointer to RlcUeCfg
+ * Pointer to RlcUeCreate
* @return ROK - success
* RFAILED - failure
*
*****************************************************************/
-uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t gnbDuUeF1apId, DuUeCfg *ueCfgDb, RlcUeCfg *duRlcUeCfg)
+uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t gnbDuUeF1apId, DuUeCfg *ueCfgDb, DuRlcUeCfg *duRlcUeCfg)
{
uint8_t ret = ROK;
- RlcUeCfg *rlcUeCfg = NULLP;
+ RlcUeCreate *rlcUeCfg = NULLP;
Pst pst;
- ret = fillRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duRlcUeCfg);
+ ret = updateRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duRlcUeCfg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_CREATE_REQ);
/* Copying ueCfg to a sharable buffer */
- DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
+ DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCreate));
if(rlcUeCfg)
{
- memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
- memcpy(rlcUeCfg, duRlcUeCfg, sizeof(RlcUeCfg));
+ memset(rlcUeCfg, 0, sizeof(RlcUeCreate));
+ fillRlcUeCfg(duRlcUeCfg, rlcUeCfg);
+
/* Processing one Ue at a time to RLC */
DU_LOG("\nDEBUG --> DU_APP: Sending UE create request to RLC UL");
ret = (*packRlcUeCreateReqOpts[pst.selector])(&pst, rlcUeCfg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU_APP : Failure in sending Ue Create Req to RLC");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCfg));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, rlcUeCfg, sizeof(RlcUeCreate));
ret = RFAILED;
}
}
* @details
*
- * Function : DuProcRlcUeCfgRsp
+ * Function : DuProcRlcUeCreateRsp
*
* Functionality:
* Processes UE create Rsp received from RLC UL
* RFAILED - failure
*
*****************************************************************/
-uint8_t DuProcRlcUeCfgRsp(Pst *pst, RlcUeCfgRsp *cfgRsp)
+uint8_t DuProcRlcUeCreateRsp(Pst *pst, RlcUeCreateRsp *cfgRsp)
{
uint8_t ret = ROK;
if(pst->event == EVENT_RLC_UE_CREATE_RSP)
{
DU_LOG("\nINFO --> DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
- duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
+ duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].ueState == UE_HANDIN_IN_PROGRESS) &&
(duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duMacUeCfg.macUeCfgState == UE_CREATE_COMPLETE) &&
- (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_CREATE_COMPLETE))
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState == UE_CREATE_COMPLETE))
{
if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
{
if((duBuildAndSendRachRsrcReqToMac(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
{
DU_LOG("\nERROR --> DU APP : Failed to send RACH Resource Request to MAC");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(MacUeCfgRsp));
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCreateRsp));
return RFAILED;
}
}
else
{
DU_LOG("\nERROR --> DU APP : Failure in updating DU UE CB");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCreateRsp));
return RFAILED;
}
}
}
- else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP: RLC UE CREATE Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
+ pst->event, cfgRsp->ueId, cfgRsp->reason);
+ ret = RFAILED;
+ }
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCreateRsp));
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP: Received RLC Ue Create Response is NULL at DuProcRlcUeCreateRsp()");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Processes UE reconfig Rsp received from RLC UL
+ *
+ * @details
+ *
+
+ * Function : DuProcRlcUeReconfigRsp
+ *
+ * Functionality:
+ * Processes UE reconfig Rsp received from RLC UL
+ *
+ * @params[in] Post structure
+ * Pointer to RlcCfgCfm
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+uint8_t DuProcRlcUeReconfigRsp(Pst *pst, RlcUeReconfigRsp *cfgRsp)
+{
+ uint8_t ret = ROK;
+
+ if(cfgRsp)
+ {
+ if(cfgRsp->result == RLC_DU_APP_RSP_OK)
+ {
+ if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
{
DU_LOG("\nINFO --> DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
- duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
+ duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duMacUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
- (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].duRlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
{
if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
{
if((BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
{
DU_LOG("\nERROR --> DU APP : Failure in BuildAndSendUeCtxtRsp");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeReconfigRsp));
return RFAILED;
}
}
else
{
DU_LOG("\nERROR --> DU APP : Failure in updating DU UE CB");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeReconfigRsp));
return RFAILED;
}
}
}
else
{
- DU_LOG("\nERROR --> DU_APP: RLC UE CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
+ DU_LOG("\nERROR --> DU_APP: RLC UE RE-CFG Response for EVENT[%d] : FAILED [UE IDX : %d, REASON :%d]",\
pst->event, cfgRsp->ueId, cfgRsp->reason);
if((pst->event == EVENT_RLC_UE_RECONFIG_RSP))
{
}
ret = RFAILED;
}
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeCfgRsp));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cfgRsp, sizeof(RlcUeReconfigRsp));
}
else
{
- DU_LOG("\nERROR --> DU_APP: Received RLC Ue Config Response is NULL at DuProcRlcUeCfgRsp()");
+ DU_LOG("\nERROR --> DU_APP: Received RLC Ue ReConfig Response is NULL at DuProcRlcUeReconfigRsp()");
ret = RFAILED;
}
return ret;
}
+/**********************************************************************************
+ *
+ * @brief Fills Ue ReCfg from DU DB to RlcUeRecfg
+ *
+ * @details
+ *
+ * Function : fillRlcUeRecfg
+ *
+ * Functionality: fills ue ReCfg to be sent to RLC
+ *
+ * @params[in] DuRlcUeCfg Pointer
+ * RlcUeRecfg Pointer
+ *
+ * @return void
+ * *******************************************************************************/
+void fillRlcUeRecfg(DuRlcUeCfg *duRlcUeCfg, RlcUeRecfg *rlcUeRecfg)
+{
+ uint8_t lcIdx = 0;
+
+ rlcUeRecfg->cellId = duRlcUeCfg->cellId;
+ rlcUeRecfg->ueId = duRlcUeCfg->ueId;
+
+
+ if(duRlcUeCfg->numLcs > 0)
+ {
+ rlcUeRecfg->numLcsToAdd = 0;
+ rlcUeRecfg->numLcsToMod = 0;
+ rlcUeRecfg->numLcsToRel = 0;
+
+ for(lcIdx = 0; lcIdx < duRlcUeCfg->numLcs; lcIdx++)
+ {
+ if(duRlcUeCfg->rlcLcCfg[lcIdx].configType == CONFIG_ADD)
+ {
+ memcpy(&rlcUeRecfg->rlcLcCfgAdd[rlcUeRecfg->numLcsToAdd], &duRlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg, sizeof(RlcBearerCfg));
+ rlcUeRecfg->numLcsToAdd++;
+ }
+ if(duRlcUeCfg->rlcLcCfg[lcIdx].configType == CONFIG_MOD)
+ {
+ memcpy(&rlcUeRecfg->rlcLcCfgMod[rlcUeRecfg->numLcsToMod], &duRlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg, sizeof(RlcBearerCfg));
+ rlcUeRecfg->numLcsToMod++;
+ }
+ if(duRlcUeCfg->rlcLcCfg[lcIdx].configType == CONFIG_DEL)
+ {
+ memcpy(&rlcUeRecfg->rlcLcCfgRel[rlcUeRecfg->numLcsToRel], &duRlcUeCfg->rlcLcCfg[lcIdx].rlcBearerCfg, sizeof(RlcBearerCfg));
+ rlcUeRecfg->numLcsToRel++;
+ }
+ }
+ }
+ return;
+}
/*******************************************************************
*
*
* Functionality: Builds and Send Ue Reconfig Req to RLC
*
- * @params[in] cellId, crnti
+ * @params[in] uint16_t cellId,
+ * uint6_t crnti #AS per 38.473 V15.3.0, Section 9.3.1.32 crnti
+ * value range is b/w 0..65535#
* DuUeCfg *ueCfgDb
- * RlcUeCfg *rlcUeCfg
+ * RlcUeCreate *rlcUeCfg
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t duBuildAndSendUeRecfgReqToRlc(uint8_t cellId, uint8_t gnbDuUeF1apId, uint8_t crnti, DuUeCfg *ueCfgDb)
+uint8_t duBuildAndSendUeRecfgReqToRlc(uint16_t cellId, uint8_t gnbDuUeF1apId, uint16_t crnti, DuUeCfg *ueCfgDb)
{
uint8_t ret = ROK;
- RlcUeCfg *rlcUeCfg = NULLP;
+ DuRlcUeCfg *duRlcUeCfg = NULLP;
+ RlcUeRecfg *rlcUeRecfg = NULLP;
- DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
- if(rlcUeCfg)
+ DU_ALLOC(duRlcUeCfg, sizeof(DuRlcUeCfg));
+ DU_ALLOC_SHRABL_BUF(rlcUeRecfg, sizeof(RlcUeRecfg));
+ if(duRlcUeCfg && rlcUeRecfg)
{
- memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
- ret = fillRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, rlcUeCfg);
+ memset(duRlcUeCfg, 0, sizeof(DuRlcUeCfg));
+ memset(rlcUeRecfg, 0, sizeof(RlcUeRecfg));
+
+ ret = updateRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duRlcUeCfg);
+
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed at duBuildAndSendUeRecfgReqToRlc()");
else
- ret = sendUeRecfgReqToRlc(rlcUeCfg);
+ {
+ fillRlcUeRecfg(duRlcUeCfg, rlcUeRecfg);
+ ret = sendUeRecfgReqToRlc(rlcUeRecfg);
+ }
}
else
{
DU_LOG("\nERROR --> DU APP : Memory Alloc failed at duBuildAndSendUeRecfgReqToRlc()");
ret = RFAILED;
}
+ DU_FREE(duRlcUeCfg, sizeof(DuRlcUeCfg));
return ret;
}
*
* Functionality: Builds and Send Ue Reconfig Req to MAC
*
- * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
+ * @params[in] uint16_t cellId,
+ * uint6_t crnti #AS per 38.473 V15.3.0, Section 9.3.1.32 crnti
+ * value range is b/w 0..65535#
+ * CellGroupConfigRrc_t *macCellGrpCfg
* DuUeCfg *ueCfgDb
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t duBuildAndSendUeRecfgReqToMac(uint8_t cellId, uint8_t duUeF1apId, uint8_t crnti, DuUeCfg *ueCfgDb)
+uint8_t duBuildAndSendUeRecfgReqToMac(uint16_t cellId, uint8_t duUeF1apId, uint16_t crnti, DuUeCfg *ueCfgDb)
{
uint8_t ret = ROK;
DuMacUeCfg *duMacUeCfg = NULLP;
{
memset(duMacUeCfg, 0, sizeof(DuMacUeCfg));
memset(macUeRecfg, 0, sizeof(MacUeRecfg));
+
ret = updateDuMacUeCfg(cellId, duUeF1apId, crnti, ueCfgDb, duMacUeCfg);
- fillMacUeRecfg(duMacUeCfg, macUeRecfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeRecfgReqToMac()");
else
+ {
+ fillMacUeRecfg(duMacUeCfg, macUeRecfg);
ret = sendUeRecfgReqToMac(macUeRecfg);
+ }
}
else
{
ret = RFAILED;
}
DU_FREE(duMacUeCfg, sizeof(DuMacUeCfg));
-
+
return ret;
}
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
- ret = duBuildAndSendUeCreateReqToRlc(cellId, ueCb->gnbDuUeF1apId, duUeCfg, &ueCb->rlcUeCfg);
+ ret = duBuildAndSendUeCreateReqToRlc(cellId, ueCb->gnbDuUeF1apId, duUeCfg, &ueCb->duRlcUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
if(ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
{
/* Sending DL RRC Message to RLC */
- ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
+ ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->duRlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to send DL RRC msg in duProcUeContextSetupRequest()");
if(ueCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
{
/* Sending DL RRC Message to RLC */
- ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->rlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
+ ret = duBuildAndSendDlRrcMsgToRlc(cellId, ueCb->duRlcUeCfg, ueCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to send DL RRC msg in duProcUeContextModReq()");
if(duCb.actvCellLst[cellIdx] != NULLP)
{
if((duCb.actvCellLst[cellIdx]->ueCb[ueId-1].duMacUeCfg.macUeCfgState == UE_DELETE_COMPLETE)\
- &&(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg.rlcUeCfgState == UE_DELETE_COMPLETE))
+ &&(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].duRlcUeCfg.rlcUeCfgState == UE_DELETE_COMPLETE))
{
ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
deleteMacUeCfg(&ueCb->duMacUeCfg);
- deleteRlcUeCfg(&ueCb->rlcUeCfg);
+ deleteRlcUeCfg(&ueCb->duRlcUeCfg);
if(ueCb->f1UeDb !=NULLP)
{
freeF1UeDb(ueCb->f1UeDb);
if(deleteRsp)
{
- if(deleteRsp->result == DEL_SUCCESSFUL)
+ if(deleteRsp->status == SUCCESSFUL)
{
DU_LOG("\nINFO --> DU APP : MAC UE Delete Response : SUCCESS [UE IDX : %d]", deleteRsp->ueId);
GET_CELL_IDX(deleteRsp->cellId, cellIdx);
ueId = delRsp->ueId;
GET_CELL_IDX(delRsp->cellId, cellIdx);
- if(delRsp->result == SUCCESSFUL)
+ if(delRsp->status == SUCCESSFUL)
{
DU_LOG("\nINFO --> DU_APP: RLC UE Delete Response : SUCCESS [UE IDX:%d]", ueId);
if(duCb.actvCellLst[cellIdx]!=NULLP)
{
- duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg.rlcUeCfgState = UE_DELETE_COMPLETE;
+ duCb.actvCellLst[cellIdx]->ueCb[ueId-1].duRlcUeCfg.rlcUeCfgState = UE_DELETE_COMPLETE;
GET_CRNTI(crnti, ueId);
if(sendUeDeleteReqToMac(delRsp->cellId, ueId, crnti) == RFAILED)
{
/*******************************************************************
*
- * @brief delete RlcUeCfg from duCb
+ * @brief delete RlcUeCreate from duCb
*
* @details
*
* Function : deleteRlcUeCfg
*
* Functionality:
- * delete RlcUeCfg from duCb
+ * delete RlcUeCreate from duCb
*
- * @params[in] RlcUeCfg *ueCfg
+ * @params[in] RlcUeCreate *ueCfg
*
* @return ROK - success
* RFAILED - failure
*
*****************************************************************/
-void deleteRlcUeCfg(RlcUeCfg *ueCfg)
+void deleteRlcUeCfg(DuRlcUeCfg *ueCfg)
{
uint8_t lcIdx = 0;
RlcBearerCfg *lcCfg= NULLP;
{
for(lcIdx =0 ; lcIdx < ueCfg->numLcs ; lcIdx++)
{
- lcCfg = &ueCfg->rlcLcCfg[lcIdx];
+ lcCfg = &ueCfg->rlcLcCfg[lcIdx].rlcBearerCfg;
switch(lcCfg->rlcMode)
{
case RLC_AM :
}
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
}
- memset(ueCfg, 0, sizeof(RlcUeCfg));
+ memset(ueCfg, 0, sizeof(DuRlcUeCfg));
}
}
{
if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu != NULLP)
{
- ret = duBuildAndSendDlRrcMsgToRlc(cellId, duCb.actvCellLst[duUeCb->f1UeDb->cellIdx]->ueCb[ueId-1].rlcUeCfg,\
+ ret = duBuildAndSendDlRrcMsgToRlc(cellId, duCb.actvCellLst[duUeCb->f1UeDb->cellIdx]->ueCb[ueId-1].duRlcUeCfg,\
duUeCb->f1UeDb->dlRrcMsg);
if(ret == RFAILED)
{
return ret;
}
+/*******************************************************************
+ *
+ * @brief Sending UE Reset Req To Mac
+*
+* @details
+*
+* Function : sendUeResetReqToMac
+*
+* Functionality:
+* sending UE Reset Req To Mac
+*
+* @params[in] cellId, ueId, crnti
+* @return ROK - success
+* RFAILED - failure
+*
+*****************************************************************/
+
+uint8_t sendUeResetReqToMac(uint16_t cellId, uint8_t ueId)
+{
+ Pst pst;
+ uint8_t ret=ROK;
+ MacUeResetReq *ueReset = NULLP;
+
+ DU_ALLOC_SHRABL_BUF(ueReset, sizeof(MacUeResetReq));
+ if(ueReset)
+ {
+ ueReset->cellId = cellId;
+ ueReset->ueId = ueId;
+ FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_UE_RESET_REQ);
+
+ DU_LOG("\nDEBUG --> DU_APP: Sending UE Reset Request to MAC ");
+ ret = (*packMacUeResetReqOpts[pst.selector])(&pst, ueReset);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU_APP: sendUeResetReqToMac(): Failed to send UE Reset Req to MAC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueReset, sizeof(MacUeResetReq));
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP: sendUeResetReqToMac(): Failed to allocate memory");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief DU processes UE reset req and send it to MAC
+ *
+ * @details
+ *
+ * Function : duBuildAndSendUeResetReq
+ *
+ * Functionality: DU processes UE reset req and send to MAC
+ *
+ *
+ * @params[in] cellId, crnti
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t duBuildAndSendUeResetReq(uint16_t cellId, uint16_t crnti)
+{
+ uint8_t ueId =0;
+ uint16_t cellIdx = 0;
+
+ DU_LOG("\nDEBUG --> DU_APP : Building UE reset request");
+ GET_CELL_IDX(cellId, cellIdx);
+ GET_UE_ID(crnti, ueId);
+
+ if(duCb.actvCellLst[cellIdx] != NULLP)
+ {
+ if(crnti != duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].crnti)
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeResetReq(): CRNTI [%d] not found", crnti);
+ return RFAILED;
+ }
+
+ duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].ueState = UE_RESET_IN_PROGRESS;
+ if(sendUeResetReqToMac(cellId, ueId) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU APP : DuProcMacUeResetRsp(): Failed to build UE reset req for MAC ");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeResetReq(): Cell Id %d not found", cellId);
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Handle UE reset response from MAC
+*
+* @details
+*
+* Function : DuProcMacUeResetRsp
+*
+* Functionality: Handle UE reset response from MAC
+*
+* @params[in] Pointer to MacUeResetRsp and Pst
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+uint8_t DuProcMacUeResetRsp(Pst *pst, MacUeResetRsp *resetRsp)
+{
+ uint8_t ret =ROK;
+ uint16_t cellIdx=0;
+
+ if(resetRsp)
+ {
+ if(resetRsp->status == SUCCESSFUL)
+ {
+ DU_LOG("\nINFO --> DU APP : MAC UE Reset Response : SUCCESS [UE IDX : %d]", resetRsp->ueId);
+ GET_CELL_IDX(resetRsp->cellId, cellIdx);
+ if(duCb.actvCellLst[cellIdx])
+ {
+ duCb.actvCellLst[cellIdx]->ueCb[resetRsp->ueId -1].duMacUeCfg.macUeCfgState = UE_RESET_COMPLETE;
+ /*TODO - Complete the processing after receiving successfully reset rsp*/
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : DuProcMacUeResetRsp(): MAC UE Reset Response : FAILURE [UE IDX : %d]",resetRsp->ueId);
+ ret = RFAILED;
+ }
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, resetRsp, sizeof(MacUeResetRsp));
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : DuProcMacUeResetRsp(): MAC UE Reset Response is null");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+*
+* @brief Handle UE sync status indication from MAC
+*
+* @details
+*
+* Function : DuProcMacUeSyncStatusInd
+*
+* Functionality: Handle UE sync status indication from MAC
+*
+* @params[in] Pointer to MacUeSyncStatusInd and Pst
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+
+uint8_t DuProcMacUeSyncStatusInd(Pst *pst, MacUeSyncStatusInd *ueSyncStatusInd)
+{
+ uint8_t ret =RFAILED;
+ uint16_t cellIdx=0, crnti = 0;
+ char *status;
+
+ if(ueSyncStatusInd)
+ {
+ GET_CELL_IDX(ueSyncStatusInd->cellId, cellIdx);
+ if(duCb.actvCellLst[cellIdx])
+ {
+ GET_CRNTI(crnti, ueSyncStatusInd->ueId);
+ if(duCb.actvCellLst[cellIdx]->ueCb[ueSyncStatusInd->ueId-1].crnti == crnti)
+ {
+ switch(ueSyncStatusInd->status)
+ {
+ case IN_SYNC:
+ status = "IN_SYNC";
+ break;
+
+ case OUT_OF_SYNC:
+ status = "OUT_OF_SYNC";
+ break;
+
+ case OUT_OF_SUNC_MAX_RETRIES:
+ status = "OUT_OF_SUNC_MAX_RETRIES";
+ break;
+
+ default:
+ status = "INVALID";
+ break;
+
+ }
+ DU_LOG("\nINFO --> DU APP : MAC UE sync status for received UeId %d is %s", ueSyncStatusInd->ueId,status);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication : Ue Id [%d] not found",ueSyncStatusInd->cellId);
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication : Cell Id [%d] not found",ueSyncStatusInd->cellId);
+ }
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ueSyncStatusInd, sizeof(MacUeSyncStatusInd));
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : DuProcMacUeSyncStatusInd(): MAC UE sync status indication is null");
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Sending UE Reestablishment Req To Rlc
+ *
+ * @details
+ *
+ * Function : sendUeReestablishReqToRlc
+ *
+ * Functionality:
+ * Sending UE Reestablishment Req To Rlc
+ *
+ * @params[in] cellId, ueId
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+
+uint8_t sendUeReestablishReqToRlc(uint16_t cellId, uint8_t ueId, uint8_t numLcToReestablish, uint8_t *lcId)
+{
+ uint8_t ret=ROK,idx=0;
+ Pst pst;
+ RlcUeReestablishReq *ueReestablish;
+
+ DU_ALLOC_SHRABL_BUF(ueReestablish, sizeof(RlcUeReestablishReq));
+ if(ueReestablish !=NULLP)
+ {
+ ueReestablish->cellId = cellId;
+ ueReestablish->ueId = ueId;
+ ueReestablish->numLcsToReestablish = numLcToReestablish;
+
+ for(idx = 0;idx<numLcToReestablish; idx++)
+ {
+ ueReestablish->lcToReestablish[idx]= lcId[idx];
+ }
+ FILL_PST_DUAPP_TO_RLC(pst, RLC_UL_INST, EVENT_RLC_UE_REESTABLISH_REQ);
+
+ ret = (*packRlcUeReestablishReqOpts[pst.selector])(&pst, ueReestablish);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU_APP : sendUeReestablishReqToRlc():Failed to send UE Reestablishment Req to RLC");
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueReestablish, sizeof(RlcUeReestablishReq));
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP: sendUeReestablishReqToRlc():Memory allocation failed");
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief DU processes UE reestablishment req and sends to MAC and RLC
+ *
+ * @details
+ *
+ * Function : duBuildAndSendUeReestablishReq
+ *
+ * Functionality: DU processes UE reestablishment req and sends to MAC
+ * and RLC
+ *
+ * @params[in] cellId, crnti, numLcToReestablish, ListOflcid
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t duBuildAndSendUeReestablishReq(uint16_t cellId, uint16_t crnti, uint8_t numLcToReestablish, uint8_t *lcId)
+{
+ uint8_t ueId =0;
+ uint16_t cellIdx = 0;
+
+ DU_LOG("\nDEBUG --> DU_APP: Building UE Reestablishment Request ");
+ GET_CELL_IDX(cellId, cellIdx);
+ GET_UE_ID(crnti, ueId);
+
+ if(duCb.actvCellLst[cellIdx] != NULLP)
+ {
+ if(crnti != duCb.actvCellLst[cellIdx]->ueCb[ueId - 1].crnti)
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishReq(): CRNTI [%d] not found", crnti);
+ return RFAILED;
+ }
+
+ if(sendUeReestablishReqToRlc(cellId, ueId, numLcToReestablish, lcId) == RFAILED)
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishReq(): Failed to send UE reestablishment req for RLC ");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishReq(): Cell Id %d is not found", cellId);
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Processes UE Reestablishment Rsp received from RLC
+ *
+ * @details
+ *
+ * Function : DuProcRlcUeReestablishRsp
+ *
+ * Functionality:
+ * Processes UE Reestablishment Rsp received from RLC
+ *
+ * @params[in] Post structure
+ * Pointer to RlcUeReestablishRsp
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * *****************************************************************/
+
+uint8_t DuProcRlcUeReestablishRsp(Pst *pst, RlcUeReestablishRsp *ueReestablishRsp)
+{
+ uint8_t ueId = 0, ret = RFAILED;
+ uint16_t cellIdx = 0,crnti=0;
+
+ if(ueReestablishRsp)
+ {
+ ueId = ueReestablishRsp->ueId;
+ GET_CELL_IDX(ueReestablishRsp->cellId, cellIdx);
+
+ if(ueReestablishRsp->status == SUCCESSFUL)
+ {
+ if(duCb.actvCellLst[cellIdx]!=NULLP)
+ {
+ GET_CRNTI(crnti, ueId);
+ if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti == crnti)
+ {
+ /*TODO: complete the processing of UE Reestablishment Response */
+ DU_LOG("\nINFO --> DU_APP: RLC UE Reestablishment Response : SUCCESS [UE IDX:%d]", ueId);
+ ret = ROK;
+ }
+ else
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishRsp(): CRNTI [%d] not found", crnti);
+ }
+ else
+ DU_LOG("\nERROR --> DU APP : duBuildAndSendUeReestablishRsp(): Cell Id[%d] is not found", ueReestablishRsp->cellId);
+
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU_APP: RLC UE Reestablishment Response : FAILED [UE IDX:%d]", ueId);
+ }
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ueReestablishRsp, sizeof(RlcUeReestablishRsp));
+
+ }
+ return ret;
+}
/**********************************************************************
End of file
***********************************************************************/
Code Review / o-du / l2.git / blobdiff