//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));
/* 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));
-PRIVATE Bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
+static bool rlcAmmDlCheckAndSetPoll ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
- Bool newPdu,
+ 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
-Void rlcAmmSendDStaRsp
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcAmDl *amDl
-)
-#else
-Void rlcAmmSendDStaRsp(gCb, rbCb, amDl)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcAmDl *amDl;
-#endif
+void rlcAmmSendDedLcBoStatus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmDl *amDl)
{
- S32 bo = rlcAmmCalculateBo(amDl);
+ int32_t bo = rlcAmmCalculateBo(amDl);
if(bo)
{
- rlcUtlSndDStaRsp(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 rlcAmmDlCheckAndStopPollTmr
+static Void rlcAmmDlCheckAndStopPollTmr
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcSn mAckSn
)
#else
-PRIVATE Void rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn)
+static Void rlcAmmDlCheckAndStopPollTmr(gCb, rbCb, mAckSn)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcSn mAckSn;
}
}
- RETVOID;
+ return;
}
/**
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlSetTxNextAck
+static Void rlcAmmDlSetTxNextAck
(
RlcAmDl *amDl,
RlcSn sn
)
#else
-PRIVATE Void rlcAmmDlSetTxNextAck(amDl, sn)
+static Void rlcAmmDlSetTxNextAck(amDl, sn)
RlcAmDl *amDl;
RlcSn sn
#endif
{
amDl->txNextAck = sn;
- RETVOID;
+ return;
}
/**
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlProcessSuccessfulReTx
+static Void rlcAmmDlProcessSuccessfulReTx
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void rlcAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm)
+static Void rlcAmmDlProcessSuccessfulReTx(gCb, rbCb, retx, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcRetx *retx;
rlcRemRetxPdu(gCb, rbCb, retx);
- RETVOID;
+ return;
}
/**
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer
+static Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer
(
RlcCb *gCb,
RlcAmDl *amDl,
RlcDlPduInfo *pduInfo
)
#else
-PRIVATE Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo)
+static Void rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer(gCb, amDl, retx, pduInfo)
RlcCb *gCb;
RlcAmDl *amDl;
RlcRetx **retx;
RlcDlPduInfo *pduInfo;
#endif
{
- TRC2(rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer);
-
RLC_ALLOC_WC(gCb,*retx, sizeof(RlcRetx));
if (*retx == NULLP)
{
RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
gRlcStats.amRlcStats.numDLRetransPdus++;
- RETVOID;
+ return;
} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
/**
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf
+static Void rlcAmmDlHndlStatus4SduByteSegInTxBuf
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo ** datCfm
)
#else
-PRIVATE Void rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm)
+static Void rlcAmmDlHndlStatus4SduByteSegInTxBuf(gCb, rbCb, nackSnInfo, retx, datCfm)
(
RlcCb *gCb;
RlcDlRbCb *rbCb;
CmLList *lnk;
CmLList *nextLnk;
- TRC2(rlcAmmDlHndlStatus4SduByteSegInTxBuf)
-
txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
lnk = txBuf->pduLst.first;
while(lnk)
rlcUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb);
}
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn
+static Void rlcAmmDlUpdateTxAndReTxBufForNackSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm)
+static Void rlcAmmDlUpdateTxAndReTxBufForNackSn(gCb, rbCb, nackSnInfo, retxNode, datCfm)
(
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcTx *txBuf;
RlcRetx *retx;
- TRC2(rlcAmmDlUpdateTxAndReTxBufForNackSn)
-
/* Now process the NACK_SN received. Now the NACK_SN is */
/* either the first element of RETX or is in TX array */
/* To remove the remaining acks from the pdu byte segments */
(*retxNode) = retx->lstEnt.next;
}
- RETVOID;
+ return;
}
/* process the pdus/segments in the re-transmit buffer with
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)
+static Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
(
RlcAmDl *amDl;
RlcNackInfo *nackInfo;
-CmLList *retxNode;
+CmLList *retxNode;
RlcNackInfo *nackSnInfo;
-U8 idx;
+uint8_t idx;
)
#endif
{
RlcRetx *retx;
CmLList *node;
- TRC2(RlcDlAmmGetNackSnInfoFrmNackRangeIdx)
-
nackSnInfo->isSegment = FALSE;
if((!nackInfo->isSegment) || (!idx && nackSnInfo->nackRange && (!nackInfo->soStart)))
{
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;
RlcKwuSapCb *rlckwuSap;
RlcSn mTxNext;
- TRC2(rlcAmmDlHndlStatusPdu)
rlcStatusPduCnt++;
rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
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 */
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 */
RlcSn transWinStartSn = 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;
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
canged inside the above called functions */
if (oldRetxBo != AMDL.retxBo)
{
- rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
}
- RETVOID;
+ return;
}
/**
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
*/
-#ifdef ANSI
-Void rlcAmmQSdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-Buffer *mBuf,
-KwuDatReqInfo *datReq
-)
-#else
-Void rlcAmmQSdu(gCb, rbCb, mBuf, datReq)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-Buffer *mBuf;
-KwuDatReqInfo *datReq;
-#endif
+void rlcAmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *mBuf, KwuDatReqInfo *datReq)
{
RlcSdu *sdu;
#ifdef LTE_L2_MEAS
#ifndef L2_L3_SPLIT
#ifdef TENB_STATS
- U32 rlcWinSz;
+ uint32_t rlcWinSz;
#endif
#endif
#endif
- TRC2(rlcAmmQSdu)
/* Allocate sdu */
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 */
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
* queue */
if (AMDL.nxtTx == NULLP)
{
- RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId,
- "rlcAmmQSdu: Received SDU will be transmitted next"
- "UEID:%d CELLID:%d",
- rbCb->rlcId.ueId,
- rbCb->rlcId.cellId);
+ DU_LOG("\nRLC : rlcAmmQSdu: Received SDU will be transmitted next \
+ UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
AMDL.nxtTx = sdu;
}
if(!rlcDlUtlIsReestInProgress(rbCb))
{
- rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
}
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmDlAssembleCntrlInfo
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcDatReq *rlcDatReq
-)
-#else
-PRIVATE Void rlcAmmDlAssembleCntrlInfo(gCb, rbCb, rlcDatReq)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcDatReq *rlcDatReq;
-#endif
+static void rlcAmmDlAssembleCntrlInfo(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcUdxDlSapCb *sapCb;
MsgLen macHdrEstmt;
- TRC2(rlcAmmDlAssembleCntrlInfo)
-
macHdrEstmt = (rbCb->m.amDl.cntrlBo < 256) ?
RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3;
/* Eliminate fixed hdr size (14bits including ACK_SN) */
rlcAmmCreateStatusPdu(gCb,rbCb,rlcDatReq);
sapCb = RLC_GET_DL_SAPCB(gCb, rbCb);
- rlcDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst),
+ rlcDlUdxStaProhTmrStart(&(gCb->u.dlCb->udxDlSap->pst),
sapCb->suId, &(rbCb->rlcId));
/* Update number of pdus in pduInfo */
gRlcStats.amRlcStats.numDLStaPduSent++;
}
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-Void rlcAmmProcessSdus
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcDatReq *rlcDatReq,
-Bool fillCtrlPdu
-)
-#else
-Void rlcAmmProcessSdus(gCb, rbCb, rlcDatReq,fillCtrlPdu)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcDatReq *rlcDatReq;
-Bool fillCtrlPdu;
-#endif
+void rlcAmmProcessSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq, bool fillCtrlPdu)
{
- TRC2(rlcAmmProcessSdus)
-
-
/* 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
}
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;
}
{
gRlcStats.amRlcStats.numDLBytesUnused += rlcDatReq->pduSz;
}
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcSplitPdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcRetx *crnt,
-RlcRetx *next,
-U16 size
-)
-#else
-PRIVATE Void rlcSplitPdu(gCb, rbCb, crnt, next, size)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcRetx *crnt;
-RlcRetx *next;
-U16 size;
-#endif
+static void rlcSplitPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcRetx *crnt, RlcRetx *next, uint16_t size)
{
- U8 si;
+ uint8_t si;
RlcAmDl *amDl = &AMDL;
- TRC2(rlcSplitPdu)
/* Set the SN for the new segment */
next->amHdr.sn = crnt->amHdr.sn;
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;
AMDL.nxtRetx = next;
amDl->estHdrSz += next->hdrSz;
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcResegRetxPdus
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcDatReq *rlcDatReq
-)
-#else
-PRIVATE Void rlcResegRetxPdus(gCb, rbCb, rlcDatReq)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcDatReq *rlcDatReq;
-#endif
+static void rlcResegRetxPdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcAmDl *amDl;
RlcRetx *retx;
- U8 hdr[RLC_MAX_HDRSZ];
- U16 idx;
+ uint8_t hdr[RLC_MAX_HDRSZ];
+ uint16_t idx;
Buffer *pdu;
MsgLen pduSz;
#ifdef LTE_L2_MEAS
- U16 sduIdx;
+ uint16_ sduIdx;
RlcL2MeasTb *l2MeasTb;
RlclchInfo *lchInfo;
- U8 numSdus;
+ uint8_t numSdus;
#endif
- TRC2(rlcResegRetxPdus)
-
-
amDl = &AMDL;
#ifdef LTE_L2_MEAS
/* TODO : This shoould be taken care in new Trasmissions */
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 >= RLC_MAX_ACTV_DRB)
{
- RETVOID;
+ return;
}
l2MeasTb->numLchInfo++;
lchInfo->lcId = rbCb->lch.lChId;
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 */
/* kw003.201 - We should have at least one more than basic header */
if (rlcDatReq->pduSz <= retx->hdrSz)
{
- RETVOID;
+ return;
}
rlcGetNxtRetx(gCb, &(amDl->nxtRetx));
/* Send retx buf without segmentation */
if (rlcDatReq->pduSz >= pduSz)
{
- U8 pollBit;
+ uint8_t pollBit;
- RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "rlcResegRetxPdus: 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 */
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;
}
/* Segment this pdu / portion of pdu. Insert this segment into */
/* retxLst and update offset */
- RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "rlcResegRetxPdus: 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 (rlcDatReq->pduSz <= 0)
{
- RETVOID;
+ return;
}
/* Allocate memory for tracking a new segment */
#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 */
#endif
/* Construct hdr with the available hdr values */
rlcConstructAmHdr(&retx->amHdr, hdr, amDl->snLen, &idx);
- SAddPreMsgMultInOrder(hdr, idx + 1, retx->seg);
+ ODU_ADD_PRE_MSG_MULT_IN_ORDER(hdr, idx + 1, retx->seg);
retx->hdrSz = idx + 1;
amDl->retxBo -= retx->segSz;
}
#ifndef ALIGN_64BIT
- RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "rlcResegRetxPdus: 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,
- "rlcResegRetxPdus: 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;
}
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAssembleSdus
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcDatReq *rlcDatReq
-)
-#else
-PRIVATE Void rlcAssembleSdus (gCb, rbCb, rlcDatReq)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcDatReq *rlcDatReq;
-#endif
+static void rlcAssembleSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
Buffer *pdu = NULLP;
MsgLen macGrntSz = rlcDatReq->pduSz;
RlcAmDl *amDl = &AMDL;
RlcSdu *sdu = amDl->nxtTx;
RlcSduMap sduMap;
- Bool nxtTxUpd = FALSE;
+ bool nxtTxUpd = FALSE;
KwuDiscSduInfo *discSduInfo = NULLP;
RlcKwuSapCb* rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
#ifdef LTE_L2_MEAS
RlcContSduLst contSduLst; /*Contained sduLst */
- S32 dataVol = amDl->bo;
- U32 *totMacGrant = &rlcDatReq->totMacGrant;
+ int32_t dataVol = amDl->bo;
+ uint32_t *totMacGrant = &rlcDatReq->totMacGrant;
RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
- U8 *sduIdx = &dlIpThPut->lastSduIdx;
- Bool newIdx;
- Bool isSduSegmented;
- S32 oldBo;
+ uint8_t *sduIdx = &dlIpThPut->lastSduIdx;
+ bool newIdx;
+ bool isSduSegmented;
+ int32_t oldBo;
RlclchInfo lchInfo;
RlclchInfo *dstLchInfo;
- U32 segSduCnt = 0;
- U32 lchIdx;
- U32 numSdus = 0;
- U32 currSduIdx = 0;
+ 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;
+ uint8_t numNewPdu = 0;
RlcTx *txBuf = NULLP;
/* Discard new changes ends */
- VOLATILE U32 startTime = 0;
- U32 hdrEstmt;
- U32 fixedHdrSz;
- U32 pduSz;
+ volatile uint32_t startTime = 0;
+ uint32_t hdrEstmt;
+ uint32_t fixedHdrSz;
+ uint32_t pduSz;
RlcAmHdr *amHdr = NULLP;
RlcDlPduInfo *pduInfo = NULLP;
- TRC2(rlcAssembleSdus)
-
-
#ifdef LTE_L2_MEAS
contSduLst.numSdus = 0;
contSduLst.lcId = rbCb->lch.lChId;
#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 */
/* 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;
}
sdu = NULLP;
/*stopping Task*/
- SStopTask(startTime, PID_RLC_AMM_DISC_SDUS);
+ ODU_STOP_TASK(startTime, PID_RLC_AMM_DISC_SDUS);
continue;
}
}
#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 */
#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 */
#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;
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,
- "rlcAssembleSdus: 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,
- "rlcAssembleSdus: 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 rlcAmmDlCheckAndSetPoll
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-Bool newPdu,
-MsgLen bufSz
-)
-#else
-PRIVATE Bool rlcAmmDlCheckAndSetPoll(gCb, rbCb, newPdu, bufSz)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-Bool newPdu;
-MsgLen bufSz;
-#endif
+static bool rlcAmmDlCheckAndSetPoll(RlcCb *gCb, RlcDlRbCb *rbCb, bool newPdu, MsgLen bufSz)
{
- Bool pollBit = FALSE;
+ bool pollBit = FALSE;
RlcAmDl *amDl = &(rbCb->m.amDl);
- TRC2(rlcAmmDlCheckAndSetPoll)
-
-
/* 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)
amDl->pollSn = (amDl->txNext - 1) & amDl->snModMask;
- RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "rlcAmmDlCheckAndSetPoll: 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
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmCreatePdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcAmHdr *amHdr,
-RlcDlPduInfo *pduInfo,
-Buffer *pdu
-)
-#else
-PRIVATE Void rlcAmmCreatePdu(gCb, rbCb, pduInfo, amHdr, pdu)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcAmHdr *amHdr;
-RlcDlPduInfo *pduInfo;
-Buffer *pdu;
-#endif
+static void rlcAmmCreatePdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmHdr *amHdr,
+RlcDlPduInfo *pduInfo, Buffer *pdu)
{
- U8 hdr[RLC_MAX_HDRSZ];
- U16 idx;
+ uint8_t hdr[RLC_MAX_HDRSZ];
+ uint16_t idx;
RlcTx *txBuf;
- MsgLen pduSz;
+ MsgLen pduSz;
RlcAmDl *amDl = &(rbCb->m.amDl);
- TRC2(rlcAmmCreatePdu)
-
-
/* Update sn */
amHdr->sn = amDl->txNext;
}
/* Update hdr Info */
- SFndLenMsg(pdu, &pduSz);
+ ODU_GET_MSG_LEN(pdu, &pduSz);
/* passing newPDU = TRUE*/
amHdr->p = rlcAmmDlCheckAndSetPoll(gCb,rbCb, TRUE, pduSz);
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 = rlcUtlGetTxBuf(amDl->txBufLst, amHdr->sn);
rlcCpyMsg(gCb,pdu,&(pduInfo->pdu));
gCb->genSts.bytesSent += pduSz;
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcRemRetxPdu
+static Void rlcRemRetxPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx
)
#else
-PRIVATE Void rlcRemRetxPdu(gCb, rbCb, retx)
+static Void rlcRemRetxPdu(gCb, rbCb, retx)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcRetx *retx;
#endif
{
- TRC2(rlcRemRetxPdu)
-
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
if( AMDL.retxLst.count == 0)
rlcUtlAddReTxPduToBeFreedQueue(gCb, retx);
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlMarkPduForReTx
+static Void rlcAmmDlMarkPduForReTx
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx
)
#else
-PRIVATE Void rlcAmmDlMarkPduForReTx(*gCb, rbCb, retx)
+static Void rlcAmmDlMarkPduForReTx(*gCb, rbCb, retx)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcRetx *retx;
#endif
{
- TRC2(rlcAmmDlMarkPduForReTx)
if (AMDL.maxReTxReached == TRUE)
{
- RETVOID;
+ return;
}
if(retx->pendingReTrans == FALSE)
rbCb->m.amDl.cntrlBo = 0;
rbCb->m.amDl.retxBo = 0;
/* Sending BO update to SCH */
- rlcUtlSndDStaRsp(gCb, rbCb, 0,0,0,0);
+ rlcUtlSendDedLcBoStatus(gCb, rbCb, 0,0,0,0);
rlcAmmSndStaInd(gCb, rbCb, retx);
gRlcStats.amRlcStats.numDLMaxRetx++;
}
rlcRemRetxPdu(gCb,rbCb, retx);
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlCheckIsSDUDelivered
+static Void rlcAmmDlCheckIsSDUDelivered
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm)
+static Void rlcAmmDlCheckIsSDUDelivered(gCb, rbCb, sduMap, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcSduMap *sduMap;
{
RlcSdu *sdu;
- TRC2(rlcAmmDlCheckIsSDUDelivered)
-
sdu = sduMap->sdu;
sdu->mode.am.rcvdSz += sduMap->sduSz;
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
rlcUtlRaiseDlCleanupEvent(gCb);
}
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu
+static Void rlcAmmDlProcessSuccessfulTxPdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void rlcAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm)
+static Void rlcAmmDlProcessSuccessfulTxPdu(gCb, rbCb, sn, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcSn sn;
KwuDatCfmInfo **datCfm;
#endif
{
- TRC2(rlcAmmDlProcessSuccessfulTxPdu)
CmLList *pduNode;
RlcTx *txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
pduNode = txBuf->pduLst.first;
while(pduNode)
/* so that it is not processed again */
rlcUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb);
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmSndStaInd
+static Void rlcAmmSndStaInd
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcRetx *retx
)
#else
-PRIVATE Void rlcAmmSndStaInd(gCb, rbCb, retx)
+static Void rlcAmmSndStaInd(gCb, rbCb, retx)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcRetx *retx;
KwuStaIndInfo *staInd;
RlcKwuSapCb *rlckwuSap;
- TRC2(rlcAmmSndStaInd);
-
-
/* Sap control block */
rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
"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
*
*/
-#ifdef ANSI
-PRIVATE Void rlcGetNxtRetx
-(
-RlcCb *gCb,
-RlcRetx **retx
-)
-#else
-PRIVATE Void rlcGetNxtRetx(gCb, retx)
-RlcCb *gCb;
-RlcRetx **retx;
-#endif
+static void rlcGetNxtRetx(RlcCb *gCb, RlcRetx **retx)
{
CmLList *tNode;
- TRC2(rlcGetNxtRetx);
-
do
{
tNode = &((*retx)->lstEnt);
else
{
*retx = NULLP;
- RETVOID;
+ return;
}
}while((*retx)->pendingReTrans == FALSE);
- RETVOID;
+ return;
}
/**
/* 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 */
"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;
}
/**
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 sduId
+uint32_t sduId
)
#else
S16 rlcAmmDiscSdu(gCb, rbCb, sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 sduId;
+uint32_t sduId;
#endif
{
- TRC2(rlcAmmDiscSdu);
return (RFAILED);
}
RlcAmDl *amDl = &(rbCb->m.amDl);
RlcSn sn;
RlcTx *txBuf;
- TRC2(rlcAmmPollRetxTmrExp);
-
/* 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, */
AMDL.nxtRetx = retx;
}
- rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
- RETVOID;
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
+ return;
}
/* Get the last node in retxLst */
RLC_LLIST_LAST_RETX(amDl->retxLst, retx);
if (retx != NULLP)
{
rlcAmmDlMarkPduForReTx(gCb, rbCb, retx);
- rlcAmmSendDStaRsp(gCb, rbCb, &AMDL);
+ rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
}
}
- RETVOID;
+ return;
}
/**
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn
+static Void rlcAmmDlUpdateTxAndReTxBufForAckSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm)
+static Void rlcAmmDlUpdateTxAndReTxBufForAckSn(gCb, rbCb, mAckSn, retxNode, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcSn mAckSn;
RlcRetx *retx;
RlcTx *txBuf;
- TRC2(rlcAmmDlUpdateTxAndReTxBufForAckSn);
-
/* Remove pdus/segs from retxLst */
while (retxNode)
{
MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask);
}
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn
+static Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwuDatCfmInfo **datCfm
)
#else
-PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm)
+static Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn(gCb, rbCb, sn, mNackSn, retxNode, datCfm)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcSn sn;
RlcRetx *retx;
RlcTx *txBuf=NULLP;
- TRC2(rlcAmmDlUpdTxAndReTxBufForLessThanNackSn);
-
while (*retxNode)
{
retx = (RlcRetx *)((*retxNode)->node);
MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask);
}
- RETVOID;
+ return;
}
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcConstructAmHdr
-(
-RlcAmHdr *amHdr,
-U8 *hdr,
-U8 snLen,
-U16 *idx
-)
-#else
-PRIVATE Void rlcConstructAmHdr(amHdr, hdr, snLen, idx)
-RlcAmHdr *amHdr;
-U8 *hdr;
-U8 snLen;
-U16 *idx;
-#endif
+static void rlcConstructAmHdr(RlcAmHdr *amHdr, uint8_t *hdr, uint8_t snLen, uint16_t *idx)
{
- TRC2(rlcConstructAmHdr);
-
*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);
}
- RETVOID;
+ return;
}
/**
*
*/
#ifdef ANSI
-PRIVATE Void rlcAmmAddPduToRetxLst
+static Void rlcAmmAddPduToRetxLst
(
RlcAmDl *amDl,
RlcRetx *retx
)
#else
-PRIVATE Void rlcAmmAddPduToRetxLst(amDl, retx)
+static Void rlcAmmAddPduToRetxLst(amDl, retx)
RlcAmDl *amDl;
RlcRetx *retx;
#endif
RlcSn tMSn;
RlcSn retxMSn;
- TRC2(rlcAmmAddPduToRetxLst);
-
node = amDl->retxLst.last;
MODAMT(retx->amHdr.sn, retxMSn, amDl->txNextAck,amDl->snModMask);
while(node != NULLP)
amDl->nxtRetx = retx;
}
- RETVOID;
+ return;
}
/**
*/
#ifdef ANSI
-PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer
+static Void rlcAmmDlMoveFrmTxtoRetxBuffer
(
RlcCb *gCb,
RlcAmDl *amDl,
RlcSn sn
)
#else
-PRIVATE Void rlcAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn)
+static Void rlcAmmDlMoveFrmTxtoRetxBuffer(gCb, amDl, retx, sn)
RlcCb *gCb;
RlcAmDl *amDl;
RlcRetx **retx;
#endif
{
RlcTx* txBuf = rlcUtlGetTxBuf(amDl->txBufLst, sn);
- TRC2(rlcAmmDlMoveFrmTxtoRetxBuffer);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
while(txBuf->pduLst.first)
{
if (*retx == NULLP)
{
RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
/* Remove PDU from txBuf */
rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
- RETVOID;
+ return;
}
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
* @return Void
*
*/
-#ifdef ANSI
-PRIVATE Void rlcAmmCreateStatusPdu
-(
-RlcCb *gCb,
-RlcDlRbCb *rbCb,
-RlcDatReq *rlcDatReq
-)
-#else
-PRIVATE Void rlcAmmCreateStatusPdu(gCb, rbCb, rlcDatReq)
-RlcCb *gCb;
-RlcDlRbCb *rbCb;
-RlcDatReq *rlcDatReq;
-#endif
+static void rlcAmmCreateStatusPdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcSn sn; /* sequence number */
RlcSn ack_sn; /* Ack sequence number */
Buffer *mBuf; /* control pdu buffer */
MsgLen cntrlPduSz; /* control pdu size */
- U8 cntrlPdu[RLC_MAX_CNTRL_FIELDS]; /* control pdu to be added to mBuf */
+ uint8_t cntrlPdu[RLC_MAX_CNTRL_FIELDS]; /* control pdu to be added to mBuf */
RlcUdxDlStaPdu *pStaPdu;
- U16 bytesToEncode = 0; /* bytes required to encode the STATUS PDU */
- U16 encIdx = 0;
- U16 prevEncIdx = 0;
+ uint16_t bytesToEncode = 0; /* bytes required to encode the STATUS PDU */
+ uint16_t encIdx = 0;
+ uint16_t prevEncIdx = 0;
RlcNackInfo *rlcNackInfo;
- U16 nkCnt = 0;
-
- TRC2(rlcAmmCreateStatusPdu)
-
+ uint16_t nkCnt = 0;
pStaPdu = AMDL.pStaPdu;
/* set ACK SN */
{
- RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "rlcAssembleCntrlInfo: 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;
}
}
}
/* 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 */
{
- RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "rlcAssembleCntrlInfo: 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,
- "rlcAssembleCntrlInfo: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);
}
#endif
cntrlPduSz = encIdx;
- SAddPstMsgMult (cntrlPdu, cntrlPduSz, mBuf);
+ ODU_ADD_POST_MSG_MULT(cntrlPdu, cntrlPduSz, mBuf);
rlcDatReq->pduSz -= cntrlPduSz;
/* Add mBuf to AMDL.mBuf */
AMDL.mBuf = mBuf;
- RETVOID;
+ return;
}
#ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
#ifdef ANSI
-PRIVATE Void rgAmmExtractElmnt
+static Void rgAmmExtractElmnt
(
RlcCb *gCb,
Buffer *pdu,
RlcExtHdr *hdrInfo
)
#else
-PRIVATE Void rgAmmExtractElmnt(gCb, pdu, hdrInfo)
+static Void rgAmmExtractElmnt(gCb, pdu, hdrInfo)
RlcCb *gCb;
Buffer *pdu;
RlcExtHdr *hdrInfo;
#endif
{
- 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(rlcAmmExtractElmnt);
+ 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,
Buffer *cntrlPdu,
-U8 *fByte
+uint8_t *fByte
)
#else
-PRIVATE Void rgAmmUlHndlStatusPdu(udxPst,suId,gCb, rbCb, cntrlPdu, fByte)
+static Void rgAmmUlHndlStatusPdu(udxPst,suId,gCb, rbCb, cntrlPdu, fByte)
Pst *udxPst;
SuId suId;
RlcCb *gCb;
RlcDlRbCb *rbCb;
Buffer *cntrlPdu;
-U8 *fByte;
+uint8_t *fByte;
#endif
{
- U8 e1;
+ uint8_t e1;
RlcExtHdr hdrInfo;
RlcUdxStaPdu *pStaPdu;
- U8 e3; /* NACK RANGE : 5GNR */
- U32 snLen;
- U32 snRange;
- U32 resrvdBitsAckSn;
- U32 resrvdBitsNackSn;
-
-
- TRC2(rgAmmUlHndlStatusPdu)
+ 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;