Desc: Source code for RLC Unacknowledged mode assembly and
reassembly.This file contains following functions
- --kwUmmQSdu
- --kwUmmProcessSdus
- --kwUmmProcessPdus
- --kwUmmReAssembleSdus
+ --rlcUmmQSdu
+ --rlcUmmProcessSdus
+ --rlcUmmProcessPdus
+ --rlcUmmReAssembleSdus
--kwUmmReEstablish
File: kw_umm_ul.c
#include "kw.x" /* RLC layer */
#include "kw_ul.x"
-#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_UL)
+#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_UL)
-PRIVATE S16 kwUmmExtractHdr ARGS ((RlcCb *gCb,
+PRIVATE S16 rlcUmmExtractHdr ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
- KwUmHdr *umHdr));
+ RlcUmHdr *umHdr));
-PRIVATE Void kwUmmReAssembleSdus ARGS ((RlcCb *gCb,
+PRIVATE Void rlcUmmReAssembleSdus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwUmRecBuf *umRecBuf));
+ RlcUmRecBuf *umRecBuf));
#ifndef TENB_ACC
#ifndef LTE_PAL_ENB
*
* @return Void
*/
-PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn)
+PRIVATE Void rlcUmmFindNextVRUR (RlcUmUl* umUl, RlcSn nextSn)
{
- KwSn ur = KW_UM_GET_VALUE(umUl->vrUr, *umUl);
+ RlcSn ur = RLC_UM_GET_VALUE(umUl->vrUr, *umUl);
- KwSn nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl);
+ RlcSn nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
while (ur < nextSnToCompare)
{
break;
}
nextSn = (nextSn + 1) & umUl->modBitMask;
- nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl);
+ nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
}
}
*
* @return Void
*/
-PRIVATE S16 kwUmmCheckSnInReordWindow (KwSn sn,
- CONSTANT KwUmUl* CONSTANT umUl)
+PRIVATE S16 rlcUmmCheckSnInReordWindow (RlcSn sn,
+ CONSTANT RlcUmUl* CONSTANT umUl)
{
- return (KW_UM_GET_VALUE(sn, *umUl) < KW_UM_GET_VALUE(umUl->vrUh, *umUl));
+ return (RLC_UM_GET_VALUE(sn, *umUl) < RLC_UM_GET_VALUE(umUl->vrUh, *umUl));
}
/**
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void kwUmmProcessPdus
+Void rlcUmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb, /* Rb Control Block */
U32 ttiCnt /* ttiCnt received from MAC */
)
#else
-PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo,ttiCnt)
+Void rlcUmmProcessPdus(rbCb,pduInfo,ttiCnt)
RlcCb *gCb;
RlcUlRbCb *rbCb; /* Rb Control Block */
KwPduInfo *pduInfo; /* Pdu data and related information */
#endif
#else
#ifdef ANSI
-PUBLIC Void kwUmmProcessPdus
+Void rlcUmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb, /* Rb Control Block */
KwPduInfo *pduInfo /* Pdu data and related information */
)
#else
-PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo)
+Void rlcUmmProcessPdus(rbCb,pduInfo)
RlcCb *gCb;
RlcUlRbCb *rbCb; /* Rb Control Block */
KwPduInfo *pduInfo; /* Pdu data and related information */
#endif
#endif
{
- KwSn *vrUh; /* vr(uh) */
- KwSn *vrUr; /* vr(ur) */
- KwSn *vrUx; /* vr(ux) */
+ RlcSn *vrUh; /* vr(uh) */
+ RlcSn *vrUr; /* vr(ur) */
+ RlcSn *vrUx; /* vr(ux) */
U16 curSn; /* Current Sequence Number */
U32 pduCount; /* PDU count */
U32 count; /* Loop counter */
- KwUmRecBuf **recBuf; /* UM Reception Buffer */
+ RlcUmRecBuf **recBuf; /* UM Reception Buffer */
Bool tmrRunning; /* Boolean for checking Tmr */
/* kw005.201 added support for L2 Measurement */
- TRC2(kwUmmProcessPdus)
+ TRC2(rlcUmmProcessPdus)
count = 0;
while (count < pduCount)
{
- KwSn ur;
- KwSn uh;
- KwSn seqNum;
+ RlcSn ur;
+ RlcSn uh;
+ RlcSn seqNum;
Buffer *pdu = pduInfo->mBuf[count];
- KwUmRecBuf *tmpRecBuf;
+ RlcUmRecBuf *tmpRecBuf;
gCb->genSts.pdusRecv++;
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_ACC
#endif
#endif
/* create a buffer to be later inserted into the reception buffer */
- RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tmpRecBuf == NULLP)
{
extern U32 rlculdrop;
rlculdrop++;
RLC_FREE_BUF(pdu);
- RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
/*Fix for CR ccpu00144030: If threshhold is hit then also count
*should be incrmented */
count++;
#endif
#endif
/* get the pdu header */
- if (kwUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))
+ if (rlcUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))
{
RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
"Header Extraction Failed UEID:%d CELLID:%d",
/* Header extraction is a problem.
* log an error and free the allocated memory */
/* ccpu00136940 */
- RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
SPutMsg(pdu);
count++;
/* kw005.201 ccpu00117318, updating the statistics */
curSn = tmpRecBuf->umHdr.sn;
/* Check if the PDU should be discarded or not */
- ur = KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL);
- uh = KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL);
- seqNum = KW_UM_GET_VALUE(curSn, KW_UMUL);
+ ur = RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL);
+ uh = RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL);
+ seqNum = RLC_UM_GET_VALUE(curSn, RLC_UMUL);
- if (((ur < seqNum) && (seqNum < uh) && (KW_UMUL.recBuf[curSn])) ||
+ if (((ur < seqNum) && (seqNum < uh) && (RLC_UMUL.recBuf[curSn])) ||
(seqNum < ur))
{
/* PDU needs to be discarded */
rbCb->rlcId.cellId);
RLC_FREE_BUF(pdu);
- RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
count++;
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.unexpPdusRecv++;
#ifdef LTE_L2_MEAS
/* kw006.201 ccpu00120058, reduced code complexity by adding new function */
- kwUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
+ rlcUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
#endif
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.bytesRecv += recBuf[curSn]->pduSz;
- if (!kwUmmCheckSnInReordWindow(curSn,&KW_UMUL))
+ if (!rlcUmmCheckSnInReordWindow(curSn,&RLC_UMUL))
{ /* currSn is outside re-ordering window */
- *vrUh = (curSn + 1) & KW_UMUL.modBitMask;
+ *vrUh = (curSn + 1) & RLC_UMUL.modBitMask;
/* re-assemble all pdus outside the modified re-ordering window */
/* the first SN is VR(UR) */
- if (!kwUmmCheckSnInReordWindow(*vrUr,&KW_UMUL))
+ if (!rlcUmmCheckSnInReordWindow(*vrUr,&RLC_UMUL))
{
/* TODO : should it be VR(UR) + 1 ?... check, earlier it was so */
- KwSn sn = *vrUr; /* SN's which need to be re-assembled */
- KwSn lowerEdge; /* to hold the lower-edge of the
+ RlcSn sn = *vrUr; /* SN's which need to be re-assembled */
+ RlcSn lowerEdge; /* to hold the lower-edge of the
re-ordering window */
/* The new value ov VR(UR) is the lower end of the window i
* and SN's still this value need to be re-assembled */
- *vrUr = (*vrUh - KW_UMUL.umWinSz) & KW_UMUL.modBitMask;
- lowerEdge = KW_UM_GET_VALUE(*vrUr ,KW_UMUL);
+ *vrUr = (*vrUh - RLC_UMUL.umWinSz) & RLC_UMUL.modBitMask;
+ lowerEdge = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
- while (KW_UM_GET_VALUE(sn, KW_UMUL) < lowerEdge)
+ while (RLC_UM_GET_VALUE(sn, RLC_UMUL) < lowerEdge)
{
if (recBuf[sn])
{
- kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
- RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
+ RLC_FREE_WC(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
recBuf[sn] = NULLP;
}
- sn = (sn + 1) & KW_UMUL.modBitMask;
+ sn = (sn + 1) & RLC_UMUL.modBitMask;
}
}
}
if (recBuf[*vrUr])
{
- KwSn sn = *vrUr;
- KwSn tSn = KW_UM_GET_VALUE(sn,KW_UMUL);
- KwSn tVrUr;
+ RlcSn sn = *vrUr;
+ RlcSn tSn = RLC_UM_GET_VALUE(sn,RLC_UMUL);
+ RlcSn tVrUr;
/* set VR(UR) to next SN > current VR(UR) which is not received */
- KwSn nextVrUr = (*vrUr + 1) & KW_UMUL.modBitMask;
- kwUmmFindNextVRUR(&KW_UMUL, nextVrUr);
+ RlcSn nextVrUr = (*vrUr + 1) & RLC_UMUL.modBitMask;
+ rlcUmmFindNextVRUR(&RLC_UMUL, nextVrUr);
/* re-assemble SDUs with SN < Vr(UR) */
- tVrUr = KW_UM_GET_VALUE(*vrUr,KW_UMUL);
+ tVrUr = RLC_UM_GET_VALUE(*vrUr,RLC_UMUL);
while (recBuf[sn] && tSn < tVrUr)
{
- kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
- RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
+ RLC_FREE_WC(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
recBuf[sn] = NULLP;
- sn = (sn + 1) & KW_UMUL.modBitMask;
- tSn = KW_UM_GET_VALUE(sn, KW_UMUL);
+ sn = (sn + 1) & RLC_UMUL.modBitMask;
+ tSn = RLC_UM_GET_VALUE(sn, RLC_UMUL);
}
}
- tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_UMUL_REORD_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_UMUL_REORD_TMR);
if (tmrRunning)
{
- KwSn tVrUx = KW_UM_GET_VALUE(*vrUx, KW_UMUL);
- KwSn tVrUr = KW_UM_GET_VALUE(*vrUr ,KW_UMUL);
+ RlcSn tVrUx = RLC_UM_GET_VALUE(*vrUx, RLC_UMUL);
+ RlcSn tVrUr = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
- KwSn tVrUh = KW_UM_GET_VALUE(*vrUh, KW_UMUL);
+ RlcSn tVrUh = RLC_UM_GET_VALUE(*vrUh, RLC_UMUL);
- S16 ret = kwUmmCheckSnInReordWindow(*vrUx, &KW_UMUL);
+ S16 ret = rlcUmmCheckSnInReordWindow(*vrUx, &RLC_UMUL);
if ( (tVrUx <= tVrUr) || ((!ret) && (tVrUx != tVrUh)))
{
- kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
tmrRunning = FALSE;
}
}
if (!tmrRunning)
{
- if (KW_UM_GET_VALUE(*vrUh, KW_UMUL) > KW_UM_GET_VALUE(*vrUr, KW_UMUL))
+ if (RLC_UM_GET_VALUE(*vrUh, RLC_UMUL) > RLC_UM_GET_VALUE(*vrUr, RLC_UMUL))
{
- kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
*vrUx = *vrUh;
}
}
count++;
}/* end while count < pduCount */
#ifdef LTE_L2_MEAS
- kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
+ rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
#endif /* LTE_L2_MEAS */
RETVOID;
}
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwUmmReAssembleSdus
+PRIVATE Void rlcUmmReAssembleSdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwUmRecBuf *umRecBuf
+RlcUmRecBuf *umRecBuf
)
#else
-PRIVATE Void kwUmmReAssembleSdus(gCb,rbCb,umRecBuf)
+PRIVATE Void rlcUmmReAssembleSdus(gCb,rbCb,umRecBuf)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwUmRecBuf *umRecBuf;
+RlcUmRecBuf *umRecBuf;
#endif
{
U32 liCount; /* LI count */
Buffer *remPdu; /* Remaining PDU */
Buffer **partialSdu; /* Partial SDU */
- TRC2(kwUmmReAssembleSdus)
+ TRC2(rlcUmmReAssembleSdus)
liCount = umRecBuf->umHdr.numLi;
RLC_FREE_BUF(sdu);
if (liCount > 0 || !(fi & 1))
{
- kwUtlSndDatInd(gCb,rbCb,*partialSdu);
+ rlcUtlSndDatInd(gCb,rbCb,*partialSdu);
*partialSdu = NULLP;
}
}
if (liCount > 0 || !( fi & 1))
{
- kwUtlSndDatInd(gCb,rbCb,sdu);
+ rlcUtlSndDatInd(gCb,rbCb,sdu);
}
else
{
}
else
{
- kwUtlSndDatInd(gCb, rbCb, sdu);
+ rlcUtlSndDatInd(gCb, rbCb, sdu);
}
}
/*
just send the SDU to the upper layer */
else
{
- kwUtlSndDatInd(gCb, rbCb, sdu);
+ rlcUtlSndDatInd(gCb, rbCb, sdu);
}
}
rbCb->m.umUl.sn = sn;
* - If direction of the RB is downlink :
* Remove all the SDUs in the SDU queue.
* - If direction of the RB is uplink :
- * Call kwUmmReAssembleSdus() for each PDU with SN < VR(UH)
+ * Call rlcUmmReAssembleSdus() for each PDU with SN < VR(UH)
*
* @param[in] gCb RLC Instance control block
* @param[in] rlcID Identity of the RLC entity for which
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmUlReEstablish
+Void rlcUmmUlReEstablish
(
RlcCb *gCb,
CmLteRlcId *rlcId,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmUlReEstablish(gCb, rlcId, rbCb)
+Void rlcUmmUlReEstablish(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId *rlcId;
RlcUlRbCb *rbCb;
#endif
{
- KwSn curSn;
- KwSn vrUh;
- KwUmRecBuf **recBuf; /* UM Reception Buffer */
- KwKwuSapCb *kwKwSap; /* KWU SAP Information */
+ RlcSn curSn;
+ RlcSn vrUh;
+ RlcUmRecBuf **recBuf; /* UM Reception Buffer */
+ RlcKwuSapCb *rlcKwSap; /* KWU SAP Information */
- TRC2(kwUmmUlReEstablish)
+ TRC2(rlcUmmUlReEstablish)
curSn = rbCb->m.umUl.vrUr;
- vrUh = KW_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
+ vrUh = RLC_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
recBuf = rbCb->m.umUl.recBuf;
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
}
- while (KW_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
+ while (RLC_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
{
if ( recBuf[curSn] != NULLP )
{
- kwUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
- RLC_FREE_WC(gCb,recBuf[curSn],sizeof(KwUmRecBuf));
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
+ RLC_FREE_WC(gCb,recBuf[curSn],sizeof(RlcUmRecBuf));
recBuf[curSn] = NULLP;
}
curSn = (curSn + 1) & rbCb->m.umUl.modBitMask;
rbCb->m.umUl.vrUh = 0;
rbCb->m.umUl.vrUx = 0;
- kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
+ rlcKwSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
/* In the UM Mode always send reestablish-indication to Upper Latyer*/
- KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, *rlcId);
+ RlcUiKwuReEstCmpInd(&rlcKwSap->pst, rlcKwSap->suId, *rlcId);
RETVOID;
}
* -# FALSE
*/
#ifdef ANSI
-PRIVATE S16 kwUmmExtractHdr
+PRIVATE S16 rlcUmmExtractHdr
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
-KwUmHdr *umHdr
+RlcUmHdr *umHdr
)
#else
-PRIVATE S16 kwUmmExtractHdr(gCb, rbCb, pdu, umHdr)
+PRIVATE S16 rlcUmmExtractHdr(gCb, rbCb, pdu, umHdr)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *pdu;
-KwUmHdr *umHdr;
+RlcUmHdr *umHdr;
#endif
{
U8 e; /* Extension Bit */
S16 ret; /* Return Value */
#endif
- TRC3(kwUmmExtractHdr)
+ TRC3(rlcUmmExtractHdr)
SFndLenMsg(pdu,&pduSz);
umHdr->numLi = 0;
totalSz = 0;
- while(e && umHdr->numLi < KW_MAX_UL_LI )
+ while(e && umHdr->numLi < RLC_MAX_UL_LI )
{
#if (ERRCLASS & ERRCLS_DEBUG)
ret = SRemPreMsgMult(dst,2,pdu);
e = ((dst[0]) & 0x80) >> 7;
- if ( e && umHdr->numLi < KW_MAX_UL_LI)
+ if ( e && umHdr->numLi < RLC_MAX_UL_LI)
{
U8 tmp = ((dst[1]) & 0x08) >> 3;
umHdr->li[umHdr->numLi] = ( dst[1] & 0x07) << 8;
e = tmp;
}
- } /* while(e && umHdr->numLi < KW_MAX_LI ) */
+ } /* while(e && umHdr->numLi < RLC_MAX_LI ) */
if (e)
{
- /* PDU was constructed with LIs that exceeded KW_MAX_LI */
+ /* PDU was constructed with LIs that exceeded RLC_MAX_LI */
return RFAILED;
}
return ROK;
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmReOrdTmrExp
+Void rlcUmmReOrdTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmReOrdTmrExp(gCb, rbCb)
+Void rlcUmmReOrdTmrExp(gCb, rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwSn prevVrUr; /* prevVrUr */
+ RlcSn prevVrUr; /* prevVrUr */
- TRC3(kwUmmReOrdTmrExp)
+ TRC3(rlcUmmReOrdTmrExp)
- prevVrUr = KW_UMUL.vrUr;
+ prevVrUr = RLC_UMUL.vrUr;
/* set VR(UR) to SN >= VR(UX) that has not been received */
- kwUmmFindNextVRUR(&KW_UMUL, KW_UMUL.vrUx);
+ rlcUmmFindNextVRUR(&RLC_UMUL, RLC_UMUL.vrUx);
- while (KW_UM_GET_VALUE(prevVrUr,KW_UMUL) <
- KW_UM_GET_VALUE(KW_UMUL.vrUr,KW_UMUL))
+ while (RLC_UM_GET_VALUE(prevVrUr,RLC_UMUL) <
+ RLC_UM_GET_VALUE(RLC_UMUL.vrUr,RLC_UMUL))
{
- if (KW_UMUL.recBuf[prevVrUr])
+ if (RLC_UMUL.recBuf[prevVrUr])
{
- kwUmmReAssembleSdus(gCb, rbCb, KW_UMUL.recBuf[prevVrUr]);
- if(KW_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
+ rlcUmmReAssembleSdus(gCb, rbCb, RLC_UMUL.recBuf[prevVrUr]);
+ if(RLC_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
{
- RLC_FREE_BUF(KW_UMUL.recBuf[prevVrUr]->pdu);
+ RLC_FREE_BUF(RLC_UMUL.recBuf[prevVrUr]->pdu);
}
- RLC_FREE_WC(gCb, KW_UMUL.recBuf[prevVrUr], sizeof(KwUmRecBuf));
- KW_UMUL.recBuf[prevVrUr] = NULLP;
+ RLC_FREE_WC(gCb, RLC_UMUL.recBuf[prevVrUr], sizeof(RlcUmRecBuf));
+ RLC_UMUL.recBuf[prevVrUr] = NULLP;
}
prevVrUr = (prevVrUr + 1) & rbCb->m.umUl.modBitMask;
}
- if (KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL) >
- KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL))
+ if (RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL) >
+ RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL))
{
- kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
- KW_UMUL.vrUx = KW_UMUL.vrUh;
+ rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
+ RLC_UMUL.vrUx = RLC_UMUL.vrUh;
}
}
*/
#ifdef ANSI
-PUBLIC Void kwUmmFreeUlRbCb
+Void rlcUmmFreeUlRbCb
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmFreeUlRbCb(gCb,rbCb)
+Void rlcUmmFreeUlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwSn curSn = 0; /* sequence number of PDU */
- KwSn windSz; /* PDU window size */
- KwUmRecBuf **umRecBuf; /* UM module receive buffer */
+ RlcSn curSn = 0; /* sequence number of PDU */
+ RlcSn windSz; /* PDU window size */
+ RlcUmRecBuf **umRecBuf; /* UM module receive buffer */
- TRC2(kwUmmFreeUlRbCb)
+ TRC2(rlcUmmFreeUlRbCb)
windSz = rbCb->m.umUl.umWinSz << 1;
umRecBuf = rbCb->m.umUl.recBuf;
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
}
while (curSn < windSz)
{
RLC_FREE_BUF_WC(umRecBuf[curSn]->pdu);
umRecBuf[curSn]->pdu = NULLP;
- RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(KwUmRecBuf));
+ RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(RlcUmRecBuf));
umRecBuf[curSn] = NULLP;
}
curSn++;
}
- RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(KwUmRecBuf*));
+ RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(RlcUmRecBuf*));
rbCb->m.umUl.recBuf = NULLP;
RETVOID;
}
Code Review / o-du / l2.git / blobdiff