X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_amm_dl.c;h=29d612dd58c2880da71b11bf00063c161bf5a7d3;hb=2193e4cf01012809495be026097e8d7eacb9f0ac;hp=54b4b6d801495937dd9003d4d2f9bd3cbe4c9f2a;hpb=aee73991f728cc127d1ed76d5a52571d916235a4;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_amm_dl.c b/src/5gnrrlc/kw_amm_dl.c index 54b4b6d80..29d612dd5 100755 --- a/src/5gnrrlc/kw_amm_dl.c +++ b/src/5gnrrlc/kw_amm_dl.c @@ -64,26 +64,26 @@ static int RLOG_FILE_ID=189; //UDAY #ifdef L2_OPTMZ -extern U32 kwAmmStaPduList[512]; - U32 kwAmmStaPduListCnt = 0; +extern U32 rlcAmmStaPduList[512]; + U32 rlcAmmStaPduListCnt = 0; #endif /** @file gp_amm_dl.c @brief RLC Acknowledged Mode Downlink Module **/ -#define KW_MODULE (KW_DBGMASK_AM | KW_DBGMASK_DL) +#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_DL) -U32 kwStatusPduCnt, kwStatusAckCnt, kwStatusNcnt, kwSduSndCnt; +U32 rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt; /* local defines */ /* local externs */ /* forward references */ -EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb, +EXTERN Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwUdxStaPdu *pStaPdu)); + RlcUdxStaPdu *pStaPdu)); /* public variable declarations */ @@ -91,7 +91,7 @@ EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb, /* private variable declarations */ -#define KW_AM_RMV_HDR(_gCb, _rbCb, _retx) do { \ +#define RLC_AM_RMV_HDR(_gCb, _rbCb, _retx) do { \ if ((_retx)->yetToConst == FALSE) \ {\ Buffer *_pduInfo; \ @@ -104,117 +104,117 @@ EXTERN Void kwAmmDlHndlStatusPdu ARGS ((RlcCb *gCb, /* private function declarations */ -PRIVATE Void kwResegRetxPdus ARGS ((RlcCb *gCb, +PRIVATE Void rlcResegRetxPdus ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwDatReq *kwDatReq)); + RlcDatReq *rlcDatReq)); -PRIVATE Void kwRemRetxPdu ARGS ((RlcCb *gCb, +PRIVATE Void rlcRemRetxPdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwRetx *retx)); + RlcRetx *retx)); -PRIVATE Void kwAmmCreateStatusPdu ARGS ((RlcCb *gCb, +PRIVATE Void rlcAmmCreateStatusPdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwDatReq *kwDatReq)); + RlcDatReq *rlcDatReq)); -PRIVATE Void kwAmmDlMarkPduForReTx ARGS ((RlcCb *gCb, +PRIVATE Void rlcAmmDlMarkPduForReTx ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwRetx *retx)); + RlcRetx *retx)); -PRIVATE Void kwAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb, +PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, - KwSn sn, + RlcSn sn, KwuDatCfmInfo **datCfm)); -PRIVATE Void kwAmmDlSetTxNextAck ARGS((KwAmDl *amDl, KwSn sn)); +PRIVATE Void rlcAmmDlSetTxNextAck ARGS((RlcAmDl *amDl, RlcSn sn)); -PRIVATE Void kwAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb, +PRIVATE Void rlcAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, - KwSn mAckSn)); + RlcSn mAckSn)); -PRIVATE Void kwAssembleSdus ARGS ((RlcCb *gCb, +PRIVATE Void rlcAssembleSdus ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwDatReq *kwDatReq)); + RlcDatReq *rlcDatReq)); -PRIVATE Bool kwAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb, +bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - Bool newPdu, + bool newPdu, MsgLen bufSz)); -PRIVATE Void kwAmmCreatePdu ARGS ((RlcCb *gCb, +PRIVATE Void rlcAmmCreatePdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwAmHdr *amHdr, + RlcAmHdr *amHdr, RlcDlPduInfo *pduInfo, Buffer *pdu)); -PRIVATE Void kwAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, KwRetx *retx)); +PRIVATE Void rlcAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, RlcRetx *retx)); -PRIVATE Void kwGetNxtRetx ARGS ((RlcCb *gCb, KwRetx **retx)); +PRIVATE Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx)); -PRIVATE Void kwConstructAmHdr ARGS ((KwAmHdr *amHdr, +PRIVATE Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr, U8 *hdr, U8 snLen, U16 *idx)); -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb, +PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, - KwSn mAckSn, + RlcSn mAckSn, CmLList *retx, KwuDatCfmInfo **datCfm)); -PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb, - KwAmDl *amDl, - KwRetx **retx, - KwSn sn)); +PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb, + RlcAmDl *amDl, + RlcRetx **retx, + RlcSn sn)); -PRIVATE Void kwAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb, +PRIVATE Void rlcAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, - KwSduMap *sduMap, + RlcSduMap *sduMap, KwuDatCfmInfo **datCfm)); -PRIVATE Void kwAmmAddPduToRetxLst ARGS((KwAmDl *amDl, - KwRetx *retx)); +PRIVATE Void rlcAmmAddPduToRetxLst ARGS((RlcAmDl *amDl, + RlcRetx *retx)); -PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS( +PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS( ( RlcCb *gCb, -KwAmDl *amDl, -KwRetx **retx, +RlcAmDl *amDl, +RlcRetx **retx, RlcDlPduInfo *pduInfo )); -PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf ARGS( +PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ARGS( ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwNackInfo *nackSnInfo, -KwRetx **retx, +RlcNackInfo *nackSnInfo, +RlcRetx **retx, KwuDatCfmInfo **datCfm )); -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn ARGS( +PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn ARGS( ( RlcCb *gCb, RlcDlRbCb *rbCb, - KwNackInfo *nackSnInfo, + RlcNackInfo *nackSnInfo, CmLList **retxNode, KwuDatCfmInfo **datCfm )); PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ARGS( ( -KwAmDl *amDl, -KwNackInfo *nackInfo, +RlcAmDl *amDl, +RlcNackInfo *nackInfo, CmLList *retxNode, -KwNackInfo *nackSnInfo, +RlcNackInfo *nackSnInfo, U8 idx )); -PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS( +PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS( ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwSn sn, -KwSn mNackSn, +RlcSn sn, +RlcSn mNackSn, CmLList **retxNode, KwuDatCfmInfo **datCfm )); @@ -222,13 +222,13 @@ KwuDatCfmInfo **datCfm AM Module contains the following funcitons: - - kwAmmQSdu - - kwAmmProcessSdus - - kwAmmDlAssembleCntrlInfo - - kwResegRetxPdus - - kwAssembleSdus - - kwAmmDlCheckAndSetPoll - - kwAmmProcessPdus + - rlcAmmQSdu + - rlcAmmProcessSdus + - rlcAmmDlAssembleCntrlInfo + - rlcResegRetxPdus + - rlcAssembleSdus + - rlcAmmDlCheckAndSetPoll + - rlcAmmProcessPdus - rlcDlmHndlStaRsp - kwTriggerStatus - kwReassembleSdus @@ -251,28 +251,17 @@ KwuDatCfmInfo **datCfm * * @return Void */ -#ifdef ANSI -PUBLIC Void kwAmmSendDStaRsp -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwAmDl *amDl -) -#else -PUBLIC Void kwAmmSendDStaRsp(gCb, rbCb, amDl) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwAmDl *amDl; -#endif +void rlcAmmSendDedLcBoStatus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmDl *amDl) { - S32 bo = kwAmmCalculateBo(amDl); + int32_t bo = rlcAmmCalculateBo(amDl); if(bo) { - kwUtlSndDStaRsp(gCb, rbCb, bo, amDl->estHdrSz, amDl->cntrlBo ?TRUE:FALSE,amDl->cntrlBo); + rlcUtlSendDedLcBoStatus(gCb, rbCb, bo, amDl->estHdrSz, \ + amDl->cntrlBo ?TRUE:FALSE,amDl->cntrlBo); } - RETVOID; + return; } /** @@ -286,28 +275,28 @@ KwAmDl *amDl; * @return Void */ #ifdef ANSI -PRIVATE Void kwAmmDlCheckAndStopPollTmr +PRIVATE Void rlcAmmDlCheckAndStopPollTmr ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwSn mAckSn +RlcSn mAckSn ) #else -PRIVATE Void kwAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn) +PRIVATE Void rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn) RlcCb *gCb; RlcDlRbCb *rbCb; -KwSn mAckSn; +RlcSn mAckSn; #endif { - KwSn mPollSn; + RlcSn mPollSn; MODAMT(rbCb->m.amDl.pollSn, mPollSn, rbCb->m.amDl.txNextAck,rbCb->m.amDl.snModMask); if (mPollSn <= mAckSn) { - if (kwChkTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR)) + if (rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR)) { - kwStopTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR); } } @@ -323,15 +312,15 @@ KwSn mAckSn; * @return Void */ #ifdef ANSI -PRIVATE Void kwAmmDlSetTxNextAck +PRIVATE Void rlcAmmDlSetTxNextAck ( -KwAmDl *amDl, -KwSn sn +RlcAmDl *amDl, +RlcSn sn ) #else -PRIVATE Void kwAmmDlSetTxNextAck(amDl, sn) -KwAmDl *amDl; -KwSn sn +PRIVATE Void rlcAmmDlSetTxNextAck(amDl, sn) +RlcAmDl *amDl; +RlcSn sn #endif { amDl->txNextAck = sn; @@ -353,24 +342,24 @@ KwSn sn * @return Void */ #ifdef ANSI -PRIVATE Void kwAmmDlProcessSuccessfulReTx +PRIVATE Void rlcAmmDlProcessSuccessfulReTx ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwRetx *retx, +RlcRetx *retx, KwuDatCfmInfo **datCfm ) #else -PRIVATE Void kwAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm) +PRIVATE Void rlcAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm) RlcCb *gCb; RlcDlRbCb *rbCb; -KwRetx *retx; +RlcRetx *retx; KwuDatCfmInfo **datCfm; #endif { - kwAmmDlCheckIsSDUDelivered(gCb, rbCb, &(retx->sduMap), datCfm); + rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, &(retx->sduMap), datCfm); - kwRemRetxPdu(gCb, rbCb, retx); + rlcRemRetxPdu(gCb, rbCb, retx); RETVOID; } @@ -382,8 +371,8 @@ KwuDatCfmInfo **datCfm; * This function is used to move the PDU from the txBuf to re-transmit buffer * * @param[in]RlcCb *gCb RLC instance control block - * @param[in]KwAmDl *amDl AM Downlink Control Block - * @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by + * @param[in]RlcAmDl *amDl AM Downlink Control Block + * @param[in]RlcRetx **retx node in the reTx buffer to be moved to, allocated by * this function * @param[in]RlcDlPduInfo *pduInfo TX PDU which needs to be moved * @@ -392,25 +381,25 @@ KwuDatCfmInfo **datCfm; */ #ifdef ANSI -PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer +PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ( RlcCb *gCb, -KwAmDl *amDl, -KwRetx **retx, +RlcAmDl *amDl, +RlcRetx **retx, RlcDlPduInfo *pduInfo ) #else -PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo) +PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo) RlcCb *gCb; -KwAmDl *amDl; -KwRetx **retx; +RlcAmDl *amDl; +RlcRetx **retx; RlcDlPduInfo *pduInfo; #endif { - TRC2(kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer); + TRC2(rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer); - RLC_ALLOC_WC(gCb,*retx, sizeof(KwRetx)); + RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx)); #if (ERRCLASS & ERRCLS_ADD_RES) if (*retx == NULLP) @@ -434,12 +423,12 @@ RlcDlPduInfo *pduInfo; (*retx)->lstEnt.next = 0; (*retx)->lstEnt.prev = 0; /* copy the sdu maps */ - KW_MEM_CPY(&((*retx)->sduMap), + RLC_MEM_CPY(&((*retx)->sduMap), &pduInfo->sduMap, - sizeof(KwSduMap)); + sizeof(RlcSduMap)); - KW_MEM_CPY(&((*retx)->amHdr), &pduInfo->amHdr, sizeof(KwAmHdr)); - kwAmmAddPduToRetxLst(amDl, (*retx)); + RLC_MEM_CPY(&((*retx)->amHdr), &pduInfo->amHdr, sizeof(RlcAmHdr)); + rlcAmmAddPduToRetxLst(amDl, (*retx)); /* Update the BO appropriately */ amDl->retxBo += (*retx)->segSz; @@ -448,7 +437,7 @@ RlcDlPduInfo *pduInfo; gRlcStats.amRlcStats.numDLRetransPdus++; RETVOID; -} /*kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer */ +} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */ /** * @brief Function to handle Status of Sdu byte segment for a nackSn @@ -458,8 +447,8 @@ RlcDlPduInfo *pduInfo; * * @param[in]RlcCb *gCb RLC instance control block * @param[in]RlcDlRbCb *rbCb AM Downlink Control Block - * @param[in]KwNackInfo *nackSnInfo Nack Information of a NACK_SN - * @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by + * @param[in]RlcNackInfo *nackSnInfo Nack Information of a NACK_SN + * @param[in]RlcRetx **retx node in the reTx buffer to be moved to, allocated by * this function * @param[in]KwuDatCfmInfo **datCfm Ptr to datCfm * @@ -468,32 +457,32 @@ RlcDlPduInfo *pduInfo; */ #ifdef ANSI -PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf +PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwNackInfo *nackSnInfo, -KwRetx **retx, +RlcNackInfo *nackSnInfo, +RlcRetx **retx, KwuDatCfmInfo ** datCfm ) #else -PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm) +PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm) ( RlcCb *gCb; RlcDlRbCb *rbCb; -KwNackInfo *nackSnInfo; -KwRetx **retx; +RlcNackInfo *nackSnInfo; +RlcRetx **retx; KwuDatCfmInfo **datCfm; ) #endif { - KwTx *txBuf=NULLP; + RlcTx *txBuf=NULLP; CmLList *lnk; CmLList *nextLnk; - TRC2(kwAmmDlHndlStatus4SduByteSegInTxBuf) + TRC2(rlcAmmDlHndlStatus4SduByteSegInTxBuf) - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn); + txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn); if (txBuf == NULLP) { RETVOID; @@ -502,13 +491,13 @@ KwuDatCfmInfo **datCfm; while(lnk) { RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(lnk->node); - KwSn pduSoEnd = (pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1); + RlcSn pduSoEnd = (pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1); /* If So of Sdu byte segment(pduInfo/seg) is < status pdu soStart that means it's ACKED*/ if(pduSoEnd < nackSnInfo->soStart) { - kwAmmDlCheckIsSDUDelivered(gCb, + rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, &(pduInfo->sduMap), datCfm); @@ -517,7 +506,7 @@ KwuDatCfmInfo **datCfm; else if (pduSoEnd <= nackSnInfo->soEnd) { /* Move Sdu byte segment from TX buf to retx buf*/ - kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, + rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, &rbCb->m.amDl, retx, pduInfo); @@ -536,7 +525,7 @@ KwuDatCfmInfo **datCfm; if(!txBuf->pduLst.count) { /*No more Sdu byte segment are left. Hence delete txBuf*/ - kwUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb); + rlcUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb); } RETVOID; @@ -550,8 +539,8 @@ KwuDatCfmInfo **datCfm; * * @param[in]RlcCb *gCb RLC instance control block * @param[in]RlcDlRbCb *rbCb AM Downlink Control Block - * @param[in]KwNackInfo *nackSnInfo Nack Information of a NACK_SN - * @param[in]KwRetx **retx node in the reTx buffer to be moved to, allocated by + * @param[in]RlcNackInfo *nackSnInfo Nack Information of a NACK_SN + * @param[in]RlcRetx **retx node in the reTx buffer to be moved to, allocated by * this function * @param[in]KwuDatCfmInfo **datCfm Ptr to datCfm * @@ -559,29 +548,29 @@ KwuDatCfmInfo **datCfm; * */ #ifdef ANSI -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn +PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn ( RlcCb *gCb, RlcDlRbCb *rbCb, - KwNackInfo *nackSnInfo, + RlcNackInfo *nackSnInfo, CmLList **retxNode, KwuDatCfmInfo **datCfm ) #else -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm) +PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm) ( RlcCb *gCb; RlcDlRbCb *rbCb; - KwNackInfo *nackSnInfo; + RlcNackInfo *nackSnInfo; CmLList **retxNode; KwuDatCfmInfo **datCfm; ) #endif { - KwTx *txBuf; - KwRetx *retx; + RlcTx *txBuf; + RlcRetx *retx; - TRC2(kwAmmDlUpdateTxAndReTxBufForNackSn) + TRC2(rlcAmmDlUpdateTxAndReTxBufForNackSn) /* Now process the NACK_SN received. Now the NACK_SN is */ /* either the first element of RETX or is in TX array */ @@ -589,7 +578,7 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, /* if the NACK_SN is in the transmit buffer, move it to the re- transmit buffer */ - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn); + txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn); if (txBuf != NULLP) { if(nackSnInfo->isSegment) @@ -597,12 +586,12 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, /* Go through all the AMD PDUs of a particular SN and check if segment is ACKED if yes then mark succesfully sent, if segment is NACKed then move it to to retx lst */ - kwAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, &retx, datCfm); + rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, &retx, datCfm); } else { /*e2= 0 and e3= 0: Move complete PDU from TX buf to retx buf*/ - kwAmmDlMoveFrmTxtoRetxBuffer(gCb, + rlcAmmDlMoveFrmTxtoRetxBuffer(gCb, &rbCb->m.amDl, &retx, nackSnInfo->sn); @@ -622,7 +611,7 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, this NACK_SN */ while (*retxNode) { - retx = (KwRetx *)((*retxNode)->node); + retx = (RlcRetx *)((*retxNode)->node); if (retx->amHdr.sn != nackSnInfo->sn) { break; @@ -631,7 +620,7 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, ((retx->soEnd < nackSnInfo->soStart) /*|| (retx->amHdr.so > soEnd)*/)) { RLOG_ARG3(L_DEBUG, DBG_RBID, rbCb->rlcId.rbId, - "kwHndlStaRsp: Handle ACK for byte segment, Its " + "rlcHndlStaRsp: Handle ACK for byte segment, Its " "sn = %d UEID:%d CELLID:%d", nackSnInfo->sn, rbCb->rlcId.ueId, @@ -643,7 +632,7 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, rbCb->rlcId.cellId); (*retxNode) = (*retxNode)->next; - kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); + rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); } else if((!nackSnInfo->isSegment) || (retx->soEnd <= nackSnInfo->soEnd)) { @@ -653,7 +642,7 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, (*retxNode) = (*retxNode)->next; /* Mark the retx PDU we found for further retransmission */ - kwAmmDlMarkPduForReTx(gCb, rbCb, retx); + rlcAmmDlMarkPduForReTx(gCb, rbCb, retx); } else { @@ -670,11 +659,11 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, * @details * This function is used to get nack Sn information from nackRange index * -* @param[in]KwAmDl *amDl, -* @param[in]KwUdxStaPdu *StaPdu, -* @param[in]KwNackInfo *nackSnInfo, -* @param[in]KwRetx *retx; -* @param[in]KwSn sn, +* @param[in]RlcAmDl *amDl, +* @param[in]RlcUdxStaPdu *StaPdu, +* @param[in]RlcNackInfo *nackSnInfo, +* @param[in]RlcRetx *retx; +* @param[in]RlcSn sn, * @param[in]U8 idx * * @return Void @@ -683,25 +672,25 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, #ifdef ANSI PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ( -KwAmDl *amDl, -KwNackInfo *nackInfo, +RlcAmDl *amDl, +RlcNackInfo *nackInfo, CmLList *retxNode, -KwNackInfo *nackSnInfo, +RlcNackInfo *nackSnInfo, U8 idx ) #else PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx) ( -KwAmDl *amDl; -KwNackInfo *nackInfo; +RlcAmDl *amDl; +RlcNackInfo *nackInfo; CmLList *retxNode; -KwNackInfo *nackSnInfo; +RlcNackInfo *nackSnInfo; U8 idx; ) #endif { - KwTx *txBuf; - KwRetx *retx; + RlcTx *txBuf; + RlcRetx *retx; CmLList *node; TRC2(RlcDlAmmGetNackSnInfoFrmNackRangeIdx) @@ -714,7 +703,7 @@ U8 idx; nackSnInfo->soEnd = 0; RETVOID; } - txBuf = kwUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn); + txBuf = rlcUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn); if(txBuf != NULLP) { node = txBuf->pduLst.first; @@ -744,7 +733,7 @@ U8 idx; { while (retxNode) { - retx = (KwRetx *)(retxNode->node); + retx = (RlcRetx *)(retxNode->node); if(retx->amHdr.sn != nackSnInfo->sn) { break; @@ -794,36 +783,36 @@ U8 idx; * @return Void */ #ifdef ANSI -PUBLIC Void kwAmmDlHndlStatusPdu +Void rlcAmmDlHndlStatusPdu ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwUdxStaPdu *pStaPdu +RlcUdxStaPdu *pStaPdu ) #else -PUBLIC Void kwAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu) +Void rlcAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu) RlcCb *gCb; RlcDlRbCb *rbCb; -KwUdxStaPdu *pStaPdu; +RlcUdxStaPdu *pStaPdu; #endif { - KwSn mAckSn; + RlcSn mAckSn; S32 oldRetxBo; CmLList *retxNode; KwuDatCfmInfo* datCfm; - KwKwuSapCb *kwuSap; - KwSn mTxNext; + RlcKwuSapCb *rlckwuSap; + RlcSn mTxNext; - TRC2(kwAmmDlHndlStatusPdu) - kwStatusPduCnt++; + TRC2(rlcAmmDlHndlStatusPdu) + rlcStatusPduCnt++; - kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP; + rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP; /* store the re-transmission bo, to check if it changes due to the processing of the status pdu */ oldRetxBo = AMDL.retxBo; /* Allocate memory for datCfm Info */ - RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); + RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); #if (ERRCLASS & ERRCLS_ADD_RES) if (datCfm == NULLP) @@ -832,7 +821,7 @@ KwUdxStaPdu *pStaPdu; "Memory allocation failed UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); - RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); RETVOID; } #endif /* ERRCLASS & ERRCLS_RES */ @@ -852,14 +841,14 @@ KwUdxStaPdu *pStaPdu; AMDL.txNextAck, rbCb->rlcId.ueId, rbCb->rlcId.cellId); -/* RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */ - RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); +/* RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */ + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); RETVOID; } /* Venki - stopping the poll retx timer */ /*Stop PollRetx Tmr */ - kwAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn); + rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn); /* Set the first node in retx list to retxNode */ retxNode = AMDL.retxLst.first; @@ -867,11 +856,11 @@ KwUdxStaPdu *pStaPdu; /* If NACK exists in control PDU */ if (pStaPdu->nackCnt) { - KwSn sn; - KwNackInfo nackSnInfo; - KwSn mNackSn; - KwSn txNextAck; - KwSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which + RlcSn sn; + RlcNackInfo nackSnInfo; + RlcSn mNackSn; + RlcSn txNextAck; + RlcSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which to start processing the transmission buffer */ U32 idx = 0; @@ -879,7 +868,7 @@ KwUdxStaPdu *pStaPdu; /* if any NACKs then txNextAck should be equal to the first NACK_SN*/ txNextAck = pStaPdu->nackInfo[0].sn; - kwStatusNcnt += pStaPdu->nackCnt; + rlcStatusNcnt += pStaPdu->nackCnt; /* For NACKs */ while (idx < pStaPdu->nackCnt) @@ -889,7 +878,7 @@ KwUdxStaPdu *pStaPdu; nackSnInfo.sn = pStaPdu->nackInfo[idx].sn; RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId, - "kwHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d", + "rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d", nackSnInfo.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); @@ -916,17 +905,17 @@ KwUdxStaPdu *pStaPdu; "Status Pdu is not correct UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); - RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); RETVOID; } /* clear all the SNs < NACK_SN from re-transmission list */ - kwAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, + rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, &retxNode, &datCfm); if(!nackSnInfo.nackRange) { - kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, &retxNode, &datCfm); + rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, &retxNode, &datCfm); gRlcStats.amRlcStats.numRlcAmCellNackRx++; } else @@ -939,7 +928,7 @@ KwUdxStaPdu *pStaPdu; RlcDlAmmGetNackSnInfoFrmNackRangeIdx(&AMDL, &pStaPdu->nackInfo[idx], retxNode, &nackSnInfo, idx1); - kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, + rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, &retxNode, &datCfm); nackSnInfo.sn = ((nackSnInfo.sn + 1) & (AMDL.snModMask)); gRlcStats.amRlcStats.numRlcAmCellNackRx++; @@ -952,25 +941,25 @@ KwUdxStaPdu *pStaPdu; /* Remove the PDUs with are further acked by the ACK_SN after taking care of all the NACK_SN related acknowledgments*/ - kwAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm); + rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm); /* Update txNextAck */ - kwAmmDlSetTxNextAck(&AMDL,txNextAck); + rlcAmmDlSetTxNextAck(&AMDL,txNextAck); } else { - kwStatusAckCnt++; + rlcStatusAckCnt++; /* For All ACKs */ RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId, - "kwHndlStaRsp: Received All ACKS UEID:%d CELLID:%d", + "rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); /* For the remaining ACKs after last nackSn */ - kwAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm); + rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm); /* update txNextAck */ - kwAmmDlSetTxNextAck(&AMDL, pStaPdu->ackSn); + rlcAmmDlSetTxNextAck(&AMDL, pStaPdu->ackSn); } if(datCfm->numSduIds != 0) @@ -986,22 +975,22 @@ KwUdxStaPdu *pStaPdu; rbCb->rlcId.cellId); datCfm->numSduIds = 1024; } - kwSduSndCnt += datCfm->numSduIds; + rlcSduSndCnt += datCfm->numSduIds; /* Sap control block */ - KwUiKwuDatCfm(&kwuSap->pst, kwuSap->suId, datCfm); + RlcUiKwuDatCfm(&rlckwuSap->pst, rlckwuSap->suId, datCfm); } else { - RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); } /* Fix for memory corruption */ - KW_LLIST_FIRST_RETX(AMDL.retxLst, AMDL.nxtRetx); + RLC_LLIST_FIRST_RETX(AMDL.retxLst, AMDL.nxtRetx); /* BO update, if retransmission BO has changed. AMDL.retxBo would have canged inside the above called functions */ if (oldRetxBo != AMDL.retxBo) { - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); + rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL); } RETVOID; @@ -1022,13 +1011,13 @@ KwUdxStaPdu *pStaPdu; * Calculated bo */ #ifdef ANSI -PUBLIC S32 kwAmmCalculateBo +S32 rlcAmmCalculateBo ( -KwAmDl *amDl +RlcAmDl *amDl ) #else -PUBLIC S32 kwAmmCalculateBo(amDl) -KwAmDl *amDl; +S32 rlcAmmCalculateBo(amDl) +RlcAmDl *amDl; #endif { S32 bo; @@ -1052,7 +1041,7 @@ KwAmDl *amDl; bo = amDl->cntrlBo + amDl->retxBo; /* if window is not stalled then add the transmit bo also */ - if (! KW_AM_IS_TRANS_WIN_STALLED(amDl)) + if (! RLC_AM_IS_TRANS_WIN_STALLED(amDl)) { bo += amDl->bo; } @@ -1069,7 +1058,7 @@ U32 kwRxSdu; * SDU queue of the corresponding RbCb. It also updates the BO and report the * same to MAC. * - Allocate memory for and assign received buffer to the SDU - * - Add SDU in the sduQ of KwAmDl + * - Add SDU in the sduQ of RlcAmDl * - Calculate bo with the buffer received * - Accumulate bo with retransmission bo and control pdu's bo if available * - Estimate the header size for the bo; Fill in StaRspInfo and send it @@ -1083,52 +1072,35 @@ U32 kwRxSdu; * @return Void * -# RETVOID */ -#ifdef ANSI -PUBLIC Void kwAmmQSdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -Buffer *mBuf, -KwuDatReqInfo *datReq -) -#else -PUBLIC Void kwAmmQSdu(gCb, rbCb, mBuf, datReq) -RlcCb *gCb; -RlcDlRbCb *rbCb; -Buffer *mBuf; -KwuDatReqInfo *datReq; -#endif +void rlcAmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *mBuf, KwuDatReqInfo *datReq) { - KwSdu *sdu; + RlcSdu *sdu; #ifdef LTE_L2_MEAS #ifndef L2_L3_SPLIT #ifdef TENB_STATS - U32 kwWinSz; + uint32_t rlcWinSz; #endif #endif #endif - TRC2(kwAmmQSdu) /* Allocate sdu */ - RLC_ALLOC_WC(gCb,sdu, sizeof(KwSdu)); + RLC_ALLOC_WC(gCb,sdu, sizeof(RlcSdu)); #if (ERRCLASS & ERRCLS_ADD_RES) if (sdu == NULLP) { - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RETVOID; + DU_LOG("\n RLC : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\ + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } #endif /* ERRCLASS & ERRCLS_RES */ - KW_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb); + RLC_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb); /* Discard new changes starts */ - kwUtlGetCurrTime(&sdu->arrTime); + rlcUtlGetCurrTime(&sdu->arrTime); /* Discard new changes ends */ /* Assign values to sdu */ - SFndLenMsg(mBuf, &sdu->sduSz); + ODU_GET_MSG_LEN(mBuf, &sdu->sduSz); sdu->mBuf = mBuf; sdu->actSz = sdu->sduSz; @@ -1139,7 +1111,7 @@ KwuDatReqInfo *datReq; #ifndef RGL_SPECIFIC_CHANGES #ifdef MSPD { -extern U32 dlrate_kwu; +extern uint32_t dlrate_kwu; dlrate_kwu += sdu->sduSz; } #endif @@ -1148,11 +1120,8 @@ dlrate_kwu += sdu->sduSz; * queue */ if (AMDL.nxtTx == NULLP) { - RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId, - "kwAmmQSdu: Received SDU will be transmitted next" - "UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcAmmQSdu: Received SDU will be transmitted next \ + UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); AMDL.nxtTx = sdu; } @@ -1168,10 +1137,10 @@ dlrate_kwu += sdu->sduSz; { rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxPktsInSduQ = AMDL.sduQ.count; } - kwWinSz = KW_AM_TRANS_WIN_SIZE(&AMDL); - if (kwWinSz > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz) + rlcWinSz = RLC_AM_TRANS_WIN_SIZE(&AMDL); + if (rlcWinSz > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz) { - rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz = kwWinSz; + rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz = rlcWinSz; } } #endif @@ -1179,7 +1148,7 @@ dlrate_kwu += sdu->sduSz; #endif /* Update BO and estimate header size for the current BO */ AMDL.bo = AMDL.bo + sdu->sduSz; - if(AMDL.snLen == KW_AM_CFG_12BIT_SN_LEN) + if(AMDL.snLen == RLC_AM_CFG_12BIT_SN_LEN) { AMDL.estHdrSz += 2; } @@ -1193,16 +1162,16 @@ dlrate_kwu += sdu->sduSz; (rbCb->ueCb->numActRb[rbCb->qci] == 0)) { rbCb->ueCb->numActRb[rbCb->qci]++; - gCb.kwL2Cb.numActUe[rbCb->qci]++; + gCb.rlcL2Cb.numActUe[rbCb->qci]++; } #endif if(!rlcDlUtlIsReestInProgress(rbCb)) { - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); + rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL); } - RETVOID; + return; } /** @@ -1221,59 +1190,45 @@ dlrate_kwu += sdu->sduSz; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlAssembleCntrlInfo -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwAmmDlAssembleCntrlInfo(gCb, rbCb, kwDatReq) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +void rlcAmmDlAssembleCntrlInfo(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq) { - KwUdxDlSapCb *sapCb; + RlcUdxDlSapCb *sapCb; MsgLen macHdrEstmt; - TRC2(kwAmmDlAssembleCntrlInfo) - macHdrEstmt = (rbCb->m.amDl.cntrlBo < 256) ? - KW_MAC_HDR_SZ2 : KW_MAC_HDR_SZ3; + RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3; /* Eliminate fixed hdr size (14bits including ACK_SN) */ - if (kwDatReq->pduSz >= (KW_CNTRL_PDU_FIXED_HDRSZ + macHdrEstmt)) + if (rlcDatReq->pduSz >= (RLC_CNTRL_PDU_FIXED_HDRSZ + macHdrEstmt)) { /* Check the TB size whether it is sufficcient enough to fit the status Pdu into it otherwise make arrangement such that it can fit into in a way of possible NACks*/ /* ccpu00135743 : fix for MAC Hdr size calc */ - kwDatReq->pduSz -= macHdrEstmt; + rlcDatReq->pduSz -= macHdrEstmt; /* Create the status Pdu with the required NACKs */ - kwAmmCreateStatusPdu(gCb,rbCb,kwDatReq); + rlcAmmCreateStatusPdu(gCb,rbCb,rlcDatReq); - sapCb = KW_GET_DL_SAPCB(gCb, rbCb); - rlcDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst), + sapCb = RLC_GET_DL_SAPCB(gCb, rbCb); + rlcDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst), sapCb->suId, &(rbCb->rlcId)); /* Update number of pdus in pduInfo */ - kwDatReq->pduInfo.mBuf[kwDatReq->pduInfo.numPdu] = AMDL.mBuf; - kwDatReq->pduInfo.numPdu++; + rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = AMDL.mBuf; + rlcDatReq->pduInfo.numPdu++; gRlcStats.amRlcStats.numDLStaPduSent++; RLC_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region, gCb->u.dlCb->udxDlSap->pst.pool, AMDL.pStaPdu, - sizeof(KwUdxDlStaPdu)); + sizeof(RlcUdxDlStaPdu)); AMDL.pStaPdu = NULLP; AMDL.mBuf = NULLP; gRlcStats.amRlcStats.numDLStaPduSent++; } - RETVOID; + return; } /** @@ -1286,12 +1241,12 @@ KwDatReq *kwDatReq; * set for the data PDU and returns PDU(s) and updated BO with * estimated header size to be sent to MAC. * - * - Check if the control BO is available and call kwAssembleCntrlInfo + * - Check if the control BO is available and call rlcAssembleCntrlInfo * to assemble control Information * - Check if the pdu size is available to form PDUs from retransmission - * buffer and call kwResegRetxPdus + * buffer and call rlcResegRetxPdus * - Check if the pdu size is available and assemble SDUs from sduQ - * if exist, using kwAssembleSdus + * if exist, using rlcAssembleSdus * - PDU Info and bo are filled in and then sent to MAC from the * utility function * @@ -1303,25 +1258,8 @@ KwDatReq *kwDatReq; * @return Void * */ -#ifdef ANSI -PUBLIC Void kwAmmProcessSdus -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwDatReq *kwDatReq, -Bool fillCtrlPdu -) -#else -PUBLIC Void kwAmmProcessSdus(gCb, rbCb, kwDatReq,fillCtrlPdu) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwDatReq *kwDatReq; -Bool fillCtrlPdu; -#endif +void rlcAmmProcessSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq, bool fillCtrlPdu) { - TRC2(kwAmmProcessSdus) - - /* Assemble control information. fillCtrlPdu parameter check is added for CA * It is used to force cntrl Pdu scheduling on PCell. for Non CA case this * flag will always be TRUE. In CA case, for PCELL it is TRUE and for SCEll @@ -1333,55 +1271,53 @@ Bool fillCtrlPdu; #endif ) { - kwDatReq->boRep.staPduPrsnt = TRUE; - kwDatReq->boRep.staPduBo = AMDL.cntrlBo; + rlcDatReq->boRep.staPduPrsnt = TRUE; + rlcDatReq->boRep.staPduBo = AMDL.cntrlBo; if (AMDL.pStaPdu != NULLP) { - kwAmmDlAssembleCntrlInfo (gCb, rbCb, kwDatReq); + rlcAmmDlAssembleCntrlInfo (gCb, rbCb, rlcDatReq); } else { - RLOG_ARG2(L_ERROR, DBG_RBID, rbCb->rlcId.rbId, - "Miscomputation of control Bo. UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmProcessSdus: Miscomputation of control Bo. \ + UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); } AMDL.cntrlBo = 0; } /* Retransmit PDUs /portions of PDUs available in retxLst */ - if ((kwDatReq->pduSz > 0) && (AMDL.nxtRetx != NULLP)) + if ((rlcDatReq->pduSz > 0) && (AMDL.nxtRetx != NULLP)) { - kwResegRetxPdus (gCb,rbCb, kwDatReq); + rlcResegRetxPdus (gCb,rbCb, rlcDatReq); } /* Assemble SDUs to form new PDUs */ - if ((kwDatReq->pduSz > 0) && (AMDL.nxtTx != 0)) + if ((rlcDatReq->pduSz > 0) && (AMDL.nxtTx != 0)) { - kwAssembleSdus(gCb,rbCb, kwDatReq); + rlcAssembleSdus(gCb,rbCb, rlcDatReq); } if (AMDL.nxtRetx != NULLP) { - kwDatReq->boRep.oldestSduArrTime = AMDL.nxtRetx->sduMap.sdu->arrTime; + rlcDatReq->boRep.oldestSduArrTime = AMDL.nxtRetx->sduMap.sdu->arrTime; } else if (AMDL.nxtTx != NULLP) { - kwDatReq->boRep.oldestSduArrTime = AMDL.nxtTx->arrTime; + rlcDatReq->boRep.oldestSduArrTime = AMDL.nxtTx->arrTime; } /* Accumulate bo */ - kwDatReq->boRep.bo = kwAmmCalculateBo(&AMDL); - kwDatReq->boRep.staPduBo = AMDL.cntrlBo; + rlcDatReq->boRep.bo = rlcAmmCalculateBo(&AMDL); + rlcDatReq->boRep.staPduBo = AMDL.cntrlBo; /* Hdr estimation is moved to kwAmmCreatePDu */ - kwDatReq->boRep.estHdrSz = AMDL.estHdrSz; + rlcDatReq->boRep.estHdrSz = AMDL.estHdrSz; - if(kwDatReq->pduSz > 0) + if(rlcDatReq->pduSz > 0) { - gRlcStats.amRlcStats.numDLBytesUnused += kwDatReq->pduSz; + gRlcStats.amRlcStats.numDLBytesUnused += rlcDatReq->pduSz; } - RETVOID; + return; } /** @@ -1402,35 +1338,18 @@ Bool fillCtrlPdu; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwSplitPdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwRetx *crnt, -KwRetx *next, -U16 size -) -#else -PRIVATE Void kwSplitPdu(gCb, rbCb, crnt, next, size) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwRetx *crnt; -KwRetx *next; -U16 size; -#endif +void rlcSplitPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcRetx *crnt, RlcRetx *next, uint16_t size) { - U8 si; - KwAmDl *amDl = &AMDL; + uint8_t si; + RlcAmDl *amDl = &AMDL; - TRC2(kwSplitPdu) /* Set the SN for the new segment */ next->amHdr.sn = crnt->amHdr.sn; /* Set the protocol specific fields appropriately */ si = crnt->amHdr.si; - crnt->amHdr.si = si | KW_SI_FIRST_SEG; - next->amHdr.si = si | KW_SI_LAST_SEG; + crnt->amHdr.si = si | RLC_SI_FIRST_SEG; + next->amHdr.si = si | RLC_SI_LAST_SEG; crnt->amHdr.p = 0; @@ -1459,34 +1378,34 @@ U16 size; next->sduMap.sduSz = next->segSz; /* Segment the payload into two parts based on the size passed */ - SSegMsg(crnt->seg, size, &next->seg); + ODU_SEGMENT_MSG(crnt->seg, size, &next->seg); next->retxCnt = crnt->retxCnt; next->yetToConst = TRUE; next->pendingReTrans = crnt->pendingReTrans; /* Compute the header size and update the BO appropriately */ - if(amDl->snLen == KW_AM_CFG_12BIT_SN_LEN) + if(amDl->snLen == RLC_AM_CFG_12BIT_SN_LEN) { - next->hdrSz = KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ; - if(crnt->amHdr.si == KW_SI_FIRST_SEG) + next->hdrSz = RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ; + if(crnt->amHdr.si == RLC_SI_FIRST_SEG) { - crnt->hdrSz = KW_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ; + crnt->hdrSz = RLC_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ; } else { - crnt->hdrSz = KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ; + crnt->hdrSz = RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ; } } else { - next->hdrSz = KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ; - if(crnt->amHdr.si == KW_SI_FIRST_SEG) + next->hdrSz = RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ; + if(crnt->amHdr.si == RLC_SI_FIRST_SEG) { - crnt->hdrSz = KW_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ; + crnt->hdrSz = RLC_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ; } else { - crnt->hdrSz = KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ; + crnt->hdrSz = RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ; } } @@ -1496,7 +1415,7 @@ U16 size; AMDL.nxtRetx = next; amDl->estHdrSz += next->hdrSz; - RETVOID; + return; } /** @@ -1511,7 +1430,7 @@ U16 size; * - While pdusize is available and retxBuf has data (pdu or portion * of pdu) to be sent, form the pdu as it is if it matches with the * pdusize else segment the PDUs/portion of PDUs - * - Call kwAmmDlCheckAndSetPoll function to check and set the poll bit as + * - Call rlcAmmDlCheckAndSetPoll function to check and set the poll bit as * required * - Concatenate data and header info and fill pduInfo * - Update retxCnt and send indication to PDCP if it reaches maxRetx @@ -1524,104 +1443,86 @@ U16 size; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwResegRetxPdus -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwResegRetxPdus(gCb, rbCb, kwDatReq) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +void rlcResegRetxPdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq) { - KwAmDl *amDl; - KwRetx *retx; - U8 hdr[KW_MAX_HDRSZ]; - U16 idx; + RlcAmDl *amDl; + RlcRetx *retx; + uint8_t hdr[RLC_MAX_HDRSZ]; + uint16_t idx; Buffer *pdu; MsgLen pduSz; #ifdef LTE_L2_MEAS - U16 sduIdx; - KwL2MeasTb *l2MeasTb; - KwlchInfo *lchInfo; - U8 numSdus; + uint16_ sduIdx; + RlcL2MeasTb *l2MeasTb; + RlclchInfo *lchInfo; + uint8_t numSdus; #endif - TRC2(kwResegRetxPdus) - - amDl = &AMDL; #ifdef LTE_L2_MEAS /* TODO : This shoould be taken care in new Trasmissions */ /* This lchInfo should be retrieved there */ - l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb); + l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb); if (l2MeasTb == NULLP) { - RETVOID; + return; } /* TODO : This lcid needs to be searched in case of normal Tx */ /* In retx here, its fine as this will be higher priority */ lchInfo = &l2MeasTb->lchInfo[l2MeasTb->numLchInfo]; - if (l2MeasTb->numLchInfo >= KW_MAX_ACTV_DRB) + if (l2MeasTb->numLchInfo >= RLC_MAX_ACTV_DRB) { - RETVOID; + return; } l2MeasTb->numLchInfo++; lchInfo->lcId = rbCb->lch.lChId; lchInfo->numSdus = 0; #endif - while ((kwDatReq->pduSz > 0) && (amDl->nxtRetx != NULLP)&& - (kwDatReq->pduInfo.numPdu < KW_MAX_PDU)) + while ((rlcDatReq->pduSz > 0) && (amDl->nxtRetx != NULLP)&& + (rlcDatReq->pduInfo.numPdu < RLC_MAX_PDU)) { - U16 tmpSz; + uint16_t tmpSz; retx = amDl->nxtRetx; /* kw003.201 : Add header size to seg size to determine if the */ /* the segment can be completed within the allocation */ /* kw003.201 - Eliminate MAC Header Size based on bites needed */ - tmpSz = KW_MIN((retx->segSz + retx->hdrSz), kwDatReq->pduSz); + tmpSz = RLC_MIN((retx->segSz + retx->hdrSz), rlcDatReq->pduSz); pduSz = (retx->segSz + retx->hdrSz); /* 5GNR_RLC: length field in 5GNR MAC Hdr is 8/16 btis*/ - kwDatReq->pduSz -= (tmpSz < 255) ? KW_MAC_HDR_SZ2 : KW_MAC_HDR_SZ3; + rlcDatReq->pduSz -= (tmpSz < 255) ? RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3; /* kw003.201 - We should have at least one more than basic header */ - if (kwDatReq->pduSz <= retx->hdrSz) + if (rlcDatReq->pduSz <= retx->hdrSz) { - RETVOID; + return; } - kwGetNxtRetx(gCb, &(amDl->nxtRetx)); + rlcGetNxtRetx(gCb, &(amDl->nxtRetx)); /* Send retx buf without segmentation */ - if (kwDatReq->pduSz >= pduSz) + if (rlcDatReq->pduSz >= pduSz) { - U8 pollBit; + uint8_t pollBit; - RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwResegRetxPdus: Send retx buf without segmentation " - "UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcResegRetxPdus: Send retx buf without segmentation " + "UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); if (retx->yetToConst) { /* Construct hdr with the available hdr values */ - kwConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx); + rlcConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx); /* Add header to the pdu/segment */ - SAddPreMsgMultInOrder(hdr, idx + 1, retx->seg); + ODU_ADD_PRE_MSG_MULT_IN_ORDER(hdr, idx + 1, retx->seg); retx->yetToConst = FALSE; } /* kw003.201 - Check if poll bit needs to be set. Retx size does */ /* not affect the poll bit so it is being passed as zero */ - pollBit = kwAmmDlCheckAndSetPoll(gCb,rbCb, FALSE, 0); - KW_UPD_POLL_BIT(gCb, retx, pollBit); + pollBit = rlcAmmDlCheckAndSetPoll(gCb,rbCb, FALSE, 0); + RLC_UPD_POLL_BIT(gCb, retx, pollBit); - kwDatReq->pduSz -= pduSz; + rlcDatReq->pduSz -= pduSz; AMDL.estHdrSz -= retx->hdrSz; #ifdef LTE_L2_MEAS @@ -1629,7 +1530,7 @@ KwDatReq *kwDatReq; { numSdus = 0; for (sduIdx = lchInfo->numSdus ; - ((numSdus < retx->numSdu) && (sduIdx < KW_L2MEAS_SDUIDX)) ; + ((numSdus < retx->numSdu) && (sduIdx < RLC_L2MEAS_SDUIDX)) ; sduIdx++, numSdus++) { lchInfo->sduInfo[sduIdx].arvlTime = retx->sduMap[numSdus].sdu->arrTime; @@ -1641,54 +1542,50 @@ KwDatReq *kwDatReq; } else { - KwRetx *tNode; + RlcRetx *tNode; /* Segment this pdu / portion of pdu. Insert this segment into */ /* retxLst and update offset */ - RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwResegRetxPdus: Segment retx buf UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); /* Eliminate fixed header size if the pdu is segmented for the */ /* first time */ - if(amDl->snLen == KW_AM_CFG_12BIT_SN_LEN) + if(amDl->snLen == RLC_AM_CFG_12BIT_SN_LEN) { - if(retx->amHdr.si < KW_SI_LAST_SEG) + if(retx->amHdr.si < RLC_SI_LAST_SEG) { - kwDatReq->pduSz -= KW_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ; + rlcDatReq->pduSz -= RLC_AM_SEG_12BIT_SN_WITHOUT_SO_HDRSZ; } else { - kwDatReq->pduSz -= KW_AM_SEG_12BIT_SN_WITH_SO_HDRSZ; + rlcDatReq->pduSz -= RLC_AM_SEG_12BIT_SN_WITH_SO_HDRSZ; } } else { - if(retx->amHdr.si < KW_SI_LAST_SEG) + if(retx->amHdr.si < RLC_SI_LAST_SEG) { - kwDatReq->pduSz -= KW_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ; + rlcDatReq->pduSz -= RLC_AM_SEG_18BIT_SN_WITHOUT_SO_HDRSZ; } else { - kwDatReq->pduSz -= KW_AM_SEG_18BIT_SN_WITH_SO_HDRSZ; + rlcDatReq->pduSz -= RLC_AM_SEG_18BIT_SN_WITH_SO_HDRSZ; } } - if (kwDatReq->pduSz <= 0) + if (rlcDatReq->pduSz <= 0) { - RETVOID; + return; } /* Allocate memory for tracking a new segment */ - RLC_ALLOC_WC(gCb,tNode, sizeof(KwRetx)); + RLC_ALLOC_WC(gCb,tNode, sizeof(RlcRetx)); #if (ERRCLASS & ERRCLS_ADD_RES) if (tNode == NULLP) { - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RETVOID; + DU_LOG("\nRLC: rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } #endif /* ERRCLASS & ERRCLS_RES */ @@ -1697,17 +1594,17 @@ KwDatReq *kwDatReq; tNode->lstEnt.prev = 0; /* Segment header and data */ - KW_AM_RMV_HDR(gCb, rbCb, retx); + RLC_AM_RMV_HDR(gCb, rbCb, retx); /* kw003.201 - Split the payload and update other fields */ - kwSplitPdu(gCb,rbCb, retx, tNode, kwDatReq->pduSz); + rlcSplitPdu(gCb,rbCb, retx, tNode, rlcDatReq->pduSz); #ifdef LTE_L2_MEAS numSdus = 0; /* ccpu00143043 */ sduIdx = lchInfo->numSdus; for (numSdus = 0, sduIdx = lchInfo->numSdus; - ((numSdus < retx->numSdu) && (sduIdx < KW_L2MEAS_SDUIDX)); + ((numSdus < retx->numSdu) && (sduIdx < RLC_L2MEAS_SDUIDX)); numSdus++, sduIdx++) { lchInfo->sduInfo[sduIdx].arvlTime = @@ -1721,23 +1618,23 @@ KwDatReq *kwDatReq; } #endif /* Construct hdr with the available hdr values */ - kwConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx); - SAddPreMsgMultInOrder(hdr, idx + 1, retx->seg); + rlcConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx); + ODU_ADD_PRE_MSG_MULT_IN_ORDER(hdr, idx + 1, retx->seg); retx->hdrSz = idx + 1; /* Poll bit need not be set for this seg, since its second */ /* half remains in retxLst */ - KW_UPD_POLL_BIT(gCb, retx, FALSE); + RLC_UPD_POLL_BIT(gCb, retx, FALSE); retx->yetToConst = FALSE; - kwDatReq->pduSz = 0; + rlcDatReq->pduSz = 0; } - kwCpyMsg(gCb,retx->seg, &pdu); + rlcCpyMsg(gCb,retx->seg, &pdu); /* Update pduInfo */ - kwDatReq->pduInfo.mBuf[kwDatReq->pduInfo.numPdu] = pdu; - kwDatReq->pduInfo.numPdu++; + rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = pdu; + rlcDatReq->pduInfo.numPdu++; /* kw005.201 ccpu00117318, updating the statistics */ gCb->genSts.pdusRetx += 1; gRlcStats.amRlcStats.numRlcAmCellRetxPdu++; @@ -1746,22 +1643,14 @@ KwDatReq *kwDatReq; amDl->retxBo -= retx->segSz; } #ifndef ALIGN_64BIT - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwResegRetxPdus: retxBo after resegmentation = %ld" - "UEID:%d CELLID:%d", - amDl->retxBo, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcResegRetxPdus: retxBo after resegmentation = %ld" + "UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId); #else - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwResegRetxPdus: retxBo after resegmentation = %d " - "UEID:%d CELLID:%d", - amDl->retxBo, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcResegRetxPdus: retxBo after resegmentation = %d " + "UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId); #endif - RETVOID; + return; } @@ -1775,7 +1664,7 @@ KwDatReq *kwDatReq; * - While pdusize is available, segment/concatenate SDUs or else if it * matches the pdu size form PDUs accordingly. * - RLC header and MAC header size are eliminated while forming the PDUs - * - Call kwAmmDlCheckAndSetPoll function to check and set the poll bit + * - Call rlcAmmDlCheckAndSetPoll function to check and set the poll bit * as required * - Concatenate data and header info and fill pduInfo * @@ -1785,61 +1674,46 @@ KwDatReq *kwDatReq; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAssembleSdus -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwAssembleSdus (gCb, rbCb, kwDatReq) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +void rlcAssembleSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq) { Buffer *pdu = NULLP; - MsgLen macGrntSz = kwDatReq->pduSz; - KwAmDl *amDl = &AMDL; - KwSdu *sdu = amDl->nxtTx; - KwSduMap sduMap; - Bool nxtTxUpd = FALSE; + MsgLen macGrntSz = rlcDatReq->pduSz; + RlcAmDl *amDl = &AMDL; + RlcSdu *sdu = amDl->nxtTx; + RlcSduMap sduMap; + bool nxtTxUpd = FALSE; KwuDiscSduInfo *discSduInfo = NULLP; - KwKwuSapCb* kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP; + RlcKwuSapCb* rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP; #ifdef LTE_L2_MEAS - KwContSduLst contSduLst; /*Contained sduLst */ - S32 dataVol = amDl->bo; - U32 *totMacGrant = &kwDatReq->totMacGrant; - KwL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh; - U8 *sduIdx = &dlIpThPut->lastSduIdx; - Bool newIdx; - Bool isSduSegmented; - S32 oldBo; - KwlchInfo lchInfo; - KwlchInfo *dstLchInfo; - U32 segSduCnt = 0; - U32 lchIdx; - U32 numSdus = 0; - U32 currSduIdx = 0; - KwL2MeasTb *l2MeasTb; + RlcContSduLst contSduLst; /*Contained sduLst */ + int32_t dataVol = amDl->bo; + uint32_t *totMacGrant = &rlcDatReq->totMacGrant; + RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh; + uint8_t *sduIdx = &dlIpThPut->lastSduIdx; + bool newIdx; + bool isSduSegmented; + int32_t oldBo; + RlclchInfo lchInfo; + RlclchInfo *dstLchInfo; + uint32_t segSduCnt = 0; + uint32_t lchIdx; + uint32_t numSdus = 0; + uint32_t currSduIdx = 0; + RlcL2MeasTb *l2MeasTb; #endif /* Discard new changes starts */ Ticks timeDiff = 0; Ticks curTime = 0; - U8 numNewPdu = 0; - KwTx *txBuf = NULLP; + uint8_t numNewPdu = 0; + RlcTx *txBuf = NULLP; /* Discard new changes ends */ - VOLATILE U32 startTime = 0; - U32 hdrEstmt; - U32 fixedHdrSz; - U32 pduSz; - KwAmHdr *amHdr = NULLP; + VOLATILE uint32_t startTime = 0; + uint32_t hdrEstmt; + uint32_t fixedHdrSz; + uint32_t pduSz; + RlcAmHdr *amHdr = NULLP; RlcDlPduInfo *pduInfo = NULLP; - TRC2(kwAssembleSdus) - - #ifdef LTE_L2_MEAS contSduLst.numSdus = 0; contSduLst.lcId = rbCb->lch.lChId; @@ -1849,41 +1723,39 @@ KwDatReq *kwDatReq; #endif /* Discard new changes starts */ /* Allocate memory for discSdu Info */ - RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, - kwuSap->pst.pool, + RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, + rlckwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo)); #if (ERRCLASS & ERRCLS_ADD_RES) if (discSduInfo == NULLP) { - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RETVOID; + DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } #endif /* ERRCLASS & ERRCLS_RES */ discSduInfo->numSduIds = 0; discSduInfo->rlcId = rbCb->rlcId; - kwUtlGetCurrTime(&curTime); + rlcUtlGetCurrTime(&curTime); amDl->sduQ.crnt = &sdu->lstEnt; /* Eliminate fixed header size */ - /*5GNR: value of KW_AM_PDU_FIXED_HDRSZ will be 2 or 3 depending on SN Size*/ - if(amDl->snLen == KW_AM_CFG_12BIT_SN_LEN) + /*5GNR: value of RLC_AM_PDU_FIXED_HDRSZ will be 2 or 3 depending on SN Size*/ + if(amDl->snLen == RLC_AM_CFG_12BIT_SN_LEN) { - fixedHdrSz = KW_AM_PDU_12BIT_SN_HDRSZ; + fixedHdrSz = RLC_AM_PDU_12BIT_SN_HDRSZ; } else { - fixedHdrSz = KW_AM_PDU_18BIT_SN_HDRSZ; + fixedHdrSz = RLC_AM_PDU_18BIT_SN_HDRSZ; } while ((macGrntSz > fixedHdrSz) && (sdu != NULLP) && - (kwDatReq->pduInfo.numPdu < KW_MAX_PDU) && - (numNewPdu < KW_MAX_NEW_DL_PDU)) + (rlcDatReq->pduInfo.numPdu < RLC_MAX_PDU) && + (numNewPdu < RLC_MAX_NEW_DL_PDU)) { #ifdef LTE_L2_MEAS isSduSegmented = sdu->mode.am.isSegmented; @@ -1893,14 +1765,14 @@ KwDatReq *kwDatReq; (rbCb->rlcId.rbType == CM_LTE_DRB)) { //leftAmSdus[rbCb->qci]--; - timeDiff = KW_TIME_DIFF(curTime,sdu->arrTime); + timeDiff = RLC_TIME_DIFF(curTime,sdu->arrTime); if (timeDiff > rbCb->discTmrInt) { CmLList* nxtNode; /*starting Task*/ SStartTask(&startTime, PID_RLC_AMM_DISC_SDUS); #ifdef LTE_L2_MEAS - KW_UPD_L2_DL_DISC_SDU_STS(gCb,rbCb); + RLC_UPD_L2_DL_DISC_SDU_STS(gCb,rbCb); /* TODO need to send disc cfm to pdcp */ #endif /* Update bo for boReport */ @@ -1912,11 +1784,8 @@ KwDatReq *kwDatReq; /* store the info for sending it to PDCP */ if(discSduInfo->numSduIds > 500) { - RLOG_ARG2(L_ERROR,DBG_RBID, rbCb->rlcId.rbId, - "This is a big error, we shouldn't be here" - "UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAssembleSdus: This is a big error, we shouldn't be here" + "UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); break; } @@ -1925,20 +1794,20 @@ KwDatReq *kwDatReq; cmLListDelFrm(&amDl->sduQ, &sdu->lstEnt); - kwUtlAddSduToBeFreedQueue(gCb, sdu); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlAddSduToBeFreedQueue(gCb, sdu); + rlcUtlRaiseDlCleanupEvent(gCb); /* We need to restore the crnt in the linked list which * would have become NULL in the DelFrm above */ amDl->sduQ.crnt = nxtNode; if(nxtNode) - sdu = (KwSdu*)nxtNode->node; + sdu = (RlcSdu*)nxtNode->node; else sdu = NULLP; /*stopping Task*/ - SStopTask(startTime, PID_RLC_AMM_DISC_SDUS); + ODU_STOP_TASK(startTime, PID_RLC_AMM_DISC_SDUS); continue; } } @@ -1950,7 +1819,7 @@ KwDatReq *kwDatReq; /** kw003.201 - Check for window stall when you are * creating a new PDU */ - if (KW_AM_IS_TRANS_WIN_STALLED(amDl)) + if (RLC_AM_IS_TRANS_WIN_STALLED(amDl)) { //int *a = NULLP; printf("\n Window stalled \n"); @@ -1969,8 +1838,8 @@ KwDatReq *kwDatReq; /* Eliminate MAC header */ /* ccpu00135743 : Fix for MAC Hdr size calculation */ /*5GNR: value of mac hdr length field changed to 8/16bits */ - pduSz = KW_MIN(macGrntSz, (sdu->sduSz + hdrEstmt)); - hdrEstmt += (pduSz < 255) ? KW_MAC_HDR_SZ2 : KW_MAC_HDR_SZ3; + pduSz = RLC_MIN(macGrntSz, (sdu->sduSz + hdrEstmt)); + hdrEstmt += (pduSz < 255) ? RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3; macGrntSz -= hdrEstmt; /* kw005.201 Check for PDU Size is large enough. @@ -1985,41 +1854,37 @@ KwDatReq *kwDatReq; if (!sdu->mode.am.isSegmented) { /* Update txBuf */ - RLC_ALLOC_WC(gCb,txBuf, sizeof(KwTx)); + RLC_ALLOC_WC(gCb,txBuf, sizeof(RlcTx)); cmLListInit(&txBuf->pduLst); #if (ERRCLASS & ERRCLS_ADD_RES) if (txBuf == NULLP) { - U32 avblMem = 0; + uint32_t avblMem = 0; SRegInfoShow(gCb->init.region, &avblMem); - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RETVOID; + DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } #endif /* ERRCLASS & ERRCLS_RES */ - kwUtlStoreTxBuf(amDl->txBufLst, txBuf, amDl->txNext); + rlcUtlStoreTxBuf(amDl->txBufLst, txBuf, amDl->txNext); } else { - txBuf = kwUtlGetTxBuf(amDl->txBufLst, amDl->txNext); + txBuf = rlcUtlGetTxBuf(amDl->txBufLst, amDl->txNext); } RLC_ALLOC_WC(gCb,pduInfo, sizeof(RlcDlPduInfo)); #if (ERRCLASS & ERRCLS_ADD_RES) if (pduInfo == NULLP) { - U32 avblMem = 0; + uint32_t avblMem = 0; SRegInfoShow(gCb->init.region, &avblMem); - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RETVOID; + DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } #endif /* ERRCLASS & ERRCLS_RES */ @@ -2045,7 +1910,7 @@ KwDatReq *kwDatReq; { /*5GNR RLC: SN should be same for all segment of a SDU*/ pduInfo->amHdr.sn = sdu->mode.am.sn; - pduInfo->amHdr.si = KW_SI_LAST_SEG; /* binary 10 */ + pduInfo->amHdr.si = RLC_SI_LAST_SEG; /* binary 10 */ pduInfo->amHdr.so = sdu->actSz - sdu->sduSz; sdu->mode.am.isSegmented = FALSE; @@ -2060,18 +1925,18 @@ KwDatReq *kwDatReq; } amHdr = &pduInfo->amHdr; /* Create PDU with hdr and data */ - kwAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu); + rlcAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu); - //printf("\n Segmentation not required case: numPdu %d pdu %p \n",kwDatReq->pduInfo.numPdu, pdu); + //printf("\n Segmentation not required case: numPdu %d pdu %p \n",rlcDatReq->pduInfo.numPdu, pdu); #ifdef LTE_L2_MEAS_RLC - kwUtlUpdSduSnMap(rbCb, sdu, kwDatReq, TRUE); + rlcUtlUpdSduSnMap(rbCb, sdu, rlcDatReq, TRUE); #endif /* LTE_L2_MEAS */ /* kw005.201 ccpu00117318, updating the statistics */ - kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId); + rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId); #ifdef LTE_L2_MEAS - if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb)) + if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb)) { if(isSduSegmented) { @@ -2079,15 +1944,15 @@ KwDatReq *kwDatReq; } else { - KW_GETSDUIDX(*sduIdx); + RLC_GETSDUIDX(*sduIdx); newIdx = TRUE; } - kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst); - kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, + rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst); + rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, sdu->mode.am.sduId, newIdx); /* Update the arrival time for each SDU */ /* ccpu00143043 */ - if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX) + if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX) { lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime; lchInfo.numSdus++; @@ -2105,27 +1970,27 @@ KwDatReq *kwDatReq; Buffer *remSeg = NULLP; - //printf("\n SDU segmentation case: numPdu %d pdu %p \n", kwDatReq->pduInfo.numPdu, pdu); + //printf("\n SDU segmentation case: numPdu %d pdu %p \n", rlcDatReq->pduInfo.numPdu, pdu); #ifdef LTE_L2_MEAS - if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rbCb) || - KW_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(gCb,rbCb) || - KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb) ) + if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rbCb) || + RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(gCb,rbCb) || + RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb) ) { /* If actual size of the sdu is equal to msgLen * then it is first segment of the SDU */ if(sdu->actSz == sdu->sduSz) { - KW_GETSDUIDX(*sduIdx); + RLC_GETSDUIDX(*sduIdx); newIdx = TRUE; } else { *sduIdx = dlIpThPut->lastSduIdx; } - kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst); - kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, + rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst); + rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, sdu->mode.am.sduId, newIdx); - if(KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb)) + if(RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb)) { /* If actual size of the sdu is equal to msgLen * then it is first segment of the SDU */ @@ -2138,7 +2003,7 @@ KwDatReq *kwDatReq; #endif /* Segment the SDU to the size of the PDU and update header Info */ - SSegMsg(sdu->mBuf, macGrntSz, &remSeg); + ODU_SEGMENT_MSG(sdu->mBuf, macGrntSz, &remSeg); pdu = sdu->mBuf; sdu->mBuf = remSeg; @@ -2148,7 +2013,7 @@ KwDatReq *kwDatReq; /*5GNR RLC: SN should be same for all segment of a SDU. * Sdu was already segmented and segmenting again*/ pduInfo->amHdr.sn = sdu->mode.am.sn; - pduInfo->amHdr.si = KW_SI_MID_SEG; /* binary 11 */ + pduInfo->amHdr.si = RLC_SI_MID_SEG; /* binary 11 */ pduInfo->amHdr.so = sdu->actSz - sdu->sduSz; //printf("\n 5GNRLOG: mid segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n", @@ -2157,7 +2022,7 @@ KwDatReq *kwDatReq; else { /*5GNR RLC: This means it is the first*/ - pduInfo->amHdr.si = KW_SI_FIRST_SEG; /* binary 01 */ + pduInfo->amHdr.si = RLC_SI_FIRST_SEG; /* binary 01 */ /*5GNR_RLC: Store SN so that in sub-seqent SDU segments will use this SN*/ sdu->mode.am.sn = pduInfo->amHdr.sn; pduInfo->amHdr.so = 0; @@ -2168,14 +2033,14 @@ KwDatReq *kwDatReq; amHdr = &pduInfo->amHdr; /* Create PDU with hdr and data */ - kwAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu); + rlcAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu); sdu->mode.am.isSegmented = TRUE; sdu->sduSz -= macGrntSz; sduMap.sduSz = macGrntSz; #ifdef LTE_L2_MEAS_RLC - kwUtlUpdSduSnMap(rbCb, sdu, kwDatReq, FALSE); + rlcUtlUpdSduSnMap(rbCb, sdu, rlcDatReq, FALSE); #endif /* LTE_L2_MEAS */ amDl->nxtTx = sdu; @@ -2188,39 +2053,39 @@ KwDatReq *kwDatReq; sduMap.sdu = sdu; /* Update pduInfo */ - kwDatReq->pduInfo.mBuf[kwDatReq->pduInfo.numPdu] = pdu; - kwDatReq->pduInfo.numPdu++; + rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = pdu; + rlcDatReq->pduInfo.numPdu++; numNewPdu++; /* kw005.201 ccpu00117318, updating the statistics */ gCb->genSts.pdusSent++; gRlcStats.amRlcStats.numRlcAmCellSduBytesTx = gRlcStats.amRlcStats.numRlcAmCellSduBytesTx + sduMap.sduSz; /* Update the RLC Tx buffer with the new PDU info */ - KW_MEM_CPY(&pduInfo->sduMap, &sduMap, sizeof(KwSduMap)); + RLC_MEM_CPY(&pduInfo->sduMap, &sduMap, sizeof(RlcSduMap)); pdu = NULLP; macGrntSz -= sduMap.sduSz; /* Get next sdu for assembly */ - KW_LLIST_NEXT_SDU(amDl->sduQ, sdu); + RLC_LLIST_NEXT_SDU(amDl->sduQ, sdu); } /*End of pduSz loop */ - kwDatReq->pduSz = macGrntSz; + rlcDatReq->pduSz = macGrntSz; /* Updating nxtTx to sdu in the Q */ if (!nxtTxUpd) amDl->nxtTx = sdu; #ifdef LTE_L2_MEAS - if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && + if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (rbCb->rlcId.rbType == CM_LTE_DRB)) { numSdus = 0; currSduIdx = 0; - l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb); - kwUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant); + l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb); + rlcUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant); if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP)) { for (lchIdx = 0; ((lchIdx < l2MeasTb->numLchInfo) - && (lchIdx < KW_MAX_ACTV_DRB )); lchIdx++) + && (lchIdx < RLC_MAX_ACTV_DRB )); lchIdx++) { if (l2MeasTb->lchInfo[lchIdx].lcId == rbCb->lch.lChId) { @@ -2228,7 +2093,7 @@ KwDatReq *kwDatReq; break; } } - if (lchIdx < KW_MAX_ACTV_DRB) + if (lchIdx < RLC_MAX_ACTV_DRB) { if (lchIdx == l2MeasTb->numLchInfo) { @@ -2238,7 +2103,7 @@ KwDatReq *kwDatReq; } dstLchInfo = &l2MeasTb->lchInfo[lchIdx]; currSduIdx = l2MeasTb->lchInfo[lchIdx].numSdus; - while ((numSdus < lchInfo.numSdus) && (currSduIdx < KW_L2MEAS_SDUIDX)) + while ((numSdus < lchInfo.numSdus) && (currSduIdx < RLC_L2MEAS_SDUIDX)) { dstLchInfo->sduInfo[currSduIdx].arvlTime = lchInfo.sduInfo[numSdus].arvlTime; dstLchInfo->sduInfo[currSduIdx].isRetxPdu = FALSE; @@ -2260,29 +2125,18 @@ KwDatReq *kwDatReq; if(discSduInfo->numSduIds != 0) { /* Sap control block */ - KwUiKwuDiscSduCfm(&kwuSap->pst, kwuSap->suId, discSduInfo); + RlcUiKwuDiscSduCfm(&rlckwuSap->pst, rlckwuSap->suId, discSduInfo); } else { - RLC_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo)); + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo)); } -#ifndef ALIGN_64BIT - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAssembleSdus: BO after assembly = %ld UEID:%d CELLID:%d", - amDl->bo, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); -#else - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d", - amDl->bo, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); -#endif + DU_LOG("\nRLC: rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d", + amDl->bo, rbCb->rlcId.ueId, rbCb->rlcId.cellId); - RETVOID; + return; } /** @@ -2308,28 +2162,11 @@ KwDatReq *kwDatReq; * -# 0 - Poll bit is not set * */ -#ifdef ANSI -PRIVATE Bool kwAmmDlCheckAndSetPoll -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -Bool newPdu, -MsgLen bufSz -) -#else -PRIVATE Bool kwAmmDlCheckAndSetPoll(gCb, rbCb, newPdu, bufSz) -RlcCb *gCb; -RlcDlRbCb *rbCb; -Bool newPdu; -MsgLen bufSz; -#endif +bool rlcAmmDlCheckAndSetPoll(RlcCb *gCb, RlcDlRbCb *rbCb, bool newPdu, MsgLen bufSz) { - Bool pollBit = FALSE; - KwAmDl *amDl = &(rbCb->m.amDl); - - TRC2(kwAmmDlCheckAndSetPoll) + bool pollBit = FALSE; + RlcAmDl *amDl = &(rbCb->m.amDl); - /* If it's a new PDU increment PDU without poll and bytes without poll and check if they cross the configured number of poll pdu and poll bytes*/ if (newPdu) @@ -2347,7 +2184,7 @@ MsgLen bufSz; /* Check if both tx/retx buffer are empty or if tx window is stalled */ if (((amDl->nxtTx == NULLP) && (amDl->nxtRetx == NULLP)) || - KW_AM_IS_TRANS_WIN_STALLED(amDl)) + RLC_AM_IS_TRANS_WIN_STALLED(amDl)) { pollBit = TRUE; } @@ -2359,23 +2196,20 @@ MsgLen bufSz; amDl->pollSn = (amDl->txNext - 1) & amDl->snModMask; - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d", - amDl->pollSn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d", + amDl->pollSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); /* kw005.201: Fix for poll retransmission timer. * Timer is stopped if it is already running and * then starting the timer. Fixes crs * ccpu00117216 and ccpu00118284 . * */ - if( TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMDL_POLL_RETX_TMR) ) + if( TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR) ) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR); } - kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR); } return (pollBit); @@ -2397,38 +2231,20 @@ MsgLen bufSz; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmCreatePdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwAmHdr *amHdr, -RlcDlPduInfo *pduInfo, -Buffer *pdu -) -#else -PRIVATE Void kwAmmCreatePdu(gCb, rbCb, pduInfo, amHdr, pdu) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwAmHdr *amHdr; -RlcDlPduInfo *pduInfo; -Buffer *pdu; -#endif +void rlcAmmCreatePdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmHdr *amHdr, +RlcDlPduInfo *pduInfo, Buffer *pdu) { - U8 hdr[KW_MAX_HDRSZ]; - U16 idx; - KwTx *txBuf; - MsgLen pduSz; - KwAmDl *amDl = &(rbCb->m.amDl); - - TRC2(kwAmmCreatePdu) - + uint8_t hdr[RLC_MAX_HDRSZ]; + uint16_t idx; + RlcTx *txBuf; + MsgLen pduSz; + RlcAmDl *amDl = &(rbCb->m.amDl); /* Update sn */ amHdr->sn = amDl->txNext; /*5GNR RLC: Increment txNext only if no segmentation of it is a last segment */ - if((!amHdr->si) || (amHdr->si == KW_SI_LAST_SEG)) + if((!amHdr->si) || (amHdr->si == RLC_SI_LAST_SEG)) { //printf("\n 5GNRLOG: no segment/last seg SDU with lcId %d Sn %u txNext %u So %u\n", // rbCb->lch.lChId, amHdr->sn, amDl->txNext, amHdr->so); @@ -2436,19 +2252,19 @@ Buffer *pdu; } /* Update hdr Info */ - SFndLenMsg(pdu, &pduSz); + ODU_GET_MSG_LEN(pdu, &pduSz); /* passing newPDU = TRUE*/ - amHdr->p = kwAmmDlCheckAndSetPoll(gCb,rbCb, TRUE, pduSz); + amHdr->p = rlcAmmDlCheckAndSetPoll(gCb,rbCb, TRUE, pduSz); /* Construct header with the available hdr Info, set isSegment to FALSE */ - kwConstructAmHdr(amHdr, hdr, amDl->snLen, &idx); + rlcConstructAmHdr(amHdr, hdr, amDl->snLen, &idx); /* Concatenate hdr and data */ - SAddPreMsgMultInOrder(hdr, idx+1, pdu); + ODU_ADD_PRE_MSG_MULT_IN_ORDER(hdr, idx+1, pdu); - txBuf = kwUtlGetTxBuf(amDl->txBufLst, amHdr->sn); - kwCpyMsg(gCb,pdu,&(pduInfo->pdu)); + txBuf = rlcUtlGetTxBuf(amDl->txBufLst, amHdr->sn); + rlcCpyMsg(gCb,pdu,&(pduInfo->pdu)); pduInfo->pduSz = pduSz; pduInfo->hdrSz = idx+1; @@ -2457,7 +2273,7 @@ Buffer *pdu; /* Reestimate estHdrSz for mid and last seg */ if(amHdr->si & 0x1) { - amDl->estHdrSz += ((amHdr->si == KW_SI_MID_SEG)? pduInfo->hdrSz : (pduInfo->hdrSz + 2)); + amDl->estHdrSz += ((amHdr->si == RLC_SI_MID_SEG)? pduInfo->hdrSz : (pduInfo->hdrSz + 2)); } cmLListAdd2Tail(&txBuf->pduLst, &pduInfo->lstEnt); @@ -2465,7 +2281,7 @@ Buffer *pdu; gCb->genSts.bytesSent += pduSz; - RETVOID; + return; } /** @@ -2484,20 +2300,20 @@ Buffer *pdu; * */ #ifdef ANSI -PRIVATE Void kwRemRetxPdu +PRIVATE Void rlcRemRetxPdu ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwRetx *retx +RlcRetx *retx ) #else -PRIVATE Void kwRemRetxPdu(gCb, rbCb, retx) +PRIVATE Void rlcRemRetxPdu(gCb, rbCb, retx) RlcCb *gCb; RlcDlRbCb *rbCb; -KwRetx *retx; +RlcRetx *retx; #endif { - TRC2(kwRemRetxPdu) + TRC2(rlcRemRetxPdu) cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt); @@ -2512,8 +2328,8 @@ KwRetx *retx; AMDL.estHdrSz -= retx->hdrSz; } - kwUtlAddReTxPduToBeFreedQueue(gCb, retx); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlAddReTxPduToBeFreedQueue(gCb, retx); + rlcUtlRaiseDlCleanupEvent(gCb); RETVOID; } @@ -2535,20 +2351,20 @@ KwRetx *retx; * */ #ifdef ANSI -PRIVATE Void kwAmmDlMarkPduForReTx +PRIVATE Void rlcAmmDlMarkPduForReTx ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwRetx *retx +RlcRetx *retx ) #else -PRIVATE Void kwAmmDlMarkPduForReTx(*gCb, rbCb, retx) +PRIVATE Void rlcAmmDlMarkPduForReTx(*gCb, rbCb, retx) RlcCb *gCb; RlcDlRbCb *rbCb; -KwRetx *retx; +RlcRetx *retx; #endif { - TRC2(kwAmmDlMarkPduForReTx) + TRC2(rlcAmmDlMarkPduForReTx) if (AMDL.maxReTxReached == TRUE) { RETVOID; @@ -2575,12 +2391,12 @@ KwRetx *retx; rbCb->m.amDl.cntrlBo = 0; rbCb->m.amDl.retxBo = 0; /* Sending BO update to SCH */ - kwUtlSndDStaRsp(gCb, rbCb, 0,0,0,0); - kwAmmSndStaInd(gCb, rbCb, retx); + rlcUtlSendDedLcBoStatus(gCb, rbCb, 0,0,0,0); + rlcAmmSndStaInd(gCb, rbCb, retx); gRlcStats.amRlcStats.numDLMaxRetx++; } - kwRemRetxPdu(gCb,rbCb, retx); + rlcRemRetxPdu(gCb,rbCb, retx); RETVOID; } @@ -2615,24 +2431,24 @@ KwRetx *retx; * */ #ifdef ANSI -PRIVATE Void kwAmmDlCheckIsSDUDelivered +PRIVATE Void rlcAmmDlCheckIsSDUDelivered ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwSduMap *sduMap, +RlcSduMap *sduMap, KwuDatCfmInfo **datCfm ) #else -PRIVATE Void kwAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm) +PRIVATE Void rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm) RlcCb *gCb; RlcDlRbCb *rbCb; -KwSduMap *sduMap; +RlcSduMap *sduMap; KwuDatCfmInfo **datCfm; #endif { - KwSdu *sdu; + RlcSdu *sdu; - TRC2(kwAmmDlCheckIsSDUDelivered) + TRC2(rlcAmmDlCheckIsSDUDelivered) sdu = sduMap->sdu; @@ -2653,11 +2469,11 @@ KwuDatCfmInfo **datCfm; * send so many confirms in one go * Confrims to PDCP are being dropped in this case */ - KwKwuSapCb *kwuSap; - kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP; - KwUiKwuDatCfm(&kwuSap->pst, kwuSap->suId, *datCfm); + RlcKwuSapCb *rlckwuSap; + rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP; + RlcUiKwuDatCfm(&rlckwuSap->pst, rlckwuSap->suId, *datCfm); - RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, *datCfm, sizeof(KwuDatCfmInfo)); + RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, *datCfm, sizeof(KwuDatCfmInfo)); #if (ERRCLASS & ERRCLS_ADD_RES) if (*datCfm == NULLP) @@ -2679,8 +2495,8 @@ KwuDatCfmInfo **datCfm; /* Remove SDU from the sduQ */ cmLListDelFrm(&AMDL.sduQ, &sdu->lstEnt); - kwUtlAddSduToBeFreedQueue(gCb, sdu); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlAddSduToBeFreedQueue(gCb, sdu); + rlcUtlRaiseDlCleanupEvent(gCb); } RETVOID; @@ -2702,25 +2518,25 @@ KwuDatCfmInfo **datCfm; * */ #ifdef ANSI -PRIVATE Void kwAmmDlProcessSuccessfulTxPdu +PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwSn sn, +RlcSn sn, KwuDatCfmInfo **datCfm ) #else -PRIVATE Void kwAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm) +PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm) RlcCb *gCb; RlcDlRbCb *rbCb; -KwSn sn; +RlcSn sn; KwuDatCfmInfo **datCfm; #endif { - TRC2(kwAmmDlProcessSuccessfulTxPdu) + TRC2(rlcAmmDlProcessSuccessfulTxPdu) CmLList *pduNode; - KwTx *txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn); + RlcTx *txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn); if (txBuf == NULLP) { @@ -2730,17 +2546,17 @@ KwuDatCfmInfo **datCfm; while(pduNode) { RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pduNode->node); - kwAmmDlCheckIsSDUDelivered(gCb, + rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, &(pduInfo->sduMap), datCfm); pduNode = pduNode->next; } - kwUtlAddTxPduToBeFreedQueue(gCb, txBuf); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlAddTxPduToBeFreedQueue(gCb, txBuf); + rlcUtlRaiseDlCleanupEvent(gCb); /* so that it is not processed again */ - kwUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb); + rlcUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb); RETVOID; } @@ -2760,30 +2576,30 @@ KwuDatCfmInfo **datCfm; * */ #ifdef ANSI -PRIVATE Void kwAmmSndStaInd +PRIVATE Void rlcAmmSndStaInd ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwRetx *retx +RlcRetx *retx ) #else -PRIVATE Void kwAmmSndStaInd(gCb, rbCb, retx) +PRIVATE Void rlcAmmSndStaInd(gCb, rbCb, retx) RlcCb *gCb; RlcDlRbCb *rbCb; -KwRetx *retx; +RlcRetx *retx; #endif { KwuStaIndInfo *staInd; - KwKwuSapCb *kwuSap; + RlcKwuSapCb *rlckwuSap; - TRC2(kwAmmSndStaInd); + TRC2(rlcAmmSndStaInd); /* Sap control block */ - kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP; + rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP; /* Allocate memory for staInd Info */ - RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, staInd, sizeof(KwuStaIndInfo)); + RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, staInd, sizeof(KwuStaIndInfo)); #if (ERRCLASS & ERRCLS_ADD_RES) if (staInd == NULLP) @@ -2797,14 +2613,14 @@ KwRetx *retx; #endif /* ERRCLASS & ERRCLS_RES */ /* Fill staInd Info */ - KW_MEM_CPY(&staInd->rlcId, &rbCb->rlcId, sizeof(CmLteRlcId)); + RLC_MEM_CPY(&staInd->rlcId, &rbCb->rlcId, sizeof(CmLteRlcId)); staInd->numSdu = 1; staInd->sduId[0] = retx->sduMap.sdu->mode.am.sduId; #ifdef KW_PDCP #else - KwUiKwuStaInd(&kwuSap->pst, kwuSap->suId, staInd); + RlcUiKwuStaInd(&rlckwuSap->pst, rlckwuSap->suId, staInd); #endif /* KW_PDCP */ RETVOID; @@ -2824,22 +2640,10 @@ KwRetx *retx; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwGetNxtRetx -( -RlcCb *gCb, -KwRetx **retx -) -#else -PRIVATE Void kwGetNxtRetx(gCb, retx) -RlcCb *gCb; -KwRetx **retx; -#endif +void rlcGetNxtRetx(RlcCb *gCb, RlcRetx **retx) { CmLList *tNode; - TRC2(kwGetNxtRetx); - do { tNode = &((*retx)->lstEnt); @@ -2847,7 +2651,7 @@ KwRetx **retx; if (tNode) { - *retx = (KwRetx *)tNode->node; + *retx = (RlcRetx *)tNode->node; } else { @@ -2856,7 +2660,7 @@ KwRetx **retx; } }while((*retx)->pendingReTrans == FALSE); - RETVOID; + return; } /** @@ -2872,14 +2676,14 @@ KwRetx **retx; * */ #ifdef ANSI -PUBLIC Void kwAmmDlReEstablish +Void rlcAmmDlReEstablish ( RlcCb *gCb, CmLteRlcId rlcId, RlcDlRbCb *rbCb ) #else -PUBLIC Void kwAmmDlReEstablish(gCb, rlcId, rbCb) +Void rlcAmmDlReEstablish(gCb, rlcId, rbCb) RlcCb *gCb; CmLteRlcId rlcId; RlcDlRbCb *rbCb; @@ -2888,8 +2692,8 @@ RlcDlRbCb *rbCb; /* create a new AM DL RB, reset it and replace in the UeCb*/ RlcDlUeCb *ueCb; RlcDlRbCb *resetRb; - KwAmDl* newAmDl; - KwAmDl* oldAmDl; + RlcAmDl* newAmDl; + RlcAmDl* oldAmDl; RLC_ALLOC(gCb, resetRb, sizeof(RlcDlRbCb)); /* ccpu00135170 Removing KLOCK warning */ @@ -2898,8 +2702,8 @@ RlcDlRbCb *rbCb; RETVOID; } - KW_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb)); - RLC_MEM_SET(&resetRb->m.amDl, 0 , sizeof(KwAmDl)); + RLC_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb)); + RLC_MEM_SET(&resetRb->m.amDl, 0 , sizeof(RlcAmDl)); /* AGHOSH changes start */ /* restore the old AM values */ @@ -2917,7 +2721,7 @@ RlcDlRbCb *rbCb; cmInitTimers(&(resetRb->m.amDl.pollRetxTmr), 1); /* AGHOSH changes end */ - if (ROK != kwDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb)) + if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb)) { RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId.cellId, "UeId [%d]: UeCb not found RBID;%d", @@ -2953,14 +2757,14 @@ RlcDlRbCb *rbCb; U32 hashIndex; RLC_ALLOC(gCb, resetRb->m.amDl.txBufLst, - (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp))); - for(hashIndex = 0; hashIndex < KW_TX_BUF_BIN_SIZE; hashIndex++) + (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp))); + for(hashIndex = 0; hashIndex < RLC_TX_BUF_BIN_SIZE; hashIndex++) { cmLListInit(&(resetRb->m.amDl.txBufLst[hashIndex])); } #endif /* send the old rb of deletion */ - kwAmmFreeDlRbCb(gCb,rbCb); + rlcAmmFreeDlRbCb(gCb,rbCb); /* TODO: for now we are re-settting the re-establishment flag here @@ -2995,21 +2799,21 @@ RlcDlRbCb *rbCb; * -# RFAILED In case the SDU is not found or already mapped */ #ifdef ANSI -PUBLIC S16 kwAmmDiscSdu +S16 rlcAmmDiscSdu ( RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId ) #else -PUBLIC S16 kwAmmDiscSdu(gCb, rbCb, sduId) +S16 rlcAmmDiscSdu(gCb, rbCb, sduId) RlcCb *gCb; RlcDlRbCb *rbCb; U32 sduId; #endif { - TRC2(kwAmmDiscSdu); - return RFAILED; + TRC2(rlcAmmDiscSdu); + return (RFAILED); } /** @@ -3025,22 +2829,22 @@ U32 sduId; * @return Void */ #ifdef ANSI -PUBLIC Void kwAmmPollRetxTmrExp +Void rlcAmmPollRetxTmrExp ( RlcCb *gCb, RlcDlRbCb *rbCb ) #else -PUBLIC Void kwAmmPollRetxTmrExp(gCb, rbCb) +Void rlcAmmPollRetxTmrExp(gCb, rbCb) RlcCb *gCb; RlcDlRbCb *rbCb; #endif { - KwRetx *retx; - KwAmDl *amDl = &(rbCb->m.amDl); - KwSn sn; - KwTx *txBuf; - TRC2(kwAmmPollRetxTmrExp); + RlcRetx *retx; + RlcAmDl *amDl = &(rbCb->m.amDl); + RlcSn sn; + RlcTx *txBuf; + TRC2(rlcAmmPollRetxTmrExp); /* kw003.201 - Correcting the logic for determmining whether to do */ @@ -3060,31 +2864,31 @@ RlcDlRbCb *rbCb; } if (((amDl->nxtTx == NULLP) && (amDl->nxtRetx == NULLP)) || - KW_AM_IS_TRANS_WIN_STALLED(amDl)) + RLC_AM_IS_TRANS_WIN_STALLED(amDl)) { sn = (amDl->txNext - 1) & amDl->snModMask; - txBuf = kwUtlGetTxBuf(amDl->txBufLst, sn); + txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn); if (txBuf != NULLP) { - kwAmmDlMoveFrmTxtoRetxBuffer(gCb,amDl, &retx, sn); + rlcAmmDlMoveFrmTxtoRetxBuffer(gCb,amDl, &retx, sn); if (AMDL.nxtRetx == NULLP) { AMDL.nxtRetx = retx; } - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); + rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL); RETVOID; } /* Get the last node in retxLst */ - KW_LLIST_LAST_RETX(amDl->retxLst, retx); + RLC_LLIST_LAST_RETX(amDl->retxLst, retx); /* Unset wtForAck flag for the NACK PDUs */ if (retx != NULLP) { - kwAmmDlMarkPduForReTx(gCb, rbCb, retx); - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); + rlcAmmDlMarkPduForReTx(gCb, rbCb, retx); + rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL); } } @@ -3110,39 +2914,39 @@ RlcDlRbCb *rbCb; */ #ifdef ANSI -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn +PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwSn mAckSn, +RlcSn mAckSn, CmLList *retxNode, KwuDatCfmInfo **datCfm ) #else -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm) +PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm) RlcCb *gCb; RlcDlRbCb *rbCb; -KwSn mAckSn; +RlcSn mAckSn; CmLList *retxNode; KwuDatCfmInfo **datCfm; #endif { - KwSn mSn; - KwSn sn; - KwRetx *retx; - KwTx *txBuf; + RlcSn mSn; + RlcSn sn; + RlcRetx *retx; + RlcTx *txBuf; - TRC2(kwAmmDlUpdateTxAndReTxBufForAckSn); + TRC2(rlcAmmDlUpdateTxAndReTxBufForAckSn); /* Remove pdus/segs from retxLst */ while (retxNode) { - retx = (KwRetx *)(retxNode->node); + retx = (RlcRetx *)(retxNode->node); retxNode = retxNode->next; MODAMT(retx->amHdr.sn, mSn, AMDL.txNextAck,AMDL.snModMask); if (mSn < mAckSn) { - kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); + rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); } } @@ -3154,17 +2958,17 @@ KwuDatCfmInfo **datCfm; sn = AMDL.txNextAck; while(mSn < mAckSn) { - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn); + txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn); if (txBuf != NULLP) { RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU " + "rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU " "with sn = %ld UEID:%ld CELLID:%ld", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); - kwAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm); + rlcAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm); } sn = (sn + 1) & AMDL.snModMask; @@ -3192,39 +2996,39 @@ KwuDatCfmInfo **datCfm; * */ #ifdef ANSI -PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn +PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ( RlcCb *gCb, RlcDlRbCb *rbCb, -KwSn sn, -KwSn mNackSn, +RlcSn sn, +RlcSn mNackSn, CmLList **retxNode, KwuDatCfmInfo **datCfm ) #else -PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm) +PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm) RlcCb *gCb; RlcDlRbCb *rbCb; -KwSn sn; -KwSn mNackSn; +RlcSn sn; +RlcSn mNackSn; CmLList **retxNode; KwuDatCfmInfo **datCfm; #endif { - KwSn mSn; - KwRetx *retx; - KwTx *txBuf=NULLP; + RlcSn mSn; + RlcRetx *retx; + RlcTx *txBuf=NULLP; - TRC2(kwAmmDlUpdTxAndReTxBufForLessThanNackSn); + TRC2(rlcAmmDlUpdTxAndReTxBufForLessThanNackSn); while (*retxNode) { - retx = (KwRetx *)((*retxNode)->node); + retx = (RlcRetx *)((*retxNode)->node); MODAMT(retx->amHdr.sn, mSn, AMDL.txNextAck,AMDL.snModMask); if (mSn < mNackSn) { (*retxNode) = (*retxNode)->next; - kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); + rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); } else { @@ -3238,17 +3042,17 @@ KwuDatCfmInfo **datCfm; { /* this if check seems redundant,why should mSn ever be mTxSn (which actually is VT(A) */ - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn); + txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn); if ((txBuf != NULLP)) { RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId, - "kwHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d", + "rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); /* Remove pdus from txBuf */ - kwAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm); + rlcAmmDlProcessSuccessfulTxPdu(gCb,rbCb, sn, datCfm); } sn = (sn + 1) & AMDL.snModMask; @@ -3275,30 +3079,14 @@ KwuDatCfmInfo **datCfm; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwConstructAmHdr -( -KwAmHdr *amHdr, -U8 *hdr, -U8 snLen, -U16 *idx -) -#else -PRIVATE Void kwConstructAmHdr(amHdr, hdr, snLen, idx) -KwAmHdr *amHdr; -U8 *hdr; -U8 snLen; -U16 *idx; -#endif +void rlcConstructAmHdr(RlcAmHdr *amHdr, uint8_t *hdr, uint8_t snLen, uint16_t *idx) { - TRC2(kwConstructAmHdr); - *idx = 0; - hdr[0] = KW_DATA_BITMASK; + hdr[0] = RLC_DATA_BITMASK; hdr[0] = hdr[0] | (amHdr->p << 6); hdr[0] = hdr[0] | ((amHdr->si & 0x3) << 4); - if(snLen == KW_AM_CFG_12BIT_SN_LEN) + if(snLen == RLC_AM_CFG_12BIT_SN_LEN) { hdr[0] = hdr[0] | (U8)((amHdr->sn & 0xF00) >> 8); hdr[1] = (U8)(amHdr->sn & 0x0FF); @@ -3313,7 +3101,7 @@ U16 *idx; (*idx)++; } - if ((amHdr->si == KW_SI_MID_SEG) || (amHdr->si == KW_SI_LAST_SEG)) + if ((amHdr->si == RLC_SI_MID_SEG) || (amHdr->si == RLC_SI_LAST_SEG)) { (*idx)++; hdr[(*idx)] = (U8)((amHdr->so & 0xFF00)>> 8); @@ -3321,7 +3109,7 @@ U16 *idx; hdr[(*idx)] = (U8)(amHdr->so & 0xFF); } - RETVOID; + return; } /** @@ -3339,29 +3127,29 @@ U16 *idx; * */ #ifdef ANSI -PRIVATE Void kwAmmAddPduToRetxLst +PRIVATE Void rlcAmmAddPduToRetxLst ( -KwAmDl *amDl, -KwRetx *retx +RlcAmDl *amDl, +RlcRetx *retx ) #else -PRIVATE Void kwAmmAddPduToRetxLst(amDl, retx) -KwAmDl *amDl; -KwRetx *retx; +PRIVATE Void rlcAmmAddPduToRetxLst(amDl, retx) +RlcAmDl *amDl; +RlcRetx *retx; #endif { CmLList *node; - KwRetx *tRetx; - KwSn tMSn; - KwSn retxMSn; + RlcRetx *tRetx; + RlcSn tMSn; + RlcSn retxMSn; - TRC2(kwAmmAddPduToRetxLst); + TRC2(rlcAmmAddPduToRetxLst); node = amDl->retxLst.last; MODAMT(retx->amHdr.sn, retxMSn, amDl->txNextAck,amDl->snModMask); while(node != NULLP) { - tRetx = (KwRetx *)(node->node); + tRetx = (RlcRetx *)(node->node); MODAMT(tRetx->amHdr.sn, tMSn, amDl->txNextAck,amDl->snModMask); if (tMSn > retxMSn) { @@ -3410,23 +3198,23 @@ KwRetx *retx; */ #ifdef ANSI -PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer +PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer ( RlcCb *gCb, -KwAmDl *amDl, -KwRetx **retx, -KwSn sn +RlcAmDl *amDl, +RlcRetx **retx, +RlcSn sn ) #else -PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn) +PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn) RlcCb *gCb; -KwAmDl *amDl; -KwRetx **retx; -KwSn sn; +RlcAmDl *amDl; +RlcRetx **retx; +RlcSn sn; #endif { - KwTx* txBuf = kwUtlGetTxBuf(amDl->txBufLst, sn); - TRC2(kwAmmDlMoveFrmTxtoRetxBuffer); + RlcTx* txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn); + TRC2(rlcAmmDlMoveFrmTxtoRetxBuffer); if (txBuf == NULLP) { @@ -3435,7 +3223,7 @@ KwSn sn; while(txBuf->pduLst.first) { RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node); - RLC_ALLOC_WC(gCb,*retx, sizeof(KwRetx)); + RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx)); #if (ERRCLASS & ERRCLS_ADD_RES) if (*retx == NULLP) @@ -3446,7 +3234,7 @@ KwSn sn; #endif /* ERRCLASS & ERRCLS_RES */ /* Move Sdu byte segment from TX buf to retx buf*/ - kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, + rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo); @@ -3456,7 +3244,7 @@ KwSn sn; RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo)); } /* Remove PDU from txBuf */ - kwUtlDelTxBuf(amDl->txBufLst, txBuf,gCb); + rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb); RETVOID; } @@ -3477,21 +3265,21 @@ KwSn sn; * @return Void */ #ifdef ANSI -PUBLIC Void kwAmmFreeDlRbCb +Void rlcAmmFreeDlRbCb ( RlcCb *gCb, RlcDlRbCb *rbCb ) #else -PUBLIC Void kwAmmFreeDlRbCb(gCb,rbCb) +Void rlcAmmFreeDlRbCb(gCb,rbCb) RlcCb *gCb; RlcDlRbCb *rbCb; #endif { /* stop the re-transmission timer */ - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMDL_POLL_RETX_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR)) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR); } /* store the entire Rb pointer */ @@ -3501,7 +3289,7 @@ RlcDlRbCb *rbCb; /* the sdu queue */ cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.amDl.sduQ)); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlRaiseDlCleanupEvent(gCb); RETVOID; } @@ -3514,39 +3302,24 @@ RlcDlRbCb *rbCb; * * @param[in] gCb RLC instance control block * @param[in] rbCb Downlink RB control block - * @param[in] kwDatReq The data to be passed to MAC + * @param[in] rlcDatReq The data to be passed to MAC * * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmCreateStatusPdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwAmmCreateStatusPdu(gCb, rbCb, kwDatReq) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +void rlcAmmCreateStatusPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq) { - KwSn sn; /* sequence number */ - KwSn ack_sn; /* Ack sequence number */ + RlcSn sn; /* sequence number */ + RlcSn ack_sn; /* Ack sequence number */ Buffer *mBuf; /* control pdu buffer */ MsgLen cntrlPduSz; /* control pdu size */ - U8 cntrlPdu[KW_MAX_CNTRL_FIELDS]; /* control pdu to be added to mBuf */ - KwUdxDlStaPdu *pStaPdu; - U16 bytesToEncode = 0; /* bytes required to encode the STATUS PDU */ - U16 encIdx = 0; - U16 prevEncIdx = 0; - KwNackInfo *kwNackInfo; - U16 nkCnt = 0; - - TRC2(kwAmmCreateStatusPdu) - + uint8_t cntrlPdu[RLC_MAX_CNTRL_FIELDS]; /* control pdu to be added to mBuf */ + RlcUdxDlStaPdu *pStaPdu; + uint16_t bytesToEncode = 0; /* bytes required to encode the STATUS PDU */ + uint16_t encIdx = 0; + uint16_t prevEncIdx = 0; + RlcNackInfo *rlcNackInfo; + uint16_t nkCnt = 0; pStaPdu = AMDL.pStaPdu; @@ -3563,7 +3336,7 @@ KwDatReq *kwDatReq; ack_sn = pStaPdu->ackSn; - if (rbCb->m.amDl.snLen == KW_AM_CFG_12BIT_SN_LEN) + if (rbCb->m.amDl.snLen == RLC_AM_CFG_12BIT_SN_LEN) { /* If alteast one NACK SN Info then set the E1 field */ @@ -3581,24 +3354,24 @@ KwDatReq *kwDatReq; { sn = pStaPdu->nackInfo[nkCnt].sn; - kwNackInfo = &(pStaPdu->nackInfo[nkCnt]); + rlcNackInfo = &(pStaPdu->nackInfo[nkCnt]); bytesToEncode += 2; /* 2 Octets for NACK SN */ /* Check if E2 : isSegment is set */ - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { bytesToEncode += 4; /* 4 Octets: SOstart, SOend */ } /* Check if E3 : nackRange is set */ - if (kwNackInfo->nackRange) + if (rlcNackInfo->nackRange) { bytesToEncode += 1; /* 1 Octet: NACK range */ } /* Check if this NACK info can be accomodated in the Grant */ - if( kwDatReq->pduSz >= bytesToEncode) + if( rlcDatReq->pduSz >= bytesToEncode) { /* If there is a NACK SN before this then set its E1 bit */ @@ -3614,7 +3387,7 @@ KwDatReq *kwDatReq; /* Next Octet */ cntrlPdu[encIdx + 1] = (sn & 0xF) << 4; - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { /*Set E2 Bit */ cntrlPdu[encIdx + 1] |= 0x4; @@ -3622,25 +3395,25 @@ KwDatReq *kwDatReq; /* Add soStart and soEnd */ /* SOstart */ - cntrlPdu[encIdx + 2] = (kwNackInfo->soStart) >> 8; - cntrlPdu[encIdx + 3] = kwNackInfo->soStart & 0xFF; + cntrlPdu[encIdx + 2] = (rlcNackInfo->soStart) >> 8; + cntrlPdu[encIdx + 3] = rlcNackInfo->soStart & 0xFF; /* SOend */ - cntrlPdu[encIdx + 4] = (kwNackInfo->soEnd) >> 8; - cntrlPdu[encIdx + 5] = kwNackInfo->soEnd & 0xFF; + cntrlPdu[encIdx + 4] = (rlcNackInfo->soEnd) >> 8; + cntrlPdu[encIdx + 5] = rlcNackInfo->soEnd & 0xFF; } - if (kwNackInfo->nackRange) + if (rlcNackInfo->nackRange) { /*Set E3 Bit */ cntrlPdu[encIdx + 1] |= 0x2; - if(kwNackInfo->isSegment) + if(rlcNackInfo->isSegment) { - cntrlPdu[encIdx + 6] = kwNackInfo->nackRange; + cntrlPdu[encIdx + 6] = rlcNackInfo->nackRange; } else { - cntrlPdu[encIdx + 2] = kwNackInfo->nackRange; + cntrlPdu[encIdx + 2] = rlcNackInfo->nackRange; } } @@ -3649,7 +3422,7 @@ KwDatReq *kwDatReq; /* Set ACK SN now */ else { - ack_sn = kwNackInfo->sn; + ack_sn = rlcNackInfo->sn; /* Not even one nack can be accomodated */ if (nkCnt == 0) @@ -3668,19 +3441,15 @@ KwDatReq *kwDatReq; /* set ACK SN */ { - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAssembleCntrlInfo: ACK PDU's SN = %d" - "UEID:%d CELLID:%d", - ack_sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAssembleCntrlInfo: ACK PDU's SN = %d"\ + "UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); cntrlPdu[0] |= (ack_sn & 0xF00)>> 8; cntrlPdu[1] = (U8)ack_sn; } } - else if (rbCb->m.amDl.snLen == KW_AM_CFG_18BIT_SN_LEN) + else if (rbCb->m.amDl.snLen == RLC_AM_CFG_18BIT_SN_LEN) { /* If alteast one NACK SN Info then set the E1 field */ if (pStaPdu->nackCount) @@ -3697,24 +3466,24 @@ KwDatReq *kwDatReq; { sn = pStaPdu->nackInfo[nkCnt].sn; - kwNackInfo = &(pStaPdu->nackInfo[nkCnt]); + rlcNackInfo = &(pStaPdu->nackInfo[nkCnt]); bytesToEncode += 3; /* 3 Octets for NACK SN */ /* Check if E2 : isSegment is set */ - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { bytesToEncode += 4; /* 4 Octets: SOstart, SOend */ } /* Check if E3 : nackRange is set */ - if (kwNackInfo->nackRange) + if (rlcNackInfo->nackRange) { bytesToEncode += 1; /* 1 Octet: NACK range */ } /* Check if this NACK info can be accomodated in the Grant */ - if( kwDatReq->pduSz >= bytesToEncode) + if( rlcDatReq->pduSz >= bytesToEncode) { /* If there is a NACK SN before this then set its E1 bit */ @@ -3733,7 +3502,7 @@ KwDatReq *kwDatReq; /* Next Octet */ cntrlPdu[encIdx + 2] = (U8)((sn & 0x3)<< 6); - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { /* NACKSN E1 E2 E3 R R R */ /*Set E2 Bit */ @@ -3742,27 +3511,27 @@ KwDatReq *kwDatReq; /* Add soStart and soEnd */ /* SOstart */ - cntrlPdu[encIdx + 3] = (kwNackInfo->soStart) >> 8; - cntrlPdu[encIdx + 4] = (U8)kwNackInfo->soStart; + cntrlPdu[encIdx + 3] = (rlcNackInfo->soStart) >> 8; + cntrlPdu[encIdx + 4] = (U8)rlcNackInfo->soStart; /* SOend */ - cntrlPdu[encIdx + 5] = (kwNackInfo->soEnd) >> 8; - cntrlPdu[encIdx + 6] = (U8)(kwNackInfo->soEnd); + cntrlPdu[encIdx + 5] = (rlcNackInfo->soEnd) >> 8; + cntrlPdu[encIdx + 6] = (U8)(rlcNackInfo->soEnd); } - if (kwNackInfo->nackRange) + if (rlcNackInfo->nackRange) { /* NACKSN E1 E2 E3 R R R */ /*Set E3 Bit */ cntrlPdu[encIdx + 2] |= 0x08; - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { - cntrlPdu[encIdx + 7] = kwNackInfo->nackRange; + cntrlPdu[encIdx + 7] = rlcNackInfo->nackRange; } else { - cntrlPdu[encIdx + 3] = kwNackInfo->nackRange; + cntrlPdu[encIdx + 3] = rlcNackInfo->nackRange; } } @@ -3771,7 +3540,7 @@ KwDatReq *kwDatReq; /* Set ACK SN now */ else { - ack_sn = kwNackInfo->sn; + ack_sn = rlcNackInfo->sn; /* Not even one nack can be accomodated */ if (nkCnt == 0) @@ -3790,13 +3559,8 @@ KwDatReq *kwDatReq; /* set ACK SN */ { - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAssembleCntrlInfo: ACK PDU's SN = %d" - "UEID:%d CELLID:%d", - ack_sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - + DU_LOG("\nRLC: rlcAssembleCntrlInfo: ACK PDU's SN = %d" + "UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId,rbCb->rlcId.cellId); cntrlPdu[0] |= (ack_sn & 0x3C000) >> 14; cntrlPdu[1] = (ack_sn & 0x3FC0) >> 6; @@ -3807,36 +3571,34 @@ KwDatReq *kwDatReq; else { /* ERROR Log */ - RLOG_ARG3(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "kwAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! UEID:%d CELLID:%d", - rbCb->m.amDl.snLen, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \ + UEID:%d CELLID:%d", rbCb->m.amDl.snLen, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); } #ifndef L2_OPTMZ - SGetMsg(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb),&mBuf); + SGetMsg(RLC_GET_MEM_REGION(gCb), RLC_GET_MEM_POOL(gCb),&mBuf); #else - mBuf = (Buffer *)kwAmmStaPduList[kwAmmStaPduListCnt++]; + mBuf = (Buffer *)rlcAmmStaPduList[rlcAmmStaPduListCnt++]; SResetMBuf(mBuf); - if(kwAmmStaPduListCnt > 511) - kwAmmStaPduListCnt = 0; + if(rlcAmmStaPduListCnt > 511) + rlcAmmStaPduListCnt = 0; #endif cntrlPduSz = encIdx; - SAddPstMsgMult (cntrlPdu, cntrlPduSz, mBuf); + ODU_ADD_POST_MSG_MULT(cntrlPdu, cntrlPduSz, mBuf); - kwDatReq->pduSz -= cntrlPduSz; + rlcDatReq->pduSz -= cntrlPduSz; /* Add mBuf to AMDL.mBuf */ AMDL.mBuf = mBuf; - RETVOID; + return; } #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */ -S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId, +S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId, CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu); #ifdef ANSI @@ -3844,13 +3606,13 @@ PRIVATE Void rgAmmExtractElmnt ( RlcCb *gCb, Buffer *pdu, -KwExtHdr *hdrInfo +RlcExtHdr *hdrInfo ) #else PRIVATE Void rgAmmExtractElmnt(gCb, pdu, hdrInfo) RlcCb *gCb; Buffer *pdu; -KwExtHdr *hdrInfo; +RlcExtHdr *hdrInfo; #endif { U8 hdr; @@ -3863,7 +3625,7 @@ KwExtHdr *hdrInfo; /* U8 rLen1 = 0; */ U16 tVal; - TRC2(kwAmmExtractElmnt); + TRC2(rlcAmmExtractElmnt); hdr = hdrInfo->hdr; @@ -3875,7 +3637,7 @@ KwExtHdr *hdrInfo; tHdr = hdr; if (len <= 8) { - val = tHdr >> (KW_BYTE_LEN - (len)); + val = tHdr >> (RLC_BYTE_LEN - (len)); hdr = hdr << len; pLen -= len; } @@ -3883,31 +3645,31 @@ KwExtHdr *hdrInfo; { fLen = pLen; val = tHdr; - val = val >> (KW_BYTE_LEN - fLen); + val = val >> (RLC_BYTE_LEN - fLen); val = val << (len - fLen); rLen = len - fLen; SRemPreMsg(&hdr, pdu); tHdr = hdr; if (rLen <= 8) { - hdr = hdr >> (KW_BYTE_LEN - rLen); + hdr = hdr >> (RLC_BYTE_LEN - rLen); val = val | hdr; hdr = tHdr << rLen; - pLen = (KW_BYTE_LEN - rLen); + pLen = (RLC_BYTE_LEN - rLen); } else { - rLen = rLen - KW_BYTE_LEN; + rLen = rLen - RLC_BYTE_LEN; tVal = hdr; tVal = tVal << rLen; val = val | tVal; SRemPreMsg(&hdr, pdu); tHdr = hdr; - hdr = hdr >> (KW_BYTE_LEN - rLen); + hdr = hdr >> (RLC_BYTE_LEN - rLen); val = val | hdr; hdr = tHdr << rLen; - pLen = (KW_BYTE_LEN - rLen); + pLen = (RLC_BYTE_LEN - rLen); } } @@ -3942,8 +3704,8 @@ U8 *fByte; #endif { U8 e1; - KwExtHdr hdrInfo; - KwUdxStaPdu *pStaPdu; + RlcExtHdr hdrInfo; + RlcUdxStaPdu *pStaPdu; U8 e3; /* NACK RANGE : 5GNR */ U32 snLen; U32 snRange; @@ -3953,9 +3715,9 @@ U8 *fByte; TRC2(rgAmmUlHndlStatusPdu) - KWDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n"); + RLCDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n"); - KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr)); + RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr)); /* Extract the Control PDU */ hdrInfo.hdr = (*fByte << 1); @@ -3964,14 +3726,14 @@ U8 *fByte; /* D/C has been shifted in the calling function */ if (hdrInfo.hdr & 0xE0) { - KWDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n"); + RLCDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n"); RETVOID; } RLC_ALLOC_SHRABL_BUF(udxPst->region, udxPst->pool, pStaPdu, - sizeof(KwUdxStaPdu)); + sizeof(RlcUdxStaPdu)); #if (ERRCLASS & ERRCLS_ADD_RES) /* Memory allocation failure can not be expected */ @@ -3981,39 +3743,39 @@ U8 *fByte; } #endif - if (rbCb->m.amDl.snLen == KW_AM_CFG_12BIT_SN_LEN) + if (rbCb->m.amDl.snLen == RLC_AM_CFG_12BIT_SN_LEN) { snLen = 12; - resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_12BITS; - resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_12BITS; + resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS; + resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS; } - else if (rbCb->m.amDl.snLen == KW_AM_CFG_18BIT_SN_LEN) + else if (rbCb->m.amDl.snLen == RLC_AM_CFG_18BIT_SN_LEN) { snLen = 18; - resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_18BITS; - resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_18BITS; + resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS; + resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS; } else { - snLen = KW_SN_LEN; + snLen = RLC_SN_LEN; resrvdBitsAckSn = 0; resrvdBitsAckSn = 0; } pStaPdu->nackCnt = 0; /* For CPT */ - hdrInfo.hdr = hdrInfo.hdr << KW_CPT_LEN; + hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN; /* ACK Sn */ - hdrInfo.len = KW_SN_LEN; + hdrInfo.len = RLC_SN_LEN; rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->ackSn = hdrInfo.val; /* Check if NACK Exists */ - hdrInfo.len = KW_E1_LEN; + hdrInfo.len = RLC_E1_LEN; rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); e1 = (U8)hdrInfo.val; - KWDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn); + RLCDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn); /* Extract the Reserved Bits after ACK SN field */ hdrInfo.len = resrvdBitsAckSn; @@ -4022,18 +3784,18 @@ U8 *fByte; /* If NACK exists in control PDU */ /* For ACKs and NACKs */ - while (e1 && (pStaPdu->nackCnt < KW_MAX_NACK_CNT)) + while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT)) { hdrInfo.len = snLen; rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val; - hdrInfo.len = KW_E1_LEN; + hdrInfo.len = RLC_E1_LEN; rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); e1 = (U8)hdrInfo.val; /* Extract e2 */ - /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is + /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is already present*/ rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); /* e2 = (U8) hdrInfo.val;*/ @@ -4042,7 +3804,7 @@ U8 *fByte; pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val; /* Extract e3 : 5GNR */ - /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is + /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is already present*/ rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); e3 = (U8) hdrInfo.val; @@ -4054,14 +3816,14 @@ U8 *fByte; /* Test for resegmentation */ if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment) { - hdrInfo.len = KW_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */ + hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */ rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val; rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd = hdrInfo.val; - KWDBGP_DETAIL(gCb, + RLCDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: soStart and soEnd = %d %d \n", pStaPdu->nackInfo[pStaPdu->nackCnt].soStart, pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd); @@ -4077,7 +3839,7 @@ U8 *fByte; if (e3) { /* Extract NACK range field */ - hdrInfo.len = KW_NACK_RANGE_LEN; + hdrInfo.len = RLC_NACK_RANGE_LEN; rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); snRange = (U8)hdrInfo.val; @@ -4092,9 +3854,9 @@ U8 *fByte; /* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN to the last NACK SN + 1 and discard the original ACK_SN*/ - if(pStaPdu->nackCnt == KW_MAX_NACK_CNT) + if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT) { - pStaPdu->ackSn = (pStaPdu->nackInfo[KW_MAX_NACK_CNT-1].sn + 1) & amDl->snModMask; + pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & amDl->snModMask; } @@ -4105,7 +3867,7 @@ U8 *fByte; RETVOID; } -PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId, +S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId, CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu) { RlcDlRbCb *rbCb = NULLP; @@ -4118,7 +3880,7 @@ PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId, gCb = RLC_GET_RLCCB(1); /* DL RLC instance */ - if( ROK != kwDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb))) + if( ROK != rlcDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb))) { printf("\n RLC UECb Not found...\n"); return RFAILED; @@ -4140,7 +3902,7 @@ PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId, return RFAILED; } - if(KW_CNTRL_PDU == ((fByte & KW_DC_POS) >> KW_DC_SHT)) + if(RLC_CNTRL_PDU == ((fByte & RLC_DC_POS) >> RLC_DC_SHT)) { SRemPreMsg(&temp, rlcSdu); dlRlcPst.selector = 1;/* LWLC*/