X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_utl_dl.c;h=09d0bbeace378d539c81ba09c6c307661495f48d;hb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;hp=351225ab8b9b4a39de933e46f170a2f9953a3166;hpb=5625a52ad68f6ad93684e68bbbdbaef0d462cf9a;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_utl_dl.c b/src/5gnrrlc/kw_utl_dl.c index 351225ab8..09d0bbeac 100755 --- a/src/5gnrrlc/kw_utl_dl.c +++ b/src/5gnrrlc/kw_utl_dl.c @@ -44,22 +44,12 @@ static int RLOG_FILE_ID=209; */ /* 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 -#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 */ @@ -72,16 +62,6 @@ static int RLOG_FILE_ID=209; #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 */ @@ -105,8 +85,8 @@ EXTERN void kwUtlDlBatchProcHqStaInd ARGS ((Void)); #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)); @@ -115,8 +95,8 @@ Void ResetRLCStats(Void) #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, @@ -160,8 +140,8 @@ Void PrintRLCStats(Void) #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)", @@ -219,6 +199,97 @@ Void PrintRLCStats(Void) } #endif +/******************************************************************* + * + * @brief + * Handler for storing all DL PDU Info into RLC-MAC interface + * struct and sending to lower interface + * + * @details + * This function stores DL PDU info for all logical channels + * of per UE grant per TTI and sends to MAC + * + * Function : KwLiRguDDatReq + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +#ifdef ANSI +PUBLIC S16 KwLiRguDDatReq +( +Pst *post, +SpId spId, +RguDDatReqInfo *datReqInfo +) +#else +PUBLIC S16 KwLiRguDDatReq(post, spId, datReqInfo) +Pst *post; +SpId spId; +RguDDatReqInfo *datReqInfo; +#endif +{ + U8 ueIdx; /* UE info list iterator */ + U8 tbIdx; /* TB info list iterator */ + U8 lchIdx; /* Lch info list iterator */ + U8 pduIdx; /* RLC PDU list iterator */ + RguDDatReqPerUe datPerUe; /* DL data info per UE */ + RguDatReqTb datPerTb; /* DL data info per TB */ + RguLchDatReq datPerLch; /* DL data info per Lch */ + RlcMacData *dlData; /* DL data to be sent to MAC */ + + TRC3(KwLiRguDDatReq) + + dlData = NULLP; + 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"); + return RFAILED; + } +#endif /* ERRCLASS & ERRCLS_ADD_RES */ + + for(ueIdx = 0; ueIdx < datReqInfo->nmbOfUeGrantPerTti; ueIdx++) + { + datPerUe = datReqInfo->datReq[ueIdx]; + + cmMemset((U8 *)dlData, 0, sizeof(RlcMacData)); + + dlData->cellId = datReqInfo->cellId; + dlData->rnti = datPerUe.rnti; + //dlData->timeToTx = datPerUe.transId; /* Derive timing info from transId */ + dlData->numPdu = 0; + + for(tbIdx = 0; tbIdx < datPerUe.nmbOfTbs; tbIdx++) + { + datPerTb = datPerUe.datReqTb[tbIdx]; + for(lchIdx = 0; lchIdx < datPerTb.nmbLch; lchIdx++) + { + datPerLch = datPerTb.lchData[lchIdx]; + for(pduIdx = 0; pduIdx < datPerLch.pdu.numPdu; pduIdx++) + { + 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 */ + RlcMacSendDlData(post, spId, dlData); + } /* For Data per UE */ + + /* Check if to be freed here */ + + RLC_FREE_SHRABL_BUF(post->region, + post->pool, + datReqInfo, sizeof(RguDDatReqInfo)); + + return ROK; +}/* End of KwLiRguDDatReq */ + /** * * @brief @@ -242,21 +313,21 @@ Void PrintRLCStats(Void) #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 */ @@ -280,7 +351,7 @@ KwDStaIndInfo *staIndInfo; 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) @@ -288,7 +359,7 @@ KwDStaIndInfo *staIndInfo; { 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++) @@ -332,7 +403,7 @@ KwDStaIndInfo *staIndInfo; #endif rbCb = ueCb->lCh[staIndTb->lchStaInd[count].lcId - 1].dlRbCb; - if (rbCb && (!kwDlUtlIsReestInProgress(rbCb))) + if (rbCb && (!rlcDlUtlIsReestInProgress(rbCb))) { //Debug staIndSz += staIndTb->lchStaInd[count].totBufSize; @@ -448,17 +519,17 @@ KwDStaIndInfo *staIndInfo; #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 */ } @@ -478,7 +549,7 @@ KwDStaIndInfo *staIndInfo; rguSap = &(gCb->u.dlCb->rguDlSap[suId]); //Debug KwLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo); - RETVALUE(ROK); + return ROK; } /** @@ -504,8 +575,8 @@ KwDStaIndInfo *staIndInfo; #ifdef ANSI PUBLIC S16 kwUtlSndDStaRsp ( -KwCb *gCb, -KwDlRbCb *rbCb, +RlcCb *gCb, +RlcDlRbCb *rbCb, S32 bo, S32 estHdrSz, Bool staPduPrsnt, @@ -513,15 +584,15 @@ U32 staPduBo ) #else PUBLIC S16 kwUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo) -KwCb *gCb; -KwDlRbCb *rbCb; +RlcCb *gCb; +RlcDlRbCb *rbCb; S32 bo; S32 estHdrSz; Bool staPduPrsnt; U32 staPduBo; #endif { - RguDStaRspInfo staRspInfo; /* Status Response Information */ + RlcMacBOStatus boStatus; /* Buffer occupancy status information */ KwRguSapCb *rguSap; /* MAC SAP Information */ TRC3(kwUtlSndDStaRsp) #ifndef TENB_ACC @@ -529,56 +600,32 @@ U32 staPduBo; && (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP))) { rbCb->boUnRprtdCnt++; - RETVALUE(ROK); + return ROK; } #endif rguSap = &(gCb->u.dlCb->rguDlSap[rbCb->rguSapId]); -#ifdef CCPU_OPT - staRspInfo.boReport.estRlcHdrSz = estHdrSz; - staRspInfo.boReport.staPduPrsnt = staPduPrsnt; -#endif -#ifdef LTE_ADV - staRspInfo.boReport.staPduBo = staPduBo; -#endif rbCb->boUnRprtdCnt = (U32)0; rbCb->lastRprtdBoToMac = (U32)bo; - staRspInfo.boReport.bo = bo; - staRspInfo.cellId = rbCb->rlcId.cellId; - staRspInfo.rnti = rbCb->rlcId.ueId; - staRspInfo.lcId = rbCb->lch.lChId; - if ( CM_LTE_MODE_UM == rbCb->mode && (rbCb->m.umDl.sduQ.count > 0)) - { - staRspInfo.boReport.oldestSduArrTime = - ((KwSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime; - } - else if ( CM_LTE_MODE_AM == rbCb->mode ) - { - if (rbCb->m.amDl.nxtRetx != NULLP) - { - staRspInfo.boReport.oldestSduArrTime = rbCb->m.amDl.nxtRetx->sduMap.sdu->arrTime; - } - else if (rbCb->m.amDl.nxtTx != NULLP) - { - staRspInfo.boReport.oldestSduArrTime = AMDL.nxtTx->arrTime; - } - else - { - kwUtlGetCurrTime(&staRspInfo.boReport.oldestSduArrTime); - } - } + + boStatus.cellId = rbCb->rlcId.cellId; + boStatus.rnti = rbCb->rlcId.ueId; + boStatus.commCh = FALSE; + boStatus.lcId = rbCb->lch.lChId; + boStatus.bo = bo; + /* If trace flag is enabled send the trace indication */ if(gCb->init.trc == TRUE) { /* Populate the trace params */ - kwLmmSendTrc(gCb,EVTRGUDSTARSP, NULLP); + kwLmmSendTrc(gCb, EVTRLCBOSTA, NULLP); } /* Send Status Response to MAC layer */ - KwLiRguDStaRsp(&rguSap->pst,rguSap->spId,&staRspInfo); + RlcMacSendBOStatus(&rguSap->pst,rguSap->spId,&boStatus); - RETVALUE(ROK); + return ROK; } /** @@ -602,26 +649,26 @@ U32 staPduBo; #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 @@ -646,7 +693,7 @@ CmLListCp *sduQ; 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 @@ -678,14 +725,14 @@ CmLListCp *sduQ; #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; @@ -727,18 +774,18 @@ 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; @@ -773,18 +820,18 @@ KwDlRbCb *rbCb; * 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); } /** @@ -797,16 +844,16 @@ KwDlRbCb *rbCb; * @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; } @@ -825,20 +872,20 @@ KwDlRbCb *rbCb; * @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++) { @@ -846,7 +893,7 @@ KwDlUeCb *ueCb; { if(ueCb->srbCb[rbIdx]->rlcId.rbId != 1) { - kwDlUtlSetReestInProgressForRB(gCb,ueCb->srbCb[rbIdx]); + rlcDlUtlSetReestInProgressForRB(gCb,ueCb->srbCb[rbIdx]); } else { @@ -863,7 +910,7 @@ KwDlUeCb *ueCb; { if(ueCb->drbCb[rbIdx] != NULLP) { - kwDlUtlSetReestInProgressForRB(gCb,ueCb->drbCb[rbIdx]); + rlcDlUtlSetReestInProgressForRB(gCb,ueCb->drbCb[rbIdx]); } } @@ -935,13 +982,13 @@ Buffer *pdu; #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)); @@ -963,16 +1010,16 @@ KwDlDataToBeFreed *toBeFreed; #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; @@ -994,11 +1041,11 @@ KwCb *gCb; #ifdef ANSI PUBLIC Void kwUtlRaiseDlCleanupEvent ( -KwCb *gCb +RlcCb *gCb ) #else PUBLIC Void kwUtlRaiseDlCleanupEvent(gCb) -KwCb *gCb; +RlcCb *gCb; #endif { #ifdef KWSELFPSTDLCLEAN @@ -1023,12 +1070,12 @@ KwCb *gCb; #ifdef ANSI PUBLIC Void kwUtlAddSduToBeFreedQueue ( -KwCb *gCb, +RlcCb *gCb, KwSdu *sdu ) #else PUBLIC Void kwUtlAddSduToBeFreedQueue(gCb, sdu) -KwCb *gCb; +RlcCb *gCb; KwSdu *sdu; #endif { @@ -1048,12 +1095,12 @@ KwSdu *sdu; #ifdef ANSI PUBLIC Void kwUtlAddReTxPduToBeFreedQueue ( -KwCb *gCb, +RlcCb *gCb, KwRetx *retx ) #else PUBLIC Void kwUtlAddReTxPduToBeFreedQueue(gCb, retx) -KwCb *gCb; +RlcCb *gCb; KwRetx *retx; #endif { @@ -1073,12 +1120,12 @@ KwRetx *retx; #ifdef ANSI PUBLIC Void kwUtlAddTxPduToBeFreedQueue ( -KwCb *gCb, +RlcCb *gCb, KwTx *pdu ) #else PUBLIC Void kwUtlAddTxPduToBeFreedQueue(gCb, pdu) -KwCb *gCb; +RlcCb *gCb; KwTx *pdu; #endif { @@ -1106,14 +1153,14 @@ KwTx *pdu; #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 { @@ -1134,11 +1181,11 @@ U32 *toBeFreed { 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) @@ -1151,21 +1198,21 @@ U32 *toBeFreed } 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) @@ -1182,7 +1229,7 @@ U32 *toBeFreed { 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)); @@ -1191,14 +1238,14 @@ U32 *toBeFreed if(*toBeFreed == 0) { - RETVALUE(TRUE); + return (TRUE); } if(gCb->u.dlCb->shutdownReceived) { (*toBeFreed)--; } - RETVALUE(FALSE);; + return (FALSE);; } /** @@ -1212,11 +1259,11 @@ U32 *toBeFreed #ifdef ANSI PUBLIC Void kwUtlFreeDlMemory ( -KwCb *gCb +RlcCb *gCb ) #else PUBLIC Void kwUtlFreeDlMemory(gCb) -KwCb *gCb; +RlcCb *gCb; #endif { U32 toBeFreed; @@ -1228,7 +1275,7 @@ KwCb *gCb; RETVOID; } - KwDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed; + RlcDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed; /* ccpu00136940 */ if(gCb->u.dlCb->shutdownReceived) { @@ -1269,8 +1316,8 @@ KwCb *gCb; { 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--; } @@ -1286,13 +1333,13 @@ KwCb *gCb; 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--; } @@ -1317,12 +1364,12 @@ KwCb *gCb; 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)); } } @@ -1347,7 +1394,7 @@ KwCb *gCb; * @return Void * */ -S16 kwUtlL2MeasDlInit(KwCb *gCb) +S16 kwUtlL2MeasDlInit(RlcCb *gCb) { U16 cntr; @@ -1362,7 +1409,7 @@ S16 kwUtlL2MeasDlInit(KwCb *gCb) 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; } /** * @@ -1381,16 +1428,16 @@ S16 kwUtlL2MeasDlInit(KwCb *gCb) #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; @@ -1548,13 +1595,13 @@ Bool newIdx; #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; @@ -1564,13 +1611,13 @@ KwDlRbCb *rbCb; 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 */ @@ -1586,7 +1633,7 @@ KwDlRbCb *rbCb; curL2MeasTb->lchInfo[idx].numSdus = 0; } } - RETVALUE(curL2MeasTb); + return (curL2MeasTb); } @@ -1612,21 +1659,21 @@ KwDlRbCb *rbCb; #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 */ @@ -1649,14 +1696,14 @@ U8 tbIdx; 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 */ @@ -1794,13 +1841,13 @@ U8 tbIdx; } } /* 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 */ /** @@ -1822,12 +1869,12 @@ U8 tbIdx; #ifdef ANSI PUBLIC S16 kwUtlSndDlL2MeasCfm ( -KwCb *gCb, +RlcCb *gCb, KwL2MeasEvtCb *measEvtCb ) #else PUBLIC S16 kwUtlSndDlL2MeasCfm(gCb, measEvtCb) -KwCb *gCb; +RlcCb *gCb; KwL2MeasEvtCb *measEvtCb; #endif { @@ -1961,7 +2008,7 @@ KwL2MeasEvtCb *measEvtCb; } /* Fix Klock warning */ KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt); - RETVALUE(ROK); + return ROK; } /* kwUtlSndL2MeasCfm */ /** * @@ -1982,13 +2029,13 @@ KwL2MeasEvtCb *measEvtCb; #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 @@ -1996,7 +2043,7 @@ KwL2MeasCfmEvt *measCfmEvt; TRC3(kwUtlSndDlL2MeasNCfm) KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt); - RETVALUE(ROK); + return ROK; } /* kwUtlSndL2MeasNCfm */ /** * @@ -2016,20 +2063,20 @@ KwL2MeasCfmEvt *measCfmEvt; 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; @@ -2088,7 +2135,7 @@ U8 measType; } /* kwUtlResetDlL2MeasInKwRb */ #endif -PRIVATE Void dumpRLCDlRbInformation(KwDlRbCb* dlRbCb) +PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb) { if(dlRbCb->mode == CM_LTE_MODE_UM) { @@ -2125,11 +2172,11 @@ PRIVATE Void dumpRLCDlRbInformation(KwDlRbCb* dlRbCb) 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 */ @@ -2140,7 +2187,7 @@ Void DumpRLCDlDebugInformation(Void) 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); @@ -2148,7 +2195,7 @@ Void DumpRLCDlDebugInformation(Void) } 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); @@ -2156,7 +2203,7 @@ Void DumpRLCDlDebugInformation(Void) } } - 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); @@ -2185,7 +2232,7 @@ void kwUtlFreeDlMem() Void; #endif { - kwUtlFreeDlMemory(KW_GET_KWCB(KW_DL_INST)); + kwUtlFreeDlMemory(RLC_GET_RLCCB(KW_DL_INST)); } /** @@ -2272,14 +2319,14 @@ Void; #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 { @@ -2288,7 +2335,7 @@ U32 pktAdmitCnt; 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)); @@ -2381,11 +2428,11 @@ KwSn sn; txBuf = (KwTx *) node->node; if(txBuf->sn == sn) { - RETVALUE(txBuf); + return (txBuf); } CM_LLIST_NEXT_NODE(txBufLstCp, node); } - RETVALUE(NULLP); + return (NULLP); } /* kwUtlStoreTxBuf */ /** * @@ -2406,13 +2453,13 @@ PUBLIC Void kwUtlDelTxBuf ( 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; @@ -2425,7 +2472,7 @@ KwCb *gCb; 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 */ @@ -2448,13 +2495,13 @@ PUBLIC Void kwUtlRemovTxBuf ( 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;