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 */
/* 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 */
//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 */
/* 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;\
/* 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
));
AM Module contains the following funcitons:
- - kwAmmQSdu
- - kwAmmProcessSdus
- - kwAmmDlAssembleCntrlInfo
- - kwResegRetxPdus
- - kwAssembleSdus
- - kwAmmDlCheckAndSetPoll
- - kwAmmProcessPdus
- - kwDlmHndlStaRsp
+ - rlcAmmQSdu
+ - rlcAmmProcessSdus
+ - rlcAmmDlAssembleCntrlInfo
+ - rlcResegRetxPdus
+ - rlcAssembleSdus
+ - rlcAmmDlCheckAndSetPoll
+ - rlcAmmProcessPdus
+ - rlcDlmHndlStaRsp
- kwTriggerStatus
- kwReassembleSdus
*
* @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;
}
/**
*
* @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;
}
/**
*
* @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;
}
/**
*
* @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;
}
/**
* @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 */
(*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;
gRlcStats.amRlcStats.numDLRetransPdus++;
- RETVOID;
-} /*kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
+ return;
+} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
/**
* @brief Function to handle Status of Sdu byte segment for a nackSn
* @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
*
*
*/
-#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);
else if (pduSoEnd <= nackSnInfo->soEnd)
{
/* Move Sdu byte segment from TX buf to retx buf*/
- kwAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
+ rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb,
&rbCb->m.amDl,
retx,
pduInfo);
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;
}
/**
* @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 */
/* 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)
/* 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);
(*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;
((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,
rbCb->rlcId.cellId);
(*retxNode) = (*retxNode)->next;
- kwAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
+ rlcAmmDlProcessSuccessfulReTx(gCb,rbCb, retx, datCfm);
}
else if((!nackSnInfo->isSegment) || (retx->soEnd <= nackSnInfo->soEnd))
{
(*retxNode) = (*retxNode)->next;
/* Mark the retx PDU we found for further retransmission */
- kwAmmDlMarkPduForReTx(gCb, rbCb, retx);
+ rlcAmmDlMarkPduForReTx(gCb, rbCb, retx);
}
else
{
break;
}
} /* end of retxNode while loop*/
- RETVOID;
+ return;
}
/**
* @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;
{
while (retxNode)
{
- retx = (KwRetx *)(retxNode->node);
+ retx = (RlcRetx *)(retxNode->node);
if(retx->amHdr.sn != nackSnInfo->sn)
{
break;
*
* @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)
"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)
{
"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)
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);
/* 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))
{
"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));
/* 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)
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;
}
/**
* @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;
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
* 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
* @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;
#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 */
(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;
}
/**
* @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;
}
/**
* 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
*
* @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;
}
/**
* @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;
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;
}
/**
* - 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
* @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;
}
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 */
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 =
}
#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++;
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;
}
* - 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
*
* @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;
#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;
(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 */
/* 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;
}
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;
}
}
/** 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");
/* 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.
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 */
{
/*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;
}
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)
{
}
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++;
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 */
#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;
/*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",
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;
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;
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)
{
break;
}
}
- if (lchIdx < KW_MAX_ACTV_DRB)
+ if (lchIdx < RLC_MAX_ACTV_DRB)
{
if (lchIdx == l2MeasTb->numLchInfo)
{
}
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;
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;
}
/**
* -# 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)
/* 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;
}
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);
}
/**
* @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);
}
/* 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;
/* 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);
gCb->genSts.bytesSent += pduSz;
- RETVOID;
+ return;
}
/**
* @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;
}
/**
* @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)
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 */
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;
}
/**
* @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;
* 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)
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
}
/* 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;
}
/**
* @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;
}
/**
* @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)
"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;
}
/**
* @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);
if (tNode)
{
- *retx = (KwRetx *)tNode->node;
+ *retx = (RlcRetx *)tNode->node;
}
else
{
*retx = NULLP;
- RETVOID;
+ return;
}
}while((*retx)->pendingReTrans == FALSE);
- RETVOID;
+ return;
}
/**
* @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 */
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)
&&(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
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;
}
/**
* -# 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);
}
/**
*
* @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, */
}
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;
}
/**
*
*/
-#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);
}
}
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;
}
/**
* @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
{
}
/* 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;
}
* @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;
}
/**
* @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)
{
amDl->nxtRetx = retx;
}
- RETVOID;
+ return;
}
/**
*
*/
-#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;
}
*
* @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 */
/* the sdu queue */
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.amDl.sduQ));
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
*
* @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| */
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 */
{
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 */
/* Next Octet */
cntrlPdu[encIdx + 1] = (sn & 0xF) << 4;
- if (kwNackInfo->isSegment)
+ if (rlcNackInfo->isSegment)
{
/*Set E2 Bit */
cntrlPdu[encIdx + 1] |= 0x4;
/* 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;
}
}
/* Set ACK SN now */
else
{
- ack_sn = kwNackInfo->sn;
+ ack_sn = rlcNackInfo->sn;
/* Not even one nack can be accomodated */
if (nkCnt == 0)
/* 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)
{
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 */
}
/* 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 */
/* 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;
}
}
/* Set ACK SN now */
else
{
- ack_sn = kwNackInfo->sn;
+ ack_sn = rlcNackInfo->sn;
/* Not even one nack can be accomodated */
if (nkCnt == 0)
/* 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;
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;
tHdr = hdr;
if (len <= 8)
{
- val = tHdr >> (KW_BYTE_LEN - (len));
+ val = tHdr >> (RLC_BYTE_LEN - (len));
hdr = hdr << len;
pLen -= len;
}
{
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);
}
}
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);
/* 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;
/* 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;
/* 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);
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;
/* 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*/
retVal = ROK;
}
- RETVALUE(retVal);
+ return (retVal);
}
Code Review / o-du / l2.git / blobdiff