*/
/* header (.h) include files */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
+
+#include "common_def.h"
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
#include <sys/time.h>
#endif
-#include <stdlib.h>
-#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 "ckw.h" /* CKW defines */
#include "kwu.h" /* CKW defines */
#include "lkw.h" /* LKW defines */
#include "kw_dl.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 "ckw.x" /* CKW includes */
#include "kwu.x" /* KWU includes */
#include "lkw.x" /* LKW inlcudes */
#endif
Void ResetRLCStats(Void)
{
- KwCb* dlInst = kwCb[1];
- KwCb* ulInst = kwCb[0];
+ RlcCb* dlInst = rlcCb[1];
+ RlcCb* ulInst = rlcCb[0];
cmMemset((U8*)&gRlcStats, 0, sizeof(RLCStats));
cmMemset((U8*)&dlInst->genSts,0,sizeof(KwGenSts));
cmMemset((U8*)&ulInst->genSts,0,sizeof(KwGenSts));
#ifndef ALIGN_64BIT
Void PrintRLCStats(Void)
{
- KwCb* dlInst = kwCb[1];
- KwCb* ulInst = kwCb[0];
+ RlcCb* dlInst = rlcCb[1];
+ RlcCb* ulInst = rlcCb[0];
RLOG4(L_ALWAYS,"RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
dlInst->genSts.pdusSent,
#else
Void PrintRLCStats(Void)
{
- KwCb* dlInst = kwCb[1];
- KwCb* ulInst = kwCb[0];
+ RlcCb* dlInst = rlcCb[1];
+ RlcCb* ulInst = rlcCb[0];
printf ("\n================================ RLC STATS ===========================\n");
RLOG4(L_ALWAYS,"RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
RguDDatReqPerUe datPerUe; /* DL data info per UE */
RguDatReqTb datPerTb; /* DL data info per TB */
RguLchDatReq datPerLch; /* DL data info per Lch */
- RguPduInfo pduInfo; /* DL RLC PDU infor */
RlcMacData *dlData; /* DL data to be sent to MAC */
TRC3(KwLiRguDDatReq)
dlData = NULLP;
- KW_ALLOC_SHRABL_BUF(post->region, post->pool,
+ RLC_ALLOC_SHRABL_BUF(post->region, post->pool,
dlData, sizeof(RlcMacData));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( datReqInfo == NULLP )
{
RLOG0(L_FATAL,"Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
dlData->cellId = datReqInfo->cellId;
dlData->rnti = datPerUe.rnti;
//dlData->timeToTx = datPerUe.transId; /* Derive timing info from transId */
- dlData->nmbPdu = 0;
+ dlData->numPdu = 0;
for(tbIdx = 0; tbIdx < datPerUe.nmbOfTbs; tbIdx++)
{
datPerLch = datPerTb.lchData[lchIdx];
for(pduIdx = 0; pduIdx < datPerLch.pdu.numPdu; pduIdx++)
{
- dlData->pduInfo[dlData->nmbPdu].commCh = FALSE;
- dlData->pduInfo[dlData->nmbPdu].lcId = datPerLch.lcId;
- dlData->pduInfo[dlData->nmbPdu].pduBuf = datPerLch.pdu.mBuf[pduIdx];
- dlData->nmbPdu++;
+ dlData->pduInfo[dlData->numPdu].commCh = FALSE;
+ dlData->pduInfo[dlData->numPdu].lcId = datPerLch.lcId;
+ dlData->pduInfo[dlData->numPdu].pduBuf = datPerLch.pdu.mBuf[pduIdx];
+ dlData->numPdu++;
}/* For per PDU */
}/* For Data per Lch */
}/* For Data per Tb */
/* Check if to be freed here */
- KW_FREE_SHRABL_BUF(post->region,
+ RLC_FREE_SHRABL_BUF(post->region,
post->pool,
datReqInfo, sizeof(RguDDatReqInfo));
- RETVALUE(ROK);
+ return ROK;
}/* End of KwLiRguDDatReq */
/**
#ifdef ANSI
PUBLIC S16 kwUtlSndToLi
(
-KwCb *gCb,
+RlcCb *gCb,
SuId suId,
KwDStaIndInfo *staIndInfo
)
#else
PUBLIC S16 kwUtlSndToLi(gCb, suId, staIndInfo)
-KwCb *gCb;
+RlcCb *gCb;
SuId suId;
KwDStaIndInfo *staIndInfo;
#endif
{
- KwDlUeCb *ueCb; /* UE control block */
+ RlcDlUeCb *ueCb; /* UE control block */
U32 count; /* Loop Counter */
U32 numTb; /* Number of Tbs */
- KwDlRbCb *rbCb; /* RB Control Block */
+ RlcDlRbCb *rbCb; /* RB Control Block */
KwDatReq datReq; /* PDUs Information */
RguDDatReqInfo *datReqInfo; /* Data Request Information */
KwRguSapCb *rguSap; /* MAC SAP CB */
datReqInfo = NULLP;
- KW_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap->pst.region,
+ RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap->pst.region,
gCb->u.dlCb->rguDlSap->pst.pool,
datReqInfo,sizeof(RguDDatReqInfo));
#if (ERRCLASS & ERRCLS_ADD_RES)
{
RLOG_ARG0(L_FATAL,DBG_CELLID,staIndInfo->cellId,
"Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
for(idx = 0; idx < staIndInfo->nmbOfUeGrantPerTti; idx++)
#endif
rbCb = ueCb->lCh[staIndTb->lchStaInd[count].lcId - 1].dlRbCb;
- if (rbCb && (!kwDlUtlIsReestInProgress(rbCb)))
+ if (rbCb && (!rlcDlUtlIsReestInProgress(rbCb)))
{
//Debug
staIndSz += staIndTb->lchStaInd[count].totBufSize;
#ifdef LTE_L2_MEAS_LOSS_DELAY
if(tbSnMap->numSn == 0)
{
- KW_FREE(tbSnMap,sizeof(KwTbSnMap));
- KW_FREE(datReqTb->rguSnInfo,sizeof(RguSnMapInfo));
+ RLC_FREE(tbSnMap,sizeof(KwTbSnMap));
+ RLC_FREE(datReqTb->rguSnInfo,sizeof(RguSnMapInfo));
datReqTb->rguSnInfo = NULLP;
- kwCb.kwL2Cb.curTbSnMap = NULLP;
+ rlcCb.kwL2Cb.curTbSnMap = NULLP;
datReqTb->snMapPres = FALSE;
}
else
{
- cmHashListInsert(&(kwCb.kwL2Cb.tbHlCp),(PTR)tbSnMap,
+ cmHashListInsert(&(rlcCb.kwL2Cb.tbHlCp),(PTR)tbSnMap,
(U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
- kwCb.kwL2Cb.curTbSnMap = NULLP;
+ rlcCb.kwL2Cb.curTbSnMap = NULLP;
}
#endif /* LTE_L2_MEAS */
}
rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
//Debug
KwLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo);
- RETVALUE(ROK);
+ return ROK;
}
/**
#ifdef ANSI
PUBLIC S16 kwUtlSndDStaRsp
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
S32 bo,
S32 estHdrSz,
Bool staPduPrsnt,
)
#else
PUBLIC S16 kwUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
S32 bo;
S32 estHdrSz;
Bool staPduPrsnt;
&& (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
{
rbCb->boUnRprtdCnt++;
- RETVALUE(ROK);
+ return ROK;
}
#endif
RlcMacSendBOStatus(&rguSap->pst,rguSap->spId,&boStatus);
- RETVALUE(ROK);
+ return ROK;
}
/**
#ifdef ANSI
PUBLIC Void kwUtlEmptySduQ
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
CmLListCp *sduQ
)
#else
PUBLIC Void kwUtlEmptySduQ(gCb,rbCb, sduQ)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
CmLListCp *sduQ;
#endif
#else
#ifdef ANSI
PUBLIC Void kwUtlEmptySduQ
(
-KwCb *gCb,
+RlcCb *gCb,
CmLListCp *sduQ
)
#else
PUBLIC Void kwUtlEmptySduQ(gCb,sduQ)
-KwCb *gCb;
+RlcCb *gCb;
CmLListCp *sduQ;
#endif
#endif
if(sduSnMap != NULLP)
{
cmLListDelFrm(&(rbCb->sduSnMapQ), &(sduSnMap->lstEnt));
- KW_FREE(sduSnMap, sizeof(KwSduSnMap));
+ RLC_FREE(sduSnMap, sizeof(KwSduSnMap));
CM_LLIST_FIRST_NODE(sduSnMapQ, firstSduSnMap);
}
else
#ifdef ANSI
PUBLIC Void kwUtlCalcLiForSdu
(
-KwCb *gCb,
+RlcCb *gCb,
U16 numLi,
MsgLen msgLen,
S16 *pduSz
)
#else
PUBLIC Void kwUtlCalcLiForSdu(gCb,numLi,msgLen,pduSz)
-KwCb *gCb;
+RlcCb *gCb;
U16 numLi;
MsgLen msgLen;
S16 *pduSz;
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwDlUtlSetReestInProgressForRB
+PUBLIC Void rlcDlUtlSetReestInProgressForRB
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwDlUtlSetReestInProgressForRB(gCb,rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+PUBLIC Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlUtlSetReestInProgressForRB)
+ TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = TRUE;
* FALSE : Re-establishment is not in progress
*/
#ifdef ANSI
-PUBLIC Bool kwDlUtlIsReestInProgress
+PUBLIC Bool rlcDlUtlIsReestInProgress
(
-KwDlRbCb *rbCb
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Bool kwDlUtlIsReestInProgress(rbCb)
-KwDlRbCb *rbCb;
+PUBLIC Bool rlcDlUtlIsReestInProgress(rbCb)
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlUtlSetReestInProgressForRB)
+ TRC2(rlcDlUtlSetReestInProgressForRB)
- RETVALUE(rbCb->reestInProgress);
+ return (rbCb->reestInProgress);
}
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwDlUtlResetReestInProgress
+PUBLIC Void rlcDlUtlResetReestInProgress
(
-KwDlRbCb *rbCb
+RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwDlUtlResetReestInProgress(rbCb)
-KwDlRbCb *rbCb;
+PUBLIC Void rlcDlUtlResetReestInProgress(rbCb)
+RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwDlUtlSetReestInProgressForRB)
+ TRC2(rlcDlUtlSetReestInProgressForRB)
rbCb->reestInProgress = FALSE;
}
* @return void
*/
#ifdef ANSI
-PUBLIC Void kwDlUtlSetReestInProgressForAllRBs
+PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs
(
-KwCb *gCb,
-KwDlUeCb *ueCb
+RlcCb *gCb,
+RlcDlUeCb *ueCb
)
#else
-PUBLIC Void kwDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
-KwCb *gCb;
-KwDlUeCb *ueCb;
+PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
+RlcCb *gCb;
+RlcDlUeCb *ueCb;
#endif
{
U32 rbIdx;
- TRC2(kwDlUtlSetReestInProgressForAllRBs)
+ TRC2(rlcDlUtlSetReestInProgressForAllRBs)
for(rbIdx = 0;rbIdx < KW_MAX_SRB_PER_UE;rbIdx++)
{
{
if(ueCb->srbCb[rbIdx]->rlcId.rbId != 1)
{
- kwDlUtlSetReestInProgressForRB(gCb,ueCb->srbCb[rbIdx]);
+ rlcDlUtlSetReestInProgressForRB(gCb,ueCb->srbCb[rbIdx]);
}
else
{
{
if(ueCb->drbCb[rbIdx] != NULLP)
{
- kwDlUtlSetReestInProgressForRB(gCb,ueCb->drbCb[rbIdx]);
+ rlcDlUtlSetReestInProgressForRB(gCb,ueCb->drbCb[rbIdx]);
}
}
#ifdef ANSI
PUBLIC Void kwUtlInitToBeFreed
(
-KwCb *gCb,
-KwDlDataToBeFreed *toBeFreed
+RlcCb *gCb,
+RlcDlDataToBeFreed *toBeFreed
)
#else
PUBLIC Void kwUtlInitToBeFreed(gCb, toBeFreed)
-KwCb *gCb;
-KwDlDataToBeFreed *toBeFreed;
+RlcCb *gCb;
+RlcDlDataToBeFreed *toBeFreed;
#endif
{
cmLListInit(&(toBeFreed->sduLst));
#ifdef ANSI
PUBLIC Void kwUtlInitializeSelfPst
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlInitializeSelfPst(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
Pst *selfPst = &gCb->u.dlCb->selfPst;
- KW_MEM_SET(selfPst, 0, sizeof(Pst));
+ RLC_MEM_SET(selfPst, 0, sizeof(Pst));
selfPst->srcProcId = SFndProcId();
selfPst->dstProcId = SFndProcId();
selfPst->dstEnt = gCb->init.ent;
#ifdef ANSI
PUBLIC Void kwUtlRaiseDlCleanupEvent
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlRaiseDlCleanupEvent(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
#ifdef KWSELFPSTDLCLEAN
#ifdef ANSI
PUBLIC Void kwUtlAddSduToBeFreedQueue
(
-KwCb *gCb,
+RlcCb *gCb,
KwSdu *sdu
)
#else
PUBLIC Void kwUtlAddSduToBeFreedQueue(gCb, sdu)
-KwCb *gCb;
+RlcCb *gCb;
KwSdu *sdu;
#endif
{
#ifdef ANSI
PUBLIC Void kwUtlAddReTxPduToBeFreedQueue
(
-KwCb *gCb,
+RlcCb *gCb,
KwRetx *retx
)
#else
PUBLIC Void kwUtlAddReTxPduToBeFreedQueue(gCb, retx)
-KwCb *gCb;
+RlcCb *gCb;
KwRetx *retx;
#endif
{
#ifdef ANSI
PUBLIC Void kwUtlAddTxPduToBeFreedQueue
(
-KwCb *gCb,
+RlcCb *gCb,
KwTx *pdu
)
#else
PUBLIC Void kwUtlAddTxPduToBeFreedQueue(gCb, pdu)
-KwCb *gCb;
+RlcCb *gCb;
KwTx *pdu;
#endif
{
#ifdef ANSI
PRIVATE Bool kwUtlFreeDlAmRbMemory
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
U32 *toBeFreed
)
#else
PRIVATE Bool kwUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
U32 *toBeFreed
#endif
{
{
while(txBuf->pduLst.first)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(txBuf->pduLst.first->node);
- KW_FREE_BUF(pduInfo->pdu);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
+ RLC_FREE_BUF(pduInfo->pdu);
/* Delete node from the txBuf Pdu lst */
cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
- KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo));
+ RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
kwUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
if(gCb->u.dlCb->shutdownReceived == 0)
}
if(*toBeFreed == 0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
#ifndef LTE_TDD
- KW_FREE(gCb,AMDL.txBufLst, (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,AMDL.txBufLst, (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
while (retx && (*toBeFreed)) /* Till to be freed becomes 0 */
{
- KW_FREE_BUF(retx->seg);
+ RLC_FREE_BUF(retx->seg);
cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
- KW_FREE_WC(gCb, retx, sizeof(KwRetx));
+ RLC_FREE_WC(gCb, retx, sizeof(KwRetx));
KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
if(gCb->u.dlCb->shutdownReceived == 0)
{
Pst *udxPst;
udxPst = &gCb->u.dlCb->udxDlSap->pst;
- KW_FREE_SHRABL_BUF_WC(udxPst->region,
+ RLC_FREE_SHRABL_BUF_WC(udxPst->region,
udxPst->pool,
AMDL.pStaPdu,
sizeof(KwUdxDlStaPdu));
if(*toBeFreed == 0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
if(gCb->u.dlCb->shutdownReceived)
{
(*toBeFreed)--;
}
- RETVALUE(FALSE);;
+ return (FALSE);;
}
/**
#ifdef ANSI
PUBLIC Void kwUtlFreeDlMemory
(
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlFreeDlMemory(gCb)
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 toBeFreed;
RETVOID;
}
- KwDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
+ RlcDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
/* ccpu00136940 */
if(gCb->u.dlCb->shutdownReceived)
{
{
KwRetx* seg = (KwRetx *)(lst->first->node);
cmLListDelFrm(lst, lst->first);
- KW_FREE_BUF_WC(seg->seg);
- KW_FREE_WC(gCb,seg, sizeof(KwRetx));
+ RLC_FREE_BUF_WC(seg->seg);
+ RLC_FREE_WC(gCb,seg, sizeof(KwRetx));
toBeFreed--;
}
cmLListDelFrm(lst, lst->first);
while(pdu->pduLst.first)
{
- KwDlPduInfo *pduInfo = (KwDlPduInfo *)(pdu->pduLst.first->node);
+ RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pdu->pduLst.first->node);
cmLListDelFrm(&pdu->pduLst, pdu->pduLst.first);
- KW_FREE_BUF_WC(pduInfo->pdu);
- KW_FREE_WC(gCb, pduInfo, sizeof(KwDlPduInfo));
+ RLC_FREE_BUF_WC(pduInfo->pdu);
+ RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
}
- KW_FREE_WC(gCb,pdu, sizeof(KwTx));
+ RLC_FREE_WC(gCb,pdu, sizeof(KwTx));
toBeFreed--;
}
while((lst->first) && toBeFreed)
#endif
{
- KwDlRbCb* rbCb = (KwDlRbCb *)(lst->first->node);
+ RlcDlRbCb* rbCb = (RlcDlRbCb *)(lst->first->node);
Bool moreToBeFreed = kwUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
if(!moreToBeFreed)
{
cmLListDelFrm(lst, lst->first);
- KW_FREE_WC(gCb, rbCb, sizeof(KwDlRbCb));
+ RLC_FREE_WC(gCb, rbCb, sizeof(RlcDlRbCb));
}
}
* @return Void
*
*/
-S16 kwUtlL2MeasDlInit(KwCb *gCb)
+S16 kwUtlL2MeasDlInit(RlcCb *gCb)
{
U16 cntr;
gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_UU_LOSS].measCb.measType= LKW_L2MEAS_UU_LOSS;
gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_ACT_UE].measCb.measType= LKW_L2MEAS_ACT_UE;
- RETVALUE(ROK);
+ return ROK;
}
/**
*
#ifdef ANSI
PUBLIC Void kwUtlUpdateBurstSdus
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
KwContSduLst *contSduLst,
S32 dataVol,
U32 schPduSz
)
#else
PUBLIC Void kwUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
KwContSduLst *contSduLst;
S32 dataVol;
U32 schPduSz;
#ifdef ANSI
PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb
(
-KwCb *gCb,
-KwDlRbCb *rbCb
+RlcCb *gCb,
+RlcDlRbCb *rbCb
)
#else
PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb(gCb, rbCb)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
#endif
{
KwL2MeasTb *curL2MeasTb;
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
- /* Intentionally avoiding the KW_ALLOC macro to avoid memset */
+ /* Intentionally avoiding the RLC_ALLOC macro to avoid memset */
if (SGetSBuf(gCb->init.region,
gCb->init.pool,
(Data **)&curL2MeasTb,
(Size)sizeof(KwL2MeasTb)) != ROK)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx] = curL2MeasTb;
/* Initialize the Meas Tb details */
curL2MeasTb->lchInfo[idx].numSdus = 0;
}
}
- RETVALUE(curL2MeasTb);
+ return (curL2MeasTb);
}
#ifdef ANSI
PUBLIC S16 kwUtlProcHarqInd
(
-KwCb *gCb,
+RlcCb *gCb,
RguHarqStatusInd *hqStaInd,
-KwDlUeCb *ueCb,
+RlcDlUeCb *ueCb,
U8 tbIdx
)
#else
PUBLIC S16 kwUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
-KwCb *gCb;
+RlcCb *gCb;
RguHarqStatusInd *hqStaInd;
-KwDlUeCb *ueCb;
+RlcDlUeCb *ueCb;
U8 tbIdx;
#endif
{
#ifdef LTE_L2_MEAS
- KwDlRbCb *kwRbCb; /* KW Control Block */
+ RlcDlRbCb *kwRbCb; /* KW Control Block */
KwL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
U8 lcIdx; /* Logical channel id index */
U8 sduIndx; /* sdu index to out standing sdu list in rbCb */
ret = ROK;
if(hqStaInd->tbId[tbIdx] >= KW_INVALID_TBID)
{
- RETVALUE(ROK);
+ return ROK;
}
/* Find the L2 measurement tbCb to process DL Ip thruput*/
l2MeasTb = ueCb->l2MeasTbCb[hqStaInd->tbId[tbIdx]];
if(l2MeasTb == NULLP)
{
- RETVALUE(ROK);
+ return ROK;
}
/* For each logical channel in the tbCb, process
* and get the DL IP thruput */
}
}
/* Free this tb, deallocate the memory */
- KW_FREE(gCb, l2MeasTb, sizeof(KwL2MeasTb));
+ RLC_FREE(gCb, l2MeasTb, sizeof(KwL2MeasTb));
ueCb->l2MeasTbCb[hqStaInd->tbId[tbIdx]] = NULLP;
/*stopping Task*/
SStopTask(startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
- RETVALUE(ret);
+ return (ret);
}/* end of kwUtlProcHarqInd */
/**
#ifdef ANSI
PUBLIC S16 kwUtlSndDlL2MeasCfm
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasEvtCb *measEvtCb
)
#else
PUBLIC S16 kwUtlSndDlL2MeasCfm(gCb, measEvtCb)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasEvtCb *measEvtCb;
#endif
{
}
/* Fix Klock warning */
KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndL2MeasCfm */
/**
*
#ifdef ANSI
PUBLIC S16 kwUtlSndDlL2MeasNCfm
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasReqEvt *measReqEvt,
KwL2MeasCfmEvt *measCfmEvt
)
#else
PUBLIC S16 kwUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasReqEvt *measReqEvt;
KwL2MeasCfmEvt *measCfmEvt;
#endif
TRC3(kwUtlSndDlL2MeasNCfm)
KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndL2MeasNCfm */
/**
*
PUBLIC Void kwUtlResetDlL2MeasInKwRb
(
-KwCb *gCb,
+RlcCb *gCb,
KwL2MeasCb *measCb,
U8 measType
)
#else
PUBLIC Void kwUtlResetDlL2MeasInKwRb(gCb, measCb, measType)
-KwCb *gCb;
+RlcCb *gCb;
KwL2MeasCb *measCb;
U8 measType;
#endif
{
U32 ueIdx;
U32 qciIdx;
- KwDlUeCb *ueCb = NULL;
+ RlcDlUeCb *ueCb = NULL;
} /* kwUtlResetDlL2MeasInKwRb */
#endif
-PRIVATE Void dumpRLCDlRbInformation(KwDlRbCb* dlRbCb)
+PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
{
if(dlRbCb->mode == CM_LTE_MODE_UM)
{
Void DumpRLCDlDebugInformation(Void)
{
- KwCb* dlInst = kwCb[1]; /* TODO : Check whether DL is 0 or 1 */
+ RlcCb* dlInst = rlcCb[1]; /* TODO : Check whether DL is 0 or 1 */
- KwDlCb *dlCb = dlInst->u.dlCb;
+ RlcDlCb *dlCb = dlInst->u.dlCb;
- KwDlUeCb *ueCb = NULLP;
+ RlcDlUeCb *ueCb = NULLP;
RTLIN_DUMP_DEBUG("RLC Information\n");
RTLIN_DUMP_DEBUG("===============\n");
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
U32 i;
for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
{
- KwDlRbCb* dlRbCb = ueCb->srbCb[i];
+ RlcDlRbCb* dlRbCb = ueCb->srbCb[i];
if( dlRbCb != NULLP)
{
dumpRLCDlRbInformation(dlRbCb);
}
for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
{
- KwDlRbCb* dlRbCb = ueCb->drbCb[i];
+ RlcDlRbCb* dlRbCb = ueCb->drbCb[i];
if( dlRbCb != NULLP)
{
dumpRLCDlRbInformation(dlRbCb);
}
}
- KwDlDataToBeFreed* pToBeFreed = &dlCb->toBeFreed;
+ RlcDlDataToBeFreed* pToBeFreed = &dlCb->toBeFreed;
RTLIN_DUMP_DEBUG("toBeFreed RETX list size = %d\n",(int)pToBeFreed->reTxLst.count);
RTLIN_DUMP_DEBUG("toBeFreed TX list size = %d\n",(int)pToBeFreed->txLst.count);
Void;
#endif
{
- kwUtlFreeDlMemory(KW_GET_KWCB(KW_DL_INST));
+ kwUtlFreeDlMemory(RLC_GET_RLCCB(KW_DL_INST));
}
/**
#ifdef ANSI
PUBLIC Void kwUtlTrigPdbFlowCntrl
(
-KwCb *gCb,
-KwDlRbCb *rbCb,
+RlcCb *gCb,
+RlcDlRbCb *rbCb,
U32 pktAdmitCnt
)
#else
PUBLIC Void kwUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
-KwCb *gCb;
-KwDlRbCb *rbCb;
+RlcCb *gCb;
+RlcDlRbCb *rbCb;
U32 pktAdmitCnt;
#endif
{
kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
- KW_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
+ RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region,
kwuSap->pst.pool,
flowCntrlInfo,
sizeof(KwuFlowCntrlIndInfo));
txBuf = (KwTx *) node->node;
if(txBuf->sn == sn)
{
- RETVALUE(txBuf);
+ return (txBuf);
}
CM_LLIST_NEXT_NODE(txBufLstCp, node);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* kwUtlStoreTxBuf */
/**
*
(
CmLListCp *txBufLst,
KwTx *txBuf,
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlDelTxBuf(txBufLst, txBuf, gCb)
CmLListCp *txBufLst;
KwTx *txBuf;
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 hashKey;
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
- KW_FREE_WC(gCb, txBuf, sizeof(KwTx));
+ RLC_FREE_WC(gCb, txBuf, sizeof(KwTx));
RETVOID;
} /* kwUtlDelTxBuf */
(
CmLListCp *txBufLst,
KwTx *txBuf,
-KwCb *gCb
+RlcCb *gCb
)
#else
PUBLIC Void kwUtlRemovTxBuf(txBufLst, txBuf, gCb)
CmLListCp *txBufLst;
KwTx *txBuf;
-KwCb *gCb;
+RlcCb *gCb;
#endif
{
U32 hashKey;
Code Review / o-du / l2.git / blobdiff