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=9fbb0d7ebf45e75ee45435326853d962160d336f;hpb=5bca27d3d33c085718de6e894b875c845d7456d2;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/rlc_msg_hdl.c b/src/5gnrrlc/rlc_msg_hdl.c index 9fbb0d7eb..38f0456fa 100644 --- a/src/5gnrrlc/rlc_msg_hdl.c +++ b/src/5gnrrlc/rlc_msg_hdl.c @@ -40,31 +40,84 @@ #include "du_app_rlc_inf.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 : fillRlcUeCfgRsp + * Function : fillRlcUeCreateRsp * * Functionality: * Fills RLC UL UE Cfg Rsp from RlcCRsp * * @params[in] Pointer to RlcCfgCfm - * Pointer to RlcUeCfgRsp + * Pointer to RlcUeCreateRsp * * @return ROK/RFAILED * *****************************************************************/ -uint8_t fillRlcUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) +uint8_t fillRlcUeCreateRsp(RlcUeCreateRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) { uint8_t idx; uint8_t ret = ROK; rlcCfgRsp->cellId = rlcCRsp->cellId; 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) @@ -165,7 +218,6 @@ uint8_t fillLcCfg(RlcCb *gCb, RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg) memcpy(rlcUeCfg->snssai, duRlcUeCfg->snssai, sizeof(Snssai)); } fillEntModeAndDir(&rlcUeCfg->entMode, &rlcUeCfg->dir, duRlcUeCfg->rlcMode); - rlcUeCfg->cfgType = duRlcUeCfg->configType; switch(rlcUeCfg->entMode) { @@ -212,7 +264,7 @@ uint8_t fillLcCfg(RlcCb *gCb, RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg) * Function : fillRlcCfg * * Functionality: - * fills LC Cfgs to be Add/Mod/Del in RLC + * fills LC Cfgs to be Add in RLC * * @params[in] * RlcEntCfgInfo pointer @@ -222,22 +274,83 @@ uint8_t fillLcCfg(RlcCb *gCb, RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg) * ******************************************************************/ -uint8_t fillRlcCfg(RlcCb *gCb, RlcCfgInfo *rlcUeCfg, RlcUeCfg *ueCfg) +uint8_t fillRlcCfg(RlcCb *gCb, RlcCfgInfo *rlcUeCfg, RlcUeCreate *ueCfg) { uint8_t lcIdx; rlcUeCfg->ueId = ueCfg->ueId; rlcUeCfg->cellId = ueCfg->cellId; - rlcUeCfg->numEnt = ueCfg->numLcs; + rlcUeCfg->numEnt = ueCfg->numLcsToAdd; rlcUeCfg->transId = getTransId(); - for(lcIdx = 0; lcIdx < rlcUeCfg->numEnt; lcIdx++) { - if(fillLcCfg(gCb, &rlcUeCfg->entCfg[lcIdx], &ueCfg->rlcLcCfg[lcIdx]) != ROK) + 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; } @@ -253,26 +366,76 @@ uint8_t fillRlcCfg(RlcCb *gCb, RlcCfgInfo *rlcUeCfg, RlcUeCfg *ueCfg) * Functionality: * Fill RlcCfgCfmInfo structure for sending failure response to DU * - * @params[in] RlcCfgCfmInfo *cfgRsp, RlcUeCfg *ueCfg + * @params[in] RlcCfgCfmInfo *cfgRsp, RlcUeCreate *ueCfg * * @return void * * ****************************************************************/ -void fillRlcCfgFailureRsp(RlcCfgCfmInfo *cfgRsp, RlcUeCfg *ueCfg) +void fillRlcCfgFailureRsp(RlcCfgCfmInfo *cfgRsp, RlcUeCreate *ueCfg) { uint8_t cfgIdx =0; cfgRsp->ueId = ueCfg->ueId; cfgRsp->cellId = ueCfg->cellId; - cfgRsp->numEnt = ueCfg->numLcs; - for(cfgIdx =0; cfgIdxnumLcs; cfgIdx++) + cfgRsp->numEnt = ueCfg->numLcsToAdd; + for(cfgIdx =0; cfgIdxnumLcsToAdd; cfgIdx++) { - cfgRsp->entCfgCfm[cfgIdx].rbId = ueCfg->rlcLcCfg[cfgIdx].rbId; - cfgRsp->entCfgCfm[cfgIdx].rbType = ueCfg->rlcLcCfg[cfgIdx].rbType; + 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 @@ -285,12 +448,12 @@ void fillRlcCfgFailureRsp(RlcCfgCfmInfo *cfgRsp, RlcUeCfg *ueCfg) * Handles Ue create Request from DU APP * * @params[in] Post structure pointer - * RlcUeCfg pointer + * RlcUeCreate pointer * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) +uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCreate *ueCfg) { uint8_t ret = ROK; RlcCb *gCb; @@ -314,7 +477,7 @@ uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) 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); - SendRlcUeCfgRspToDu(&rspPst, &cfgRsp); + SendRlcUeCreateRspToDu(&rspPst, &cfgRsp); } else @@ -324,7 +487,7 @@ uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()"); } } - RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg)); + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCreate)); return ret; } @@ -400,11 +563,11 @@ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) return RFAILED; } - datReqInfo->rlcId.rbType = dlRrcMsgInfo->rbType; - datReqInfo->rlcId.rbId = dlRrcMsgInfo->rbId; + 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 */ @@ -454,7 +617,7 @@ 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; @@ -463,7 +626,6 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) 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 */ /* Initializing dedicated logical channel Database */ DU_LOG("\nDEBUG --> RLC: Received UL Data request from MAC"); @@ -478,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) + RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ + sizeof(RguDDatIndInfo)); + if(!dLchUlDat) { - DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData"); - ret = RFAILED; - break; - } - memset(cLchUlDat, 0, sizeof(RguCDatIndInfo)); - - cLchUlDat->cellId = ulData->cellId; - GET_UE_ID(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) - { - DU_LOG("\nERROR --> RLC : 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; } - 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("\nERROR --> RLC : 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("\nERROR --> RLC : 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 @@ -573,7 +702,7 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData->pduInfo[pduIdx].pduBuf, \ 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 */ @@ -601,70 +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("\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("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for cLchSchInfo"); - ret = RFAILED; - break; - } - memset(cLchSchInfo, 0, sizeof(RguCStaIndInfo)); - - 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); + 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; + } + 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("\nERROR --> RLC: 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*/ @@ -699,15 +801,15 @@ uint8_t RlcProcSchedResultRpt(Pst *pst, RlcSchedResultRpt *schRep) * RFAILED - failure * * ****************************************************************/ -uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg) +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]",ueCfg->cellId, ueCfg->ueId); + + 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)); @@ -719,13 +821,13 @@ uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg) else { memset(rlcUeCfg, 0, sizeof(RlcCfgInfo)); - ret = fillRlcCfg(rlcUeCb, rlcUeCfg, ueCfg); + 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); - fillRlcCfgFailureRsp(&cfgRsp, ueCfg); - SendRlcUeCfgRspToDu(&rspPst, &cfgRsp); + fillRlcRecfgFailureRsp(&cfgRsp, ueRecfg); + SendRlcUeReconfigRspToDu(&rspPst, &cfgRsp); } else { @@ -735,7 +837,7 @@ uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg) } } - RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg)); + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRecfg, sizeof(RlcUeRecfg)); return ret; } @@ -803,13 +905,13 @@ uint8_t RlcProcDlUserDataTransfer(Pst *pst, RlcDlUserDataInfo *dlDataMsgInfo) * Functionality: * sending UE delete response to DU * - * @params[in] uint8_t cellId, uint8_t ueId, UeDeleteResult result + * @params[in] uint8_t cellId, uint8_t ueId, CauseOfResult status * * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint8_t sendRlcUeDeleteRspToDu(uint16_t cellId,uint8_t ueId, UeDeleteResult result) +uint8_t sendRlcUeDeleteRspToDu(uint16_t cellId,uint8_t ueId, CauseOfResult status) { Pst pst; RlcUeDeleteRsp *ueDeleteRsp = NULLP; @@ -826,7 +928,7 @@ uint8_t sendRlcUeDeleteRspToDu(uint16_t cellId,uint8_t ueId, UeDeleteResult resu { ueDeleteRsp->cellId = cellId; ueDeleteRsp->ueId = ueId; - ueDeleteRsp->result = result; + ueDeleteRsp->status = status; if(rlcSendUeDeleteRspToDu(&pst, ueDeleteRsp) == ROK) { @@ -865,7 +967,7 @@ uint8_t RlcProcUeDeleteReq(Pst *pst, RlcUeDelete *ueDelete) uint8_t ret = ROK; RlcCb *gRlcCb = NULLP; RlcUlUeCb *ueCb = NULLP; - UeDeleteResult result=SUCCESSFUL; + CauseOfResult status =SUCCESSFUL; DU_LOG("\nDEBUG --> RLC: UE Delete request received. CellID[%d] UEID[%d]",ueDelete->cellId, ueDelete->ueId); @@ -885,17 +987,17 @@ uint8_t RlcProcUeDeleteReq(Pst *pst, RlcUeDelete *ueDelete) } else { - result = INVALID_CELLID; + status = CELLID_INVALID; } } else { - result = INVALID_UEID; + status = UEID_INVALID; } - if(result != SUCCESSFUL) + if(status != SUCCESSFUL) { - ret = sendRlcUeDeleteRspToDu(ueDelete->cellId, ueDelete->ueId, result); + ret = sendRlcUeDeleteRspToDu(ueDelete->cellId, ueDelete->ueId, status); if(ret != ROK) { DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq():Failed to send UE Delete response to DU"); @@ -1070,10 +1172,126 @@ uint8_t BuildSliceReportToDu(uint8_t snssaiCnt) } 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 + **********************************************************************/