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 "du_app_rlc_inf.h"
+#include "rlc_lwr_inf_api.h"
+#include "rlc_upr_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
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- RLOG4(L_ALWAYS,"RLC Stats: AMDL: "
+ RLOG4(L_ALWAYS,"RLC Stats: RLC_AMDL: "
"StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu,
gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
- RLOG3(L_ALWAYS,"RLC Stats: AMDL: "
+ RLOG3(L_ALWAYS,"RLC Stats: RLC_AMDL: "
"DRB:%lu MaxRetx:%lu RetransPdus:%lu",
gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus);
- RLOG4(L_ALWAYS,"RLC Stats: AMUL: "
+ RLOG4(L_ALWAYS,"RLC Stats: RLC_AMUL: "
" PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ",
gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires,
gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
RTLIN_DUMP_DEBUG("RLC Stats:"
- "AMDL: StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu DRB:%lu MaxRetx:%lu RetransPdus:%lu \n"
- "AMUL: PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu \n",
+ "RLC_AMDL: StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu DRB:%lu MaxRetx:%lu RetransPdus:%lu \n"
+ "RLC_AMUL: PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu \n",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, gRlcStats.amRlcStats.numDLBytesUnused,
gRlcStats.amRlcStats.numDLPollTimerExpiresSrb, gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus, gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires,
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- RLOG4(L_ALWAYS,"RLC Stats: AMDL: "
+ RLOG4(L_ALWAYS,"RLC Stats: RLC_AMDL: "
"StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu,
gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
- RLOG3(L_ALWAYS,"RLC Stats: AMDL: "
+ RLOG3(L_ALWAYS,"RLC Stats: RLC_AMDL: "
"DRB:%lu MaxRetx:%lu RetransPdus:%lu",
gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus);
- RLOG4(L_ALWAYS,"RLC Stats: AMUL: "
+ RLOG4(L_ALWAYS,"RLC Stats: RLC_AMUL: "
" PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ",
gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires,
gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
/* RTLIN_DUMP_DEBUG("AM RLC Stats:"
- "AMDL: SDUs Tx :(%u) SDU Bytes Tx :(%u) SDUs Retx :(%u) MaxRetx:(%u) WindowStalls: (%u) \n"
- "AMUL: DropOutWinRx :(%u) SDUs Rx :(%u) SDU Bytes Rx :(%u) SDUNack Rx :(%u) Duplicate Pdu Rx :(%u) \n",
+ "RLC_AMDL: SDUs Tx :(%u) SDU Bytes Tx :(%u) SDUs Retx :(%u) MaxRetx:(%u) WindowStalls: (%u) \n"
+ "RLC_AMUL: DropOutWinRx :(%u) SDUs Rx :(%u) SDU Bytes Rx :(%u) SDUNack Rx :(%u) Duplicate Pdu Rx :(%u) \n",
gRlcStats.amRlcStats.numRlcAmCellSduTx, gRlcStats.amRlcStats.numRlcAmCellSduBytesTx,
gRlcStats.amRlcStats.numRlcAmCellRetxPdu, gRlcStats.amRlcStats.numRlcAmMaxRetx, gRlcStats.amRlcStats.numRlcAmCellWinStall,
gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx, gRlcStats.amRlcStats.numRlcAmCellSduRx,
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- RTLIN_DUMP_DEBUG("AMDL: StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u DRB:%u MaxRetx:%u RetransPdus:%u \n"
+ RTLIN_DUMP_DEBUG("RLC_AMDL: StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u DRB:%u MaxRetx:%u RetransPdus:%u \n"
" SDUs Tx :(%u) SDU Bytes Tx :(%u) SDUs Retx :(%u) WindowStalls: (%u) \n"
- "AMUL: PdusDiscarded:%u ReOrdTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u \n"
+ "RLC_AMUL: PdusDiscarded:%u ReOrdTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u \n"
" DropOutWinRx :(%u) SDUs Rx :(%u) SDU Bytes Rx :(%u) SDUNack Rx :(%u) Duplicate Pdu Rx:(%u) \n",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, gRlcStats.amRlcStats.numDLBytesUnused,
gRlcStats.amRlcStats.numDLPollTimerExpiresSrb, gRlcStats.amRlcStats.numDLPollTimerExpiresDrb,
* 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 */
+ RlcDlRrcMsgRsp *dlRrcMsgRsp;/* DL Data Msg Rsp sent to DU */
+ 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));
-#if (ERRCLASS & ERRCLS_ADD_RES)
- if ( datReqInfo == NULLP )
+ dlRrcMsgRsp = NULLP;
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ dlData, sizeof(RlcData));
+ 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 */
for(ueIdx = 0; ueIdx < datReqInfo->nmbOfUeGrantPerTti; ueIdx++)
{
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);
+
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
+ if( dlRrcMsgRsp == NULLP )
+ {
+ DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed for dlRrcMsgRsp");
+ 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));
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+ datReqInfo, sizeof(RguDDatReqInfo));
+ return RFAILED;
+ }
+
+ dlRrcMsgRsp->cellId = dlData->cellId;
+ dlRrcMsgRsp->crnti = dlData->rnti;
+
+ /* 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));
+ /* Update DL RRC MSG Rsp State */
+ dlRrcMsgRsp->state = TRANSMISSION_FAILED;
+ }
+ else
+ dlRrcMsgRsp->state = TRANSMISSION_COMPLETE;
+
+ /* Send Dl RRC Msg Rsp to DU APP */
+ FILL_PST_RLC_TO_DUAPP(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_RSP_TO_DU);
+ if(rlcSendDlRrcMsgRspToDu(&pst, dlRrcMsgRsp) != ROK)
+ {
+ RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
+ }
} /* 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++)
{
datReq.totMacGrant = grantPerLch[staIndTb->lchStaInd[count].lcId];
#endif
rlcUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
- if ( CM_LTE_MODE_UM == rbCb->mode )
+ if ( RLC_MODE_UM == rbCb->mode )
{
rlcUmmProcessSdus(gCb,rbCb,&datReq);
}
- else if ( CM_LTE_MODE_AM == rbCb->mode )
+ else if ( RLC_MODE_AM == rbCb->mode )
{
rlcAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
}
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;
- if (RLC_AM_IS_POLL_BIT_SET(AMDL) &&
- (AMDL.sduQ.count > 1))
+ if (RLC_AM_IS_POLL_BIT_SET(RLC_AMDL) &&
+ (RLC_AMDL.sduQ.count > 1))
{
/* Poll bit is set indicate to MAC*/
datReqTb->lchData[count].setMaxUlPrio = TRUE;
#ifdef L2_OPTMZ
/* Set if Bearer is UM */
- if ( CM_LTE_MODE_UM == rbCb->mode )
+ if ( RLC_MODE_UM == rbCb->mode )
{
datReqTb->lchData[count].freeBuff = TRUE;
}
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)
- && (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
+ if ((rbCb->lastRprtdBoToMac > (uint32_t)8000) && (rbCb->boUnRprtdCnt < (uint32_t)5)
+ && (!staPduPrsnt) && ((RLC_MODE_AM == rbCb->mode ) && (RLC_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]);
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, \
+ boStatus, sizeof(RlcBoStatus));
- rbCb->boUnRprtdCnt = (U32)0;
- rbCb->lastRprtdBoToMac = (U32)bo;
+ boStatus->cellId = rbCb->rlcId.cellId;
+ boStatus->ueIdx = rbCb->rlcId.ueId;
+ boStatus->commCh = FALSE;
+ boStatus->lcId = rbCb->lch.lChId;
+ boStatus->bo = bo;
- boStatus.cellId = rbCb->rlcId.cellId;
- boStatus.rnti = 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;
}
*/
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
-#ifdef ANSI
Void rlcUtlEmptySduQ
(
RlcCb *gCb,
CmLListCp *sduQ
)
#else
-Void rlcUtlEmptySduQ(gCb,rbCb, sduQ)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-CmLListCp *sduQ;
-#endif
-#else
-#ifdef ANSI
Void rlcUtlEmptySduQ
(
RlcCb *gCb,
CmLListCp *sduQ
)
-#else
-Void rlcUtlEmptySduQ(gCb,sduQ)
-RlcCb *gCb;
-CmLListCp *sduQ;
-#endif
#endif
{
#ifdef LTE_L2_MEAS_RLC
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;
}
/**
*
* @return void
*/
-#ifdef ANSI
-Void rlcDlUtlSetReestInProgressForRB
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb
-)
-#else
-Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-#endif
+Void rlcDlUtlSetReestInProgressForRB(RlcCb *gCb,RlcDlRbCb *rbCb)
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = TRUE;
- if(rbCb->mode == CM_LTE_MODE_AM )
+ if(rbCb->mode == RLC_MODE_AM )
{
rbCb->m.amDl.estHdrSz = 0;
- if(rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
+ if(rlcChkTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
}
else
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);
}
*
* @return Void
*/
-#ifdef ANSI
-Void rlcDlUtlResetReestInProgress
-(
-RlcDlRbCb *rbCb
-)
-#else
-Void rlcDlUtlResetReestInProgress(rbCb)
-RlcDlRbCb *rbCb;
-#endif
+Void rlcDlUtlResetReestInProgress(RlcDlRbCb *rbCb)
{
- TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = FALSE;
}
*
* @return void
*/
-#ifdef ANSI
-Void rlcDlUtlSetReestInProgressForAllRBs
-(
-RlcCb *gCb,
-RlcDlUeCb *ueCb
-)
-#else
-Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
-RlcCb *gCb;
-RlcDlUeCb *ueCb;
-#endif
+Void rlcDlUtlSetReestInProgressForAllRBs(RlcCb *gCb,RlcDlUeCb *ueCb)
{
- U32 rbIdx;
+ uint32_t rbIdx;
- TRC2(rlcDlUtlSetReestInProgressForAllRBs)
-
for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
{
if(ueCb->srbCb[rbIdx] != NULLP)
else
{
/* For SRB we just need to stop the poll re-transmit timer */
- if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR))
+ if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], EVENT_RLC_AMDL_POLL_RETX_TMR);
}
}
}
}
}
- 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;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlInitToBeFreed
-(
-RlcCb *gCb,
-RlcDlDataToBeFreed *toBeFreed
-)
-#else
-Void rlcUtlInitToBeFreed(gCb, toBeFreed)
-RlcCb *gCb;
-RlcDlDataToBeFreed *toBeFreed;
-#endif
+Void rlcUtlInitToBeFreed(RlcCb *gCb,RlcDlDataToBeFreed *toBeFreed)
{
cmLListInit(&(toBeFreed->sduLst));
cmLListInit(&(toBeFreed->rbLst));
cmLListInit(&(toBeFreed->reTxLst));
cmLListInit(&(toBeFreed->txLst));
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlInitializeSelfPst
-(
-RlcCb *gCb
-)
-#else
-Void rlcUtlInitializeSelfPst(gCb)
-RlcCb *gCb;
-#endif
+Void rlcUtlInitializeSelfPst(RlcCb *gCb)
{
Pst *selfPst = &gCb->u.dlCb->selfPst;
*
* @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;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlAddReTxPduToBeFreedQueue
-(
-RlcCb *gCb,
-RlcRetx *retx
-)
-#else
-Void rlcUtlAddReTxPduToBeFreedQueue(gCb, retx)
-RlcCb *gCb;
-RlcRetx *retx;
-#endif
+Void rlcUtlAddReTxPduToBeFreedQueue(RlcCb *gCb,RlcRetx *retx)
{
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.reTxLst), &(retx->lstEnt));
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlAddTxPduToBeFreedQueue
-(
-RlcCb *gCb,
-RlcTx *pdu
-)
-#else
-Void rlcUtlAddTxPduToBeFreedQueue(gCb, pdu)
-RlcCb *gCb;
-RlcTx *pdu;
-#endif
+Void rlcUtlAddTxPduToBeFreedQueue(RlcCb *gCb,RlcTx *pdu)
{
pdu->rlsLnk.node = (PTR)pdu;
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.txLst), &(pdu->rlsLnk));
- RETVOID;
+ return;
}
/*
* - TRUE if more data to be freed
* - FALSE if all the data has been freed
*/
-#ifdef ANSI
-PRIVATE Bool rlcUtlFreeDlAmRbMemory
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-U32 *toBeFreed
-)
-#else
-PRIVATE Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-U32 *toBeFreed
-#endif
+static Bool rlcUtlFreeDlAmRbMemory(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t *toBeFreed)
{
RlcRetx *retx; /* retransmission buffer */
RlcSn mTxNext; /* send state variable */
RlcTx *txBuf;
- TRC2(rlcUtlFreeDlAmRbMemory)
-
-
- MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
+ MODAMT(RLC_AMDL.txNext, mTxNext, RLC_AMDL.txNextAck,RLC_AMDL.snModMask);
/* TODO : to be checked changed from <= to < */
while ((0 < mTxNext) && *toBeFreed)
{
- txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, AMDL.txNextAck);
+ txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, RLC_AMDL.txNextAck);
if (txBuf && txBuf->pduLst.first)
{
while(txBuf->pduLst.first)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
- RLC_FREE_BUF(pduInfo->pdu);
+ ODU_PUT_MSG_BUF(pduInfo->pdu);
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
- RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
+ RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
- rlcUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
+ rlcUtlDelTxBuf(RLC_AMDL.txBufLst, txBuf, gCb);
if(gCb->u.dlCb->shutdownReceived == 0)
{
(*toBeFreed)--;
}
}
- AMDL.txNextAck = (AMDL.txNextAck + 1) & AMDL.snModMask;
- MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
+ RLC_AMDL.txNextAck = (RLC_AMDL.txNextAck + 1) & RLC_AMDL.snModMask;
+ MODAMT(RLC_AMDL.txNext, mTxNext, RLC_AMDL.txNextAck,RLC_AMDL.snModMask);
}
if(*toBeFreed == 0)
{
}
#ifndef LTE_TDD
- RLC_FREE(gCb,AMDL.txBufLst, (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,RLC_AMDL.txBufLst, (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
- RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+ RLC_LLIST_FIRST_RETX(RLC_AMDL.retxLst, retx);
while (retx && (*toBeFreed)) /* Till to be freed becomes 0 */
{
- RLC_FREE_BUF(retx->seg);
+ ODU_PUT_MSG_BUF(retx->seg);
- cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
- RLC_FREE_WC(gCb, retx, sizeof(RlcRetx));
+ cmLListDelFrm(&RLC_AMDL.retxLst, &retx->lstEnt);
+ RLC_FREE(gCb, retx, sizeof(RlcRetx));
- RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+ RLC_LLIST_FIRST_RETX(RLC_AMDL.retxLst, retx);
if(gCb->u.dlCb->shutdownReceived == 0)
{
(*toBeFreed)--;
}
- AMDL.nxtRetx = NULLP;
+ RLC_AMDL.nxtRetx = NULLP;
/* clean up if there is info about STATUS PDU to be sent */
- if(AMDL.pStaPdu)
+ if(RLC_AMDL.pStaPdu)
{
Pst *udxPst;
udxPst = &gCb->u.dlCb->udxDlSap->pst;
RLC_FREE_SHRABL_BUF_WC(udxPst->region,
udxPst->pool,
- AMDL.pStaPdu,
+ RLC_AMDL.pStaPdu,
sizeof(RlcUdxDlStaPdu));
- AMDL.pStaPdu = NULLP;
+ RLC_AMDL.pStaPdu = NULLP;
}
if(*toBeFreed == 0)
(*toBeFreed)--;
}
- return (FALSE);;
+ return (FALSE);
}
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlFreeDlMemory
-(
-RlcCb *gCb
-)
-#else
-Void rlcUtlFreeDlMemory(gCb)
-RlcCb *gCb;
-#endif
+Void rlcUtlFreeDlMemory(RlcCb *gCb)
{
- 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;
{
RlcRetx* seg = (RlcRetx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
- RLC_FREE_BUF_WC(seg->seg);
- RLC_FREE_WC(gCb,seg, sizeof(RlcRetx));
+ ODU_PUT_MSG_BUF(seg->seg);
+ RLC_FREE(gCb,seg, sizeof(RlcRetx));
toBeFreed--;
}
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pdu->pduLst.first->node);
cmLListDelFrm(&pdu->pduLst, pdu->pduLst.first);
- RLC_FREE_BUF_WC(pduInfo->pdu);
- RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
+ ODU_PUT_MSG_BUF(pduInfo->pdu);
+ RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
- RLC_FREE_WC(gCb,pdu, sizeof(RlcTx));
+ RLC_FREE(gCb,pdu, sizeof(RlcTx));
toBeFreed--;
}
if(!moreToBeFreed)
{
cmLListDelFrm(lst, lst->first);
- RLC_FREE_WC(gCb, rbCb, sizeof(RlcDlRbCb));
+ RLC_FREE(gCb, rbCb, sizeof(RlcDlRbCb));
}
}
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;
* @return Void
*
*/
-#ifdef ANSI
Void rlcUtlUpdateBurstSdus
(
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;
-#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
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlUpdateContainedSduLst
-(
-U8 sduIdx,
-RlcContSduLst *contSduLst
-)
-#else
-Void rlcUtlUpdateContainedSduLst(sduIdx, contSduLst)
-U8 sduIdx;
-RlcContSduLst *contSduLst;
-#endif
+Void rlcUtlUpdateContainedSduLst(uint8_t sduIdx,RlcContSduLst *contSduLst)
{
if (contSduLst->numSdus < RLC_L2MEAS_MAX_OUTSTNGSDU)
{
contSduLst->sduIdx[contSduLst->numSdus] = sduIdx;
contSduLst->numSdus++;
}
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
Void rlcUtlUpdateOutStandingSduLst
(
RlcL2MeasDlIpTh *dlIpThPut,
-U8 sduIdx,
-MsgLen sduLen,
-U32 sduId,
-Bool newIdx
+uint8_t sduIdx,
+MsgLen sduLen,
+uint32_t sduId,
+Bool newIdx
)
-#else
-Void rlcUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
-RlcL2MeasDlIpTh *dlIpThPut;
-U8 sduIdx;
-MsgLen sduLen;
-U32 sduId;
-Bool newIdx;
-#endif
{
if (sduIdx < RLC_L2MEAS_MAX_OUTSTNGSDU)
{
dlIpThPut->outStngSduArr[sduIdx].sduId = sduId;
dlIpThPut->outStngSduArr[sduIdx].sduLen = sduLen;
}
- RETVOID;
+ return;
}
-#ifdef ANSI
-RlcL2MeasTb * rlcUtlGetCurMeasTb
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb
-)
-#else
-RlcL2MeasTb * rlcUtlGetCurMeasTb(gCb, rbCb)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-#endif
+RlcL2MeasTb * rlcUtlGetCurMeasTb(RlcCb *gCb,RlcDlRbCb *rbCb)
{
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 */
* -# ROK
*/
-#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;
-#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);
* -# ROK
*/
-#ifdef ANSI
-S16 rlcUtlSndDlL2MeasCfm
-(
-RlcCb *gCb,
-RlcL2MeasEvtCb *measEvtCb
-)
-#else
-S16 rlcUtlSndDlL2MeasCfm(gCb, measEvtCb)
-RlcCb *gCb;
-RlcL2MeasEvtCb *measEvtCb;
-#endif
+S16 rlcUtlSndDlL2MeasCfm(RlcCb *gCb,RlcL2MeasEvtCb *measEvtCb)
{
- 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;
* -# ROK
*/
-#ifdef ANSI
-S16 rlcUtlSndDlL2MeasNCfm
-(
-RlcCb *gCb,
-RlcL2MeasReqEvt *measReqEvt,
-RlcL2MeasCfmEvt *measCfmEvt
-)
-#else
-S16 rlcUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
-RlcCb *gCb;
-RlcL2MeasReqEvt *measReqEvt;
-RlcL2MeasCfmEvt *measCfmEvt;
-#endif
+S16 rlcUtlSndDlL2MeasNCfm(RlcCb *gCb,RlcL2MeasReqEvt *measReqEvt,RlcL2MeasCfmEvt *measCfmEvt)
{
- TRC3(rlcUtlSndDlL2MeasNCfm)
RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlResetDlL2MeasInRlcRb
-(
-RlcCb *gCb,
-RlcL2MeasCb *measCb,
-U8 measType
-)
-#else
-Void rlcUtlResetDlL2MeasInRlcRb(gCb, measCb, measType)
-RlcCb *gCb;
-RlcL2MeasCb *measCb;
-U8 measType;
-#endif
+Void rlcUtlResetDlL2MeasInRlcRb(RlcCb *gCb,RlcL2MeasCb *measCb,uint8_t measType)
{
- 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)
+ if(dlRbCb->mode == RLC_MODE_UM)
{
RLOG_ARG3(L_DEBUG,DBG_RBID,dlRbCb->rlcId.rbId,
"UM Downlink UEID:%d CELLID:%d Q size = %d",
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.umDl.sduQ.count);
}
- else if(dlRbCb->mode == CM_LTE_MODE_AM)
+ else if(dlRbCb->mode == RLC_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];
* @return Void
*/
-#ifdef ANSI
-void rlcUtlFreeDlMem
-(
- Void
-)
-#else
-void rlcUtlFreeDlMem()
-Void;
-#endif
+void rlcUtlFreeDlMem( Void)
{
rlcUtlFreeDlMemory(RLC_GET_RLCCB(RLC_DL_INST));
}
* @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();
}
#if defined(MAC_RLC_HARQ_STA_RBUF) || defined (SS_RBUF)
#ifdef LTE_L2_MEAS
-#ifdef ANSI
-void rlcUtlDlBatchProcHqStaInd
-(
- Void
-)
-#else
-void rlcUtlDlBatchProcHqStaInd()
-Void;
-#endif
+void rlcUtlDlBatchProcHqStaInd( Void)
{
/* Read from Ring Buffer and process PDCP packets */
//Pst pst = {0};
* @return Void
*
*/
-#ifdef ANSI
-Void rlcUtlTrigPdbFlowCntrl
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-U32 pktAdmitCnt
-)
-#else
-Void rlcUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-U32 pktAdmitCnt;
-#endif
+Void rlcUtlTrigPdbFlowCntrl(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t pktAdmitCnt)
{
KwuFlowCntrlIndInfo *flowCntrlInfo;
RlcKwuSapCb* rlckwuSap;
*
* @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 */
/**
*
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlDelTxBuf
-(
-CmLListCp *txBufLst,
-RlcTx *txBuf,
-RlcCb *gCb
-)
-#else
-Void rlcUtlDelTxBuf(txBufLst, txBuf, gCb)
-CmLListCp *txBufLst;
-RlcTx *txBuf;
-RlcCb *gCb;
-#endif
+Void rlcUtlDelTxBuf (CmLListCp *txBufLst,RlcTx *txBuf,RlcCb *gCb)
{
- 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;
+ RLC_FREE(gCb, txBuf, sizeof(RlcTx));
+ return;
} /* rlcUtlDelTxBuf */
/**
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlRemovTxBuf
-(
-CmLListCp *txBufLst,
-RlcTx *txBuf,
-RlcCb *gCb
-)
-#else
-Void rlcUtlRemovTxBuf(txBufLst, txBuf, gCb)
-CmLListCp *txBufLst;
-RlcTx *txBuf;
-RlcCb *gCb;
-#endif
+Void rlcUtlRemovTxBuf(CmLListCp *txBufLst,RlcTx *txBuf,RlcCb *gCb)
{
- 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