static int RLOG_FILE_ID=190;
/* header include files (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-
-#include "gen.h" /* general */
-#include "ssi.h" /* system services */
-#include "cm5.h" /* common timer defines */
-#include "cm_tkns.h" /* common tokens defines */
-#include "cm_mblk.h" /* common memory allocation library defines */
-#include "cm_llist.h" /* common link list defines */
-#include "cm_hash.h" /* common hash list defines */
-#include "cm_lte.h" /* common LTE defines */
+#include "common_def.h"
#include "lkw.h" /* LKW defines */
#include "ckw.h" /* CKW defines */
#include "kwu.h" /* KWU defines */
#include "kw_ul.h"
/* extern (.x) include files */
-#include "gen.x" /* general */
-#include "ssi.x" /* system services */
-
-#include "cm5.x" /* common timer library */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_mblk.x" /* common memory allocation */
-#include "cm_llist.x" /* common link list */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lte.x" /* common LTE includes */
-#include "cm_lib.x" /* common memory allocation library */
#include "lkw.x" /* LKW */
#include "ckw.x" /* CKW */
#include "kwu.x" /* KWU */
/* private function declarations */
-PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((KwCb *gCb, KwUlRbCb *rbCb));
+PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
-PRIVATE S16 kwAmmExtractHdr ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE S16 kwAmmExtractHdr ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *pdu,
KwAmHdr *amHdr,
U8 *fByte));
-PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((KwCb *gCb,
+PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
Buffer *pdu,
- KwUlRbCb *rbCb,
+ RlcUlRbCb *rbCb,
KwAmHdr *amHdr));
-PRIVATE Void kwAmmTriggerStatus ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwAmmTriggerStatus ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwSn sn,
Bool discFlg));
-PRIVATE S16 kwAmmUlReassembleSdus ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE S16 kwAmmUlReassembleSdus ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwAmRecBuf *recBuf));
-PRIVATE Void kwAmmProcPduOrSeg ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwAmmProcPduOrSeg ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
KwAmHdr *amHdr,
Buffer *pdu));
-PRIVATE Void kwAmmUpdExpByteSeg ARGS ((KwCb *gCb,KwAmUl *amUl, KwSeg* newSeg));
+PRIVATE Void kwAmmUpdExpByteSeg ARGS ((RlcCb *gCb,KwAmUl *amUl, KwSeg* newSeg));
-PRIVATE Void kwAmmExtractElmnt ARGS ((KwCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo));
+PRIVATE Void kwAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo));
-PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((KwCb *gCb,
- KwUlRbCb *rbCb,
+PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
+ RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte));
#ifdef ANSI
PRIVATE S16 kwAmmUlSetNackInfo
(
-KwUlRbCb *rbCb,
+RlcUlRbCb *rbCb,
KwSn sn,
Bool isSegment,
U16 soStart,
)
#else
PRIVATE S16 kwAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
KwSn sn;
Bool isSegment;
U16 soStart;
}
*prevNackSn = sn;
- RETVALUE(sizeToBeEncd);
+ return (sizeToBeEncd);
}
/**
#ifdef ANSI
PRIVATE Void kwAmmUlAssembleCntrlInfo
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PRIVATE Void kwAmmUlAssembleCntrlInfo(gCb, rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwUdxDlStaPdu *pStatusPdu;
sapCb = KW_GET_UDX_SAP(gCb);
- KW_ALLOC_SHRABL_BUF(sapCb->pst.region,
+ RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
sizeof(KwUdxDlStaPdu));
AMUL.gatherStaPduInfo = FALSE;
- if (KwUlUdxStaPduReq(&sapCb->pst,
+ if (rlcUlUdxStaPduReq(&sapCb->pst,
sapCb->spId,
&rbCb->rlcId,
pStatusPdu) != ROK)
"Failed to Send Sta Pdu UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_SHRABL_BUF_WC(sapCb->pst.region,
+ RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
sapCb->pst.pool,
pStatusPdu,
sizeof(KwUdxDlStaPdu));
#ifdef ANSI
PUBLIC Void kwAmmProcessPdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
U32 ttiCnt
)
#else
PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
U32 ttiCnt;
#endif
#ifdef ANSI
PUBLIC Void kwAmmProcessPdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwPduInfo *pduInfo
)
#else
PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwPduInfo *pduInfo;
#endif
#endif
"Header Extraction Failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
gCb->genSts.errorPdusRecv++;
continue;
}
if (amHdr.dc == 0)
{
kwAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
if((amHdr.si == KW_SI_LAST_SEG) && (!amHdr.so))
amHdr.sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_T2K3K_SPECIFIC_CHANGES
#ifndef LTE_PAL_ENB
/* Changed the condition to TRUE from ROK */
- if(isMemThreshReached(kwCb[0]->init.region) == TRUE)
+ if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
{
extern U32 rlculdrop;
rlculdrop++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
#endif
#else
#ifndef LTE_PAL_ENB
/*ccpu00142274 - UL memory based flow control*/
- if(isMemThreshReached(kwCb[0]->init.region) != ROK)
+ if(isMemThreshReached(rlcCb[0]->init.region) != ROK)
{
extern U32 rlculdrop;
rlculdrop++;
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
#endif
{
if(rbCb->rlcId.rbType == CM_LTE_DRB)
{
- KW_FREE_BUF(pdu);
+ RLC_FREE_BUF(pdu);
continue;
}
}
#ifdef ANSI
PRIVATE S16 kwAmmExtractHdr
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *pdu,
KwAmHdr *amHdr,
U8 *fByte
)
#else
PRIVATE S16 kwAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *pdu;
KwAmHdr *amHdr;
U8 *fByte;
if (KW_CNTRL_PDU == amHdr->dc)
{
//printf ("++++++++++++ 5GNRLOG HDR extracted CTRL : \n");
- RETVALUE(ROK);
+ return ROK;
}
amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT;
}
//printf ("++++++++++++ 5GNRLOG HDR extracted DATA : sn %d \n", sn);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef OLD
#ifdef ANSI
PRIVATE S16 kwAmmExtractHdrOld
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
KwAmHdr *amHdr,
U8 *fByte
)
#else
PRIVATE S16 kwAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
KwAmHdr *amHdr;
U8 *fByte;
amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT;
if (KW_CNTRL_PDU == amHdr->dc)
{
- RETVALUE(ROK);
+ return ROK;
}
/* kw002.201 : Changed the extraction of hdr elements to avoid */
/* function calls */
if (! hdrInfo.val)
{
RLOG0(L_ERROR, "Received LI as 0");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* store the extracted LI value */
{
RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]",
amHdr->numLi, KW_MAX_UL_LI);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* first 2 bytes + Add one for Odd LI*/
{
RLOG3(L_ERROR,"SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ",
amHdr->sn, totalSz, pduSz);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
#ifdef ANSI
PRIVATE Void kwAmmUlHndlStatusPdu
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
U8 *fByte
)
#else
PRIVATE Void kwAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *cntrlPdu;
U8 *fByte;
#endif
sapCb = KW_GET_UDX_SAP(gCb);
- KW_ALLOC_SHRABL_BUF(sapCb->pst.region,
+ RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
sapCb->pst.pool,
pStaPdu,
sizeof(KwUdxStaPdu));
/* Parse & send Status PDU to RLC-DL */
- KwUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
+ rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
RETVOID;
}
#ifdef ANSI
PRIVATE Void kwAmmUlRlsAllSegs
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmRecBuf *recBuf
)
#else
PRIVATE Void kwAmmUlRlsAllSegs(gCb,recBuf)
-KwCb *gCb;
+RlcCb *gCb;
KwAmRecBuf *recBuf;
#endif
{
KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
while (seg != NULLP)
{
- KW_FREE_BUF_WC(seg->seg);
+ RLC_FREE_BUF_WC(seg->seg);
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- KW_FREE_WC(gCb,seg, sizeof(KwSeg));
+ RLC_FREE_WC(gCb,seg, sizeof(KwSeg));
KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
#ifdef ANSI
PRIVATE Bool kwAmmAddRcvdSeg
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwAmHdr *amHdr,
Buffer *pdu,
U16 pduSz
)
#else
PRIVATE Bool kwAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwAmHdr *amHdr;
Buffer *pdu;
U16 pduSz;
if (NULLP == recBuf)
{
- KW_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
{
if (recBuf->allRcvd == TRUE)
{
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
}
{
/* This is a duplicate segment */
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
if ((seg) && (seg->amHdr.so <= soEnd))
{
/* This is a duplicate segment */
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
/* 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. */
- KW_ALLOC_WC(gCb,tseg, sizeof(KwSeg));
+ RLC_ALLOC_WC(gCb,tseg, sizeof(KwSeg));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tseg == NULLP)
{
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
tseg->lstEnt.node = (PTR)tseg;
kwAmmUpdExpByteSeg(gCb,&AMUL,tseg);
- RETVALUE(TRUE);
+ return (TRUE);
}
/**
#ifdef ANSI
PRIVATE Bool kwAmmUlPlacePduInRecBuf
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
-KwUlRbCb *rbCb,
+RlcUlRbCb *rbCb,
KwAmHdr *amHdr
)
#else
PRIVATE Bool kwAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
KwAmHdr *amHdr;
#endif
{
rbCb->rlcId.cellId);
gCb->genSts.unexpPdusRecv++;
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
if (amHdr->si == 0)
/* store the received PDU in the reception buffer */
if (NULLP == recBuf)
{
- KW_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf));
#if (ERRCLASS & ERRCLS_ADD_RES)
if (recBuf == NULLP)
{
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
{
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
gCb->genSts.unexpPdusRecv++;
- KW_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ RLC_FREE_BUF(pdu);
+ return (FALSE);
}
recBuf->isDelvUpperLayer = FALSE;
recBuf->pdu = pdu;
recBuf->allRcvd = TRUE;
gRlcStats.amRlcStats.numRlcAmCellSduRx++;
KW_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(KwAmHdr));
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
/* We received a segment. We need to add that to the existing */
/* segments, if any. */
- RETVALUE(kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
+ return (kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
}
}
#ifdef ANSI
PRIVATE Void kwAmmTriggerStatus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwSn sn,
Bool discFlg
)
#else
PRIVATE Void kwAmmTriggerStatus(gCb,rbCb, sn, discFlg)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwSn sn;
Bool discFlg;
#endif
#ifdef ANSI
PRIVATE Void kwAmmProcPduOrSeg
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwAmHdr *amHdr,
Buffer *pdu
)
#else
PRIVATE Void kwAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwAmHdr *amHdr;
Buffer *pdu;
#endif
/* Release the existing partial SDU as we have PDUs or */
/* segments that are out of sequence */
rbCb->m.amUl.isOutOfSeq = TRUE;
- KW_FREE_BUF(AMUL.partialSdu);
+ RLC_FREE_BUF(AMUL.partialSdu);
}
//if (amHdr->fi & KW_FI_FIRST_SEG)
{/* first Segment of the SDU */
if (AMUL.partialSdu != NULLP)
{ /* Some old SDU may be present */
- KW_FREE_BUF_WC(AMUL.partialSdu);
+ RLC_FREE_BUF_WC(AMUL.partialSdu);
}
AMUL.partialSdu = pdu;
pdu = NULLP;
else if(amHdr->si == 0x03)
{/* Middle or last segment of the SUD */
SCatMsg(AMUL.partialSdu,pdu, M1M2);
- KW_FREE_BUF_WC(pdu);
+ RLC_FREE_BUF_WC(pdu);
pdu = NULLP;
}
else if (amHdr->si == 0x02)
{
SCatMsg(pdu,AMUL.partialSdu,M2M1);
- KW_FREE_BUF_WC(AMUL.partialSdu);
+ RLC_FREE_BUF_WC(AMUL.partialSdu);
}
if (pdu != NULLP)
#ifdef ANSI
PRIVATE S16 kwAmmUlReassembleSdus
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
KwAmRecBuf *recBuf
)
#else
PRIVATE S16 kwAmmUlReassembleSdus(gCb, rbCb, recBuf)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
KwAmRecBuf *recBuf;
#endif
{
AMUL.expSo = seg->soEnd + 1;
cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
- KW_FREE_WC(gCb, seg, sizeof(KwSeg));
+ RLC_FREE_WC(gCb, seg, sizeof(KwSeg));
KW_LLIST_FIRST_SEG(recBuf->segLst, seg);
}
AMUL.expSo = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
#ifdef ANSI
PUBLIC Void kwAmmUlReEstablish
(
-KwCb *gCb,
+RlcCb *gCb,
CmLteRlcId rlcId,
Bool sendReEst,
-KwUlRbCb *rbCb
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
-KwCb *gCb;
+RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
-KwUlRbCb *rbCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn sn;
/* Remove PDU and segments */
if(recBuf->pdu)
{
- KW_FREE_BUF_WC(recBuf->pdu);
+ RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments*/
kwAmmUlRlsAllSegs(gCb,recBuf);
AMUL.expSo = 0;
if (AMUL.partialSdu != NULLP)
{
- KW_FREE_BUF(AMUL.partialSdu);
+ RLC_FREE_BUF(AMUL.partialSdu);
}
kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
#ifdef ANSI
PUBLIC Void kwAmmReOrdTmrExp
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmReOrdTmrExp(rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwAmUl *amUl = &(rbCb->m.amUl);
#ifdef ANSI
PUBLIC Void kwAmmStaProTmrExp
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmStaProTmrExp(gCb, rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwAmUl *amUl = &(rbCb->m.amUl);
#ifdef ANSI
PRIVATE Void kwAmmExtractElmnt
(
-KwCb *gCb,
+RlcCb *gCb,
Buffer *pdu,
KwExtHdr *hdrInfo
)
#else
PRIVATE Void kwAmmExtractElmnt(gCb, pdu, hdrInfo)
-KwCb *gCb;
+RlcCb *gCb;
Buffer *pdu;
KwExtHdr *hdrInfo;
#endif
#ifdef ANSI
PRIVATE Void kwAmmUpdExpByteSeg
(
-KwCb *gCb,
+RlcCb *gCb,
KwAmUl *amUl,
KwSeg *seg
)
#else
PRIVATE Void kwAmmUpdExpByteSeg(gCb, amUl, seg)
-KwCb *gCb;
+RlcCb *gCb;
KwAmUl *amUl;
KwSeg *seg;
#endif
#ifdef ANSI
PUBLIC Void kwAmmFreeUlRbCb
(
-KwCb *gCb,
-KwUlRbCb *rbCb
+RlcCb *gCb,
+RlcUlRbCb *rbCb
)
#else
PUBLIC Void kwAmmFreeUlRbCb(gCb,rbCb)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
#endif
{
KwSn curSn = 0; /* Sequence number of PDU */
{
if (recBuf->pdu != NULLP)
{
- KW_FREE_BUF_WC(recBuf->pdu);
+ RLC_FREE_BUF_WC(recBuf->pdu);
}
/* Release all the segments */
kwAmmUlRlsAllSegs(gCb,recBuf);
}while ( curSn < windSz );
#ifndef LTE_TDD
- KW_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
rbCb->m.amUl.recBufLst = NULLP;
#endif
if(rbCb->m.amUl.partialSdu != NULLP)
{
- KW_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
+ RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
}
RETVOID;
} /* kwAmmFreeUlRbCb */
Code Review / o-du / l2.git / blobdiff