X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Frlc_msg_hdl.c;h=28a4f62c503a9ef1cb8defea277f515711265a4a;hb=refs%2Fchanges%2F91%2F5391%2F11;hp=713fc2779661e1c892c3fc37f94269f936cbea71;hpb=088bb8763eaf91c139ede025faf2fac7e57d25ed;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/rlc_msg_hdl.c b/src/5gnrrlc/rlc_msg_hdl.c index 713fc2779..28a4f62c5 100644 --- a/src/5gnrrlc/rlc_msg_hdl.c +++ b/src/5gnrrlc/rlc_msg_hdl.c @@ -24,7 +24,9 @@ #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" /* header/extern include files (.x) */ #include "rgu.x" @@ -33,17 +35,21 @@ #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_mac_inf.h" #include "du_app_rlc_inf.h" #include "rlc_utils.h" - +#include "rlc_upr_inf_api.h" /******************************************************************* * * @brief Fills RLC UL UE Cfg Rsp from RlcCRsp * * @details * - * Function : fillRlcUlUeCfgRsp + * Function : fillRlcUeCfgRsp * * Functionality: * Fills RLC UL UE Cfg Rsp from RlcCRsp @@ -51,13 +57,14 @@ * @params[in] Pointer to RlcCfgCfm * Pointer to RlcUeCfgRsp * - * @return void + * @return ROK/RFAILED * *****************************************************************/ -void fillRlcUlUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) +uint8_t fillRlcUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) { uint8_t idx; + uint8_t ret = ROK; rlcCfgRsp->cellId = rlcCRsp->cellId; rlcCfgRsp->ueIdx = rlcCRsp->ueId; @@ -67,13 +74,17 @@ void fillRlcUlUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp) { 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; } /******************************************************************* @@ -98,19 +109,19 @@ 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 : @@ -118,13 +129,111 @@ void fillEntModeAndDir(uint8_t *entMode, uint8_t *direction, RlcMode 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 void + * + * ****************************************************************/ +void fillLcCfg(RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg, uint8_t cfgType) +{ + 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; + fillEntModeAndDir(&rlcUeCfg->entMode, &rlcUeCfg->dir, duRlcUeCfg->rlcMode); + rlcUeCfg->cfgType = cfgType; + 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.reOrdTmr = duRlcUeCfg->u.amCfg->ulAmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE; + 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 * RLC_REASSEMBLY_TMR_BASE; + + /* DL UM CONFIG */ + rlcUeCfg->m.umInfo.dl.snLen = duRlcUeCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm; + break; + } + default: + break; + }/* End of switch(entMode) */ +} + +/******************************************************************* + * + * @brief fills LC Cfgs to be Added in RLC + * + * @details + * + * Function : fillRlcCfg + * + * Functionality: + * fills LC Cfgs to be Add/Mod/Del in RLC + * + * @params[in] + * RlcEntCfgInfo pointer + * RlcBearerCfg pointer + * @return void + * + ******************************************************************/ + +void fillRlcCfg(RlcCfgInfo *rlcUeCfg, RlcUeCfg *ueCfg) +{ + uint8_t lcIdx; + + rlcUeCfg->ueId = ueCfg->ueIdx; + rlcUeCfg->cellId = ueCfg->cellId; + rlcUeCfg->numEnt = ueCfg->numLcs; + rlcUeCfg->transId = getTransId(); + + for(lcIdx = 0; lcIdx < rlcUeCfg->numEnt; lcIdx++) + { + fillLcCfg(&rlcUeCfg->entCfg[lcIdx], &ueCfg->rlcLcCfg[lcIdx], ueCfg->rlcLcCfg[lcIdx].configType); + } +} + /******************************************************************* * * @brief Handles Ue Create Request from DU APP * * @details * - * Function : RlcUlProcUeCreateReq + * Function : RlcProcUeCreateReq * * Functionality: * Handles Ue create Request from DU APP @@ -135,82 +244,75 @@ void fillEntModeAndDir(uint8_t *entMode, uint8_t *direction, RlcMode rlcMode) * RFAILED - failure * * ****************************************************************/ -uint8_t RlcUlProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) +uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) { - uint8_t idx; uint8_t ret = ROK; - uint8_t lChRbIdx; RlcCfgInfo *rlcUeCfg = NULLP; RlcCb *rlcUeCb = NULLP; rlcUeCb = RLC_GET_RLCCB(pst->dstInst); RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo)); - if(rlcUeCfg) + if(rlcUeCfg == NULLP) + { + DU_LOG("\nRLC: Failed to allocate memory at RlcProcUeCreateReq()"); + ret = RFAILED; + } + else { memset(rlcUeCfg, 0, sizeof(RlcCfgInfo)); - - 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) */ - } + fillRlcCfg(rlcUeCfg, ueCfg); ret = RlcProcCfgReq(pst, rlcUeCfg); - } - else - { - DU_LOG("\nRLC: Failed to allocate memory "); - ret = RFAILED; - } - RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg)); - return ret; + if(ret != ROK) + DU_LOG("\nRLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()"); + + } + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg)); + return ret; } /******************************************************************* +* +* @brief filling the structure of rrc delivery msg info +* +* @details +* +* Function : BuildAndSendRrcDeliveryReportToDu +* +* Functionality: filling the structure of rrc delivery msg info +* +* @return ROK - success +* RFAILED - failure +* +* ****************************************************************/ +uint8_t BuildAndSendRrcDeliveryReportToDu( RlcDlRrcMsgInfo *dlRrcMsgInfo ) +{ + Pst pst; + RrcDeliveryReport *rrcDelivery; + + DU_LOG("\nRLC : Filling the 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->srbId = dlRrcMsgInfo->lcId ; + rrcDelivery->rrcDeliveryStatus.deliveryStatus = PDCP_SN; + rrcDelivery->rrcDeliveryStatus.triggeringMessage = PDCP_SN; + + /* Sending UL RRC Message transfeer to DU APP */ + memset(&pst, 0, sizeof(Pst)); + FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RRC_DELIVERY_MSG_TRANS_TO_DU); + rlcSendRrcDeliveryReportToDu(&pst, rrcDelivery); + } + else + { + DU_LOG("\nRLC : Memory allocation failed"); + } + + return ROK; +} +/* **************************************************************** * * @brief Process the DL RRC Message from DU APP * @@ -228,7 +330,6 @@ uint8_t RlcUlProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg) * ****************************************************************/ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) { - uint16_t copyLen; Buffer *mBuf; KwuDatReqInfo *datReqInfo; @@ -236,6 +337,8 @@ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) if(!datReqInfo) { DU_LOG("\nRLC : 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; } @@ -251,15 +354,22 @@ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) { DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData"); RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo)); + 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); + + if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK) + { return RFAILED; } - /* ODU_COPY_FIX_BUF_TO_MSG copies fixed buffer in reverse order. Hence reversing the - * fixed buffer before copying in order to maintain the actual order*/ - reverseFixBuf(dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen); - ODU_COPY_FIX_BUF_TO_MSG(dlRrcMsgInfo->rrcMsg, mBuf, 0, dlRrcMsgInfo->msgLen, \ - (MsgLen *)©Len); - RlcUiKwuDatReq(pst, datReqInfo, mBuf); + /* RRC Delivery report is only send when RRC Delivery status report is true in DL RRC Message */ + if(dlRrcMsgInfo->deliveryStaRpt) + { + BuildAndSendRrcDeliveryReportToDu(dlRrcMsgInfo); + } /* Free memory allocated by du app */ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo)); @@ -268,6 +378,297 @@ uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo) return ROK; } +/******************************************************************* + * + * @brief Process UL data from UE + * + * @details + * + * Function : RlcProcUlData + * + * Functionality: + * This function receives the PDU from MAC. + * seggregates common and dedicated logical channel + * PDU and call respective handler. + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) +{ + uint8_t ret = ROK; + 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 */ + + /* Initializing dedicated logical channel Database */ + DU_LOG("\nRLC: Received UL Data request from MAC"); + for(idx = 0; idx < MAX_NUM_LC; idx++) + { + dLchData[idx].lcId = idx; + dLchData[idx].pdu.numPdu = 0; + } + dLchPduPres = FALSE; + + /* Seggregate PDUs received on common and dedicated channels + * and call common channel's handler */ + for(idx = 0; idx< ulData->numPdu; idx++) + { + if(ulData->pduInfo[idx].commCh) + { + 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) + { + DU_LOG("\nRLC : Memory allocation failed at RlcProcUlData"); + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \ + sizeof(RguCDatIndInfo)); + ret = RFAILED; + break; + } + oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, \ + ulData->pduInfo[idx].pduLen); + + rlcProcCommLcUlData(pst, 0, cLchUlDat); + } + else + { + if(!dLchPduPres) + { + 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; + } + + /* 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++; + } + } + + /* If any PDU received on dedicated logical channel, copy into RguDDatIndInfo + * and call its handler */ + if(ret == ROK) + { + if(dLchPduPres) + { + dLchUlDat->cellId = ulData->cellId; + GET_UE_IDX(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(pduIdx = 0; pduIdx < ulData->numPdu; pduIdx++) + { + 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)); + return ROK; + +}/* End of RlcProcUlData */ + +/******************************************************************* + * + * @brief Handler for extracting common and dedicated channel + * Scheduling result report. + * + * @details + * + * Function : RlcProcSchedResultRpt + * + * Functionality: + * Handler for extracting common and dedicated channel + * Scheduling result report + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +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"); + 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) + { + 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)); + + 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); + + } + 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++; + } + } + + /* Calling handler for all dedicated channels scheduling*/ + if(ret == ROK) + { + if(nmbDLch) + { + dLchSchInfo->staInd[0].staIndTb[0].nmbLch = nmbDLch; + rlcProcDedLcSchedRpt(pst, 0, dLchSchInfo); + } + } + + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcSchedResultRpt)); + 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, RlcUeCfg *ueCfg) +{ + uint8_t ret = ROK; + RlcCfgInfo *rlcUeCfg = NULLP; //Seed code Rlc cfg struct + RlcCb *rlcUeCb = NULLP; + + DU_LOG("\nRLC: UE reconfig request received. CellID[%d] UEIDX[%d]",ueCfg->cellId, ueCfg->ueIdx); + + rlcUeCb = RLC_GET_RLCCB(pst->dstInst); + RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo)); + if(rlcUeCfg == NULLP) + { + DU_LOG("\nRLC: Failed to allocate memory at RlcProcUeReconfigReq()"); + ret = RFAILED; + } + else + { + memset(rlcUeCfg, 0, sizeof(RlcCfgInfo)); + fillRlcCfg(rlcUeCfg, ueCfg); + ret = RlcProcCfgReq(pst, rlcUeCfg); + if(ret != ROK) + DU_LOG("\nRLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()"); + } + + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg)); + return ret; +} + /********************************************************************** End of file **********************************************************************/