X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Frlc_msg_hdl.c;h=38f0456fa9da076f4c62505955ea7c75a6c19ffd;hb=HEAD;hp=9b33b26923c0099023bbcb3496693a7c26a312d3;hpb=9076bc05cb36d3ed99890b2e3f57f6d06f4a7e93;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/rlc_msg_hdl.c b/src/5gnrrlc/rlc_msg_hdl.c index 9b33b2692..38f0456fa 100644 --- a/src/5gnrrlc/rlc_msg_hdl.c +++ b/src/5gnrrlc/rlc_msg_hdl.c @@ -22,64 +22,119 @@ #include "lkw.h" /* LKW defines */ #include "ckw.h" /* CKW defines */ #include "kwu.h" /* KWU defines */ -#include "kw_env.h" /* RLC environment options */ -#include "kw.h" /* RLC defines */ -#include "kw_udx.h" -#include "kw_ul.h" -#include "kw_dl.h" +#include "rlc_env.h" /* RLC environment options */ +#include "rlc_err.h" + /* header/extern include files (.x) */ #include "rgu.x" #include "lkw.x" /* LKW */ #include "ckw.x" /* CKW */ #include "kwu.x" /* KWU */ -#include "kw_err.h" -#include "kw.x" -#include "kw_udx.x" -#include "kw_dl.x" -#include "kw_ul.x" +#include "rlc_utils.h" /* RLC defines */ +#include "rlc_dl_ul_inf.h" +#include "rlc_dl.h" +#include "rlc_ul.h" #include "rlc_mac_inf.h" #include "du_app_rlc_inf.h" -#include "rlc_utils.h" #include "rlc_upr_inf_api.h" +#include "rlc_mgr.h" + +/******************************************************************* + * + * @brief building and sending UE max retransmission info to DU + * + * @details + * + * Function : BuildAndSendRlcMaxRetransIndToDu + * + * Functionality: + * Building and sending UE max retransmission information to DU + * + * @params[in] uint8_t cellId, uint8_t ueId, CauseOfResult status + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t BuildAndSendRlcMaxRetransIndToDu(uint16_t cellId,uint8_t ueId, uint8_t lcId, uint8_t lcType) +{ + Pst pst; + RlcMaxRetransInfo *maxRetransInfo = NULLP; + + FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RLC_MAX_RETRANSMISSION); + + RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, maxRetransInfo, sizeof(RlcMaxRetransInfo)); + if(!maxRetransInfo) + { + DU_LOG("\nERROR --> RLC: sendRlcMaxRetransIndToDu(): Memory allocation failed "); + return RFAILED; + } + else + { + maxRetransInfo->cellId = cellId; + maxRetransInfo->ueId = ueId; + maxRetransInfo->lcId = lcId; + maxRetransInfo->lcType = lcType; + + if(rlcSendMaxRetransIndToDu(&pst, maxRetransInfo) == ROK) + { + DU_LOG("\nDEBUG --> RLC: UE [ %d] max retransmission information sent successfully",ueId); + } + else + { + DU_LOG("\nERROR --> RLC: SendRlcMaxRetransIndToDu(): fail to send UeId's[%d] maximum retransmission information", ueId); + RLC_FREE_SHRABL_BUF(pst.region, pst.pool, maxRetransInfo, sizeof(RlcMaxRetransInfo)); + return RFAILED; + } + } + return ROK; +} + /******************************************************************* * * @brief Fills RLC UL UE Cfg Rsp from RlcCRsp * * @details * - * Function : fillRlcUlUeCfgRsp + * Function : fillRlcUeCreateRsp * * Functionality: * Fills RLC UL UE Cfg Rsp from RlcCRsp * * @params[in] Pointer to RlcCfgCfm - * Pointer to RlcUeCfgRsp + * Pointer to RlcUeCreateRsp * - * @return void + * @return ROK/RFAILED * *****************************************************************/ -void fillRlcUlUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) +uint8_t fillRlcUeCreateRsp(RlcUeCreateRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) { uint8_t idx; + uint8_t ret = ROK; rlcCfgRsp->cellId = rlcCRsp->cellId; - rlcCfgRsp->ueIdx = rlcCRsp->ueId; + rlcCfgRsp->ueId = rlcCRsp->ueId; + rlcCfgRsp->result = RLC_DU_APP_RSP_OK; for(idx = 0; idx < rlcCRsp->numEnt; idx++) { if(rlcCRsp->entCfgCfm[idx].status.status == CKW_CFG_CFM_OK) { rlcCfgRsp->result = RLC_DU_APP_RSP_OK; rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason; + ret = ROK; } else { rlcCfgRsp->result = RLC_DU_APP_RSP_NOK; rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason; + ret = RFAILED; + break; } } + return ret; } /******************************************************************* @@ -104,117 +159,338 @@ void fillEntModeAndDir(uint8_t *entMode, uint8_t *direction, RlcMode rlcMode) switch(rlcMode) { case RLC_AM: - *entMode = CM_LTE_MODE_AM; + *entMode = RLC_MODE_AM; *direction = RLC_CFG_DIR_BOTH; break; case RLC_UM_BI_DIRECTIONAL: - *entMode = CM_LTE_MODE_UM; + *entMode = RLC_MODE_UM; *direction = RLC_CFG_DIR_BOTH; break; case RLC_UM_UNI_DIRECTIONAL_UL: - *entMode = CM_LTE_MODE_UM; + *entMode = RLC_MODE_UM; *direction = RLC_CFG_DIR_UL; break; case RLC_UM_UNI_DIRECTIONAL_DL: - *entMode = CM_LTE_MODE_UM; + *entMode = RLC_MODE_UM; *direction = RLC_CFG_DIR_DL; break; default : - DU_LOG("\nRLC: Rlc Mode invalid %d", rlcMode); + DU_LOG("\nERROR --> RLC: Rlc Mode invalid %d", rlcMode); break; } } + +/******************************************************************* + * + * @brief fills LC Cfgs to be Added in RLC + * + * @details + * + * Function : fillLcCfg + * + * Functionality: + * fills LC Cfgs to be Added in RLC + * + * @params[in] + * RlcEntCfgInfo pointer + * RlcBearerCfg pointer + * Config Type + * @return ROK - SUCCESS + * RFAILED - FAILURE + * + * ****************************************************************/ +uint8_t fillLcCfg(RlcCb *gCb, RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg) +{ + uint8_t lChRbIdx = 0; + + rlcUeCfg->rbId = duRlcUeCfg->rbId; + rlcUeCfg->rbType = duRlcUeCfg->rbType; // SRB or DRB + rlcUeCfg->lCh[lChRbIdx].lChId = duRlcUeCfg->lcId; + rlcUeCfg->lCh[lChRbIdx].type = duRlcUeCfg->lcType; + if(duRlcUeCfg->snssai) + { + RLC_ALLOC(gCb, rlcUeCfg->snssai, sizeof(Snssai)); + if(rlcUeCfg->snssai == NULLP) + { + DU_LOG("\nERROR --> RLC : fillLcCfg(): Failed to allocate memory for snssai"); + return RFAILED; + } + memcpy(rlcUeCfg->snssai, duRlcUeCfg->snssai, sizeof(Snssai)); + } + fillEntModeAndDir(&rlcUeCfg->entMode, &rlcUeCfg->dir, duRlcUeCfg->rlcMode); + switch(rlcUeCfg->entMode) + { + + case RLC_MODE_AM: + { + /* DL AM INFO */ + rlcUeCfg->m.amInfo.dl.snLen = duRlcUeCfg->u.amCfg->dlAmCfg.snLenDl; + rlcUeCfg->m.amInfo.dl.pollRetxTmr = duRlcUeCfg->u.amCfg->dlAmCfg.pollRetxTmr; + rlcUeCfg->m.amInfo.dl.pollPdu = duRlcUeCfg->u.amCfg->dlAmCfg.pollPdu; + rlcUeCfg->m.amInfo.dl.pollByte = duRlcUeCfg->u.amCfg->dlAmCfg.pollByte; + rlcUeCfg->m.amInfo.dl.maxRetx = duRlcUeCfg->u.amCfg->dlAmCfg.maxRetxTh; + + /* UL AM INFO */ + lChRbIdx++; //lChRbIdx = 1, indicates UL AM + rlcUeCfg->lCh[lChRbIdx].lChId = duRlcUeCfg->lcId; + rlcUeCfg->lCh[lChRbIdx].type = duRlcUeCfg->lcType; + rlcUeCfg->m.amInfo.ul.snLen = duRlcUeCfg->u.amCfg->ulAmCfg.snLenUl; + rlcUeCfg->m.amInfo.ul.staProhTmr = duRlcUeCfg->u.amCfg->ulAmCfg.statProhTmr; + rlcUeCfg->m.amInfo.ul.reAsmblTmr = duRlcUeCfg->u.amCfg->ulAmCfg.reAssemTmr; + break; + } + case RLC_MODE_UM: + { + /* UL UM CONFIG */ + rlcUeCfg->m.umInfo.ul.snLen = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm; + rlcUeCfg->m.umInfo.ul.reAsmblTmr = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr; + + /* DL UM CONFIG */ + rlcUeCfg->m.umInfo.dl.snLen = duRlcUeCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm; + break; + } + default: + break; + }/* End of switch(entMode) */ + return ROK; +} + +/******************************************************************* + * + * @brief fills LC Cfgs to be Added in RLC + * + * @details + * + * Function : fillRlcCfg + * + * Functionality: + * fills LC Cfgs to be Add in RLC + * + * @params[in] + * RlcEntCfgInfo pointer + * RlcBearerCfg pointer + * @return ROK - Success + * RFAILED - Failure + * + ******************************************************************/ + +uint8_t fillRlcCfg(RlcCb *gCb, RlcCfgInfo *rlcUeCfg, RlcUeCreate *ueCfg) +{ + uint8_t lcIdx; + + rlcUeCfg->ueId = ueCfg->ueId; + rlcUeCfg->cellId = ueCfg->cellId; + rlcUeCfg->numEnt = ueCfg->numLcsToAdd; + rlcUeCfg->transId = getTransId(); + for(lcIdx = 0; lcIdx < rlcUeCfg->numEnt; lcIdx++) + { + if(fillLcCfg(gCb, &rlcUeCfg->entCfg[lcIdx], &ueCfg->rlcLcCfgAdd[lcIdx]) != ROK) + { + DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration"); + return RFAILED; + } + rlcUeCfg->entCfg[lcIdx].cfgType = CONFIG_ADD; + } + return ROK; +} + +/******************************************************************* + * + * @brief updates LC Cfgs to be Added/Mod/Rel in RLC + * + * @details + * + * Function : updateRlcCfg + * + * Functionality: + * updates LC Cfgs to be Add/Mod/Del in RLC + * + * @params[in] + * RlcEntCfgInfo pointer + * RlcBearerCfg pointer + * @return ROK - Success + * RFAILED - Failure + * + ******************************************************************/ + +uint8_t updateRlcCfg(RlcCb *gCb, RlcCfgInfo *rlcUeCfg, RlcUeRecfg *ueRecfg) +{ + uint8_t lcIdx = 0; + + rlcUeCfg->ueId = ueRecfg->ueId; + rlcUeCfg->cellId = ueRecfg->cellId; + rlcUeCfg->transId = getTransId(); + + rlcUeCfg->numEnt = 0; + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToAdd; lcIdx++) + { + if(fillLcCfg(gCb, &rlcUeCfg->entCfg[rlcUeCfg->numEnt], &ueRecfg->rlcLcCfgAdd[lcIdx]) != ROK) + { + DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration"); + return RFAILED; + } + rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CONFIG_ADD; + rlcUeCfg->numEnt++; + } + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToMod; lcIdx++) + { + if(fillLcCfg(gCb, &rlcUeCfg->entCfg[rlcUeCfg->numEnt], &ueRecfg->rlcLcCfgMod[lcIdx]) != ROK) + { + DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration"); + return RFAILED; + } + rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CONFIG_MOD; + rlcUeCfg->numEnt++; + } + for(lcIdx = 0; lcIdx < ueRecfg->numLcsToRel; lcIdx++) + { + if(fillLcCfg(gCb, &rlcUeCfg->entCfg[rlcUeCfg->numEnt], &ueRecfg->rlcLcCfgRel[lcIdx]) != ROK) + { + DU_LOG("\nERROR --> RLC : fillRlcCfg(): Failed to fill LC configuration"); + return RFAILED; + } + rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CONFIG_DEL; + rlcUeCfg->numEnt++; + } + return ROK; +} + +/******************************************************************* + * + * @brief Fill RlcCfgCfmInfo structure for sending failure response to DU + * + * @details + * + * Function : fillRlcCfgFailureRsp + * + * Functionality: + * Fill RlcCfgCfmInfo structure for sending failure response to DU + * + * @params[in] RlcCfgCfmInfo *cfgRsp, RlcUeCreate *ueCfg + * + * @return void + * + * ****************************************************************/ +void fillRlcCfgFailureRsp(RlcCfgCfmInfo *cfgRsp, RlcUeCreate *ueCfg) +{ + uint8_t cfgIdx =0; + + cfgRsp->ueId = ueCfg->ueId; + cfgRsp->cellId = ueCfg->cellId; + cfgRsp->numEnt = ueCfg->numLcsToAdd; + for(cfgIdx =0; cfgIdxnumLcsToAdd; cfgIdx++) + { + cfgRsp->entCfgCfm[cfgIdx].rbId = ueCfg->rlcLcCfgAdd[cfgIdx].rbId; + cfgRsp->entCfgCfm[cfgIdx].rbType = ueCfg->rlcLcCfgAdd[cfgIdx].rbType; + cfgRsp->entCfgCfm[cfgIdx].status.status = RLC_DU_APP_RSP_NOK; + cfgRsp->entCfgCfm[cfgIdx].status.reason = CKW_CFG_REAS_NONE; + } +} + +/******************************************************************* + * + * @brief Fill RlcCfgCfmInfo structure for sending failure response to DU + * + * @details + * + * Function : fillRlcRecfgFailureRsp + * + * Functionality: + * Fill RlcCfgCfmInfo structure for sending failure response to DU + * + * @params[in] RlcCfgCfmInfo *cfgRsp, RlcUeCreate *ueCfg + * + * @return void + * + * ****************************************************************/ +void fillRlcRecfgFailureRsp(RlcCfgCfmInfo *cfgRsp, RlcUeRecfg *ueRecfg) +{ + uint8_t cfgIdx =0; + + cfgRsp->ueId = ueRecfg->ueId; + cfgRsp->cellId = ueRecfg->cellId; + cfgRsp->numEnt = 0; + for(cfgIdx =0; cfgIdxnumLcsToAdd; cfgIdx++) + { + cfgRsp->entCfgCfm[cfgRsp->numEnt].rbId = ueRecfg->rlcLcCfgAdd[cfgIdx].rbId; + cfgRsp->entCfgCfm[cfgRsp->numEnt].rbType = ueRecfg->rlcLcCfgAdd[cfgIdx].rbType; + cfgRsp->entCfgCfm[cfgRsp->numEnt].status.status = RLC_DU_APP_RSP_NOK; + cfgRsp->entCfgCfm[cfgRsp->numEnt].status.reason = CKW_CFG_REAS_NONE; + cfgRsp->numEnt++; + } + for(cfgIdx =0; cfgIdxnumLcsToMod; cfgIdx++) + { + cfgRsp->entCfgCfm[cfgRsp->numEnt].rbId = ueRecfg->rlcLcCfgMod[cfgIdx].rbId; + cfgRsp->entCfgCfm[cfgRsp->numEnt].rbType = ueRecfg->rlcLcCfgMod[cfgIdx].rbType; + cfgRsp->entCfgCfm[cfgRsp->numEnt].status.status = RLC_DU_APP_RSP_NOK; + cfgRsp->entCfgCfm[cfgRsp->numEnt].status.reason = CKW_CFG_REAS_NONE; + cfgRsp->numEnt++; + } + for(cfgIdx =0; cfgIdxnumLcsToRel; cfgIdx++) + { + cfgRsp->entCfgCfm[cfgRsp->numEnt].rbId = ueRecfg->rlcLcCfgRel[cfgIdx].rbId; + cfgRsp->entCfgCfm[cfgRsp->numEnt].rbType = ueRecfg->rlcLcCfgRel[cfgIdx].rbType; + cfgRsp->entCfgCfm[cfgRsp->numEnt].status.status = RLC_DU_APP_RSP_NOK; + cfgRsp->entCfgCfm[cfgRsp->numEnt].status.reason = CKW_CFG_REAS_NONE; + cfgRsp->numEnt++; + } +} + /******************************************************************* * * @brief Handles Ue Create Request from DU APP * * @details * - * Function : RlcUlProcUeCreateReq + * Function : RlcProcUeCreateReq * * Functionality: * Handles Ue create Request from DU APP * * @params[in] Post structure pointer - * RlcUeCfg pointer + * RlcUeCreate pointer * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t RlcUlProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) +uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCreate *ueCfg) { - uint8_t idx; uint8_t ret = ROK; - uint8_t lChRbIdx; + RlcCb *gCb; RlcCfgInfo *rlcUeCfg = NULLP; + RlcCfgCfmInfo cfgRsp; + Pst rspPst; - RlcCb *rlcUeCb = NULLP; - rlcUeCb = RLC_GET_RLCCB(pst->dstInst); - RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo)); - if(rlcUeCfg) + gCb = RLC_GET_RLCCB(pst->dstInst); + RLC_ALLOC(gCb, rlcUeCfg, sizeof(RlcCfgInfo)); + if(rlcUeCfg == NULLP) + { + DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeCreateReq()"); + ret = RFAILED; + } + else { memset(rlcUeCfg, 0, sizeof(RlcCfgInfo)); + ret = fillRlcCfg(gCb, rlcUeCfg, ueCfg); + if(ret != ROK) + { + DU_LOG("\nERROR --> RLC: Failed to fill configuration at RlcProcUeCreateReq()"); + FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_CREATE_RSP); + fillRlcCfgFailureRsp(&cfgRsp, ueCfg); + SendRlcUeCreateRspToDu(&rspPst, &cfgRsp); - rlcUeCfg->ueId = ueCfg->ueIdx; - rlcUeCfg->cellId = ueCfg->cellId; - rlcUeCfg->numEnt = ueCfg->numLcs; - rlcUeCfg->transId = getTransId(); - - for(idx = 0; idx < ueCfg->numLcs; idx++) - { - lChRbIdx = 0; - rlcUeCfg->entCfg[idx].rbId = ueCfg->rlcBearerCfg[idx].rbId; - rlcUeCfg->entCfg[idx].rbType = ueCfg->rlcBearerCfg[idx].rbType; // SRB or DRB - rlcUeCfg->entCfg[idx].lCh[lChRbIdx].lChId = ueCfg->rlcBearerCfg[idx].lcId; - rlcUeCfg->entCfg[idx].lCh[lChRbIdx].type = ueCfg->rlcBearerCfg[idx].lcType; - fillEntModeAndDir(&rlcUeCfg->entCfg[idx].entMode, &rlcUeCfg->entCfg[idx].dir,\ - ueCfg->rlcBearerCfg[idx].rlcMode); - rlcUeCfg->entCfg[idx].cfgType = CKW_CFG_ADD; - switch(rlcUeCfg->entCfg[idx].entMode) - { - - case CM_LTE_MODE_AM: - { - /* DL AM INFO */ - rlcUeCfg->entCfg[idx].m.amInfo.dl.snLen = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.snLenDl; - rlcUeCfg->entCfg[idx].m.amInfo.dl.pollRetxTmr = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.pollRetxTmr; - rlcUeCfg->entCfg[idx].m.amInfo.dl.pollPdu = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.pollPdu; - rlcUeCfg->entCfg[idx].m.amInfo.dl.pollByte = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.pollByte; - rlcUeCfg->entCfg[idx].m.amInfo.dl.maxRetx = ueCfg->rlcBearerCfg[idx].u.amCfg.dlAmCfg.maxRetxTh; - - /* UL AM INFO */ - lChRbIdx++; //lChRbIdx = 1, indicates UL AM - rlcUeCfg->entCfg[idx].lCh[lChRbIdx].lChId = ueCfg->rlcBearerCfg[idx].lcId; - rlcUeCfg->entCfg[idx].lCh[lChRbIdx].type = ueCfg->rlcBearerCfg[idx].lcType; - rlcUeCfg->entCfg[idx].m.amInfo.ul.snLen = ueCfg->rlcBearerCfg[idx].u.amCfg.ulAmCfg.snLenUl; - rlcUeCfg->entCfg[idx].m.amInfo.ul.staProhTmr = ueCfg->rlcBearerCfg[idx].u.amCfg.ulAmCfg.statProhTmr; - rlcUeCfg->entCfg[idx].m.amInfo.ul.reOrdTmr = ueCfg->rlcBearerCfg[idx].u.amCfg.ulAmCfg.reAssemTmr; - break; - } - case CM_LTE_MODE_UM: - { - /* UL UM CONFIG */ - rlcUeCfg->entCfg[idx].m.umInfo.ul.snLen = ueCfg->rlcBearerCfg[idx].u.umBiDirCfg.ulUmCfg.snLenUlUm; - rlcUeCfg->entCfg[idx].m.umInfo.ul.reOrdTmr = ueCfg->rlcBearerCfg[idx].u.umBiDirCfg.ulUmCfg.reAssemTmr; - - /* DL UM CONFIG */ - rlcUeCfg->entCfg[idx].m.umInfo.dl.snLen = ueCfg->rlcBearerCfg[idx].u.umBiDirCfg.dlUmCfg.snLenDlUm; - break; - } - default: - break; - }/* End of switch(entMode) */ - } - ret = RlcProcCfgReq(pst, rlcUeCfg); } else { - DU_LOG("\nRLC: Failed to allocate memory "); - ret = RFAILED; + ret = RlcProcCfgReq(pst, rlcUeCfg); + if(ret != ROK) + DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()"); } - RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg)); - return ret; + } + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCreate)); + return ret; } + /******************************************************************* * * @brief filling the structure of rrc delivery msg info @@ -233,14 +509,14 @@ uint8_t BuildAndSendRrcDeliveryReportToDu( RlcDlRrcMsgInfo *dlRrcMsgInfo ) { Pst pst; RrcDeliveryReport *rrcDelivery; - - DU_LOG("\nRLC : Filling the RRC Delivery Report"); + + DU_LOG("\nINFO --> RLC : Filling RRC Delivery Report"); RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, rrcDelivery, sizeof(RrcDeliveryReport)); if(rrcDelivery) { rrcDelivery->cellId = dlRrcMsgInfo->cellId; - rrcDelivery->ueIdx = dlRrcMsgInfo->ueIdx; + rrcDelivery->ueId = dlRrcMsgInfo->ueId; rrcDelivery->srbId = dlRrcMsgInfo->lcId ; rrcDelivery->rrcDeliveryStatus.deliveryStatus = PDCP_SN; rrcDelivery->rrcDeliveryStatus.triggeringMessage = PDCP_SN; @@ -252,7 +528,7 @@ uint8_t BuildAndSendRrcDeliveryReportToDu( RlcDlRrcMsgInfo *dlRrcMsgInfo ) } else { - DU_LOG("\nRLC : Memory allocation failed"); + DU_LOG("\nERROR --> RLC : Memory allocation failed"); } return ROK; @@ -276,36 +552,39 @@ uint8_t BuildAndSendRrcDeliveryReportToDu( RlcDlRrcMsgInfo *dlRrcMsgInfo ) uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) { Buffer *mBuf; - KwuDatReqInfo *datReqInfo; + RlcDatReqInfo *datReqInfo; - RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo)); + RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo)); if(!datReqInfo) { - DU_LOG("\nRLC : Memory allocation failed in RlcProcDlRrcMsgTransfer"); + DU_LOG("\nERROR --> RLC : Memory allocation failed in RlcProcDlRrcMsgTransfer"); RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen); RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo)); return RFAILED; } - datReqInfo->rlcId.rbType = dlRrcMsgInfo->rbType; - datReqInfo->rlcId.rbId = dlRrcMsgInfo->rbId; - datReqInfo->rlcId.ueId = dlRrcMsgInfo->ueIdx; + datReqInfo->rlcId.rbType = RB_TYPE_SRB; + datReqInfo->rlcId.rbId = dlRrcMsgInfo->lcId; + datReqInfo->rlcId.ueId = dlRrcMsgInfo->ueId; datReqInfo->rlcId.cellId = dlRrcMsgInfo->cellId; - datReqInfo->lcType = dlRrcMsgInfo->lcType; + datReqInfo->lcType = LCH_DCCH; datReqInfo->sduId = ++(rlcCb[pst->dstInst]->dlSduId); /* Copy fixed buffer to message */ if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &mBuf) != ROK) { - DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData"); - RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo)); + DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo)); RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen); RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo)); return RFAILED; } oduCpyFixBufToMsg(dlRrcMsgInfo->rrcMsg, mBuf, dlRrcMsgInfo->msgLen); - rlcProcDlData(pst, datReqInfo, mBuf); + if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK) + { + return RFAILED; + } /* RRC Delivery report is only send when RRC Delivery status report is true in DL RRC Message */ if(dlRrcMsgInfo->deliveryStaRpt) @@ -314,7 +593,7 @@ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) } /* Free memory allocated by du app */ - RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo)); + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo)); RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen); RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo)); return ROK; @@ -338,18 +617,18 @@ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) +uint8_t RlcProcUlData(Pst *pst, RlcUlData *ulData) { uint8_t ret = ROK; - uint8_t idx, pduIdx; - uint8_t lcId; /* Logical Channel */ - uint8_t numDLch = 0; /* Number of dedicated logical channel */ + uint8_t idx, pduIdx; + uint8_t lcId; /* Logical Channel */ + uint8_t numDLch = 0; /* Number of dedicated logical channel */ bool dLchPduPres; /* PDU received on dedicated logical channel */ - RguLchDatInd dLchData[MAX_NUM_LC]; /* PDU info on dedicated logical channel */ - RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */ - RguCDatIndInfo *cLchUlDat; /* UL data on common logical channel */ + RguLchDatInd dLchData[MAX_NUM_LC]; /* PDU info on dedicated logical channel */ + RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */ /* Initializing dedicated logical channel Database */ + DU_LOG("\nDEBUG --> RLC: Received UL Data request from MAC"); for(idx = 0; idx < MAX_NUM_LC; idx++) { dLchData[idx].lcId = idx; @@ -361,72 +640,39 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) * and call common channel's handler */ for(idx = 0; idx< ulData->numPdu; idx++) { - if(ulData->pduInfo[idx].commCh) + if(!dLchPduPres) { - RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \ - sizeof(RguCDatIndInfo)); - if(!cLchUlDat) - { - DU_LOG("\nRLC : Memory allocation failed at RlcProcUlData"); - ret = RFAILED; - break; - } - memset(cLchUlDat, 0, sizeof(RguCDatIndInfo)); - - cLchUlDat->cellId = ulData->cellId; - GET_UE_IDX(ulData->rnti, cLchUlDat->rnti); - cLchUlDat->lcId = ulData->pduInfo[idx].lcId; - - /* Copy fixed buffer to message */ - if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &cLchUlDat->pdu) != ROK) + RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ + sizeof(RguDDatIndInfo)); + if(!dLchUlDat) { - DU_LOG("\nRLC : Memory allocation failed at RlcProcUlData"); - RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \ - sizeof(RguCDatIndInfo)); + DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); ret = RFAILED; - break; + break; } - oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, \ - ulData->pduInfo[idx].pduLen); - - rlcProcCommLcUlData(pst, 0, cLchUlDat); + dLchPduPres = TRUE; } - else + + /* Copy fixed buffer to message */ + lcId = ulData->pduInfo[idx].lcId; + if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \ + &dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK) { - if(!dLchPduPres) + DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); + for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++) { - RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ - sizeof(RguDDatIndInfo)); - if(!dLchUlDat) - { - DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData"); - ret = RFAILED; - break; - } - dLchPduPres = TRUE; + ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]); } - - /* Copy fixed buffer to message */ - lcId = ulData->pduInfo[idx].lcId; - if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \ - &dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK) - { - DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData"); - for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++) - { - ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]); - } - RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ - sizeof(RguDDatIndInfo)); - ret = RFAILED; - break; - } - oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, \ - dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu],\ - ulData->pduInfo[idx].pduLen); - - dLchData[lcId].pdu.numPdu++; + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ + sizeof(RguDDatIndInfo)); + ret = RFAILED; + break; } + oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, \ + dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu],\ + ulData->pduInfo[idx].pduLen); + + dLchData[lcId].pdu.numPdu++; } /* If any PDU received on dedicated logical channel, copy into RguDDatIndInfo @@ -435,28 +681,28 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) { if(dLchPduPres) { - dLchUlDat->cellId = ulData->cellId; - dLchUlDat->rnti = ulData->rnti; + dLchUlDat->cellId = ulData->cellId; + GET_UE_ID(ulData->rnti, dLchUlDat->rnti); - for(idx = 0; idx < MAX_NUM_LC; idx++) - { - if(dLchData[idx].pdu.numPdu) - { - memcpy(&dLchUlDat->lchData[numDLch], &dLchData[idx], sizeof(RguLchDatInd)); - numDLch++; - } - } - dLchUlDat->numLch = numDLch; - rlcProcDedLcUlData(pst, 0, dLchUlDat); + for(idx = 0; idx < MAX_NUM_LC; idx++) + { + if(dLchData[idx].pdu.numPdu) + { + memcpy(&dLchUlDat->lchData[numDLch], &dLchData[idx], sizeof(RguLchDatInd)); + numDLch++; + } + } + dLchUlDat->numLch = numDLch; + rlcProcDedLcUlData(pst, 0, dLchUlDat); } } for(pduIdx = 0; pduIdx < ulData->numPdu; pduIdx++) { RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData->pduInfo[pduIdx].pduBuf, \ - ulData->pduInfo[pduIdx].pduLen); + ulData->pduInfo[pduIdx].pduLen); } - RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcData)); + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcUlData)); return ROK; }/* End of RlcProcUlData */ @@ -484,71 +730,43 @@ uint8_t RlcProcSchedResultRpt(Pst *pst, RlcSchedResultRpt *schRep) uint8_t ret = ROK; uint8_t idx; /* Iterator */ uint8_t nmbDLch = 0; /* Number of dedicated logical channles */ - RguCStaIndInfo *cLchSchInfo; /* Common logical channel scheduling result */ RguDStaIndInfo *dLchSchInfo; /* Dedicated logical channel scheduling result */ - DU_LOG("\nRLC : Received scheduling report from MAC"); - + DU_LOG("\nDEBUG --> RLC : Received scheduling report from MAC"); for(idx=0; idx < schRep->numLc; idx++) { - /* If it is common channel, fill status indication information - * and trigger the handler for each common lch separately */ - if(schRep->lcSch[idx].commCh) + /* Fill status info structure if at least one channel's scheduling report is received */ + if(nmbDLch == 0) { - RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, cLchSchInfo, \ - sizeof(RguCStaIndInfo)); - if(!cLchSchInfo) - { - DU_LOG("\nRLC: RlcProcSchedResultRpt: Memory allocation failed for cLchSchInfo"); - ret = RFAILED; - break; - } - memset(cLchSchInfo, 0, sizeof(RguCStaIndInfo)); + RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, dLchSchInfo, \ + sizeof(RguDStaIndInfo)); + if(!dLchSchInfo) + { + DU_LOG("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo"); + ret = RFAILED; + break; + } - cLchSchInfo->cellId = schRep->cellId; - cLchSchInfo->lcId = schRep->lcSch[idx].lcId; - cLchSchInfo->transId = schRep->slotInfo.sfn; - cLchSchInfo->transId = (cLchSchInfo->transId << 16) | schRep->slotInfo.slot; - cLchSchInfo->rnti = schRep->rnti; - rlcProcCommLcSchedRpt(pst, 0, cLchSchInfo); + dLchSchInfo->cellId = schRep->cellId; + dLchSchInfo->nmbOfUeGrantPerTti = 1; + /* MAC sends Scheduling report for one UE at a time. Hence filling + only the 0th index of staInd */ + dLchSchInfo->staInd[0].rnti = schRep->rnti; + /* Storing sfn/slot into a single 32-bit variable to be used later*/ + dLchSchInfo->staInd[0].transId = schRep->slotInfo.sfn; + dLchSchInfo->staInd[0].transId = \ + (dLchSchInfo->staInd[0].transId << 16) | schRep->slotInfo.slot; + dLchSchInfo->staInd[0].nmbOfTbs = 1; + dLchSchInfo->staInd[0].fillCtrlPdu = true; } - else - { - /* Fill status info structure if at least one dedicated channel - * scheduling report is received */ - if(nmbDLch == 0) - { - RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, dLchSchInfo, \ - sizeof(RguDStaIndInfo)); - if(!dLchSchInfo) - { - DU_LOG("\nRLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo"); - ret = RFAILED; - break; - } - - dLchSchInfo->cellId = schRep->cellId; - dLchSchInfo->nmbOfUeGrantPerTti = 1; - /* MAC sends Scheduling report for one UE at a time. Hence filling - only the 0th index of staInd */ - dLchSchInfo->staInd[0].rnti = schRep->rnti; - - /* Storing sfn/slot into a single 32-bit variable to be used later*/ - dLchSchInfo->staInd[0].transId = schRep->slotInfo.sfn; - dLchSchInfo->staInd[0].transId = \ - (dLchSchInfo->staInd[0].transId << 16) | schRep->slotInfo.slot; - dLchSchInfo->staInd[0].nmbOfTbs = 1; - dLchSchInfo->staInd[0].fillCtrlPdu = true; - } - - /* Fill logical channel scheduling info */ - dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].lcId = \ - schRep->lcSch[idx].lcId; - dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].totBufSize = \ - schRep->lcSch[idx].bufSize; - nmbDLch++; - } + + /* Fill logical channel scheduling info */ + dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].lcId = \ + schRep->lcSch[idx].lcId; + dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].totBufSize = \ + schRep->lcSch[idx].bufSize; + nmbDLch++; } /* Calling handler for all dedicated channels scheduling*/ @@ -565,6 +783,515 @@ uint8_t RlcProcSchedResultRpt(Pst *pst, RlcSchedResultRpt *schRep) return ret; } + +/******************************************************************* + * + * @brief Handles Ue Reconfig Request from DU APP + * + * @details + * + * Function : RlcProcUeReconfigReq + * + * Functionality: + * Handles Ue Reconfig Request from DU APP + * + * @params[in] Post structure pointer + * RlcUeCfg pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeRecfg *ueRecfg) +{ + uint8_t ret = ROK; + RlcCfgInfo *rlcUeCfg = NULLP; //Seed code Rlc cfg struct + RlcCb *rlcUeCb = NULLP; + RlcCfgCfmInfo cfgRsp; + Pst rspPst; + + DU_LOG("\nDEBUG --> RLC: UE reconfig request received. CellID[%d] UEID[%d]",ueRecfg->cellId, ueRecfg->ueId); + + rlcUeCb = RLC_GET_RLCCB(pst->dstInst); + RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo)); + if(rlcUeCfg == NULLP) + { + DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeReconfigReq()"); + ret = RFAILED; + } + else + { + memset(rlcUeCfg, 0, sizeof(RlcCfgInfo)); + ret = updateRlcCfg(rlcUeCb, rlcUeCfg, ueRecfg); + if(ret != ROK) + { + DU_LOG("\nERROR --> RLC: Failed to fill configuration at RlcProcUeReconfigReq()"); + FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_RSP); + fillRlcRecfgFailureRsp(&cfgRsp, ueRecfg); + SendRlcUeReconfigRspToDu(&rspPst, &cfgRsp); + } + else + { + ret = RlcProcCfgReq(pst, rlcUeCfg); + if(ret != ROK) + DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()"); + } + } + + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRecfg, sizeof(RlcUeRecfg)); + return ret; +} + +/* **************************************************************** + * + * @brief Process the DL Data transfer from DU APP + * + * @details + * + * Function : RlcProcDlUserDataTransfer + * + * Functionality: Process the DL transfer from DU APP + * + * @params[in] Post structure + * DL RRC Message info + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t RlcProcDlUserDataTransfer(Pst *pst, RlcDlUserDataInfo *dlDataMsgInfo) +{ + Buffer *mBuf = NULLP; + RlcDatReqInfo *datReqInfo = NULLP; + + if(dlDataMsgInfo->dlMsg == NULLP) + { + DU_LOG("\nERROR --> RLC_DL : Received DL message is NULLP in RlcProcDlUserDataTransfer()"); + return RFAILED; + } + RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo)); + if(!datReqInfo) + { + DU_LOG("\nERROR --> RLC_DL : Memory allocation failed for DatReq in RlcProcDlUserDataTransfer()"); + ODU_PUT_MSG_BUF(dlDataMsgInfo->dlMsg); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo)); + return RFAILED; + } + + datReqInfo->rlcId.rbType = RB_TYPE_DRB; + datReqInfo->rlcId.rbId = dlDataMsgInfo->rbId; + datReqInfo->rlcId.ueId = dlDataMsgInfo->ueId; + datReqInfo->rlcId.cellId = dlDataMsgInfo->cellId; + datReqInfo->lcType = LCH_DTCH; + datReqInfo->sduId = ++(rlcCb[pst->dstInst]->dlSduId); + mBuf = dlDataMsgInfo->dlMsg; + if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK) + { + return RFAILED; + } + + /* Free memory allocated by du app */ + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo)); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo)); + return ROK; +} + +/******************************************************************* + * + * @brief sending UE delete response to DU + * + * @details + * + * Function : sendRlcUeDeleteRspToDu + * + * Functionality: + * sending UE delete response to DU + * + * @params[in] uint8_t cellId, uint8_t ueId, CauseOfResult status + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t sendRlcUeDeleteRspToDu(uint16_t cellId,uint8_t ueId, CauseOfResult status) +{ + Pst pst; + RlcUeDeleteRsp *ueDeleteRsp = NULLP; + + FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RLC_UE_DELETE_RSP); + + RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp)); + if(!ueDeleteRsp) + { + DU_LOG("\nERROR --> RLC: sendRlcUeDeleteRspToDu(): Memory allocation failed "); + return RFAILED; + } + else + { + ueDeleteRsp->cellId = cellId; + ueDeleteRsp->ueId = ueId; + ueDeleteRsp->status = status; + + if(rlcSendUeDeleteRspToDu(&pst, ueDeleteRsp) == ROK) + { + DU_LOG("\nDEBUG --> RLC: UE Delete response send successfully"); + } + else + { + DU_LOG("\nERROR --> RLC: SendRlcUeDeleteRspToDu():Failed to send UE Delete response to DU"); + RLC_FREE_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp)); + return RFAILED; + } + } + return ROK; +} + +/******************************************************************* +* +* @brief Handles Ue delete Request from DU APP +* +* @details +* +* Function : RlcProcUeDeleteReq +* +* Functionality: +* Handles Ue delete Request from DU APP +* +* @params[in] Post structure pointer +* RlcUeDelete pointer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t RlcProcUeDeleteReq(Pst *pst, RlcUeDelete *ueDelete) +{ + uint8_t ret = ROK; + RlcCb *gRlcCb = NULLP; + RlcUlUeCb *ueCb = NULLP; + CauseOfResult status =SUCCESSFUL; + + DU_LOG("\nDEBUG --> RLC: UE Delete request received. CellID[%d] UEID[%d]",ueDelete->cellId, ueDelete->ueId); + + if(ueDelete != NULLP) + { + gRlcCb = RLC_GET_RLCCB(pst->dstInst); + rlcDbmFetchUlUeCb(gRlcCb,ueDelete->ueId, ueDelete->cellId, &ueCb); + if(ueCb != NULLP) + { + if(ueDelete->cellId == ueCb->cellId) + { + memcpy(&ueCb->ueDeleteInfo.pst, pst, sizeof(Pst)); + if((rlcChkTmr(gRlcCb, (PTR)ueCb, EVENT_RLC_UE_DELETE_TMR)) == FALSE) + { + rlcStartTmr(gRlcCb,(PTR)ueCb, EVENT_RLC_UE_DELETE_TMR); + } + } + else + { + status = CELLID_INVALID; + } + } + else + { + status = UEID_INVALID; + } + + if(status != SUCCESSFUL) + { + ret = sendRlcUeDeleteRspToDu(ueDelete->cellId, ueDelete->ueId, status); + if(ret != ROK) + { + DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq():Failed to send UE Delete response to DU"); + } + } + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(RlcUeDelete)); + } + else + { + DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq(): Recieved NULL pointer UE Delete "); + ret = RFAILED; + } + return ret; +} + +/******************************************************************* +* +* @brief Send the Slice Metrics to DU APP +* +* @details +* +* Function : sendSlicePmToDu +* +* Functionality: +* Handles the sending of Slice Metrics to DU APP +* +* @params[in] Post structure pointer +* SlicePmList *sliceStats pointer +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +uint8_t sendSlicePmToDu(SlicePmList *sliceStats) +{ + Pst pst; + + FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RLC_SLICE_PM_TO_DU); + + if(!sliceStats) + { + DU_LOG("\nERROR --> RLC: sendSlicePmToDu(): Memory allocation failed "); + return RFAILED; + } + else + { + if(rlcSendSlicePmToDu(&pst, sliceStats) == ROK) + { + DU_LOG("\nDEBUG --> RLC: Slice PM send successfully"); + } + else + { + DU_LOG("\nERROR --> RLC: sendSlicePmToDu():Failed to send Slice PM to DU"); + RLC_FREE_SHRABL_BUF(pst.region, pst.pool, sliceStats, sizeof(SlicePmList)); + return RFAILED; + } + } + return ROK; +} + +/** + * @brief + * Handler for searching the Slice Entry in Slice Metrics structure + * + * @details + * This func finds the slice entry in the SliceMetric record structure and + * return the index of the slice sot hat Tput entries can be done + * + * @param[in] snssaiVal : Snssai Val to be searched + * *snssaiIdx : O/P : Index of the Slice in Slice Metrics record + * sliceStats : Pointer of Slice metrics record list + * + * @return bool: True: If slice found in the record + * False: If Slice not found; thus parent function will create the + * recpord of this snssai + * + */ +bool rlcFindSliceEntry(SliceIdentifier snssaiVal, uint8_t *snssaiIdx, SlicePmList *sliceStats) +{ + uint8_t cntSlices = sliceStats->numSlice; + + for(*snssaiIdx = 0;(*snssaiIdx) < cntSlices; (*snssaiIdx)++) + { + if((snssaiVal.sst == sliceStats->sliceRecord[*snssaiIdx].networkSliceIdentifier.sst)&& + (snssaiVal.sd == sliceStats->sliceRecord[*snssaiIdx].networkSliceIdentifier.sd)) + { + return TRUE; + } + } + return FALSE; +} + + +/******************************************************************* +* +* @brief Builds the Slice Performance Metrics structure to be sent to DU +* +* @details +* +* Function : BuildSliceReportToDu +* +* Functionality: +* Builds the Slice Performance Metrics structure to be sent to DU +* +* @params[in] uint8_t snssaiCnt +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +uint8_t BuildSliceReportToDu(uint8_t snssaiCnt) +{ + CmLList *node = NULLP; + RlcTptPerSnssai *snssaiNode = NULLP; + Direction dir = DIR_UL; + SlicePmList *sliceStats = NULLP; /*Slice metric */ + SliceIdentifier snssaiVal ; + uint8_t snssaiIdx = 0; + + if(snssaiCnt == 0) + { + DU_LOG("\nERROR --> RLC: No SNSSAI to send the SLice PM"); + return RFAILED; + } + + RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats, sizeof(SlicePmList)); + if(sliceStats == NULLP) + { + DU_LOG("\nERROR --> RLC: Memory Allocation Failed"); + return RFAILED; + } + RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats->sliceRecord, snssaiCnt * (sizeof(SlicePm))); + + if(sliceStats->sliceRecord == NULLP) + { + DU_LOG("\nERROR --> RLC: Memory Allocation Failed"); + RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats, sizeof(SlicePmList)); + return RFAILED; + } + while(dir < DIR_BOTH) + { + node = arrTputPerSnssai[dir]->first; + if(node == NULLP) + { + DU_LOG("\nERROR --> RLC: No SNSSAI in list"); + RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats, sizeof(SlicePmList)); + RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, sliceStats->sliceRecord, (snssaiCnt * (sizeof(SlicePm)))); + return RFAILED; + } + + while(node) + { + snssaiIdx = 0; + snssaiNode = (RlcTptPerSnssai *)node->node; + + snssaiVal.sst = snssaiNode->snssai->sst; + snssaiVal.sd = snssaiNode->snssai->sd[2]+snssaiNode->snssai->sd[1]*10+snssaiNode->snssai->sd[0]*100; + if(rlcFindSliceEntry(snssaiVal, &snssaiIdx, sliceStats) == FALSE) + { + sliceStats->sliceRecord[snssaiIdx].networkSliceIdentifier = snssaiVal; + sliceStats->numSlice++; + } + if(dir == DIR_UL) + { + sliceStats->sliceRecord[snssaiIdx].ThpUl = snssaiNode->tpt; + } + else + { + sliceStats->sliceRecord[snssaiIdx].ThpDl = snssaiNode->tpt; + } + node = node->next; + } + dir++; + } + + sendSlicePmToDu(sliceStats); + return ROK; +} + +/******************************************************************* + * + * @brief sending UE reestablishment response to DU + * + * @details + * + * Function : sendRlcUeReestablishRspToDu + * + * Functionality: + * sending UE reestablishment response to DU + * + * @params[in] uint8_t cellId, uint8_t ueId, CauseOfResult status + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t sendRlcUeReestablishRspToDu(uint16_t cellId,uint8_t ueId, CauseOfResult status) +{ + Pst pst; + RlcUeReestablishRsp *ueReestablishRsp = NULLP; + + FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RLC_UE_REESTABLISH_RSP); + + RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, ueReestablishRsp, sizeof(RlcUeReestablishRsp)); + if(!ueReestablishRsp) + { + DU_LOG("\nERROR --> RLC: sendRlcUeReestablishRspToDu(): Memory allocation failed "); + return RFAILED; + } + else + { + ueReestablishRsp->cellId = cellId; + ueReestablishRsp->ueId = ueId; + ueReestablishRsp->status = status; + + if(rlcSendUeReestablishRspToDu(&pst, ueReestablishRsp) == ROK) + { + DU_LOG("\nDEBUG --> RLC: UE Reestablishment response send successfully"); + } + else + { + DU_LOG("\nERROR --> RLC: SendRlcUeReestablishRspToDu():Failed to send UE Reestablishment response to DU"); + RLC_FREE_SHRABL_BUF(pst.region, pst.pool, ueReestablishRsp, sizeof(RlcUeReestablishRsp)); + return RFAILED; + } + } + return ROK; +} + +/******************************************************************* +* +* @brief Handles Ue reestablishment Request from DU APP +* +* @details +* +* Function : RlcProcUeReestablishReq +* +* Functionality: +* Handles Ue reestablishment Request from DU APP +* +* @params[in] Post structure pointer +* RlcUeReestablishReq pointer +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ + +uint8_t RlcProcUeReestablishReq(Pst *pst, RlcUeReestablishReq *ueReestablishReq) +{ + uint8_t ret = RFAILED; + RlcCb *gRlcCb = NULLP; + RlcUlUeCb *ueCb = NULLP; + CauseOfResult status =SUCCESSFUL; + + if(ueReestablishReq != NULLP) + { + gRlcCb = RLC_GET_RLCCB(pst->dstInst); + rlcDbmFetchUlUeCb(gRlcCb,ueReestablishReq->ueId, ueReestablishReq->cellId, &ueCb); + if(ueCb != NULLP) + { + if(ueReestablishReq->cellId == ueCb->cellId) + { + /* TODO : + * Step 1: Fill the RlcCfgInfo structure with data from the ueReestablishReq, just as we did in fillRlcCfg function and set + * ConfigType = CONFIG_REESTABLISH + * Step 2: To finish processing of Ue Reestablishment, call the RlcProcCfgReq function */ + } + else + { + status = CELLID_INVALID; + DU_LOG("\nERROR --> SCH : RlcProcUeReestablishReq(): cell Id[%d] not found", ueReestablishReq->cellId); + } + } + else + { + status = UEID_INVALID; + DU_LOG("\nERROR --> SCH : RlcProcUeReestablishReq(): ue Id[%d] not found", ueReestablishReq->cellId); + } + + if(status != SUCCESSFUL) + { + if(sendRlcUeReestablishRspToDu(ueReestablishReq->cellId, ueReestablishReq->ueId, status) != ROK) + { + DU_LOG("\nERROR --> RLC: RlcProcUeReestablishReq():Failed to send UE Reestablishment response to DU"); + } + } + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueReestablishReq, sizeof(RlcUeDelete)); + } + else + { + DU_LOG("\nERROR --> RLC: RlcProcUeReestablishReq(): Recieved NULL pointer UE Reestablishment "); + } + return ret; +} /********************************************************************** - End of file -**********************************************************************/ + End of file + **********************************************************************/