X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_utl_ul.c;h=1b70dcec66256d890fa5bfb2b204a88549cf0c28;hb=088bb8763eaf91c139ede025faf2fac7e57d25ed;hp=9baac7352cb5f7b0d5d06eda17cdfb6daa7818a3;hpb=8340c342ebcfc82193c3f66e7f15047c1e37399b;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_utl_ul.c b/src/5gnrrlc/kw_utl_ul.c index 9baac7352..1b70dcec6 100755 --- a/src/5gnrrlc/kw_utl_ul.c +++ b/src/5gnrrlc/kw_utl_ul.c @@ -25,10 +25,10 @@ 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 @@ -43,22 +43,12 @@ static int RLOG_FILE_ID=210; */ /* 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 #endif -#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" /* KWU defines */ #include "lkw.h" /* LKW defines */ @@ -70,16 +60,6 @@ static int RLOG_FILE_ID=210; #include "kw_ul.h" /* RLC Uplink defines */ /* 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 includes */ @@ -90,10 +70,10 @@ static int RLOG_FILE_ID=210; #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 */ /** @@ -116,30 +96,30 @@ PUBLIC KwAmRecBuf* kwUtlGetRecBuf(CmLListCp *recBufLst, KwSn sn); * */ #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, @@ -153,12 +133,12 @@ KwDatIndInfo *datIndInfo; { 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 @@ -188,7 +168,7 @@ KwDatIndInfo *datIndInfo; { if(pduInfo->mBuf[j]) { - KW_FREE_BUF_WC(pduInfo->mBuf[j]); + RLC_FREE_BUF_WC(pduInfo->mBuf[j]); } } continue; @@ -201,22 +181,22 @@ KwDatIndInfo *datIndInfo; { /* 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; } /** @@ -235,16 +215,16 @@ KwDatIndInfo *datIndInfo; * -# 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 { @@ -253,7 +233,7 @@ Buffer *sdu; KwuDatIndInfo datIndInfoTmp; #endif - TRC3(kwUtlSndDatInd) + TRC3(rlcUtlSndDatInd) #ifndef KW_PDCP @@ -268,12 +248,12 @@ Buffer *sdu; "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; @@ -283,17 +263,17 @@ Buffer *sdu; 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) { @@ -320,11 +300,11 @@ PRIVATE Void dumpRLCUlRbInformation(KwUlRbCb* ulRbCb) 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++; @@ -344,9 +324,9 @@ PRIVATE Void dumpRLCUlRbInformation(KwUlRbCb* ulRbCb) 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, @@ -354,17 +334,17 @@ Void DumpRLCUlDebugInformation(Void) (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); @@ -376,8 +356,8 @@ Void DumpRLCUlDebugInformation(Void) /* * 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 */ @@ -396,17 +376,17 @@ Void DumpRLCUlDebugInformation(Void) * @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; } /** * @@ -424,21 +404,21 @@ S16 kwUtlL2MeasUlInit(KwCb *gCb) * */ #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); @@ -457,7 +437,7 @@ U32 ttiCnt; #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) { @@ -467,7 +447,7 @@ U32 ttiCnt; } 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 @@ -484,7 +464,7 @@ U32 ttiCnt; /*stopping Task*/ SStopTask(startTime, PID_RLC_IP_TPT_INCTTI); -} /* kwUtlCalUlIpThrPutIncTTI */ +} /* rlcUtlCalUlIpThrPutIncTTI */ /** @@ -503,43 +483,43 @@ U32 ttiCnt; * */ #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 */ /** @@ -560,22 +540,22 @@ PUBLIC Void kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt) */ #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) && @@ -586,19 +566,19 @@ KwL2MeasEvtCb *measEvtCb; 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. @@ -616,20 +596,20 @@ KwL2MeasEvtCb *measEvtCb; */ #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; @@ -639,19 +619,19 @@ KwL2MeasEvtCb *measEvtCb; 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; @@ -660,8 +640,8 @@ KwL2MeasEvtCb *measEvtCb; 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; @@ -702,9 +682,9 @@ KwL2MeasEvtCb *measEvtCb; } 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 . @@ -724,23 +704,23 @@ KwL2MeasEvtCb *measEvtCb; */ #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 @@ -749,7 +729,7 @@ KwL2MeasCfmEvt *measCfmEvt; * * @details * - * Function :kwUtlValidateL2Meas + * Function :rlcUtlValidateL2Meas * * @param[in] measReqEvt L2 measurement request received from layer manager. * @param[out] measCfmEvt L2 measurement confirm to be prepared. @@ -759,31 +739,31 @@ KwL2MeasCfmEvt *measCfmEvt; **/ #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; @@ -791,7 +771,7 @@ U8 *numLCh; U8 numFaild = 0; - TRC3(kwUtlValidateL2Meas) + TRC3(rlcUtlValidateL2Meas) idx = 0; rbCb = NULLP; @@ -806,7 +786,7 @@ U8 *numLCh; 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. */ @@ -819,17 +799,17 @@ U8 *numLCh; 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 */ @@ -840,7 +820,7 @@ U8 *numLCh; 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. */ @@ -852,7 +832,7 @@ U8 *numLCh; 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; @@ -862,7 +842,7 @@ U8 *numLCh; 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) { @@ -877,12 +857,12 @@ U8 *numLCh; 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; @@ -896,30 +876,30 @@ U8 *numLCh; 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 */ @@ -931,7 +911,7 @@ KwL2MeasCfmEvt *measCfmEvt; 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. */ @@ -944,10 +924,10 @@ KwL2MeasCfmEvt *measCfmEvt; 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 */ /** * @@ -965,23 +945,23 @@ KwL2MeasCfmEvt *measCfmEvt; */ #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; @@ -1000,13 +980,13 @@ U8 measType; } } - 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]) { @@ -1016,7 +996,7 @@ U8 measType; } } } -} /* kwUtlResetUlL2MeasInKwRb */ +} /* rlcUtlResetUlL2MeasInRlcRb */ /** * @@ -1035,20 +1015,20 @@ U8 measType; * -# 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 @@ -1057,29 +1037,29 @@ U8 measType; 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 */ /** @@ -1098,29 +1078,29 @@ U8 measType; * @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 */ /** * @@ -1137,39 +1117,39 @@ KwSn sn; * @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 @@ -1185,32 +1165,32 @@ KwSn sn; * @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 */