//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));
-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;
}
}
- 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
{
- 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,
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;
- 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;
}
/**
* @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;
- 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
-)
-#else
-PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
-(
-RlcAmDl *amDl;
-RlcNackInfo *nackInfo;
-CmLList *retxNode;
-RlcNackInfo *nackSnInfo;
-U8 idx;
+uint8_t idx
)
-#endif
{
RlcTx *txBuf;
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;
*
* @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;
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
rlcAmmSendDedLcBoStatus(gCb, rbCb, &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)
{
#ifndef RGL_SPECIFIC_CHANGES
#ifdef MSPD
{
-extern uint32_t dlrate_kwu;
+uint32_t dlrate_kwu;
dlrate_kwu += sdu->sduSz;
}
#endif
* @return Void
*
*/
-void rlcAmmDlAssembleCntrlInfo(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
+static void rlcAmmDlAssembleCntrlInfo(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcUdxDlSapCb *sapCb;
MsgLen macHdrEstmt;
* @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;
* @return Void
*
*/
-void rlcResegRetxPdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
+static void rlcResegRetxPdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *rlcDatReq)
{
RlcAmDl *amDl;
RlcRetx *retx;
* @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;
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;
* -# 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);
* @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];
* @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)
{
- TRC2(rlcRemRetxPdu)
-
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
if( AMDL.retxLst.count == 0)
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)
{
- TRC2(rlcAmmDlMarkPduForReTx)
if (AMDL.maxReTxReached == TRUE)
{
- RETVOID;
+ return;
}
if(retx->pendingReTrans == FALSE)
rlcRemRetxPdu(gCb,rbCb, retx);
- RETVOID;
+ return;
}
}
- 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;
- 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;
}
/**
* @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
{
- 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;
}
/**
* @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;
- 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
*
*/
-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 */
"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 )
{
- TRC2(rlcAmmDiscSdu);
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);
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, */
}
rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
- RETVOID;
+ return;
}
/* Get the last node in retxLst */
RLC_LLIST_LAST_RETX(amDl->retxLst, retx);
}
}
- 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;
RlcRetx *retx;
RlcTx *txBuf;
- TRC2(rlcAmmDlUpdateTxAndReTxBufForAckSn);
-
/* Remove pdus/segs from retxLst */
while (retxNode)
{
MODAMT(sn, mSn, AMDL.txNextAck,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;
RlcTx *txBuf=NULLP;
- TRC2(rlcAmmDlUpdTxAndReTxBufForLessThanNackSn);
-
while (*retxNode)
{
retx = (RlcRetx *)((*retxNode)->node);
MODAMT(sn, mSn, AMDL.txNextAck,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;
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,
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);
- 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;
}
*
* @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))
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 */
"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)
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;
-
- 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,
+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;
-
-
- 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;
Code Review / o-du / l2.git / blobdiff