#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"
#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
* @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;
{
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;
}
/*******************************************************************
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 :
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
* 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
*
* ****************************************************************/
uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo)
{
- uint16_t copyLen;
Buffer *mBuf;
KwuDatReqInfo *datReqInfo;
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;
}
{
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));
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
**********************************************************************/
Code Review / o-du / l2.git / blobdiff