X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_utl_dl.c;h=146eaf9867dd504a6d5f4a773656389c5ccc78c0;hb=65443172dd60a6ea312bd3a15959dbf54ad7f045;hp=63b18863c269338dbb85da4f0c55cee4913846a1;hpb=5831bf6b3454aa200a92cd3e84209650734e4863;p=o-du%2Fl2.git

diff --git a/src/5gnrrlc/kw_utl_dl.c b/src/5gnrrlc/kw_utl_dl.c
index 63b18863c..146eaf986 100755
--- a/src/5gnrrlc/kw_utl_dl.c
+++ b/src/5gnrrlc/kw_utl_dl.c
@@ -25,11 +25,11 @@
      Desc:     Source code for RLC Utility Module
                This file contains following functions
 
-                  --kwUtlSndToLi
-                  --kwUtlRcvFrmLi
-                  --kwUtlEmptySduQ
-                  --kwUtlSndDStaRsp
-                  --kwUtlSndDatInd 
+                  --rlcUtlSendToMac
+                  --rlcUtlRcvFrmMac
+                  --rlcUtlEmptySduQ
+                  --rlcUtlSendDedLcBoStatus
+                  --rlcUtlSendUlDataToDu 
                   --kwUtlShutDown
 
      File:     kw_utl_dl.c
@@ -71,25 +71,29 @@ static int RLOG_FILE_ID=209;
 #include "kw_udx.x"        /* UDX interface includes */
 #include "kw_dl.x"         /* RLC downlink includes */
 
+#include "rlc_utils.h"
+#include "rlc_mac_inf.h"
+#include "rlc_lwr_inf_api.h"
+
 #include "ss_rbuf.h"
 #include "ss_rbuf.x" 
 
-EXTERN SsRngBufCnt rngCb;
+SsRngBufCnt rngCb;
 
 #if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
-extern U32 isDatReqProcessed;
+uint32_t isDatReqProcessed;
 #endif
-#define KW_MODULE (KW_DBGMASK_DUT | KW_DBGMASK_DL) /* for debugging purpose */
+#define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_DL) /* for debugging purpose */
 #if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)) || defined (SS_RBUF)
-EXTERN void kwUtlDlBatchProcHqStaInd ARGS ((Void));
+void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
 #endif
 Void ResetRLCStats(Void)
 {
    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));
+   memset(&gRlcStats, 0, sizeof(RLCStats));
+   memset(&dlInst->genSts,0,sizeof(RlcGenSts));
+   memset(&ulInst->genSts,0,sizeof(RlcGenSts));
 }
 
 #ifndef ALIGN_64BIT
@@ -209,46 +213,37 @@ Void PrintRLCStats(Void)
  *    This function stores DL PDU info for all logical channels
  *    of per UE grant per TTI and sends to MAC
  *
- *    Function : KwLiRguDDatReq 
+ *    Function : rlcSendDedLcDlData 
  *
  * @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
+uint8_t rlcSendDedLcDlData(Pst *post, SpId spId, RguDDatReqInfo *datReqInfo)
 {
-   U8               ueIdx;      /* UE info list iterator */ 
-   U8               tbIdx;      /* TB info list iterator */
-   U8               lchIdx;     /* Lch info list iterator */
-   U8               pduIdx;     /* RLC PDU list iterator */
+   uint8_t          ueIdx;      /* UE info list iterator */ 
+   uint8_t          tbIdx;      /* TB info list iterator */
+   uint8_t          lchIdx;     /* Lch info list iterator */
+   uint8_t          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)
+   RlcData          *dlData;    /* DL data to be sent to MAC */
+   Pst              pst;        /* Post structure */
+   uint16_t         pduLen;     /* PDU length */
+   uint16_t         copyLen;    /* Number of bytes copied */
 
    dlData = NULLP;
-   RLC_ALLOC_SHRABL_BUF(post->region, post->pool,
-                       dlData, sizeof(RlcMacData));
+   RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+                       dlData, sizeof(RlcData));
 #if (ERRCLASS & ERRCLS_ADD_RES)
-   if ( datReqInfo == NULLP )
+   if ( dlData == NULLP )
    {
-      RLOG0(L_FATAL,"Memory allocation failed");
-      RETVALUE(RFAILED);
+      DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed for dl data");
+      RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+          datReqInfo, sizeof(RguDDatReqInfo));
+      return RFAILED;
    }
 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 
@@ -256,12 +251,15 @@ RguDDatReqInfo    *datReqInfo;
    {
       datPerUe = datReqInfo->datReq[ueIdx];
 
-      cmMemset((U8 *)dlData, 0, sizeof(RlcMacData));
+      memset(dlData, 0, sizeof(RlcData));
 
       dlData->cellId = datReqInfo->cellId;
       dlData->rnti = datPerUe.rnti;
-      //dlData->timeToTx = datPerUe.transId; /* Derive timing info from transId */
-      dlData->nmbPdu = 0;
+
+      /* Retrieving sfn/slot from transId. It was filled in RlcProcSchedResultRpt */
+      dlData->slotInfo.sfn = datPerUe.transId >> 16;
+      dlData->slotInfo.slot = datPerUe.transId & 0xffff;
+      dlData->numPdu = 0;
 
       for(tbIdx = 0; tbIdx < datPerUe.nmbOfTbs; tbIdx++)
       {
@@ -271,24 +269,60 @@ RguDDatReqInfo    *datReqInfo;
             datPerLch = datPerTb.lchData[lchIdx];
             for(pduIdx = 0; pduIdx < datPerLch.pdu.numPdu; pduIdx++)
             {
-               dlData->pduInfo[dlData->nmbPdu].commCh = FALSE;
-               dlData->pduInfo[dlData->nmbPdu].lcId = datPerLch.lcId;
-               dlData->pduInfo[dlData->nmbPdu].pduBuf = datPerLch.pdu.mBuf[pduIdx];
-               dlData->nmbPdu++;
+               dlData->pduInfo[dlData->numPdu].commCh = FALSE;
+               dlData->pduInfo[dlData->numPdu].lcId = datPerLch.lcId;
+
+               /* Copy Message to fixed buffer to send */
+	       ODU_GET_MSG_LEN(datPerLch.pdu.mBuf[pduIdx], (MsgLen *)&pduLen);
+	       RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+	          dlData->pduInfo[dlData->numPdu].pduBuf, pduLen);
+
+	       if (dlData->pduInfo[dlData->numPdu].pduBuf == NULLP )
+	       {
+	          DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed");
+		  for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
+		  {
+		     RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
+		       dlData->pduInfo[pduIdx].pduLen);
+		  }
+		  RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+		     dlData, sizeof(RlcData));
+		  RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+		     datReqInfo, sizeof(RguDDatReqInfo));
+		  return RFAILED;
+	       }
+
+               ODU_COPY_MSG_TO_FIX_BUF(datPerLch.pdu.mBuf[pduIdx], 0, pduLen, \
+	          dlData->pduInfo[dlData->numPdu].pduBuf, (MsgLen *)&copyLen);
+	       dlData->pduInfo[dlData->numPdu].pduLen = pduLen;
+
+               /* Free message */
+	       ODU_PUT_MSG_BUF(datPerLch.pdu.mBuf[pduIdx]);
+
+               dlData->numPdu++;
             }/* For per PDU */
          }/* For Data per Lch */
       }/* For Data per Tb */
-      RlcMacSendDlData(post, spId, dlData);
+
+      /* Sending DL Data per UE to MAC */
+      memset(&pst, 0, sizeof(Pst));
+      FILL_PST_RLC_TO_MAC(pst, RLC_DL_INST, EVENT_DL_DATA_TO_MAC);
+      if(RlcSendDlDataToMac(&pst, dlData) != ROK)
+      {
+         for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
+	 {
+	    RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
+	       dlData->pduInfo[pduIdx].pduLen);
+	 }
+         RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData, sizeof(RlcData));
+      }
    } /* For Data per UE */
 
-   /* Check if to be freed here */
-   
-   RLC_FREE_SHRABL_BUF(post->region, 
-            post->pool, 
+   RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
             datReqInfo, sizeof(RguDDatReqInfo));
    
-   RETVALUE(ROK);
-}/* End of KwLiRguDDatReq */
+   return ROK;
+}/* End of rlcSendDedLcDlData */
 
 /**
  *
@@ -310,81 +344,67 @@ RguDDatReqInfo    *datReqInfo;
  *      -# RFAILED
  *
  */
-#ifdef ANSI
-PUBLIC S16 kwUtlSndToLi
-(
-RlcCb            *gCb,
-SuId            suId,
-KwDStaIndInfo   *staIndInfo
-)
-#else
-PUBLIC S16 kwUtlSndToLi(gCb, suId, staIndInfo)
-RlcCb            *gCb;
-SuId            suId;
-KwDStaIndInfo   *staIndInfo; 
-#endif
+uint8_t rlcUtlSendToMac(RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo)
 {
+   uint8_t           numPdu = 0;
+   uint16_t          ueIdx;
    RlcDlUeCb         *ueCb;         /* UE control block */
-   U32              count;         /* Loop Counter */
-   U32              numTb;         /* Number of Tbs */
+   uint32_t          count;         /* Loop Counter */
+   uint32_t          numTb;         /* Number of Tbs */
    RlcDlRbCb         *rbCb;         /* RB Control Block */
-   KwDatReq         datReq;        /* PDUs Information */
+   RlcDatReq         datReq;        /* PDUs Information */
    RguDDatReqInfo   *datReqInfo;   /* Data Request Information */
-   KwRguSapCb       *rguSap;       /* MAC SAP CB */
-   U32              totNumPdu;     /* Total number of PDUS */
+   RlcRguSapCb      *rguSap;       /* MAC SAP CB */
+   uint32_t         totNumPdu;     /* Total number of PDUS */
    RguStaIndTb      *staIndTb = NULLP;
    RguDatReqTb      *datReqTb = NULLP;
    RguDStaIndPerUe  *staInd = NULLP;
 #ifdef LTE_L2_MEAS   
-    U32 grantPerLch[RGU_MAX_LC] = {0};
+   uint32_t   grantPerLch[RGU_MAX_LC] = {0};
 #endif
 /* kw005.201 added support for L2 Measurement */
 #ifdef LTE_L2_MEAS_LOSS_DELAY
-   U8        snIdx1;
-   U8        snIdx2;
+   uint8_t        snIdx1;
+   uint8_t        snIdx2;
 #endif /* LTE_L2_MEAS */
-   U32 idx;
+   uint32_t  idx;
 
 //Debug
-   U32 staIndSz=0,datIndSz = 0;
-   TRC2(kwUtlSndToLi)
-
+   uint32_t staIndSz=0,datIndSz = 0;
 
    datReqInfo = NULLP;
-   RLC_ALLOC_SHRABL_BUF(gCb->u.dlCb->rguDlSap->pst.region,
-                       gCb->u.dlCb->rguDlSap->pst.pool,
+   RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
                        datReqInfo,sizeof(RguDDatReqInfo));
 #if (ERRCLASS & ERRCLS_ADD_RES)
       if ( datReqInfo == NULLP )
       {
-         RLOG_ARG0(L_FATAL,DBG_CELLID,staIndInfo->cellId,
-                  "Memory allocation failed");
-         RETVALUE(RFAILED);
+         DU_LOG("\nRLC: rlcUtlSendToMac: Memory allocation failed");
+         return RFAILED;
       }
 #endif /* ERRCLASS & ERRCLS_ADD_RES */
    for(idx = 0; idx < staIndInfo->nmbOfUeGrantPerTti; idx++)
    {
       staInd = &staIndInfo->staInd[idx];
       /* Fetch Ue control block */
-      if(ROK != kwDbmFetchDlUeCb(gCb,staInd->rnti,staIndInfo->cellId,&ueCb))
+      GET_UE_IDX(staInd->rnti, ueIdx);
+      if(ROK != rlcDbmFetchDlUeCb(gCb, ueIdx, staIndInfo->cellId,&ueCb))
       {
          /* Fetch UeCb failed */
-         RLOG_ARG1(L_ERROR, DBG_CELLID,staIndInfo->cellId, 
-                  "UeId[%u]:ueCb not found",
-                  staInd->rnti);
+         DU_LOG("\nRLC: rlcUtlSendToMac: UeId[%u]:ueCb not found",
+            staInd->rnti);
          /* If ueCb is not found for current rnti then continue to look for next rnti*/
          continue; 
       }
-      /* kw002.201 Removed the allocation of KwDatReq */
+      /* kw002.201 Removed the allocation of RlcDatReq */
       /* kw004.201 Used SSI function to initialize the variable */
-      cmMemset( (U8 *)&datReq, 0, sizeof(KwDatReq) ); 
+      memset(&datReq, 0, sizeof(RlcDatReq) ); 
       totNumPdu = 0;
       for (numTb = 0; numTb < staInd->nmbOfTbs; numTb++)
       {
          staIndTb = &(staInd->staIndTb[numTb]);
          datReqTb = &(datReqInfo->datReq[idx].datReqTb[numTb]);
 #ifdef LTE_L2_MEAS
-         ueCb->tbIdx = (ueCb->tbIdx+1) % KW_MAX_TB_PER_UE;
+         ueCb->tbIdx = (ueCb->tbIdx+1) % RLC_MAX_TB_PER_UE;
 #endif   
          for (count = 0;count < staIndTb->nmbLch; count++)
          {
@@ -411,14 +431,14 @@ KwDStaIndInfo   *staIndInfo;
 #ifdef LTE_L2_MEAS            
                datReq.totMacGrant = grantPerLch[staIndTb->lchStaInd[count].lcId];
 #endif
-               kwUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
+               rlcUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
                if ( CM_LTE_MODE_UM == rbCb->mode )
                {
-                  kwUmmProcessSdus(gCb,rbCb,&datReq);
+                  rlcUmmProcessSdus(gCb,rbCb,&datReq);
                }
                else if ( CM_LTE_MODE_AM == rbCb->mode )
                {
-                  kwAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
+                  rlcAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
                }
 #ifdef LTE_L2_MEAS            
                grantPerLch[staIndTb->lchStaInd[count].lcId] = datReq.totMacGrant;
@@ -428,19 +448,17 @@ KwDStaIndInfo   *staIndInfo;
                   continue;
                }
                totNumPdu += datReq.pduInfo.numPdu;
-               cmMemcpy((U8 *)(&(datReqTb->lchData[count].pdu)),
-                     (U8 *)(&(datReq.pduInfo)),sizeof(KwPduInfo));
+               memcpy(&(datReqTb->lchData[count].pdu),
+                  &(datReq.pduInfo),sizeof(KwPduInfo));
 
-//Debug
-               U8 numPdu = 0;
                for (;numPdu < datReqTb->lchData[count].pdu.numPdu ; numPdu ++)
                {
                   MsgLen len = 0;
-                  SFndLenMsg(datReqTb->lchData[count].pdu.mBuf[numPdu],&len);
+                  ODU_GET_MSG_LEN(datReqTb->lchData[count].pdu.mBuf[numPdu],&len);
                   datIndSz += len; 
                }
                datReqTb->lchData[count].setMaxUlPrio = FALSE;
-               if (KW_AM_IS_POLL_BIT_SET(AMDL) && 
+               if (RLC_AM_IS_POLL_BIT_SET(AMDL) && 
                    (AMDL.sduQ.count > 1))
                { 
                   /* Poll bit is set indicate to MAC*/
@@ -495,7 +513,7 @@ KwDStaIndInfo   *staIndInfo;
                datReqTb->lchData[count].boReport.oldestSduArrTime = 
                                              datReq.boRep.oldestSduArrTime;
                /* kw004.201 Used SSI function to initialize the variable */
-               cmMemset( (U8 *)&datReq, 0, sizeof(KwDatReq) ); 
+               memset(&datReq, 0, sizeof(RlcDatReq) ); 
             }
          }
 #ifdef LTE_L2_MEAS
@@ -505,7 +523,7 @@ KwDStaIndInfo   *staIndInfo;
          }
          else
          {
-            datReqTb->tbId = KW_INVALID_TBID; 
+            datReqTb->tbId = RLC_INVALID_TBID; 
          }
 #endif
          datReqTb->nmbLch = staIndTb->nmbLch;
@@ -519,17 +537,17 @@ KwDStaIndInfo   *staIndInfo;
 #ifdef LTE_L2_MEAS_LOSS_DELAY
          if(tbSnMap->numSn == 0)
          {
-            RLC_FREE(tbSnMap,sizeof(KwTbSnMap));
+            RLC_FREE(tbSnMap,sizeof(RlcTbSnMap));
             RLC_FREE(datReqTb->rguSnInfo,sizeof(RguSnMapInfo));
             datReqTb->rguSnInfo = NULLP;
-            rlcCb.kwL2Cb.curTbSnMap = NULLP;
+            rlcCb.rlcL2Cb.curTbSnMap = NULLP;
             datReqTb->snMapPres = FALSE;
          }
          else
          {
-            cmHashListInsert(&(rlcCb.kwL2Cb.tbHlCp),(PTR)tbSnMap,
-                  (U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
-            rlcCb.kwL2Cb.curTbSnMap = NULLP;
+            cmHashListInsert(&(rlcCb.rlcL2Cb.tbHlCp),(PTR)tbSnMap,
+                  (uint8_t *) &(tbSnMap->tbId), (uint16_t)sizeof(tbSnMap->tbId));
+            rlcCb.rlcL2Cb.curTbSnMap = NULLP;
          }
 #endif /* LTE_L2_MEAS */
       }
@@ -539,17 +557,10 @@ KwDStaIndInfo   *staIndInfo;
    }
    datReqInfo->cellId  = staIndInfo->cellId;
    datReqInfo->nmbOfUeGrantPerTti = staIndInfo->nmbOfUeGrantPerTti;
-   /* If trace flag is enabled send the trace indication */
-   if(TRUE == gCb->init.trc )
-   {
-      /* Populate the trace params */
-      kwLmmSendTrc(gCb,EVTRGUDDATREQ, NULLP);
-   }
 
    rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
-//Debug
-   KwLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo); 
-   RETVALUE(ROK);
+   rlcSendDedLcDlData(&rguSap->pst,rguSap->spId,datReqInfo); 
+   return ROK;
 }
 
 /**
@@ -572,60 +583,40 @@ KwDStaIndInfo   *staIndInfo;
  *      -# ROK 
  *      -# RFAILED
  */
-#ifdef ANSI
-PUBLIC S16 kwUtlSndDStaRsp
-(
-RlcCb       *gCb,
-RlcDlRbCb   *rbCb,     
-S32        bo,        
-S32        estHdrSz,  
-Bool       staPduPrsnt,
-U32        staPduBo
-)
-#else
-PUBLIC S16 kwUtlSndDStaRsp(gCb,rbCb,bo,estHdrSz,staPduPrsnt,staPduBo)
-RlcCb       *gCb;
-RlcDlRbCb   *rbCb;      
-S32        bo;         
-S32        estHdrSz;   
-Bool       staPduPrsnt;
-U32        staPduBo;
-#endif
+uint8_t rlcUtlSendDedLcBoStatus(RlcCb *gCb, RlcDlRbCb *rbCb, int32_t bo, \
+   int32_t estHdrSz, bool staPduPrsnt, uint32_t staPduBo)
 {
-   RlcMacBOStatus   boStatus;      /* Buffer occupancy status information */
-   KwRguSapCb       *rguSap;       /* MAC SAP Information */
-   TRC3(kwUtlSndDStaRsp)
+   Pst           pst;           /* Post info */
+   RlcBoStatus   *boStatus;      /* Buffer occupancy status information */
+
 #ifndef TENB_ACC
-   if ((rbCb->lastRprtdBoToMac > (U32)8000) && (rbCb->boUnRprtdCnt < (U32)5) 
+   if ((rbCb->lastRprtdBoToMac > (uint32_t)8000) && (rbCb->boUnRprtdCnt < (uint32_t)5) 
        && (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
    {
       rbCb->boUnRprtdCnt++;
-      RETVALUE(ROK);
+      return ROK;
    }
 #endif
+   rbCb->boUnRprtdCnt = (uint32_t)0;
+   rbCb->lastRprtdBoToMac = (uint32_t)bo;
 
-   rguSap = &(gCb->u.dlCb->rguDlSap[rbCb->rguSapId]);
+   RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, \
+      boStatus, sizeof(RlcBoStatus));
 
-   rbCb->boUnRprtdCnt = (U32)0;
-   rbCb->lastRprtdBoToMac = (U32)bo;
+   boStatus->cellId = rbCb->rlcId.cellId;
+   boStatus->ueIdx = rbCb->rlcId.ueId;
+   boStatus->commCh = FALSE; 
+   boStatus->lcId = rbCb->lch.lChId;
+   boStatus->bo = bo;
 
-   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)
+   FILL_PST_RLC_TO_MAC(pst, RLC_DL_INST, EVENT_BO_STATUS_TO_MAC);
+   /* Send Status Response to MAC layer */
+   if(RlcSendBoStatusToMac(&pst, boStatus) != ROK)
    {
-      /* Populate the trace params */
-      kwLmmSendTrc(gCb, EVTRLCBOSTA, NULLP);
+      RLC_FREE_SHRABL_BUF(pst.region, pst.pool, boStatus, sizeof(RlcBoStatus));
    }
-   /* Send Status Response to MAC layer */
-   RlcMacSendBOStatus(&rguSap->pst,rguSap->spId,&boStatus);
 
-
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /**
@@ -647,27 +638,27 @@ U32        staPduBo;
 /* kw005.201 added support for L2 Measurement */
 #ifdef LTE_L2_MEAS_RLC
 #ifdef ANSI
-PUBLIC Void kwUtlEmptySduQ
+Void rlcUtlEmptySduQ
 (
 RlcCb        *gCb, 
 RlcDlRbCb    *rbCb,
 CmLListCp   *sduQ 
 )
 #else
-PUBLIC Void kwUtlEmptySduQ(gCb,rbCb, sduQ)
+Void rlcUtlEmptySduQ(gCb,rbCb, sduQ)
 RlcCb        *gCb;
 RlcDlRbCb    *rbCb;
 CmLListCp   *sduQ;
 #endif
 #else
 #ifdef ANSI
-PUBLIC Void kwUtlEmptySduQ
+Void rlcUtlEmptySduQ
 (
 RlcCb        *gCb,
 CmLListCp   *sduQ 
 )
 #else
-PUBLIC Void kwUtlEmptySduQ(gCb,sduQ)
+Void rlcUtlEmptySduQ(gCb,sduQ)
 RlcCb        *gCb;
 CmLListCp   *sduQ; 
 #endif
@@ -676,9 +667,8 @@ CmLListCp   *sduQ;
 #ifdef LTE_L2_MEAS_RLC
    CmLListCp   *sduSnMapQ;             /* SDU Sequence number map queue */
    CmLList     *firstSduSnMap;         /* First Node in SDU SnMap Queue */
-   KwSduSnMap  *sduSnMap;              /* SDU Sn Map */
+   RlcSduSnMap  *sduSnMap;              /* SDU Sn Map */
 
-   TRC2(kwUtlEmptySduQ)
    sduSnMapQ = NULLP;
    firstSduSnMap = NULLP;
    sduSnMap = NULLP;
@@ -689,11 +679,11 @@ CmLListCp   *sduQ;
 
    while(firstSduSnMap)
    {
-      sduSnMap = (KwSduSnMap *)firstSduSnMap->node;
+      sduSnMap = (RlcSduSnMap *)firstSduSnMap->node;
       if(sduSnMap != NULLP)
       {
          cmLListDelFrm(&(rbCb->sduSnMapQ), &(sduSnMap->lstEnt));
-         RLC_FREE(sduSnMap, sizeof(KwSduSnMap));
+         RLC_FREE(sduSnMap, sizeof(RlcSduSnMap));
          CM_LLIST_FIRST_NODE(sduSnMapQ, firstSduSnMap);
       }
       else
@@ -702,7 +692,7 @@ CmLListCp   *sduQ;
       }
    }
 #endif
-   RETVOID;
+   return;
 }
 
 /**
@@ -722,27 +712,11 @@ CmLListCp   *sduQ;
  *
  * @return  void 
  */
-#ifdef ANSI
-PUBLIC Void kwUtlCalcLiForSdu
-(
-RlcCb     *gCb,
-U16      numLi, 
-MsgLen   msgLen,
-S16      *pduSz 
-)
-#else
-PUBLIC Void kwUtlCalcLiForSdu(gCb,numLi,msgLen,pduSz)
-RlcCb     *gCb;
-U16      numLi; 
-MsgLen   msgLen;
-S16      *pduSz;
-#endif 
+void rlcUtlCalcLiForSdu(RlcCb *gCb, uint16_t numLi, MsgLen msgLen, int16_t *pduSz)
 {
-   TRC2(kwUtlCalcLiForSdu)
-
-   if ( (*pduSz > msgLen)  && (msgLen < KW_2K_BYTE))
+   if ( (*pduSz > msgLen)  && (msgLen < RLC_2K_BYTE))
    {
-      if(0 == (numLi & KW_BIT0)) /* check if number of LIs are odd or even */
+      if(0 == (numLi & RLC_BIT0)) /* check if number of LIs are odd or even */
       {  
          /* if number of LI's are even 2 bytes needed */
          *pduSz -= 2;
@@ -753,7 +727,7 @@ S16      *pduSz;
          *pduSz -= 1;
       }
    }
-   RETVOID;
+   return;
 }
 
 /**
@@ -774,18 +748,17 @@ S16      *pduSz;
  * @return  void 
  */
 #ifdef ANSI
-PUBLIC Void rlcDlUtlSetReestInProgressForRB
+Void rlcDlUtlSetReestInProgressForRB
 (
 RlcCb     *gCb,
 RlcDlRbCb *rbCb
 )
 #else
-PUBLIC Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
+Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
 RlcCb     *gCb;
 RlcDlRbCb *rbCb;
 #endif 
 {
-   TRC2(rlcDlUtlSetReestInProgressForRB)
       
    rbCb->reestInProgress = TRUE;
    
@@ -793,9 +766,9 @@ RlcDlRbCb *rbCb;
    {
       rbCb->m.amDl.estHdrSz = 0;
 
-      if(kwChkTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR))
+      if(rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
       {
-         kwStopTmr(gCb, (PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
+         rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
       }
    }
    else
@@ -803,9 +776,9 @@ RlcDlRbCb *rbCb;
       rbCb->m.umDl.estHdrSz= 0;
    }
 
-   kwUtlSndDStaRsp(gCb, rbCb, 0, 0, FALSE,0);
+   rlcUtlSendDedLcBoStatus(gCb, rbCb, 0, 0, FALSE,0);
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -819,19 +792,9 @@ RlcDlRbCb *rbCb;
  *          TRUE  : Re-establishment is in progress
  *          FALSE : Re-establishment is not in progress
  */
-#ifdef ANSI
-PUBLIC Bool rlcDlUtlIsReestInProgress
-(
-RlcDlRbCb *rbCb
-)
-#else
-PUBLIC Bool rlcDlUtlIsReestInProgress(rbCb)
-RlcDlRbCb *rbCb;
-#endif 
+bool rlcDlUtlIsReestInProgress(RlcDlRbCb *rbCb)
 {
-   TRC2(rlcDlUtlSetReestInProgressForRB)
-
-   RETVALUE(rbCb->reestInProgress);
+   return (rbCb->reestInProgress);
 }
 
 /**
@@ -844,16 +807,15 @@ RlcDlRbCb *rbCb;
  * @return  Void
  */
 #ifdef ANSI
-PUBLIC Void rlcDlUtlResetReestInProgress
+Void rlcDlUtlResetReestInProgress
 (
 RlcDlRbCb *rbCb
 )
 #else
-PUBLIC Void rlcDlUtlResetReestInProgress(rbCb)
+Void rlcDlUtlResetReestInProgress(rbCb)
 RlcDlRbCb *rbCb;
 #endif 
 {
-   TRC2(rlcDlUtlSetReestInProgressForRB)
 
    rbCb->reestInProgress = FALSE;
 }
@@ -872,22 +834,20 @@ RlcDlRbCb *rbCb;
  * @return  void 
  */
 #ifdef ANSI
-PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs
+Void rlcDlUtlSetReestInProgressForAllRBs
 (
 RlcCb     *gCb,
 RlcDlUeCb *ueCb
 )
 #else
-PUBLIC Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
+Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
 RlcCb     *gCb;
 RlcDlUeCb *ueCb;
 #endif 
 {
-   U32        rbIdx;
+   uint32_t        rbIdx;
    
-   TRC2(rlcDlUtlSetReestInProgressForAllRBs)
-
-   for(rbIdx = 0;rbIdx < KW_MAX_SRB_PER_UE;rbIdx++)
+   for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
    {
       if(ueCb->srbCb[rbIdx] != NULLP)
       {
@@ -898,15 +858,15 @@ RlcDlUeCb *ueCb;
          else
          {
             /* For SRB we just need to stop the poll re-transmit timer */
-            if(kwChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], KW_EVT_AMDL_POLL_RETX_TMR))
+            if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR))
             {
-               kwStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], KW_EVT_AMDL_POLL_RETX_TMR);
+               rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR);
             }
          }
       }
    }
    
-   for(rbIdx = 0;rbIdx < KW_MAX_DRB_PER_UE;rbIdx++)
+   for(rbIdx = 0;rbIdx < RLC_MAX_DRB_PER_UE;rbIdx++)
    {
       if(ueCb->drbCb[rbIdx] != NULLP)
       {
@@ -914,7 +874,7 @@ RlcDlUeCb *ueCb;
       }
    }
       
-   RETVOID;
+   return;
 }
 
 /**
@@ -922,22 +882,14 @@ RlcDlUeCb *ueCb;
  *         in KWU SAP statistics
  *
  *
- * @param[in]  kwuSap     KWU SAP in which to increment the counter
+ * @param[in]  rlckwuSap     KWU SAP in which to increment the counter
  *
  * @return  Void
  */
-#ifdef ANSI
-PUBLIC Void kwUtlIncrementKwuStsSduTx
-(
-KwKwuSapCb *kwuSap 
-)
-#else
-PUBLIC Void kwUtlIncrementKwuStsSduTx(kwuSap)
-KwKwuSapCb *kwuSap;
-#endif
+void rlcUtlIncrementKwuStsSduTx(RlcKwuSapCb *rlckwuSap)
 {
-   kwuSap->sts.sduTx++;
-   RETVOID;
+   rlckwuSap->sts.sduTx++;
+   return;
 }
 
 /**
@@ -950,23 +902,13 @@ KwKwuSapCb *kwuSap;
  *
  * @return  Void
  */
-#ifdef ANSI
-PUBLIC Void kwUtlIncrementGenStsBytesAndPdusSent
-(
-KwGenSts   *genSts,
-Buffer     *pdu   
-)
-#else
-PUBLIC Void kwUtlIncrementGenStsBytesAndPdusSent(genSts, pdu)
-KwGenSts   *genSts;
-Buffer     *pdu; 
-#endif
+void rlcUtlIncrementGenStsBytesAndPdusSent(RlcGenSts *genSts, Buffer *pdu)
 {
    MsgLen bytesSent;
-   SFndLenMsg(pdu, &bytesSent);
+   ODU_GET_MSG_LEN(pdu, &bytesSent);
    genSts->bytesSent += bytesSent;
    genSts->pdusSent++;
-   RETVOID;
+   return;
 }
 
 /**
@@ -980,13 +922,13 @@ Buffer     *pdu;
  * @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlInitToBeFreed
+Void rlcUtlInitToBeFreed
 (
 RlcCb                *gCb,
 RlcDlDataToBeFreed   *toBeFreed
 )
 #else
-PUBLIC Void kwUtlInitToBeFreed(gCb, toBeFreed)
+Void rlcUtlInitToBeFreed(gCb, toBeFreed)
 RlcCb                *gCb;
 RlcDlDataToBeFreed   *toBeFreed;
 #endif
@@ -996,7 +938,7 @@ RlcDlDataToBeFreed   *toBeFreed;
    cmLListInit(&(toBeFreed->reTxLst));
    cmLListInit(&(toBeFreed->txLst));
    
-   RETVOID;
+   return;
 }
 
 /**
@@ -1008,12 +950,12 @@ RlcDlDataToBeFreed   *toBeFreed;
  * @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlInitializeSelfPst
+Void rlcUtlInitializeSelfPst
 (
 RlcCb *gCb  
 )
 #else
-PUBLIC Void kwUtlInitializeSelfPst(gCb)
+Void rlcUtlInitializeSelfPst(gCb)
 RlcCb *gCb;
 #endif
 {
@@ -1038,24 +980,16 @@ RlcCb *gCb;
  *
  * @return  Void
  */
-#ifdef ANSI
-PUBLIC Void kwUtlRaiseDlCleanupEvent
-(
-RlcCb *gCb  
-)
-#else
-PUBLIC Void kwUtlRaiseDlCleanupEvent(gCb)
-RlcCb *gCb;
-#endif
+void rlcUtlRaiseDlCleanupEvent(RlcCb *gCb)
 {
 #ifdef KWSELFPSTDLCLEAN
    if(!gCb->u.dlCb->eventInQueue)
    {
-      SPstTsk(&gCb->u.dlCb->selfPst, gCb->u.dlCb->selfPstMBuf);
+      ODU_POST_TASK(&gCb->u.dlCb->selfPst, gCb->u.dlCb->selfPstMBuf);
       gCb->u.dlCb->eventInQueue = TRUE;
    }
 #endif
-   RETVOID;
+   return;
 }
 
 /**
@@ -1067,20 +1001,10 @@ RlcCb *gCb;
  *
  * @return  Void
  */
-#ifdef ANSI
-PUBLIC Void kwUtlAddSduToBeFreedQueue
-(
-RlcCb    *gCb,
-KwSdu   *sdu
-)
-#else
-PUBLIC Void kwUtlAddSduToBeFreedQueue(gCb, sdu)
-RlcCb    *gCb;
-KwSdu   *sdu;
-#endif
+void rlcUtlAddSduToBeFreedQueue(RlcCb *gCb, RlcSdu *sdu)
 {
    cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.sduLst), &(sdu->lstEnt));
-   RETVOID;
+   return;
 }
 
 /**
@@ -1093,19 +1017,19 @@ KwSdu   *sdu;
  * @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlAddReTxPduToBeFreedQueue
+Void rlcUtlAddReTxPduToBeFreedQueue
 (
 RlcCb     *gCb,
-KwRetx   *retx
+RlcRetx   *retx
 )
 #else
-PUBLIC Void kwUtlAddReTxPduToBeFreedQueue(gCb, retx)
+Void rlcUtlAddReTxPduToBeFreedQueue(gCb, retx)
 RlcCb     *gCb;
-KwRetx   *retx;
+RlcRetx   *retx;
 #endif
 {
    cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.reTxLst), &(retx->lstEnt));
-   RETVOID;
+   return;
 }
 
 /**
@@ -1118,20 +1042,20 @@ KwRetx   *retx;
  * @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlAddTxPduToBeFreedQueue
+Void rlcUtlAddTxPduToBeFreedQueue
 (
 RlcCb   *gCb,
-KwTx   *pdu
+RlcTx   *pdu
 )
 #else
-PUBLIC Void kwUtlAddTxPduToBeFreedQueue(gCb, pdu)
+Void rlcUtlAddTxPduToBeFreedQueue(gCb, pdu)
 RlcCb   *gCb;
-KwTx   *pdu;
+RlcTx   *pdu;
 #endif
 {
    pdu->rlsLnk.node = (PTR)pdu;
    cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.txLst), &(pdu->rlsLnk));
-   RETVOID;
+   return;
 }
 
 /*
@@ -1151,32 +1075,29 @@ KwTx   *pdu;
  *     - FALSE if all the data has been freed
  */
 #ifdef ANSI
-PRIVATE Bool kwUtlFreeDlAmRbMemory
+static Bool rlcUtlFreeDlAmRbMemory
 (
 RlcCb       *gCb,
 RlcDlRbCb   *rbCb,
-U32        *toBeFreed
+uint32_t    *toBeFreed
 )
 #else
-PRIVATE Bool kwUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
+static Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
 RlcCb       *gCb;
 RlcDlRbCb   *rbCb;
-U32        *toBeFreed
+uint32_t    *toBeFreed
 #endif
 {
-   KwRetx   *retx;   /* retransmission buffer */
-   KwSn     mTxNext;    /* send state variable */
-   KwTx      *txBuf;
-
-   TRC2(kwUtlFreeDlAmRbMemory)
-
+   RlcRetx   *retx;   /* retransmission buffer */
+   RlcSn     mTxNext;    /* send state variable */
+   RlcTx      *txBuf;
 
    MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
 
    /* TODO : to be checked changed from <= to < */
    while ((0 < mTxNext) && *toBeFreed)
    {
-      txBuf =  kwUtlGetTxBuf(AMDL.txBufLst, AMDL.txNextAck);
+      txBuf =  rlcUtlGetTxBuf(AMDL.txBufLst, AMDL.txNextAck);
       if (txBuf && txBuf->pduLst.first)
       {
          while(txBuf->pduLst.first)
@@ -1187,7 +1108,7 @@ U32        *toBeFreed
 	    cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
 	    RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
 	 }
-         kwUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
+         rlcUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
          if(gCb->u.dlCb->shutdownReceived == 0)
          {   
             (*toBeFreed)--;
@@ -1198,23 +1119,23 @@ U32        *toBeFreed
    }
    if(*toBeFreed == 0)
    {
-      RETVALUE(TRUE);
+      return (TRUE);
    }
    
 #ifndef LTE_TDD 
-      RLC_FREE(gCb,AMDL.txBufLst, (KW_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+      RLC_FREE(gCb,AMDL.txBufLst, (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
 #endif
 
-   KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+   RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
    while (retx && (*toBeFreed)) /* Till to be freed becomes 0 */
    {
 
       RLC_FREE_BUF(retx->seg);
 
       cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
-      RLC_FREE_WC(gCb, retx, sizeof(KwRetx));
+      RLC_FREE_WC(gCb, retx, sizeof(RlcRetx));
 
-      KW_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+      RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
       if(gCb->u.dlCb->shutdownReceived == 0)
       {
       (*toBeFreed)--;
@@ -1232,20 +1153,20 @@ U32        *toBeFreed
       RLC_FREE_SHRABL_BUF_WC(udxPst->region,
 			    udxPst->pool,
 			    AMDL.pStaPdu, 
-			    sizeof(KwUdxDlStaPdu));
+			    sizeof(RlcUdxDlStaPdu));
       AMDL.pStaPdu = NULLP;
    }
 
    if(*toBeFreed == 0)
    {
-      RETVALUE(TRUE);
+      return (TRUE);
    }  
    if(gCb->u.dlCb->shutdownReceived)
    {   
       (*toBeFreed)--;
    }
    
-   RETVALUE(FALSE);;
+   return (FALSE);
 } 
 
 /**
@@ -1257,22 +1178,22 @@ U32        *toBeFreed
  * @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlFreeDlMemory
+Void rlcUtlFreeDlMemory
 (
 RlcCb *gCb  
 )
 #else
-PUBLIC Void kwUtlFreeDlMemory(gCb)
+Void rlcUtlFreeDlMemory(gCb)
 RlcCb *gCb;
 #endif
 {
-   U32 toBeFreed; 
+   uint32_t toBeFreed; 
 
    /* safety check, in case some event was still lying in the queue after
       the dlCb was deleted*/
    if(!gCb->u.dlCb)
    {
-      RETVOID;
+      return;
    }
 
    RlcDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
@@ -1283,22 +1204,22 @@ RlcCb *gCb;
    }
    else
    {
-      if ((pToBeFreed->txLst.count + pToBeFreed->reTxLst.count + pToBeFreed->sduLst.count) > (3 * KW_MAX_TO_BE_FREED))
+      if ((pToBeFreed->txLst.count + pToBeFreed->reTxLst.count + pToBeFreed->sduLst.count) > (3 * RLC_MAX_TO_BE_FREED))
       {
 #if !defined(KWSELFPSTDLCLEAN) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)
          if (isDatReqProcessed)
          {
-            toBeFreed = (2 *KW_MAX_TO_BE_FREED);
+            toBeFreed = (2 *RLC_MAX_TO_BE_FREED);
          }
          else
 #endif
          {
-            toBeFreed = (3 *KW_MAX_TO_BE_FREED)/2;
+            toBeFreed = (3 *RLC_MAX_TO_BE_FREED)/2;
          }
       }
       else
       {
-         toBeFreed = KW_MAX_TO_BE_FREED;
+         toBeFreed = RLC_MAX_TO_BE_FREED;
       }
    }   
    CmLListCp        *lst;
@@ -1314,10 +1235,10 @@ RlcCb *gCb;
    while((lst->first) && toBeFreed)
 #endif
    {
-      KwRetx* seg = (KwRetx *)(lst->first->node);
+      RlcRetx* seg = (RlcRetx *)(lst->first->node);
       cmLListDelFrm(lst, lst->first);
       RLC_FREE_BUF_WC(seg->seg);
-      RLC_FREE_WC(gCb,seg, sizeof(KwRetx));
+      RLC_FREE_WC(gCb,seg, sizeof(RlcRetx));
       toBeFreed--;
    }   
 
@@ -1329,7 +1250,7 @@ RlcCb *gCb;
    while((lst->first) && toBeFreed)
 #endif
    {
-      KwTx* pdu = (KwTx *)(lst->first->node);
+      RlcTx* pdu = (RlcTx *)(lst->first->node);
       cmLListDelFrm(lst, lst->first);
       while(pdu->pduLst.first)
       {
@@ -1339,7 +1260,7 @@ RlcCb *gCb;
 	 RLC_FREE_BUF_WC(pduInfo->pdu);
 	 RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
       }
-      RLC_FREE_WC(gCb,pdu, sizeof(KwTx));
+      RLC_FREE_WC(gCb,pdu, sizeof(RlcTx));
       toBeFreed--;
    }
 
@@ -1351,8 +1272,8 @@ RlcCb *gCb;
    while((lst->first) && toBeFreed)
 #endif
    {
-      KwSdu* sdu = (KwSdu *)(lst->first->node);
-      KW_RMV_SDU(gCb, lst, sdu);
+      RlcSdu* sdu = (RlcSdu *)(lst->first->node);
+      RLC_RMV_SDU(gCb, lst, sdu);
       toBeFreed--;
    }      
 
@@ -1365,7 +1286,7 @@ RlcCb *gCb;
 #endif
    {
       RlcDlRbCb* rbCb = (RlcDlRbCb *)(lst->first->node);
-      Bool moreToBeFreed = kwUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
+      Bool moreToBeFreed = rlcUtlFreeDlAmRbMemory(gCb, rbCb,&toBeFreed);
       if(!moreToBeFreed)
       {
          cmLListDelFrm(lst, lst->first);
@@ -1375,10 +1296,10 @@ RlcCb *gCb;
 
    if ((toBeFreed == 0) && !(gCb->u.dlCb->shutdownReceived))
    {
-      kwUtlRaiseDlCleanupEvent(gCb);
+      rlcUtlRaiseDlCleanupEvent(gCb);
    }
 
-   RETVOID;
+   return;
 }
 
 
@@ -1394,22 +1315,22 @@ RlcCb *gCb;
  *  @return  Void
  *
  */
-S16 kwUtlL2MeasDlInit(RlcCb *gCb)
+S16 rlcUtlL2MeasDlInit(RlcCb *gCb)
 {
-   U16   cntr;
+   uint16_t   cntr;
 
-   gCb->u.dlCb->kwL2Cb.kwNumMeas=0;
+   gCb->u.dlCb->rlcL2Cb.rlcNumMeas=0;
    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
    {
-      cmMemset((U8 *)&(gCb->u.dlCb->kwL2Cb.kwL2EvtCb[cntr]), 0, sizeof(KwL2MeasEvtCb));
+      memset(&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
    }
-   gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_DL_DISC].measCb.measType = LKW_L2MEAS_DL_DISC;
-   gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_DL_IP].measCb.measType = LKW_L2MEAS_DL_IP;
-   gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_DL_DELAY].measCb.measType= LKW_L2MEAS_DL_DELAY;
-   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;
+   gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_DISC].measCb.measType = LKW_L2MEAS_DL_DISC;
+   gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_IP].measCb.measType = LKW_L2MEAS_DL_IP;
+   gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_DL_DELAY].measCb.measType= LKW_L2MEAS_DL_DELAY;
+   gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UU_LOSS].measCb.measType= LKW_L2MEAS_UU_LOSS;
+   gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_ACT_UE].measCb.measType= LKW_L2MEAS_ACT_UE;
 
-   RETVALUE(ROK);
+   return ROK;
 }
 /**
  *
@@ -1426,31 +1347,30 @@ S16 kwUtlL2MeasDlInit(RlcCb *gCb)
  *
  */
 #ifdef ANSI
-PUBLIC Void kwUtlUpdateBurstSdus
+Void rlcUtlUpdateBurstSdus
 (
 RlcCb            *gCb,
 RlcDlRbCb        *rbCb,
-KwContSduLst    *contSduLst,
-S32             dataVol,
-U32             schPduSz
+RlcContSduLst    *contSduLst,
+S32              dataVol,
+uint32_t         schPduSz
 )
 #else
-PUBLIC Void  kwUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
+Void  rlcUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
 RlcCb            *gCb;
 RlcDlRbCb        *rbCb;
-KwContSduLst    *contSduLst;
-S32             dataVol;
-U32             schPduSz;
+RlcContSduLst    *contSduLst;
+S32              dataVol;
+uint32_t         schPduSz;
 #endif
 {
 
-   KwL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
-   KwL2MeasTb     *l2MeasTb = NULLP;
-   U8              idx;
-   U8              currTbIdx;
-   VOLATILE U32     startTime = 0;
-   KwContSduLst   *dstContSduLst;
-   TRC2(kwUtlUpdateBurstSdus)
+   RlcL2MeasDlIpTh   *l2MeasDlIpThruput = NULLP;
+   RlcL2MeasTb       *l2MeasTb = NULLP;
+   uint8_t           idx;
+   uint8_t           currTbIdx;
+   volatile uint32_t startTime = 0;
+   RlcContSduLst   *dstContSduLst;
 
 
    /*starting Task*/
@@ -1458,7 +1378,7 @@ U32             schPduSz;
 
    l2MeasDlIpThruput = &rbCb->l2MeasIpThruput.dlIpTh;
 
-   if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
+   if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
    {
       if(dataVol > schPduSz)
       {
@@ -1484,12 +1404,12 @@ U32             schPduSz;
       }
       if(l2MeasDlIpThruput->isBurstAct == TRUE)
       {
-         l2MeasTb = kwUtlGetCurMeasTb(gCb,rbCb);
+         l2MeasTb = rlcUtlGetCurMeasTb(gCb,rbCb);
          /* Get the lChId from index 0, because index 0 is always for DL */
-         if(l2MeasTb->numLcId >= KW_MAX_ACTV_DRB) 
+         if(l2MeasTb->numLcId >= RLC_MAX_ACTV_DRB) 
          {
             /* ccpu00143043 */
-            RETVOID;
+            return;
          }
          l2MeasTb->sduInfo[l2MeasTb->numLcId].lcId = rbCb->lch.lChId;
          /* Copy all the sduIdx from sduInfo to tb sduInfo */
@@ -1497,7 +1417,7 @@ U32             schPduSz;
          dstContSduLst = &l2MeasTb->sduInfo[l2MeasTb->numLcId];
          /* ccpu00143043 */
          for(idx = 0; ((idx < contSduLst->numSdus)
-                  && (currTbIdx < KW_L2MEAS_MAX_OUTSTNGSDU)) ; idx++)
+                  && (currTbIdx < RLC_L2MEAS_MAX_OUTSTNGSDU)) ; idx++)
          {
             dstContSduLst->sduIdx[currTbIdx++] = contSduLst->sduIdx[idx];
          }
@@ -1508,7 +1428,7 @@ U32             schPduSz;
 
    /*stopping Task*/
    SStopTask(startTime, PID_RLC_DLIP_TPT_BURSTCALC);
-   RETVOID;
+   return;
 }
 /**
  * @brief
@@ -1525,23 +1445,23 @@ U32             schPduSz;
  *  @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlUpdateContainedSduLst
+Void rlcUtlUpdateContainedSduLst
 (
-U8            sduIdx,
-KwContSduLst  *contSduLst
+uint8_t            sduIdx,
+RlcContSduLst  *contSduLst
 )
 #else
-PUBLIC Void kwUtlUpdateContainedSduLst(sduIdx, contSduLst)
-U8            sduIdx;
-KwContSduLst  *contSduLst;
+Void rlcUtlUpdateContainedSduLst(sduIdx, contSduLst)
+uint8_t            sduIdx;
+RlcContSduLst  *contSduLst;
 #endif
 {
-   if (contSduLst->numSdus < KW_L2MEAS_MAX_OUTSTNGSDU)
+   if (contSduLst->numSdus < RLC_L2MEAS_MAX_OUTSTNGSDU)
    {
     contSduLst->sduIdx[contSduLst->numSdus] = sduIdx;
     contSduLst->numSdus++;
    }
-    RETVOID;
+    return;
 }
 
 /**
@@ -1563,24 +1483,24 @@ KwContSduLst  *contSduLst;
  *  @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlUpdateOutStandingSduLst
+Void rlcUtlUpdateOutStandingSduLst
 (
-KwL2MeasDlIpTh   *dlIpThPut, 
-U8               sduIdx, 
+RlcL2MeasDlIpTh   *dlIpThPut, 
+uint8_t               sduIdx, 
 MsgLen           sduLen, 
-U32              sduId,
+uint32_t              sduId,
 Bool             newIdx
 )
 #else
-PUBLIC Void kwUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
-KwL2MeasDlIpTh   *dlIpThPut;
-U8               sduIdx;
+Void rlcUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
+RlcL2MeasDlIpTh   *dlIpThPut;
+uint8_t               sduIdx;
 MsgLen           sduLen; 
-U32              sduId;
+uint32_t              sduId;
 Bool             newIdx;
 #endif
 {
-   if (sduIdx < KW_L2MEAS_MAX_OUTSTNGSDU)
+   if (sduIdx < RLC_L2MEAS_MAX_OUTSTNGSDU)
    {
    if(newIdx == TRUE)
    {      
@@ -1590,50 +1510,48 @@ Bool             newIdx;
    dlIpThPut->outStngSduArr[sduIdx].sduId = sduId;
    dlIpThPut->outStngSduArr[sduIdx].sduLen = sduLen;
    }
-   RETVOID;
+   return;
 }
 #ifdef ANSI
-PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb
+RlcL2MeasTb * rlcUtlGetCurMeasTb
 (
 RlcCb     *gCb,
 RlcDlRbCb *rbCb
 )
 #else
-PUBLIC KwL2MeasTb * kwUtlGetCurMeasTb(gCb, rbCb)
+RlcL2MeasTb * rlcUtlGetCurMeasTb(gCb, rbCb)
 RlcCb     *gCb;
 RlcDlRbCb *rbCb;
 #endif
 {
-   KwL2MeasTb  *curL2MeasTb;
-   U16         idx;
+   RlcL2MeasTb  *curL2MeasTb;
+   uint16_t         idx;
 
-   TRC3(kwUtlGetCurMeasTb)
-      
    if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
       {
          /* Intentionally avoiding the RLC_ALLOC macro to avoid  memset */
          if (SGetSBuf(gCb->init.region,
                   gCb->init.pool,
                   (Data **)&curL2MeasTb,
-                  (Size)sizeof(KwL2MeasTb)) != ROK)
+                  (Size)sizeof(RlcL2MeasTb)) != ROK)
          {
-            RETVALUE(NULLP);
+            return (NULLP);
          }
          rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx] = curL2MeasTb;
          /* Initialize the Meas Tb details */
          curL2MeasTb->numLcId = 0;
          curL2MeasTb->numLchInfo = 0;
          curL2MeasTb->txSegSduCnt = 0;
-         for (idx = 0; idx < KW_MAX_ACTV_DRB; idx++)
+         for (idx = 0; idx < RLC_MAX_ACTV_DRB; idx++)
          {
             curL2MeasTb->sduInfo[idx].numSdus = 0;
          }
-         for (idx = 0; idx < KW_MAX_ACTV_DRB; idx++)
+         for (idx = 0; idx < RLC_MAX_ACTV_DRB; idx++)
          {
             curL2MeasTb->lchInfo[idx].numSdus = 0;
          }
       }
-   RETVALUE(curL2MeasTb);
+   return (curL2MeasTb);
 }
 
 
@@ -1657,68 +1575,66 @@ RlcDlRbCb *rbCb;
  */
 
 #ifdef ANSI
-PUBLIC S16 kwUtlProcHarqInd
+S16 rlcUtlProcHarqInd
 (
-RlcCb             *gCb,
+RlcCb            *gCb,
 RguHarqStatusInd *hqStaInd,
-RlcDlUeCb           *ueCb,
-U8               tbIdx
+RlcDlUeCb        *ueCb,
+uint8_t          tbIdx
 )
 #else
-PUBLIC S16 kwUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
+S16 rlcUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
 RlcCb             *gCb;
-RguHarqStatusInd *hqStaInd;
-RlcDlUeCb           *ueCb;
-U8               tbIdx;
+RguHarqStatusInd  *hqStaInd;
+RlcDlUeCb         *ueCb;
+uint8_t            tbIdx;
 #endif
 {
 #ifdef LTE_L2_MEAS
-   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 */
-   U32          numSdus;           /* number of sdus in the outstanding sdu list */
-   KwOutStngSduInfo *outStngSduArr;  /* Outstanding sdu list */
-   Ticks        ackTime;
-   Ticks        delay;
-   U32          totlSduCnt = 0;
+   RlcDlRbCb        *rlcRbCb;           /* KW Control Block */
+   RlcL2MeasTb       *l2MeasTb = NULLP;         /* Measurement TbCb */
+   uint8_t           lcIdx;             /* Logical channel id index */
+   uint8_t           sduIndx;            /* sdu index to out standing sdu list in rbCb */
+   uint32_t          numSdus;           /* number of sdus in the outstanding sdu list */
+   RlcOutStngSduInfo *outStngSduArr;  /* Outstanding sdu list */
+   Ticks             ackTime;
+   Ticks             delay;
+   uint32_t          totlSduCnt = 0;
 #endif
-   U8           timeAddedFlag;
-   S16          ret;
-   VOLATILE U32     startTime = 0;
+   uint8_t           timeAddedFlag;
+   S16               ret;
+   volatile uint32_t     startTime = 0;
    /*kw005.201 Code added for DL IP thruput measurement*/
 
-   TRC3(kwUtlProcHarqInd)
-
    /*starting Task*/
    SStartTask(&startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
 
    ret = ROK;
-   if(hqStaInd->tbId[tbIdx] >= KW_INVALID_TBID)
+   if(hqStaInd->tbId[tbIdx] >= RLC_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 */
    ackTime = SGetTtiCount();
-   for(lcIdx = 0; ((lcIdx < l2MeasTb->numLcId) && (lcIdx < KW_MAX_ACTV_DRB)); lcIdx++)
+   for(lcIdx = 0; ((lcIdx < l2MeasTb->numLcId) && (lcIdx < RLC_MAX_ACTV_DRB)); lcIdx++)
    {
       timeAddedFlag = FALSE;
-      if((kwRbCb = ueCb->lCh[l2MeasTb->sduInfo[lcIdx].lcId - 1].dlRbCb)
+      if((rlcRbCb = ueCb->lCh[l2MeasTb->sduInfo[lcIdx].lcId - 1].dlRbCb)
             == NULLP)
       {
          continue;
       }
       /* fix for DL IP stop*/
-      if (!gCb->u.dlCb->kwL2Cb.measOn[kwRbCb->qci]
-            || (kwRbCb->rlcId.rbType == CM_LTE_SRB))
+      if (!gCb->u.dlCb->rlcL2Cb.measOn[rlcRbCb->qci]
+            || (rlcRbCb->rlcId.rbType == CM_LTE_SRB))
       {
          continue;
       }
@@ -1727,51 +1643,51 @@ U8               tbIdx;
        * and check for HARQ ACK/NACK */
       numSdus = l2MeasTb->sduInfo[lcIdx].numSdus;
       /* ccpu00143043 */
-      if ((numSdus >= KW_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
+      if ((numSdus >= RLC_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
       {
          break;
       }
       totlSduCnt += numSdus;
 
-      if (KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,kwRbCb))
+      if (RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rlcRbCb))
       {
          for(sduIndx = 0; sduIndx < numSdus; sduIndx++)
          {
-            outStngSduArr =&(kwRbCb->l2MeasIpThruput.dlIpTh.outStngSduArr[\
+            outStngSduArr =&(rlcRbCb->l2MeasIpThruput.dlIpTh.outStngSduArr[\
                   l2MeasTb->sduInfo[lcIdx].sduIdx[sduIndx]]);
             if(hqStaInd->status[tbIdx] == TRUE)
             {
                /* If ACK is for burst End Sdu Id set burstActive 
                 * to FALSE  and accumulate time */
-               if((kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId == 
+               if((rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId == 
                         outStngSduArr->sduId) && (outStngSduArr->numTb == 1))
                {
-                  kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
+                  rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
                   /*Update the l2Sts structure for calculating throughput*/
-                  kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.volSummation
+                  rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.volSummation
                      += outStngSduArr->sduLen;
 
-                  kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.timeSummation
-                     += glblTtiCnt - kwRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
+                  rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.timeSummation
+                     += glblTtiCnt - rlcRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
                   outStngSduArr->sduId = 0;
                   outStngSduArr->sduLen = 0;
                   outStngSduArr->numTb = 0;
-                  kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
+                  rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
                }
 
                /* If burst is active and this sdu is only transmitted in single TB then
                 * accumulate volume  and clear the outstanding sduList */
-               if((kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE) &&
+               if((rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE) &&
                      (--(outStngSduArr->numTb) == 0))
                {
-                  kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.volSummation
+                  rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.volSummation
                      += outStngSduArr->sduLen;
 
                   if(timeAddedFlag == FALSE)
                   {
-                     kwRbCb->rbL2Cb.l2Sts[KW_L2MEAS_DL_IP]->dlIpThruput.timeSummation
-                        += glblTtiCnt - kwRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
-                     kwRbCb->l2MeasIpThruput.dlIpTh.burstStartTime = glblTtiCnt;
+                     rlcRbCb->rbL2Cb.l2Sts[RLC_L2MEAS_DL_IP]->dlIpThruput.timeSummation
+                        += glblTtiCnt - rlcRbCb->l2MeasIpThruput.dlIpTh.burstStartTime;
+                     rlcRbCb->l2MeasIpThruput.dlIpTh.burstStartTime = glblTtiCnt;
                      timeAddedFlag = TRUE;
                   }
                   outStngSduArr->sduId = 0;
@@ -1780,13 +1696,13 @@ U8               tbIdx;
             }/* End of status == TRUE */
             else
             {
-               if(kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE)
+               if(rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct == TRUE)
                {
-                  if((kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId == 
+                  if((rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId == 
                            outStngSduArr->sduId))
                   {
-                     kwRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
-                     kwRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
+                     rlcRbCb->l2MeasIpThruput.dlIpTh.isBurstAct = FALSE;
+                     rlcRbCb->l2MeasIpThruput.dlIpTh.burstEndSduId = 0;
                   }
                   /* Clear the outstanding sdu list */
                   outStngSduArr->sduId = 0;
@@ -1798,9 +1714,9 @@ U8               tbIdx;
       } 
    }
 
-   for(lcIdx = 0; ((lcIdx < l2MeasTb->numLchInfo) && (lcIdx < KW_MAX_ACTV_DRB)); lcIdx++)
+   for(lcIdx = 0; ((lcIdx < l2MeasTb->numLchInfo) && (lcIdx < RLC_MAX_ACTV_DRB)); lcIdx++)
    {
-      if((kwRbCb = ueCb->lCh[l2MeasTb->lchInfo[lcIdx].lcId - 1].dlRbCb)
+      if((rlcRbCb = ueCb->lCh[l2MeasTb->lchInfo[lcIdx].lcId - 1].dlRbCb)
             == NULLP)
       {
          continue;
@@ -1811,7 +1727,7 @@ U8               tbIdx;
          continue;
       }
       /* ccpu00143043 */
-      if ((numSdus > KW_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
+      if ((numSdus > RLC_L2MEAS_MAX_OUTSTNGSDU) || (numSdus == 0))
       {
          break;
       }
@@ -1820,15 +1736,15 @@ U8               tbIdx;
       {
          for(sduIndx = 0; sduIndx < numSdus; sduIndx++)
          {
-            delay = KW_TIME_DIFF(ackTime,l2MeasTb->lchInfo[lcIdx].sduInfo[sduIndx].arvlTime);
-            KW_UPD_PDCP_L2_DLDELAY_STS(gCb,kwRbCb, delay); 
+            delay = RLC_TIME_DIFF(ackTime,l2MeasTb->lchInfo[lcIdx].sduInfo[sduIndx].arvlTime);
+            RLC_UPD_PDCP_L2_DLDELAY_STS(gCb,rlcRbCb, delay); 
          }
          /* Case of sduInfo not updated */
          if (totlSduCnt == 0)
          {
             totlSduCnt = numSdus;
          }
-         KW_UPD_L2_UU_LOSS_POS_PKTS(gCb,kwRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
+         RLC_UPD_L2_UU_LOSS_POS_PKTS(gCb,rlcRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
       }
       else
       {
@@ -1837,18 +1753,18 @@ U8               tbIdx;
          {
             totlSduCnt = numSdus;
          }
-         KW_UPD_L2_UU_LOSS_PKTS(gCb,kwRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
+         RLC_UPD_L2_UU_LOSS_PKTS(gCb,rlcRbCb, (totlSduCnt + l2MeasTb->txSegSduCnt));
       }
    }
    /* Free this tb, deallocate the memory */
-   RLC_FREE(gCb, l2MeasTb, sizeof(KwL2MeasTb));
+   RLC_FREE(gCb, l2MeasTb, sizeof(RlcL2MeasTb));
    ueCb->l2MeasTbCb[hqStaInd->tbId[tbIdx]] = NULLP;
    
    /*stopping Task*/
    SStopTask(startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
 
-   RETVALUE(ret);
-}/* end of  kwUtlProcHarqInd */ 
+   return (ret);
+}/* end of  rlcUtlProcHarqInd */ 
 
 /**
  *
@@ -1867,44 +1783,41 @@ U8               tbIdx;
  */
 
 #ifdef ANSI
-PUBLIC S16 kwUtlSndDlL2MeasCfm
+S16 rlcUtlSndDlL2MeasCfm
 (
 RlcCb                  *gCb,
-KwL2MeasEvtCb         *measEvtCb
+RlcL2MeasEvtCb         *measEvtCb
 )
 #else
-PUBLIC S16 kwUtlSndDlL2MeasCfm(gCb, measEvtCb)
+S16 rlcUtlSndDlL2MeasCfm(gCb, measEvtCb)
 RlcCb                  *gCb;
-KwL2MeasEvtCb         *measEvtCb;
+RlcL2MeasEvtCb         *measEvtCb;
 #endif
 {
-   U32                     qciIdx;
-   KwL2MeasCb              *measCb = NULLP;
-   KwL2MeasCfmEvt          measCfmEvt;
-   U32                     posPkts;
-   U32                     dLoss;
-
-   U64                     dlDataVol;
-   U64                     dlTime;
-   U16                     cntr;
+   uint32_t         qciIdx;
+   RlcL2MeasCb      *measCb = NULLP;
+   RlcL2MeasCfmEvt   measCfmEvt;
+   uint32_t          posPkts;
+   uint32_t          dLoss;
+   uint64_t          dlDataVol;
+   uint64_t          dlTime;
+   uint16_t          cntr;
    /* Discard new changes starts */
-   U8                      qci = 0;
-   U32                     cfmIdx =0;
+   uint8_t           qci = 0;
+   uint32_t          cfmIdx =0;
    /* Discard new changes ends */
 
-   TRC3(kwUtlSndL2MeasCfm)
-
    /* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
 #ifndef ALIGN_64BIT
-   RLOG1(L_DEBUG,"kwUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
+   RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
 #else
-   RLOG1(L_DEBUG,"kwUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
+   RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
 #endif
 
    /* Clean up the RB data structures */
    measCb = &measEvtCb->measCb;
    
-   cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt));
+   memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
    measCfmEvt.transId = measEvtCb->transId;
 
    measCfmEvt.measType = measCb->measType;
@@ -1913,8 +1826,8 @@ KwL2MeasEvtCb         *measEvtCb;
    
    if(measCb->measType & LKW_L2MEAS_DL_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++)        
       {
@@ -1931,7 +1844,7 @@ KwL2MeasEvtCb         *measEvtCb;
                dlDataVol = pUeInfoLstCb[cntr].measData[qci].dlIpThruput.volSummation;
                dlTime = pUeInfoLstCb[cntr].measData[qci].dlIpThruput.timeSummation;
 
-               if((0 == dlTime) || !(gCb->u.dlCb->kwL2Cb.measOn[qci] & LKW_L2MEAS_DL_IP) )
+               if((0 == dlTime) || !(gCb->u.dlCb->rlcL2Cb.measOn[qci] & LKW_L2MEAS_DL_IP) )
                {
                   pUeInfoLstCfm[cfmIdx].measCfm[pUeInfoLstCfm[cfmIdx].numCfm].val.ipThrput.dlIpThPut = 0;
                }
@@ -1955,8 +1868,8 @@ KwL2MeasEvtCb         *measEvtCb;
    }
    else
    {
-      KwL2Cntr *pMeasData = measCb->val.nonIpThMeas.measData;
-      KwL2MeasCfmNonIpThMeas *pMeasCfmNonIp = &measCfmEvt.val.nonIpThMeas;
+      RlcL2Cntr *pMeasData = measCb->val.nonIpThMeas.measData;
+      RlcL2MeasCfmNonIpThMeas *pMeasCfmNonIp = &measCfmEvt.val.nonIpThMeas;
 
       pMeasCfmNonIp->numCfm = 0;
 
@@ -2007,9 +1920,9 @@ KwL2MeasEvtCb         *measEvtCb;
       }
    }
    /* Fix Klock warning */
-   KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
-   RETVALUE(ROK);
-} /* kwUtlSndL2MeasCfm */
+   RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
+   return ROK;
+} /* rlcUtlSndL2MeasCfm */
 /**
  *
  * @brief Handler for Sending Negative confirm .
@@ -2027,23 +1940,22 @@ KwL2MeasEvtCb         *measEvtCb;
  */
 
 #ifdef ANSI
-PUBLIC S16 kwUtlSndDlL2MeasNCfm
+S16 rlcUtlSndDlL2MeasNCfm
 (
 RlcCb           *gCb,
-KwL2MeasReqEvt *measReqEvt,
-KwL2MeasCfmEvt *measCfmEvt
+RlcL2MeasReqEvt *measReqEvt,
+RlcL2MeasCfmEvt *measCfmEvt
 )
 #else
-PUBLIC S16 kwUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
+S16 rlcUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
 RlcCb           *gCb;
-KwL2MeasReqEvt *measReqEvt;
-KwL2MeasCfmEvt *measCfmEvt;
+RlcL2MeasReqEvt *measReqEvt;
+RlcL2MeasCfmEvt *measCfmEvt;
 #endif
 {
-   TRC3(kwUtlSndDlL2MeasNCfm)
 
-   KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
-   RETVALUE(ROK);
+   RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
+   return ROK;
 } /* kwUtlSndL2MeasNCfm */
 /**
  *
@@ -2061,21 +1973,21 @@ KwL2MeasCfmEvt *measCfmEvt;
  */
 #ifdef ANSI
 
-PUBLIC Void kwUtlResetDlL2MeasInKwRb
+Void rlcUtlResetDlL2MeasInRlcRb
 (
 RlcCb       *gCb,
-KwL2MeasCb *measCb,
-U8             measType
+RlcL2MeasCb *measCb,
+uint8_t      measType
 )
 #else
-PUBLIC Void kwUtlResetDlL2MeasInKwRb(gCb, measCb, measType)
+Void rlcUtlResetDlL2MeasInRlcRb(gCb, measCb, measType)
 RlcCb       *gCb;
-KwL2MeasCb *measCb;
-U8             measType;
+RlcL2MeasCb *measCb;
+uint8_t      measType;
 #endif
 {
-   U32           ueIdx;
-   U32           qciIdx;
+   uint32_t           ueIdx;
+   uint32_t           qciIdx;
    RlcDlUeCb      *ueCb = NULL;
 
 
@@ -2092,11 +2004,11 @@ U8             measType;
                {
                   measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[qciIdx].dlIpThruput.volSummation = 0;
                   measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[qciIdx].dlIpThruput.timeSummation = 0;
-                  gCb->u.dlCb->kwL2Cb.measOn[qciIdx] &= ~measType; 
+                  gCb->u.dlCb->rlcL2Cb.measOn[qciIdx] &= ~measType; 
                }
             }
 
-            if(ROK  != kwDbmFetchDlUeCb(gCb,measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
+            if(ROK  != rlcDbmFetchDlUeCb(gCb,measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
                      measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId, &ueCb))
             {
                continue;
@@ -2110,10 +2022,10 @@ U8             measType;
       /* for now the only meas should be DL discard in this case */
       if (measCb->measType & LKW_L2MEAS_DL_DISC)
       {
-         U32 i;
+         uint32_t i;
          for(i = 0; i < measCb->val.nonIpThMeas.numQci; i++)
          {
-            U8 qciVal = measCb->val.nonIpThMeas.qci[i];
+            uint8_t qciVal = measCb->val.nonIpThMeas.qci[i];
 
             measCb->val.nonIpThMeas.measData[qciVal].dlDisc.discSdus = 0;
             measCb->val.nonIpThMeas.measData[qciVal].dlDisc.totSdus  = 0;
@@ -2122,20 +2034,20 @@ U8             measType;
       }
       if (measCb->measType & LKW_L2MEAS_DL_DELAY)
       {
-         U32 i;
+         uint32_t i;
          for(i = 0; i < measCb->val.nonIpThMeas.numQci; i++)
          {
-            U8 qciVal = measCb->val.nonIpThMeas.qci[i];
+            uint8_t qciVal = measCb->val.nonIpThMeas.qci[i];
 
             measCb->val.nonIpThMeas.measData[qciVal].dlPjSduDelay.sduDelay = 0;
          }
       }
       measCb->val.nonIpThMeas.numQci = 0;
    }
-} /* kwUtlResetDlL2MeasInKwRb */
+} /* rlcUtlResetDlL2MeasInRlcRb */
 #endif
 
-PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
+static Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
 {
    if(dlRbCb->mode == CM_LTE_MODE_UM)
    {
@@ -2147,10 +2059,10 @@ PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
    }
    else if(dlRbCb->mode == CM_LTE_MODE_AM)
    {
-      U32 j, numTxPdus=0;
-      for(j = 0; j <= (KW_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
+      uint32_t j, numTxPdus=0;
+      for(j = 0; j <= (RLC_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
       {
-         KwTx *txBuf = kwUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
+         RlcTx *txBuf = rlcUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
          if(txBuf != NULLP)
          {
             numTxPdus++;
@@ -2184,8 +2096,8 @@ Void DumpRLCDlDebugInformation(Void)
                                    (PTR) ueCb, 
                                    (PTR *)&ueCb))
    {
-      U32 i;
-      for(i = 0; i< KW_MAX_SRB_PER_UE; i++)
+      uint32_t i;
+      for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
       {
          RlcDlRbCb* dlRbCb = ueCb->srbCb[i]; 
          if( dlRbCb != NULLP)
@@ -2193,7 +2105,7 @@ Void DumpRLCDlDebugInformation(Void)
             dumpRLCDlRbInformation(dlRbCb);
          }
       }
-      for(i = 0; i< KW_MAX_DRB_PER_UE; i++)
+      for(i = 0; i< RLC_MAX_DRB_PER_UE; i++)
       {
          RlcDlRbCb* dlRbCb = ueCb->drbCb[i]; 
          if( dlRbCb != NULLP)
@@ -2223,16 +2135,16 @@ Void DumpRLCDlDebugInformation(Void)
  */
 
 #ifdef ANSI
-void kwUtlFreeDlMem
+void rlcUtlFreeDlMem
 (
  Void
 )
 #else
-void kwUtlFreeDlMem()
+void rlcUtlFreeDlMem()
 Void;
 #endif
 {
-  kwUtlFreeDlMemory(RLC_GET_RLCCB(KW_DL_INST));
+  rlcUtlFreeDlMemory(RLC_GET_RLCCB(RLC_DL_INST));
 }
 
 /**
@@ -2240,24 +2152,14 @@ Void;
  * @b Description
  *        This function returns current time
  *
- *  @param[in] U32 
+ *  @param[in] uint32_t 
  *
  *
  *  @return  Void
  */
 
-#ifdef ANSI
-void kwUtlGetCurrTime
-(
- U32  *currTime
-)
-#else
-void kwUtlGetCurrTime(U32 *currTime)
-U32   *currTime;
-#endif
+void rlcUtlGetCurrTime(uint32_t  *currTime)
 {
-   TRC2(kwUtlGetCurrTime)
-
    /* Need t define else part for PAL */
    *currTime = SGetTtiCount();
 }
@@ -2265,12 +2167,12 @@ U32   *currTime;
 #if defined(MAC_RLC_HARQ_STA_RBUF) || defined (SS_RBUF)
 #ifdef LTE_L2_MEAS
 #ifdef ANSI
-void kwUtlDlBatchProcHqStaInd
+void rlcUtlDlBatchProcHqStaInd
 (
  Void
 )
 #else
-void kwUtlDlBatchProcHqStaInd()
+void rlcUtlDlBatchProcHqStaInd()
 Void;
 #endif
 {
@@ -2287,7 +2189,7 @@ Void;
    while(NULLP != elmIndx)
    {
       staInd = (RguHarqStaInd *)elmIndx;
-      KwLiRguHqStaInd(&(staInd->pst), 0, &(staInd->hqStatusInd));
+      RlcLiRguHqStaInd(&(staInd->pst), 0, &(staInd->hqStatusInd));
 
       elmIndx = NULLP;
       staInd  = NULLP;
@@ -2317,31 +2219,31 @@ Void;
  *
  */
 #ifdef ANSI
-PUBLIC Void kwUtlTrigPdbFlowCntrl
+Void rlcUtlTrigPdbFlowCntrl
 (
 RlcCb       *gCb,
 RlcDlRbCb   *rbCb,
-U32        pktAdmitCnt
+uint32_t    pktAdmitCnt
 )
 #else
-PUBLIC Void kwUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
+Void rlcUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
 RlcCb       *gCb;
 RlcDlRbCb   *rbCb;
-U32        pktAdmitCnt;
+uint32_t    pktAdmitCnt;
 #endif
 {
    KwuFlowCntrlIndInfo    *flowCntrlInfo;
-   KwKwuSapCb*            kwuSap;
+   RlcKwuSapCb*            rlckwuSap;
 
-   kwuSap = gCb->u.dlCb->kwuDlSap + KW_UI_PDCP;
+   rlckwuSap = gCb->u.dlCb->rlcKwuDlSap + RLC_UI_PDCP;
 
-   RLC_SHRABL_STATIC_BUF_ALLOC(kwuSap->pst.region, 
-                              kwuSap->pst.pool, 
+   RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, 
+                              rlckwuSap->pst.pool, 
                               flowCntrlInfo, 
                               sizeof(KwuFlowCntrlIndInfo));
    flowCntrlInfo->rlcId       = rbCb->rlcId;
    flowCntrlInfo->pktAdmitCnt = pktAdmitCnt;
-   KwUiKwuFlowCntrlInd(&kwuSap->pst, kwuSap->suId, flowCntrlInfo);
+   RlcUiKwuFlowCntrlInd(&rlckwuSap->pst, rlckwuSap->suId, flowCntrlInfo);
 }
 
 /**
@@ -2359,31 +2261,17 @@ U32        pktAdmitCnt;
  *
  *  @return  Void
  */
-#ifdef ANSI
-PUBLIC Void kwUtlStoreTxBuf 
-(
-CmLListCp        *txBufLst,
-KwTx             *txBuf,
-KwSn              sn
-)
-#else
-PUBLIC Void kwUtlStoreTxBuf(txBufLst, txBuf, sn)
-CmLListCp        *txBufLst;
-KwTx             *txBuf;
-KwSn              sn;
-#endif
+void rlcUtlStoreTxBuf(CmLListCp *txBufLst, RlcTx *txBuf, RlcSn sn)
 {
-   U32             hashKey; 
+   uint32_t   hashKey; 
 
-   TRC3(kwUtlStoretxBuf)
-   //printf("S-sn(%d)\n", sn);
-   hashKey = (sn % KW_TX_BUF_BIN_SIZE );
+   hashKey = (sn % RLC_TX_BUF_BIN_SIZE );
    txBuf->sn = sn; 
    txBuf->lnk.node = (PTR)txBuf;
    cmLListAdd2Tail(&(txBufLst[hashKey]), &txBuf->lnk);
 
-   RETVOID;
-} /* kwUtlStoreRecBuf */
+   return;
+} /* rlcUtlStoreRecBuf */
 
 /**
  *
@@ -2399,41 +2287,28 @@ KwSn              sn;
  *
  *  @return  Void
  */
-#ifdef ANSI
-PUBLIC KwTx* kwUtlGetTxBuf 
-(
-CmLListCp        *txBufLst,
-KwSn             sn
-)
-#else
-PUBLIC KwTx* kwUtlGetTxBuf(txBufLst, sn)
-CmLListCp        *txBufLst;
-KwSn             sn;
-#endif
+RlcTx* rlcUtlGetTxBuf(CmLListCp *txBufLst, RlcSn sn)
 {
-   U32                 hashKey; 
+   uint32_t            hashKey; 
    CmLListCp           *txBufLstCp;
-   KwTx                *txBuf;
+   RlcTx               *txBuf;
    CmLList             *node = NULLP;
 
-   TRC3(kwUtlGetTxBuf)
-   //printf("G-sn(%d)\n", sn);
-
-   hashKey = (sn % KW_TX_BUF_BIN_SIZE ); 
+   hashKey = (sn % RLC_TX_BUF_BIN_SIZE ); 
  
    txBufLstCp = &txBufLst[hashKey];
    CM_LLIST_FIRST_NODE(txBufLstCp, node);
    while(node)
    {
-      txBuf = (KwTx *) node->node;
+      txBuf = (RlcTx *) node->node;
       if(txBuf->sn == sn)
       {
-         RETVALUE(txBuf);
+         return (txBuf);
       }
       CM_LLIST_NEXT_NODE(txBufLstCp, node);
    }
-   RETVALUE(NULLP);
-} /* kwUtlStoreTxBuf */
+   return NULLP;
+} /* rlcUtlStoreTxBuf */
 /**
  *
  * @brief Delete the DL buffer from the list
@@ -2449,32 +2324,30 @@ KwSn             sn;
  *  @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlDelTxBuf 
+Void rlcUtlDelTxBuf 
 (
 CmLListCp        *txBufLst,
-KwTx            *txBuf,
+RlcTx            *txBuf,
 RlcCb              *gCb                              
 )
 #else
-PUBLIC Void kwUtlDelTxBuf(txBufLst, txBuf, gCb)
+Void rlcUtlDelTxBuf(txBufLst, txBuf, gCb)
 CmLListCp        *txBufLst;
-KwTx             *txBuf;
+RlcTx             *txBuf;
 RlcCb             *gCb;                              
 #endif
 {
-   U32                 hashKey; 
+   uint32_t            hashKey; 
    CmLListCp           *txBufLstCp;
 
-   TRC3(kwUtlDelTxBuf)
-
-   hashKey = (txBuf->sn % KW_TX_BUF_BIN_SIZE ); 
+   hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE ); 
  
    txBufLstCp = &txBufLst[hashKey];
    //printf("D-sn(%d)\n", txBuf->hdr.sn);
    cmLListDelFrm(txBufLstCp, &txBuf->lnk);
-   RLC_FREE_WC(gCb, txBuf, sizeof(KwTx));
-   RETVOID;
-} /* kwUtlDelTxBuf */
+   RLC_FREE_WC(gCb, txBuf, sizeof(RlcTx));
+   return;
+} /* rlcUtlDelTxBuf */
 
 /**
  *
@@ -2491,31 +2364,29 @@ RlcCb             *gCb;
  *  @return  Void
  */
 #ifdef ANSI
-PUBLIC Void kwUtlRemovTxBuf 
+Void rlcUtlRemovTxBuf 
 (
 CmLListCp        *txBufLst,
-KwTx            *txBuf,
+RlcTx            *txBuf,
 RlcCb              *gCb                              
 )
 #else
-PUBLIC Void kwUtlRemovTxBuf(txBufLst, txBuf, gCb)
+Void rlcUtlRemovTxBuf(txBufLst, txBuf, gCb)
 CmLListCp        *txBufLst;
-KwTx             *txBuf;
+RlcTx             *txBuf;
 RlcCb             *gCb;                              
 #endif
 {
-   U32                 hashKey; 
+   uint32_t            hashKey; 
    CmLListCp           *txBufLstCp;
 
-   TRC3(kwUtlRemovTxBuf)
-
-   hashKey = (txBuf->sn % KW_TX_BUF_BIN_SIZE ); 
+   hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE ); 
  
    txBufLstCp = &txBufLst[hashKey];
    //printf("D-sn(%d)\n", txBuf->hdr.sn);
    cmLListDelFrm(txBufLstCp, &txBuf->lnk);
-   RETVOID;
-} /* kwUtlRemovTxBuf */
+   return;
+} /* rlcUtlRemovTxBuf */