Desc: Source code for RLC Utility Module
This file contains following functions
- --rlcUtlSndToLi
- --rlcUtlRcvFrmLi
+ --rlcUtlSendToMac
+ --rlcUtlRcvFrmMac
--rlcUtlEmptySduQ
- --rlcUtlSndDStaRsp
- --rlcUtlSndDatInd
+ --rlcUtlSendDedLcBoStatus
+ --rlcUtlSendUlDataToDu
--kwUtlShutDown
File: kw_utl_dl.c
#include "kw_udx.x" /* UDX interface includes */
#include "kw_dl.x" /* RLC downlink includes */
+#include "rlc_utils.h"
+#include "rlc_mac_inf.h"
+#include "rlc_lwr_inf_api.h"
+
#include "ss_rbuf.h"
#include "ss_rbuf.x"
-EXTERN SsRngBufCnt rngCb;
+SsRngBufCnt rngCb;
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
-extern U32 isDatReqProcessed;
+uint32_t isDatReqProcessed;
#endif
#define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_DL) /* for debugging purpose */
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)) || defined (SS_RBUF)
-EXTERN void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
+void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
#endif
Void ResetRLCStats(Void)
{
RlcCb* dlInst = rlcCb[1];
RlcCb* ulInst = rlcCb[0];
- cmMemset((U8*)&gRlcStats, 0, sizeof(RLCStats));
- cmMemset((U8*)&dlInst->genSts,0,sizeof(RlcGenSts));
- cmMemset((U8*)&ulInst->genSts,0,sizeof(RlcGenSts));
+ memset(&gRlcStats, 0, sizeof(RLCStats));
+ memset(&dlInst->genSts,0,sizeof(RlcGenSts));
+ memset(&ulInst->genSts,0,sizeof(RlcGenSts));
}
#ifndef ALIGN_64BIT
* This function stores DL PDU info for all logical channels
* of per UE grant per TTI and sends to MAC
*
- * Function : RlcLiRguDDatReq
+ * Function : rlcSendDedLcDlData
*
* @params[in]
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-#ifdef ANSI
-S16 RlcLiRguDDatReq
-(
-Pst *post,
-SpId spId,
-RguDDatReqInfo *datReqInfo
-)
-#else
-S16 RlcLiRguDDatReq(post, spId, datReqInfo)
-Pst *post;
-SpId spId;
-RguDDatReqInfo *datReqInfo;
-#endif
+uint8_t rlcSendDedLcDlData(Pst *post, SpId spId, RguDDatReqInfo *datReqInfo)
{
- U8 ueIdx; /* UE info list iterator */
- U8 tbIdx; /* TB info list iterator */
- U8 lchIdx; /* Lch info list iterator */
- U8 pduIdx; /* RLC PDU list iterator */
+ uint8_t ueIdx; /* UE info list iterator */
+ uint8_t tbIdx; /* TB info list iterator */
+ uint8_t lchIdx; /* Lch info list iterator */
+ uint8_t pduIdx; /* RLC PDU list iterator */
RguDDatReqPerUe datPerUe; /* DL data info per UE */
RguDatReqTb datPerTb; /* DL data info per TB */
RguLchDatReq datPerLch; /* DL data info per Lch */
- RlcMacData *dlData; /* DL data to be sent to MAC */
-
- TRC3(RlcLiRguDDatReq)
+ RlcData *dlData; /* DL data to be sent to MAC */
+ Pst pst; /* Post structure */
+ uint16_t pduLen; /* PDU length */
+ uint16_t copyLen; /* Number of bytes copied */
dlData = NULLP;
- RLC_ALLOC_SHRABL_BUF(post->region, post->pool,
- dlData, sizeof(RlcMacData));
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ dlData, sizeof(RlcData));
#if (ERRCLASS & ERRCLS_ADD_RES)
- if ( datReqInfo == NULLP )
+ if ( dlData == NULLP )
{
- RLOG0(L_FATAL,"Memory allocation failed");
+ DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed for dl data");
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ datReqInfo, sizeof(RguDDatReqInfo));
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
{
datPerUe = datReqInfo->datReq[ueIdx];
- cmMemset((U8 *)dlData, 0, sizeof(RlcMacData));
+ memset(dlData, 0, sizeof(RlcData));
dlData->cellId = datReqInfo->cellId;
dlData->rnti = datPerUe.rnti;
- //dlData->timeToTx = datPerUe.transId; /* Derive timing info from transId */
+
+ /* Retrieving sfn/slot from transId. It was filled in RlcProcSchedResultRpt */
+ dlData->slotInfo.sfn = datPerUe.transId >> 16;
+ dlData->slotInfo.slot = datPerUe.transId & 0xffff;
dlData->numPdu = 0;
for(tbIdx = 0; tbIdx < datPerUe.nmbOfTbs; tbIdx++)
{
dlData->pduInfo[dlData->numPdu].commCh = FALSE;
dlData->pduInfo[dlData->numPdu].lcId = datPerLch.lcId;
- dlData->pduInfo[dlData->numPdu].pduBuf = datPerLch.pdu.mBuf[pduIdx];
+
+ /* Copy Message to fixed buffer to send */
+ ODU_GET_MSG_LEN(datPerLch.pdu.mBuf[pduIdx], (MsgLen *)&pduLen);
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ dlData->pduInfo[dlData->numPdu].pduBuf, pduLen);
+
+ if (dlData->pduInfo[dlData->numPdu].pduBuf == NULLP )
+ {
+ DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed");
+ for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
+ {
+ RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
+ dlData->pduInfo[pduIdx].pduLen);
+ }
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ dlData, sizeof(RlcData));
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ datReqInfo, sizeof(RguDDatReqInfo));
+ return RFAILED;
+ }
+
+ ODU_COPY_MSG_TO_FIX_BUF(datPerLch.pdu.mBuf[pduIdx], 0, pduLen, \
+ dlData->pduInfo[dlData->numPdu].pduBuf, (MsgLen *)©Len);
+ dlData->pduInfo[dlData->numPdu].pduLen = pduLen;
+
+ /* Free message */
+ ODU_PUT_MSG_BUF(datPerLch.pdu.mBuf[pduIdx]);
+
dlData->numPdu++;
}/* For per PDU */
}/* For Data per Lch */
}/* For Data per Tb */
- RlcMacSendDlData(post, spId, dlData);
+
+ /* Sending DL Data per UE to MAC */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_RLC_TO_MAC(pst, RLC_DL_INST, EVENT_DL_DATA_TO_MAC);
+ if(RlcSendDlDataToMac(&pst, dlData) != ROK)
+ {
+ for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
+ {
+ RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
+ dlData->pduInfo[pduIdx].pduLen);
+ }
+ RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData, sizeof(RlcData));
+ }
} /* For Data per UE */
- /* Check if to be freed here */
-
- RLC_FREE_SHRABL_BUF(post->region,
- post->pool,
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
datReqInfo, sizeof(RguDDatReqInfo));
return ROK;
-}/* End of RlcLiRguDDatReq */
+}/* End of rlcSendDedLcDlData */
/**
*
* -# RFAILED
*
*/
-#ifdef ANSI
-S16 rlcUtlSndToLi
-(
-RlcCb *gCb,
-SuId suId,
-KwDStaIndInfo *staIndInfo
-)
-#else
-S16 rlcUtlSndToLi(gCb, suId, staIndInfo)
-RlcCb *gCb;
-SuId suId;
-KwDStaIndInfo *staIndInfo;
-#endif
+uint8_t rlcUtlSendToMac(RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo)
{
+ uint8_t numPdu = 0;
+ uint16_t ueIdx;
RlcDlUeCb *ueCb; /* UE control block */
- U32 count; /* Loop Counter */
- U32 numTb; /* Number of Tbs */
+ uint32_t count; /* Loop Counter */
+ uint32_t numTb; /* Number of Tbs */
RlcDlRbCb *rbCb; /* RB Control Block */
RlcDatReq datReq; /* PDUs Information */
RguDDatReqInfo *datReqInfo; /* Data Request Information */
- RlcRguSapCb *rguSap; /* MAC SAP CB */
- U32 totNumPdu; /* Total number of PDUS */
+ RlcRguSapCb *rguSap; /* MAC SAP CB */
+ uint32_t totNumPdu; /* Total number of PDUS */
RguStaIndTb *staIndTb = NULLP;
RguDatReqTb *datReqTb = NULLP;
RguDStaIndPerUe *staInd = NULLP;
#ifdef LTE_L2_MEAS
- U32 grantPerLch[RGU_MAX_LC] = {0};
+ uint32_t grantPerLch[RGU_MAX_LC] = {0};
#endif
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_LOSS_DELAY
- U8 snIdx1;
- U8 snIdx2;
+ uint8_t snIdx1;
+ uint8_t snIdx2;
#endif /* LTE_L2_MEAS */
- U32 idx;
+ uint32_t idx;
//Debug
- U32 staIndSz=0,datIndSz = 0;
- TRC2(rlcUtlSndToLi)
-
+ uint32_t staIndSz=0,datIndSz = 0;
datReqInfo = NULLP;
- RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap->pst.region,
- gCb->u.dlCb->rguDlSap->pst.pool,
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
datReqInfo,sizeof(RguDDatReqInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( datReqInfo == NULLP )
{
- RLOG_ARG0(L_FATAL,DBG_CELLID,staIndInfo->cellId,
- "Memory allocation failed");
+ DU_LOG("\nRLC: rlcUtlSendToMac: Memory allocation failed");
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
{
staInd = &staIndInfo->staInd[idx];
/* Fetch Ue control block */
- if(ROK != rlcDbmFetchDlUeCb(gCb,staInd->rnti,staIndInfo->cellId,&ueCb))
+ GET_UE_IDX(staInd->rnti, ueIdx);
+ if(ROK != rlcDbmFetchDlUeCb(gCb, ueIdx, staIndInfo->cellId,&ueCb))
{
/* Fetch UeCb failed */
- RLOG_ARG1(L_ERROR, DBG_CELLID,staIndInfo->cellId,
- "UeId[%u]:ueCb not found",
- staInd->rnti);
+ DU_LOG("\nRLC: rlcUtlSendToMac: UeId[%u]:ueCb not found",
+ staInd->rnti);
/* If ueCb is not found for current rnti then continue to look for next rnti*/
continue;
}
/* kw002.201 Removed the allocation of RlcDatReq */
/* kw004.201 Used SSI function to initialize the variable */
- cmMemset( (U8 *)&datReq, 0, sizeof(RlcDatReq) );
+ memset(&datReq, 0, sizeof(RlcDatReq) );
totNumPdu = 0;
for (numTb = 0; numTb < staInd->nmbOfTbs; numTb++)
{
continue;
}
totNumPdu += datReq.pduInfo.numPdu;
- cmMemcpy((U8 *)(&(datReqTb->lchData[count].pdu)),
- (U8 *)(&(datReq.pduInfo)),sizeof(KwPduInfo));
+ memcpy(&(datReqTb->lchData[count].pdu),
+ &(datReq.pduInfo),sizeof(KwPduInfo));
-//Debug
- U8 numPdu = 0;
for (;numPdu < datReqTb->lchData[count].pdu.numPdu ; numPdu ++)
{
MsgLen len = 0;
- SFndLenMsg(datReqTb->lchData[count].pdu.mBuf[numPdu],&len);
+ ODU_GET_MSG_LEN(datReqTb->lchData[count].pdu.mBuf[numPdu],&len);
datIndSz += len;
}
datReqTb->lchData[count].setMaxUlPrio = FALSE;
datReqTb->lchData[count].boReport.oldestSduArrTime =
datReq.boRep.oldestSduArrTime;
/* kw004.201 Used SSI function to initialize the variable */
- cmMemset( (U8 *)&datReq, 0, sizeof(RlcDatReq) );
+ memset(&datReq, 0, sizeof(RlcDatReq) );
}
}
#ifdef LTE_L2_MEAS
else
{
cmHashListInsert(&(rlcCb.rlcL2Cb.tbHlCp),(PTR)tbSnMap,
- (U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
+ (uint8_t *) &(tbSnMap->tbId), (uint16_t)sizeof(tbSnMap->tbId));
rlcCb.rlcL2Cb.curTbSnMap = NULLP;
}
#endif /* LTE_L2_MEAS */
}
datReqInfo->cellId = staIndInfo->cellId;
datReqInfo->nmbOfUeGrantPerTti = staIndInfo->nmbOfUeGrantPerTti;
- /* If trace flag is enabled send the trace indication */
- if(TRUE == gCb->init.trc )
- {
- /* Populate the trace params */
- rlcLmmSendTrc(gCb,EVTRGUDDATREQ, NULLP);
- }
rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
-//Debug
- RlcLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo);
+ rlcSendDedLcDlData(&rguSap->pst,rguSap->spId,datReqInfo);
return ROK;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-S16 rlcUtlSndDStaRsp
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-S32 bo,
-S32 estHdrSz,
-Bool staPduPrsnt,
-U32 staPduBo
-)
-#else
-S16 rlcUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-S32 bo;
-S32 estHdrSz;
-Bool staPduPrsnt;
-U32 staPduBo;
-#endif
+uint8_t rlcUtlSendDedLcBoStatus(RlcCb *gCb, RlcDlRbCb *rbCb, int32_t bo, \
+ int32_t estHdrSz, bool staPduPrsnt, uint32_t staPduBo)
{
- RlcMacBOStatus boStatus; /* Buffer occupancy status information */
- RlcRguSapCb *rguSap; /* MAC SAP Information */
- TRC3(rlcUtlSndDStaRsp)
+ Pst pst; /* Post info */
+ RlcBoStatus *boStatus; /* Buffer occupancy status information */
+
#ifndef TENB_ACC
- if ((rbCb->lastRprtdBoToMac > (U32)8000) && (rbCb->boUnRprtdCnt < (U32)5)
+ if ((rbCb->lastRprtdBoToMac > (uint32_t)8000) && (rbCb->boUnRprtdCnt < (uint32_t)5)
&& (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
{
rbCb->boUnRprtdCnt++;
return ROK;
}
#endif
+ rbCb->boUnRprtdCnt = (uint32_t)0;
+ rbCb->lastRprtdBoToMac = (uint32_t)bo;
- rguSap = &(gCb->u.dlCb->rguDlSap[rbCb->rguSapId]);
-
- rbCb->boUnRprtdCnt = (U32)0;
- rbCb->lastRprtdBoToMac = (U32)bo;
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, \
+ boStatus, sizeof(RlcBoStatus));
- boStatus.cellId = rbCb->rlcId.cellId;
- boStatus.rnti = rbCb->rlcId.ueId;
- boStatus.commCh = FALSE;
- boStatus.lcId = rbCb->lch.lChId;
- boStatus.bo = bo;
+ boStatus->cellId = rbCb->rlcId.cellId;
+ boStatus->ueIdx = rbCb->rlcId.ueId;
+ boStatus->commCh = FALSE;
+ boStatus->lcId = rbCb->lch.lChId;
+ boStatus->bo = bo;
- /* If trace flag is enabled send the trace indication */
- if(gCb->init.trc == TRUE)
+ FILL_PST_RLC_TO_MAC(pst, RLC_DL_INST, EVENT_BO_STATUS_TO_MAC);
+ /* Send Status Response to MAC layer */
+ if(RlcSendBoStatusToMac(&pst, boStatus) != ROK)
{
- /* Populate the trace params */
- rlcLmmSendTrc(gCb, EVTRLCBOSTA, NULLP);
+ RLC_FREE_SHRABL_BUF(pst.region, pst.pool, boStatus, sizeof(RlcBoStatus));
}
- /* Send Status Response to MAC layer */
- RlcMacSendBOStatus(&rguSap->pst,rguSap->spId,&boStatus);
-
return ROK;
}
CmLList *firstSduSnMap; /* First Node in SDU SnMap Queue */
RlcSduSnMap *sduSnMap; /* SDU Sn Map */
- TRC2(rlcUtlEmptySduQ)
sduSnMapQ = NULLP;
firstSduSnMap = NULLP;
sduSnMap = NULLP;
}
}
#endif
- RETVOID;
+ return;
}
/**
*
* @return void
*/
-#ifdef ANSI
-Void rlcUtlCalcLiForSdu
-(
-RlcCb *gCb,
-U16 numLi,
-MsgLen msgLen,
-S16 *pduSz
-)
-#else
-Void rlcUtlCalcLiForSdu(gCb,numLi,msgLen,pduSz)
-RlcCb *gCb;
-U16 numLi;
-MsgLen msgLen;
-S16 *pduSz;
-#endif
+void rlcUtlCalcLiForSdu(RlcCb *gCb, uint16_t numLi, MsgLen msgLen, int16_t *pduSz)
{
- TRC2(rlcUtlCalcLiForSdu)
-
if ( (*pduSz > msgLen) && (msgLen < RLC_2K_BYTE))
{
if(0 == (numLi & RLC_BIT0)) /* check if number of LIs are odd or even */
*pduSz -= 1;
}
}
- RETVOID;
+ return;
}
/**
RlcDlRbCb *rbCb;
#endif
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = TRUE;
rbCb->m.umDl.estHdrSz= 0;
}
- rlcUtlSndDStaRsp(gCb, rbCb, 0, 0, FALSE,0);
+ rlcUtlSendDedLcBoStatus(gCb, rbCb, 0, 0, FALSE,0);
- RETVOID;
+ return;
}
/**
* TRUE : Re-establishment is in progress
* FALSE : Re-establishment is not in progress
*/
-#ifdef ANSI
-Bool rlcDlUtlIsReestInProgress
-(
-RlcDlRbCb *rbCb
-)
-#else
-Bool rlcDlUtlIsReestInProgress(rbCb)
-RlcDlRbCb *rbCb;
-#endif
+bool rlcDlUtlIsReestInProgress(RlcDlRbCb *rbCb)
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
-
return (rbCb->reestInProgress);
}
RlcDlRbCb *rbCb;
#endif
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = FALSE;
}
RlcDlUeCb *ueCb;
#endif
{
- U32 rbIdx;
+ uint32_t rbIdx;
- TRC2(rlcDlUtlSetReestInProgressForAllRBs)
-
for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
{
if(ueCb->srbCb[rbIdx] != NULLP)
}
}
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlIncrementKwuStsSduTx
-(
-RlcKwuSapCb *rlckwuSap
-)
-#else
-Void rlcUtlIncrementKwuStsSduTx(rlckwuSap)
-RlcKwuSapCb *rlckwuSap;
-#endif
+void rlcUtlIncrementKwuStsSduTx(RlcKwuSapCb *rlckwuSap)
{
rlckwuSap->sts.sduTx++;
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlIncrementGenStsBytesAndPdusSent
-(
-RlcGenSts *genSts,
-Buffer *pdu
-)
-#else
-Void rlcUtlIncrementGenStsBytesAndPdusSent(genSts, pdu)
-RlcGenSts *genSts;
-Buffer *pdu;
-#endif
+void rlcUtlIncrementGenStsBytesAndPdusSent(RlcGenSts *genSts, Buffer *pdu)
{
MsgLen bytesSent;
- SFndLenMsg(pdu, &bytesSent);
+ ODU_GET_MSG_LEN(pdu, &bytesSent);
genSts->bytesSent += bytesSent;
genSts->pdusSent++;
- RETVOID;
+ return;
}
/**
cmLListInit(&(toBeFreed->reTxLst));
cmLListInit(&(toBeFreed->txLst));
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlRaiseDlCleanupEvent
-(
-RlcCb *gCb
-)
-#else
-Void rlcUtlRaiseDlCleanupEvent(gCb)
-RlcCb *gCb;
-#endif
+void rlcUtlRaiseDlCleanupEvent(RlcCb *gCb)
{
#ifdef KWSELFPSTDLCLEAN
if(!gCb->u.dlCb->eventInQueue)
{
- SPstTsk(&gCb->u.dlCb->selfPst, gCb->u.dlCb->selfPstMBuf);
+ ODU_POST_TASK(&gCb->u.dlCb->selfPst, gCb->u.dlCb->selfPstMBuf);
gCb->u.dlCb->eventInQueue = TRUE;
}
#endif
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlAddSduToBeFreedQueue
-(
-RlcCb *gCb,
-RlcSdu *sdu
-)
-#else
-Void rlcUtlAddSduToBeFreedQueue(gCb, sdu)
-RlcCb *gCb;
-RlcSdu *sdu;
-#endif
+void rlcUtlAddSduToBeFreedQueue(RlcCb *gCb, RlcSdu *sdu)
{
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.sduLst), &(sdu->lstEnt));
- RETVOID;
+ return;
}
/**
#endif
{
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.reTxLst), &(retx->lstEnt));
- RETVOID;
+ return;
}
/**
{
pdu->rlsLnk.node = (PTR)pdu;
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.txLst), &(pdu->rlsLnk));
- RETVOID;
+ return;
}
/*
* - FALSE if all the data has been freed
*/
#ifdef ANSI
-PRIVATE Bool rlcUtlFreeDlAmRbMemory
+static Bool rlcUtlFreeDlAmRbMemory
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 *toBeFreed
+uint32_t *toBeFreed
)
#else
-PRIVATE Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
+static Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 *toBeFreed
+uint32_t *toBeFreed
#endif
{
RlcRetx *retx; /* retransmission buffer */
RlcSn mTxNext; /* send state variable */
RlcTx *txBuf;
- TRC2(rlcUtlFreeDlAmRbMemory)
-
-
MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
/* TODO : to be checked changed from <= to < */
(*toBeFreed)--;
}
- return (FALSE);;
+ return (FALSE);
}
/**
RlcCb *gCb;
#endif
{
- U32 toBeFreed;
+ uint32_t toBeFreed;
/* safety check, in case some event was still lying in the queue after
the dlCb was deleted*/
if(!gCb->u.dlCb)
{
- RETVOID;
+ return;
}
RlcDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
rlcUtlRaiseDlCleanupEvent(gCb);
}
- RETVOID;
+ return;
}
*/
S16 rlcUtlL2MeasDlInit(RlcCb *gCb)
{
- U16 cntr;
+ uint16_t cntr;
gCb->u.dlCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
+ memset(&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_DISC].measCb.measType = LKW_L2MEAS_DL_DISC;
gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_IP].measCb.measType = LKW_L2MEAS_DL_IP;
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcContSduLst *contSduLst,
-S32 dataVol,
-U32 schPduSz
+S32 dataVol,
+uint32_t schPduSz
)
#else
Void rlcUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcContSduLst *contSduLst;
-S32 dataVol;
-U32 schPduSz;
+S32 dataVol;
+uint32_t schPduSz;
#endif
{
- RlcL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
- RlcL2MeasTb *l2MeasTb = NULLP;
- U8 idx;
- U8 currTbIdx;
- VOLATILE U32 startTime = 0;
+ RlcL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
+ RlcL2MeasTb *l2MeasTb = NULLP;
+ uint8_t idx;
+ uint8_t currTbIdx;
+ volatile uint32_t startTime = 0;
RlcContSduLst *dstContSduLst;
- TRC2(rlcUtlUpdateBurstSdus)
/*starting Task*/
if(l2MeasTb->numLcId >= RLC_MAX_ACTV_DRB)
{
/* ccpu00143043 */
- RETVOID;
+ return;
}
l2MeasTb->sduInfo[l2MeasTb->numLcId].lcId = rbCb->lch.lChId;
/* Copy all the sduIdx from sduInfo to tb sduInfo */
/*stopping Task*/
SStopTask(startTime, PID_RLC_DLIP_TPT_BURSTCALC);
- RETVOID;
+ return;
}
/**
* @brief
#ifdef ANSI
Void rlcUtlUpdateContainedSduLst
(
-U8 sduIdx,
+uint8_t sduIdx,
RlcContSduLst *contSduLst
)
#else
Void rlcUtlUpdateContainedSduLst(sduIdx, contSduLst)
-U8 sduIdx;
+uint8_t sduIdx;
RlcContSduLst *contSduLst;
#endif
{
contSduLst->sduIdx[contSduLst->numSdus] = sduIdx;
contSduLst->numSdus++;
}
- RETVOID;
+ return;
}
/**
Void rlcUtlUpdateOutStandingSduLst
(
RlcL2MeasDlIpTh *dlIpThPut,
-U8 sduIdx,
+uint8_t sduIdx,
MsgLen sduLen,
-U32 sduId,
+uint32_t sduId,
Bool newIdx
)
#else
Void rlcUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
RlcL2MeasDlIpTh *dlIpThPut;
-U8 sduIdx;
+uint8_t sduIdx;
MsgLen sduLen;
-U32 sduId;
+uint32_t sduId;
Bool newIdx;
#endif
{
dlIpThPut->outStngSduArr[sduIdx].sduId = sduId;
dlIpThPut->outStngSduArr[sduIdx].sduLen = sduLen;
}
- RETVOID;
+ return;
}
#ifdef ANSI
RlcL2MeasTb * rlcUtlGetCurMeasTb
#endif
{
RlcL2MeasTb *curL2MeasTb;
- U16 idx;
+ uint16_t idx;
- TRC3(rlcUtlGetCurMeasTb)
-
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
/* Intentionally avoiding the RLC_ALLOC macro to avoid memset */
#ifdef ANSI
S16 rlcUtlProcHarqInd
(
-RlcCb *gCb,
+RlcCb *gCb,
RguHarqStatusInd *hqStaInd,
-RlcDlUeCb *ueCb,
-U8 tbIdx
+RlcDlUeCb *ueCb,
+uint8_t tbIdx
)
#else
S16 rlcUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
RlcCb *gCb;
-RguHarqStatusInd *hqStaInd;
-RlcDlUeCb *ueCb;
-U8 tbIdx;
+RguHarqStatusInd *hqStaInd;
+RlcDlUeCb *ueCb;
+uint8_t tbIdx;
#endif
{
#ifdef LTE_L2_MEAS
- RlcDlRbCb *rlcRbCb; /* KW Control Block */
- RlcL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
- U8 lcIdx; /* Logical channel id index */
- U8 sduIndx; /* sdu index to out standing sdu list in rbCb */
- U32 numSdus; /* number of sdus in the outstanding sdu list */
+ RlcDlRbCb *rlcRbCb; /* KW Control Block */
+ RlcL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
+ uint8_t lcIdx; /* Logical channel id index */
+ uint8_t sduIndx; /* sdu index to out standing sdu list in rbCb */
+ uint32_t numSdus; /* number of sdus in the outstanding sdu list */
RlcOutStngSduInfo *outStngSduArr; /* Outstanding sdu list */
- Ticks ackTime;
- Ticks delay;
- U32 totlSduCnt = 0;
+ Ticks ackTime;
+ Ticks delay;
+ uint32_t totlSduCnt = 0;
#endif
- U8 timeAddedFlag;
- S16 ret;
- VOLATILE U32 startTime = 0;
+ uint8_t timeAddedFlag;
+ S16 ret;
+ volatile uint32_t startTime = 0;
/*kw005.201 Code added for DL IP thruput measurement*/
- TRC3(rlcUtlProcHarqInd)
-
/*starting Task*/
SStartTask(&startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
RlcL2MeasEvtCb *measEvtCb;
#endif
{
- U32 qciIdx;
- RlcL2MeasCb *measCb = NULLP;
- RlcL2MeasCfmEvt measCfmEvt;
- U32 posPkts;
- U32 dLoss;
-
- U64 dlDataVol;
- U64 dlTime;
- U16 cntr;
+ uint32_t qciIdx;
+ RlcL2MeasCb *measCb = NULLP;
+ RlcL2MeasCfmEvt measCfmEvt;
+ uint32_t posPkts;
+ uint32_t dLoss;
+ uint64_t dlDataVol;
+ uint64_t dlTime;
+ uint16_t cntr;
/* Discard new changes starts */
- U8 qci = 0;
- U32 cfmIdx =0;
+ uint8_t qci = 0;
+ uint32_t cfmIdx =0;
/* Discard new changes ends */
- TRC3(rlcUtlSndL2MeasCfm)
-
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
+ memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- TRC3(rlcUtlSndDlL2MeasNCfm)
RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
(
RlcCb *gCb,
RlcL2MeasCb *measCb,
-U8 measType
+uint8_t measType
)
#else
Void rlcUtlResetDlL2MeasInRlcRb(gCb, measCb, measType)
RlcCb *gCb;
RlcL2MeasCb *measCb;
-U8 measType;
+uint8_t measType;
#endif
{
- U32 ueIdx;
- U32 qciIdx;
+ uint32_t ueIdx;
+ uint32_t qciIdx;
RlcDlUeCb *ueCb = NULL;
/* for now the only meas should be DL discard in this case */
if (measCb->measType & LKW_L2MEAS_DL_DISC)
{
- U32 i;
+ uint32_t i;
for(i = 0; i < measCb->val.nonIpThMeas.numQci; i++)
{
- U8 qciVal = measCb->val.nonIpThMeas.qci[i];
+ uint8_t qciVal = measCb->val.nonIpThMeas.qci[i];
measCb->val.nonIpThMeas.measData[qciVal].dlDisc.discSdus = 0;
measCb->val.nonIpThMeas.measData[qciVal].dlDisc.totSdus = 0;
}
if (measCb->measType & LKW_L2MEAS_DL_DELAY)
{
- U32 i;
+ uint32_t i;
for(i = 0; i < measCb->val.nonIpThMeas.numQci; i++)
{
- U8 qciVal = measCb->val.nonIpThMeas.qci[i];
+ uint8_t qciVal = measCb->val.nonIpThMeas.qci[i];
measCb->val.nonIpThMeas.measData[qciVal].dlPjSduDelay.sduDelay = 0;
}
} /* rlcUtlResetDlL2MeasInRlcRb */
#endif
-PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
+static Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
{
if(dlRbCb->mode == CM_LTE_MODE_UM)
{
}
else if(dlRbCb->mode == CM_LTE_MODE_AM)
{
- U32 j, numTxPdus=0;
+ uint32_t j, numTxPdus=0;
for(j = 0; j <= (RLC_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
{
RlcTx *txBuf = rlcUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
(PTR) ueCb,
(PTR *)&ueCb))
{
- U32 i;
+ uint32_t i;
for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
RlcDlRbCb* dlRbCb = ueCb->srbCb[i];
* @b Description
* This function returns current time
*
- * @param[in] U32
+ * @param[in] uint32_t
*
*
* @return Void
*/
-#ifdef ANSI
-void rlcUtlGetCurrTime
-(
- U32 *currTime
-)
-#else
-void rlcUtlGetCurrTime(U32 *currTime)
-U32 *currTime;
-#endif
+void rlcUtlGetCurrTime(uint32_t *currTime)
{
- TRC2(rlcUtlGetCurrTime)
-
/* Need t define else part for PAL */
*currTime = SGetTtiCount();
}
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 pktAdmitCnt
+uint32_t pktAdmitCnt
)
#else
Void rlcUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 pktAdmitCnt;
+uint32_t pktAdmitCnt;
#endif
{
KwuFlowCntrlIndInfo *flowCntrlInfo;
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlStoreTxBuf
-(
-CmLListCp *txBufLst,
-RlcTx *txBuf,
-RlcSn sn
-)
-#else
-Void rlcUtlStoreTxBuf(txBufLst, txBuf, sn)
-CmLListCp *txBufLst;
-RlcTx *txBuf;
-RlcSn sn;
-#endif
+void rlcUtlStoreTxBuf(CmLListCp *txBufLst, RlcTx *txBuf, RlcSn sn)
{
- U32 hashKey;
+ uint32_t hashKey;
- TRC3(kwUtlStoretxBuf)
- //printf("S-sn(%d)\n", sn);
hashKey = (sn % RLC_TX_BUF_BIN_SIZE );
txBuf->sn = sn;
txBuf->lnk.node = (PTR)txBuf;
cmLListAdd2Tail(&(txBufLst[hashKey]), &txBuf->lnk);
- RETVOID;
+ return;
} /* rlcUtlStoreRecBuf */
/**
*
* @return Void
*/
-#ifdef ANSI
-RlcTx* rlcUtlGetTxBuf
-(
-CmLListCp *txBufLst,
-RlcSn sn
-)
-#else
-RlcTx* rlcUtlGetTxBuf(txBufLst, sn)
-CmLListCp *txBufLst;
-RlcSn sn;
-#endif
+RlcTx* rlcUtlGetTxBuf(CmLListCp *txBufLst, RlcSn sn)
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *txBufLstCp;
- RlcTx *txBuf;
+ RlcTx *txBuf;
CmLList *node = NULLP;
- TRC3(rlcUtlGetTxBuf)
- //printf("G-sn(%d)\n", sn);
-
hashKey = (sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
}
CM_LLIST_NEXT_NODE(txBufLstCp, node);
}
- return (NULLP);
+ return NULLP;
} /* rlcUtlStoreTxBuf */
/**
*
RlcCb *gCb;
#endif
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *txBufLstCp;
- TRC3(rlcUtlDelTxBuf)
-
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
RLC_FREE_WC(gCb, txBuf, sizeof(RlcTx));
- RETVOID;
+ return;
} /* rlcUtlDelTxBuf */
/**
RlcCb *gCb;
#endif
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *txBufLstCp;
- TRC3(rlcUtlRemovTxBuf)
-
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
- RETVOID;
+ return;
} /* rlcUtlRemovTxBuf */
Code Review / o-du / l2.git / blobdiff