X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_amm_dl.c;h=7e4d6ced5e2b7684df6c47fddb1b4610277bf400;hb=refs%2Fchanges%2F91%2F5391%2F11;hp=7b309f828a848cbde84b198e0fbdc99da74d44ce;hpb=5625a52ad68f6ad93684e68bbbdbaef0d462cf9a;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_amm_dl.c b/src/5gnrrlc/kw_amm_dl.c index 7b309f828..7e4d6ced5 100755 --- a/src/5gnrrlc/kw_amm_dl.c +++ b/src/5gnrrlc/kw_amm_dl.c @@ -39,18 +39,7 @@ static const char* RLOG_MODULE_NAME="AMM"; static int RLOG_MODULE_ID=2048; static int RLOG_FILE_ID=189; /* header include files (.h) */ -#include "envopt.h" /* environment options */ -#include "envdep.h" /* environment dependent */ -#include "envind.h" /* environment independent */ - -#include "gen.h" /* general */ -#include "ssi.h" /* system services */ -#include "cm5.h" /* common timer defines */ -#include "cm_tkns.h" /* common tokens defines */ -#include "cm_mblk.h" /* common memory allocation library defines */ -#include "cm_llist.h" /* common link list defines */ -#include "cm_hash.h" /* common hash list defines */ -#include "cm_lte.h" /* common LTE defines */ +#include "common_def.h" #include "lkw.h" /* LKW defines */ #include "ckw.h" /* CKW defines */ #include "kwu.h" /* KWU defines */ @@ -64,15 +53,6 @@ static int RLOG_FILE_ID=189; /* extern (.x) include files */ -#include "gen.x" /* general */ -#include "ssi.x" /* system services */ -#include "cm5.x" /* common timer library */ -#include "cm_tkns.x" /* common tokens */ -#include "cm_mblk.x" /* common memory allocation */ -#include "cm_llist.x" /* common link list */ -#include "cm_hash.x" /* common hash list */ -#include "cm_lte.x" /* common LTE includes */ -#include "cm_lib.x" /* common memory allocation library */ #include "lkw.x" /* LKW */ #include "ckw.x" /* CKW */ #include "kwu.x" /* KWU */ @@ -84,26 +64,26 @@ static int RLOG_FILE_ID=189; //UDAY #ifdef L2_OPTMZ -extern U32 kwAmmStaPduList[512]; - U32 kwAmmStaPduListCnt = 0; +uint32_t rlcAmmStaPduList[512]; +uint32_t 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; +uint32_t rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt; /* local defines */ /* local externs */ /* forward references */ -EXTERN Void kwAmmDlHndlStatusPdu ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwUdxStaPdu *pStaPdu)); +Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcUdxStaPdu *pStaPdu)); /* public variable declarations */ @@ -111,12 +91,12 @@ EXTERN Void kwAmmDlHndlStatusPdu ARGS ((KwCb *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; \ SSegMsg((_retx)->seg, (_retx)->hdrSz, &_pduInfo); \ - KW_FREE_BUF((_retx)->seg); \ + ODU_PUT_MSG_BUF((_retx)->seg); \ (_retx)->seg = _pduInfo; \ }\ (_rbCb)->m.amDl.estHdrSz -= retx->hdrSz;\ @@ -124,117 +104,117 @@ EXTERN Void kwAmmDlHndlStatusPdu ARGS ((KwCb *gCb, /* private function declarations */ -PRIVATE Void kwResegRetxPdus ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwDatReq *kwDatReq)); +static Void rlcResegRetxPdus ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcDatReq *rlcDatReq)); -PRIVATE Void kwRemRetxPdu ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwRetx *retx)); +static Void rlcRemRetxPdu ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcRetx *retx)); -PRIVATE Void kwAmmCreateStatusPdu ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwDatReq *kwDatReq)); +static Void rlcAmmCreateStatusPdu ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcDatReq *rlcDatReq)); -PRIVATE Void kwAmmDlMarkPduForReTx ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwRetx *retx)); +static Void rlcAmmDlMarkPduForReTx ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcRetx *retx)); -PRIVATE Void kwAmmDlProcessSuccessfulTxPdu ARGS((KwCb *gCb, - KwDlRbCb *rbCb, - KwSn sn, +static Void rlcAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcSn sn, KwuDatCfmInfo **datCfm)); -PRIVATE Void kwAmmDlSetTxNextAck ARGS((KwAmDl *amDl, KwSn sn)); +static Void rlcAmmDlSetTxNextAck ARGS((RlcAmDl *amDl, RlcSn sn)); -PRIVATE Void kwAmmDlCheckAndStopPollTmr ARGS((KwCb *gCb, - KwDlRbCb *rbCb, - KwSn mAckSn)); +static Void rlcAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcSn mAckSn)); -PRIVATE Void kwAssembleSdus ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwDatReq *kwDatReq)); +static Void rlcAssembleSdus ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcDatReq *rlcDatReq)); -PRIVATE Bool kwAmmDlCheckAndSetPoll ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - Bool newPdu, +static bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + bool newPdu, MsgLen bufSz)); -PRIVATE Void kwAmmCreatePdu ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwAmHdr *amHdr, - KwDlPduInfo *pduInfo, +static Void rlcAmmCreatePdu ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcAmHdr *amHdr, + RlcDlPduInfo *pduInfo, Buffer *pdu)); -PRIVATE Void kwAmmSndStaInd ARGS ((KwCb *gCb,KwDlRbCb *rbCb, KwRetx *retx)); +static Void rlcAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, RlcRetx *retx)); -PRIVATE Void kwGetNxtRetx ARGS ((KwCb *gCb, KwRetx **retx)); +static Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx)); -PRIVATE Void kwConstructAmHdr ARGS ((KwAmHdr *amHdr, - U8 *hdr, - U8 snLen, - U16 *idx)); +static Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr, + uint8_t *hdr, + uint8_t snLen, + uint16_t *idx)); -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, - KwSn mAckSn, +static Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcSn mAckSn, CmLList *retx, KwuDatCfmInfo **datCfm)); -PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer ARGS ((KwCb *gCb, - KwAmDl *amDl, - KwRetx **retx, - KwSn sn)); +static Void rlcAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb, + RlcAmDl *amDl, + RlcRetx **retx, + RlcSn sn)); -PRIVATE Void kwAmmDlCheckIsSDUDelivered ARGS((KwCb *gCb, - KwDlRbCb *rbCb, - KwSduMap *sduMap, +static Void rlcAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcSduMap *sduMap, KwuDatCfmInfo **datCfm)); -PRIVATE Void kwAmmAddPduToRetxLst ARGS((KwAmDl *amDl, - KwRetx *retx)); +static Void rlcAmmAddPduToRetxLst ARGS((RlcAmDl *amDl, + RlcRetx *retx)); -PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS( +static Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS( ( -KwCb *gCb, -KwAmDl *amDl, -KwRetx **retx, -KwDlPduInfo *pduInfo +RlcCb *gCb, +RlcAmDl *amDl, +RlcRetx **retx, +RlcDlPduInfo *pduInfo )); -PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf ARGS( +static Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ARGS( ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwNackInfo *nackSnInfo, -KwRetx **retx, +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcNackInfo *nackSnInfo, +RlcRetx **retx, KwuDatCfmInfo **datCfm )); -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn ARGS( +static Void rlcAmmDlUpdateTxAndReTxBufForNackSn ARGS( ( - KwCb *gCb, - KwDlRbCb *rbCb, - KwNackInfo *nackSnInfo, + RlcCb *gCb, + RlcDlRbCb *rbCb, + RlcNackInfo *nackSnInfo, CmLList **retxNode, KwuDatCfmInfo **datCfm )); -PRIVATE Void KwDlAmmGetNackSnInfoFrmNackRangeIdx ARGS( +static Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ARGS( ( -KwAmDl *amDl, -KwNackInfo *nackInfo, +RlcAmDl *amDl, +RlcNackInfo *nackInfo, CmLList *retxNode, -KwNackInfo *nackSnInfo, -U8 idx +RlcNackInfo *nackSnInfo, +uint8_t idx )); -PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS( +static Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS( ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwSn sn, -KwSn mNackSn, +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcSn sn, +RlcSn mNackSn, CmLList **retxNode, KwuDatCfmInfo **datCfm )); @@ -242,14 +222,14 @@ KwuDatCfmInfo **datCfm AM Module contains the following funcitons: - - kwAmmQSdu - - kwAmmProcessSdus - - kwAmmDlAssembleCntrlInfo - - kwResegRetxPdus - - kwAssembleSdus - - kwAmmDlCheckAndSetPoll - - kwAmmProcessPdus - - kwDlmHndlStaRsp + - rlcAmmQSdu + - rlcAmmProcessSdus + - rlcAmmDlAssembleCntrlInfo + - rlcResegRetxPdus + - rlcAssembleSdus + - rlcAmmDlCheckAndSetPoll + - rlcAmmProcessPdus + - rlcDlmHndlStaRsp - kwTriggerStatus - kwReassembleSdus @@ -271,28 +251,17 @@ KwuDatCfmInfo **datCfm * * @return Void */ -#ifdef ANSI -PUBLIC Void kwAmmSendDStaRsp -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwAmDl *amDl -) -#else -PUBLIC Void kwAmmSendDStaRsp(gCb, rbCb, amDl) -KwCb *gCb; -KwDlRbCb *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; } /** @@ -305,33 +274,21 @@ KwAmDl *amDl; * * @return Void */ -#ifdef ANSI -PRIVATE Void kwAmmDlCheckAndStopPollTmr -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwSn mAckSn -) -#else -PRIVATE Void kwAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn) -KwCb *gCb; -KwDlRbCb *rbCb; -KwSn mAckSn; -#endif +static Void rlcAmmDlCheckAndStopPollTmr(RlcCb *gCb,RlcDlRbCb *rbCb,RlcSn mAckSn) { - 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, EVENT_RLC_AMDL_POLL_RETX_TMR)) { - kwStopTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStopTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR); } } - RETVOID; + return; } /** @@ -342,21 +299,11 @@ KwSn mAckSn; * * @return Void */ -#ifdef ANSI -PRIVATE Void kwAmmDlSetTxNextAck -( -KwAmDl *amDl, -KwSn sn -) -#else -PRIVATE Void kwAmmDlSetTxNextAck(amDl, sn) -KwAmDl *amDl; -KwSn sn -#endif +static Void rlcAmmDlSetTxNextAck(RlcAmDl *amDl,RlcSn sn) { amDl->txNextAck = sn; - RETVOID; + return; } /** @@ -372,27 +319,19 @@ KwSn sn * * @return Void */ -#ifdef ANSI -PRIVATE Void kwAmmDlProcessSuccessfulReTx +static Void rlcAmmDlProcessSuccessfulReTx ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwRetx *retx, -KwuDatCfmInfo **datCfm +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcRetx *retx, +KwuDatCfmInfo **datCfm ) -#else -PRIVATE Void kwAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm) -KwCb *gCb; -KwDlRbCb *rbCb; -KwRetx *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; + return; } /** @@ -401,42 +340,32 @@ KwuDatCfmInfo **datCfm; * @details * This function is used to move the PDU from the txBuf to re-transmit buffer * - * @param[in]KwCb *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]RlcCb *gCb RLC instance control block + * @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]KwDlPduInfo *pduInfo TX PDU which needs to be moved + * @param[in]RlcDlPduInfo *pduInfo TX PDU which needs to be moved * * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer +static Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ( -KwCb *gCb, -KwAmDl *amDl, -KwRetx **retx, -KwDlPduInfo *pduInfo +RlcCb *gCb, +RlcAmDl *amDl, +RlcRetx **retx, +RlcDlPduInfo *pduInfo ) -#else -PRIVATE Void kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo) -KwCb *gCb; -KwAmDl *amDl; -KwRetx **retx; -KwDlPduInfo *pduInfo; -#endif { - TRC2(kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer); - - KW_ALLOC_WC(gCb,*retx, sizeof(KwRetx)); + RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx)); #if (ERRCLASS & ERRCLS_ADD_RES) if (*retx == NULLP) { RLOG0(L_FATAL, "Memory allocation failed"); - RETVOID; + return; } #endif /* ERRCLASS & ERRCLS_RES */ @@ -454,12 +383,12 @@ KwDlPduInfo *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; @@ -467,8 +396,8 @@ KwDlPduInfo *pduInfo; gRlcStats.amRlcStats.numDLRetransPdus++; - RETVOID; -} /*kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer */ + return; +} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */ /** * @brief Function to handle Status of Sdu byte segment for a nackSn @@ -476,10 +405,10 @@ KwDlPduInfo *pduInfo; * @details * This function is used to move the PDU from the txBuf to re-transmit buffer * - * @param[in]KwCb *gCb RLC instance control block - * @param[in]KwDlRbCb *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]RlcCb *gCb RLC instance control block + * @param[in]RlcDlRbCb *rbCb AM Downlink Control Block + * @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 * @@ -487,48 +416,35 @@ KwDlPduInfo *pduInfo; * */ -#ifdef ANSI -PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf +static Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwNackInfo *nackSnInfo, -KwRetx **retx, +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcNackInfo *nackSnInfo, +RlcRetx **retx, KwuDatCfmInfo ** datCfm ) -#else -PRIVATE Void kwAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm) -( -KwCb *gCb; -KwDlRbCb *rbCb; -KwNackInfo *nackSnInfo; -KwRetx **retx; -KwuDatCfmInfo **datCfm; -) -#endif { - KwTx *txBuf=NULLP; + RlcTx *txBuf=NULLP; CmLList *lnk; CmLList *nextLnk; - TRC2(kwAmmDlHndlStatus4SduByteSegInTxBuf) - - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn); + txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, nackSnInfo->sn); if (txBuf == NULLP) { - RETVOID; + return; } lnk = txBuf->pduLst.first; while(lnk) { - KwDlPduInfo *pduInfo = (KwDlPduInfo *)(lnk->node); - KwSn pduSoEnd = (pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1); + RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(lnk->node); + 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); @@ -537,7 +453,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); @@ -550,16 +466,16 @@ KwuDatCfmInfo **datCfm; nextLnk = lnk->next; /* Delete node from the txBuf Pdu lst */ cmLListDelFrm(&txBuf->pduLst, lnk); - KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo)); + RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo)); lnk = nextLnk; } if(!txBuf->pduLst.count) { /*No more Sdu byte segment are left. Hence delete txBuf*/ - kwUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb); + rlcUtlDelTxBuf(RLC_AMDL.txBufLst, txBuf,gCb); } - RETVOID; + return; } /** @@ -568,40 +484,27 @@ KwuDatCfmInfo **datCfm; * @details * This function is used to move the PDU from the txBuf to re-transmit buffer * - * @param[in]KwCb *gCb RLC instance control block - * @param[in]KwDlRbCb *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]RlcCb *gCb RLC instance control block + * @param[in]RlcDlRbCb *rbCb AM Downlink Control Block + * @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 * * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn -( - KwCb *gCb, - KwDlRbCb *rbCb, - KwNackInfo *nackSnInfo, - CmLList **retxNode, - KwuDatCfmInfo **datCfm - ) -#else -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm) +static Void rlcAmmDlUpdateTxAndReTxBufForNackSn ( - KwCb *gCb; - KwDlRbCb *rbCb; - KwNackInfo *nackSnInfo; - CmLList **retxNode; - KwuDatCfmInfo **datCfm; - ) -#endif +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcNackInfo *nackSnInfo, +CmLList **retxNode, +KwuDatCfmInfo **datCfm +) { - KwTx *txBuf; - KwRetx *retx; - - TRC2(kwAmmDlUpdateTxAndReTxBufForNackSn) + RlcTx *txBuf; + RlcRetx *retx; /* Now process the NACK_SN received. Now the NACK_SN is */ /* either the first element of RETX or is in TX array */ @@ -609,7 +512,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(RLC_AMDL.txBufLst, nackSnInfo->sn); if (txBuf != NULLP) { if(nackSnInfo->isSegment) @@ -617,12 +520,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); @@ -635,14 +538,14 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, (*retxNode) = retx->lstEnt.next; } - RETVOID; + return; } /* process the pdus/segments in the re-transmit buffer with this NACK_SN */ while (*retxNode) { - retx = (KwRetx *)((*retxNode)->node); + retx = (RlcRetx *)((*retxNode)->node); if (retx->amHdr.sn != nackSnInfo->sn) { break; @@ -651,7 +554,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, @@ -663,7 +566,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)) { @@ -673,7 +576,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 { @@ -681,7 +584,7 @@ PRIVATE Void kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, break; } } /* end of retxNode while loop*/ - RETVOID; + return; } /** @@ -690,58 +593,45 @@ 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]U8 idx +* @param[in]RlcAmDl *amDl, +* @param[in]RlcUdxStaPdu *StaPdu, +* @param[in]RlcNackInfo *nackSnInfo, +* @param[in]RlcRetx *retx; +* @param[in]RlcSn sn, +* @param[in]uint8_t idx * * @return Void * */ -#ifdef ANSI -PRIVATE Void KwDlAmmGetNackSnInfoFrmNackRangeIdx +static Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ( -KwAmDl *amDl, -KwNackInfo *nackInfo, +RlcAmDl *amDl, +RlcNackInfo *nackInfo, CmLList *retxNode, -KwNackInfo *nackSnInfo, -U8 idx +RlcNackInfo *nackSnInfo, +uint8_t idx ) -#else -PRIVATE Void KwDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx) -( -KwAmDl *amDl; -KwNackInfo *nackInfo; -CmLList *retxNode; -KwNackInfo *nackSnInfo; -U8 idx; -) -#endif { - KwTx *txBuf; - KwRetx *retx; + RlcTx *txBuf; + RlcRetx *retx; CmLList *node; - TRC2(KwDlAmmGetNackSnInfoFrmNackRangeIdx) - nackSnInfo->isSegment = FALSE; if((!nackInfo->isSegment) || (!idx && nackSnInfo->nackRange && (!nackInfo->soStart))) { nackSnInfo->soStart = 0; nackSnInfo->soEnd = 0; - RETVOID; + return; } - txBuf = kwUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn); + txBuf = rlcUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn); if(txBuf != NULLP) { node = txBuf->pduLst.first; while(node) { - KwDlPduInfo *pduInfo = (KwDlPduInfo *)(node->node); - U16 pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1; + RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(node->node); + uint16_t pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1; if((!idx) && (pduInfo->amHdr.so == nackInfo->soStart)) { nackSnInfo->isSegment = TRUE; @@ -764,7 +654,7 @@ U8 idx; { while (retxNode) { - retx = (KwRetx *)(retxNode->node); + retx = (RlcRetx *)(retxNode->node); if(retx->amHdr.sn != nackSnInfo->sn) { break; @@ -813,37 +703,24 @@ U8 idx; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwAmmDlHndlStatusPdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwUdxStaPdu *pStaPdu -) -#else -PUBLIC Void kwAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu) -KwCb *gCb; -KwDlRbCb *rbCb; -KwUdxStaPdu *pStaPdu; -#endif +Void rlcAmmDlHndlStatusPdu(RlcCb *gCb,RlcDlRbCb *rbCb,RlcUdxStaPdu *pStaPdu) { - KwSn mAckSn; + RlcSn mAckSn; S32 oldRetxBo; CmLList *retxNode; KwuDatCfmInfo* datCfm; - KwKwuSapCb *kwuSap; - KwSn mTxNext; + RlcKwuSapCb *rlckwuSap; + RlcSn mTxNext; - TRC2(kwAmmDlHndlStatusPdu) - kwStatusPduCnt++; + 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; + oldRetxBo = RLC_AMDL.retxBo; /* Allocate memory for datCfm Info */ - KW_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) @@ -852,16 +729,16 @@ KwUdxStaPdu *pStaPdu; "Memory allocation failed UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); - KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); - RETVOID; + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); + return; } #endif /* ERRCLASS & ERRCLS_RES */ datCfm->numSduIds = 0; datCfm->rlcId = rbCb->rlcId; - MODAMT(pStaPdu->ackSn, mAckSn, AMDL.txNextAck,AMDL.snModMask); - MODAMT(AMDL.txNext,mTxNext, AMDL.txNextAck,AMDL.snModMask); + MODAMT(pStaPdu->ackSn, mAckSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); + MODAMT(RLC_AMDL.txNext,mTxNext, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); if(mAckSn > mTxNext) { @@ -869,37 +746,37 @@ KwUdxStaPdu *pStaPdu; "Invalid ACK SN = %d received. Current Vta =%d" "UEID:%d CELLID:%d", pStaPdu->ackSn, - AMDL.txNextAck, + RLC_AMDL.txNextAck, rbCb->rlcId.ueId, rbCb->rlcId.cellId); -/* KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */ - KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); - RETVOID; +/* 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)); + return; } /* 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; + retxNode = RLC_AMDL.retxLst.first; /* 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 = RLC_AMDL.txNextAck; /*used to track the SN from which to start processing the transmission buffer */ - U32 idx = 0; + uint32_t idx = 0; /* 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) @@ -909,7 +786,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); @@ -924,10 +801,10 @@ KwUdxStaPdu *pStaPdu; /* move transWinStartSn to nackSnInfo.sn + 1, as the pdu's before that will be removed from the buffer */ transWinStartSn = (nackSnInfo.sn + (nackSnInfo.nackRange ?\ - (nackSnInfo.nackRange - 1) : 0) + 1) & AMDL.snModMask; + (nackSnInfo.nackRange - 1) : 0) + 1) & RLC_AMDL.snModMask; /* Clear the acked SNs from the retx list */ - MODAMT(nackSnInfo.sn, mNackSn, AMDL.txNextAck,AMDL.snModMask); + MODAMT(nackSnInfo.sn, mNackSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); if ((mNackSn > mAckSn) || (mNackSn >= mTxNext)) { @@ -936,32 +813,32 @@ KwUdxStaPdu *pStaPdu; "Status Pdu is not correct UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); - KW_SHRABL_STATIC_BUF_FREE(kwuSap->pst.region, kwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); - RETVOID; + RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); + return; } /* 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 { - U8 idx1 = 0; + uint8_t idx1 = 0; /* Update issegment, soStart, soEnd ,sn in nackSnInfo and handle * nack sn*/ do { - KwDlAmmGetNackSnInfoFrmNackRangeIdx(&AMDL, &pStaPdu->nackInfo[idx], + RlcDlAmmGetNackSnInfoFrmNackRangeIdx(&RLC_AMDL, &pStaPdu->nackInfo[idx], retxNode, &nackSnInfo, idx1); - kwAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, + rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, &nackSnInfo, &retxNode, &datCfm); - nackSnInfo.sn = ((nackSnInfo.sn + 1) & (AMDL.snModMask)); + nackSnInfo.sn = ((nackSnInfo.sn + 1) & (RLC_AMDL.snModMask)); gRlcStats.amRlcStats.numRlcAmCellNackRx++; }while((++idx1) < (nackSnInfo.nackRange)); @@ -972,25 +849,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(&RLC_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(&RLC_AMDL, pStaPdu->ackSn); } if(datCfm->numSduIds != 0) @@ -1006,25 +883,25 @@ 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 { - KW_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); - /* BO update, if retransmission BO has changed. AMDL.retxBo would have + RLC_LLIST_FIRST_RETX(RLC_AMDL.retxLst, RLC_AMDL.nxtRetx); + /* BO update, if retransmission BO has changed. RLC_AMDL.retxBo would have canged inside the above called functions */ - if (oldRetxBo != AMDL.retxBo) + if (oldRetxBo != RLC_AMDL.retxBo) { - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); + rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL); } - RETVOID; + return; } /** @@ -1041,15 +918,7 @@ KwUdxStaPdu *pStaPdu; * @return S16 * Calculated bo */ -#ifdef ANSI -PUBLIC S32 kwAmmCalculateBo -( -KwAmDl *amDl -) -#else -PUBLIC S32 kwAmmCalculateBo(amDl) -KwAmDl *amDl; -#endif +S32 rlcAmmCalculateBo(RlcAmDl *amDl) { S32 bo; @@ -1072,14 +941,14 @@ 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; } return bo; } -U32 kwRxSdu; +uint32_t kwRxSdu; /** * @brief Handler to queue the SDUs received from PDCP @@ -1089,7 +958,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 @@ -1101,54 +970,37 @@ U32 kwRxSdu; * @param[in] datReq Ptr to the datReq sent from PDCP * * @return Void - * -# RETVOID + * -# void */ -#ifdef ANSI -PUBLIC Void kwAmmQSdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -Buffer *mBuf, -KwuDatReqInfo *datReq -) -#else -PUBLIC Void kwAmmQSdu(gCb, rbCb, mBuf, datReq) -KwCb *gCb; -KwDlRbCb *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 */ - KW_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; @@ -1159,53 +1011,50 @@ KwuDatReqInfo *datReq; #ifndef RGL_SPECIFIC_CHANGES #ifdef MSPD { -extern U32 dlrate_kwu; +uint32_t dlrate_kwu; dlrate_kwu += sdu->sduSz; } #endif #endif /* Update nxtTx to point to the added sdu if this is the first SDU in the * queue */ - if (AMDL.nxtTx == NULLP) + if (RLC_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); - AMDL.nxtTx = sdu; + DU_LOG("\nRLC : rlcAmmQSdu: Received SDU will be transmitted next \ + UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); + RLC_AMDL.nxtTx = sdu; } /* Add sdu to the sdu list */ - cmLListAdd2Tail(&AMDL.sduQ, &sdu->lstEnt); + cmLListAdd2Tail(&RLC_AMDL.sduQ, &sdu->lstEnt); sdu->lstEnt.node = (PTR)sdu; #ifdef LTE_L2_MEAS #ifndef L2_L3_SPLIT #ifdef TENB_STATS if (rbCb->ueCb->tenbStats) { - if (AMDL.sduQ.count > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxPktsInSduQ) + if (RLC_AMDL.sduQ.count > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxPktsInSduQ) { - rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxPktsInSduQ = AMDL.sduQ.count; + rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxPktsInSduQ = RLC_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(&RLC_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 #endif #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) + RLC_AMDL.bo = RLC_AMDL.bo + sdu->sduSz; + if(RLC_AMDL.snLen == RLC_AM_CFG_12BIT_SN_LEN) { - AMDL.estHdrSz += 2; + RLC_AMDL.estHdrSz += 2; } else { - AMDL.estHdrSz += 3; + RLC_AMDL.estHdrSz += 3; } #ifdef LTE_L2_MEAS_RLC /* Update numActUe if it is not active */ @@ -1213,16 +1062,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(!kwDlUtlIsReestInProgress(rbCb)) + if(!rlcDlUtlIsReestInProgress(rbCb)) { - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); + rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL); } - RETVOID; + return; } /** @@ -1241,59 +1090,45 @@ dlrate_kwu += sdu->sduSz; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlAssembleCntrlInfo -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwAmmDlAssembleCntrlInfo(gCb, rbCb, kwDatReq) -KwCb *gCb; -KwDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +static 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); - KwDlUdxStaProhTmrStart(&(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] = RLC_AMDL.mBuf; + rlcDatReq->pduInfo.numPdu++; gRlcStats.amRlcStats.numDLStaPduSent++; - KW_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region, + RLC_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region, gCb->u.dlCb->udxDlSap->pst.pool, - AMDL.pStaPdu, - sizeof(KwUdxDlStaPdu)); + RLC_AMDL.pStaPdu, + sizeof(RlcUdxDlStaPdu)); - AMDL.pStaPdu = NULLP; - AMDL.mBuf = NULLP; + RLC_AMDL.pStaPdu = NULLP; + RLC_AMDL.mBuf = NULLP; gRlcStats.amRlcStats.numDLStaPduSent++; } - RETVOID; + return; } /** @@ -1306,12 +1141,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 * @@ -1323,85 +1158,66 @@ KwDatReq *kwDatReq; * @return Void * */ -#ifdef ANSI -PUBLIC Void kwAmmProcessSdus -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwDatReq *kwDatReq, -Bool fillCtrlPdu -) -#else -PUBLIC Void kwAmmProcessSdus(gCb, rbCb, kwDatReq,fillCtrlPdu) -KwCb *gCb; -KwDlRbCb *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 * it is FALSE */ - if ((AMDL.cntrlBo != 0) + if ((RLC_AMDL.cntrlBo != 0) #ifdef LTE_ADV && (fillCtrlPdu) #endif ) { - kwDatReq->boRep.staPduPrsnt = TRUE; - kwDatReq->boRep.staPduBo = AMDL.cntrlBo; + rlcDatReq->boRep.staPduPrsnt = TRUE; + rlcDatReq->boRep.staPduBo = RLC_AMDL.cntrlBo; - if (AMDL.pStaPdu != NULLP) + if (RLC_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; + RLC_AMDL.cntrlBo = 0; } /* Retransmit PDUs /portions of PDUs available in retxLst */ - if ((kwDatReq->pduSz > 0) && (AMDL.nxtRetx != NULLP)) + if ((rlcDatReq->pduSz > 0) && (RLC_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) && (RLC_AMDL.nxtTx != 0)) { - kwAssembleSdus(gCb,rbCb, kwDatReq); + rlcAssembleSdus(gCb,rbCb, rlcDatReq); } - if (AMDL.nxtRetx != NULLP) + if (RLC_AMDL.nxtRetx != NULLP) { - kwDatReq->boRep.oldestSduArrTime = AMDL.nxtRetx->sduMap.sdu->arrTime; + rlcDatReq->boRep.oldestSduArrTime = RLC_AMDL.nxtRetx->sduMap.sdu->arrTime; } - else if (AMDL.nxtTx != NULLP) + else if (RLC_AMDL.nxtTx != NULLP) { - kwDatReq->boRep.oldestSduArrTime = AMDL.nxtTx->arrTime; + rlcDatReq->boRep.oldestSduArrTime = RLC_AMDL.nxtTx->arrTime; } /* Accumulate bo */ - kwDatReq->boRep.bo = kwAmmCalculateBo(&AMDL); - kwDatReq->boRep.staPduBo = AMDL.cntrlBo; + rlcDatReq->boRep.bo = rlcAmmCalculateBo(&RLC_AMDL); + rlcDatReq->boRep.staPduBo = RLC_AMDL.cntrlBo; /* Hdr estimation is moved to kwAmmCreatePDu */ - kwDatReq->boRep.estHdrSz = AMDL.estHdrSz; + rlcDatReq->boRep.estHdrSz = RLC_AMDL.estHdrSz; - if(kwDatReq->pduSz > 0) + if(rlcDatReq->pduSz > 0) { - gRlcStats.amRlcStats.numDLBytesUnused += kwDatReq->pduSz; + gRlcStats.amRlcStats.numDLBytesUnused += rlcDatReq->pduSz; } - RETVOID; + return; } /** @@ -1422,35 +1238,18 @@ Bool fillCtrlPdu; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwSplitPdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwRetx *crnt, -KwRetx *next, -U16 size -) -#else -PRIVATE Void kwSplitPdu(gCb, rbCb, crnt, next, size) -KwCb *gCb; -KwDlRbCb *rbCb; -KwRetx *crnt; -KwRetx *next; -U16 size; -#endif +static void rlcSplitPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcRetx *crnt, RlcRetx *next, uint16_t size) { - U8 si; - KwAmDl *amDl = &AMDL; + uint8_t si; + RlcAmDl *amDl = &RLC_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; @@ -1479,44 +1278,44 @@ 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; } } /* Add the next to the retx list */ - AMDL.retxLst.crnt = &crnt->lstEnt; - CM_LLIST_INS_AFT_CRNT(AMDL.retxLst, next); - AMDL.nxtRetx = next; + RLC_AMDL.retxLst.crnt = &crnt->lstEnt; + CM_LLIST_INS_AFT_CRNT(RLC_AMDL.retxLst, next); + RLC_AMDL.nxtRetx = next; amDl->estHdrSz += next->hdrSz; - RETVOID; + return; } /** @@ -1531,7 +1330,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 @@ -1544,112 +1343,94 @@ U16 size; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwResegRetxPdus -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwResegRetxPdus(gCb, rbCb, kwDatReq) -KwCb *gCb; -KwDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +static 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; + amDl = &RLC_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; - AMDL.estHdrSz -= retx->hdrSz; + rlcDatReq->pduSz -= pduSz; + RLC_AMDL.estHdrSz -= retx->hdrSz; #ifdef LTE_L2_MEAS if (rbCb->rlcId.rbType == CM_LTE_DRB) { 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; @@ -1661,54 +1442,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 */ - KW_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 */ @@ -1717,17 +1494,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 = @@ -1741,23 +1518,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++; @@ -1766,22 +1543,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; } @@ -1795,7 +1564,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 * @@ -1805,60 +1574,45 @@ KwDatReq *kwDatReq; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAssembleSdus -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwAssembleSdus (gCb, rbCb, kwDatReq) -KwCb *gCb; -KwDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +static 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 = &RLC_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; - KwDlPduInfo *pduInfo = NULLP; - - TRC2(kwAssembleSdus) - + volatile uint32_t startTime = 0; + uint32_t hdrEstmt; + uint32_t fixedHdrSz; + uint32_t pduSz; + RlcAmHdr *amHdr = NULLP; + RlcDlPduInfo *pduInfo = NULLP; #ifdef LTE_L2_MEAS contSduLst.numSdus = 0; @@ -1869,41 +1623,39 @@ KwDatReq *kwDatReq; #endif /* Discard new changes starts */ /* Allocate memory for discSdu Info */ - KW_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; @@ -1913,14 +1665,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 */ @@ -1932,11 +1684,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; } @@ -1945,20 +1694,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; } } @@ -1970,7 +1719,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"); @@ -1989,8 +1738,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. @@ -2005,41 +1754,37 @@ KwDatReq *kwDatReq; if (!sdu->mode.am.isSegmented) { /* Update txBuf */ - KW_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); } - KW_ALLOC_WC(gCb,pduInfo, sizeof(KwDlPduInfo)); + 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 */ @@ -2065,7 +1810,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; @@ -2080,18 +1825,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) { @@ -2099,15 +1844,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++; @@ -2125,27 +1870,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 */ @@ -2158,7 +1903,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; @@ -2168,7 +1913,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", @@ -2177,7 +1922,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; @@ -2188,14 +1933,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; @@ -2208,39 +1953,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) { @@ -2248,7 +1993,7 @@ KwDatReq *kwDatReq; break; } } - if (lchIdx < KW_MAX_ACTV_DRB) + if (lchIdx < RLC_MAX_ACTV_DRB) { if (lchIdx == l2MeasTb->numLchInfo) { @@ -2258,7 +2003,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; @@ -2280,29 +2025,16 @@ KwDatReq *kwDatReq; if(discSduInfo->numSduIds != 0) { /* Sap control block */ - KwUiKwuDiscSduCfm(&kwuSap->pst, kwuSap->suId, discSduInfo); + RlcUiKwuDiscSduCfm(&rlckwuSap->pst, rlckwuSap->suId, discSduInfo); } else { - KW_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 - - RETVOID; + DU_LOG("\nRLC: rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d", + amDl->bo, rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } /** @@ -2328,28 +2060,11 @@ KwDatReq *kwDatReq; * -# 0 - Poll bit is not set * */ -#ifdef ANSI -PRIVATE Bool kwAmmDlCheckAndSetPoll -( -KwCb *gCb, -KwDlRbCb *rbCb, -Bool newPdu, -MsgLen bufSz -) -#else -PRIVATE Bool kwAmmDlCheckAndSetPoll(gCb, rbCb, newPdu, bufSz) -KwCb *gCb; -KwDlRbCb *rbCb; -Bool newPdu; -MsgLen bufSz; -#endif +static 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) @@ -2367,7 +2082,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; } @@ -2379,26 +2094,23 @@ 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,EVENT_RLC_AMDL_POLL_RETX_TMR) ) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR); } - kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR); } - RETVALUE(pollBit); + return (pollBit); } /** @@ -2411,44 +2123,26 @@ MsgLen bufSz; * @param[in] gCB RLC instance control block * @param[in] rbCb Downlink RB control block * @param[in] amHdr AM header - * @param[in] KwDlPduInfo Pointer to PduInfo + * @param[in] RlcDlPduInfo Pointer to PduInfo * @param[in] pdu PDU buffer * * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmCreatePdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwAmHdr *amHdr, -KwDlPduInfo *pduInfo, -Buffer *pdu -) -#else -PRIVATE Void kwAmmCreatePdu(gCb, rbCb, pduInfo, amHdr, pdu) -KwCb *gCb; -KwDlRbCb *rbCb; -KwAmHdr *amHdr; -KwDlPduInfo *pduInfo; -Buffer *pdu; -#endif +static 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); @@ -2456,19 +2150,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; @@ -2477,7 +2171,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); @@ -2485,7 +2179,7 @@ Buffer *pdu; gCb->genSts.bytesSent += pduSz; - RETVOID; + return; } /** @@ -2503,39 +2197,25 @@ Buffer *pdu; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwRemRetxPdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwRetx *retx -) -#else -PRIVATE Void kwRemRetxPdu(gCb, rbCb, retx) -KwCb *gCb; -KwDlRbCb *rbCb; -KwRetx *retx; -#endif +static Void rlcRemRetxPdu(RlcCb *gCb,RlcDlRbCb *rbCb,RlcRetx *retx) { - TRC2(kwRemRetxPdu) - - cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt); + cmLListDelFrm(&RLC_AMDL.retxLst, &retx->lstEnt); - if( AMDL.retxLst.count == 0) + if( RLC_AMDL.retxLst.count == 0) { - AMDL.nxtRetx = NULLP; + RLC_AMDL.nxtRetx = NULLP; } if(retx->pendingReTrans == TRUE) { - AMDL.retxBo -= retx->segSz; - AMDL.estHdrSz -= retx->hdrSz; + RLC_AMDL.retxBo -= retx->segSz; + RLC_AMDL.estHdrSz -= retx->hdrSz; } - kwUtlAddReTxPduToBeFreedQueue(gCb, retx); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlAddReTxPduToBeFreedQueue(gCb, retx); + rlcUtlRaiseDlCleanupEvent(gCb); - RETVOID; + return; } /** @@ -2554,24 +2234,11 @@ KwRetx *retx; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlMarkPduForReTx -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwRetx *retx -) -#else -PRIVATE Void kwAmmDlMarkPduForReTx(*gCb, rbCb, retx) -KwCb *gCb; -KwDlRbCb *rbCb; -KwRetx *retx; -#endif +static Void rlcAmmDlMarkPduForReTx(RlcCb *gCb,RlcDlRbCb *rbCb,RlcRetx *retx) { - TRC2(kwAmmDlMarkPduForReTx) - if (AMDL.maxReTxReached == TRUE) + if (RLC_AMDL.maxReTxReached == TRUE) { - RETVOID; + return; } if(retx->pendingReTrans == FALSE) @@ -2579,10 +2246,10 @@ KwRetx *retx; retx->pendingReTrans = TRUE; ++retx->retxCnt; - AMDL.retxBo += retx->segSz; - AMDL.estHdrSz += retx->hdrSz; + RLC_AMDL.retxBo += retx->segSz; + RLC_AMDL.estHdrSz += retx->hdrSz; - if (retx->retxCnt > AMDL.maxRetx) + if (retx->retxCnt > RLC_AMDL.maxRetx) { /* RLC_DL_MAX_RETX fix */ /* Marking the RB stalled for DL scheduling. This is to avoid unnecessary */ @@ -2595,27 +2262,27 @@ 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; + return; } - if (AMDL.nxtRetx == NULLP) + if (RLC_AMDL.nxtRetx == NULLP) { - AMDL.nxtRetx = retx; + RLC_AMDL.nxtRetx = retx; } gRlcStats.amRlcStats.numDLRetransPdus++; } - RETVOID; + return; } /** @@ -2634,25 +2301,15 @@ KwRetx *retx; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlCheckIsSDUDelivered +static Void rlcAmmDlCheckIsSDUDelivered ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwSduMap *sduMap, -KwuDatCfmInfo **datCfm +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcSduMap *sduMap, +KwuDatCfmInfo **datCfm ) -#else -PRIVATE Void kwAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm) -KwCb *gCb; -KwDlRbCb *rbCb; -KwSduMap *sduMap; -KwuDatCfmInfo **datCfm; -#endif { - KwSdu *sdu; - - TRC2(kwAmmDlCheckIsSDUDelivered) + RlcSdu *sdu; sdu = sduMap->sdu; @@ -2673,11 +2330,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); - KW_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) @@ -2686,7 +2343,7 @@ KwuDatCfmInfo **datCfm; "Memory allocation failed UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); - RETVOID; + return; } #endif /* ERRCLASS & ERRCLS_RES */ @@ -2698,12 +2355,12 @@ KwuDatCfmInfo **datCfm; } /* Remove SDU from the sduQ */ - cmLListDelFrm(&AMDL.sduQ, &sdu->lstEnt); - kwUtlAddSduToBeFreedQueue(gCb, sdu); - kwUtlRaiseDlCleanupEvent(gCb); + cmLListDelFrm(&RLC_AMDL.sduQ, &sdu->lstEnt); + rlcUtlAddSduToBeFreedQueue(gCb, sdu); + rlcUtlRaiseDlCleanupEvent(gCb); } - RETVOID; + return; } /** @@ -2721,48 +2378,39 @@ KwuDatCfmInfo **datCfm; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlProcessSuccessfulTxPdu +static Void rlcAmmDlProcessSuccessfulTxPdu ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwSn sn, -KwuDatCfmInfo **datCfm +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcSn sn, +KwuDatCfmInfo **datCfm ) -#else -PRIVATE Void kwAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm) -KwCb *gCb; -KwDlRbCb *rbCb; -KwSn sn; -KwuDatCfmInfo **datCfm; -#endif { - TRC2(kwAmmDlProcessSuccessfulTxPdu) CmLList *pduNode; - KwTx *txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn); + RlcTx *txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn); if (txBuf == NULLP) { - RETVOID; + return; } pduNode = txBuf->pduLst.first; while(pduNode) { - KwDlPduInfo *pduInfo = (KwDlPduInfo *)(pduNode->node); - kwAmmDlCheckIsSDUDelivered(gCb, + RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pduNode->node); + 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(RLC_AMDL.txBufLst, txBuf, gCb); - RETVOID; + return; } /** @@ -2779,31 +2427,21 @@ KwuDatCfmInfo **datCfm; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmSndStaInd +static Void rlcAmmSndStaInd ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwRetx *retx +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcRetx *retx ) -#else -PRIVATE Void kwAmmSndStaInd(gCb, rbCb, retx) -KwCb *gCb; -KwDlRbCb *rbCb; -KwRetx *retx; -#endif { KwuStaIndInfo *staInd; - KwKwuSapCb *kwuSap; - - TRC2(kwAmmSndStaInd); - + RlcKwuSapCb *rlckwuSap; /* Sap control block */ - kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP; + rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP; /* Allocate memory for staInd Info */ - KW_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) @@ -2812,22 +2450,22 @@ KwRetx *retx; "Memory allocation failed UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); - RETVOID; + return; } #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; + return; } /** @@ -2844,22 +2482,10 @@ KwRetx *retx; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwGetNxtRetx -( -KwCb *gCb, -KwRetx **retx -) -#else -PRIVATE Void kwGetNxtRetx(gCb, retx) -KwCb *gCb; -KwRetx **retx; -#endif +static void rlcGetNxtRetx(RlcCb *gCb, RlcRetx **retx) { CmLList *tNode; - TRC2(kwGetNxtRetx); - do { tNode = &((*retx)->lstEnt); @@ -2867,16 +2493,16 @@ KwRetx **retx; if (tNode) { - *retx = (KwRetx *)tNode->node; + *retx = (RlcRetx *)tNode->node; } else { *retx = NULLP; - RETVOID; + return; } }while((*retx)->pendingReTrans == FALSE); - RETVOID; + return; } /** @@ -2891,35 +2517,28 @@ KwRetx **retx; * @return Void * */ -#ifdef ANSI -PUBLIC Void kwAmmDlReEstablish +Void rlcAmmDlReEstablish ( -KwCb *gCb, +RlcCb *gCb, CmLteRlcId rlcId, -KwDlRbCb *rbCb +RlcDlRbCb *rbCb ) -#else -PUBLIC Void kwAmmDlReEstablish(gCb, rlcId, rbCb) -KwCb *gCb; -CmLteRlcId rlcId; -KwDlRbCb *rbCb; -#endif { /* create a new AM DL RB, reset it and replace in the UeCb*/ - KwDlUeCb *ueCb; - KwDlRbCb *resetRb; - KwAmDl* newAmDl; - KwAmDl* oldAmDl; - KW_ALLOC(gCb, resetRb, sizeof(KwDlRbCb)); + RlcDlUeCb *ueCb; + RlcDlRbCb *resetRb; + RlcAmDl* newAmDl; + RlcAmDl* oldAmDl; + RLC_ALLOC(gCb, resetRb, sizeof(RlcDlRbCb)); /* ccpu00135170 Removing KLOCK warning */ if(resetRb == NULLP) { - RETVOID; + return; } - KW_MEM_CPY(resetRb, rbCb, sizeof(KwDlRbCb)); - KW_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 */ @@ -2932,18 +2551,18 @@ KwDlRbCb *rbCb; newAmDl->snLen = oldAmDl->snLen; newAmDl->snModMask = oldAmDl->snModMask; newAmDl->pollRetxTmrInt = oldAmDl->pollRetxTmrInt; - rbCb->boUnRprtdCnt = (U32)0; - rbCb->lastRprtdBoToMac = (U32)0; + rbCb->boUnRprtdCnt = (uint32_t)0; + rbCb->lastRprtdBoToMac = (uint32_t)0; 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", rlcId.ueId, rlcId.rbId); - RETVOID; + return; } if(rlcId.rbType == CM_LTE_SRB) @@ -2961,26 +2580,26 @@ KwDlRbCb *rbCb; &&(resetRb->rlcId.rbId == 1)) { /* To stop the traffic on SRB2 and other DRBs*/ - kwDlUtlSetReestInProgressForAllRBs(gCb, ueCb); + rlcDlUtlSetReestInProgressForAllRBs(gCb, ueCb); } else { - kwDlUtlSetReestInProgressForRB(gCb, resetRb); + rlcDlUtlSetReestInProgressForRB(gCb, resetRb); } /* allocate the TX array again */ #ifndef LTE_TDD - U32 hashIndex; - KW_ALLOC(gCb, + uint32_t 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 @@ -2988,14 +2607,14 @@ KwDlRbCb *rbCb; There should be a proper intreface to resume the RBs */ if(rlcId.rbType == CM_LTE_SRB) { - kwDlUtlResetReestInProgress(ueCb->srbCb[rlcId.rbId]); + rlcDlUtlResetReestInProgress(ueCb->srbCb[rlcId.rbId]); } else { - kwDlUtlResetReestInProgress(ueCb->drbCb[rlcId.rbId]); + rlcDlUtlResetReestInProgress(ueCb->drbCb[rlcId.rbId]); } - RETVOID; + return; } /** @@ -3014,22 +2633,9 @@ KwDlRbCb *rbCb; * -# ROK In case of successful discard * -# RFAILED In case the SDU is not found or already mapped */ -#ifdef ANSI -PUBLIC S16 kwAmmDiscSdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -U32 sduId -) -#else -PUBLIC S16 kwAmmDiscSdu(gCb, rbCb, sduId) -KwCb *gCb; -KwDlRbCb *rbCb; -U32 sduId; -#endif +S16 rlcAmmDiscSdu(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t sduId ) { - TRC2(kwAmmDiscSdu); - RETVALUE(RFAILED); + return (RFAILED); } /** @@ -3044,25 +2650,13 @@ U32 sduId; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwAmmPollRetxTmrExp -( -KwCb *gCb, -KwDlRbCb *rbCb -) -#else -PUBLIC Void kwAmmPollRetxTmrExp(gCb, rbCb) -KwCb *gCb; -KwDlRbCb *rbCb; -#endif +Void rlcAmmPollRetxTmrExp(RlcCb *gCb,RlcDlRbCb *rbCb) { - KwRetx *retx; - KwAmDl *amDl = &(rbCb->m.amDl); - KwSn sn; - KwTx *txBuf; - TRC2(kwAmmPollRetxTmrExp); + RlcRetx *retx; + RlcAmDl *amDl = &(rbCb->m.amDl); + RlcSn sn; + RlcTx *txBuf; - /* kw003.201 - Correcting the logic for determmining whether to do */ /* any transmission of PDU. As per the spec section */ /* 5.2.2.3, if there is any to transmit or retransmit, */ @@ -3080,35 +2674,35 @@ KwDlRbCb *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) + if (RLC_AMDL.nxtRetx == NULLP) { - AMDL.nxtRetx = retx; + RLC_AMDL.nxtRetx = retx; } - kwAmmSendDStaRsp(gCb, rbCb, &AMDL); - RETVOID; + rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL); + return; } /* 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, &RLC_AMDL); } } - RETVOID; + return; } /** @@ -3129,40 +2723,29 @@ KwDlRbCb *rbCb; * */ -#ifdef ANSI -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn +static Void rlcAmmDlUpdateTxAndReTxBufForAckSn ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwSn mAckSn, +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcSn mAckSn, CmLList *retxNode, KwuDatCfmInfo **datCfm ) -#else -PRIVATE Void kwAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm) -KwCb *gCb; -KwDlRbCb *rbCb; -KwSn mAckSn; -CmLList *retxNode; -KwuDatCfmInfo **datCfm; -#endif { - KwSn mSn; - KwSn sn; - KwRetx *retx; - KwTx *txBuf; - - TRC2(kwAmmDlUpdateTxAndReTxBufForAckSn); + RlcSn mSn; + RlcSn sn; + RlcRetx *retx; + RlcTx *txBuf; /* 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); + MODAMT(retx->amHdr.sn, mSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); if (mSn < mAckSn) { - kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); + rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); } } @@ -3170,28 +2753,28 @@ KwuDatCfmInfo **datCfm; acknowledged by the ACK_SN*/ /* start from the starting of the transmission window and remove till just before ACK_SN*/ - mSn = 0; /* same as MODAMT(AMDL.txNextAck, mSn, AMDL.txNextAck);*/ - sn = AMDL.txNextAck; + mSn = 0; /* same as MODAMT(RLC_AMDL.txNextAck, mSn, RLC_AMDL.txNextAck);*/ + sn = RLC_AMDL.txNextAck; while(mSn < mAckSn) { - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn); + txBuf = rlcUtlGetTxBuf(RLC_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; - MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask); + sn = (sn + 1) & RLC_AMDL.snModMask; + MODAMT(sn, mSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); } - RETVOID; + return; } /** @@ -3211,40 +2794,28 @@ KwuDatCfmInfo **datCfm; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn +static Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ( -KwCb *gCb, -KwDlRbCb *rbCb, -KwSn sn, -KwSn mNackSn, +RlcCb *gCb, +RlcDlRbCb *rbCb, +RlcSn sn, +RlcSn mNackSn, CmLList **retxNode, KwuDatCfmInfo **datCfm ) -#else -PRIVATE Void kwAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm) -KwCb *gCb; -KwDlRbCb *rbCb; -KwSn sn; -KwSn mNackSn; -CmLList **retxNode; -KwuDatCfmInfo **datCfm; -#endif { - KwSn mSn; - KwRetx *retx; - KwTx *txBuf=NULLP; - - TRC2(kwAmmDlUpdTxAndReTxBufForLessThanNackSn); + RlcSn mSn; + RlcRetx *retx; + RlcTx *txBuf=NULLP; while (*retxNode) { - retx = (KwRetx *)((*retxNode)->node); - MODAMT(retx->amHdr.sn, mSn, AMDL.txNextAck,AMDL.snModMask); + retx = (RlcRetx *)((*retxNode)->node); + MODAMT(retx->amHdr.sn, mSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); if (mSn < mNackSn) { (*retxNode) = (*retxNode)->next; - kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); + rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm); } else { @@ -3253,29 +2824,29 @@ KwuDatCfmInfo **datCfm; } /* Remove all pdus with SN < NACK_SN from the transmission buffer */ - MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask); + MODAMT(sn, mSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); while (mSn < mNackSn) { /* this if check seems redundant,why should mSn ever be mTxSn (which actually is VT(A) */ - txBuf = kwUtlGetTxBuf(AMDL.txBufLst, sn); + txBuf = rlcUtlGetTxBuf(RLC_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; - MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask); + sn = (sn + 1) & RLC_AMDL.snModMask; + MODAMT(sn, mSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask); } - RETVOID; + return; } @@ -3295,53 +2866,37 @@ 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 +static 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); + hdr[0] = hdr[0] | (uint8_t)((amHdr->sn & 0xF00) >> 8); + hdr[1] = (uint8_t)(amHdr->sn & 0x0FF); (*idx)++; } else { - hdr[0] = hdr[0] | (U8)((amHdr->sn & 0x30000) >> 16); - hdr[1] = (U8)((amHdr->sn & 0xFF00) >> 8); + hdr[0] = hdr[0] | (uint8_t)((amHdr->sn & 0x30000) >> 16); + hdr[1] = (uint8_t)((amHdr->sn & 0xFF00) >> 8); (*idx)++; - hdr[2] = (U8)(amHdr->sn & 0xFF); + hdr[2] = (uint8_t)(amHdr->sn & 0xFF); (*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); + hdr[(*idx)] = (uint8_t)((amHdr->so & 0xFF00)>> 8); (*idx)++; - hdr[(*idx)] = (U8)(amHdr->so & 0xFF); + hdr[(*idx)] = (uint8_t)(amHdr->so & 0xFF); } - RETVOID; + return; } /** @@ -3358,30 +2913,18 @@ U16 *idx; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmAddPduToRetxLst -( -KwAmDl *amDl, -KwRetx *retx -) -#else -PRIVATE Void kwAmmAddPduToRetxLst(amDl, retx) -KwAmDl *amDl; -KwRetx *retx; -#endif +static Void rlcAmmAddPduToRetxLst(RlcAmDl *amDl,RlcRetx *retx) { CmLList *node; - KwRetx *tRetx; - KwSn tMSn; - KwSn retxMSn; + RlcRetx *tRetx; + RlcSn tMSn; + RlcSn retxMSn; - TRC2(kwAmmAddPduToRetxLst); - 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,7 +2953,7 @@ KwRetx *retx; amDl->nxtRetx = retx; } - RETVOID; + return; } /** @@ -3429,56 +2972,47 @@ KwRetx *retx; * */ -#ifdef ANSI -PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer +static Void rlcAmmDlMoveFrmTxtoRetxBuffer ( -KwCb *gCb, -KwAmDl *amDl, -KwRetx **retx, -KwSn sn +RlcCb *gCb, +RlcAmDl *amDl, +RlcRetx **retx, +RlcSn sn ) -#else -PRIVATE Void kwAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn) -KwCb *gCb; -KwAmDl *amDl; -KwRetx **retx; -KwSn sn; -#endif { - KwTx* txBuf = kwUtlGetTxBuf(amDl->txBufLst, sn); - TRC2(kwAmmDlMoveFrmTxtoRetxBuffer); + RlcTx* txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn); if (txBuf == NULLP) { - RETVOID; + return; } while(txBuf->pduLst.first) { - KwDlPduInfo *pduInfo = (KwDlPduInfo *)(txBuf->pduLst.first->node); - KW_ALLOC_WC(gCb,*retx, sizeof(KwRetx)); + RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node); + RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx)); #if (ERRCLASS & ERRCLS_ADD_RES) if (*retx == NULLP) { RLOG0(L_FATAL, "Memory allocation failed"); - RETVOID; + return; } #endif /* ERRCLASS & ERRCLS_RES */ /* Move Sdu byte segment from TX buf to retx buf*/ - kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, + rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo); /* Delete node from the txBuf Pdu lst */ cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first); - KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo)); + RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo)); } /* Remove PDU from txBuf */ - kwUtlDelTxBuf(amDl->txBufLst, txBuf,gCb); + rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb); - RETVOID; + return; } @@ -3496,22 +3030,12 @@ KwSn sn; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwAmmFreeDlRbCb -( -KwCb *gCb, -KwDlRbCb *rbCb -) -#else -PUBLIC Void kwAmmFreeDlRbCb(gCb,rbCb) -KwCb *gCb; -KwDlRbCb *rbCb; -#endif +Void rlcAmmFreeDlRbCb(RlcCb *gCb,RlcDlRbCb *rbCb) { /* stop the re-transmission timer */ - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMDL_POLL_RETX_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMDL_POLL_RETX_TMR)) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR); + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR); } /* store the entire Rb pointer */ @@ -3521,9 +3045,9 @@ KwDlRbCb *rbCb; /* the sdu queue */ cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.amDl.sduQ)); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlRaiseDlCleanupEvent(gCb); - RETVOID; + return; } /** @@ -3534,41 +3058,26 @@ KwDlRbCb *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 -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwDatReq *kwDatReq -) -#else -PRIVATE Void kwAmmCreateStatusPdu(gCb, rbCb, kwDatReq) -KwCb *gCb; -KwDlRbCb *rbCb; -KwDatReq *kwDatReq; -#endif +static 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; + 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; - TRC2(kwAmmCreateStatusPdu) - - - pStaPdu = AMDL.pStaPdu; + pStaPdu = RLC_AMDL.pStaPdu; /* D/C| CPT| */ @@ -3583,7 +3092,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 */ @@ -3601,24 +3110,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 */ @@ -3634,7 +3143,7 @@ KwDatReq *kwDatReq; /* Next Octet */ cntrlPdu[encIdx + 1] = (sn & 0xF) << 4; - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { /*Set E2 Bit */ cntrlPdu[encIdx + 1] |= 0x4; @@ -3642,25 +3151,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; } } @@ -3669,7 +3178,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) @@ -3688,19 +3197,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; + cntrlPdu[1] = (uint8_t)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) @@ -3717,24 +3222,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 */ @@ -3745,15 +3250,15 @@ KwDatReq *kwDatReq; } /* 18 BIT Nack SN encode */ - cntrlPdu[encIdx] = (U8)((sn & 0x3FC00) >> 10); + cntrlPdu[encIdx] = (uint8_t)((sn & 0x3FC00) >> 10); /* Next Octet */ - cntrlPdu[encIdx + 1] = (U8)((sn & 0x3FC) >> 2); + cntrlPdu[encIdx + 1] = (uint8_t)((sn & 0x3FC) >> 2); /* Next Octet */ - cntrlPdu[encIdx + 2] = (U8)((sn & 0x3)<< 6); + cntrlPdu[encIdx + 2] = (uint8_t)((sn & 0x3)<< 6); - if (kwNackInfo->isSegment) + if (rlcNackInfo->isSegment) { /* NACKSN E1 E2 E3 R R R */ /*Set E2 Bit */ @@ -3762,27 +3267,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] = (uint8_t)rlcNackInfo->soStart; /* SOend */ - cntrlPdu[encIdx + 5] = (kwNackInfo->soEnd) >> 8; - cntrlPdu[encIdx + 6] = (U8)(kwNackInfo->soEnd); + cntrlPdu[encIdx + 5] = (rlcNackInfo->soEnd) >> 8; + cntrlPdu[encIdx + 6] = (uint8_t)(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; } } @@ -3791,7 +3296,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) @@ -3810,13 +3315,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; @@ -3827,63 +3327,47 @@ 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; - /* Add mBuf to AMDL.mBuf */ - AMDL.mBuf = mBuf; + rlcDatReq->pduSz -= cntrlPduSz; + /* Add mBuf to RLC_AMDL.mBuf */ + RLC_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 -PRIVATE Void rgAmmExtractElmnt -( -KwCb *gCb, -Buffer *pdu, -KwExtHdr *hdrInfo -) -#else -PRIVATE Void rgAmmExtractElmnt(gCb, pdu, hdrInfo) -KwCb *gCb; -Buffer *pdu; -KwExtHdr *hdrInfo; -#endif +static Void rgAmmExtractElmnt(RlcCb *gCb,Buffer *pdu,RlcExtHdr *hdrInfo) { - U8 hdr; - U8 pLen = hdrInfo->pLen; - U8 len = (U8)hdrInfo->len; - U16 val; - U8 tHdr; - U8 fLen; - U8 rLen; - /* U8 rLen1 = 0; */ - U16 tVal; - - TRC2(kwAmmExtractElmnt); + uint8_t hdr; + uint8_t pLen = hdrInfo->pLen; + uint8_t len = (uint8_t)hdrInfo->len; + uint16_t val; + uint8_t tHdr; + uint8_t fLen; + uint8_t rLen; + /* uint8_t rLen1 = 0; */ + uint16_t tVal; hdr = hdrInfo->hdr; @@ -3895,7 +3379,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; } @@ -3903,31 +3387,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); } } @@ -3935,47 +3419,34 @@ KwExtHdr *hdrInfo; hdrInfo->hdr = hdr; hdrInfo->val = val; - RETVOID; + return; } -#ifdef ANSI -PRIVATE Void rgAmmUlHndlStatusPdu +static Void rgAmmUlHndlStatusPdu ( Pst *udxPst, SuId suId, -KwCb *gCb, -KwDlRbCb *rbCb, +RlcCb *gCb, +RlcDlRbCb *rbCb, Buffer *cntrlPdu, -U8 *fByte +uint8_t *fByte ) -#else -PRIVATE Void rgAmmUlHndlStatusPdu(udxPst,suId,gCb, rbCb, cntrlPdu, fByte) -Pst *udxPst; -SuId suId; -KwCb *gCb; -KwDlRbCb *rbCb; -Buffer *cntrlPdu; -U8 *fByte; -#endif { - U8 e1; - KwExtHdr hdrInfo; - KwUdxStaPdu *pStaPdu; - U8 e3; /* NACK RANGE : 5GNR */ - U32 snLen; - U32 snRange; - U32 resrvdBitsAckSn; - U32 resrvdBitsNackSn; - - - TRC2(rgAmmUlHndlStatusPdu) + uint8_t e1; + RlcExtHdr hdrInfo; + RlcUdxStaPdu *pStaPdu; + uint8_t e3; /* NACK RANGE : 5GNR */ + uint32_t snLen; + uint32_t snRange; + uint32_t resrvdBitsAckSn; + uint32_t resrvdBitsNackSn; - 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); @@ -3984,56 +3455,56 @@ 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"); - RETVOID; + RLCDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n"); + return; } - KW_ALLOC_SHRABL_BUF(udxPst->region, + 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 */ if(!pStaPdu) { - RETVOID; + return; } #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); + e1 = (uint8_t)hdrInfo.val; + RLCDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn); /* Extract the Reserved Bits after ACK SN field */ hdrInfo.len = resrvdBitsAckSn; @@ -4042,30 +3513,30 @@ 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; + e1 = (uint8_t)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;*/ + /* e2 = (uint8_t) hdrInfo.val;*/ /* Store e2 value */ - pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val; + pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) 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; + e3 = (uint8_t) hdrInfo.val; /* Extract Reserved Bits after NACK SN */ hdrInfo.len = resrvdBitsNackSn; @@ -4074,14 +3545,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); @@ -4097,9 +3568,9 @@ 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; + snRange = (uint8_t)hdrInfo.val; pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange; @@ -4112,55 +3583,55 @@ 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; } /* Parse & send Status PDU to RLC-DL */ - //KwUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu); - KwUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu); + //rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu); + rlcUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu); - RETVOID; + return; } -PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId, +S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId, CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu) { - KwDlRbCb *rbCb = NULLP; - KwDlUeCb *ueCb = NULLP; - U8 fByte; - U8 temp; + RlcDlRbCb *rbCb = NULLP; + RlcDlUeCb *ueCb = NULLP; + uint8_t fByte; + uint8_t temp; S16 retVal = RFAILED; - KwCb *gCb; + RlcCb *gCb; Pst dlRlcPst = *udxPst; - gCb = KW_GET_KWCB(1); /* DL RLC instance */ + 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"); - RETVALUE(RFAILED); + return RFAILED; } rbCb = ueCb->lCh[lcId - 1].dlRbCb; /* Skip if mode is not AM */ - if((rbCb == NULLP) || (rbCb->mode != CM_LTE_MODE_AM)) + if((rbCb == NULLP) || (rbCb->mode != RLC_MODE_AM)) { - RETVALUE(RFAILED); + return RFAILED; } if(ROK != SExamMsg((Data *)(&fByte), rlcSdu, 0)) { printf("\n Failure in Rlc Hdr SExamMsg\n"); - RETVALUE(RFAILED); + 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*/ @@ -4168,7 +3639,7 @@ PUBLIC S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId, retVal = ROK; } - RETVALUE(retVal); + return (retVal); }