File: kw_amm_dl.c
*********************************************************************21*/
-static const char* RLOG_MODULE_NAME="AMM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=189;
/* header include files (.h) */
#include "common_def.h"
#include "lkw.h" /* LKW defines */
//UDAY
#ifdef L2_OPTMZ
-extern U32 rlcAmmStaPduList[512];
- U32 rlcAmmStaPduListCnt = 0;
+uint32_t rlcAmmStaPduList[512];
+uint32_t rlcAmmStaPduListCnt = 0;
#endif
**/
#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_DL)
-U32 rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
+uint32_t rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
/* local defines */
/* local externs */
/* forward references */
-EXTERN Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
+Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcUdxStaPdu *pStaPdu));
{\
Buffer *_pduInfo; \
SSegMsg((_retx)->seg, (_retx)->hdrSz, &_pduInfo); \
- RLC_FREE_BUF((_retx)->seg); \
+ ODU_PUT_MSG_BUF((_retx)->seg); \
(_retx)->seg = _pduInfo; \
}\
(_rbCb)->m.amDl.estHdrSz -= retx->hdrSz;\
/* private function declarations */
-PRIVATE Void rlcResegRetxPdus ARGS ((RlcCb *gCb,
+static Void rlcResegRetxPdus ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcDatReq *rlcDatReq));
-PRIVATE Void rlcRemRetxPdu ARGS ((RlcCb *gCb,
+static Void rlcRemRetxPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx));
-PRIVATE Void rlcAmmCreateStatusPdu ARGS ((RlcCb *gCb,
+static Void rlcAmmCreateStatusPdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcDatReq *rlcDatReq));
-PRIVATE Void rlcAmmDlMarkPduForReTx ARGS ((RlcCb *gCb,
+static Void rlcAmmDlMarkPduForReTx ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx));
-PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb,
+static Void rlcAmmDlProcessSuccessfulTxPdu ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSn sn,
KwuDatCfmInfo **datCfm));
-PRIVATE Void rlcAmmDlSetTxNextAck ARGS((RlcAmDl *amDl, RlcSn sn));
+static Void rlcAmmDlSetTxNextAck ARGS((RlcAmDl *amDl, RlcSn sn));
-PRIVATE Void rlcAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb,
+static Void rlcAmmDlCheckAndStopPollTmr ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSn mAckSn));
-PRIVATE Void rlcAssembleSdus ARGS ((RlcCb *gCb,
+static Void rlcAssembleSdus ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcDatReq *rlcDatReq));
-bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
+static bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
bool newPdu,
MsgLen bufSz));
-PRIVATE Void rlcAmmCreatePdu ARGS ((RlcCb *gCb,
+static Void rlcAmmCreatePdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcAmHdr *amHdr,
RlcDlPduInfo *pduInfo,
Buffer *pdu));
-PRIVATE Void rlcAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, RlcRetx *retx));
+static Void rlcAmmSndStaInd ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb, RlcRetx *retx));
-PRIVATE Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx));
+static Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx));
-PRIVATE Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr,
- U8 *hdr,
- U8 snLen,
- U16 *idx));
+static Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr,
+ uint8_t *hdr,
+ uint8_t snLen,
+ uint16_t *idx));
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
+static Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSn mAckSn,
CmLList *retx,
KwuDatCfmInfo **datCfm));
-PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb,
+static Void rlcAmmDlMoveFrmTxtoRetxBuffer ARGS ((RlcCb *gCb,
RlcAmDl *amDl,
RlcRetx **retx,
RlcSn sn));
-PRIVATE Void rlcAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb,
+static Void rlcAmmDlCheckIsSDUDelivered ARGS((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSduMap *sduMap,
KwuDatCfmInfo **datCfm));
-PRIVATE Void rlcAmmAddPduToRetxLst ARGS((RlcAmDl *amDl,
+static Void rlcAmmAddPduToRetxLst ARGS((RlcAmDl *amDl,
RlcRetx *retx));
-PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS(
+static Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer ARGS(
(
RlcCb *gCb,
RlcAmDl *amDl,
RlcDlPduInfo *pduInfo
));
-PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ARGS(
+static Void rlcAmmDlHndlStatus4SduByteSegInTxBuf ARGS(
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
));
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn ARGS(
+static Void rlcAmmDlUpdateTxAndReTxBufForNackSn ARGS(
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
));
-PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ARGS(
+static Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx ARGS(
(
RlcAmDl *amDl,
RlcNackInfo *nackInfo,
CmLList *retxNode,
RlcNackInfo *nackSnInfo,
-U8 idx
+uint8_t idx
));
-PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
+static Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
*
* @return Void
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlCheckAndStopPollTmr
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcSn mAckSn
-)
-#else
-PRIVATE Void rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcSn mAckSn;
-#endif
+static Void rlcAmmDlCheckAndStopPollTmr(RlcCb *gCb,RlcDlRbCb *rbCb,RlcSn mAckSn)
{
RlcSn mPollSn;
if (mPollSn <= mAckSn)
{
- if (rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
+ if (rlcChkTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
}
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlSetTxNextAck
-(
-RlcAmDl *amDl,
-RlcSn sn
-)
-#else
-PRIVATE Void rlcAmmDlSetTxNextAck(amDl, sn)
-RlcAmDl *amDl;
-RlcSn sn
-#endif
+static Void rlcAmmDlSetTxNextAck(RlcAmDl *amDl,RlcSn sn)
{
amDl->txNextAck = sn;
- RETVOID;
+ return;
}
/**
*
* @return Void
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlProcessSuccessfulReTx
+static Void rlcAmmDlProcessSuccessfulReTx
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx,
-KwuDatCfmInfo **datCfm
+KwuDatCfmInfo **datCfm
)
-#else
-PRIVATE Void rlcAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcRetx *retx;
-KwuDatCfmInfo **datCfm;
-#endif
{
rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, &(retx->sduMap), datCfm);
rlcRemRetxPdu(gCb, rbCb, retx);
- RETVOID;
+ return;
}
/**
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer
+static Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer
(
RlcCb *gCb,
RlcAmDl *amDl,
RlcRetx **retx,
RlcDlPduInfo *pduInfo
)
-#else
-PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo)
-RlcCb *gCb;
-RlcAmDl *amDl;
-RlcRetx **retx;
-RlcDlPduInfo *pduInfo;
-#endif
{
RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
{
- RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
gRlcStats.amRlcStats.numDLRetransPdus++;
- RETVOID;
+ return;
} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
/**
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf
+static Void rlcAmmDlHndlStatus4SduByteSegInTxBuf
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx **retx,
KwuDatCfmInfo ** datCfm
)
-#else
-PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm)
-(
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcNackInfo *nackSnInfo;
-RlcRetx **retx;
-KwuDatCfmInfo **datCfm;
-)
-#endif
{
RlcTx *txBuf=NULLP;
CmLList *lnk;
CmLList *nextLnk;
- txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
+ txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, nackSnInfo->sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
lnk = txBuf->pduLst.first;
while(lnk)
nextLnk = lnk->next;
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, lnk);
- RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
+ RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo));
lnk = nextLnk;
}
if(!txBuf->pduLst.count)
{
/*No more Sdu byte segment are left. Hence delete txBuf*/
- rlcUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb);
+ rlcUtlDelTxBuf(RLC_AMDL.txBufLst, txBuf,gCb);
}
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn
+static Void rlcAmmDlUpdateTxAndReTxBufForNackSn
(
- RlcCb *gCb,
- RlcDlRbCb *rbCb,
- RlcNackInfo *nackSnInfo,
- CmLList **retxNode,
- KwuDatCfmInfo **datCfm
- )
-#else
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm)
-(
- RlcCb *gCb;
- RlcDlRbCb *rbCb;
- RlcNackInfo *nackSnInfo;
- CmLList **retxNode;
- KwuDatCfmInfo **datCfm;
- )
-#endif
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
+RlcNackInfo *nackSnInfo,
+CmLList **retxNode,
+KwuDatCfmInfo **datCfm
+)
{
RlcTx *txBuf;
RlcRetx *retx;
/* if the NACK_SN is in the transmit buffer, move it to the re-
transmit buffer */
- txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
+ txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, nackSnInfo->sn);
if (txBuf != NULLP)
{
if(nackSnInfo->isSegment)
(*retxNode) = retx->lstEnt.next;
}
- RETVOID;
+ return;
}
/* process the pdus/segments in the re-transmit buffer with
if ((nackSnInfo->isSegment) &&
((retx->soEnd < nackSnInfo->soStart) /*|| (retx->amHdr.so > soEnd)*/))
{
- RLOG_ARG3(L_DEBUG, DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: Handle ACK for byte segment, Its "
+ DU_LOG( "\nDEBUG --> RLC_DL : rlcHndlStaRsp: Handle ACK for byte segment, Its "
"sn = %d UEID:%d CELLID:%d",
nackSnInfo->sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RLOG_ARG4(L_DEBUG, DBG_RBID, rbCb->rlcId.rbId,
- "soStart and soEnd = %d, %d, UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : soStart and soEnd = %d, %d, UEID:%d CELLID:%d",
retx->amHdr.so, retx->soEnd,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
break;
}
} /* end of retxNode while loop*/
- RETVOID;
+ return;
}
/**
* @param[in]RlcNackInfo *nackSnInfo,
* @param[in]RlcRetx *retx;
* @param[in]RlcSn sn,
-* @param[in]U8 idx
+* @param[in]uint8_t idx
*
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx
+static Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx
(
RlcAmDl *amDl,
RlcNackInfo *nackInfo,
CmLList *retxNode,
RlcNackInfo *nackSnInfo,
-U8 idx
+uint8_t idx
)
-#else
-PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
-(
-RlcAmDl *amDl;
-RlcNackInfo *nackInfo;
-CmLList *retxNode;
-RlcNackInfo *nackSnInfo;
-U8 idx;
-)
-#endif
{
RlcTx *txBuf;
RlcRetx *retx;
{
nackSnInfo->soStart = 0;
nackSnInfo->soEnd = 0;
- RETVOID;
+ return;
}
txBuf = rlcUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn);
if(txBuf != NULLP)
while(node)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(node->node);
- U16 pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
+ uint16_t pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
if((!idx) && (pduInfo->amHdr.so == nackInfo->soStart))
{
nackSnInfo->isSegment = TRUE;
*
* @return Void
*/
-#ifdef ANSI
-Void rlcAmmDlHndlStatusPdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcUdxStaPdu *pStaPdu
-)
-#else
-Void rlcAmmDlHndlStatusPdu(gCb, rbCb, pStaPdu)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcUdxStaPdu *pStaPdu;
-#endif
+Void rlcAmmDlHndlStatusPdu(RlcCb *gCb,RlcDlRbCb *rbCb,RlcUdxStaPdu *pStaPdu)
{
RlcSn mAckSn;
S32 oldRetxBo;
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 */
RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (datCfm == NULLP)
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ 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)
{
- RLOG_ARG4(L_WARNING,DBG_RBID, rbCb->rlcId.rbId,
- "Invalid ACK SN = %d received. Current Vta =%d"
+ DU_LOG("\nERROR --> RLC_DL : 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);
/* RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
/* Venki - stopping the poll retx timer */
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)
RlcNackInfo nackSnInfo;
RlcSn mNackSn;
RlcSn txNextAck;
- RlcSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which
+ 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;
nackSnInfo.nackRange = pStaPdu->nackInfo[idx].nackRange;
nackSnInfo.sn = pStaPdu->nackInfo[idx].sn;
- RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : 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))
{
/* Erroneous NACK_SN, we should raise an error towards L3 */
- RLOG_ARG2(L_ERROR,DBG_RBID, rbCb->rlcId.rbId,
- "Status Pdu is not correct UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : Status Pdu is not correct UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
/* clear all the SNs < NACK_SN from re-transmission list */
}
else
{
- U8 idx1 = 0;
+ uint8_t idx1 = 0;
/* Update issegment, soStart, soEnd ,sn in nackSnInfo and handle
* nack sn*/
do
{
- RlcDlAmmGetNackSnInfoFrmNackRangeIdx(&AMDL, &pStaPdu->nackInfo[idx],
+ RlcDlAmmGetNackSnInfoFrmNackRangeIdx(&RLC_AMDL, &pStaPdu->nackInfo[idx],
retxNode, &nackSnInfo, idx1);
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));
rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm);
/* Update txNextAck */
- rlcAmmDlSetTxNextAck(&AMDL,txNextAck);
+ rlcAmmDlSetTxNextAck(&RLC_AMDL,txNextAck);
}
else
{
rlcStatusAckCnt++;
/* For All ACKs */
- RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb,rbCb, mAckSn, retxNode, &datCfm);
/* update txNextAck */
- rlcAmmDlSetTxNextAck(&AMDL, pStaPdu->ackSn);
+ rlcAmmDlSetTxNextAck(&RLC_AMDL, pStaPdu->ackSn);
}
if(datCfm->numSduIds != 0)
{
if(datCfm->numSduIds > 1024)
{
- RLOG_ARG4(L_DEBUG,DBG_RBID,datCfm->rlcId.rbId,
- "Sending [%lu] SDU Cfms to PDCP & [%lu] lost for"
+ DU_LOG("\nDEBUG --> RLC_DL : Sending [%u] SDU Cfms to PDCP & [%u] lost for"
"UEID:%d CELLID:%d",
datCfm->numSduIds,
datCfm->numSduIds-1024,
}
/* Fix for memory corruption */
- RLC_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)
{
- rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL);
}
- RETVOID;
+ return;
}
/**
* @return S16
* Calculated bo
*/
-#ifdef ANSI
-S32 rlcAmmCalculateBo
-(
-RlcAmDl *amDl
-)
-#else
-S32 rlcAmmCalculateBo(amDl)
-RlcAmDl *amDl;
-#endif
+S32 rlcAmmCalculateBo(RlcAmDl *amDl)
{
S32 bo;
return bo;
}
-U32 kwRxSdu;
+uint32_t kwRxSdu;
/**
* @brief Handler to queue the SDUs received from PDCP
* @param[in] datReq Ptr to the datReq sent from PDCP
*
* @return Void
- * -# RETVOID
+ * -# void
*/
void rlcAmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *mBuf, KwuDatReqInfo *datReq)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if (sdu == NULLP)
{
- DU_LOG("\n RLC : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\
+ DU_LOG("\nERROR --> RLC_DL : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
#ifndef RGL_SPECIFIC_CHANGES
#ifdef MSPD
{
-extern uint32_t 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)
{
- DU_LOG("\nRLC : rlcAmmQSdu: Received SDU will be transmitted next \
+ DU_LOG("\nDEBUG --> RLC_DL : rlcAmmQSdu: Received SDU will be transmitted next \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- AMDL.nxtTx = sdu;
+ 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;
}
- rlcWinSz = RLC_AM_TRANS_WIN_SIZE(&AMDL);
+ rlcWinSz = RLC_AM_TRANS_WIN_SIZE(&RLC_AMDL);
if (rlcWinSz > rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz)
{
rbCb->ueCb->tenbStats->stats.nonPersistent.rlc.dlMaxWindowSz = rlcWinSz;
#endif
#endif
/* Update BO and estimate header size for the current BO */
- AMDL.bo = AMDL.bo + sdu->sduSz;
- if(AMDL.snLen == RLC_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 */
if(!rlcDlUtlIsReestInProgress(rbCb))
{
- rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL);
}
return;
* @return Void
*
*/
-void rlcAmmDlAssembleCntrlInfo(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
+static void rlcAmmDlAssembleCntrlInfo(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcUdxDlSapCb *sapCb;
MsgLen macHdrEstmt;
sapCb->suId, &(rbCb->rlcId));
/* Update number of pdus in pduInfo */
- rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = AMDL.mBuf;
+ rlcDatReq->pduInfo.mBuf[rlcDatReq->pduInfo.numPdu] = RLC_AMDL.mBuf;
rlcDatReq->pduInfo.numPdu++;
gRlcStats.amRlcStats.numDLStaPduSent++;
RLC_FREE_SHRABL_BUF(gCb->u.dlCb->udxDlSap->pst.region,
gCb->u.dlCb->udxDlSap->pst.pool,
- AMDL.pStaPdu,
+ RLC_AMDL.pStaPdu,
sizeof(RlcUdxDlStaPdu));
- AMDL.pStaPdu = NULLP;
- AMDL.mBuf = NULLP;
+ RLC_AMDL.pStaPdu = NULLP;
+ RLC_AMDL.mBuf = NULLP;
gRlcStats.amRlcStats.numDLStaPduSent++;
}
* 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
)
{
rlcDatReq->boRep.staPduPrsnt = TRUE;
- rlcDatReq->boRep.staPduBo = AMDL.cntrlBo;
+ rlcDatReq->boRep.staPduBo = RLC_AMDL.cntrlBo;
- if (AMDL.pStaPdu != NULLP)
+ if (RLC_AMDL.pStaPdu != NULLP)
{
rlcAmmDlAssembleCntrlInfo (gCb, rbCb, rlcDatReq);
}
else
{
- DU_LOG("\nRLC: rlcAmmProcessSdus: Miscomputation of control Bo. \
+ DU_LOG("\nERROR --> RLC_DL : 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 ((rlcDatReq->pduSz > 0) && (AMDL.nxtRetx != NULLP))
+ if ((rlcDatReq->pduSz > 0) && (RLC_AMDL.nxtRetx != NULLP))
{
rlcResegRetxPdus (gCb,rbCb, rlcDatReq);
}
/* Assemble SDUs to form new PDUs */
- if ((rlcDatReq->pduSz > 0) && (AMDL.nxtTx != 0))
+ if ((rlcDatReq->pduSz > 0) && (RLC_AMDL.nxtTx != 0))
{
rlcAssembleSdus(gCb,rbCb, rlcDatReq);
}
- if (AMDL.nxtRetx != NULLP)
+ if (RLC_AMDL.nxtRetx != NULLP)
{
- rlcDatReq->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)
{
- rlcDatReq->boRep.oldestSduArrTime = AMDL.nxtTx->arrTime;
+ rlcDatReq->boRep.oldestSduArrTime = RLC_AMDL.nxtTx->arrTime;
}
/* Accumulate bo */
- rlcDatReq->boRep.bo = rlcAmmCalculateBo(&AMDL);
- rlcDatReq->boRep.staPduBo = AMDL.cntrlBo;
+ rlcDatReq->boRep.bo = rlcAmmCalculateBo(&RLC_AMDL);
+ rlcDatReq->boRep.staPduBo = RLC_AMDL.cntrlBo;
/* Hdr estimation is moved to kwAmmCreatePDu */
- rlcDatReq->boRep.estHdrSz = AMDL.estHdrSz;
+ rlcDatReq->boRep.estHdrSz = RLC_AMDL.estHdrSz;
if(rlcDatReq->pduSz > 0)
{
* @return Void
*
*/
-void rlcSplitPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcRetx *crnt, RlcRetx *next, uint16_t size)
+static void rlcSplitPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcRetx *crnt, RlcRetx *next, uint16_t size)
{
uint8_t si;
- RlcAmDl *amDl = &AMDL;
+ RlcAmDl *amDl = &RLC_AMDL;
/* Set the SN for the new segment */
next->amHdr.sn = crnt->amHdr.sn;
}
/* 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;
return;
* @return Void
*
*/
-void rlcResegRetxPdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
+static void rlcResegRetxPdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcAmDl *amDl;
RlcRetx *retx;
uint8_t numSdus;
#endif
- amDl = &AMDL;
+ amDl = &RLC_AMDL;
#ifdef LTE_L2_MEAS
/* TODO : This shoould be taken care in new Trasmissions */
/* This lchInfo should be retrieved there */
/* kw003.201 - Eliminate MAC Header Size based on bites needed */
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*/
+ /* 5GNR_RLC_DL : length field in 5GNR MAC Hdr is 8/16 btis*/
rlcDatReq->pduSz -= (tmpSz < 255) ? RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3;
/* kw003.201 - We should have at least one more than basic header */
{
uint8_t pollBit;
- DU_LOG("\nRLC: rlcResegRetxPdus: Send retx buf without segmentation "
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: Send retx buf without segmentation "
"UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
if (retx->yetToConst)
RLC_UPD_POLL_BIT(gCb, retx, pollBit);
rlcDatReq->pduSz -= pduSz;
- AMDL.estHdrSz -= retx->hdrSz;
+ RLC_AMDL.estHdrSz -= retx->hdrSz;
#ifdef LTE_L2_MEAS
if (rbCb->rlcId.rbType == CM_LTE_DRB)
/* Segment this pdu / portion of pdu. Insert this segment into */
/* retxLst and update offset */
- DU_LOG("\nRLC: rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
+ DU_LOG("\nINFO --> RLC_DL : 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 */
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tNode == NULLP)
{
- DU_LOG("\nRLC: rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
amDl->retxBo -= retx->segSz;
}
#ifndef ALIGN_64BIT
- DU_LOG("\nRLC: rlcResegRetxPdus: retxBo after resegmentation = %ld"
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %ld"
"UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
#else
- DU_LOG("\nRLC: rlcResegRetxPdus: retxBo after resegmentation = %d "
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %d "
"UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
#endif
* @return Void
*
*/
-void rlcAssembleSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
+static void rlcAssembleSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
Buffer *pdu = NULLP;
MsgLen macGrntSz = rlcDatReq->pduSz;
- RlcAmDl *amDl = &AMDL;
+ RlcAmDl *amDl = &RLC_AMDL;
RlcSdu *sdu = amDl->nxtTx;
RlcSduMap sduMap;
bool nxtTxUpd = FALSE;
uint8_t numNewPdu = 0;
RlcTx *txBuf = NULLP;
/* Discard new changes ends */
- VOLATILE uint32_t startTime = 0;
+ volatile uint32_t startTime = 0;
uint32_t hdrEstmt;
uint32_t fixedHdrSz;
uint32_t pduSz;
#if (ERRCLASS & ERRCLS_ADD_RES)
if (discSduInfo == NULLP)
{
- DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
/* store the info for sending it to PDCP */
if(discSduInfo->numSduIds > 500)
{
- DU_LOG("\nRLC: rlcAssembleSdus: This is a big error, we shouldn't be here"
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: This is a big error, we shouldn't be here"
"UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
break;
}
if (RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
//int *a = NULLP;
- printf("\n Window stalled \n");
+ DU_LOG("\nINFO --> RLC_DL : Window stalled \n");
gRlcStats.amRlcStats.numRlcAmCellWinStall++;
//*a = 10;
break;
{
uint32_t avblMem = 0;
SRegInfoShow(gCb->init.region, &avblMem);
- DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
{
uint32_t avblMem = 0;
SRegInfoShow(gCb->init.region, &avblMem);
- DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
/* Update Framing Info */
if (sdu->mode.am.isSegmented)
{
- /*5GNR RLC: SN should be same for all segment of a SDU*/
+ /*5GNR RLC_DL : SN should be same for all segment of a SDU*/
pduInfo->amHdr.sn = sdu->mode.am.sn;
pduInfo->amHdr.si = RLC_SI_LAST_SEG; /* binary 10 */
pduInfo->amHdr.so = sdu->actSz - sdu->sduSz;
gRlcStats.amRlcStats.numRlcAmCellSduTx++;
- //printf("\n 5GNRLOG: last segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: last segment of lcId %d SduId %u So %u macGrntSz\
+ %u sduActSz %u sdu->sduSz %u\n",
// rbCb->lch.lChId, sdu->mode.am.sduId, pduInfo->amHdr.so, macGrntSz, sdu->actSz, sdu->sduSz);
}
else
/* Create PDU with hdr and data */
rlcAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu);
- //printf("\n Segmentation not required case: numPdu %d pdu %p \n",rlcDatReq->pduInfo.numPdu, pdu);
+ //DU_LOG("\nINFO --> Segmentation not required case: numPdu %d pdu %p \n",rlcDatReq->pduInfo.numPdu, pdu);
#ifdef LTE_L2_MEAS_RLC
rlcUtlUpdSduSnMap(rbCb, sdu, rlcDatReq, TRUE);
Buffer *remSeg = NULLP;
- //printf("\n SDU segmentation case: numPdu %d pdu %p \n", rlcDatReq->pduInfo.numPdu, pdu);
+ //DU_LOG("\nINFO --> SDU segmentation case: numPdu %d pdu %p \n", rlcDatReq->pduInfo.numPdu, pdu);
#ifdef LTE_L2_MEAS
if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rbCb) ||
RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(gCb,rbCb) ||
/* Update SI and SN */
if (sdu->mode.am.isSegmented)
{
- /*5GNR RLC: SN should be same for all segment of a SDU.
+ /*5GNR RLC_DL : 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 = 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",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: mid segment of lcId %d SduId %u So %u macGrntSz %u sduActSz\
+ %u sdu->sduSz %u\n",
// rbCb->lch.lChId, sdu->mode.am.sduId, txBuf->amHdr.so, macGrntSz, sdu->actSz, sdu->sduSz);
}
else
{
- /*5GNR RLC: This means it is the first*/
+ /*5GNR RLC_DL : This means it is the first*/
pduInfo->amHdr.si = RLC_SI_FIRST_SEG; /* binary 01 */
- /*5GNR_RLC: Store SN so that in sub-seqent SDU segments will use this SN*/
+ /*5GNR_RLC_DL : Store SN so that in sub-seqent SDU segments will use this SN*/
sdu->mode.am.sn = pduInfo->amHdr.sn;
pduInfo->amHdr.so = 0;
- //printf("\n 5GNRLOG: First segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: First segment of lcId %d SduId %u So\
+ %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
// rbCb->lch.lChId, sdu->mode.am.sduId, txBuf->amHdr.so, macGrntSz, sdu->actSz, sdu->sduSz);
}
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
}
-
- DU_LOG("\nRLC: rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
amDl->bo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
-
return;
}
* -# 0 - Poll bit is not set
*
*/
-bool rlcAmmDlCheckAndSetPoll(RlcCb *gCb, RlcDlRbCb *rbCb, bool newPdu, MsgLen bufSz)
+static bool rlcAmmDlCheckAndSetPoll(RlcCb *gCb, RlcDlRbCb *rbCb, bool newPdu, MsgLen bufSz)
{
bool pollBit = FALSE;
RlcAmDl *amDl = &(rbCb->m.amDl);
amDl->pollSn = (amDl->txNext - 1) & amDl->snModMask;
- DU_LOG("\nRLC: rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
+ DU_LOG("\nINFO --> RLC_DL : rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
amDl->pollSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* kw005.201: Fix for poll retransmission timer.
* then starting the timer. Fixes crs
* ccpu00117216 and ccpu00118284 .
* */
- if( TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR) )
+ if( TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMDL_POLL_RETX_TMR) )
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
- rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
return (pollBit);
* @return Void
*
*/
-void rlcAmmCreatePdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmHdr *amHdr,
+static void rlcAmmCreatePdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmHdr *amHdr,
RlcDlPduInfo *pduInfo, Buffer *pdu)
{
uint8_t hdr[RLC_MAX_HDRSZ];
/* Update sn */
amHdr->sn = amDl->txNext;
- /*5GNR RLC: Increment txNext only if no segmentation of it is a last segment */
+ /*5GNR RLC_DL : Increment txNext only if no segmentation of it is a last segment */
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",
+ //DU_LOG("\nINFO --> RLC_DL : 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);
amDl->txNext = (amDl->txNext + 1) & amDl->snModMask;
}
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcRemRetxPdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcRetx *retx
-)
-#else
-PRIVATE Void rlcRemRetxPdu(gCb, rbCb, retx)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcRetx *retx;
-#endif
+static Void rlcRemRetxPdu(RlcCb *gCb,RlcDlRbCb *rbCb,RlcRetx *retx)
{
- 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;
}
rlcUtlAddReTxPduToBeFreedQueue(gCb, retx);
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlMarkPduForReTx
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcRetx *retx
-)
-#else
-PRIVATE Void rlcAmmDlMarkPduForReTx(*gCb, rbCb, retx)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcRetx *retx;
-#endif
+static Void rlcAmmDlMarkPduForReTx(RlcCb *gCb,RlcDlRbCb *rbCb,RlcRetx *retx)
{
- 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 */
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 rlcAmmDlCheckIsSDUDelivered
+static Void rlcAmmDlCheckIsSDUDelivered
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSduMap *sduMap,
-KwuDatCfmInfo **datCfm
+KwuDatCfmInfo **datCfm
)
-#else
-PRIVATE Void rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcSduMap *sduMap;
-KwuDatCfmInfo **datCfm;
-#endif
{
RlcSdu *sdu;
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*datCfm == NULLP)
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : 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);
+ cmLListDelFrm(&RLC_AMDL.sduQ, &sdu->lstEnt);
rlcUtlAddSduToBeFreedQueue(gCb, sdu);
rlcUtlRaiseDlCleanupEvent(gCb);
}
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu
+static Void rlcAmmDlProcessSuccessfulTxPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSn sn,
-KwuDatCfmInfo **datCfm
+KwuDatCfmInfo **datCfm
)
-#else
-PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcSn sn;
-KwuDatCfmInfo **datCfm;
-#endif
{
CmLList *pduNode;
- RlcTx *txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
+ RlcTx *txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
pduNode = txBuf->pduLst.first;
while(pduNode)
rlcUtlAddTxPduToBeFreedQueue(gCb, txBuf);
rlcUtlRaiseDlCleanupEvent(gCb);
/* so that it is not processed again */
- rlcUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb);
+ rlcUtlRemovTxBuf(RLC_AMDL.txBufLst, txBuf, gCb);
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmSndStaInd
+static Void rlcAmmSndStaInd
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx
)
-#else
-PRIVATE Void rlcAmmSndStaInd(gCb, rbCb, retx)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcRetx *retx;
-#endif
{
KwuStaIndInfo *staInd;
RlcKwuSapCb *rlckwuSap;
#if (ERRCLASS & ERRCLS_ADD_RES)
if (staInd == NULLP)
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
RlcUiKwuStaInd(&rlckwuSap->pst, rlckwuSap->suId, staInd);
#endif /* KW_PDCP */
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-void rlcGetNxtRetx(RlcCb *gCb, RlcRetx **retx)
+static void rlcGetNxtRetx(RlcCb *gCb, RlcRetx **retx)
{
CmLList *tNode;
else
{
*retx = NULLP;
- RETVOID;
+ return;
}
}while((*retx)->pendingReTrans == FALSE);
* @return Void
*
*/
-#ifdef ANSI
Void rlcAmmDlReEstablish
(
RlcCb *gCb,
CmLteRlcId rlcId,
RlcDlRbCb *rbCb
)
-#else
-Void rlcAmmDlReEstablish(gCb, rlcId, rbCb)
-RlcCb *gCb;
-CmLteRlcId rlcId;
-RlcDlRbCb *rbCb;
-#endif
{
/* create a new AM DL RB, reset it and replace in the UeCb*/
RlcDlUeCb *ueCb;
/* ccpu00135170 Removing KLOCK warning */
if(resetRb == NULLP)
{
- RETVOID;
+ return;
}
RLC_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb));
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 != rlcDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb))
{
- RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId.cellId,
- "UeId [%d]: UeCb not found RBID;%d",
+ DU_LOG("\nERROR --> RLC_DL : UeId [%d]: UeCb not found RBID;%d",
rlcId.ueId,
rlcId.rbId);
- RETVOID;
+ return;
}
if(rlcId.rbType == CM_LTE_SRB)
/* allocate the TX array again */
#ifndef LTE_TDD
- U32 hashIndex;
+ uint32_t hashIndex;
RLC_ALLOC(gCb,
resetRb->m.amDl.txBufLst,
(RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
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
-S16 rlcAmmDiscSdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-U32 sduId
-)
-#else
-S16 rlcAmmDiscSdu(gCb, rbCb, sduId)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-U32 sduId;
-#endif
+S16 rlcAmmDiscSdu(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t sduId )
{
return (RFAILED);
}
*
* @return Void
*/
-#ifdef ANSI
-Void rlcAmmPollRetxTmrExp
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb
-)
-#else
-Void rlcAmmPollRetxTmrExp(gCb, rbCb)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-#endif
+Void rlcAmmPollRetxTmrExp(RlcCb *gCb,RlcDlRbCb *rbCb)
{
RlcRetx *retx;
RlcAmDl *amDl = &(rbCb->m.amDl);
{
rlcAmmDlMoveFrmTxtoRetxBuffer(gCb,amDl, &retx, sn);
- if (AMDL.nxtRetx == NULLP)
+ if (RLC_AMDL.nxtRetx == NULLP)
{
- AMDL.nxtRetx = retx;
+ RLC_AMDL.nxtRetx = retx;
}
- rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
- RETVOID;
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL);
+ return;
}
/* Get the last node in retxLst */
RLC_LLIST_LAST_RETX(amDl->retxLst, retx);
if (retx != NULLP)
{
rlcAmmDlMarkPduForReTx(gCb, rbCb, retx);
- rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &RLC_AMDL);
}
}
- RETVOID;
+ return;
}
/**
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn
+static Void rlcAmmDlUpdateTxAndReTxBufForAckSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
CmLList *retxNode,
KwuDatCfmInfo **datCfm
)
-#else
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcSn mAckSn;
-CmLList *retxNode;
-KwuDatCfmInfo **datCfm;
-#endif
{
RlcSn mSn;
RlcSn sn;
{
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)
{
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 = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
+ txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn);
if (txBuf != NULLP)
{
- RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
- "with sn = %ld UEID:%ld CELLID:%ld",
+
+ DU_LOG("\nDEBUG --> RLC_DL : rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
+ "with sn = %d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
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 rlcAmmDlUpdTxAndReTxBufForLessThanNackSn
+static Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
CmLList **retxNode,
KwuDatCfmInfo **datCfm
)
-#else
-PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcSn sn;
-RlcSn mNackSn;
-CmLList **retxNode;
-KwuDatCfmInfo **datCfm;
-#endif
{
RlcSn mSn;
RlcRetx *retx;
while (*retxNode)
{
retx = (RlcRetx *)((*retxNode)->node);
- MODAMT(retx->amHdr.sn, mSn, AMDL.txNextAck,AMDL.snModMask);
+ MODAMT(retx->amHdr.sn, mSn, RLC_AMDL.txNextAck,RLC_AMDL.snModMask);
if (mSn < mNackSn)
{
(*retxNode) = (*retxNode)->next;
}
/* 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 = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
+ txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn);
if ((txBuf != NULLP))
{
- RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
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
*
*/
-void rlcConstructAmHdr(RlcAmHdr *amHdr, uint8_t *hdr, uint8_t snLen, uint16_t *idx)
+static void rlcConstructAmHdr(RlcAmHdr *amHdr, uint8_t *hdr, uint8_t snLen, uint16_t *idx)
{
*idx = 0;
hdr[0] = RLC_DATA_BITMASK;
hdr[0] = hdr[0] | ((amHdr->si & 0x3) << 4);
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 == 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);
}
return;
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmAddPduToRetxLst
-(
-RlcAmDl *amDl,
-RlcRetx *retx
-)
-#else
-PRIVATE Void rlcAmmAddPduToRetxLst(amDl, retx)
-RlcAmDl *amDl;
-RlcRetx *retx;
-#endif
+static Void rlcAmmAddPduToRetxLst(RlcAmDl *amDl,RlcRetx *retx)
{
CmLList *node;
RlcRetx *tRetx;
amDl->nxtRetx = retx;
}
- RETVOID;
+ return;
}
/**
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer
+static Void rlcAmmDlMoveFrmTxtoRetxBuffer
(
RlcCb *gCb,
RlcAmDl *amDl,
RlcRetx **retx,
RlcSn sn
)
-#else
-PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn)
-RlcCb *gCb;
-RlcAmDl *amDl;
-RlcRetx **retx;
-RlcSn sn;
-#endif
{
RlcTx* txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
while(txBuf->pduLst.first)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
{
- RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
- RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
+ RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
/* Remove PDU from txBuf */
rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
- RETVOID;
+ return;
}
*
* @return Void
*/
-#ifdef ANSI
-Void rlcAmmFreeDlRbCb
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb
-)
-#else
-Void rlcAmmFreeDlRbCb(gCb,rbCb)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-#endif
+Void rlcAmmFreeDlRbCb(RlcCb *gCb,RlcDlRbCb *rbCb)
{
/* stop the re-transmission timer */
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
/* store the entire Rb pointer */
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-void rlcAmmCreateStatusPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
+static void rlcAmmCreateStatusPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcSn sn; /* sequence number */
RlcSn ack_sn; /* Ack sequence number */
RlcNackInfo *rlcNackInfo;
uint16_t nkCnt = 0;
- pStaPdu = AMDL.pStaPdu;
+ pStaPdu = RLC_AMDL.pStaPdu;
/* D/C| CPT| */
/* set ACK SN */
{
- DU_LOG("\nRLC: rlcAssembleCntrlInfo: ACK PDU's SN = %d"\
+ DU_LOG("\nINFO --> RLC_DL : 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;
}
}
}
/* 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 (rlcNackInfo->isSegment)
{
/* Add soStart and soEnd */
/* SOstart */
cntrlPdu[encIdx + 3] = (rlcNackInfo->soStart) >> 8;
- cntrlPdu[encIdx + 4] = (U8)rlcNackInfo->soStart;
+ cntrlPdu[encIdx + 4] = (uint8_t)rlcNackInfo->soStart;
/* SOend */
cntrlPdu[encIdx + 5] = (rlcNackInfo->soEnd) >> 8;
- cntrlPdu[encIdx + 6] = (U8)(rlcNackInfo->soEnd);
+ cntrlPdu[encIdx + 6] = (uint8_t)(rlcNackInfo->soEnd);
}
if (rlcNackInfo->nackRange)
/* set ACK SN */
{
- DU_LOG("\nRLC: rlcAssembleCntrlInfo: ACK PDU's SN = %d"
+ DU_LOG("\nINFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId,rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0x3C000) >> 14;
else
{
/* ERROR Log */
- DU_LOG("\nRLC: rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \
UEID:%d CELLID:%d", rbCb->m.amDl.snLen, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
ODU_ADD_POST_MSG_MULT(cntrlPdu, cntrlPduSz, mBuf);
rlcDatReq->pduSz -= cntrlPduSz;
- /* Add mBuf to AMDL.mBuf */
- AMDL.mBuf = mBuf;
+ /* Add mBuf to RLC_AMDL.mBuf */
+ RLC_AMDL.mBuf = mBuf;
return;
}
S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
-#ifdef ANSI
-PRIVATE Void rgAmmExtractElmnt
-(
-RlcCb *gCb,
-Buffer *pdu,
-RlcExtHdr *hdrInfo
-)
-#else
-PRIVATE Void rgAmmExtractElmnt(gCb, pdu, hdrInfo)
-RlcCb *gCb;
-Buffer *pdu;
-RlcExtHdr *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;
+ 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;
hdrInfo->hdr = hdr;
hdrInfo->val = val;
- RETVOID;
+ return;
}
-#ifdef ANSI
-PRIVATE Void rgAmmUlHndlStatusPdu
+static Void rgAmmUlHndlStatusPdu
(
Pst *udxPst,
SuId suId,
-RlcCb *gCb,
-RlcDlRbCb *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;
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-Buffer *cntrlPdu;
-U8 *fByte;
-#endif
{
- U8 e1;
+ uint8_t e1;
RlcExtHdr hdrInfo;
RlcUdxStaPdu *pStaPdu;
- U8 e3; /* NACK RANGE : 5GNR */
- U32 snLen;
- U32 snRange;
- U32 resrvdBitsAckSn;
- U32 resrvdBitsNackSn;
+ uint8_t e3; /* NACK RANGE : 5GNR */
+ uint32_t snLen;
+ uint32_t snRange;
+ uint32_t resrvdBitsAckSn;
+ uint32_t resrvdBitsNackSn;
RLCDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n");
if (hdrInfo.hdr & 0xE0)
{
RLCDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n");
- RETVOID;
+ return;
}
RLC_ALLOC_SHRABL_BUF(udxPst->region,
/* Memory allocation failure can not be expected */
if(!pStaPdu)
{
- RETVOID;
+ return;
}
#endif
/* Check if NACK Exists */
hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ 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 = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
/* Extract e2 */
/* 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 = 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;
/* Extract NACK range field */
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;
//rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
rlcUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu);
- RETVOID;
+ return;
}
S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
{
RlcDlRbCb *rbCb = NULLP;
RlcDlUeCb *ueCb = NULLP;
- U8 fByte;
- U8 temp;
+ uint8_t fByte;
+ uint8_t temp;
S16 retVal = RFAILED;
RlcCb *gCb;
Pst dlRlcPst = *udxPst;
if( ROK != rlcDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
{
- printf("\n RLC UECb Not found...\n");
+ DU_LOG("\nERROR --> RLC_DL : RLC UECb Not found...\n");
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))
{
return RFAILED;
}
if(ROK != SExamMsg((Data *)(&fByte),
rlcSdu, 0))
{
- printf("\n Failure in Rlc Hdr SExamMsg\n");
+ DU_LOG("\nERROR --> RLC_DL : Failure in Rlc Hdr SExamMsg\n");
return RFAILED;
}
Code Review / o-du / l2.git / blobdiff