Desc: Source code for RLC Lower Interface Module.
This file contains following functions
- --KwLiRguBndCfm
- --KwLiRguCDatInd
- --KwLiRguDDatInd
- --KwLiRguCStaInd
- --KwLiRguDStaInd
- --KwLiRguHqStaInd
+ --RlcLiRguBndCfm
+ --rlcProcCommLcUlData
+ --rlcProcDedLcUlData
+ --rlcProcCommLcSchedRpt
+ --rlcProcDedLcSchedRpt
+ --RlcLiRguHqStaInd
File: kw_lim.c
**********************************************************************/
-static const char* RLOG_MODULE_NAME="LIM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=196;
/**
* @file kw_lim.c
* @brief RLC Lower Interface module
*/
-#define KW_MODULE KW_DBGMASK_INF
+#define RLC_MODULE RLC_DBGMASK_INF
\f
/* header (.h) include files */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-
-#include "gen.h" /* general */
-#include "ssi.h" /* system services */
-#include "cm5.h" /* common timer defines */
-#include "cm_tkns.h" /* common tokens defines */
-#include "cm_mblk.h" /* common memory allocation library defines */
-#include "cm_llist.h" /* common link list defines */
-#include "cm_hash.h" /* common hash list defines */
-#include "cm_lte.h" /* common LTE defines */
+#include "common_def.h"
#include "lkw.h" /* LKW defines */
#include "ckw.h" /* CKW defines */
#include "kwu.h" /* KWU defines */
#include "kw_ul.h"
/* extern (.x) include files */
-#include "gen.x" /* general */
-#include "ssi.x" /* system services */
-
-#include "cm5.x" /* common timer library */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_mblk.x" /* common memory allocation */
-#include "cm_llist.x" /* common link list */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lte.x" /* common LTE includes */
-#include "cm_lib.x" /* common memory allocation library */
#include "lkw.x" /* LKW */
#include "ckw.x" /* CKW */
#include "kwu.x" /* KWU */
#include "kw_udx.x"
#include "kw_dl.x"
#include "kw_ul.x"
+#include "rlc_utils.h"
+#include "rlc_mac_inf.h"
#ifdef __cplusplus
-EXTERN "C" {
+extern "C" {
#endif /* __cplusplus */
\f
*
* @details
* This function handles the bind confirmation received from MAC. If the
- * bind was successful changes the state of the SAP to KW_SAP_BND
- * else KW_SAP_CFG. Sends an alarm to LM in any case
+ * bind was successful changes the state of the SAP to RLC_SAP_BND
+ * else RLC_SAP_CFG. Sends an alarm to LM in any case
*
* @param[in] pst Post structure
* @param[in] suId Service User ID
* -# RFAILED
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguBndCfm
-(
-Pst *pst,
-SuId suId,
-U8 status
-)
-#else
-PUBLIC S16 KwLiRguBndCfm (pst, suId, status)
-Pst *pst;
-SuId suId;
-U8 status;
-#endif
+S16 RlcLiRguBndCfm(Pst *pst,SuId suId,uint8_t status)
{
- U16 event; /* Event */
- U16 cause; /* Cause */
- KwRguSapCb *rguSap; /* RGU SAP Control Block */
- KwCb *tKwCb;
-
- TRC3(KwLiRguBndCfm)
+ uint16_t event; /* Event */
+ uint16_t cause; /* Cause */
+ RlcRguSapCb *rguSap; /* RGU SAP Control Block */
+ RlcCb *tRlcCb;
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG,"KwLiRguBndCfm(suId(%d), status(%d)", suId, status);
+ DU_LOG("\nDEBUG --> RLC UL : RlcLiRguBndCfm(suId(%d), status(%d)", suId, status);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (tKwCb->init.cfgDone != TRUE)
+ if (tRlcCb->init.cfgDone != TRUE)
{
- RLOG0(L_FATAL,"General configuration not done");
+ DU_LOG("\nERROR --> RLC UL : General configuration not done");
- KW_SEND_SAPID_ALARM(tKwCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0))
+ if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
- RLOG0(L_ERROR, "Invalid suId");
+ DU_LOG("\nERROR --> RLC UL : Invalid suId");
- KW_SEND_SAPID_ALARM(tKwCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
+ RLC_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- rguSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
- &(tKwCb->u.dlCb->rguDlSap[suId]) : &(tKwCb->u.ulCb->rguUlSap[suId]);
+ rguSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
+ &(tRlcCb->u.dlCb->rguDlSap[suId]) : &(tRlcCb->u.ulCb->rguUlSap[suId]);
- RLOG1(L_DEBUG, "KwLiRguBndCfm: For RGU SAP state=%d", rguSap->state)
+ DU_LOG("\nDEBUG --> RLC UL : RlcLiRguBndCfm: For RGU SAP state=%d", rguSap->state);
switch (rguSap->state)
{
- case KW_SAP_BINDING:
+ case RLC_SAP_BINDING:
{
- kwStopTmr (tKwCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM);
+ rlcStopTmr (tRlcCb,(PTR)rguSap, EVENT_RLC_WAIT_BNDCFM);
rguSap->retryCnt = 0;
if (status == CM_BND_OK)
{
- rguSap->state = KW_SAP_BND;
+ rguSap->state = RLC_SAP_BND;
event = LCM_EVENT_BND_OK;
cause = LKW_CAUSE_SAP_BNDENB;
}
else
{
- rguSap->state = KW_SAP_CFG;
+ rguSap->state = RLC_SAP_CFG;
event = LCM_EVENT_BND_FAIL;
cause = LKW_CAUSE_UNKNOWN;
}
}
/* Send an alarm with proper event and cause */
- KW_SEND_SAPID_ALARM(tKwCb, suId, event, cause);
-
- RETVALUE(ROK);
-} /* KwLiRguBndCfm */
-
-/**
- * @brief Handler to process PDU received from MAC
- *
- * @details
- * This function receives the PDU from MAC.
- * seggregates common and dedicated logical channel
- * PDU and call respective handler.
- *
- * @param[in] pst Post structure
- * @param[in] suId Service User ID
- * @param[in] datInd Data Indication Information
- *
- * @return S16
- * -# ROK
- * -# RFAILED
- *
-*/
-
-PUBLIC S16 RlcMacProcUlData(Pst *pst, SuId suId, RlcMacData *ulData)
-{
- U8 idx;
- U8 lcId; /* Logical Channel */
- U8 numDLch = 0; /* Number of dedicated logical channel */
- Bool dLchPduPres; /* PDU received on dedicated logical channel */
- RguLchDatInd dLchData[RGU_MAX_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 */
- for(idx = 0; idx < RGU_MAX_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->nmbPdu; idx++)
- {
- if(ulData->pduInfo[idx].commCh)
- {
- cmMemset((U8*)&cLchUlDat, (U8)0, sizeof(RguCDatIndInfo));
-
- cLchUlDat.cellId = ulData->cellId;
- cLchUlDat.rnti = ulData->rnti;
- cLchUlDat.lcId = ulData->pduInfo[idx].lcId;
- cLchUlDat.pdu = ulData->pduInfo[idx].pduBuf;
-
- KwLiRguCDatInd(pst, suId, &cLchUlDat);
- }
- else
- {
- if(!dLchPduPres)
- {
- dLchPduPres = TRUE;
- }
-
- lcId = ulData->pduInfo[idx].lcId;
- dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu] = ulData->pduInfo[idx].pduBuf;
- dLchData[lcId].pdu.numPdu++;
- }
- }
-
- /* If any PDU received on dedicated logical channel, copy into RguDDatIndInfo
- * and call its handler */
- if(dLchPduPres)
- {
- dLchUlDat.cellId = ulData->cellId;
- dLchUlDat.rnti = ulData->rnti;
-
- for(idx = 0; idx < RGU_MAX_LC; idx++)
- {
- if(dLchData[idx].pdu.numPdu)
- {
- cmMemcpy((U8 *)&dLchUlDat.lchData[numDLch], (U8 *)&dLchData[idx], sizeof(RguLchDatInd));
- numDLch++;
- }
- }
- dLchUlDat.numLch = numDLch;
- KwLiRguDDatInd(pst, suId, &dLchUlDat);
- }
+ RLC_SEND_SAPID_ALARM(tRlcCb, suId, event, cause);
- RETVALUE(ROK);
-
-}/* End of RlcMacProcUlData */
+ return (ROK);
+} /* RlcLiRguBndCfm */
-PUBLIC int rlcDDatIndRcvd;
-PUBLIC int rlcCDatIndRcvd;
+int rlcDDatIndRcvd;
+int rlcCDatIndRcvd;
/**
* @brief Handler to process PDU received from MAC for common logical channels.
*
* -# RFAILED
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguCDatInd
-(
-Pst *pst,
-SuId suId,
-RguCDatIndInfo *datInd
-)
-#else
-PUBLIC S16 KwLiRguCDatInd(pst,suId,datInd)
-Pst *pst;
-SuId suId;
-RguCDatIndInfo *datInd;
-#endif
+uint8_t rlcProcCommLcUlData(Pst *pst, SuId suId, RguCDatIndInfo *datInd)
{
- KwUlRbCb *rbCb;
- KwCb *tKwCb;
+ RlcUlRbCb *rbCb;
+ RlcCb *tRlcCb;
rlcCDatIndRcvd++;
- TRC3(KwLiRguCDatInd)
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE (RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
+ return RFAILED;
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
-
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#if (ERRCLASS & ERRCLS_DEBUG)
- if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
+ if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
+ return RFAILED;
}
#endif
/* kw006.201 ccpu00120058, Added array boundary condition check */
#if (ERRCLASS & ERRCLS_DEBUG)
- if(KW_MAX_LCH_PER_CELL <= datInd->lcId)
+ if(RLC_MAX_LCH_PER_CELL <= datInd->lcId)
{
- RLOG_ARG1(L_ERROR,DBG_LCID,datInd->lcId, "Invalid LcId, Max is [%d]",
- KW_MAX_LCH_PER_CELL);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> RLC UL : rlcProcCommLcUlData : Invalid LcId [%d], Max is [%d]",\
+ datInd->lcId, RLC_MAX_LCH_PER_CELL);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fetch RbCb from lcId */
- kwDbmFetchUlRbCbFromLchId(tKwCb, 0, datInd->cellId, datInd->lcId, &rbCb);
+ rlcDbmFetchUlRbCbFromLchId(tRlcCb, datInd->rnti, datInd->cellId, datInd->lcId, &rbCb);
if (!rbCb)
{
- RLOG_ARG1(L_ERROR, DBG_CELLID,datInd->cellId, "LcId [%d] not found",
+ DU_LOG("\nERROR --> RLC UL : rlcProcCommLcUlData : LcId [%d] not found",
datInd->lcId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
+ return RFAILED;
}
/* Dispatch to TM Module */
#ifdef CCPU_OPT
- kwTmmRcvFrmLi(tKwCb, rbCb, datInd->rnti, datInd->pdu);
+ rlcTmmRcvFrmMac(tRlcCb, rbCb, datInd->rnti, datInd->pdu);
#else /* CCPU_OPT */
- kwTmmRcvFrmLi(tKwCb, rbCb, datInd->pdu);
+ rlcTmmRcvFrmMac(tRlcCb, rbCb, datInd->pdu);
#endif /* CCPU_OPT */
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(ROK);
-} /* KwLiRguCDatInd */
+ return (ROK);
+} /* rlcProcCommLcUlData */
/**
* @brief Handler to process PDU received from MAC for
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguDDatInd
-(
-Pst *pst,
-SuId suId,
-RguDDatIndInfo *datInd
-)
-#else
-PUBLIC S16 KwLiRguDDatInd(pst, suId, datInd)
-Pst *pst;
-SuId suId;
-RguDDatIndInfo *datInd;
-#endif
+uint8_t rlcProcDedLcUlData(Pst *pst, SuId suId, RguDDatIndInfo *datInd)
{
- TRC3(KwLiRguDDatInd)
-
rlcDDatIndRcvd++;
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
- RETVALUE (RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguDDatIndInfo));
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
- if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
+ if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- RLOG1(L_DEBUG,"KwLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
- RETVALUE(RFAILED);
+ DU_LOG("\nDEBUG --> RLC UL : rlcProcDedLcUlData : suId(%d))recieved in DL Inst", suId);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguDDatIndInfo));
+ return RFAILED;
}
#endif
- kwUtlRcvFrmLi(KW_GET_KWCB(pst->dstInst),datInd);
+ rlcUtlRcvFrmMac(RLC_GET_RLCCB(pst->dstInst),datInd);
#ifndef SS_RBUF
#ifdef SS_LOCKLESS_MEMORY
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguDDatIndInfo));
#else
- KW_PST_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
+ RLC_PST_FREE(RLC_MEM_REGION_UL, RLC_POOL, datInd, sizeof(RguDDatIndInfo));
#endif
#endif
- RETVALUE(ROK);
-} /* KwLiRguDDatInd */
-
-
-/*******************************************************************
- *
- * @brief Handler for extracting common and dedicated channel
- * Scheduling result report.
- *
- * @details
- *
- * Function : RlcMacProcSchedRep
- *
- * Functionality:
- * Handler for extracting common and dedicated channel
- * Scheduling result report
- *
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-PUBLIC S16 RlcMacProcSchedRep(Pst *pst, SuId suId,RlcMacSchedRep *schRep)
-{
- U8 idx; /* Iterator */
- U8 nmbDLch = 0; /* Number of dedicated logical channles */
- RguCStaIndInfo cLchSchInfo; /* Common logical channel scheduling result */
- RguDStaIndInfo dLchSchInfo; /* Dedicated logical channel scheduling result */
-
- for(idx=0; idx < schRep->nmbLch; idx++)
- {
- /* If it is common channel, fill status indication information
- * and trigger the handler for each common lch separately */
- if(schRep->lchSta[idx].commCh)
- {
- cmMemset((U8*)&cLchSchInfo, (U8)0, sizeof(RguCStaIndInfo));
-
- cLchSchInfo.cellId = schRep->cellId;
- cLchSchInfo.lcId = schRep->lchSta[idx].lchStaInd.lcId;
- //cLchSchInfo.transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */
- cLchSchInfo.rnti = schRep->rnti;
-
- KwLiRguCStaInd(pst, suId, &cLchSchInfo);
-
- }
- else
- {
- /* Fill status info structure if at least one dedicated channel
- * scheduling report is received */
- if(nmbDLch == 0)
- {
- dLchSchInfo.cellId = schRep->cellId;
- dLchSchInfo.nmbOfUeGrantPerTti = 1;
- dLchSchInfo.staInd[0].rnti = schRep->rnti;
- //dLchSchInfo.staInd[0].transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */
- dLchSchInfo.staInd[0].nmbOfTbs = 1;
- //dLchSchInfo.staInd[0].fillCrlPdu = /* TODO : Check the value needed to be filled */
- }
-
- /* Fill logical channel scheduling info */
- cmMemcpy((U8 *)&dLchSchInfo.staInd[0].staIndTb[0].lchStaInd[nmbDLch], (U8 *)&schRep->lchSta[idx].lchStaInd, sizeof(RguLchStaInd));
- nmbDLch++;
-
- }
-
- }
-
- /* Calling handler for all dedicated channels scheduling*/
- if(nmbDLch)
- {
- dLchSchInfo.staInd[0].staIndTb[0].nmbLch = nmbDLch;
- KwLiRguDStaInd(pst, suId, &dLchSchInfo);
- }
-
- RETVALUE(ROK);
-}
+ return ROK;
+} /* rlcProcDedLcUlData */
/**
* @brief Handler for trigerring the data transfer from RLC to MAC
* -# RFAILED
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguCStaInd
-(
-Pst *pst,
-SuId suId,
-RguCStaIndInfo *staInd
-)
-#else
-PUBLIC S16 KwLiRguCStaInd(pst,suId,staInd)
-Pst *pst;
-SuId suId;
-RguCStaIndInfo *staInd;
-#endif
+uint8_t rlcProcCommLcSchedRpt(Pst *pst, SuId suId, RguCStaIndInfo *staInd)
{
- KwDlRbCb *rbCb;
- KwCb *tKwCb;
-
- TRC3(KwLiRguCStaInd)
+ RlcDlRbCb *rbCb;
+ RlcCb *tRlcCb;
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE (RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
+ return (RFAILED);
}
#endif
- tKwCb = KW_GET_KWCB(pst->dstInst);
-
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0))
+ if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
{
- KWLOGERROR(tKwCb,
- ERRCLS_INT_PAR,
- EKW040,
- (ErrVal) suId,
- "KwLiRguCStaInd: Invalid RGU suId\n");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> RLC UL : rlcProcCommLcSchedRpt: Invalid RGU suId %d\n", suId);
+ return RFAILED;
}
- if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
+ if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
- RLOG_ARG1(L_ERROR,DBG_LCID,staInd->lcId,
- "Received in RLC UL CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC UL : rlcProcCommLcSchedRpt: Received in RLC UL CELLID:%d",
staInd->cellId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE(RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
+ return RFAILED;
}
#endif
/* kw006.201 ccpu00120058, added boundary condition check */
#if (ERRCLASS & ERRCLS_DEBUG)
- if(KW_MAX_LCH_PER_CELL < staInd->lcId)
+ if(RLC_MAX_LCH_PER_CELL < staInd->lcId)
{
- RLOG_ARG2(L_ERROR,DBG_LCID,staInd->lcId,
- "Invalid LcId, Max is [%d] CELLID:%d",
- KW_MAX_LCH_PER_CELL,
- staInd->cellId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> RLC UL : rlcProcCommLcSchedRpt: Invalid LcId, Max is [%d] CELLID:%d",
+ RLC_MAX_LCH_PER_CELL, staInd->cellId);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fertch RbCb from lcId */
- kwDbmFetchDlRbCbFromLchId(tKwCb,0, staInd->cellId, staInd->lcId, &rbCb);
+ rlcDbmFetchDlRbCbFromLchId(tRlcCb,0, staInd->cellId, staInd->lcId, &rbCb);
if(!rbCb)
{
- RLOG_ARG1(L_ERROR, DBG_CELLID,staInd->cellId,
- "LcId [%d] not found CELLID:%d",
- staInd->lcId);
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> RLC UL : rlcProcCommLcSchedRpt: LcId [%d] not found CELLID:%d",
+ staInd->lcId, staInd->cellId);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
+ return RFAILED;
}
/* Dispatch to TM Module */
rbCb->transId = staInd->transId;
- /* ccpu00136940 */
- /* If trace flag is enabled send the trace indication */
- if(tKwCb->init.trc == TRUE)
- {
- /* Populate the trace params */
- kwLmmSendTrc(tKwCb,EVTRGUCSTAIND, NULLP);
- }
- kwTmmSndToLi(tKwCb, suId, rbCb, staInd);
+ rlcTmmSendToMac(tRlcCb, suId, rbCb, staInd);
#ifndef SS_RBUF
#ifdef SS_LOCKLESS_MEMORY
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
#else
- KW_PST_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_PST_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
#endif
#else
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguCStaIndInfo));
#endif
- RETVALUE(ROK);
-} /* KwLiRguCStaInd */
+ return ROK;
+} /* rlcProcCommLcSchedRpt */
/**
* @brief Handler for trigerring the data transfer from RLC to MAC
* -# RFAILED
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguDStaInd
-(
-Pst *pst,
-SuId suId,
-RguDStaIndInfo *staInd
-)
-#else
-PUBLIC S16 KwLiRguDStaInd(pst, suId, staInd)
-Pst *pst;
-SuId suId;
-RguDStaIndInfo *staInd;
-#endif
+uint8_t rlcProcDedLcSchedRpt(Pst *pst, SuId suId, RguDStaIndInfo *staInd)
{
- KwCb *gCb;
- TRC3(KwLiRguDStaInd)
+ RlcCb *gCb;
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
+ if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- RETVALUE (RFAILED);
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguDStaIndInfo));
+ return RFAILED;
}
#endif
- gCb = KW_GET_KWCB(pst->dstInst);
+ gCb = RLC_GET_RLCCB(pst->dstInst);
#if (ERRCLASS & ERRCLS_INT_PAR)
- if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL)
+ if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"Received in RLC UL ");
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- RETVALUE(RFAILED);
+ DU_LOG("\nDEBUG --> RLC UL : rlcProcDedLcSchedRpt: Received in RLC UL ");
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguDStaIndInfo));
+ return RFAILED;
}
if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0))
{
- KWLOGERROR(gCb,
- ERRCLS_INT_PAR,
- EKW040,
- (ErrVal) suId,
- "KwLiRguDStaInd: Invalid RGU suId\n");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> RLC UL : rlcProcDedLcSchedRpt: Invalid RGU suId %d\n", suId);
+ return (RFAILED);
}
#endif
- kwUtlSndToLi(gCb, suId, staInd);
+ rlcUtlSendToMac(gCb, suId, staInd);
/* kw002.201 :Freeing from proper region */
- KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- RETVALUE(ROK);
-} /* KwLiRguDStaInd */
+ RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, staInd, sizeof(RguDStaIndInfo));
+ return ROK;
+} /* rlcProcDedLcSchedRpt */
/**
* @brief Handler for handling the flow cntrl Ind from MAC
*
* @details
* This function receives the flow control indication from
- * MAC and calls kwUtlTrigPdbFlowCntrl
+ * MAC and calls rlcUtlTrigPdbFlowCntrl
*
* @param[in] pst Post structure
* @param[in] suId Service User ID
* -# RFAILED
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguFlowCntrlInd
-(
-Pst *pst,
-SuId suId,
-RguFlowCntrlInd *flowCntrlInd
-)
-#else
-PUBLIC S16 KwLiRguFlowCntrlInd(pst, suId, flowCntrlInd)
-Pst *pst;
-SuId suId;
-RguFlowCntrlInd *flowCntrlInd;
-#endif
+S16 RlcLiRguFlowCntrlInd(Pst *pst,SuId suId,RguFlowCntrlInd *flowCntrlInd)
{
- KwCb *tKwCb;
- KwDlRbCb *rbCb = NULLP;
- U32 idx;
- U32 lcIdx;
+ RlcCb *tRlcCb;
+ RlcDlRbCb *rbCb = NULLP;
+ uint32_t idx;
+ uint32_t lcIdx;
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
for (idx = 0; idx < flowCntrlInd->numUes; idx++)
{
for (lcIdx = 0; lcIdx < flowCntrlInd->ueFlowCntrlInfo[idx].numLcs; lcIdx++)
{
RguLcFlowCntrlInfo *lcInfo = &(flowCntrlInd->ueFlowCntrlInfo[idx].lcInfo[lcIdx]);
- kwDbmFetchDlRbCbFromLchId(tKwCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
+ rlcDbmFetchDlRbCbFromLchId(tRlcCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
if (rbCb)
{
if (lcInfo->pktAdmitCnt == 0) /* Special case */
{
- kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt);
+ rlcUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
continue;
}
- if (rbCb->mode == CM_LTE_MODE_AM)
+ if (rbCb->mode == RLC_MODE_AM)
{
if ((rbCb->m.amDl.retxLst.count != 0) ||
((rbCb->m.amDl.bo == 0) ||
continue;
}
}
- kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt);
+ rlcUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
* -# RFAILED
*
*/
-#ifdef ANSI
-PUBLIC S16 KwLiRguHqStaInd
-(
-Pst *pst,
-SuId suId,
-RguHarqStatusInd *staInd
-)
-#else
-PUBLIC S16 KwLiRguHqStaInd(pst,suId,staInd)
-Pst *pst;
-SuId suId;
-RguHarqStatusInd *staInd;
-#endif
+S16 RlcLiRguHqStaInd(Pst *pst, SuId suId,RguHarqStatusInd *staInd)
{
- KwUeKey ueKey;
- S16 ret;
- KwDlUeCb *ueCb;
- U8 tbIdx;
- KwCb *tKwCb;
-
- TRC3(KwLiRguHqStaInd)
+ RlcUeKey ueKey;
+ S16 ret;
+ RlcDlUeCb *ueCb;
+ uint8_t tbIdx;
+ RlcCb *tRlcCb;
- tKwCb = KW_GET_KWCB(pst->dstInst);
+ tRlcCb = RLC_GET_RLCCB(pst->dstInst);
ueKey.cellId = staInd->cellId;
ueKey.ueId = staInd->ueId;
- ret = kwDbmFetchDlUeCb(tKwCb, ueKey.ueId, ueKey.cellId, &ueCb);
+ ret = rlcDbmFetchDlUeCb(tRlcCb, ueKey.ueId, ueKey.cellId, &ueCb);
if (ret != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- /*Call kwUtlProcHarqInd as many times as number of Tbs present*/
+ /*Call rlcUtlProcHarqInd as many times as number of Tbs present*/
for ( tbIdx = 0; tbIdx < staInd->numTbs; tbIdx++)
{
- kwUtlProcHarqInd(tKwCb, staInd, ueCb, tbIdx);
+ rlcUtlProcHarqInd(tRlcCb, staInd, ueCb, tbIdx);
}
- RETVALUE(ROK);
-} /* KwLiRguHqStaInd */
+ return (ROK);
+} /* RlcLiRguHqStaInd */
#endif /* LTE_L2_MEAS */
#ifdef __cplusplus