X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_amm_ul.c;h=a2b6742edeee551c93bf558aacd847cf79b04fb7;hb=28f46cc35608de7bddea133457cff5fb330fd86d;hp=59c337c137408747255f95739572fcde37dc4146;hpb=0a26c487f1b6bbb5217e47b15fa8273b2e749283;p=o-du%2Fl2.git

diff --git a/src/5gnrrlc/kw_amm_ul.c b/src/5gnrrlc/kw_amm_ul.c
index 59c337c13..a2b6742ed 100755
--- a/src/5gnrrlc/kw_amm_ul.c
+++ b/src/5gnrrlc/kw_amm_ul.c
@@ -66,7 +66,7 @@ static int RLOG_FILE_ID=190;
 #ifndef RGL_SPECIFIC_CHANGES
 #ifndef TENB_ACC
 #ifndef LTE_PAL_ENB
-extern U32 ulrate_rgu;
+uint32_t ulrate_rgu;
 #endif
 #endif
 #endif
@@ -74,11 +74,11 @@ extern U32 ulrate_rgu;
 #ifndef TENB_ACC
 #ifndef TENB_T2K3K_SPECIFIC_CHANGES
 #ifndef LTE_PAL_ENB
-extern U32 isMemThreshReached(Region region);
+uint32_t isMemThreshReached(Region region);
 #endif
 #else
 #ifndef LTE_PAL_ENB
-extern U32  isMemThreshReached(Region region);
+uint32_t  isMemThreshReached(Region region);
 #endif
 #endif
 #endif
@@ -90,41 +90,41 @@ extern U32  isMemThreshReached(Region region);
 
 /* private function declarations */
 
-PRIVATE Void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
+static void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
 
-PRIVATE S16 rlcAmmExtractHdr ARGS ((RlcCb *gCb,
+static uint8_t rlcAmmExtractHdr ARGS ((RlcCb *gCb,
                                 RlcUlRbCb   *rbCb,
                                 Buffer *pdu,
                                 RlcAmHdr *amHdr,
-                                U8 *fByte));
+                                uint8_t *fByte));
 
-PRIVATE Bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
-                                            Buffer *pdu,
-                                            RlcUlRbCb *rbCb,
-                                            RlcAmHdr *amHdr));
+static bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
+                                     Buffer *pdu,
+                                     RlcUlRbCb *rbCb,
+                                     RlcAmHdr *amHdr));
 
-PRIVATE Void rlcAmmTriggerStatus ARGS ((RlcCb *gCb,
-                                    RlcUlRbCb *rbCb,
-                                    RlcSn sn,
-                                    Bool discFlg));
+static void rlcAmmTriggerStatus ARGS ((RlcCb *gCb,
+                                RlcUlRbCb *rbCb,
+                                RlcSn sn,
+                                bool discFlg));
 
-PRIVATE S16  rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb,
+static uint8_t  rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb,
                                      RlcUlRbCb *rbCb,
                                      RlcAmRecBuf *recBuf));
 
-PRIVATE Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb,
+static Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb,
                                       RlcUlRbCb *rbCb,
                                       RlcAmHdr *amHdr,
                                       Buffer *pdu));
 
-PRIVATE Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg));
+static Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg));
 
-PRIVATE Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo));
+static Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo));
 
-PRIVATE Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
+static Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
                                          RlcUlRbCb *rbCb,
                                          Buffer *cntrlPdu,
-                                         U8 *fByte));
+                                         uint8_t *fByte));
 
 /******************************************************************************
 
@@ -159,125 +159,104 @@ PRIVATE Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
  *    The number of bytes required to encode this NACK information
  *
  */
-#ifdef ANSI
-PRIVATE S16 rlcAmmUlSetNackInfo
-(
-RlcUlRbCb      *rbCb,
-RlcSn          sn,
-Bool          isSegment,
-U16           soStart,
-U16           soEnd,
-RlcUdxDlStaPdu *statusPdu,
-RlcSn          *prevNackSn
-)
-#else
-PRIVATE S16 rlcAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn)
-RlcUlRbCb      *rbCb;
-RlcSn          sn;
-Bool          isSegment;
-U16           soStart;
-U16           soEnd;
-RlcUdxDlStaPdu *statusPdu,
-RlcSn          *prevNackSn;
-#endif
+static uint8_t rlcAmmUlSetNackInfo(RlcUlRbCb *rbCb, RlcSn sn, bool isSegment, \
+   uint16_t soStart, uint16_t soEnd, RlcUdxDlStaPdu *statusPdu, RlcSn *prevNackSn)
 {
    RlcNackInfo   *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount);
-   S16           sizeToBeEncd = 0; /* Status PDu size to be encoded */
-
-   TRC2(rlcAmmUlSetNackInfo)
-
-      /* In following cases we should increment the nackCnt & fill new NACK_SN info:
-       *    1) First NACK_SN of the statusdPdu
-       *    2) NACK_SN is not continuous with previous
-       *    3) NACK_SN is same as previuos but segments are not continuous
-       *    4) NACK_SN is continuous with previous but previous NACK_SN segments
-       *       are not missing in sequence till end
-       */
-      if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & AMUL.snModMask) != sn) ||
-            (((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) ||
-            ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != RLC_ALL_BYTES_MISSING)))
+   uint16_t       sizeToBeEncd = 0; /* Status PDu size to be encoded */
+
+   /* In following cases we should increment the nackCnt & fill new NACK_SN info:
+    *    1) First NACK_SN of the statusdPdu
+    *    2) NACK_SN is not continuous with previous
+    *    3) NACK_SN is same as previuos but segments are not continuous
+    *    4) NACK_SN is continuous with previous but previous NACK_SN segments
+    *       are not missing in sequence till end
+    */
+   if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & RLC_AMUL.snModMask) != sn) ||
+	 (((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) ||
+	 ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != RLC_ALL_BYTES_MISSING)))
+   {
+      if(nackInfo->nackRange)
       {
-         if(nackInfo->nackRange)
-         {
-            if((nackInfo->soEnd) && (!nackInfo->soStart))
-            {
-               /*First nack_sn of this nackRange not segmented but last is segmented */
-               sizeToBeEncd = 5; /*32 for soStart and soEnd and 8 for nackRange */ 
-            }
-            else
-            {
-               /*First nack_sn of this nackRange was segmented */
-               sizeToBeEncd = 1; /*8 for nackRange */ 
-            }
-         }
+	 if((nackInfo->soEnd) && (!nackInfo->soStart))
+	 {
+	    /*First nack_sn of this nackRange not segmented but last is segmented */
+	    sizeToBeEncd = 5; /*32 for soStart and soEnd and 8 for nackRange */ 
+	 }
+	 else
+	 {
+	    /*First nack_sn of this nackRange was segmented */
+	    sizeToBeEncd = 1; /*8 for nackRange */ 
+	 }
+      }
 
-         if(*prevNackSn != 0xffffffff)
-         {
-            /* Increment nackCount as this sn is continous */
-            statusPdu->nackCount++;
-            nackInfo = statusPdu->nackInfo + statusPdu->nackCount;
-         }
+      if(*prevNackSn != 0xffffffff)
+      {
+	 /* Increment nackCount as this sn is continous */
+	 statusPdu->nackCount++;
+	 nackInfo = statusPdu->nackInfo + statusPdu->nackCount;
+      }
 
-         nackInfo->sn = sn;
-         nackInfo->isSegment = isSegment;
-         nackInfo->soStart = soStart;
-         nackInfo->soEnd   = soEnd;
-         nackInfo->nackRange = 0;
+      nackInfo->sn = sn;
+      nackInfo->isSegment = isSegment;
+      nackInfo->soStart = soStart;
+      nackInfo->soEnd   = soEnd;
+      nackInfo->nackRange = 0;
 
-         if(isSegment)
-         {
-            sizeToBeEncd += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
-         }
-         else
-         {
-            sizeToBeEncd += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
-         }
+      if(isSegment)
+      {
+	 sizeToBeEncd += ((RLC_AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
       }
       else
       {
-         if(!(nackInfo->nackRange))
-         {
-            nackInfo->nackRange++;
-         }
-         /* This case means there are continuous SNs/Segments. If it is the next
-          * Sn then increment nackRnage. if same SN but different segment then
-          * dont increment nackRange */
-         if((((*prevNackSn) + 1) & AMUL.snModMask) == sn)
-         {
-            nackInfo->nackRange++;
-         }
-
-         /* If NackRange is reached to max value then increment statusPdu->nackCount*/
-         if(nackInfo->nackRange == 255)
-         {
-            statusPdu->nackCount++;
-            if(nackInfo->isSegment)
-            {
-               sizeToBeEncd = 1; /* return only nackRangeSize*/
-            }
-            else if (isSegment)
-            {
-               /* First SN was not segmented of this nackRange but last SN is segmented */
-               sizeToBeEncd = 5; /* return size of soSatrt + soEnd + nackRnage */
-            }
-         }
+	 sizeToBeEncd += ((RLC_AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
+      }
+   }
+   else
+   {
+      if(!(nackInfo->nackRange))
+      {
+	 nackInfo->nackRange++;
+      }
+      /* This case means there are continuous SNs/Segments. If it is the next
+       * Sn then increment nackRnage. if same SN but different segment then
+       * dont increment nackRange */
+      if((((*prevNackSn) + 1) & RLC_AMUL.snModMask) == sn)
+      {
+	 nackInfo->nackRange++;
+      }
 
-         if(isSegment)
-         {
-            nackInfo->isSegment = isSegment;
-            nackInfo->soEnd = soEnd;
-         }
-         else if(nackInfo->isSegment)
-         {
-            nackInfo->soEnd = RLC_ALL_BYTES_MISSING;
-         }
-         else
-         {
-            nackInfo->soStart = 0;
-            nackInfo->soEnd =   0;
-         }
+      /* If NackRange is reached to max value then increment statusPdu->nackCount*/
+      if(nackInfo->nackRange == 255)
+      {
+	 statusPdu->nackCount++;
+	 if(nackInfo->isSegment)
+	 {
+	    sizeToBeEncd = 1; /* return only nackRangeSize*/
+	 }
+	 else if (isSegment)
+	 {
+	    /* First SN was not segmented of this nackRange but last SN is segmented */
+	    sizeToBeEncd = 5; /* return size of soSatrt + soEnd + nackRnage */
+	 }
+      }
 
+      if(isSegment)
+      {
+	 nackInfo->isSegment = isSegment;
+	 nackInfo->soEnd = soEnd;
       }
+      else if(nackInfo->isSegment)
+      {
+	 nackInfo->soEnd = RLC_ALL_BYTES_MISSING;
+      }
+      else
+      {
+	 nackInfo->soStart = 0;
+	 nackInfo->soEnd =   0;
+      }
+
+   }
    *prevNackSn = sn;
 
    return (sizeToBeEncd);
@@ -299,17 +278,7 @@ RlcSn          *prevNackSn;
  * @return  Void
  *
  */
-#ifdef ANSI
-PRIVATE Void rlcAmmUlAssembleCntrlInfo
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb
-)
-#else
-PRIVATE Void rlcAmmUlAssembleCntrlInfo(gCb, rbCb)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-#endif
+static void rlcAmmUlAssembleCntrlInfo(RlcCb *gCb, RlcUlRbCb *rbCb)
 {
    RlcUdxDlStaPdu   *pStatusPdu;
    RlcNackInfo      *nackInfo;
@@ -317,18 +286,15 @@ RlcUlRbCb   *rbCb;
    RlcSn            mSn;               /* Mod val of sequence number */
    RlcSn            rxHighestStatus;              /* Mod val of rxHighestStatus */
    RlcSeg           *seg;              /* pdu segment */
-   U16             nackCnt = 0;       /* Index for staPdu */
-   U16             seqSo;             /* segmment offset */
+   uint16_t         nackCnt = 0;       /* Index for staPdu */
+   uint16_t         seqSo;             /* segmment offset */
    RlcUdxUlSapCb    *sapCb;
-   U16             staPduEncSize = 3; /* size that would be of the encoded
+   uint16_t         staPduEncSize = 3; /* size that would be of the encoded
                                           STATUS PDU, it is in bits; 15 for
                                           first fixed part of STATUS PDU */
    RlcAmRecBuf      *recBuf = NULLP;
    RlcSn            prevNackSn = 0xffffffff;
 
-   TRC2(rlcAmmUlAssembleCntrlInfo)
-
-
    sapCb = RLC_GET_UDX_SAP(gCb);
 
    RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
@@ -340,26 +306,23 @@ RlcUlRbCb   *rbCb;
    /* Memory allocation failure can not be expected  */
    if(!pStatusPdu)
    {
-     RETVOID;
+     return;
    }
 #endif
 
-   sn = AMUL.rxNext;
-   MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
-   MODAMR(AMUL.rxHighestStatus, rxHighestStatus, AMUL.rxNext, AMUL.snModMask);
+   sn = RLC_AMUL.rxNext;
+   MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
+   MODAMR(RLC_AMUL.rxHighestStatus, rxHighestStatus, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
    
-   recBuf =  rlcUtlGetRecBuf(AMUL.recBufLst, sn);
+   recBuf =  rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
 
    while (mSn < rxHighestStatus )
    {
       /* For missing PDUs */
       if ((NULLP  == recBuf) && nackCnt < RLC_MAX_NACK_CNT )
       {
-         RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, 
-                  "Missing PDU's SN = %d UEID:%d CELLID:%d", 
-                  sn,
-                  rbCb->rlcId.ueId,
-                  rbCb->rlcId.cellId);
+         DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing PDU's SN = %d UEID:%d \
+	    CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
          staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
                                              sn,
                                              FALSE, /* isSegment */
@@ -389,18 +352,11 @@ RlcUlRbCb   *rbCb;
                                                    pStatusPdu,
                                                    &prevNackSn);
 
-               RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
-                             "Missing byte segment's" 
-                             " SN:%d UEID:%d CELLID:%d",
-                             sn,
-                             rbCb->rlcId.ueId,
-                             rbCb->rlcId.cellId);
-               RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
-                             "soStart and soEnd = %d, %d UEID:%d CELLID:%d",
-                             seqSo,
-                             seg->amHdr.so - 1,
-                             rbCb->rlcId.ueId,
-                             rbCb->rlcId.cellId);
+               DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing byte segment's" 
+                  " SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+               DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d \
+	           UEID:%d CELLID:%d", seqSo, seg->amHdr.so - 1, rbCb->rlcId.ueId,
+                   rbCb->rlcId.cellId);
             }
 
             seqSo = seg->soEnd + 1;
@@ -420,27 +376,21 @@ RlcUlRbCb   *rbCb;
                                                 pStatusPdu,
                                                 &prevNackSn);
 
-            RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
-                          "rlcAmmUlAssembleCntrlInfo: Missing (last) byte " 
-                          "segment's SN:%d UEID:%d CELLID:%d",
-                          sn,
-                          rbCb->rlcId.ueId,
-                          rbCb->rlcId.cellId);
-            RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
-                          "soStart and soEnd = %d, %d UEID:%d CELLID:%d",
-                          seqSo,
-                          RLC_ALL_BYTES_MISSING,
-                          rbCb->rlcId.ueId,
-                          rbCb->rlcId.cellId);
+            DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing (last) byte " 
+               "segment's SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId,
+               rbCb->rlcId.cellId);
+            DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d\
+	       UEID:%d CELLID:%d", seqSo, RLC_ALL_BYTES_MISSING, rbCb->rlcId.ueId,
+               rbCb->rlcId.cellId);
          }
       }
       
 
-      sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */
-      MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
+      sn = (sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
+      MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
       
       /* Get the received Buffer the updated/next SN */
-      recBuf =  rlcUtlGetRecBuf(AMUL.recBufLst, sn);
+      recBuf =  rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
 
       /* Find the next missing sequence number if nackCnt reaches maximum and
          still Reordering window has some missing AMDPDUs / AMDPDU segments. The
@@ -480,24 +430,21 @@ RlcUlRbCb   *rbCb;
    /* Update ACK SN with the last sn for which feedback is not assembled */
    if ( mSn == rxHighestStatus)
    {
-      pStatusPdu->ackSn = AMUL.rxHighestStatus;
+      pStatusPdu->ackSn = RLC_AMUL.rxHighestStatus;
    }
    else
    {
       pStatusPdu->ackSn = sn;
    }
 
-   RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
-            "rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
-            "UEID:%d CELLID:%d",
-            pStatusPdu->ackSn,
-            rbCb->rlcId.ueId,
-            rbCb->rlcId.cellId);
+    DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
+       "UEID:%d CELLID:%d", pStatusPdu->ackSn, rbCb->rlcId.ueId,
+       rbCb->rlcId.cellId);
 
    pStatusPdu->controlBo = staPduEncSize; /*Its already in bytes */
 
-   AMUL.staTrg = FALSE;
-   AMUL.gatherStaPduInfo = FALSE;
+   RLC_AMUL.staTrg = FALSE;
+   RLC_AMUL.gatherStaPduInfo = FALSE;
 
 
    if (rlcUlUdxStaPduReq(&sapCb->pst,
@@ -505,25 +452,23 @@ RlcUlRbCb   *rbCb;
                         &rbCb->rlcId,
                         pStatusPdu) != ROK)
    {
-      RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
-               "Failed to Send Sta Pdu UEID:%d CELLID:%d",
-               rbCb->rlcId.ueId,
-               rbCb->rlcId.cellId);
+      DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Failed to Send Sta Pdu UEID:%d \
+         CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
       RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
 			    sapCb->pst.pool,
 			    pStatusPdu, 
 			    sizeof(RlcUdxDlStaPdu));
    }
 
-   RETVOID;
+   return;
 }
 
 #ifdef XEON_SPECIFIC_CHANGES
-extern U32  gRlcDatIndUL;
+uint32_t  gRlcDatIndUL;
 #endif
 
 #ifdef T2K_TRIGGER_RLC_REEST
-U32 drpRlcDrbPack;
+uint32_t drpRlcDrbPack;
 #endif
 /**
  * @brief Handler to process the PDUs received from MAC and send it to PDCP
@@ -542,78 +487,41 @@ U32 drpRlcDrbPack;
  *
  */
 #ifdef LTE_L2_MEAS
-#ifdef ANSI
-Void rlcAmmProcessPdus
-(
-RlcCb                    *gCb,
-RlcUlRbCb                *rbCb,
-KwPduInfo               *pduInfo,
-U32                     ttiCnt
-)
-#else
-Void rlcAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo)
-RlcCb                    *gCb;
-RlcUlRbCb                *rbCb;
-KwPduInfo               *pduInfo;
-U32                     ttiCnt;
-#endif
-#else
-#ifdef ANSI
-Void rlcAmmProcessPdus
-(
-RlcCb        *gCb,
-RlcUlRbCb    *rbCb,
-KwPduInfo   *pduInfo
-)
+void rlcAmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo, uint32_t ttiCnt)
 #else
-Void rlcAmmProcessPdus(gCb, rbCb, pduInfo)
-RlcCb        *gCb;
-RlcUlRbCb    *rbCb;
-KwPduInfo   *pduInfo;
-#endif
+void rlcAmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo)
 #endif
 {
    Buffer    *pdu;
    RlcAmUl    *amUl;
    RlcAmHdr   amHdr;
-   U8        numPdu = 0;
-   U8        numPduToProcess;
+   uint8_t    numPdu = 0;
+   uint8_t    numPduToProcess;
    RlcSn      sn;
    RlcSn      tSn;
    RlcSn      mSn;
-   U8        fByte;
-   Bool      discFlg;
+   uint8_t    fByte;
+   bool      discFlg;
 #ifdef LTE_L2_MEAS_RLC
    MsgLen              rlcSduSz;  /*Holds length of Rlc Sdu*/
 #endif /* LTE_L2_MEAS */
 
-   TRC2(rlcAmmProcessPdus)
-
-
-   amUl = &AMUL;
+   amUl = &RLC_AMUL;
 
    numPduToProcess = RLC_MIN(pduInfo->numPdu, RGU_MAX_PDU);
-   RLOG_ARG4(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, 
-            "numPdu[%ld],numPduToProcess[%ld] UEID:%ld CELLID:%ld",
-            numPdu,
-            numPduToProcess,
-            rbCb->rlcId.ueId,
-            rbCb->rlcId.cellId);
+   DU_LOG("\nRLC : rlcAmmProcessPdus: numPdu[%d],numPduToProcess[%d] UEID:%d CELLID:%d",
+            numPdu, numPduToProcess, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 
-   //printf ("++++++++++++  5GNRLOG numPduToProcess %d \n", numPduToProcess);
    while (numPdu < numPduToProcess)
    {
-   //printf ("++++++++++++  5GNRLOG processing pdu  %d \n", numPdu);
       discFlg = FALSE;
       pdu = pduInfo->mBuf[numPdu++];
 
       if (! pdu)
       {
 
-         RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
-                  "Null Pdu UEID:%d CELLID:%d",
-                  rbCb->rlcId.ueId,
-                  rbCb->rlcId.cellId);
+         DU_LOG("\nRLC : rlcAmmProcessPdus: Null Pdu UEID:%d CELLID:%d",
+            rbCb->rlcId.ueId, rbCb->rlcId.cellId);
          gCb->genSts.errorPdusRecv++;
          break;
       }
@@ -621,7 +529,7 @@ KwPduInfo   *pduInfo;
 #ifndef TENB_ACC
 #ifndef LTE_PAL_ENB
       MsgLen len;
-      SFndLenMsg(pdu, &len);
+      ODU_GET_MSG_LEN(pdu, &len);
       ulrate_rgu += len;
 #endif
 #endif
@@ -632,11 +540,9 @@ KwPduInfo   *pduInfo;
          a single pointer */
       if (rlcAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
       {
-         RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
-                  "Header Extraction Failed UEID:%d CELLID:%d",
-                  rbCb->rlcId.ueId,
-                  rbCb->rlcId.cellId);
-         RLC_FREE_BUF(pdu);
+         DU_LOG("\nRLC : rlcAmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",
+            rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+         ODU_PUT_MSG_BUF(pdu);
          gCb->genSts.errorPdusRecv++;
          continue;
       }
@@ -644,18 +550,15 @@ KwPduInfo   *pduInfo;
       if (amHdr.dc == 0)
       {
          rlcAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
-         RLC_FREE_BUF(pdu);
+         ODU_PUT_MSG_BUF(pdu);
          continue;
       }
       if((amHdr.si == RLC_SI_LAST_SEG) && (!amHdr.so))
       {
-         RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
-               "rlcAmmProcessPdus: Dropping PDU because SO can't be zero for last segment sn:%u "
-               "UEID:%d CELLID:%d",
-               amHdr.sn,
-               rbCb->rlcId.ueId,
-               rbCb->rlcId.cellId);
-         RLC_FREE_BUF(pdu);
+         DU_LOG("\nRLC: rlcAmmProcessPdus: Dropping PDU because SO can't be zero\
+	    for last segment sn:%u UEID:%d CELLID:%d", amHdr.sn, rbCb->rlcId.ueId,
+            rbCb->rlcId.cellId);
+         ODU_PUT_MSG_BUF(pdu);
          continue;
       }
 #ifndef RGL_SPECIFIC_CHANGES
@@ -666,9 +569,9 @@ KwPduInfo   *pduInfo;
     /* Changed the condition to TRUE from ROK  */
       if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
       {
-         extern U32 rlculdrop;
+         uint32_t rlculdrop;
 	 rlculdrop++;
-	 RLC_FREE_BUF(pdu);
+	 ODU_PUT_MSG_BUF(pdu);
 	 continue;
       }
 #endif
@@ -677,9 +580,9 @@ KwPduInfo   *pduInfo;
       /*ccpu00142274 - UL memory based flow control*/
       if(isMemThreshReached(rlcCb[0]->init.region) != ROK)
       {
-         extern U32 rlculdrop;
+         uint32_t rlculdrop;
          rlculdrop++;
-         RLC_FREE_BUF(pdu);
+         ODU_PUT_MSG_BUF(pdu);
          continue;
       }
 #endif
@@ -693,7 +596,7 @@ KwPduInfo   *pduInfo;
       {
          if(rbCb->rlcId.rbType == CM_LTE_DRB)
          {
-            RLC_FREE_BUF(pdu);
+            ODU_PUT_MSG_BUF(pdu);
             continue;
          }
       }
@@ -704,7 +607,7 @@ KwPduInfo   *pduInfo;
       if (rlcAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE)
       {
          RlcAmRecBuf      *recBuf;
-         Bool   tmrRunning;
+         bool   tmrRunning;
          RlcSn   tVrMr;
          RlcSn   mrxNextHighestRcvd;
 
@@ -719,11 +622,8 @@ KwPduInfo   *pduInfo;
          {
             amUl->rxNextHighestRcvd = ((sn + 1) & (amUl->snModMask)); 
 
-            RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
-                  "rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
-                  amUl->rxNextHighestRcvd,
-                  rbCb->rlcId.ueId,
-                  rbCb->rlcId.cellId);
+            DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
+               amUl->rxNextHighestRcvd, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
          }
          
          recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
@@ -816,11 +716,9 @@ KwPduInfo   *pduInfo;
                rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
                amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
 
-               RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
-                        "rlcAmmProcessPdus: Updated rxNextStatusTrig = %d UEID:%d CELLID:%d",
-                        amUl->rxNextStatusTrig,
-                        rbCb->rlcId.ueId,
-                        rbCb->rlcId.cellId);
+               DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextStatusTrig = %d \
+	          UEID:%d CELLID:%d", amUl->rxNextStatusTrig, rbCb->rlcId.ueId,
+                  rbCb->rlcId.cellId);
             }
          }
       }
@@ -845,7 +743,7 @@ KwPduInfo   *pduInfo;
       rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
    }
 
-   RETVOID;
+   return;
 }
 
 
@@ -870,37 +768,18 @@ KwPduInfo   *pduInfo;
  *     -# RFAILED
  *
  */
-#ifdef ANSI
-PRIVATE S16 rlcAmmExtractHdr
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb,
-Buffer     *pdu,
-RlcAmHdr    *amHdr,
-U8         *fByte
-)
-#else
-PRIVATE S16 rlcAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-Buffer     *pdu;
-RlcAmHdr    *amHdr;
-U8         *fByte;
-#endif
+static uint8_t rlcAmmExtractHdr(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *pdu, RlcAmHdr *amHdr, uint8_t *fByte)
 {
-   U8         snByte;
-   RlcSn        sn = 0;
+   uint8_t    snByte;
+   RlcSn      sn = 0;
    MsgLen     pduSz;
-   RlcExtHdr   hdrInfo;
-
-   TRC2(rlcAmmExtractHdr)
-
+   RlcExtHdr  hdrInfo;
 
    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 
    /* Extract fixed part of the header */
-   SFndLenMsg(pdu,&pduSz);
-   SRemPreMsg(fByte, pdu);
+   ODU_GET_MSG_LEN(pdu,&pduSz);
+   ODU_REM_PRE_MSG(fByte, pdu);
    amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
    if (RLC_CNTRL_PDU == amHdr->dc)
    {
@@ -915,16 +794,16 @@ U8         *fByte;
    /* 12 BIT SN */
    if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
    {
-      SRemPreMsg(&snByte, pdu);
+      ODU_REM_PRE_MSG(&snByte, pdu);
       sn = (RlcSn)(((*fByte & RLC_SN_POS_12BIT) << RLC_BYTE_LEN ) | snByte);
       amHdr->sn = sn;
    }
    else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
    {
-      SRemPreMsg(&snByte, pdu);
+      ODU_REM_PRE_MSG(&snByte, pdu);
       sn = (RlcSn)(((*fByte & RLC_SN_POS_18BIT) << RLC_BYTE_LEN ) | snByte);
 
-      SRemPreMsg(&snByte, pdu);
+      ODU_REM_PRE_MSG(&snByte, pdu);
       sn = ((sn << RLC_BYTE_LEN) | snByte);
 
       amHdr->sn = sn;
@@ -937,7 +816,6 @@ U8         *fByte;
       pduSz -= 2;
    }
 
-   //printf ("++++++++++++ 5GNRLOG HDR extracted DATA : sn %d  \n", sn);
    return ROK;
 }
 
@@ -963,32 +841,15 @@ U8         *fByte;
  *     -# RFAILED
  *
  */
-#ifdef ANSI
-PRIVATE S16 rlcAmmExtractHdrOld
-(
-RlcCb       *gCb,
-Buffer     *pdu,
-RlcAmHdr    *amHdr,
-U8         *fByte
-)
-#else
-PRIVATE S16 rlcAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
-RlcCb       *gCb;
-Buffer     *pdu;
-RlcAmHdr    *amHdr;
-U8         *fByte;
-#endif
+static S16 rlcAmmExtractHdrOld(RlcCb *gCb,Buffer *pdu,RlcAmHdr *amHdr,uint8_t *fByte)
 {
-   U8         e;
-   U8         snByte;
-   U16        sn;
+   uint8_t         e;
+   uint8_t         snByte;
+   uint16_t        sn;
    MsgLen     pduSz;
    MsgLen     totalSz = 0;
    RlcExtHdr   hdrInfo;
 
-   TRC2(rlcAmmExtractHdrOld)
-
-
    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 
    /* Extract fixed part of the header */
@@ -1007,14 +868,14 @@ U8         *fByte;
    e = amHdr->e  = (*fByte & RLC_E_POS)>> RLC_E_SHT;
     
    SRemPreMsg(&snByte, pdu);
-   sn = (U16)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
+   sn = (uint16_t)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
    amHdr->sn = sn;
    if (amHdr->rf == 1)
    {
       /* Extract extn part of the header */
       hdrInfo.len = RLC_LSF_LEN;
       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
-      amHdr->lsf = (U8)hdrInfo.val;
+      amHdr->lsf = (uint8_t)hdrInfo.val;
 
       hdrInfo.len = RLC_SO_LEN;
       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
@@ -1028,7 +889,7 @@ U8         *fByte;
    {
       hdrInfo.len = RLC_E_LEN;
       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
-      e = amHdr->e = (U8)hdrInfo.val;
+      e = amHdr->e = (uint8_t)hdrInfo.val;
 
       /* Extract LI value*/
       hdrInfo.len = RLC_LI_LEN;
@@ -1088,34 +949,17 @@ U8         *fByte;
  *  @return  Void
  *
  */
-#ifdef ANSI
-PRIVATE Void rlcAmmUlHndlStatusPdu
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb,
-Buffer     *cntrlPdu,
-U8         *fByte
-)
-#else
-PRIVATE Void rlcAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-Buffer     *cntrlPdu;
-U8         *fByte;
-#endif
+static void rlcAmmUlHndlStatusPdu(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *cntrlPdu, uint8_t *fByte)
 {
-   U8             e1;
-   RlcExtHdr       hdrInfo;
-   RlcUdxStaPdu    *pStaPdu;
-   RlcUdxUlSapCb   *sapCb;
-   U8             e3; /* NACK RANGE : 5GNR */
-   U32            snLen;
-   U32            snRange;
-   U32            resrvdBitsAckSn=0;
-   U32            resrvdBitsNackSn=0;
-
-   TRC2(rlcAmmUlHndlStatusPdu)
-
+   uint8_t          e1;
+   RlcExtHdr        hdrInfo;
+   RlcUdxStaPdu     *pStaPdu;
+   RlcUdxUlSapCb    *sapCb;
+   uint8_t          e3; /* NACK RANGE : 5GNR */
+   uint32_t         snLen;
+   uint32_t         snRange;
+   uint32_t         resrvdBitsAckSn=0;
+   uint32_t         resrvdBitsNackSn=0;
 
    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 
@@ -1126,12 +970,9 @@ U8         *fByte;
    /* D/C has been shifted in the calling function */
    if (hdrInfo.hdr & 0xE0)
    {
-      RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
-               "Reserved value for CPT received UEID:%d CELLID:%d",
-               rbCb->rlcId.ueId,
-               rbCb->rlcId.cellId);
-
-      RETVOID;
+      DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: Reserved value for CPT received UEID:%d \
+         CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+      return;
    }
 
    sapCb = RLC_GET_UDX_SAP(gCb);
@@ -1145,7 +986,7 @@ U8         *fByte;
    /* Memory allocation failure can not be expected  */
    if(!pStaPdu)
    {
-     RETVOID;
+     return;
    }
 #endif   
 
@@ -1181,12 +1022,9 @@ U8         *fByte;
    /* Check if NACK Exists */
    hdrInfo.len = RLC_E1_LEN;
    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
-   e1 = (U8)hdrInfo.val;
-   RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, 
-            "rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
-            pStaPdu->ackSn,
-            rbCb->rlcId.ueId,
-            rbCb->rlcId.cellId);
+   e1 = (uint8_t)hdrInfo.val;
+   DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
+      pStaPdu->ackSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 
    /* Extract the Reserved Bits after ACK SN field */
    hdrInfo.len = resrvdBitsAckSn;
@@ -1202,22 +1040,22 @@ U8         *fByte;
 
       hdrInfo.len = RLC_E1_LEN;
       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
-      e1 = (U8)hdrInfo.val;
+      e1 = (uint8_t)hdrInfo.val;
 
       /* Extract e2 */
       /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
          already present*/
       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
-      /*  e2 = (U8) hdrInfo.val;*/
+      /*  e2 = (uint8_t) hdrInfo.val;*/
 
       /* Store e2 value */
-      pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
+      pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) hdrInfo.val;
 
       /* Extract e3 : 5GNR */
       /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
          already present*/
       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
-      e3 = (U8) hdrInfo.val;
+      e3 = (uint8_t) hdrInfo.val;
 
       /* Extract Reserved Bits after NACK SN */
       hdrInfo.len = resrvdBitsNackSn;
@@ -1233,13 +1071,10 @@ U8         *fByte;
          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
          pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd   = hdrInfo.val;
 
-         RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,
-                       "rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
-                       "UEID:%d CELLID:%d",
-                       pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
-                       pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd,      
-                       rbCb->rlcId.ueId,
-                       rbCb->rlcId.cellId);
+         DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
+            "UEID:%d CELLID:%d", pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
+            pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd, rbCb->rlcId.ueId,
+            rbCb->rlcId.cellId);
       }                                                                
       else
       {
@@ -1254,7 +1089,7 @@ U8         *fByte;
          /* Extract NACK range field */
          hdrInfo.len = RLC_NACK_RANGE_LEN;
          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
-         snRange = (U8)hdrInfo.val;
+         snRange = (uint8_t)hdrInfo.val;
 
          pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
 
@@ -1276,7 +1111,7 @@ U8         *fByte;
    /* Parse & send Status PDU to RLC-DL */
    rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -1292,32 +1127,20 @@ U8         *fByte;
  * @return  Void
  *
  */
-#ifdef ANSI
-PRIVATE Void rlcAmmUlRlsAllSegs
-(
-RlcCb         *gCb,
-RlcAmRecBuf   *recBuf
-)
-#else
-PRIVATE Void rlcAmmUlRlsAllSegs(gCb,recBuf)
-RlcCb         *gCb;
-RlcAmRecBuf   *recBuf;
-#endif
+static void rlcAmmUlRlsAllSegs(RlcCb *gCb, RlcAmRecBuf *recBuf)
 {
    RlcSeg *seg;
 
-   TRC2(rlcAmmUlRlsAllSegs)
-
    RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
    while (seg != NULLP)
    {
-      RLC_FREE_BUF_WC(seg->seg);
+      ODU_PUT_MSG_BUF(seg->seg);
       cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
-      RLC_FREE_WC(gCb,seg, sizeof(RlcSeg));
+      RLC_FREE(gCb,seg, sizeof(RlcSeg));
       RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
    }
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -1340,34 +1163,16 @@ RlcAmRecBuf   *recBuf;
  *   -#TRUE  Successful insertion into the receiver buffer
  *   -#FALSE Possibly a duplicate segment
  */
-#ifdef ANSI
-PRIVATE Bool rlcAmmAddRcvdSeg
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb,
-RlcAmHdr    *amHdr,
-Buffer     *pdu,
-U16        pduSz
-)
-#else
-PRIVATE Bool rlcAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-RlcAmHdr    *amHdr;
-Buffer     *pdu;
-U16        pduSz;
-#endif
+static bool rlcAmmAddRcvdSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu, uint16_t pduSz)
 {
    RlcAmRecBuf   *recBuf = NULLP;
    RlcSeg        *seg;
    RlcSeg        *tseg;
-   U16          soEnd;       /* Holds the SoEnd of received segment */
-   U16          expSo = 0;   /* Expected SO */
-
-   TRC2(rlcAmmAddRcvdSeg)
+   uint16_t      soEnd;       /* Holds the SoEnd of received segment */
+   uint16_t      expSo = 0;   /* Expected SO */
 
    soEnd = amHdr->so + pduSz - 1;
-   recBuf =  rlcUtlGetRecBuf(AMUL.recBufLst, amHdr->sn);
+   recBuf =  rlcUtlGetRecBuf(RLC_AMUL.recBufLst, amHdr->sn);
 
    if (NULLP == recBuf)
    {
@@ -1375,23 +1180,21 @@ U16        pduSz;
 #if (ERRCLASS & ERRCLS_ADD_RES)
       if (recBuf == NULLP)
       {
-         RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
-                  "Memory allocation failed UEID:%d CELLID:%d",
-                  rbCb->rlcId.ueId,
-                  rbCb->rlcId.cellId);
+         DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
+            rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 
-         RLC_FREE_BUF(pdu);
-         return (FALSE);
+         ODU_PUT_MSG_BUF(pdu);
+         return FALSE;
       }
 #endif /* ERRCLASS & ERRCLS_RES */
-      rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
+      rlcUtlStoreRecBuf(RLC_AMUL.recBufLst, recBuf, amHdr->sn);
    }
    else
    {
       if (recBuf->allRcvd == TRUE)
       {
-         RLC_FREE_BUF(pdu);
-         return (FALSE);
+         ODU_PUT_MSG_BUF(pdu);
+         return FALSE;
       }
    }
  			
@@ -1410,16 +1213,16 @@ U16        pduSz;
    {
       /* This is a duplicate segment */
       gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
-      RLC_FREE_BUF(pdu);
-      return (FALSE);
+      ODU_PUT_MSG_BUF(pdu);
+      return FALSE;
    }
 
    if ((seg) && (seg->amHdr.so <= soEnd))
    {
       /* This is a duplicate segment */
       gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
-      RLC_FREE_BUF(pdu);
-      return (FALSE);
+      ODU_PUT_MSG_BUF(pdu);
+      return FALSE;
    }
 
    /* If we have come this far, we have to add this segment to the   */
@@ -1429,12 +1232,10 @@ U16        pduSz;
 #if (ERRCLASS & ERRCLS_ADD_RES)
    if (tseg == NULLP)
    {
-      RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, 
-               "Memory allocation failed UEID:%d CELLID:%d",
-               rbCb->rlcId.ueId,
-               rbCb->rlcId.cellId);
-      RLC_FREE_BUF(pdu);
-      return (FALSE);
+      DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
+         rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+      ODU_PUT_MSG_BUF(pdu);
+      return FALSE;
    }
 #endif /* ERRCLASS & ERRCLS_RES */
 
@@ -1454,9 +1255,9 @@ U16        pduSz;
       cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt);
    }
    tseg->lstEnt.node = (PTR)tseg;
-   rlcAmmUpdExpByteSeg(gCb,&AMUL,tseg);
+   rlcAmmUpdExpByteSeg(gCb,&RLC_AMUL,tseg);
 
-   return (TRUE);
+   return TRUE;
 }
 
 /**
@@ -1477,29 +1278,12 @@ U16        pduSz;
  *     -# FALSE
  *
  */
-#ifdef ANSI
-PRIVATE Bool rlcAmmUlPlacePduInRecBuf
-(
-RlcCb       *gCb,
-Buffer     *pdu,
-RlcUlRbCb   *rbCb,
-RlcAmHdr    *amHdr
-)
-#else
-PRIVATE Bool rlcAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr)
-RlcCb       *gCb;
-Buffer     *pdu;
-RlcUlRbCb   *rbCb;
-RlcAmHdr    *amHdr;
-#endif
+static bool rlcAmmUlPlacePduInRecBuf(RlcCb *gCb, Buffer *pdu, RlcUlRbCb *rbCb, RlcAmHdr *amHdr)
 {
    RlcSn     sn;
    MsgLen   pduSz;
    RlcAmUl   *amUl = &(rbCb->m.amUl);
 
-   TRC2(rlcAmmUlPlacePduInRecBuf)
-
-
    sn = amHdr->sn;
    SFndLenMsg(pdu, &pduSz);
 
@@ -1508,16 +1292,12 @@ RlcAmHdr    *amHdr;
    if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
    {
       gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++;
-      RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
-                    "rlcAmmUlPlacePduInRecBuf: SN  %d outside the window"
-                    "UEID:%d CELLID:%d",
-                    sn,
-                    rbCb->rlcId.ueId,
-                    rbCb->rlcId.cellId);
+      DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: SN  %d outside the window"
+         "UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 
       gCb->genSts.unexpPdusRecv++;
-      RLC_FREE_BUF(pdu);
-      return (FALSE);
+      ODU_PUT_MSG_BUF(pdu);
+      return FALSE;
    }
 
    if (amHdr->si == 0)
@@ -1533,15 +1313,13 @@ RlcAmHdr    *amHdr;
 #if (ERRCLASS & ERRCLS_ADD_RES)
          if (recBuf == NULLP)
          {
-            RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
-                     "Memory allocation failed UEID:%d CELLID:%d",
-                     rbCb->rlcId.ueId,
-                     rbCb->rlcId.cellId);
-            RLC_FREE_BUF(pdu);
-            return (FALSE);
+            DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: Memory allocation failed \
+	       UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+            ODU_PUT_MSG_BUF(pdu);
+            return FALSE;
          }
 #endif /* ERRCLASS & ERRCLS_RES */
-         rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
+         rlcUtlStoreRecBuf(RLC_AMUL.recBufLst, recBuf, sn);
       }
       else if (recBuf->allRcvd != TRUE)
       {
@@ -1551,8 +1329,8 @@ RlcAmHdr    *amHdr;
       {
          gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
          gCb->genSts.unexpPdusRecv++;
-         RLC_FREE_BUF(pdu);
-         return (FALSE);
+         ODU_PUT_MSG_BUF(pdu);
+         return FALSE;
       }
       recBuf->isDelvUpperLayer = FALSE;
       recBuf->pdu = pdu;
@@ -1560,7 +1338,7 @@ RlcAmHdr    *amHdr;
       recBuf->allRcvd = TRUE;
       gRlcStats.amRlcStats.numRlcAmCellSduRx++;
       RLC_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(RlcAmHdr));
-      return (TRUE);
+      return TRUE;
    }
    else
    {
@@ -1593,31 +1371,14 @@ RlcAmHdr    *amHdr;
  * @return  Void
  *
  */
-#ifdef ANSI
-PRIVATE Void rlcAmmTriggerStatus
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb,
-RlcSn       sn,
-Bool       discFlg
-)
-#else
-PRIVATE Void rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-RlcSn       sn;
-Bool       discFlg;
-#endif
+static void rlcAmmTriggerStatus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcSn sn, bool discFlg)
 {
-   Bool     tmrRunning;
+   bool     tmrRunning;
    RlcSn     tSn;
    RlcSn     tVrMr;
    RlcSn     trxHighestStatus;
    RlcAmUl   *amUl = &(rbCb->m.amUl);
 
-   TRC2(rlcAmmTriggerStatus)
-
-
    MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
    MODAMR(amUl->rxHighestStatus, trxHighestStatus, amUl->rxNext, amUl->snModMask);
    MODAMR(sn , tSn, amUl->rxNext, amUl->snModMask);
@@ -1626,10 +1387,8 @@ Bool       discFlg;
     * The "=" in the 2nd condition is removed */
    if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr))
    {
-      RLOG_ARG2(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, 
-               "rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
-                     rbCb->rlcId.ueId,
-                     rbCb->rlcId.cellId);
+      DU_LOG("\nRLC: rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
+         rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 
       amUl->staTrg = TRUE;
       amUl->gatherStaPduInfo = FALSE;
@@ -1643,7 +1402,7 @@ Bool       discFlg;
       }
    }
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -1664,62 +1423,46 @@ Bool       discFlg;
  * @return  Void
  *
  */
-#ifdef ANSI
-PRIVATE Void rlcAmmProcPduOrSeg
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb,
-RlcAmHdr    *amHdr,
-Buffer     *pdu
-)
-#else
-PRIVATE Void rlcAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-RlcAmHdr    *amHdr;
-Buffer     *pdu;
-#endif
+static void rlcAmmProcPduOrSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu)
 {
 
-   TRC2(rlcAmmProcPduOrSeg)
-
-   if ((AMUL.expSn != amHdr->sn) || (AMUL.expSo != amHdr->so))
+   if ((RLC_AMUL.expSn != amHdr->sn) || (RLC_AMUL.expSo != amHdr->so))
    {
       /* Release the existing partial SDU as we have PDUs or */
       /* segments that are out of sequence                   */
       rbCb->m.amUl.isOutOfSeq = TRUE;
-      RLC_FREE_BUF(AMUL.partialSdu);
+      ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
    }
 
    //if (amHdr->fi & RLC_FI_FIRST_SEG)
    if (amHdr->si == 0x01)
    {/* first Segment of the SDU */
-      if (AMUL.partialSdu != NULLP)
+      if (RLC_AMUL.partialSdu != NULLP)
       { /* Some old SDU may be present */
-         RLC_FREE_BUF_WC(AMUL.partialSdu);
+         ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
       }
-      AMUL.partialSdu = pdu;
+      RLC_AMUL.partialSdu = pdu;
       pdu = NULLP;
    }
    else if(amHdr->si == 0x03)
    {/* Middle or last segment of the SUD */
-      SCatMsg(AMUL.partialSdu,pdu, M1M2);
-      RLC_FREE_BUF_WC(pdu);
+      ODU_CAT_MSG(RLC_AMUL.partialSdu,pdu, M1M2);
+      ODU_PUT_MSG_BUF(pdu);
       pdu = NULLP;
    }
    else if (amHdr->si ==  0x02)
    {
-      SCatMsg(pdu,AMUL.partialSdu,M2M1);
-      RLC_FREE_BUF_WC(AMUL.partialSdu);
+      ODU_CAT_MSG(pdu,RLC_AMUL.partialSdu,M2M1);
+      ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
    }
 
    if (pdu != NULLP)
    {
-      AMUL.partialSdu = NULLP;
-      rlcUtlSndDatInd(gCb,rbCb, pdu);
+      RLC_AMUL.partialSdu = NULLP;
+      rlcUtlSendUlDataToDu(gCb,rbCb, pdu);
    }
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -1742,23 +1485,10 @@ Buffer     *pdu;
  *      -# RFAILED
  *
  */
-#ifdef ANSI
-PRIVATE S16 rlcAmmUlReassembleSdus
-(
-RlcCb         *gCb,
-RlcUlRbCb     *rbCb,
-RlcAmRecBuf   *recBuf
-)
-#else
-PRIVATE S16 rlcAmmUlReassembleSdus(gCb, rbCb, recBuf)
-RlcCb         *gCb;
-RlcUlRbCb     *rbCb;
-RlcAmRecBuf   *recBuf;
-#endif
+static uint8_t rlcAmmUlReassembleSdus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmRecBuf *recBuf)
 {
    RlcSeg        *seg;
 
-   TRC2(rlcAmmUlReassembleSdus)
    //if (recBuf->amHdr.rf == 0)
    if (recBuf->amHdr.si == 0)
    {
@@ -1766,27 +1496,27 @@ RlcAmRecBuf   *recBuf;
       rlcAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
       /* Assign NULLP to recBuf->pdu as this PDU is sent to PDCP */
       recBuf->pdu = NULLP;
-      AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
-      AMUL.expSo = 0;
+      RLC_AMUL.expSn = (recBuf->amHdr.sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
+      RLC_AMUL.expSo = 0;
    }
    else
    {
       /* This is a set of segments */
       RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
-      AMUL.expSn = recBuf->amHdr.sn;
-      AMUL.expSo = 0;
+      RLC_AMUL.expSn = recBuf->amHdr.sn;
+      RLC_AMUL.expSo = 0;
       while(seg)
       {
          rlcAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
-         AMUL.expSo = seg->soEnd + 1;
+         RLC_AMUL.expSo = seg->soEnd + 1;
 
          cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
-         RLC_FREE_WC(gCb, seg, sizeof(RlcSeg));
+         RLC_FREE(gCb, seg, sizeof(RlcSeg));
 
          RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
       }
-      AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
-      AMUL.expSo = 0;
+      RLC_AMUL.expSn = (recBuf->amHdr.sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
+      RLC_AMUL.expSo = 0;
    }
 
    return ROK;
@@ -1803,21 +1533,7 @@ RlcAmRecBuf   *recBuf;
  * @return  Void
  *
  */
-#ifdef ANSI
-Void rlcAmmUlReEstablish
-(
-RlcCb         *gCb,
-CmLteRlcId   rlcId,
-Bool         sendReEst,
-RlcUlRbCb     *rbCb
-)
-#else
-Void rlcAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
-RlcCb         *gCb;
-CmLteRlcId   rlcId;
-Bool         sendReEst;
-RlcUlRbCb     *rbCb;
-#endif
+Void rlcAmmUlReEstablish(RlcCb *gCb,CmLteRlcId rlcId,Bool sendReEst,RlcUlRbCb  *rbCb)
 {
    RlcSn   sn;
    RlcSn   mSn;
@@ -1828,18 +1544,15 @@ RlcUlRbCb     *rbCb;
 #endif
    RlcAmRecBuf   *recBuf = NULLP;
 
-   TRC2(rlcAmmUlReEstablish);
-
+   sn = RLC_AMUL.rxNext;
 
-   sn = AMUL.rxNext;
-
-   MODAMR(AMUL.vrMr, mVrMr, AMUL.rxNext, AMUL.snModMask);
-   MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
+   MODAMR(RLC_AMUL.vrMr, mVrMr, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
+   MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
 
    /* Reassemble SDUs from PDUs with SN less than upper edge of the window */
    while (mSn < mVrMr)
    {
-      recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
+      recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
       if (NULLP != recBuf)
       {
          if (recBuf->allRcvd == TRUE)
@@ -1851,15 +1564,15 @@ RlcUlRbCb     *rbCb;
             /* Remove PDU and segments */
             if(recBuf->pdu)
             {
-               RLC_FREE_BUF_WC(recBuf->pdu);
+               ODU_PUT_MSG_BUF(recBuf->pdu);
             }
             /* Release all the segments*/
             rlcAmmUlRlsAllSegs(gCb,recBuf);
          }
-         rlcUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb);
+         rlcUtlDelRecBuf(RLC_AMUL.recBufLst, recBuf, gCb);
       }
-      sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */
-      MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
+      sn = (sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
+      MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
    }
    /* Discard remaining PDUs and bytesegments in recBuf */
 
@@ -1873,18 +1586,18 @@ RlcUlRbCb     *rbCb;
        rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
    }
 
-   AMUL.rxNext  = 0;
-   AMUL.rxNextHighestRcvd  = 0;
-   AMUL.rxNextStatusTrig  = 0;
+   RLC_AMUL.rxNext  = 0;
+   RLC_AMUL.rxNextHighestRcvd  = 0;
+   RLC_AMUL.rxNextStatusTrig  = 0;
    rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
-   AMUL.rxHighestStatus = 0;
-   AMUL.staTrg  = FALSE;
-   AMUL.gatherStaPduInfo = FALSE;
-   AMUL.expSn = 0;
-   AMUL.expSo = 0;
-   if (AMUL.partialSdu != NULLP)
+   RLC_AMUL.rxHighestStatus = 0;
+   RLC_AMUL.staTrg  = FALSE;
+   RLC_AMUL.gatherStaPduInfo = FALSE;
+   RLC_AMUL.expSn = 0;
+   RLC_AMUL.expSo = 0;
+   if (RLC_AMUL.partialSdu != NULLP)
    {
-     RLC_FREE_BUF(AMUL.partialSdu);
+     ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
    }
    rlcKwuSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
 
@@ -1894,7 +1607,7 @@ RlcUlRbCb     *rbCb;
       rbCb->m.amUl.isOutOfSeq = FALSE;
    }
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -1910,17 +1623,7 @@ RlcUlRbCb     *rbCb;
  *
  */
 
-#ifdef ANSI
-Void rlcAmmReOrdTmrExp
-(
-RlcCb        *gCb,
-RlcUlRbCb    *rbCb
-)
-#else
-Void rlcAmmReOrdTmrExp(rbCb)
-RlcCb        *gCb;
-RlcUlRbCb    *rbCb;
-#endif
+Void rlcAmmReOrdTmrExp(RlcCb *gCb,RlcUlRbCb *rbCb)
 {
    RlcAmUl *amUl = &(rbCb->m.amUl);
    RlcSn sn;
@@ -1931,15 +1634,12 @@ RlcUlRbCb    *rbCb;
    Bool tmrRunning = FALSE;
    RlcAmRecBuf   *recBuf = NULLP;
 
-   TRC2(rlcAmmReOrdTmrExp);
-
-
    /* Update rxHighestStatus */
    sn = amUl->rxNextStatusTrig;
 
    MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
    MODAMR(amUl->vrMr, mVrMr, amUl->rxNext, amUl->snModMask);
-   recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
+   recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
 
    while (mSn < mVrMr)
    {
@@ -1975,7 +1675,7 @@ RlcUlRbCb    *rbCb;
       amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
    }
 
-   RETVOID;
+   return;
 } /* rlcAmmReOrdTmrExp */
 
 /**
@@ -1992,23 +1692,10 @@ RlcUlRbCb    *rbCb;
  *
  */
 
-#ifdef ANSI
-Void rlcAmmStaProTmrExp
-(
-RlcCb        *gCb,
-RlcUlRbCb    *rbCb
-)
-#else
-Void rlcAmmStaProTmrExp(gCb, rbCb)
-RlcCb        *gCb;
-RlcUlRbCb    *rbCb;
-#endif
+Void rlcAmmStaProTmrExp(RlcCb *gCb,RlcUlRbCb *rbCb)
 {
    RlcAmUl *amUl = &(rbCb->m.amUl);
 
-   TRC2(rlcAmmStaProTmrExp);
-
-
    amUl->gatherStaPduInfo = FALSE;
 
    if (amUl->staTrg == TRUE)
@@ -2018,7 +1705,7 @@ RlcUlRbCb    *rbCb;
       rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
    }
 
-   RETVOID;
+   return;
 } /* rlcAmmStaProTmrExp */
 
 /**
@@ -2034,37 +1721,23 @@ RlcUlRbCb    *rbCb;
  *
  */
 
-#ifdef ANSI
-PRIVATE Void rlcAmmExtractElmnt
-(
-RlcCb       *gCb,
-Buffer     *pdu,
-RlcExtHdr   *hdrInfo
-)
-#else
-PRIVATE Void rlcAmmExtractElmnt(gCb, pdu, hdrInfo)
-RlcCb       *gCb;
-Buffer     *pdu;
-RlcExtHdr   *hdrInfo;
-#endif
+static void rlcAmmExtractElmnt(RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo)
 {
-   U8   hdr;
-   U8   pLen = hdrInfo->pLen;
-   U8   len  = (U8)hdrInfo->len;
-   U32  val;
-   U8   tHdr;
-   U8   fLen;
-   U8   rLen;
-   /* U8   rLen1 = 0; */
-   U16  tVal;
-
-   TRC2(rlcAmmExtractElmnt);
+   uint8_t   hdr;
+   uint8_t   pLen = hdrInfo->pLen;
+   uint8_t   len  = (uint8_t)hdrInfo->len;
+   uint32_t  val;
+   uint8_t   tHdr;
+   uint8_t   fLen;
+   uint8_t   rLen;
+   /* uint8_t   rLen1 = 0; */
+   uint16_t  tVal;
 
    hdr = hdrInfo->hdr;
 
    if (pLen == 0)
    {
-      SRemPreMsg(&hdr, pdu);
+      ODU_REM_PRE_MSG(&hdr, pdu);
       pLen = 8;
    }
    tHdr = hdr;
@@ -2081,7 +1754,7 @@ RlcExtHdr   *hdrInfo;
       val = val >> (RLC_BYTE_LEN - fLen);
       val = val << (len - fLen);
       rLen = len - fLen;
-      SRemPreMsg(&hdr, pdu);
+      ODU_REM_PRE_MSG(&hdr, pdu);
       tHdr = hdr;
       if (rLen <= 8)
       {
@@ -2097,7 +1770,7 @@ RlcExtHdr   *hdrInfo;
         tVal = tVal << rLen;
         val = val | tVal;
 
-        SRemPreMsg(&hdr, pdu);
+        ODU_REM_PRE_MSG(&hdr, pdu);
         tHdr = hdr;
         hdr = hdr >> (RLC_BYTE_LEN - rLen);
         val = val | hdr;
@@ -2110,7 +1783,7 @@ RlcExtHdr   *hdrInfo;
    hdrInfo->hdr = hdr;
    hdrInfo->val = val;
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -2131,32 +1804,17 @@ RlcExtHdr   *hdrInfo;
  *
  */
 
-#ifdef ANSI
-PRIVATE Void rlcAmmUpdExpByteSeg
-(
-RlcCb     *gCb,
-RlcAmUl   *amUl,
-RlcSeg    *seg
-)
-#else
-PRIVATE Void rlcAmmUpdExpByteSeg(gCb, amUl, seg)
-RlcCb     *gCb;
-RlcAmUl   *amUl;
-RlcSeg    *seg;
-#endif
+static void rlcAmmUpdExpByteSeg(RlcCb *gCb, RlcAmUl *amUl, RlcSeg *seg)
 {
-   U16    newExpSo; /* The new expected SO */
-   RlcSn   sn = seg->amHdr.sn;
-   Bool   lstRcvd=FALSE;
+   uint16_t  newExpSo; /* The new expected SO */
+   RlcSn     sn = seg->amHdr.sn;
+   bool      lstRcvd=FALSE;
    RlcAmRecBuf *recBuf = NULLP;
    
-   TRC2(rlcAmmUpdExpByteSeg);
-
-
    recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
    if ((recBuf == NULLP) || (recBuf && (seg->amHdr.so != recBuf->expSo)))
    {
-      RETVOID;
+      return;
    }
 
    newExpSo   = seg->soEnd + 1;
@@ -2186,7 +1844,7 @@ RlcSeg    *seg;
       else
       {
          recBuf->expSo = newExpSo;
-         RETVOID;
+         return;
       }
    }
    if (lstRcvd == TRUE)
@@ -2195,7 +1853,7 @@ RlcSeg    *seg;
       gRlcStats.amRlcStats.numRlcAmCellSduRx++;
    }
 
-   RETVOID;
+   return;
 }
 
 /**
@@ -2211,25 +1869,12 @@ RlcSeg    *seg;
  *
  * @return   void
  */
-#ifdef ANSI
-Void rlcAmmFreeUlRbCb
-(
-RlcCb       *gCb,
-RlcUlRbCb   *rbCb
-)
-#else
-Void rlcAmmFreeUlRbCb(gCb,rbCb)
-RlcCb       *gCb;
-RlcUlRbCb   *rbCb;
-#endif
+Void rlcAmmFreeUlRbCb(RlcCb       *gCb,RlcUlRbCb   *rbCb)
 {
    RlcSn         curSn = 0;           /* Sequence number of PDU */
    RlcSn         windSz;              /* PDU window size */
    RlcAmRecBuf *recBuf = NULLP;
 
-   TRC2(rlcAmmFreeUlRbCb)
-
-
    windSz  =  (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
 
    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
@@ -2251,7 +1896,7 @@ RlcUlRbCb   *rbCb;
       {
          if (recBuf->pdu != NULLP)
          {
-            RLC_FREE_BUF_WC(recBuf->pdu);
+            ODU_PUT_MSG_BUF(recBuf->pdu);
          }
          /* Release all the segments */
          rlcAmmUlRlsAllSegs(gCb,recBuf);
@@ -2261,15 +1906,15 @@ RlcUlRbCb   *rbCb;
    }while ( curSn < windSz );
 
 #ifndef LTE_TDD 
-      RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+      RLC_FREE(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
       rbCb->m.amUl.recBufLst = NULLP;
 #endif
 
    if(rbCb->m.amUl.partialSdu != NULLP)
    {
-      RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
+      ODU_PUT_MSG_BUF(rbCb->m.amUl.partialSdu);
    }
-   RETVOID;
+   return;
 } /* rlcAmmFreeUlRbCb */