Desc: Source code for RLC Utility Module
This file contains following functions
- --kwUtlSndToLi
- --kwUtlRcvFrmLi
- --kwUtlEmptySduQ
- --kwUtlSndDatInd
+ --rlcUtlSndToLi
+ --rlcUtlRcvFrmLi
+ --rlcUtlEmptySduQ
+ --rlcUtlSndDatInd
--kwUtlShutDown
File: kw_utl_ul.c
#include "ss_rbuf.h"
#include "ss_rbuf.x"
#ifdef SS_RBUF
-PUBLIC S16 SMrkUlPkt(Buffer *mbuf);
+S16 SMrkUlPkt(Buffer *mbuf);
#endif
-PUBLIC KwAmRecBuf* kwUtlGetRecBuf(CmLListCp *recBufLst, KwSn sn);
-#define KW_MODULE (KW_DBGMASK_DUT | KW_DBGMASK_UL) /* for debugging purpose */
+RlcAmRecBuf* rlcUtlGetRecBuf(CmLListCp *recBufLst, RlcSn sn);
+#define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_UL) /* for debugging purpose */
/**
*
*/
#ifdef ANSI
-PUBLIC S16 kwUtlRcvFrmLi
+S16 rlcUtlRcvFrmLi
(
-KwCb *gCb,
+RlcCb *gCb,
KwDatIndInfo *datIndInfo
)
#else
-PUBLIC S16 kwUtlRcvFrmLi(gCb,datIndInfo)
-KwCb *gCb;
+S16 rlcUtlRcvFrmLi(gCb,datIndInfo)
+RlcCb *gCb;
KwDatIndInfo *datIndInfo;
#endif
{
U32 count; /* Loop Counter */
KwPduInfo *pduInfo; /* PDU Information */
- KwUlRbCb *rbCb; /* RB Control Block */
- KwUlUeCb *ueCb; /* UE Control Block */
+ RlcUlRbCb *rbCb; /* RB Control Block */
+ RlcUlUeCb *ueCb; /* UE Control Block */
/* kw005.201 added support for L2 Measurement */
- TRC2(kwUtlRcvFrmLi)
+ TRC2(rlcUtlRcvFrmLi)
ueCb = NULLP;
/* fetch UeCb */
- if( ROK != kwDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
+ if( ROK != rlcDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
{
/* Fetch UeCb failed */
RLOG_ARG1(L_ERROR,DBG_CELLID,datIndInfo->cellId,
{
if(datIndInfo->lchData[i].pdu.mBuf[j])
{
- KW_FREE_BUF_WC(datIndInfo->lchData[i].pdu.mBuf[j]);
+ RLC_FREE_BUF_WC(datIndInfo->lchData[i].pdu.mBuf[j]);
}
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
{
if(pduInfo->mBuf[j])
{
- KW_FREE_BUF_WC(pduInfo->mBuf[j]);
+ RLC_FREE_BUF_WC(pduInfo->mBuf[j]);
}
}
continue;
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- kwUmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
+ rlcUmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
#else
- kwUmmProcessPdus(gCb,rbCb,pduInfo);
+ rlcUmmProcessPdus(gCb,rbCb,pduInfo);
#endif
}
else if (rbCb->mode == CM_LTE_MODE_AM )
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- kwAmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
+ rlcAmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
#else
- kwAmmProcessPdus(gCb,rbCb,pduInfo);
+ rlcAmmProcessPdus(gCb,rbCb,pduInfo);
#endif
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndDatInd
+S16 rlcUtlSndDatInd
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *sdu
)
#else
-PUBLIC S16 kwUtlSndDatInd(gCb,rbCb,sdu)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+S16 rlcUtlSndDatInd(gCb,rbCb,sdu)
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
Buffer *sdu;
#endif
{
KwuDatIndInfo datIndInfoTmp;
#endif
- TRC3(kwUtlSndDatInd)
+ TRC3(rlcUtlSndDatInd)
#ifndef KW_PDCP
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- KW_FREE_BUF(sdu);
- RETVALUE(RFAILED);
+ RLC_FREE_BUF(sdu);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- KW_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
+ RLC_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
/* Set the "isOutofSeq" flag for each packet
* If packets are in-sequence set flag as TRUE else FALSE */
datIndInfo->isOutOfSeq = rbCb->m.amUl.isOutOfSeq;
if(gCb->init.trc == TRUE)
{
/* Populate the trace params */
- kwLmmSendTrc(gCb,KWU_EVT_DAT_IND, sdu);
+ rlcLmmSendTrc(gCb,KWU_EVT_DAT_IND, sdu);
}
#ifndef KW_PDCP
- KwUiKwuDatInd(&gCb->genCfg.lmPst, datIndInfo, sdu);
+ RlcUiKwuDatInd(&gCb->genCfg.lmPst, datIndInfo, sdu);
#endif
- RETVALUE(ROK);
-} /* kwUtlSndDatInd */
+ return (ROK);
+} /* rlcUtlSndDatInd */
-PRIVATE Void dumpRLCUlRbInformation(KwUlRbCb* ulRbCb)
+PRIVATE Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
{
if(ulRbCb->mode == CM_LTE_MODE_UM)
{
U32 i;
U32 pdusInReceptionBuffer = 0;
U32 totalSegs = 0;
- U32 windSz = KW_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
+ U32 windSz = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
for(i = 0; i< windSz; i++)
{
- KwAmRecBuf *recBuf = kwUtlGetRecBuf(ulRbCb->m.amUl.recBufLst, i);
+ RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(ulRbCb->m.amUl.recBufLst, i);
if(recBuf != NULLP)
{
pdusInReceptionBuffer++;
Void DumpRLCUlDebugInformation(Void)
{
- KwCb* ulInst = kwCb[0]; /* TODO : Check whether UL is 0 or 1 */
- KwUlCb* ulCb = ulInst->u.ulCb;
- KwUlUeCb *ueCb = NULLP;
+ RlcCb* ulInst = rlcCb[0]; /* TODO : Check whether UL is 0 or 1 */
+ RlcUlCb* ulCb = ulInst->u.ulCb;
+ RlcUlUeCb *ueCb = NULLP;
/* Until no more ueCb is ueLstCp hash list get and delete ueCb */
while (ROK == cmHashListGetNext(&ulCb->ueLstCp,
(PTR *)&ueCb))
{
U32 i;
- for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
+ for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
- KwUlRbCb* ulRbCb = ueCb->srbCb[i];
+ RlcUlRbCb* ulRbCb = ueCb->srbCb[i];
if(ulRbCb != NULLP)
{
dumpRLCUlRbInformation(ulRbCb);
}
}
- for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
+ for(i = 0; i< RLC_MAX_DRB_PER_UE; i++)
{
- KwUlRbCb* ulRbCb = ueCb->drbCb[i];
+ RlcUlRbCb* ulRbCb = ueCb->drbCb[i];
if(ulRbCb != NULLP)
{
dumpRLCUlRbInformation(ulRbCb);
/*
* kwUtlFreeUlRbCb() function is split into two functions
- * - kwAmmFreeUlRbCb() ---> gp_amm_ul.c
- * - kwUmmFreeUlRbCb() ---> gp_umm_ul.c
+ * - rlcAmmFreeUlRbCb() ---> gp_amm_ul.c
+ * - rlcUmmFreeUlRbCb() ---> gp_umm_ul.c
* and placed in respective files mentioned above
*/
* @return S16
* -# ROK
*/
-S16 kwUtlL2MeasUlInit(KwCb *gCb)
+S16 rlcUtlL2MeasUlInit(RlcCb *gCb)
{
U16 cntr;
- gCb->u.ulCb->kwL2Cb.kwNumMeas=0;
+ gCb->u.ulCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]), 0, sizeof(KwL2MeasEvtCb));
+ cmMemset((U8 *)&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
- gCb->u.ulCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
- RETVALUE(ROK);
+ gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
+ return ROK;
}
/**
*
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlCalUlIpThrPutIncTTI
+ Void rlcUtlCalUlIpThrPutIncTTI
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
U32 ttiCnt
)
#else
-PUBLIC Void kwUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
-KwCb *gCb;
-KwUlRbCb *rbCb;
+Void rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
U32 ttiCnt;
#endif
{
VOLATILE U32 startTime = 0;
- TRC2(kwUtlCalUlIpThrPutIncTTI)
+ TRC2(rlcUtlCalUlIpThrPutIncTTI)
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
#endif
/*Check if UL IP throughput measurement is ON for this RB or not*/
- if(KW_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb,rbCb))
{
if (TRUE == rbCb->ueCb->isUlBurstActive)
{
}
if (rbCb->l2MeasIpThruput.prevTtiCnt != 0)
{
- rbCb->rbL2Cb.l2Sts[KW_L2MEAS_UL_IP]->ulIpThruput.timeSummation +=
+ rbCb->rbL2Cb.l2Sts[RLC_L2MEAS_UL_IP]->ulIpThruput.timeSummation +=
(ttiCnt - rbCb->l2MeasIpThruput.prevTtiCnt);
}
else
/*stopping Task*/
SStopTask(startTime, PID_RLC_IP_TPT_INCTTI);
-} /* kwUtlCalUlIpThrPutIncTTI */
+} /* rlcUtlCalUlIpThrPutIncTTI */
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlCalUlIpThrPut
+ Void rlcUtlCalUlIpThrPut
(
-KwCb *gCb,
-KwUlRbCb *rbCb,
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
Buffer *pdu,
U32 ttiCnt
)
#else
-PUBLIC Void kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
- KwCb *gCb;
- KwUlRbCb *rbCb;
+Void rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
+ RlcCb *gCb;
+ RlcUlRbCb *rbCb;
Buffer *pdu;
U32 ttiCnt;
#endif
{
MsgLen rlcSduSz = 0; /*Holds length of Rlc Sdu*/
VOLATILE U32 startTime = 0;
- TRC2(kwUtlCalUlIpThrPut)
+ TRC2(rlcUtlCalUlIpThrPut)
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCVOL);
/*Check if UL IP throughput measurement is ON for this RB or not*/
- if(KW_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb, rbCb) &&
+ if(RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb, rbCb) &&
(TRUE == rbCb->ueCb->isUlBurstActive) &&
(rbCb->ueCb->firstPacketTTI) &&
(ttiCnt != rbCb->ueCb->firstPacketTTI))
{
SFndLenMsg(pdu, &rlcSduSz);
- rbCb->rbL2Cb.l2Sts[KW_L2MEAS_UL_IP]->ulIpThruput.volSummation += rlcSduSz;
+ rbCb->rbL2Cb.l2Sts[RLC_L2MEAS_UL_IP]->ulIpThruput.volSummation += rlcSduSz;
}
/*stopping Task*/
SStopTask(startTime, PID_RLC_IP_TPT_INCVOL);
-} /* kwUtlCalUlIpThrPut */
+} /* rlcUtlCalUlIpThrPut */
\f
/**
*/
#ifdef ANSI
-PUBLIC S16 kwUtlHdlL2TmrExp
+S16 rlcUtlHdlL2TmrExp
(
-KwCb *gCb,
-KwL2MeasEvtCb *measEvtCb
+RlcCb *gCb,
+RlcL2MeasEvtCb *measEvtCb
)
#else
-PUBLIC S16 kwUtlHdlL2TmrExp(measEvtCb)
-KwCb *gCb;
-KwL2MeasEvtCb *measEvtCb;
+S16 rlcUtlHdlL2TmrExp(measEvtCb)
+RlcCb *gCb;
+RlcL2MeasEvtCb *measEvtCb;
#endif
{
- TRC3(kwUtlHdlL2TmrExp)
+ TRC3(rlcUtlHdlL2TmrExp)
#ifdef LTE_L2_MEAS_RLC
U16 qciIdx;
- KwL2MeasCb *measCb;
+ RlcL2MeasCb *measCb;
/* Clean up the RB data structures */
if((measEvtCb->measCb.measType & LKW_L2MEAS_ACT_UE) &&
for(qciIdx = 0; qciIdx < measCb->val.nonIpThMeas.numQci;qciIdx++)
{
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.numActvUe +=
- kwCb.kwL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
+ rlcCb.rlcL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.sampOc++;
}
measEvtCb->val.nonIpThMeas.measCb.numSamples--;
- kwStartTmr(gCb, (PTR)measEvtCb, KW_EVT_L2_TMR);
- RETVALUE(ROK);
+ rlcStartTmr(gCb, (PTR)measEvtCb, RLC_EVT_L2_TMR);
+ return (ROK);
}
#endif
- kwUtlSndUlL2MeasCfm(gCb, measEvtCb);
+ rlcUtlSndUlL2MeasCfm(gCb, measEvtCb);
- RETVALUE(ROK);
-} /* kwUtlHdlL2TmrExp */
+ return (ROK);
+} /* rlcUtlHdlL2TmrExp */
/**
*
* @brief Handler for Sending L2 Measurement confirm.
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndUlL2MeasCfm
+S16 rlcUtlSndUlL2MeasCfm
(
-KwCb *gCb,
-KwL2MeasEvtCb *measEvtCb
+RlcCb *gCb,
+RlcL2MeasEvtCb *measEvtCb
)
#else
-PUBLIC S16 kwUtlSndUlL2MeasCfm(gCb, measEvtCb)
-KwCb *gCb;
-KwL2MeasEvtCb *measEvtCb;
+S16 rlcUtlSndUlL2MeasCfm(gCb, measEvtCb)
+RlcCb *gCb;
+RlcL2MeasEvtCb *measEvtCb;
#endif
{
U32 qciIdx;
- KwL2MeasCb *measCb;
- KwL2MeasCfmEvt measCfmEvt;
+ RlcL2MeasCb *measCb;
+ RlcL2MeasCfmEvt measCfmEvt;
U64 ulDataVol;
U64 ulTime;
U32 cfmIdx =0;
/* Discard new changes ends */
- TRC3(kwUtlSndUlL2MeasCfm)
+ TRC3(rlcUtlSndUlL2MeasCfm)
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- RLOG1(L_DEBUG,"kwUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- RLOG1(L_DEBUG,"kwUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
+ RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt));
+ cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
if( measCb->measType & LKW_L2MEAS_UL_IP)
{
- KwL2MeasCbUeMeasInfo *pUeInfoLstCb = measCb->val.ipThMeas.ueInfoLst;
- KwL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
+ RlcL2MeasCbUeMeasInfo *pUeInfoLstCb = measCb->val.ipThMeas.ueInfoLst;
+ RlcL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
for(cntr = 0;(cntr < measCb->val.ipThMeas.numUes) && (cntr < gCb->genCfg.maxUe);cntr++)
{
pUeInfoLstCfm[cfmIdx].numCfm = 0;
}
measCfmEvt.val.ipThMeas.numUes = cfmIdx;
}
- KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
- RETVALUE(ROK);
-} /* kwUtlSndUlL2MeasCfm */
+ RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
+ return (ROK);
+} /* rlcUtlSndUlL2MeasCfm */
/**
*
* @brief Handler for Sending Negative confirm .
*/
#ifdef ANSI
-PUBLIC S16 kwUtlSndUlL2MeasNCfm
+S16 rlcUtlSndUlL2MeasNCfm
(
-KwCb *gCb,
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt
+RlcCb *gCb,
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt
)
#else
-PUBLIC S16 kwUtlSndUlL2MeasNCfm(gCb, measReqEvt, measCfmEvt)
-KwCb *gCb;
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+S16 rlcUtlSndUlL2MeasNCfm(gCb, measReqEvt, measCfmEvt)
+RlcCb *gCb;
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- TRC3(kwUtlSndUlL2MeasNCfm)
+ TRC3(rlcUtlSndUlL2MeasNCfm)
- KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
- RETVALUE(ROK);
+ RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
+ return ROK;
} /* kwUtlSndL2MeasNCfm */
#ifdef LTE_L2_MEAS_RLC
*
* @details
*
- * Function :kwUtlValidateL2Meas
+ * Function :rlcUtlValidateL2Meas
*
* @param[in] measReqEvt L2 measurement request received from layer manager.
* @param[out] measCfmEvt L2 measurement confirm to be prepared.
**/
#ifdef ANSI
-PUBLIC S16 kwUtlValidateL2Meas
+S16 rlcUtlValidateL2Meas
(
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt,
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt,
CmLteLcId *lChId,
U8 *numLCh
)
#else
-PUBLIC S16 kwUtlValidateL2Meas(measReqEvt, measCfmEvt, lChId, numLCh)
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+S16 rlcUtlValidateL2Meas(measReqEvt, measCfmEvt, lChId, numLCh)
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
CmLteLcId *lChId;
U8 *numLCh;
#endif
{
- U8 measType;
- S16 ret;
- U8 qciIdx;
- U8 qci;
- U8 idx;
- U8 *qciVal;
- U8 numQci;
- KwRbCb *rbCb;
-
- KwUeCb *ueCb;
+ U8 measType;
+ S16 ret;
+ U8 qciIdx;
+ U8 qci;
+ U8 idx;
+ U8 *qciVal;
+ U8 numQci;
+ RlcUlRbCb *rbCb;
+
+ RlcUlUeCb *ueCb;
RbCb **rbCbLst;
U8 rbIdx;
U8 lsbNibble = 0;
U8 numFaild = 0;
- TRC3(kwUtlValidateL2Meas)
+ TRC3(rlcUtlValidateL2Meas)
idx = 0;
rbCb = NULLP;
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*User can either request for Active UE,*
*Dl delay, Dl discard, Uu Loss OR Dl ip throughput, Ul ip throughput. */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check for total maximum number of Measurement Control Block */
- if(kwCb.kwL2Cb.kwNumMeas >= LKW_MAX_L2MEAS )
+ if(rlcCb.rlcL2Cb.rlcNumMeas >= LKW_MAX_L2MEAS )
{
measCfmEvt->transId = measReqEvt->transId;
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_EXCEED_NUMMEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check that number of samples should be a non-zero value */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_ZERO_NUMSAM;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check that measurement period should be completely divisible *
* number of sample. */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_NUMSAM;
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
numQci = measReqEvt->measReq.val.nonIpThMeas.numQci;
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
qci = qciVal[qciIdx];
- ret = cmHashListFind(&(kwCb.kwL2Cb.qciHlCp),
+ ret = cmHashListFind(&(rlcCb.rlcL2Cb.qciHlCp),
(U8 *)&qci, (U16)sizeof(qci), 0, (PTR *)&rbCb);
if(ret != ROK)
{
measCfmEvt->status.reason = LKW_CAUSE_INVALID_QCI;
measCfmEvt->measType = measType;
measCfmEvt->transId = measReqEvt->transId;
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
- if(kwCb.kwL2Cb.measOn[qci] & measReqEvt->measReq.measType)
+ if(rlcCb.rlcL2Cb.measOn[qci] & measReqEvt->measReq.measType)
{
/* measurement is already ongoing */
measCfmEvt->status.status = LCM_PRIM_NOK;
if(measCfmEvt->val.nonIpThMeas.numCfm > 0)
{
measCfmEvt->transId = measReqEvt->transId;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
-}/* kwUtlValidateL2Meas */
+ return (ROK);
+}/* rlcUtlValidateL2Meas */
#endif
#ifdef ANSI
-PUBLIC S16 kwUtlValidateIpThL2Meas
+S16 rlcUtlValidateIpThL2Meas
(
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt
)
#else
-PUBLIC S16 kwUtlValidateIpThL2Meas(measReqEvt, measCfmEvt)
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+S16 rlcUtlValidateIpThL2Meas(measReqEvt, measCfmEvt)
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
U8 measType;
U8 lsbNibble = 0;
U8 msbNibble = 0;
- TRC3(kwUtlValidateIpThL2Meas)
+ TRC3(rlcUtlValidateIpThL2Meas)
measType = measReqEvt->measReq.measType;
/* Check for the range of measType */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*User can either request for Active UE,*
*Dl delay, Dl discard, Uu Loss OR Dl ip throughput, Ul ip throughput. */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
-}/* kwUtlValidateL2Meas */
+ return (ROK);
+}/* rlcUtlValidateL2Meas */
/**
*
*/
#ifdef ANSI
-PUBLIC Void kwUtlResetUlL2MeasInKwRb
+Void rlcUtlResetUlL2MeasInRlcRb
(
-KwCb *gCb,
-KwL2MeasCb *measCb,
+RlcCb *gCb,
+RlcL2MeasCb *measCb,
U8 measType
)
#else
-PUBLIC Void kwUtlResetUlL2MeasInKwRb(measCb, measType)
-KwCb *gCb;
-KwL2MeasCb *measCb;
+Void rlcUtlResetUlL2MeasInRlcRb(measCb, measType)
+RlcCb *gCb;
+RlcL2MeasCb *measCb;
U8 measType;
#endif
{
U32 rbIdx;
U32 ueIdx;
U32 qciIdx;
- KwUlUeCb *ueCb = NULL;
+ RlcUlUeCb *ueCb = NULL;
}
}
- if(ROK != kwDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
+ if(ROK != rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId, &ueCb))
{
continue;
}
- for (rbIdx = 0; rbIdx < KW_MAX_DRB_PER_UE; rbIdx++)
+ for (rbIdx = 0; rbIdx < RLC_MAX_DRB_PER_UE; rbIdx++)
{
if (ueCb->drbCb[rbIdx])
{
}
}
}
-} /* kwUtlResetUlL2MeasInKwRb */
+} /* rlcUtlResetUlL2MeasInRlcRb */
/**
*
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void kwUtlPlcMeasDatInL2Sts
+Void rlcUtlPlcMeasDatInL2Sts
(
-KwL2Cntr *measData,
-KwL2MeasRbCb *rbL2Cb,
+RlcL2Cntr *measData,
+RlcL2MeasRbCb *rbL2Cb,
U8 measType
)
#else
-PUBLIC Void kwUtlPlcMeasDatInL2Sts(measData, rbL2Cb, measType)
-KwL2Cntr *measData;
-KwL2MeasRbCb *rbL2Cb;
+Void rlcUtlPlcMeasDatInL2Sts(measData, rbL2Cb, measType)
+RlcL2Cntr *measData;
+RlcL2MeasRbCb *rbL2Cb;
U8 measType;
#endif
{
- TRC3(kwUtlPlcMeasDatInL2Sts)
+ TRC3(rlcUtlPlcMeasDatInL2Sts)
/* We should check the number of measType in the request. This can be done
* by looking at each bit in the measType. Also store the measData in the
if(measType & LKW_L2MEAS_ACT_UE)
{
- rbL2Cb->l2Sts[KW_L2MEAS_ACT_UE] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_ACT_UE] = measData;
}
if(measType & LKW_L2MEAS_UU_LOSS)
{
- rbL2Cb->l2Sts[KW_L2MEAS_UU_LOSS] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_UU_LOSS] = measData;
}
if(measType & LKW_L2MEAS_DL_IP )
{
- rbL2Cb->l2Sts[KW_L2MEAS_DL_IP] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_DL_IP] = measData;
}
if(measType & LKW_L2MEAS_UL_IP)
{
- rbL2Cb->l2Sts[KW_L2MEAS_UL_IP] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_UL_IP] = measData;
}
if(measType & LKW_L2MEAS_DL_DISC)
{
- rbL2Cb->l2Sts[KW_L2MEAS_DL_DISC] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_DL_DISC] = measData;
}
if(measType & LKW_L2MEAS_DL_DELAY)
{
- rbL2Cb->l2Sts[KW_L2MEAS_DL_DELAY] = measData;
+ rbL2Cb->l2Sts[RLC_L2MEAS_DL_DELAY] = measData;
}
-}/* End of kwUtlPlcMeasDatInL2Sts */
+}/* End of rlcUtlPlcMeasDatInL2Sts */
#endif /* LTE_L2_MEAS */
/**
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlStoreRecBuf
+Void rlcUtlStoreRecBuf
(
CmLListCp *recBufLst,
-KwAmRecBuf *recBuf,
-KwSn sn
+RlcAmRecBuf *recBuf,
+RlcSn sn
)
#else
-PUBLIC Void kwUtlStoreRecBuf(recBufLst, recBuf, sn)
+Void rlcUtlStoreRecBuf(recBufLst, recBuf, sn)
CmLListCp *recBufLst;
-KwAmRecBuf *recBuf;
-KwSn sn;
+RlcAmRecBuf *recBuf;
+RlcSn sn;
#endif
{
U32 hashKey;
- TRC3(kwUtlStoreRecBuf)
+ TRC3(rlcUtlStoreRecBuf)
- hashKey = (sn % KW_RCV_BUF_BIN_SIZE );
+ hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
recBuf->lnk.node = (PTR)recBuf;
cmLListAdd2Tail(&(recBufLst[hashKey]), &recBuf->lnk);
RETVOID;
-} /* kwUtlStoreRecBuf */
+} /* rlcUtlStoreRecBuf */
/**
*
* @return Void
*/
#ifdef ANSI
-PUBLIC KwAmRecBuf* kwUtlGetRecBuf
+RlcAmRecBuf* rlcUtlGetRecBuf
(
CmLListCp *recBufLst,
-KwSn sn
+RlcSn sn
)
#else
-PUBLIC KwAmRecBuf* kwUtlGetRecBuf(recBufLst, sn)
+RlcAmRecBuf* rlcUtlGetRecBuf(recBufLst, sn)
CmLListCp *recBufLst;
-KwSn sn;
+RlcSn sn;
#endif
{
U32 hashKey;
CmLListCp *recBufLstCp;
- KwAmRecBuf *recBuf;
+ RlcAmRecBuf *recBuf;
CmLList *node = NULLP;
- TRC3(kwUtlGetRecBuf)
+ TRC3(rlcUtlGetRecBuf)
- hashKey = (sn % KW_RCV_BUF_BIN_SIZE );
+ hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
recBufLstCp = &recBufLst[hashKey];
CM_LLIST_FIRST_NODE(recBufLstCp, node);
while(node)
{
- recBuf = (KwAmRecBuf *) node->node;
+ recBuf = (RlcAmRecBuf *) node->node;
if(recBuf->amHdr.sn == sn)
{
- RETVALUE(recBuf);
+ return (recBuf);
}
CM_LLIST_NEXT_NODE(recBufLstCp, node);
}
- RETVALUE(NULLP);
-} /* kwUtlStoreRecBuf */
+ return (NULLP);
+} /* rlcUtlStoreRecBuf */
/**
*
* @brief Delete the UL buffer from the list
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUtlDelRecBuf
+Void rlcUtlDelRecBuf
(
CmLListCp *recBufLst,
-KwAmRecBuf *recBuf,
-KwCb *gCb
+RlcAmRecBuf *recBuf,
+RlcCb *gCb
)
#else
-PUBLIC Void kwUtlDelRecBuf(recBufLst, recBufi, gCb)
+Void rlcUtlDelRecBuf(recBufLst, recBufi, gCb)
CmLListCp *recBufLst;
-KwAmRecBuf *recBuf;
-KwCb *gCb;
+RlcAmRecBuf *recBuf;
+RlcCb *gCb;
#endif
{
U32 hashKey;
CmLListCp *recBufLstCp;
- TRC3(kwUtlDelRecBuf)
+ TRC3(rlcUtlDelRecBuf)
- hashKey = (recBuf->amHdr.sn % KW_RCV_BUF_BIN_SIZE );
+ hashKey = (recBuf->amHdr.sn % RLC_RCV_BUF_BIN_SIZE );
recBufLstCp = &recBufLst[hashKey];
cmLListDelFrm(recBufLstCp, &recBuf->lnk);
- KW_FREE_WC(gCb, recBuf, sizeof(KwAmRecBuf));
+ RLC_FREE_WC(gCb, recBuf, sizeof(RlcAmRecBuf));
RETVOID;
-} /* kwUtlDelRecBuf */
+} /* rlcUtlDelRecBuf */
Code Review / o-du / l2.git / blobdiff