X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_utl_dl.c;h=1146d201a97e9749de0d2f9fa0a15365b5623ac9;hb=refs%2Fchanges%2F91%2F5391%2F11;hp=1d1c3fb193bc1716dc272cc1033c39d72f67729e;hpb=0a26c487f1b6bbb5217e47b15fa8273b2e749283;p=o-du%2Fl2.git

diff --git a/src/5gnrrlc/kw_utl_dl.c b/src/5gnrrlc/kw_utl_dl.c
index 1d1c3fb19..1146d201a 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
 
-                  --rlcUtlSndToLi
-                  --rlcUtlRcvFrmLi
+                  --rlcUtlSendToMac
+                  --rlcUtlRcvFrmMac
                   --rlcUtlEmptySduQ
-                  --rlcUtlSndDStaRsp
-                  --rlcUtlSndDatInd 
+                  --rlcUtlSendDedLcBoStatus
+                  --rlcUtlSendUlDataToDu 
                   --kwUtlShutDown
 
      File:     kw_utl_dl.c
@@ -71,25 +71,31 @@ 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 "du_app_rlc_inf.h"
+#include "rlc_lwr_inf_api.h"
+#include "rlc_upr_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 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 rlcUtlDlBatchProcHqStaInd 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(RlcGenSts));
-   cmMemset((U8*)&ulInst->genSts,0,sizeof(RlcGenSts));
+   memset(&gRlcStats, 0, sizeof(RLCStats));
+   memset(&dlInst->genSts,0,sizeof(RlcGenSts));
+   memset(&ulInst->genSts,0,sizeof(RlcGenSts));
 }
 
 #ifndef ALIGN_64BIT
@@ -107,15 +113,15 @@ Void PrintRLCStats(Void)
                      ulInst->genSts.pdusRecv,
                      ulInst->genSts.unexpPdusRecv,
                      ulInst->genSts.errorPdusRecv);
-   RLOG4(L_ALWAYS,"RLC Stats: AMDL: "
+   RLOG4(L_ALWAYS,"RLC Stats: RLC_AMDL: "
                      "StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
                      gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, 
                      gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
-   RLOG3(L_ALWAYS,"RLC Stats: AMDL: "
+   RLOG3(L_ALWAYS,"RLC Stats: RLC_AMDL: "
                      "DRB:%lu MaxRetx:%lu RetransPdus:%lu", 
                      gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx, 
                      gRlcStats.amRlcStats.numDLRetransPdus);
-   RLOG4(L_ALWAYS,"RLC Stats: AMUL: "
+   RLOG4(L_ALWAYS,"RLC Stats: RLC_AMUL: "
                      " PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ", 
                      gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires, 
                      gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
@@ -130,8 +136,8 @@ Void PrintRLCStats(Void)
                      ulInst->genSts.unexpPdusRecv,
                      ulInst->genSts.errorPdusRecv);
    RTLIN_DUMP_DEBUG("RLC Stats:"
-                    "AMDL: StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu DRB:%lu MaxRetx:%lu RetransPdus:%lu \n"
-                    "AMUL: PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu \n", 
+                    "RLC_AMDL: StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu DRB:%lu MaxRetx:%lu RetransPdus:%lu \n"
+                    "RLC_AMUL: PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu \n", 
                      gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, gRlcStats.amRlcStats.numDLBytesUnused, 
                      gRlcStats.amRlcStats.numDLPollTimerExpiresSrb, gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx, 
                      gRlcStats.amRlcStats.numDLRetransPdus, gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires, 
@@ -153,21 +159,21 @@ Void PrintRLCStats(Void)
                      ulInst->genSts.pdusRecv,
                      ulInst->genSts.unexpPdusRecv,
                      ulInst->genSts.errorPdusRecv);
-   RLOG4(L_ALWAYS,"RLC Stats: AMDL: "
+   RLOG4(L_ALWAYS,"RLC Stats: RLC_AMDL: "
                      "StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
                      gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, 
                      gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
-   RLOG3(L_ALWAYS,"RLC Stats: AMDL: "
+   RLOG3(L_ALWAYS,"RLC Stats: RLC_AMDL: "
                      "DRB:%lu MaxRetx:%lu RetransPdus:%lu", 
                      gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx, 
                      gRlcStats.amRlcStats.numDLRetransPdus);
-   RLOG4(L_ALWAYS,"RLC Stats: AMUL: "
+   RLOG4(L_ALWAYS,"RLC Stats: RLC_AMUL: "
                      " PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ", 
                      gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires, 
                      gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
  /*  RTLIN_DUMP_DEBUG("AM RLC Stats:"
-                    "AMDL: SDUs Tx :(%u) SDU Bytes Tx :(%u) SDUs Retx :(%u) MaxRetx:(%u) WindowStalls: (%u) \n"
-                    "AMUL: DropOutWinRx :(%u) SDUs Rx :(%u) SDU Bytes Rx :(%u) SDUNack Rx :(%u) Duplicate Pdu Rx :(%u) \n",
+                    "RLC_AMDL: SDUs Tx :(%u) SDU Bytes Tx :(%u) SDUs Retx :(%u) MaxRetx:(%u) WindowStalls: (%u) \n"
+                    "RLC_AMUL: DropOutWinRx :(%u) SDUs Rx :(%u) SDU Bytes Rx :(%u) SDUNack Rx :(%u) Duplicate Pdu Rx :(%u) \n",
                      gRlcStats.amRlcStats.numRlcAmCellSduTx, gRlcStats.amRlcStats.numRlcAmCellSduBytesTx,
                      gRlcStats.amRlcStats.numRlcAmCellRetxPdu, gRlcStats.amRlcStats.numRlcAmMaxRetx, gRlcStats.amRlcStats.numRlcAmCellWinStall,
                      gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx, gRlcStats.amRlcStats.numRlcAmCellSduRx,
@@ -182,10 +188,10 @@ Void PrintRLCStats(Void)
                      ulInst->genSts.pdusRecv,
                      ulInst->genSts.unexpPdusRecv,
                      ulInst->genSts.errorPdusRecv);
-   RTLIN_DUMP_DEBUG("AMDL: StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u DRB:%u MaxRetx:%u RetransPdus:%u \n"
+   RTLIN_DUMP_DEBUG("RLC_AMDL: StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u DRB:%u MaxRetx:%u RetransPdus:%u \n"
                     "      SDUs Tx :(%u) SDU Bytes Tx :(%u) SDUs Retx :(%u) WindowStalls: (%u) \n"
 
-                    "AMUL: PdusDiscarded:%u ReOrdTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u \n"
+                    "RLC_AMUL: PdusDiscarded:%u ReOrdTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u \n"
                     "      DropOutWinRx :(%u) SDUs Rx :(%u) SDU Bytes Rx :(%u) SDUNack Rx :(%u) Duplicate Pdu Rx:(%u) \n", 
                      gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, gRlcStats.amRlcStats.numDLBytesUnused, 
                      gRlcStats.amRlcStats.numDLPollTimerExpiresSrb, gRlcStats.amRlcStats.numDLPollTimerExpiresDrb,
@@ -209,58 +215,52 @@ Void PrintRLCStats(Void)
  *    This function stores DL PDU info for all logical channels
  *    of per UE grant per TTI and sends to MAC
  *
- *    Function : RlcLiRguDDatReq 
+ *    Function : rlcSendDedLcDlData 
  *
  * @params[in] 
  * @return ROK     - success
  *         RFAILED - failure
  *
  * ****************************************************************/
-#ifdef ANSI
-S16 RlcLiRguDDatReq
-(
-Pst               *post,
-SpId              spId,
-RguDDatReqInfo    *datReqInfo
-)
-#else
-S16 RlcLiRguDDatReq(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(RlcLiRguDDatReq)
+   RlcData          *dlData;    /* DL data to be sent to MAC */
+   RlcDlRrcMsgRsp   *dlRrcMsgRsp;/* DL Data Msg Rsp sent to DU */
+   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));
-#if (ERRCLASS & ERRCLS_ADD_RES)
-   if ( datReqInfo == NULLP )
+   dlRrcMsgRsp = NULLP;
+   RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+                       dlData, sizeof(RlcData));
+   if ( dlData == NULLP )
    {
-      RLOG0(L_FATAL,"Memory allocation failed");
+      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 */
 
    for(ueIdx = 0; ueIdx < datReqInfo->nmbOfUeGrantPerTti; ueIdx++)
    {
       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 */
+
+      /* 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++)
@@ -273,22 +273,88 @@ RguDDatReqInfo    *datReqInfo;
             {
                dlData->pduInfo[dlData->numPdu].commCh = FALSE;
                dlData->pduInfo[dlData->numPdu].lcId = datPerLch.lcId;
-               dlData->pduInfo[dlData->numPdu].pduBuf = datPerLch.pdu.mBuf[pduIdx];
+
+               /* 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);
+
+      RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+                     dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
+      if( dlRrcMsgRsp == NULLP )
+      {
+         DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed for dlRrcMsgRsp");
+         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));
+         RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
+             datReqInfo, sizeof(RguDDatReqInfo));
+         return RFAILED;
+      }
+
+      dlRrcMsgRsp->cellId = dlData->cellId;
+      dlRrcMsgRsp->crnti = dlData->rnti;
+
+      /* 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));
+	 /* Update DL RRC MSG Rsp State */
+         dlRrcMsgRsp->state = TRANSMISSION_FAILED;
+      }
+      else
+         dlRrcMsgRsp->state = TRANSMISSION_COMPLETE;
+
+      /* Send Dl RRC Msg Rsp to DU APP */
+      FILL_PST_RLC_TO_DUAPP(pst, RLC_DL_INST, EVENT_DL_RRC_MSG_RSP_TO_DU);
+      if(rlcSendDlRrcMsgRspToDu(&pst, dlRrcMsgRsp) != ROK)
+      {
+         RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
+      }
    } /* 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));
    
    return ROK;
-}/* End of RlcLiRguDDatReq */
+}/* End of rlcSendDedLcDlData */
 
 /**
  *
@@ -310,55 +376,41 @@ RguDDatReqInfo    *datReqInfo;
  *      -# RFAILED
  *
  */
-#ifdef ANSI
-S16 rlcUtlSndToLi
-(
-RlcCb            *gCb,
-SuId            suId,
-KwDStaIndInfo   *staIndInfo
-)
-#else
-S16 rlcUtlSndToLi(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 */
    RlcDatReq         datReq;        /* PDUs Information */
    RguDDatReqInfo   *datReqInfo;   /* Data Request Information */
-   RlcRguSapCb       *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(rlcUtlSndToLi)
-
+   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");
+         DU_LOG("\nRLC: rlcUtlSendToMac: Memory allocation failed");
          return RFAILED;
       }
 #endif /* ERRCLASS & ERRCLS_ADD_RES */
@@ -366,18 +418,18 @@ KwDStaIndInfo   *staIndInfo;
    {
       staInd = &staIndInfo->staInd[idx];
       /* Fetch Ue control block */
-      if(ROK != rlcDbmFetchDlUeCb(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 RlcDatReq */
       /* kw004.201 Used SSI function to initialize the variable */
-      cmMemset( (U8 *)&datReq, 0, sizeof(RlcDatReq) ); 
+      memset(&datReq, 0, sizeof(RlcDatReq) ); 
       totNumPdu = 0;
       for (numTb = 0; numTb < staInd->nmbOfTbs; numTb++)
       {
@@ -412,11 +464,11 @@ KwDStaIndInfo   *staIndInfo;
                datReq.totMacGrant = grantPerLch[staIndTb->lchStaInd[count].lcId];
 #endif
                rlcUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
-               if ( CM_LTE_MODE_UM == rbCb->mode )
+               if ( RLC_MODE_UM == rbCb->mode )
                {
                   rlcUmmProcessSdus(gCb,rbCb,&datReq);
                }
-               else if ( CM_LTE_MODE_AM == rbCb->mode )
+               else if ( RLC_MODE_AM == rbCb->mode )
                {
                   rlcAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
                }
@@ -428,20 +480,18 @@ 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 (RLC_AM_IS_POLL_BIT_SET(AMDL) && 
-                   (AMDL.sduQ.count > 1))
+               if (RLC_AM_IS_POLL_BIT_SET(RLC_AMDL) && 
+                   (RLC_AMDL.sduQ.count > 1))
                { 
                   /* Poll bit is set indicate to MAC*/
                   datReqTb->lchData[count].setMaxUlPrio = TRUE;
@@ -460,7 +510,7 @@ KwDStaIndInfo   *staIndInfo;
 
 #ifdef L2_OPTMZ
                /* Set if Bearer is UM */
-               if ( CM_LTE_MODE_UM == rbCb->mode )
+               if ( RLC_MODE_UM == rbCb->mode )
                {
                   datReqTb->lchData[count].freeBuff = TRUE;
                }
@@ -495,7 +545,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(RlcDatReq) ); 
+               memset(&datReq, 0, sizeof(RlcDatReq) ); 
             }
          }
 #ifdef LTE_L2_MEAS
@@ -528,7 +578,7 @@ KwDStaIndInfo   *staIndInfo;
          else
          {
             cmHashListInsert(&(rlcCb.rlcL2Cb.tbHlCp),(PTR)tbSnMap,
-                  (U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
+                  (uint8_t *) &(tbSnMap->tbId), (uint16_t)sizeof(tbSnMap->tbId));
             rlcCb.rlcL2Cb.curTbSnMap = NULLP;
          }
 #endif /* LTE_L2_MEAS */
@@ -539,16 +589,9 @@ 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 */
-      rlcLmmSendTrc(gCb,EVTRGUDDATREQ, NULLP);
-   }
 
    rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
-//Debug
-   RlcLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo); 
+   rlcSendDedLcDlData(&rguSap->pst,rguSap->spId,datReqInfo); 
    return ROK;
 }
 
@@ -572,58 +615,38 @@ KwDStaIndInfo   *staIndInfo;
  *      -# ROK 
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rlcUtlSndDStaRsp
-(
-RlcCb       *gCb,
-RlcDlRbCb   *rbCb,     
-S32        bo,        
-S32        estHdrSz,  
-Bool       staPduPrsnt,
-U32        staPduBo
-)
-#else
-S16 rlcUtlSndDStaRsp(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 */
-   RlcRguSapCb       *rguSap;       /* MAC SAP Information */
-   TRC3(rlcUtlSndDStaRsp)
+   Pst           pst;           /* Post info */
+   RlcBoStatus   *boStatus;      /* Buffer occupancy status information */
+
 #ifndef TENB_ACC
-   if ((rbCb->lastRprtdBoToMac > (U32)8000) && (rbCb->boUnRprtdCnt < (U32)5) 
-       && (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
+   if ((rbCb->lastRprtdBoToMac > (uint32_t)8000) && (rbCb->boUnRprtdCnt < (uint32_t)5) 
+       && (!staPduPrsnt) && ((RLC_MODE_AM == rbCb->mode ) && (RLC_AMDL.nxtRetx == NULLP)))
    {
       rbCb->boUnRprtdCnt++;
       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 */
-      rlcLmmSendTrc(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);
-
 
    return ROK;
 }
@@ -646,7 +669,6 @@ U32        staPduBo;
  */
 /* kw005.201 added support for L2 Measurement */
 #ifdef LTE_L2_MEAS_RLC
-#ifdef ANSI
 Void rlcUtlEmptySduQ
 (
 RlcCb        *gCb, 
@@ -654,23 +676,11 @@ RlcDlRbCb    *rbCb,
 CmLListCp   *sduQ 
 )
 #else
-Void rlcUtlEmptySduQ(gCb,rbCb, sduQ)
-RlcCb        *gCb;
-RlcDlRbCb    *rbCb;
-CmLListCp   *sduQ;
-#endif
-#else
-#ifdef ANSI
 Void rlcUtlEmptySduQ
 (
 RlcCb        *gCb,
 CmLListCp   *sduQ 
 )
-#else
-Void rlcUtlEmptySduQ(gCb,sduQ)
-RlcCb        *gCb;
-CmLListCp   *sduQ; 
-#endif
 #endif
 {
 #ifdef LTE_L2_MEAS_RLC
@@ -678,7 +688,6 @@ CmLListCp   *sduQ;
    CmLList     *firstSduSnMap;         /* First Node in SDU SnMap Queue */
    RlcSduSnMap  *sduSnMap;              /* SDU Sn Map */
 
-   TRC2(rlcUtlEmptySduQ)
    sduSnMapQ = NULLP;
    firstSduSnMap = NULLP;
    sduSnMap = NULLP;
@@ -702,7 +711,7 @@ CmLListCp   *sduQ;
       }
    }
 #endif
-   RETVOID;
+   return;
 }
 
 /**
@@ -722,24 +731,8 @@ CmLListCp   *sduQ;
  *
  * @return  void 
  */
-#ifdef ANSI
-Void rlcUtlCalcLiForSdu
-(
-RlcCb     *gCb,
-U16      numLi, 
-MsgLen   msgLen,
-S16      *pduSz 
-)
-#else
-Void rlcUtlCalcLiForSdu(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(rlcUtlCalcLiForSdu)
-
    if ( (*pduSz > msgLen)  && (msgLen < RLC_2K_BYTE))
    {
       if(0 == (numLi & RLC_BIT0)) /* check if number of LIs are odd or even */
@@ -753,7 +746,7 @@ S16      *pduSz;
          *pduSz -= 1;
       }
    }
-   RETVOID;
+   return;
 }
 
 /**
@@ -773,29 +766,18 @@ S16      *pduSz;
  *
  * @return  void 
  */
-#ifdef ANSI
-Void rlcDlUtlSetReestInProgressForRB
-(
-RlcCb     *gCb,
-RlcDlRbCb *rbCb
-)
-#else
-Void rlcDlUtlSetReestInProgressForRB(gCb,rbCb)
-RlcCb     *gCb;
-RlcDlRbCb *rbCb;
-#endif 
+Void rlcDlUtlSetReestInProgressForRB(RlcCb *gCb,RlcDlRbCb *rbCb)
 {
-   TRC2(rlcDlUtlSetReestInProgressForRB)
       
    rbCb->reestInProgress = TRUE;
    
-   if(rbCb->mode == CM_LTE_MODE_AM )
+   if(rbCb->mode == RLC_MODE_AM )
    {
       rbCb->m.amDl.estHdrSz = 0;
 
-      if(rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
+      if(rlcChkTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR))
       {
-         rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+         rlcStopTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
       }
    }
    else
@@ -803,9 +785,9 @@ RlcDlRbCb *rbCb;
       rbCb->m.umDl.estHdrSz= 0;
    }
 
-   rlcUtlSndDStaRsp(gCb, rbCb, 0, 0, FALSE,0);
+   rlcUtlSendDedLcBoStatus(gCb, rbCb, 0, 0, FALSE,0);
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -819,18 +801,8 @@ RlcDlRbCb *rbCb;
  *          TRUE  : Re-establishment is in progress
  *          FALSE : Re-establishment is not in progress
  */
-#ifdef ANSI
-Bool rlcDlUtlIsReestInProgress
-(
-RlcDlRbCb *rbCb
-)
-#else
-Bool rlcDlUtlIsReestInProgress(rbCb)
-RlcDlRbCb *rbCb;
-#endif 
+bool rlcDlUtlIsReestInProgress(RlcDlRbCb *rbCb)
 {
-   TRC2(rlcDlUtlSetReestInProgressForRB)
-
    return (rbCb->reestInProgress);
 }
 
@@ -843,17 +815,8 @@ RlcDlRbCb *rbCb;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcDlUtlResetReestInProgress
-(
-RlcDlRbCb *rbCb
-)
-#else
-Void rlcDlUtlResetReestInProgress(rbCb)
-RlcDlRbCb *rbCb;
-#endif 
+Void rlcDlUtlResetReestInProgress(RlcDlRbCb *rbCb)
 {
-   TRC2(rlcDlUtlSetReestInProgressForRB)
 
    rbCb->reestInProgress = FALSE;
 }
@@ -871,22 +834,10 @@ RlcDlRbCb *rbCb;
  *
  * @return  void 
  */
-#ifdef ANSI
-Void rlcDlUtlSetReestInProgressForAllRBs
-(
-RlcCb     *gCb,
-RlcDlUeCb *ueCb
-)
-#else
-Void rlcDlUtlSetReestInProgressForAllRBs(gCb,ueCb)
-RlcCb     *gCb;
-RlcDlUeCb *ueCb;
-#endif 
+Void rlcDlUtlSetReestInProgressForAllRBs(RlcCb *gCb,RlcDlUeCb *ueCb)
 {
-   U32        rbIdx;
+   uint32_t        rbIdx;
    
-   TRC2(rlcDlUtlSetReestInProgressForAllRBs)
-
    for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
    {
       if(ueCb->srbCb[rbIdx] != NULLP)
@@ -898,9 +849,9 @@ RlcDlUeCb *ueCb;
          else
          {
             /* For SRB we just need to stop the poll re-transmit timer */
-            if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR))
+            if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], EVENT_RLC_AMDL_POLL_RETX_TMR))
             {
-               rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR);
+               rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], EVENT_RLC_AMDL_POLL_RETX_TMR);
             }
          }
       }
@@ -914,7 +865,7 @@ RlcDlUeCb *ueCb;
       }
    }
       
-   RETVOID;
+   return;
 }
 
 /**
@@ -926,18 +877,10 @@ RlcDlUeCb *ueCb;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlIncrementKwuStsSduTx
-(
-RlcKwuSapCb *rlckwuSap 
-)
-#else
-Void rlcUtlIncrementKwuStsSduTx(rlckwuSap)
-RlcKwuSapCb *rlckwuSap;
-#endif
+void rlcUtlIncrementKwuStsSduTx(RlcKwuSapCb *rlckwuSap)
 {
    rlckwuSap->sts.sduTx++;
-   RETVOID;
+   return;
 }
 
 /**
@@ -950,23 +893,13 @@ RlcKwuSapCb *rlckwuSap;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlIncrementGenStsBytesAndPdusSent
-(
-RlcGenSts   *genSts,
-Buffer     *pdu   
-)
-#else
-Void rlcUtlIncrementGenStsBytesAndPdusSent(genSts, pdu)
-RlcGenSts   *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;
 }
 
 /**
@@ -979,24 +912,14 @@ Buffer     *pdu;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlInitToBeFreed
-(
-RlcCb                *gCb,
-RlcDlDataToBeFreed   *toBeFreed
-)
-#else
-Void rlcUtlInitToBeFreed(gCb, toBeFreed)
-RlcCb                *gCb;
-RlcDlDataToBeFreed   *toBeFreed;
-#endif
+Void rlcUtlInitToBeFreed(RlcCb *gCb,RlcDlDataToBeFreed *toBeFreed)
 {
    cmLListInit(&(toBeFreed->sduLst));
    cmLListInit(&(toBeFreed->rbLst));
    cmLListInit(&(toBeFreed->reTxLst));
    cmLListInit(&(toBeFreed->txLst));
    
-   RETVOID;
+   return;
 }
 
 /**
@@ -1007,15 +930,7 @@ RlcDlDataToBeFreed   *toBeFreed;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlInitializeSelfPst
-(
-RlcCb *gCb  
-)
-#else
-Void rlcUtlInitializeSelfPst(gCb)
-RlcCb *gCb;
-#endif
+Void rlcUtlInitializeSelfPst(RlcCb *gCb)
 {
    Pst *selfPst = &gCb->u.dlCb->selfPst;
    
@@ -1038,24 +953,16 @@ RlcCb *gCb;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlRaiseDlCleanupEvent
-(
-RlcCb *gCb  
-)
-#else
-Void rlcUtlRaiseDlCleanupEvent(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 +974,10 @@ RlcCb *gCb;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlAddSduToBeFreedQueue
-(
-RlcCb    *gCb,
-RlcSdu   *sdu
-)
-#else
-Void rlcUtlAddSduToBeFreedQueue(gCb, sdu)
-RlcCb    *gCb;
-RlcSdu   *sdu;
-#endif
+void rlcUtlAddSduToBeFreedQueue(RlcCb *gCb, RlcSdu *sdu)
 {
    cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.sduLst), &(sdu->lstEnt));
-   RETVOID;
+   return;
 }
 
 /**
@@ -1092,20 +989,10 @@ RlcSdu   *sdu;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlAddReTxPduToBeFreedQueue
-(
-RlcCb     *gCb,
-RlcRetx   *retx
-)
-#else
-Void rlcUtlAddReTxPduToBeFreedQueue(gCb, retx)
-RlcCb     *gCb;
-RlcRetx   *retx;
-#endif
+Void rlcUtlAddReTxPduToBeFreedQueue(RlcCb *gCb,RlcRetx *retx)
 {
    cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.reTxLst), &(retx->lstEnt));
-   RETVOID;
+   return;
 }
 
 /**
@@ -1117,21 +1004,11 @@ RlcRetx   *retx;
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlAddTxPduToBeFreedQueue
-(
-RlcCb   *gCb,
-RlcTx   *pdu
-)
-#else
-Void rlcUtlAddTxPduToBeFreedQueue(gCb, pdu)
-RlcCb   *gCb;
-RlcTx   *pdu;
-#endif
+Void rlcUtlAddTxPduToBeFreedQueue(RlcCb   *gCb,RlcTx   *pdu)
 {
    pdu->rlsLnk.node = (PTR)pdu;
    cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.txLst), &(pdu->rlsLnk));
-   RETVOID;
+   return;
 }
 
 /*
@@ -1150,51 +1027,36 @@ RlcTx   *pdu;
  *     - TRUE if more data to be freed
  *     - FALSE if all the data has been freed
  */
-#ifdef ANSI
-PRIVATE Bool rlcUtlFreeDlAmRbMemory
-(
-RlcCb       *gCb,
-RlcDlRbCb   *rbCb,
-U32        *toBeFreed
-)
-#else
-PRIVATE Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
-RlcCb       *gCb;
-RlcDlRbCb   *rbCb;
-U32        *toBeFreed
-#endif
+static Bool rlcUtlFreeDlAmRbMemory(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t *toBeFreed)
 {
    RlcRetx   *retx;   /* retransmission buffer */
    RlcSn     mTxNext;    /* send state variable */
    RlcTx      *txBuf;
 
-   TRC2(rlcUtlFreeDlAmRbMemory)
-
-
-   MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
+   MODAMT(RLC_AMDL.txNext, mTxNext, RLC_AMDL.txNextAck,RLC_AMDL.snModMask);
 
    /* TODO : to be checked changed from <= to < */
    while ((0 < mTxNext) && *toBeFreed)
    {
-      txBuf =  rlcUtlGetTxBuf(AMDL.txBufLst, AMDL.txNextAck);
+      txBuf =  rlcUtlGetTxBuf(RLC_AMDL.txBufLst, RLC_AMDL.txNextAck);
       if (txBuf && txBuf->pduLst.first)
       {
          while(txBuf->pduLst.first)
 	 {
 	    RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(txBuf->pduLst.first->node);
-	    RLC_FREE_BUF(pduInfo->pdu);
+	    ODU_PUT_MSG_BUF(pduInfo->pdu);
 	    /* Delete node from the txBuf Pdu lst */
 	    cmLListDelFrm(&txBuf->pduLst, txBuf->pduLst.first);
-	    RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
+	    RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo));
 	 }
-         rlcUtlDelTxBuf(AMDL.txBufLst, txBuf, gCb);
+         rlcUtlDelTxBuf(RLC_AMDL.txBufLst, txBuf, gCb);
          if(gCb->u.dlCb->shutdownReceived == 0)
          {   
             (*toBeFreed)--;
 	 }
       }
-      AMDL.txNextAck = (AMDL.txNextAck + 1) & AMDL.snModMask;
-      MODAMT(AMDL.txNext, mTxNext, AMDL.txNextAck,AMDL.snModMask);
+      RLC_AMDL.txNextAck = (RLC_AMDL.txNextAck + 1) & RLC_AMDL.snModMask;
+      MODAMT(RLC_AMDL.txNext, mTxNext, RLC_AMDL.txNextAck,RLC_AMDL.snModMask);
    }
    if(*toBeFreed == 0)
    {
@@ -1202,19 +1064,19 @@ U32        *toBeFreed
    }
    
 #ifndef LTE_TDD 
-      RLC_FREE(gCb,AMDL.txBufLst, (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
+      RLC_FREE(gCb,RLC_AMDL.txBufLst, (RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
 #endif
 
-   RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+   RLC_LLIST_FIRST_RETX(RLC_AMDL.retxLst, retx);
    while (retx && (*toBeFreed)) /* Till to be freed becomes 0 */
    {
 
-      RLC_FREE_BUF(retx->seg);
+      ODU_PUT_MSG_BUF(retx->seg);
 
-      cmLListDelFrm(&AMDL.retxLst, &retx->lstEnt);
-      RLC_FREE_WC(gCb, retx, sizeof(RlcRetx));
+      cmLListDelFrm(&RLC_AMDL.retxLst, &retx->lstEnt);
+      RLC_FREE(gCb, retx, sizeof(RlcRetx));
 
-      RLC_LLIST_FIRST_RETX(AMDL.retxLst, retx);
+      RLC_LLIST_FIRST_RETX(RLC_AMDL.retxLst, retx);
       if(gCb->u.dlCb->shutdownReceived == 0)
       {
       (*toBeFreed)--;
@@ -1222,18 +1084,18 @@ U32        *toBeFreed
 
    }
 
-   AMDL.nxtRetx = NULLP;
+   RLC_AMDL.nxtRetx = NULLP;
 
    /* clean up if there is info about STATUS PDU to be sent */
-   if(AMDL.pStaPdu)
+   if(RLC_AMDL.pStaPdu)
    {
       Pst *udxPst;
       udxPst = &gCb->u.dlCb->udxDlSap->pst;
       RLC_FREE_SHRABL_BUF_WC(udxPst->region,
 			    udxPst->pool,
-			    AMDL.pStaPdu, 
+			    RLC_AMDL.pStaPdu, 
 			    sizeof(RlcUdxDlStaPdu));
-      AMDL.pStaPdu = NULLP;
+      RLC_AMDL.pStaPdu = NULLP;
    }
 
    if(*toBeFreed == 0)
@@ -1245,7 +1107,7 @@ U32        *toBeFreed
       (*toBeFreed)--;
    }
    
-   return (FALSE);;
+   return (FALSE);
 } 
 
 /**
@@ -1256,23 +1118,15 @@ U32        *toBeFreed
  *
  * @return  Void
  */
-#ifdef ANSI
-Void rlcUtlFreeDlMemory
-(
-RlcCb *gCb  
-)
-#else
-Void rlcUtlFreeDlMemory(gCb)
-RlcCb *gCb;
-#endif
+Void rlcUtlFreeDlMemory(RlcCb *gCb)
 {
-   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;
@@ -1316,8 +1170,8 @@ RlcCb *gCb;
    {
       RlcRetx* seg = (RlcRetx *)(lst->first->node);
       cmLListDelFrm(lst, lst->first);
-      RLC_FREE_BUF_WC(seg->seg);
-      RLC_FREE_WC(gCb,seg, sizeof(RlcRetx));
+      ODU_PUT_MSG_BUF(seg->seg);
+      RLC_FREE(gCb,seg, sizeof(RlcRetx));
       toBeFreed--;
    }   
 
@@ -1336,10 +1190,10 @@ RlcCb *gCb;
          RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(pdu->pduLst.first->node);
          
 	 cmLListDelFrm(&pdu->pduLst, pdu->pduLst.first);
-	 RLC_FREE_BUF_WC(pduInfo->pdu);
-	 RLC_FREE_WC(gCb, pduInfo, sizeof(RlcDlPduInfo));
+	 ODU_PUT_MSG_BUF(pduInfo->pdu);
+	 RLC_FREE(gCb, pduInfo, sizeof(RlcDlPduInfo));
       }
-      RLC_FREE_WC(gCb,pdu, sizeof(RlcTx));
+      RLC_FREE(gCb,pdu, sizeof(RlcTx));
       toBeFreed--;
    }
 
@@ -1369,7 +1223,7 @@ RlcCb *gCb;
       if(!moreToBeFreed)
       {
          cmLListDelFrm(lst, lst->first);
-         RLC_FREE_WC(gCb, rbCb, sizeof(RlcDlRbCb));
+         RLC_FREE(gCb, rbCb, sizeof(RlcDlRbCb));
       }
    } 
 
@@ -1378,7 +1232,7 @@ RlcCb *gCb;
       rlcUtlRaiseDlCleanupEvent(gCb);
    }
 
-   RETVOID;
+   return;
 }
 
 
@@ -1396,12 +1250,12 @@ RlcCb *gCb;
  */
 S16 rlcUtlL2MeasDlInit(RlcCb *gCb)
 {
-   U16   cntr;
+   uint16_t   cntr;
 
    gCb->u.dlCb->rlcL2Cb.rlcNumMeas=0;
    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
    {
-      cmMemset((U8 *)&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
+      memset(&(gCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
    }
    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;
@@ -1425,32 +1279,22 @@ S16 rlcUtlL2MeasDlInit(RlcCb *gCb)
  *  @return  Void
  *
  */
-#ifdef ANSI
 Void rlcUtlUpdateBurstSdus
 (
 RlcCb            *gCb,
 RlcDlRbCb        *rbCb,
 RlcContSduLst    *contSduLst,
-S32             dataVol,
-U32             schPduSz
+S32              dataVol,
+uint32_t         schPduSz
 )
-#else
-Void  rlcUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
-RlcCb            *gCb;
-RlcDlRbCb        *rbCb;
-RlcContSduLst    *contSduLst;
-S32             dataVol;
-U32             schPduSz;
-#endif
 {
 
-   RlcL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
-   RlcL2MeasTb     *l2MeasTb = NULLP;
-   U8              idx;
-   U8              currTbIdx;
-   VOLATILE U32     startTime = 0;
+   RlcL2MeasDlIpTh   *l2MeasDlIpThruput = NULLP;
+   RlcL2MeasTb       *l2MeasTb = NULLP;
+   uint8_t           idx;
+   uint8_t           currTbIdx;
+   volatile uint32_t startTime = 0;
    RlcContSduLst   *dstContSduLst;
-   TRC2(rlcUtlUpdateBurstSdus)
 
 
    /*starting Task*/
@@ -1489,7 +1333,7 @@ U32             schPduSz;
          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 */
@@ -1508,7 +1352,7 @@ U32             schPduSz;
 
    /*stopping Task*/
    SStopTask(startTime, PID_RLC_DLIP_TPT_BURSTCALC);
-   RETVOID;
+   return;
 }
 /**
  * @brief
@@ -1524,24 +1368,14 @@ U32             schPduSz;
  *
  *  @return  Void
  */
-#ifdef ANSI
-Void rlcUtlUpdateContainedSduLst
-(
-U8            sduIdx,
-RlcContSduLst  *contSduLst
-)
-#else
-Void rlcUtlUpdateContainedSduLst(sduIdx, contSduLst)
-U8            sduIdx;
-RlcContSduLst  *contSduLst;
-#endif
+Void rlcUtlUpdateContainedSduLst(uint8_t sduIdx,RlcContSduLst *contSduLst)
 {
    if (contSduLst->numSdus < RLC_L2MEAS_MAX_OUTSTNGSDU)
    {
     contSduLst->sduIdx[contSduLst->numSdus] = sduIdx;
     contSduLst->numSdus++;
    }
-    RETVOID;
+    return;
 }
 
 /**
@@ -1562,23 +1396,14 @@ RlcContSduLst  *contSduLst;
  *
  *  @return  Void
  */
-#ifdef ANSI
 Void rlcUtlUpdateOutStandingSduLst
 (
 RlcL2MeasDlIpTh   *dlIpThPut, 
-U8               sduIdx, 
-MsgLen           sduLen, 
-U32              sduId,
-Bool             newIdx
+uint8_t           sduIdx, 
+MsgLen            sduLen, 
+uint32_t          sduId,
+Bool              newIdx
 )
-#else
-Void rlcUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
-RlcL2MeasDlIpTh   *dlIpThPut;
-U8               sduIdx;
-MsgLen           sduLen; 
-U32              sduId;
-Bool             newIdx;
-#endif
 {
    if (sduIdx < RLC_L2MEAS_MAX_OUTSTNGSDU)
    {
@@ -1590,25 +1415,13 @@ Bool             newIdx;
    dlIpThPut->outStngSduArr[sduIdx].sduId = sduId;
    dlIpThPut->outStngSduArr[sduIdx].sduLen = sduLen;
    }
-   RETVOID;
+   return;
 }
-#ifdef ANSI
-RlcL2MeasTb * rlcUtlGetCurMeasTb
-(
-RlcCb     *gCb,
-RlcDlRbCb *rbCb
-)
-#else
-RlcL2MeasTb * rlcUtlGetCurMeasTb(gCb, rbCb)
-RlcCb     *gCb;
-RlcDlRbCb *rbCb;
-#endif
+RlcL2MeasTb * rlcUtlGetCurMeasTb(RlcCb *gCb,RlcDlRbCb *rbCb)
 {
    RlcL2MeasTb  *curL2MeasTb;
-   U16         idx;
+   uint16_t         idx;
 
-   TRC3(rlcUtlGetCurMeasTb)
-      
    if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
       {
          /* Intentionally avoiding the RLC_ALLOC macro to avoid  memset */
@@ -1656,40 +1469,30 @@ RlcDlRbCb *rbCb;
  *      -# ROK
  */
 
-#ifdef ANSI
 S16 rlcUtlProcHarqInd
 (
-RlcCb             *gCb,
+RlcCb            *gCb,
 RguHarqStatusInd *hqStaInd,
-RlcDlUeCb           *ueCb,
-U8               tbIdx
+RlcDlUeCb        *ueCb,
+uint8_t          tbIdx
 )
-#else
-S16 rlcUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
-RlcCb             *gCb;
-RguHarqStatusInd *hqStaInd;
-RlcDlUeCb           *ueCb;
-U8               tbIdx;
-#endif
 {
 #ifdef LTE_L2_MEAS
-   RlcDlRbCb       *rlcRbCb;           /* KW Control Block */
-   RlcL2MeasTb   *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 */
+   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;
-   U32          totlSduCnt = 0;
+   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(rlcUtlProcHarqInd)
-
    /*starting Task*/
    SStartTask(&startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
 
@@ -1866,34 +1669,21 @@ U8               tbIdx;
  *      -# ROK
  */
 
-#ifdef ANSI
-S16 rlcUtlSndDlL2MeasCfm
-(
-RlcCb                  *gCb,
-RlcL2MeasEvtCb         *measEvtCb
-)
-#else
-S16 rlcUtlSndDlL2MeasCfm(gCb, measEvtCb)
-RlcCb                  *gCb;
-RlcL2MeasEvtCb         *measEvtCb;
-#endif
+S16 rlcUtlSndDlL2MeasCfm(RlcCb *gCb,RlcL2MeasEvtCb *measEvtCb)
 {
-   U32                     qciIdx;
-   RlcL2MeasCb              *measCb = NULLP;
-   RlcL2MeasCfmEvt          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(rlcUtlSndL2MeasCfm)
-
    /* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
 #ifndef ALIGN_64BIT
    RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
@@ -1904,7 +1694,7 @@ RlcL2MeasEvtCb         *measEvtCb;
    /* Clean up the RB data structures */
    measCb = &measEvtCb->measCb;
    
-   cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
+   memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
    measCfmEvt.transId = measEvtCb->transId;
 
    measCfmEvt.measType = measCb->measType;
@@ -2026,21 +1816,8 @@ RlcL2MeasEvtCb         *measEvtCb;
  *      -# ROK
  */
 
-#ifdef ANSI
-S16 rlcUtlSndDlL2MeasNCfm
-(
-RlcCb           *gCb,
-RlcL2MeasReqEvt *measReqEvt,
-RlcL2MeasCfmEvt *measCfmEvt
-)
-#else
-S16 rlcUtlSndDlL2MeasNCfm(gCb,measReqEvt, measCfmEvt)
-RlcCb           *gCb;
-RlcL2MeasReqEvt *measReqEvt;
-RlcL2MeasCfmEvt *measCfmEvt;
-#endif
+S16 rlcUtlSndDlL2MeasNCfm(RlcCb *gCb,RlcL2MeasReqEvt *measReqEvt,RlcL2MeasCfmEvt *measCfmEvt)
 {
-   TRC3(rlcUtlSndDlL2MeasNCfm)
 
    RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
    return ROK;
@@ -2059,23 +1836,11 @@ RlcL2MeasCfmEvt *measCfmEvt;
  *
  *  @return  Void
  */
-#ifdef ANSI
 
-Void rlcUtlResetDlL2MeasInRlcRb
-(
-RlcCb       *gCb,
-RlcL2MeasCb *measCb,
-U8             measType
-)
-#else
-Void rlcUtlResetDlL2MeasInRlcRb(gCb, measCb, measType)
-RlcCb       *gCb;
-RlcL2MeasCb *measCb;
-U8             measType;
-#endif
+Void rlcUtlResetDlL2MeasInRlcRb(RlcCb *gCb,RlcL2MeasCb *measCb,uint8_t measType)
 {
-   U32           ueIdx;
-   U32           qciIdx;
+   uint32_t           ueIdx;
+   uint32_t           qciIdx;
    RlcDlUeCb      *ueCb = NULL;
 
 
@@ -2110,10 +1875,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,10 +1887,10 @@ 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;
          }
@@ -2135,9 +1900,9 @@ U8             measType;
 } /* rlcUtlResetDlL2MeasInRlcRb */
 #endif
 
-PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
+static Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
 {
-   if(dlRbCb->mode == CM_LTE_MODE_UM)
+   if(dlRbCb->mode == RLC_MODE_UM)
    {
       RLOG_ARG3(L_DEBUG,DBG_RBID,dlRbCb->rlcId.rbId,
                "UM Downlink UEID:%d CELLID:%d Q size = %d",
@@ -2145,9 +1910,9 @@ PRIVATE Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
                        dlRbCb->rlcId.cellId,
                        (int)dlRbCb->m.umDl.sduQ.count);
    }
-   else if(dlRbCb->mode == CM_LTE_MODE_AM)
+   else if(dlRbCb->mode == RLC_MODE_AM)
    {
-      U32 j, numTxPdus=0;
+      uint32_t j, numTxPdus=0;
       for(j = 0; j <= (RLC_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
       {
          RlcTx *txBuf = rlcUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
@@ -2184,7 +1949,7 @@ Void DumpRLCDlDebugInformation(Void)
                                    (PTR) ueCb, 
                                    (PTR *)&ueCb))
    {
-      U32 i;
+      uint32_t i;
       for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
       {
          RlcDlRbCb* dlRbCb = ueCb->srbCb[i]; 
@@ -2222,15 +1987,7 @@ Void DumpRLCDlDebugInformation(Void)
  *  @return  Void
  */
 
-#ifdef ANSI
-void rlcUtlFreeDlMem
-(
- Void
-)
-#else
-void rlcUtlFreeDlMem()
-Void;
-#endif
+void rlcUtlFreeDlMem( Void)
 {
   rlcUtlFreeDlMemory(RLC_GET_RLCCB(RLC_DL_INST));
 }
@@ -2240,39 +1997,21 @@ Void;
  * @b Description
  *        This function returns current time
  *
- *  @param[in] U32 
+ *  @param[in] uint32_t 
  *
  *
  *  @return  Void
  */
 
-#ifdef ANSI
-void rlcUtlGetCurrTime
-(
- U32  *currTime
-)
-#else
-void rlcUtlGetCurrTime(U32 *currTime)
-U32   *currTime;
-#endif
+void rlcUtlGetCurrTime(uint32_t  *currTime)
 {
-   TRC2(rlcUtlGetCurrTime)
-
    /* Need t define else part for PAL */
    *currTime = SGetTtiCount();
 }
 
 #if defined(MAC_RLC_HARQ_STA_RBUF) || defined (SS_RBUF)
 #ifdef LTE_L2_MEAS
-#ifdef ANSI
-void rlcUtlDlBatchProcHqStaInd
-(
- Void
-)
-#else
-void rlcUtlDlBatchProcHqStaInd()
-Void;
-#endif
+void rlcUtlDlBatchProcHqStaInd( Void)
 {
    /* Read from Ring Buffer and process PDCP packets */
    //Pst pst = {0};
@@ -2316,19 +2055,7 @@ Void;
  *  @return  Void
  *
  */
-#ifdef ANSI
-Void rlcUtlTrigPdbFlowCntrl
-(
-RlcCb       *gCb,
-RlcDlRbCb   *rbCb,
-U32        pktAdmitCnt
-)
-#else
-Void rlcUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
-RlcCb       *gCb;
-RlcDlRbCb   *rbCb;
-U32        pktAdmitCnt;
-#endif
+Void rlcUtlTrigPdbFlowCntrl(RlcCb  *gCb,RlcDlRbCb *rbCb,uint32_t pktAdmitCnt)
 {
    KwuFlowCntrlIndInfo    *flowCntrlInfo;
    RlcKwuSapCb*            rlckwuSap;
@@ -2359,30 +2086,16 @@ U32        pktAdmitCnt;
  *
  *  @return  Void
  */
-#ifdef ANSI
-Void rlcUtlStoreTxBuf 
-(
-CmLListCp        *txBufLst,
-RlcTx             *txBuf,
-RlcSn              sn
-)
-#else
-Void rlcUtlStoreTxBuf(txBufLst, txBuf, sn)
-CmLListCp        *txBufLst;
-RlcTx             *txBuf;
-RlcSn              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 % RLC_TX_BUF_BIN_SIZE );
    txBuf->sn = sn; 
    txBuf->lnk.node = (PTR)txBuf;
    cmLListAdd2Tail(&(txBufLst[hashKey]), &txBuf->lnk);
 
-   RETVOID;
+   return;
 } /* rlcUtlStoreRecBuf */
 
 /**
@@ -2399,26 +2112,13 @@ RlcSn              sn;
  *
  *  @return  Void
  */
-#ifdef ANSI
-RlcTx* rlcUtlGetTxBuf 
-(
-CmLListCp        *txBufLst,
-RlcSn             sn
-)
-#else
-RlcTx* rlcUtlGetTxBuf(txBufLst, sn)
-CmLListCp        *txBufLst;
-RlcSn             sn;
-#endif
+RlcTx* rlcUtlGetTxBuf(CmLListCp *txBufLst, RlcSn sn)
 {
-   U32                 hashKey; 
+   uint32_t            hashKey; 
    CmLListCp           *txBufLstCp;
-   RlcTx                *txBuf;
+   RlcTx               *txBuf;
    CmLList             *node = NULLP;
 
-   TRC3(rlcUtlGetTxBuf)
-   //printf("G-sn(%d)\n", sn);
-
    hashKey = (sn % RLC_TX_BUF_BIN_SIZE ); 
  
    txBufLstCp = &txBufLst[hashKey];
@@ -2432,7 +2132,7 @@ RlcSn             sn;
       }
       CM_LLIST_NEXT_NODE(txBufLstCp, node);
    }
-   return (NULLP);
+   return NULLP;
 } /* rlcUtlStoreTxBuf */
 /**
  *
@@ -2448,32 +2148,18 @@ RlcSn             sn;
  *
  *  @return  Void
  */
-#ifdef ANSI
-Void rlcUtlDelTxBuf 
-(
-CmLListCp        *txBufLst,
-RlcTx            *txBuf,
-RlcCb              *gCb                              
-)
-#else
-Void rlcUtlDelTxBuf(txBufLst, txBuf, gCb)
-CmLListCp        *txBufLst;
-RlcTx             *txBuf;
-RlcCb             *gCb;                              
-#endif
+Void rlcUtlDelTxBuf (CmLListCp *txBufLst,RlcTx  *txBuf,RlcCb *gCb)
 {
-   U32                 hashKey; 
+   uint32_t            hashKey; 
    CmLListCp           *txBufLstCp;
 
-   TRC3(rlcUtlDelTxBuf)
-
    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(RlcTx));
-   RETVOID;
+   RLC_FREE(gCb, txBuf, sizeof(RlcTx));
+   return;
 } /* rlcUtlDelTxBuf */
 
 /**
@@ -2490,31 +2176,17 @@ RlcCb             *gCb;
  *
  *  @return  Void
  */
-#ifdef ANSI
-Void rlcUtlRemovTxBuf 
-(
-CmLListCp        *txBufLst,
-RlcTx            *txBuf,
-RlcCb              *gCb                              
-)
-#else
-Void rlcUtlRemovTxBuf(txBufLst, txBuf, gCb)
-CmLListCp        *txBufLst;
-RlcTx             *txBuf;
-RlcCb             *gCb;                              
-#endif
+Void rlcUtlRemovTxBuf(CmLListCp *txBufLst,RlcTx  *txBuf,RlcCb *gCb)
 {
-   U32                 hashKey; 
+   uint32_t            hashKey; 
    CmLListCp           *txBufLstCp;
 
-   TRC3(rlcUtlRemovTxBuf)
-
    hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE ); 
  
    txBufLstCp = &txBufLst[hashKey];
    //printf("D-sn(%d)\n", txBuf->hdr.sn);
    cmLListDelFrm(txBufLstCp, &txBuf->lnk);
-   RETVOID;
+   return;
 } /* rlcUtlRemovTxBuf */