/** @file gp_amm_ul.c
@brief RLC Acknowledged Mode Uplink Module
**/
-#define KW_MODULE (KW_DBGMASK_AM | KW_DBGMASK_UL) /* for debugging purpose */
+#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_UL) /* for debugging purpose */
/* private function declarations */
-PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
+PRIVATE Void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
-PRIVATE S16 kwAmmExtractHdr ARGS ((RlcCb *gCb,
+PRIVATE S16 rlcAmmExtractHdr ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
- KwAmHdr *amHdr,
+ RlcAmHdr *amHdr,
U8 *fByte));
-PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
+PRIVATE Bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
Buffer *pdu,
RlcUlRbCb *rbCb,
- KwAmHdr *amHdr));
+ RlcAmHdr *amHdr));
-PRIVATE Void kwAmmTriggerStatus ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmTriggerStatus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwSn sn,
+ RlcSn sn,
Bool discFlg));
-PRIVATE S16 kwAmmUlReassembleSdus ARGS ((RlcCb *gCb,
+PRIVATE S16 rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwAmRecBuf *recBuf));
+ RlcAmRecBuf *recBuf));
-PRIVATE Void kwAmmProcPduOrSeg ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- KwAmHdr *amHdr,
+ RlcAmHdr *amHdr,
Buffer *pdu));
-PRIVATE Void kwAmmUpdExpByteSeg ARGS ((RlcCb *gCb,KwAmUl *amUl, KwSeg* newSeg));
+PRIVATE Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg));
-PRIVATE Void kwAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo));
+PRIVATE Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo));
-PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte));
AM Module contains the following funcitons:
- - kwAmmProcessSdus
- - kwAmmUlAssembleCntrlInfo
- - kwResegRetxPdus
- - kwAssembleSdus
+ - rlcAmmProcessSdus
+ - rlcAmmUlAssembleCntrlInfo
+ - rlcResegRetxPdus
+ - rlcAssembleSdus
- kwChkandSetPoll
- - kwAmmProcessPdus
- - kwAmmUlHndlStatusPdu
- - kwAmmTriggerStatus
- - kwAmmUlReassembleSdus
+ - rlcAmmProcessPdus
+ - rlcAmmUlHndlStatusPdu
+ - rlcAmmTriggerStatus
+ - rlcAmmUlReassembleSdus
*******************************************************************************/
/** @addtogroup ammode */
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmUlSetNackInfo
+PRIVATE S16 rlcAmmUlSetNackInfo
(
RlcUlRbCb *rbCb,
-KwSn sn,
+RlcSn sn,
Bool isSegment,
U16 soStart,
U16 soEnd,
-KwUdxDlStaPdu *statusPdu,
-KwSn *prevNackSn
+RlcUdxDlStaPdu *statusPdu,
+RlcSn *prevNackSn
)
#else
-PRIVATE S16 kwAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
+PRIVATE S16 rlcAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
RlcUlRbCb *rbCb;
-KwSn sn;
+RlcSn sn;
Bool isSegment;
U16 soStart;
U16 soEnd;
-KwUdxDlStaPdu *statusPdu,
-KwSn *prevNackSn;
+RlcUdxDlStaPdu *statusPdu,
+RlcSn *prevNackSn;
#endif
{
- KwNackInfo *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount);
+ RlcNackInfo *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount);
S16 sizeToBeEncd = 0; /* Status PDu size to be encoded */
- TRC2(kwAmmUlSetNackInfo)
+ TRC2(rlcAmmUlSetNackInfo)
/* In following cases we should increment the nackCnt & fill new NACK_SN info:
* 1) First NACK_SN of the statusdPdu
*/
if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & AMUL.snModMask) != sn) ||
(((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) ||
- ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != KW_ALL_BYTES_MISSING)))
+ ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != RLC_ALL_BYTES_MISSING)))
{
if(nackInfo->nackRange)
{
if(isSegment)
{
- sizeToBeEncd += ((AMUL.snLen == KW_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
+ sizeToBeEncd += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
}
else
{
- sizeToBeEncd += ((AMUL.snLen == KW_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
+ sizeToBeEncd += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
}
}
else
}
else if(nackInfo->isSegment)
{
- nackInfo->soEnd = KW_ALL_BYTES_MISSING;
+ nackInfo->soEnd = RLC_ALL_BYTES_MISSING;
}
else
{
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmUlAssembleCntrlInfo
+PRIVATE Void rlcAmmUlAssembleCntrlInfo
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PRIVATE Void kwAmmUlAssembleCntrlInfo(gCb, rbCb)
+PRIVATE Void rlcAmmUlAssembleCntrlInfo(gCb, rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwUdxDlStaPdu *pStatusPdu;
- KwNackInfo *nackInfo;
- KwSn sn; /* sequence number */
- KwSn mSn; /* Mod val of sequence number */
- KwSn rxHighestStatus; /* Mod val of rxHighestStatus */
- KwSeg *seg; /* pdu segment */
+ RlcUdxDlStaPdu *pStatusPdu;
+ RlcNackInfo *nackInfo;
+ RlcSn sn; /* sequence number */
+ RlcSn mSn; /* Mod val of sequence number */
+ RlcSn rxHighestStatus; /* Mod val of rxHighestStatus */
+ RlcSeg *seg; /* pdu segment */
U16 nackCnt = 0; /* Index for staPdu */
U16 seqSo; /* segmment offset */
- KwUdxUlSapCb *sapCb;
+ RlcUdxUlSapCb *sapCb;
U16 staPduEncSize = 3; /* size that would be of the encoded
STATUS PDU, it is in bits; 15 for
first fixed part of STATUS PDU */
- KwAmRecBuf *recBuf = NULLP;
- KwSn prevNackSn = 0xffffffff;
+ RlcAmRecBuf *recBuf = NULLP;
+ RlcSn prevNackSn = 0xffffffff;
- TRC2(kwAmmUlAssembleCntrlInfo)
+ TRC2(rlcAmmUlAssembleCntrlInfo)
- sapCb = KW_GET_UDX_SAP(gCb);
+ sapCb = RLC_GET_UDX_SAP(gCb);
RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
/* Memory allocation failure can not be expected */
MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
MODAMR(AMUL.rxHighestStatus, rxHighestStatus, AMUL.rxNext, AMUL.snModMask);
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
while (mSn < rxHighestStatus )
{
/* For missing PDUs */
- if ((NULLP == recBuf) && nackCnt < KW_MAX_NACK_CNT )
+ if ((NULLP == recBuf) && nackCnt < RLC_MAX_NACK_CNT )
{
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
"Missing PDU's SN = %d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- staPduEncSize += kwAmmUlSetNackInfo(rbCb,
+ staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
FALSE, /* isSegment */
0, /* SOStart */
with soStart and soEnd info to staPdu */
seqSo = 0;
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
- while (seg != NULLP && nackCnt < KW_MAX_NACK_CNT)
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ while (seg != NULLP && nackCnt < RLC_MAX_NACK_CNT)
{
/* For missing byte segments */
if (seg->amHdr.so != seqSo)
{
- staPduEncSize += kwAmmUlSetNackInfo(rbCb,
+ staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
TRUE,
seqSo,
}
seqSo = seg->soEnd + 1;
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
}
/* Check if the last segment is missing */
- KW_LLIST_LAST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_LAST_SEG(recBuf->segLst, seg);
if ((seg != NULLP) &&
- (seg->amHdr.si != KW_SI_LAST_SEG && nackCnt < KW_MAX_NACK_CNT))
+ (seg->amHdr.si != RLC_SI_LAST_SEG && nackCnt < RLC_MAX_NACK_CNT))
{
- staPduEncSize += kwAmmUlSetNackInfo(rbCb,
+ staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
sn,
TRUE,
seqSo,
- KW_ALL_BYTES_MISSING,
+ RLC_ALL_BYTES_MISSING,
pStatusPdu,
&prevNackSn);
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlAssembleCntrlInfo: Missing (last) byte "
+ "rlcAmmUlAssembleCntrlInfo: Missing (last) byte "
"segment's SN:%d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
"soStart and soEnd = %d, %d UEID:%d CELLID:%d",
seqSo,
- KW_ALL_BYTES_MISSING,
+ RLC_ALL_BYTES_MISSING,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
/* Get the received Buffer the updated/next SN */
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
/* Find the next missing sequence number if nackCnt reaches maximum and
still Reordering window has some missing AMDPDUs / AMDPDU segments. The
next missing sequence number will be considered as the ack sequnece
number in the status pdu.*/
- if((nackCnt == KW_MAX_NACK_CNT) &&
+ if((nackCnt == RLC_MAX_NACK_CNT) &&
((recBuf == NULLP) ||
((recBuf->pdu == NULLP) &&
(recBuf->segLst.count > 0))))
}
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
+ "rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d",
pStatusPdu->ackSn,
rbCb->rlcId.ueId,
RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
- sizeof(KwUdxDlStaPdu));
+ sizeof(RlcUdxDlStaPdu));
}
RETVOID;
#endif
#ifdef T2K_TRIGGER_RLC_REEST
-PUBLIC U32 drpRlcDrbPack;
+U32 drpRlcDrbPack;
#endif
/**
* @brief Handler to process the PDUs received from MAC and send it to PDCP
*/
#ifdef LTE_L2_MEAS
#ifdef ANSI
-PUBLIC Void kwAmmProcessPdus
+Void rlcAmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
U32 ttiCnt
)
#else
-PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
+Void rlcAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
RlcCb *gCb;
RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
#endif
#else
#ifdef ANSI
-PUBLIC Void kwAmmProcessPdus
+Void rlcAmmProcessPdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo
)
#else
-PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo)
+Void rlcAmmProcessPdus(gCb, rbCb, pduInfo)
RlcCb *gCb;
RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
#endif
{
Buffer *pdu;
- KwAmUl *amUl;
- KwAmHdr amHdr;
+ RlcAmUl *amUl;
+ RlcAmHdr amHdr;
U8 numPdu = 0;
U8 numPduToProcess;
- KwSn sn;
- KwSn tSn;
- KwSn mSn;
+ RlcSn sn;
+ RlcSn tSn;
+ RlcSn mSn;
U8 fByte;
Bool discFlg;
#ifdef LTE_L2_MEAS_RLC
MsgLen rlcSduSz; /*Holds length of Rlc Sdu*/
#endif /* LTE_L2_MEAS */
- TRC2(kwAmmProcessPdus)
+ TRC2(rlcAmmProcessPdus)
amUl = &AMUL;
- numPduToProcess = KW_MIN(pduInfo->numPdu, RGU_MAX_PDU);
+ numPduToProcess = RLC_MIN(pduInfo->numPdu, RGU_MAX_PDU);
RLOG_ARG4(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
"numPdu[%ld],numPduToProcess[%ld] UEID:%ld CELLID:%ld",
numPdu,
#endif
#endif
/* Extract AM PDU/SEG header Info */
- KW_MEM_ZERO(&amHdr, sizeof(KwAmHdr));
+ RLC_MEM_ZERO(&amHdr, sizeof(RlcAmHdr));
/* Avoided the allocation of amHdr and sending
a single pointer */
- if (kwAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
+ if (rlcAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
{
RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
"Header Extraction Failed UEID:%d CELLID:%d",
/* Check if its a control PDU */
if (amHdr.dc == 0)
{
- kwAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
+ rlcAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
RLC_FREE_BUF(pdu);
continue;
}
- if((amHdr.si == KW_SI_LAST_SEG) && (!amHdr.so))
+ if((amHdr.si == RLC_SI_LAST_SEG) && (!amHdr.so))
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Dropping PDU because SO can't be zero for last segment sn:%u "
+ "rlcAmmProcessPdus: Dropping PDU because SO can't be zero for last segment sn:%u "
"UEID:%d CELLID:%d",
amHdr.sn,
rbCb->rlcId.ueId,
#endif
/* Reordering data PDU */
sn = amHdr.sn;
- if (kwAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE)
+ if (rlcAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE)
{
- KwAmRecBuf *recBuf;
+ RlcAmRecBuf *recBuf;
Bool tmrRunning;
- KwSn tVrMr;
- KwSn mrxNextHighestRcvd;
+ RlcSn tVrMr;
+ RlcSn mrxNextHighestRcvd;
#ifdef LTE_L2_MEAS
- kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt);
+ rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt);
#endif /* LTE_L2_MEAS */
/* Update rxNextHighestRcvd */
amUl->rxNextHighestRcvd = ((sn + 1) & (amUl->snModMask));
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
+ "rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
amUl->rxNextHighestRcvd,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
if ((NULLP != recBuf) && ( recBuf->allRcvd))
{
/* deliver the reassembled RLC SDU to upper layer,
But not removed from the table */
- kwAmmUlReassembleSdus(gCb, rbCb, recBuf);
+ rlcAmmUlReassembleSdus(gCb, rbCb, recBuf);
recBuf->isDelvUpperLayer = TRUE;
MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
{
tSn = (sn + 1) & (amUl->snModMask) ; /* MOD (2 Pwr SN LEN- 1) */
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
/* Scan through till the upper edge of the window */
MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask);
while (mSn <= tVrMr)
if ((NULLP == recBuf) || (!recBuf->allRcvd))
{
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Updated rxHighestStatus:%d "
+ "rlcAmmProcessPdus: Updated rxHighestStatus:%d "
"UEID:%d CELLID:%d",
tSn,
rbCb->rlcId.ueId,
break;
}
tSn = (tSn + 1) & (amUl->snModMask); /* MOD (2 Pwr SN LEN- 1) */
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
mSn++;
}
}
if (sn == amUl->rxNext)
{
tSn = sn;
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask);
/* Scan through till the upper edge of the window */
while (mSn <= tVrMr)
/* RecBuf should remove from table
since PDU is already sent to upper layer */
recBuf->isDelvUpperLayer = FALSE;
- kwUtlDelRecBuf(amUl->recBufLst, recBuf, gCb);
+ rlcUtlDelRecBuf(amUl->recBufLst, recBuf, gCb);
}
else
{
amUl->rxNext = tSn;
- amUl->vrMr = (amUl->rxNext + (KW_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask);
+ amUl->vrMr = (amUl->rxNext + (RLC_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask);
break;
}
tSn = (tSn + 1) & (amUl->snModMask);
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
mSn++;
}
}
}
/* Check if reOrdTmr is running and update rxNextStatusTrig accordingly */
- tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
if (tmrRunning)
{
- Bool snInWin = KW_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl);
+ Bool snInWin = RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl);
if ( (amUl->rxNextStatusTrig == amUl->rxNext) || ( (!snInWin) &&
(amUl->rxNextStatusTrig != amUl->vrMr) ) )
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
tmrRunning = FALSE;
}
}
{
if (amUl->rxNextHighestRcvd > amUl->rxNext)
{
- kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmProcessPdus: Updated rxNextStatusTrig = %d UEID:%d CELLID:%d",
+ "rlcAmmProcessPdus: Updated rxNextStatusTrig = %d UEID:%d CELLID:%d",
amUl->rxNextStatusTrig,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
if (amHdr.p)
{
- kwAmmTriggerStatus(gCb,rbCb, sn, discFlg);
+ rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg);
}
}
#ifdef LTE_L2_MEAS
- kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
+ rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
#endif /* LTE_L2_MEAS */
gCb->genSts.pdusRecv += pduInfo->numPdu;
if (amUl->gatherStaPduInfo)
{
- kwAmmUlAssembleCntrlInfo(gCb,rbCb);
+ rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
}
RETVOID;
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmExtractHdr
+PRIVATE S16 rlcAmmExtractHdr
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
U8 *fByte
)
#else
-PRIVATE S16 kwAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
+PRIVATE S16 rlcAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *pdu;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
U8 *fByte;
#endif
{
U8 snByte;
- KwSn sn = 0;
+ RlcSn sn = 0;
MsgLen pduSz;
- KwExtHdr hdrInfo;
+ RlcExtHdr hdrInfo;
- TRC2(kwAmmExtractHdr)
+ TRC2(rlcAmmExtractHdr)
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract fixed part of the header */
SFndLenMsg(pdu,&pduSz);
SRemPreMsg(fByte, pdu);
- amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT;
- if (KW_CNTRL_PDU == amHdr->dc)
+ amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
+ if (RLC_CNTRL_PDU == amHdr->dc)
{
//printf ("++++++++++++ 5GNRLOG HDR extracted CTRL : \n");
return ROK;
}
- amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT;
+ amHdr->p = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
- amHdr->si = (*fByte & KW_SI_POS) >> KW_SI_SHT;
+ amHdr->si = (*fByte & RLC_SI_POS) >> RLC_SI_SHT;
/* 12 BIT SN */
- if (rbCb->m.amUl.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
SRemPreMsg(&snByte, pdu);
- sn = (KwSn)(((*fByte & KW_SN_POS_12BIT) << KW_BYTE_LEN ) | snByte);
+ sn = (RlcSn)(((*fByte & RLC_SN_POS_12BIT) << RLC_BYTE_LEN ) | snByte);
amHdr->sn = sn;
}
- else if (rbCb->m.amUl.snLen == KW_AM_CFG_18BIT_SN_LEN)
+ else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
{
SRemPreMsg(&snByte, pdu);
- sn = (KwSn)(((*fByte & KW_SN_POS_18BIT) << KW_BYTE_LEN ) | snByte);
+ sn = (RlcSn)(((*fByte & RLC_SN_POS_18BIT) << RLC_BYTE_LEN ) | snByte);
SRemPreMsg(&snByte, pdu);
- sn = ((sn << KW_BYTE_LEN) | snByte);
+ sn = ((sn << RLC_BYTE_LEN) | snByte);
amHdr->sn = sn;
}
if ((amHdr->si != 0) && (amHdr->si != 0x01))
{
- hdrInfo.len = KW_SO_LEN_5GNR;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_SO_LEN_5GNR;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
amHdr->so = hdrInfo.val;
pduSz -= 2;
}
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmExtractHdrOld
+PRIVATE S16 rlcAmmExtractHdrOld
(
RlcCb *gCb,
Buffer *pdu,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
U8 *fByte
)
#else
-PRIVATE S16 kwAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
+PRIVATE S16 rlcAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
RlcCb *gCb;
Buffer *pdu;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
U8 *fByte;
#endif
{
U16 sn;
MsgLen pduSz;
MsgLen totalSz = 0;
- KwExtHdr hdrInfo;
+ RlcExtHdr hdrInfo;
- TRC2(kwAmmExtractHdrOld)
+ TRC2(rlcAmmExtractHdrOld)
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract fixed part of the header */
SFndLenMsg(pdu,&pduSz);
SRemPreMsg(fByte, pdu);
- amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT;
- if (KW_CNTRL_PDU == amHdr->dc)
+ amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
+ if (RLC_CNTRL_PDU == amHdr->dc)
{
return ROK;
}
/* kw002.201 : Changed the extraction of hdr elements to avoid */
/* function calls */
- amHdr->rf = (*fByte & KW_RF_POS) >> KW_RF_SHT;
- amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT;
- amHdr->fi = (*fByte & KW_FI_POS) >> KW_FI_SHT;
- e = amHdr->e = (*fByte & KW_E_POS)>> KW_E_SHT;
-
+ amHdr->rf = (*fByte & RLC_RF_POS) >> RLC_RF_SHT;
+ amHdr->p = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
+ amHdr->fi = (*fByte & RLC_FI_POS) >> RLC_FI_SHT;
+ e = amHdr->e = (*fByte & RLC_E_POS)>> RLC_E_SHT;
+
SRemPreMsg(&snByte, pdu);
- sn = (U16)(((*fByte & KW_SN_POS) << KW_BYTE_LEN ) | snByte);
+ sn = (U16)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
amHdr->sn = sn;
if (amHdr->rf == 1)
{
/* Extract extn part of the header */
- hdrInfo.len = KW_LSF_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_LSF_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
amHdr->lsf = (U8)hdrInfo.val;
- hdrInfo.len = KW_SO_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_SO_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
amHdr->so = hdrInfo.val;
pduSz -= 2;
}
amHdr->numLi = 0;
/* Extract LIs */
- while (e && (amHdr->numLi < KW_MAX_UL_LI))
+ while (e && (amHdr->numLi < RLC_MAX_UL_LI))
{
- hdrInfo.len = KW_E_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_E_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
e = amHdr->e = (U8)hdrInfo.val;
/* Extract LI value*/
- hdrInfo.len = KW_LI_LEN;
- kwAmmExtractElmnt(gCb, pdu, &hdrInfo);
+ hdrInfo.len = RLC_LI_LEN;
+ rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
/* li = hdrInfo.val;*/
/* check if LI is zero */
totalSz += hdrInfo.val; /* incrment the size by LI value */
}
- /*ccpu00122597:PDU is dropped if liCnt exceeds KW_MAX_LI*/
- if(e && (amHdr->numLi >= KW_MAX_UL_LI))
+ /*ccpu00122597:PDU is dropped if liCnt exceeds RLC_MAX_LI*/
+ if(e && (amHdr->numLi >= RLC_MAX_UL_LI))
{
RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]",
- amHdr->numLi, KW_MAX_UL_LI);
+ amHdr->numLi, RLC_MAX_UL_LI);
return RFAILED;
}
* @brief Private handler to process the status PDU
*
* @details
- * Private handler invokded by kwAmmProcessPdus to process the
+ * Private handler invokded by rlcAmmProcessPdus to process the
* control PDU (status report) received from its peer RLC entity.
*
* - Decode the values from the received control pdu
- * - Create a KwUdxStaPdu structure, copy the values onto it and
+ * - Create a RlcUdxStaPdu structure, copy the values onto it and
* send it to the DL instance for further processing
*
* @param[in] gCb RLC instance control block
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmUlHndlStatusPdu
+PRIVATE Void rlcAmmUlHndlStatusPdu
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
U8 *fByte
)
#else
-PRIVATE Void kwAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
+PRIVATE Void rlcAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
RlcCb *gCb;
RlcUlRbCb *rbCb;
Buffer *cntrlPdu;
#endif
{
U8 e1;
- KwExtHdr hdrInfo;
- KwUdxStaPdu *pStaPdu;
- KwUdxUlSapCb *sapCb;
+ RlcExtHdr hdrInfo;
+ RlcUdxStaPdu *pStaPdu;
+ RlcUdxUlSapCb *sapCb;
U8 e3; /* NACK RANGE : 5GNR */
U32 snLen;
U32 snRange;
U32 resrvdBitsAckSn=0;
U32 resrvdBitsNackSn=0;
- TRC2(kwAmmUlHndlStatusPdu)
+ TRC2(rlcAmmUlHndlStatusPdu)
- KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr));
+ RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
/* Extract the Control PDU */
hdrInfo.hdr = (*fByte << 1);
RETVOID;
}
- sapCb = KW_GET_UDX_SAP(gCb);
+ sapCb = RLC_GET_UDX_SAP(gCb);
RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStaPdu,
- sizeof(KwUdxStaPdu));
+ sizeof(RlcUdxStaPdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
/* Memory allocation failure can not be expected */
}
#endif
- if (rbCb->m.amUl.snLen == KW_AM_CFG_12BIT_SN_LEN)
+ if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
snLen = 12;
- resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_12BITS;
- resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_12BITS;
+ resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS;
+ resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS;
}
- else if (rbCb->m.amUl.snLen == KW_AM_CFG_18BIT_SN_LEN)
+ else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
{
snLen = 18;
- resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_18BITS;
- resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_18BITS;
+ resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS;
+ resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS;
}
else
{
- snLen = KW_SN_LEN;
+ snLen = RLC_SN_LEN;
resrvdBitsAckSn = 0;
resrvdBitsAckSn = 0;
}
pStaPdu->nackCnt = 0;
/* For CPT */
- hdrInfo.hdr = hdrInfo.hdr << KW_CPT_LEN;
+ hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN;
/* ACK Sn */
hdrInfo.len = snLen;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->ackSn = hdrInfo.val;
//printf ("++++++++++++ 5GNRLOG HNDL STATUS acksn %d : \n", pStaPdu->ackSn);
/* Check if NACK Exists */
- hdrInfo.len = KW_E1_LEN;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_E1_LEN;
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (U8)hdrInfo.val;
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
+ "rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
pStaPdu->ackSn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
/* Extract the Reserved Bits after ACK SN field */
hdrInfo.len = resrvdBitsAckSn;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* If NACK exists in control PDU */
/* For ACKs and NACKs */
- while (e1 && (pStaPdu->nackCnt < KW_MAX_NACK_CNT))
+ while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT))
{
hdrInfo.len = snLen;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val;
- hdrInfo.len = KW_E1_LEN;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_E1_LEN;
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e1 = (U8)hdrInfo.val;
/* Extract e2 */
- /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is
+ /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* e2 = (U8) hdrInfo.val;*/
/* Store e2 value */
pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
/* Extract e3 : 5GNR */
- /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is
+ /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
e3 = (U8) hdrInfo.val;
/* Extract Reserved Bits after NACK SN */
hdrInfo.len = resrvdBitsNackSn;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
/* Test for resegmentation */
if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment)
{
- hdrInfo.len = KW_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd = hdrInfo.val;
RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
+ "rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
"UEID:%d CELLID:%d",
pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd,
if (e3)
{
/* Extract NACK range field */
- hdrInfo.len = KW_NACK_RANGE_LEN;
- kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
+ hdrInfo.len = RLC_NACK_RANGE_LEN;
+ rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
snRange = (U8)hdrInfo.val;
pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
/* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN
to the last NACK SN + 1 and discard the original ACK_SN*/
- if(pStaPdu->nackCnt == KW_MAX_NACK_CNT)
+ if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT)
{
- pStaPdu->ackSn = (pStaPdu->nackInfo[KW_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask);
+ pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask);
}
* @brief Private handler to release all stored segments
*
* @details
- * Private handler invokded by kwAmmUlPlacePduInRecBuf to release the
+ * Private handler invokded by rlcAmmUlPlacePduInRecBuf to release the
* stored segements in case a complete PDU is received later.
*
* @param[in] gCb RLC instance control block
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmUlRlsAllSegs
+PRIVATE Void rlcAmmUlRlsAllSegs
(
RlcCb *gCb,
-KwAmRecBuf *recBuf
+RlcAmRecBuf *recBuf
)
#else
-PRIVATE Void kwAmmUlRlsAllSegs(gCb,recBuf)
+PRIVATE Void rlcAmmUlRlsAllSegs(gCb,recBuf)
RlcCb *gCb;
-KwAmRecBuf *recBuf;
+RlcAmRecBuf *recBuf;
#endif
{
- KwSeg *seg;
+ RlcSeg *seg;
- TRC2(kwAmmUlRlsAllSegs)
+ TRC2(rlcAmmUlRlsAllSegs)
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
while (seg != NULLP)
{
RLC_FREE_BUF_WC(seg->seg);
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- RLC_FREE_WC(gCb,seg, sizeof(KwSeg));
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_FREE_WC(gCb,seg, sizeof(RlcSeg));
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
RETVOID;
* @brief Private handler to store the received segment
*
* @details
- * Private handler invokded by kwAmmUlPlacePduInRecBuf to add a received
+ * Private handler invokded by rlcAmmUlPlacePduInRecBuf to add a received
* segment in reception buffer of a RBCB.
* - It is responsible for detecting duplicate segments
* - Adding it at appropriate position in the received buffer
* -#FALSE Possibly a duplicate segment
*/
#ifdef ANSI
-PRIVATE Bool kwAmmAddRcvdSeg
+PRIVATE Bool rlcAmmAddRcvdSeg
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
Buffer *pdu,
U16 pduSz
)
#else
-PRIVATE Bool kwAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
+PRIVATE Bool rlcAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
Buffer *pdu;
U16 pduSz;
#endif
{
- KwAmRecBuf *recBuf = NULLP;
- KwSeg *seg;
- KwSeg *tseg;
+ RlcAmRecBuf *recBuf = NULLP;
+ RlcSeg *seg;
+ RlcSeg *tseg;
U16 soEnd; /* Holds the SoEnd of received segment */
U16 expSo = 0; /* Expected SO */
- TRC2(kwAmmAddRcvdSeg)
+ TRC2(rlcAmmAddRcvdSeg)
soEnd = amHdr->so + pduSz - 1;
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, amHdr->sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, amHdr->sn);
if (NULLP == recBuf)
{
- RLC_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb,recBuf, sizeof(RlcAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
- kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
+ rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
}
else
{
recBuf->isDelvUpperLayer = FALSE;
/* kw003.201 - Move past the segments that are different than the */
/* one received. */
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
while ((seg != NULLP) && (seg->amHdr.so < amHdr->so))
{
expSo = seg->amHdr.so + seg->segSz;
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
}
/* The received segment should start after the end of previous seg */
/* If we have come this far, we have to add this segment to the */
/* reception buffer as we either have eliminated duplicates or */
/* have found none. */
- RLC_ALLOC_WC(gCb,tseg, sizeof(KwSeg));
+ RLC_ALLOC_WC(gCb,tseg, sizeof(RlcSeg));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tseg == NULLP)
{
tseg->seg = pdu;
tseg->segSz = pduSz;
- KW_MEM_CPY(&tseg->amHdr, amHdr, sizeof(KwAmHdr));
+ RLC_MEM_CPY(&tseg->amHdr, amHdr, sizeof(RlcAmHdr));
recBuf->amHdr.si = amHdr->si;
recBuf->amHdr.sn = amHdr->sn;
tseg->soEnd = soEnd;
cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt);
}
tseg->lstEnt.node = (PTR)tseg;
- kwAmmUpdExpByteSeg(gCb,&AMUL,tseg);
+ rlcAmmUpdExpByteSeg(gCb,&AMUL,tseg);
return (TRUE);
}
*
*/
#ifdef ANSI
-PRIVATE Bool kwAmmUlPlacePduInRecBuf
+PRIVATE Bool rlcAmmUlPlacePduInRecBuf
(
RlcCb *gCb,
Buffer *pdu,
RlcUlRbCb *rbCb,
-KwAmHdr *amHdr
+RlcAmHdr *amHdr
)
#else
-PRIVATE Bool kwAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
+PRIVATE Bool rlcAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
RlcCb *gCb;
Buffer *pdu;
RlcUlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
#endif
{
- KwSn sn;
+ RlcSn sn;
MsgLen pduSz;
- KwAmUl *amUl = &(rbCb->m.amUl);
+ RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(kwAmmUlPlacePduInRecBuf)
+ TRC2(rlcAmmUlPlacePduInRecBuf)
sn = amHdr->sn;
gCb->genSts.bytesRecv += pduSz;
gRlcStats.amRlcStats.numRlcAmCellSduBytesRx += pduSz;
- if (!KW_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
+ if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
{
gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++;
RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmUlPlacePduInRecBuf: SN %d outside the window"
+ "rlcAmmUlPlacePduInRecBuf: SN %d outside the window"
"UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
if (amHdr->si == 0)
{
- KwAmRecBuf *recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn);
+ RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
/* We received a complete PDU. Either we already have it, in which */
/* case we just ignore the new PDU and discard it. Otherwise, */
/* store the received PDU in the reception buffer */
if (NULLP == recBuf)
{
- RLC_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb, recBuf, sizeof(RlcAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
- kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
+ rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
}
else if (recBuf->allRcvd != TRUE)
{
- kwAmmUlRlsAllSegs(gCb,recBuf);
+ rlcAmmUlRlsAllSegs(gCb,recBuf);
}
else
{
recBuf->pduSz = pduSz;
recBuf->allRcvd = TRUE;
gRlcStats.amRlcStats.numRlcAmCellSduRx++;
- KW_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(KwAmHdr));
+ RLC_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(RlcAmHdr));
return (TRUE);
}
else
{
/* We received a segment. We need to add that to the existing */
/* segments, if any. */
- return (kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
+ return (rlcAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
}
}
* @brief Private handler to trigger status report
*
* @details
- * Private handler invokded by kwAmmProcessPdus to check if the
+ * Private handler invokded by rlcAmmProcessPdus to check if the
* status report need to be sent, and update the status trigger
* flag accordingly based on status prohibit timer.
*
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmTriggerStatus
+PRIVATE Void rlcAmmTriggerStatus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwSn sn,
+RlcSn sn,
Bool discFlg
)
#else
-PRIVATE Void kwAmmTriggerStatus(gCb,rbCb, sn, discFlg)
+PRIVATE Void rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwSn sn;
+RlcSn sn;
Bool discFlg;
#endif
{
Bool tmrRunning;
- KwSn tSn;
- KwSn tVrMr;
- KwSn trxHighestStatus;
- KwAmUl *amUl = &(rbCb->m.amUl);
+ RlcSn tSn;
+ RlcSn tVrMr;
+ RlcSn trxHighestStatus;
+ RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(kwAmmTriggerStatus)
+ TRC2(rlcAmmTriggerStatus)
MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr))
{
RLOG_ARG2(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "kwAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
+ "rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
amUl->gatherStaPduInfo = FALSE;
/* Check if staProhTmr is running */
- tmrRunning = kwChkTmr(gCb,(PTR) rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
if (!tmrRunning)
{
*
*/
#ifdef ANSI
-PRIVATE Void kwAmmProcPduOrSeg
+PRIVATE Void rlcAmmProcPduOrSeg
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwAmHdr *amHdr,
+RlcAmHdr *amHdr,
Buffer *pdu
)
#else
-PRIVATE Void kwAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
+PRIVATE Void rlcAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwAmHdr *amHdr;
+RlcAmHdr *amHdr;
Buffer *pdu;
#endif
{
- TRC2(kwAmmProcPduOrSeg)
+ TRC2(rlcAmmProcPduOrSeg)
if ((AMUL.expSn != amHdr->sn) || (AMUL.expSo != amHdr->so))
{
RLC_FREE_BUF(AMUL.partialSdu);
}
- //if (amHdr->fi & KW_FI_FIRST_SEG)
+ //if (amHdr->fi & RLC_FI_FIRST_SEG)
if (amHdr->si == 0x01)
{/* first Segment of the SDU */
if (AMUL.partialSdu != NULLP)
if (pdu != NULLP)
{
AMUL.partialSdu = NULLP;
- kwUtlSndDatInd(gCb,rbCb, pdu);
+ rlcUtlSndDatInd(gCb,rbCb, pdu);
}
RETVOID;
* @brief Private handler to reassemble SDUs
*
* @details
- * Private handler invokded by kwAmmProcessPdus with the PDU
+ * Private handler invokded by rlcAmmProcessPdus with the PDU
* from the reception buffer in sequence to reassemble SDUs and
* send it to PDCP.
*
*
*/
#ifdef ANSI
-PRIVATE S16 kwAmmUlReassembleSdus
+PRIVATE S16 rlcAmmUlReassembleSdus
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-KwAmRecBuf *recBuf
+RlcAmRecBuf *recBuf
)
#else
-PRIVATE S16 kwAmmUlReassembleSdus(gCb, rbCb, recBuf)
+PRIVATE S16 rlcAmmUlReassembleSdus(gCb, rbCb, recBuf)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-KwAmRecBuf *recBuf;
+RlcAmRecBuf *recBuf;
#endif
{
- KwSeg *seg;
+ RlcSeg *seg;
- TRC2(kwAmmUlReassembleSdus)
+ TRC2(rlcAmmUlReassembleSdus)
//if (recBuf->amHdr.rf == 0)
if (recBuf->amHdr.si == 0)
{
/* This is a PDU */
- kwAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
+ rlcAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
/* Assign NULLP to recBuf->pdu as this PDU is sent to PDCP */
recBuf->pdu = NULLP;
AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
else
{
/* This is a set of segments */
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
AMUL.expSn = recBuf->amHdr.sn;
AMUL.expSo = 0;
while(seg)
{
- kwAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
+ rlcAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
AMUL.expSo = seg->soEnd + 1;
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- RLC_FREE_WC(gCb, seg, sizeof(KwSeg));
+ RLC_FREE_WC(gCb, seg, sizeof(RlcSeg));
- KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
+ RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
AMUL.expSo = 0;
*
*/
#ifdef ANSI
-PUBLIC Void kwAmmUlReEstablish
+Void rlcAmmUlReEstablish
(
RlcCb *gCb,
CmLteRlcId rlcId,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
+Void rlcAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
RlcUlRbCb *rbCb;
#endif
{
- KwSn sn;
- KwSn mSn;
- KwSn mVrMr;
+ RlcSn sn;
+ RlcSn mSn;
+ RlcSn mVrMr;
#ifndef KW_PDCP
- KwKwuSapCb *kwKwSap;
+ RlcKwuSapCb *rlcKwuSap;
#endif
- KwAmRecBuf *recBuf = NULLP;
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmUlReEstablish);
+ TRC2(rlcAmmUlReEstablish);
sn = AMUL.rxNext;
/* Reassemble SDUs from PDUs with SN less than upper edge of the window */
while (mSn < mVrMr)
{
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
if (NULLP != recBuf)
{
if (recBuf->allRcvd == TRUE)
{
- kwAmmUlReassembleSdus(gCb,rbCb, recBuf);
+ rlcAmmUlReassembleSdus(gCb,rbCb, recBuf);
}
else
{
RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments*/
- kwAmmUlRlsAllSegs(gCb,recBuf);
+ rlcAmmUlRlsAllSegs(gCb,recBuf);
}
- kwUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb);
+ rlcUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb);
}
sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */
MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
/* Discard remaining PDUs and bytesegments in recBuf */
/* Stop all timers and reset variables */
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
}
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_STA_PROH_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
}
AMUL.rxNext = 0;
AMUL.rxNextHighestRcvd = 0;
AMUL.rxNextStatusTrig = 0;
- rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
+ rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
AMUL.rxHighestStatus = 0;
AMUL.staTrg = FALSE;
AMUL.gatherStaPduInfo = FALSE;
{
RLC_FREE_BUF(AMUL.partialSdu);
}
- kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
+ rlcKwuSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
if(sendReEst)
{
- KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, rlcId);
+ RlcUiKwuReEstCmpInd(&rlcKwuSap->pst, rlcKwuSap->suId, rlcId);
rbCb->m.amUl.isOutOfSeq = FALSE;
}
*/
#ifdef ANSI
-PUBLIC Void kwAmmReOrdTmrExp
+Void rlcAmmReOrdTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmReOrdTmrExp(rbCb)
+Void rlcAmmReOrdTmrExp(rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwAmUl *amUl = &(rbCb->m.amUl);
- KwSn sn;
- KwSn mSn;
- KwSn mVrMr;
- KwSn mrxHighestStatus;
- KwSn mrxNextHighestRcvd;
+ RlcAmUl *amUl = &(rbCb->m.amUl);
+ RlcSn sn;
+ RlcSn mSn;
+ RlcSn mVrMr;
+ RlcSn mrxHighestStatus;
+ RlcSn mrxNextHighestRcvd;
Bool tmrRunning = FALSE;
- KwAmRecBuf *recBuf = NULLP;
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmReOrdTmrExp);
+ TRC2(rlcAmmReOrdTmrExp);
/* Update rxHighestStatus */
MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
MODAMR(amUl->vrMr, mVrMr, amUl->rxNext, amUl->snModMask);
- recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
while (mSn < mVrMr)
{
amUl->gatherStaPduInfo = FALSE;
/* Check if staProhTmr is running */
- tmrRunning = kwChkTmr(gCb,(PTR) rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
if (!tmrRunning)
{
gRlcStats.amRlcStats.numULReOrdTimerExpires++;
amUl->gatherStaPduInfo = TRUE;
- kwAmmUlAssembleCntrlInfo(gCb, rbCb);
+ rlcAmmUlAssembleCntrlInfo(gCb, rbCb);
}
break;
MODAMR(amUl->rxHighestStatus, mrxHighestStatus, amUl->rxNext, amUl->snModMask);
if (mrxNextHighestRcvd > mrxHighestStatus)
{
- kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
}
RETVOID;
-} /* kwAmmReOrdTmrExp */
+} /* rlcAmmReOrdTmrExp */
/**
* @brief Handler for status prohibit timer expiry
*/
#ifdef ANSI
-PUBLIC Void kwAmmStaProTmrExp
+Void rlcAmmStaProTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmStaProTmrExp(gCb, rbCb)
+Void rlcAmmStaProTmrExp(gCb, rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwAmUl *amUl = &(rbCb->m.amUl);
+ RlcAmUl *amUl = &(rbCb->m.amUl);
- TRC2(kwAmmStaProTmrExp);
+ TRC2(rlcAmmStaProTmrExp);
amUl->gatherStaPduInfo = FALSE;
{
amUl->gatherStaPduInfo = TRUE;
/* kw002.201 : Sending StaRsp after StaProhibit tmr expiry */
- kwAmmUlAssembleCntrlInfo(gCb,rbCb);
+ rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
}
RETVOID;
-} /* kwAmmStaProTmrExp */
+} /* rlcAmmStaProTmrExp */
/**
* @brief Handler to extract an element of AM Header
*/
#ifdef ANSI
-PRIVATE Void kwAmmExtractElmnt
+PRIVATE Void rlcAmmExtractElmnt
(
RlcCb *gCb,
Buffer *pdu,
-KwExtHdr *hdrInfo
+RlcExtHdr *hdrInfo
)
#else
-PRIVATE Void kwAmmExtractElmnt(gCb, pdu, hdrInfo)
+PRIVATE Void rlcAmmExtractElmnt(gCb, pdu, hdrInfo)
RlcCb *gCb;
Buffer *pdu;
-KwExtHdr *hdrInfo;
+RlcExtHdr *hdrInfo;
#endif
{
U8 hdr;
/* U8 rLen1 = 0; */
U16 tVal;
- TRC2(kwAmmExtractElmnt);
+ TRC2(rlcAmmExtractElmnt);
hdr = hdrInfo->hdr;
tHdr = hdr;
if (len <= 8)
{
- val = tHdr >> (KW_BYTE_LEN - (len));
+ val = tHdr >> (RLC_BYTE_LEN - (len));
hdr = hdr << len;
pLen -= len;
}
{
fLen = pLen;
val = tHdr;
- val = val >> (KW_BYTE_LEN - fLen);
+ val = val >> (RLC_BYTE_LEN - fLen);
val = val << (len - fLen);
rLen = len - fLen;
SRemPreMsg(&hdr, pdu);
tHdr = hdr;
if (rLen <= 8)
{
- hdr = hdr >> (KW_BYTE_LEN - rLen);
+ hdr = hdr >> (RLC_BYTE_LEN - rLen);
val = val | hdr;
hdr = tHdr << rLen;
- pLen = (KW_BYTE_LEN - rLen);
+ pLen = (RLC_BYTE_LEN - rLen);
}
else
{
- rLen = rLen - KW_BYTE_LEN;
+ rLen = rLen - RLC_BYTE_LEN;
tVal = hdr;
tVal = tVal << rLen;
val = val | tVal;
SRemPreMsg(&hdr, pdu);
tHdr = hdr;
- hdr = hdr >> (KW_BYTE_LEN - rLen);
+ hdr = hdr >> (RLC_BYTE_LEN - rLen);
val = val | hdr;
hdr = tHdr << rLen;
- pLen = (KW_BYTE_LEN - rLen);
+ pLen = (RLC_BYTE_LEN - rLen);
}
}
*/
#ifdef ANSI
-PRIVATE Void kwAmmUpdExpByteSeg
+PRIVATE Void rlcAmmUpdExpByteSeg
(
RlcCb *gCb,
-KwAmUl *amUl,
-KwSeg *seg
+RlcAmUl *amUl,
+RlcSeg *seg
)
#else
-PRIVATE Void kwAmmUpdExpByteSeg(gCb, amUl, seg)
+PRIVATE Void rlcAmmUpdExpByteSeg(gCb, amUl, seg)
RlcCb *gCb;
-KwAmUl *amUl;
-KwSeg *seg;
+RlcAmUl *amUl;
+RlcSeg *seg;
#endif
{
U16 newExpSo; /* The new expected SO */
- KwSn sn = seg->amHdr.sn;
+ RlcSn sn = seg->amHdr.sn;
Bool lstRcvd=FALSE;
- KwAmRecBuf *recBuf = NULLP;
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmUpdExpByteSeg);
+ TRC2(rlcAmmUpdExpByteSeg);
- recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn);
+ recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
if ((recBuf == NULLP) || (recBuf && (seg->amHdr.so != recBuf->expSo)))
{
RETVOID;
lstRcvd = TRUE;
}
/* kw003.201 - This should update seg with the one after newSeg */
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
while(seg)
{
/* keep going ahead as long as the expectedSo match with the header so
newExpSo = seg->soEnd + 1;
recBuf->expSo = newExpSo;
//lstRcvd = seg->amHdr.lsf;
- KW_LLIST_NEXT_SEG(recBuf->segLst, seg);
+ RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
}
else
{
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwAmmFreeUlRbCb
+Void rlcAmmFreeUlRbCb
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
#else
-PUBLIC Void kwAmmFreeUlRbCb(gCb,rbCb)
+Void rlcAmmFreeUlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcUlRbCb *rbCb;
#endif
{
- KwSn curSn = 0; /* Sequence number of PDU */
- KwSn windSz; /* PDU window size */
- KwAmRecBuf *recBuf = NULLP;
+ RlcSn curSn = 0; /* Sequence number of PDU */
+ RlcSn windSz; /* PDU window size */
+ RlcAmRecBuf *recBuf = NULLP;
- TRC2(kwAmmFreeUlRbCb)
+ TRC2(rlcAmmFreeUlRbCb)
- windSz = (KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
+ windSz = (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
}
- if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_STA_PROH_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
{
- kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
}
while( ( curSn < windSz ) hence changing to do while */
do
{
- recBuf = kwUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn);
+ recBuf = rlcUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn);
if ( recBuf != NULLP )
{
if (recBuf->pdu != NULLP)
RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments */
- kwAmmUlRlsAllSegs(gCb,recBuf);
- kwUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb);
+ rlcAmmUlRlsAllSegs(gCb,recBuf);
+ rlcUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb);
}
curSn++;
}while ( curSn < windSz );
#ifndef LTE_TDD
- RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
rbCb->m.amUl.recBufLst = NULLP;
#endif
RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
}
RETVOID;
-} /* kwAmmFreeUlRbCb */
+} /* rlcAmmFreeUlRbCb */
/*@}*/
Code Review / o-du / l2.git / blobdiff