X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_lim.c;h=765e5e6e0269d100f308bdeada91e590b092571f;hb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;hp=f590955669513ef29862a1bd53f57045dd1c96e2;hpb=2af23ef78e09b945e68188eefc0d9fa0bc14a4d4;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_lim.c b/src/5gnrrlc/kw_lim.c index f59095566..765e5e6e0 100755 --- a/src/5gnrrlc/kw_lim.c +++ b/src/5gnrrlc/kw_lim.c @@ -48,18 +48,7 @@ static int RLOG_FILE_ID=196; /* header (.h) include files */ -#include "envopt.h" /* environment options */ -#include "envdep.h" /* environment dependent */ -#include "envind.h" /* environment independent */ - -#include "gen.h" /* general */ -#include "ssi.h" /* system services */ -#include "cm5.h" /* common timer defines */ -#include "cm_tkns.h" /* common tokens defines */ -#include "cm_mblk.h" /* common memory allocation library defines */ -#include "cm_llist.h" /* common link list defines */ -#include "cm_hash.h" /* common hash list defines */ -#include "cm_lte.h" /* common LTE defines */ +#include "common_def.h" #include "lkw.h" /* LKW defines */ #include "ckw.h" /* CKW defines */ #include "kwu.h" /* KWU defines */ @@ -73,16 +62,6 @@ static int RLOG_FILE_ID=196; #include "kw_ul.h" /* extern (.x) include files */ -#include "gen.x" /* general */ -#include "ssi.x" /* system services */ - -#include "cm5.x" /* common timer library */ -#include "cm_tkns.x" /* common tokens */ -#include "cm_mblk.x" /* common memory allocation */ -#include "cm_llist.x" /* common link list */ -#include "cm_hash.x" /* common hash list */ -#include "cm_lte.x" /* common LTE includes */ -#include "cm_lib.x" /* common memory allocation library */ #include "lkw.x" /* LKW */ #include "ckw.x" /* CKW */ #include "kwu.x" /* KWU */ @@ -92,6 +71,7 @@ static int RLOG_FILE_ID=196; #include "kw_udx.x" #include "kw_dl.x" #include "kw_ul.x" +#include "rlc_utils.h" #ifdef __cplusplus EXTERN "C" { @@ -135,42 +115,42 @@ U8 status; U16 event; /* Event */ U16 cause; /* Cause */ KwRguSapCb *rguSap; /* RGU SAP Control Block */ - KwCb *tKwCb; + RlcCb *tRlcCb; TRC3(KwLiRguBndCfm) #if (ERRCLASS & ERRCLS_INT_PAR) - if (pst->dstInst >= KW_MAX_RLC_INSTANCES) + if (pst->dstInst >= MAX_RLC_INSTANCES) { - RETVALUE (RFAILED); + return (RFAILED); } #endif - tKwCb = KW_GET_KWCB(pst->dstInst); + tRlcCb = RLC_GET_RLCCB(pst->dstInst); RLOG2(L_DEBUG,"KwLiRguBndCfm(suId(%d), status(%d)", suId, status); #if (ERRCLASS & ERRCLS_INT_PAR) - if (tKwCb->init.cfgDone != TRUE) + if (tRlcCb->init.cfgDone != TRUE) { RLOG0(L_FATAL,"General configuration not done"); - KW_SEND_SAPID_ALARM(tKwCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE); + KW_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE); - RETVALUE(RFAILED); + return RFAILED; } - if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0)) + if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0)) { RLOG0(L_ERROR, "Invalid suId"); - KW_SEND_SAPID_ALARM(tKwCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID); + KW_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID); - RETVALUE(RFAILED); + return RFAILED; } #endif /* ERRCLASS & ERRCLS_INT_PAR */ - rguSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ? - &(tKwCb->u.dlCb->rguDlSap[suId]) : &(tKwCb->u.ulCb->rguUlSap[suId]); + rguSap = (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ? + &(tRlcCb->u.dlCb->rguDlSap[suId]) : &(tRlcCb->u.ulCb->rguUlSap[suId]); RLOG1(L_DEBUG, "KwLiRguBndCfm: For RGU SAP state=%d", rguSap->state) @@ -178,7 +158,7 @@ U8 status; { case KW_SAP_BINDING: { - kwStopTmr (tKwCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM); + kwStopTmr (tRlcCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM); rguSap->retryCnt = 0; @@ -204,9 +184,9 @@ U8 status; } /* Send an alarm with proper event and cause */ - KW_SEND_SAPID_ALARM(tKwCb, suId, event, cause); + KW_SEND_SAPID_ALARM(tRlcCb, suId, event, cause); - RETVALUE(ROK); + return ROK; } /* KwLiRguBndCfm */ /** @@ -227,15 +207,16 @@ U8 status; * */ -PUBLIC S16 RlcMacProcUlData(Pst *pst, SuId suId, RlcMacData *ulData) +uint8_t RlcProcUlData(Pst *pst, RlcMacData *ulData) { U8 idx; U8 lcId; /* Logical Channel */ U8 numDLch = 0; /* Number of dedicated logical channel */ Bool dLchPduPres; /* PDU received on dedicated logical channel */ RguLchDatInd dLchData[RGU_MAX_LC]; /* PDU info on dedicated logical channel */ - RguDDatIndInfo dLchUlDat; /* UL data on dedicated logical channel */ - RguCDatIndInfo cLchUlDat; /* UL data on common logical channel */ + RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */ + RguCDatIndInfo *cLchUlDat; /* UL data on common logical channel */ + uint16_t copyLen; /* Initializing dedicated logical channel Database */ for(idx = 0; idx < RGU_MAX_LC; idx++) @@ -248,29 +229,40 @@ PUBLIC S16 RlcMacProcUlData(Pst *pst, SuId suId, RlcMacData *ulData) /* Seggregate PDUs received on common and dedicated channels * and call common channel's handler */ - for(idx = 0; idx< ulData->nmbPdu; idx++) + for(idx = 0; idx< ulData->numPdu; idx++) { if(ulData->pduInfo[idx].commCh) { - cmMemset((U8*)&cLchUlDat, (U8)0, sizeof(RguCDatIndInfo)); - - cLchUlDat.cellId = ulData->cellId; - cLchUlDat.rnti = ulData->rnti; - cLchUlDat.lcId = ulData->pduInfo[idx].lcId; - cLchUlDat.pdu = ulData->pduInfo[idx].pduBuf; - - KwLiRguCDatInd(pst, suId, &cLchUlDat); + RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchUlDat, sizeof(RguCDatIndInfo)); + cmMemset((U8*)cLchUlDat, (U8)0, sizeof(RguCDatIndInfo)); + + cLchUlDat->cellId = ulData->cellId; + GET_UE_IDX(ulData->rnti, cLchUlDat->rnti); + cLchUlDat->lcId = ulData->pduInfo[idx].lcId; + + /* Copy fixed buffer to message */ + if(SGetMsg(RLC_MEM_REGION_UL, RLC_POOL, &cLchUlDat->pdu) != ROK) + { + DU_LOG("\nRLC : Memory allocation failed at RlcProcUlData"); + return RFAILED; + } + reverseFixBuf(ulData->pduInfo[idx].pduBuf, ulData->pduInfo[idx].pduLen); + SCpyFixMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, 0, \ + ulData->pduInfo[idx].pduLen, (MsgLen *)©Len); + + KwLiRguCDatInd(pst, 0, cLchUlDat); } else { - if(!dLchPduPres) - { - dLchPduPres = TRUE; - } - - lcId = ulData->pduInfo[idx].lcId; - dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu] = ulData->pduInfo[idx].pduBuf; - dLchData[lcId].pdu.numPdu++; + if(!dLchPduPres) + { + RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchUlDat, sizeof(RguDDatIndInfo)); + dLchPduPres = TRUE; + } + + lcId = ulData->pduInfo[idx].lcId; + dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu] = ulData->pduInfo[idx].pduBuf; + dLchData[lcId].pdu.numPdu++; } } @@ -278,24 +270,26 @@ PUBLIC S16 RlcMacProcUlData(Pst *pst, SuId suId, RlcMacData *ulData) * and call its handler */ if(dLchPduPres) { - dLchUlDat.cellId = ulData->cellId; - dLchUlDat.rnti = ulData->rnti; + dLchUlDat->cellId = ulData->cellId; + dLchUlDat->rnti = ulData->rnti; for(idx = 0; idx < RGU_MAX_LC; idx++) { - if(dLchData[idx].pdu.numPdu) - { - cmMemcpy((U8 *)&dLchUlDat.lchData[numDLch], (U8 *)&dLchData[idx], sizeof(RguLchDatInd)); - numDLch++; - } + if(dLchData[idx].pdu.numPdu) + { + cmMemcpy((U8 *)&dLchUlDat->lchData[numDLch], (U8 *)&dLchData[idx], sizeof(RguLchDatInd)); + numDLch++; + } } - dLchUlDat.numLch = numDLch; - KwLiRguDDatInd(pst, suId, &dLchUlDat); + dLchUlDat->numLch = numDLch; + KwLiRguDDatInd(pst, 0, dLchUlDat); } + - RETVALUE(ROK); + RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcMacData)); + return ROK; -}/* End of RlcMacProcUlData */ +}/* End of RlcProcUlData */ PUBLIC int rlcDDatIndRcvd; PUBLIC int rlcCDatIndRcvd; @@ -329,28 +323,28 @@ SuId suId; RguCDatIndInfo *datInd; #endif { - KwUlRbCb *rbCb; - KwCb *tKwCb; + RlcUlRbCb *rbCb; + RlcCb *tRlcCb; rlcCDatIndRcvd++; TRC3(KwLiRguCDatInd) #if (ERRCLASS & ERRCLS_INT_PAR) - if (pst->dstInst >= KW_MAX_RLC_INSTANCES) + if (pst->dstInst >= MAX_RLC_INSTANCES) { - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); - RETVALUE (RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); + return (RFAILED); } #endif - tKwCb = KW_GET_KWCB(pst->dstInst); + tRlcCb = RLC_GET_RLCCB(pst->dstInst); #if (ERRCLASS & ERRCLS_DEBUG) - if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) + if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL) { - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); + return RFAILED; } #endif @@ -360,31 +354,31 @@ RguCDatIndInfo *datInd; { RLOG_ARG1(L_ERROR,DBG_LCID,datInd->lcId, "Invalid LcId, Max is [%d]", KW_MAX_LCH_PER_CELL); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); + return RFAILED; } #endif /* (ERRCLASS & ERRCLS_DEBUG) */ /* Fetch RbCb from lcId */ - kwDbmFetchUlRbCbFromLchId(tKwCb, 0, datInd->cellId, datInd->lcId, &rbCb); + kwDbmFetchUlRbCbFromLchId(tRlcCb, datInd->rnti, datInd->cellId, datInd->lcId, &rbCb); if (!rbCb) { RLOG_ARG1(L_ERROR, DBG_CELLID,datInd->cellId, "LcId [%d] not found", datInd->lcId); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); + return RFAILED; } /* Dispatch to TM Module */ #ifdef CCPU_OPT - kwTmmRcvFrmLi(tKwCb, rbCb, datInd->rnti, datInd->pdu); + kwTmmRcvFrmLi(tRlcCb, rbCb, datInd->rnti, datInd->pdu); #else /* CCPU_OPT */ - kwTmmRcvFrmLi(tKwCb, rbCb, datInd->pdu); + kwTmmRcvFrmLi(tRlcCb, rbCb, datInd->pdu); #endif /* CCPU_OPT */ - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo)); - RETVALUE(ROK); + return ROK; } /* KwLiRguCDatInd */ /** @@ -423,31 +417,31 @@ RguDDatIndInfo *datInd; rlcDDatIndRcvd++; #if (ERRCLASS & ERRCLS_INT_PAR) - if (pst->dstInst >= KW_MAX_RLC_INSTANCES) + if (pst->dstInst >= MAX_RLC_INSTANCES) { - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); - RETVALUE (RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); + return (RFAILED); } #endif #if (ERRCLASS & ERRCLS_DEBUG) - if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL) + if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL) { RLOG1(L_DEBUG,"KwLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); + return RFAILED; } #endif - kwUtlRcvFrmLi(KW_GET_KWCB(pst->dstInst),datInd); + kwUtlRcvFrmLi(RLC_GET_RLCCB(pst->dstInst),datInd); #ifndef SS_RBUF #ifdef SS_LOCKLESS_MEMORY - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); #else - KW_PST_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); + RLC_PST_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo)); #endif #endif - RETVALUE(ROK); + return ROK; } /* KwLiRguDDatInd */ @@ -469,12 +463,14 @@ RguDDatIndInfo *datInd; * RFAILED - failure * * ****************************************************************/ -PUBLIC S16 RlcMacProcSchedRep(Pst *pst, SuId suId,RlcMacSchedRep *schRep) +PUBLIC uint16_t RlcMacProcSchedRep(Pst *pst, SuId suId, RlcMacSchedRepInfo *schRep) { U8 idx; /* Iterator */ U8 nmbDLch = 0; /* Number of dedicated logical channles */ - RguCStaIndInfo cLchSchInfo; /* Common logical channel scheduling result */ - RguDStaIndInfo dLchSchInfo; /* Dedicated logical channel scheduling result */ + RguCStaIndInfo *cLchSchInfo; /* Common logical channel scheduling result */ + RguDStaIndInfo *dLchSchInfo; /* Dedicated logical channel scheduling result */ + + DU_LOG("\nRLC : Received scheduling report from MAC"); for(idx=0; idx < schRep->nmbLch; idx++) { @@ -482,14 +478,15 @@ PUBLIC S16 RlcMacProcSchedRep(Pst *pst, SuId suId,RlcMacSchedRep *schRep) * and trigger the handler for each common lch separately */ if(schRep->lchSta[idx].commCh) { - cmMemset((U8*)&cLchSchInfo, (U8)0, sizeof(RguCStaIndInfo)); + RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchSchInfo, sizeof(RguCStaIndInfo)); + cmMemset((U8*)cLchSchInfo, (U8)0, sizeof(RguCStaIndInfo)); - cLchSchInfo.cellId = schRep->cellId; - cLchSchInfo.lcId = schRep->lchSta[idx].lchStaInd.lcId; - //cLchSchInfo.transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */ - cLchSchInfo.rnti = schRep->rnti; + cLchSchInfo->cellId = schRep->cellId; + cLchSchInfo->lcId = schRep->lchSta[idx].lchStaInd.lcId; + //cLchSchInfo->transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */ + cLchSchInfo->rnti = schRep->rnti; - KwLiRguCStaInd(pst, suId, &cLchSchInfo); + KwLiRguCStaInd(pst, suId, cLchSchInfo); } else @@ -498,16 +495,18 @@ PUBLIC S16 RlcMacProcSchedRep(Pst *pst, SuId suId,RlcMacSchedRep *schRep) * scheduling report is received */ if(nmbDLch == 0) { - dLchSchInfo.cellId = schRep->cellId; - dLchSchInfo.nmbOfUeGrantPerTti = 1; - dLchSchInfo.staInd[0].rnti = schRep->rnti; - //dLchSchInfo.staInd[0].transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */ - dLchSchInfo.staInd[0].nmbOfTbs = 1; - //dLchSchInfo.staInd[0].fillCrlPdu = /* TODO : Check the value needed to be filled */ + RLC_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchSchInfo, sizeof(RguDStaIndInfo)); + + dLchSchInfo->cellId = schRep->cellId; + dLchSchInfo->nmbOfUeGrantPerTti = 1; + dLchSchInfo->staInd[0].rnti = schRep->rnti; + //dLchSchInfo->staInd[0].transId = schRep->timeToTx; /* TODO : fill transId suing timeToTx */ + dLchSchInfo->staInd[0].nmbOfTbs = 1; + //dLchSchInfo->staInd[0].fillCrlPdu = /* TODO : Check the value needed to be filled */ } /* Fill logical channel scheduling info */ - cmMemcpy((U8 *)&dLchSchInfo.staInd[0].staIndTb[0].lchStaInd[nmbDLch], (U8 *)&schRep->lchSta[idx].lchStaInd, sizeof(RguLchStaInd)); + cmMemcpy((U8 *)&dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch], (U8 *)&schRep->lchSta[idx].lchStaInd, sizeof(RguLchStaInd)); nmbDLch++; } @@ -517,11 +516,13 @@ PUBLIC S16 RlcMacProcSchedRep(Pst *pst, SuId suId,RlcMacSchedRep *schRep) /* Calling handler for all dedicated channels scheduling*/ if(nmbDLch) { - dLchSchInfo.staInd[0].staIndTb[0].nmbLch = nmbDLch; - KwLiRguDStaInd(pst, suId, &dLchSchInfo); + dLchSchInfo->staInd[0].staIndTb[0].nmbLch = nmbDLch; + KwLiRguDStaInd(pst, suId, dLchSchInfo); } + + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo)); - RETVALUE(ROK); + return ROK; } /** @@ -556,39 +557,39 @@ SuId suId; RguCStaIndInfo *staInd; #endif { - KwDlRbCb *rbCb; - KwCb *tKwCb; + RlcDlRbCb *rbCb; + RlcCb *tRlcCb; TRC3(KwLiRguCStaInd) #if (ERRCLASS & ERRCLS_INT_PAR) - if (pst->dstInst >= KW_MAX_RLC_INSTANCES) + if (pst->dstInst >= MAX_RLC_INSTANCES) { - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); - RETVALUE (RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + return (RFAILED); } #endif - tKwCb = KW_GET_KWCB(pst->dstInst); + tRlcCb = RLC_GET_RLCCB(pst->dstInst); #if (ERRCLASS & ERRCLS_INT_PAR) - if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0)) + if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0)) { - KWLOGERROR(tKwCb, + KWLOGERROR(tRlcCb, ERRCLS_INT_PAR, EKW040, (ErrVal) suId, "KwLiRguCStaInd: Invalid RGU suId\n"); - RETVALUE(RFAILED); + return RFAILED; } - if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_UL) + if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_UL) { RLOG_ARG1(L_ERROR,DBG_LCID,staInd->lcId, "Received in RLC UL CELLID:%d", staInd->cellId); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + return RFAILED; } #endif @@ -602,41 +603,41 @@ RguCStaIndInfo *staInd; "Invalid LcId, Max is [%d] CELLID:%d", KW_MAX_LCH_PER_CELL, staInd->cellId); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + return RFAILED; } #endif /* (ERRCLASS & ERRCLS_DEBUG) */ /* Fertch RbCb from lcId */ - kwDbmFetchDlRbCbFromLchId(tKwCb,0, staInd->cellId, staInd->lcId, &rbCb); + kwDbmFetchDlRbCbFromLchId(tRlcCb,0, staInd->cellId, staInd->lcId, &rbCb); if(!rbCb) { RLOG_ARG1(L_ERROR, DBG_CELLID,staInd->cellId, "LcId [%d] not found CELLID:%d", staInd->lcId); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + return RFAILED; } /* Dispatch to TM Module */ rbCb->transId = staInd->transId; /* ccpu00136940 */ /* If trace flag is enabled send the trace indication */ - if(tKwCb->init.trc == TRUE) + if(tRlcCb->init.trc == TRUE) { /* Populate the trace params */ - kwLmmSendTrc(tKwCb,EVTRGUCSTAIND, NULLP); + kwLmmSendTrc(tRlcCb,EVTRGUCSTAIND, NULLP); } - kwTmmSndToLi(tKwCb, suId, rbCb, staInd); + kwTmmSndToLi(tRlcCb, suId, rbCb, staInd); #ifndef SS_RBUF #ifdef SS_LOCKLESS_MEMORY - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); #else - KW_PST_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + RLC_PST_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); #endif #else - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo)); #endif - RETVALUE(ROK); + return ROK; } /* KwLiRguCStaInd */ /** @@ -672,25 +673,25 @@ SuId suId; RguDStaIndInfo *staInd; #endif { - KwCb *gCb; + RlcCb *gCb; TRC3(KwLiRguDStaInd) #if (ERRCLASS & ERRCLS_INT_PAR) - if (pst->dstInst >= KW_MAX_RLC_INSTANCES) + if (pst->dstInst >= MAX_RLC_INSTANCES) { - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo)); - RETVALUE (RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo)); + return (RFAILED); } #endif - gCb = KW_GET_KWCB(pst->dstInst); + gCb = RLC_GET_RLCCB(pst->dstInst); #if (ERRCLASS & ERRCLS_INT_PAR) - if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL) + if (((RlcCb*)RLC_GET_RLCCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL) { RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"Received in RLC UL "); - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo)); - RETVALUE(RFAILED); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo)); + return RFAILED; } if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0)) { @@ -699,14 +700,14 @@ RguDStaIndInfo *staInd; EKW040, (ErrVal) suId, "KwLiRguDStaInd: Invalid RGU suId\n"); - RETVALUE(RFAILED); + return RFAILED; } #endif kwUtlSndToLi(gCb, suId, staInd); /* kw002.201 :Freeing from proper region */ - KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo)); - RETVALUE(ROK); + RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo)); + return ROK; } /* KwLiRguDStaInd */ /** @@ -741,24 +742,24 @@ SuId suId; RguFlowCntrlInd *flowCntrlInd; #endif { - KwCb *tKwCb; - KwDlRbCb *rbCb = NULLP; + RlcCb *tRlcCb; + RlcDlRbCb *rbCb = NULLP; U32 idx; U32 lcIdx; - tKwCb = KW_GET_KWCB(pst->dstInst); + tRlcCb = RLC_GET_RLCCB(pst->dstInst); for (idx = 0; idx < flowCntrlInd->numUes; idx++) { for (lcIdx = 0; lcIdx < flowCntrlInd->ueFlowCntrlInfo[idx].numLcs; lcIdx++) { RguLcFlowCntrlInfo *lcInfo = &(flowCntrlInd->ueFlowCntrlInfo[idx].lcInfo[lcIdx]); - kwDbmFetchDlRbCbFromLchId(tKwCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb); + kwDbmFetchDlRbCbFromLchId(tRlcCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb); if (rbCb) { if (lcInfo->pktAdmitCnt == 0) /* Special case */ { - kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt); + kwUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt); continue; } if (rbCb->mode == CM_LTE_MODE_AM) @@ -778,11 +779,11 @@ RguFlowCntrlInd *flowCntrlInd; continue; } } - kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt); + kwUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt); } } } - RETVALUE(ROK); + return ROK; } /* kw005.201 added support for L2 Measurement */ #ifdef LTE_L2_MEAS @@ -826,29 +827,29 @@ RguHarqStatusInd *staInd; KwUeKey ueKey; S16 ret; - KwDlUeCb *ueCb; + RlcDlUeCb *ueCb; U8 tbIdx; - KwCb *tKwCb; + RlcCb *tRlcCb; TRC3(KwLiRguHqStaInd) - tKwCb = KW_GET_KWCB(pst->dstInst); + tRlcCb = RLC_GET_RLCCB(pst->dstInst); ueKey.cellId = staInd->cellId; ueKey.ueId = staInd->ueId; - ret = kwDbmFetchDlUeCb(tKwCb, ueKey.ueId, ueKey.cellId, &ueCb); + ret = kwDbmFetchDlUeCb(tRlcCb, ueKey.ueId, ueKey.cellId, &ueCb); if (ret != ROK ) { - RETVALUE(RFAILED); + return RFAILED; } /*Call kwUtlProcHarqInd as many times as number of Tbs present*/ for ( tbIdx = 0; tbIdx < staInd->numTbs; tbIdx++) { - kwUtlProcHarqInd(tKwCb, staInd, ueCb, tbIdx); + kwUtlProcHarqInd(tRlcCb, staInd, ueCb, tbIdx); } - RETVALUE(ROK); + return ROK; } /* KwLiRguHqStaInd */ #endif /* LTE_L2_MEAS */