X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_umm_ul.c;h=8c4f897705cea73d85fcdca7bf3cad2bdccc141d;hb=0a26c487f1b6bbb5217e47b15fa8273b2e749283;hp=2f6755ed852c492d40024b2be4f6ebc0f805a32f;hpb=105199ef642ffe9736ea24a01d4546578fa25e60;p=o-du%2Fl2.git

diff --git a/src/5gnrrlc/kw_umm_ul.c b/src/5gnrrlc/kw_umm_ul.c
index 2f6755ed8..8c4f89770 100755
--- a/src/5gnrrlc/kw_umm_ul.c
+++ b/src/5gnrrlc/kw_umm_ul.c
@@ -25,10 +25,10 @@
      Desc:     Source code for RLC Unacknowledged mode assembly and
                reassembly.This file contains following functions
 
-                  --kwUmmQSdu
-                  --kwUmmProcessSdus
-                  --kwUmmProcessPdus
-                  --kwUmmReAssembleSdus
+                  --rlcUmmQSdu
+                  --rlcUmmProcessSdus
+                  --rlcUmmProcessPdus
+                  --rlcUmmReAssembleSdus
                   --kwUmmReEstablish 
 
      File:     kw_umm_ul.c
@@ -67,16 +67,16 @@ static int RLOG_FILE_ID=240;
 #include "kw.x"                 /* RLC layer */
 #include "kw_ul.x"
 
-#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_UL)
+#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_UL)
 
-PRIVATE S16 kwUmmExtractHdr ARGS ((KwCb *gCb, 
-                                   KwUlRbCb *rbCb,
+PRIVATE S16 rlcUmmExtractHdr ARGS ((RlcCb *gCb, 
+                                   RlcUlRbCb *rbCb,
                                    Buffer *pdu,
-                                   KwUmHdr *umHdr));
+                                   RlcUmHdr *umHdr));
 
-PRIVATE Void kwUmmReAssembleSdus ARGS ((KwCb *gCb,
-                                        KwUlRbCb *rbCb,
-                                        KwUmRecBuf *umRecBuf));
+PRIVATE Void rlcUmmReAssembleSdus ARGS ((RlcCb *gCb,
+                                        RlcUlRbCb *rbCb,
+                                        RlcUmRecBuf *umRecBuf));
 
 #ifndef TENB_ACC
 #ifndef LTE_PAL_ENB
@@ -96,11 +96,11 @@ extern U32 isMemThreshReached(Region region);
  *
  * @return  Void
 */ 
-PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn)
+PRIVATE Void rlcUmmFindNextVRUR (RlcUmUl* umUl, RlcSn nextSn)
 {
-   KwSn ur = KW_UM_GET_VALUE(umUl->vrUr, *umUl);
+   RlcSn ur = RLC_UM_GET_VALUE(umUl->vrUr, *umUl);
    
-   KwSn nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl);
+   RlcSn nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
    
    while (ur < nextSnToCompare)
    {
@@ -110,7 +110,7 @@ PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn)
          break;
       }
       nextSn = (nextSn + 1) & umUl->modBitMask; 
-      nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl);
+      nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
    }
 }
 
@@ -127,10 +127,10 @@ PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn)
  *
  * @return  Void
 */
-PRIVATE S16 kwUmmCheckSnInReordWindow (KwSn sn, 
-                                       CONSTANT KwUmUl* CONSTANT umUl)  
+PRIVATE S16 rlcUmmCheckSnInReordWindow (RlcSn sn, 
+                                       CONSTANT RlcUmUl* CONSTANT umUl)  
 {
-   return (KW_UM_GET_VALUE(sn, *umUl) < KW_UM_GET_VALUE(umUl->vrUh, *umUl)); 
+   return (RLC_UM_GET_VALUE(sn, *umUl) < RLC_UM_GET_VALUE(umUl->vrUh, *umUl)); 
 }
 
 /**
@@ -152,48 +152,48 @@ PRIVATE S16 kwUmmCheckSnInReordWindow (KwSn sn,
 #ifdef LTE_L2_MEAS
 
 #ifdef ANSI
-PUBLIC Void kwUmmProcessPdus
+Void rlcUmmProcessPdus
 (
-KwCb      *gCb,
-KwUlRbCb  *rbCb,                   /* Rb Control Block */
+RlcCb      *gCb,
+RlcUlRbCb  *rbCb,                   /* Rb Control Block */
 KwPduInfo *pduInfo,                 /* Pdu  data and related information */
 U32       ttiCnt                  /* ttiCnt received from MAC */
 )
 #else
-PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo,ttiCnt)
-KwCb      *gCb;
-KwUlRbCb  *rbCb;                   /* Rb Control Block */
+Void rlcUmmProcessPdus(rbCb,pduInfo,ttiCnt)
+RlcCb      *gCb;
+RlcUlRbCb  *rbCb;                   /* Rb Control Block */
 KwPduInfo *pduInfo;                /* Pdu  data and related information */
 U32       ttiCnt;                  /* ttiCnt received from MAC */
 #endif
 #else
 #ifdef ANSI
-PUBLIC Void kwUmmProcessPdus
+Void rlcUmmProcessPdus
 (
-KwCb      *gCb,
-KwUlRbCb  *rbCb,                /* Rb Control Block */
+RlcCb      *gCb,
+RlcUlRbCb  *rbCb,                /* Rb Control Block */
 KwPduInfo *pduInfo              /* Pdu  data and related information */
 )
 #else
-PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo)
-KwCb      *gCb;
-KwUlRbCb  *rbCb;                /* Rb Control Block */
+Void rlcUmmProcessPdus(rbCb,pduInfo)
+RlcCb      *gCb;
+RlcUlRbCb  *rbCb;                /* Rb Control Block */
 KwPduInfo *pduInfo;             /* Pdu  data and related information */
 #endif
 #endif
 {
-   KwSn          *vrUh;      /* vr(uh) */
-   KwSn          *vrUr;      /* vr(ur) */
-   KwSn         *vrUx;      /* vr(ux) */
+   RlcSn          *vrUh;      /* vr(uh) */
+   RlcSn          *vrUr;      /* vr(ur) */
+   RlcSn         *vrUx;      /* vr(ux) */
    U16          curSn;      /* Current Sequence Number */
    U32          pduCount;   /* PDU count */
    U32          count;      /* Loop counter */
-   KwUmRecBuf   **recBuf;   /* UM Reception Buffer */
+   RlcUmRecBuf   **recBuf;   /* UM Reception Buffer */
 
    Bool         tmrRunning;   /* Boolean for checking Tmr */
 /* kw005.201 added support for L2 Measurement */
 
-   TRC2(kwUmmProcessPdus)
+   TRC2(rlcUmmProcessPdus)
 
 
    count = 0;
@@ -208,11 +208,11 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
 
    while (count < pduCount)
    {
-      KwSn   ur; 
-      KwSn   uh; 
-      KwSn   seqNum;
+      RlcSn   ur; 
+      RlcSn   uh; 
+      RlcSn   seqNum;
       Buffer *pdu = pduInfo->mBuf[count];
-      KwUmRecBuf *tmpRecBuf;
+      RlcUmRecBuf *tmpRecBuf;
       gCb->genSts.pdusRecv++;
 #ifndef RGL_SPECIFIC_CHANGES
 #ifndef TENB_ACC
@@ -225,7 +225,7 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
 #endif      
 #endif      
       /* create a buffer to be later inserted into the reception buffer */
-      KW_ALLOC_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+      RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
 #if (ERRCLASS & ERRCLS_ADD_RES)
       if (tmpRecBuf == NULLP)
       {   
@@ -244,12 +244,12 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
 #ifndef LTE_PAL_ENB
     /* Changed the condition to TRUE from ROK  */
 #ifndef XEON_SPECIFIC_CHANGES    
-     if(isMemThreshReached(kwCb[0]->init.region) == TRUE)
+     if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
      {
         extern U32 rlculdrop;
         rlculdrop++;
-        KW_FREE_BUF(pdu);
-        KW_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+        RLC_FREE_BUF(pdu);
+        RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
         /*Fix for CR ccpu00144030: If threshhold is hit then also count
          *should be incrmented */
         count++;
@@ -260,7 +260,7 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
 #endif
 #endif
       /* get the pdu header */
-      if (kwUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))  
+      if (rlcUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))  
       {
          RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId,
                   "Header Extraction Failed UEID:%d CELLID:%d",
@@ -270,7 +270,7 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
          /* Header extraction is a problem. 
           * log an error and free the allocated memory */
          /* ccpu00136940 */
-         KW_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+         RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
          SPutMsg(pdu);
          count++;
          /* kw005.201 ccpu00117318, updating the statistics */
@@ -280,11 +280,11 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
       curSn = tmpRecBuf->umHdr.sn;
 
       /* Check if the PDU should be discarded or not */
-      ur = KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL); 
-      uh = KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL); 
-      seqNum = KW_UM_GET_VALUE(curSn, KW_UMUL); 
+      ur = RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL); 
+      uh = RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL); 
+      seqNum = RLC_UM_GET_VALUE(curSn, RLC_UMUL); 
 
-      if (((ur < seqNum) && (seqNum < uh) && (KW_UMUL.recBuf[curSn])) || 
+      if (((ur < seqNum) && (seqNum < uh) && (RLC_UMUL.recBuf[curSn])) || 
           (seqNum < ur)) 
       {
          /* PDU needs to be discarded */
@@ -294,8 +294,8 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
                   rbCb->rlcId.ueId,
                   rbCb->rlcId.cellId);
 
-         KW_FREE_BUF(pdu);
-         KW_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf));
+         RLC_FREE_BUF(pdu);
+         RLC_FREE_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
          count++;
          /* kw005.201 ccpu00117318, updating the statistics */
          gCb->genSts.unexpPdusRecv++;
@@ -306,7 +306,7 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
 #ifdef LTE_L2_MEAS
 
       /* kw006.201 ccpu00120058, reduced code complexity by adding new function */
-      kwUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
+      rlcUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
 
 #endif 
 
@@ -317,89 +317,89 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
       /* kw005.201 ccpu00117318, updating the statistics */
       gCb->genSts.bytesRecv += recBuf[curSn]->pduSz;
       
-      if (!kwUmmCheckSnInReordWindow(curSn,&KW_UMUL))
+      if (!rlcUmmCheckSnInReordWindow(curSn,&RLC_UMUL))
       {  /* currSn is outside re-ordering window */
-         *vrUh  = (curSn + 1) & KW_UMUL.modBitMask;
+         *vrUh  = (curSn + 1) & RLC_UMUL.modBitMask;
 
          /* re-assemble all pdus outside the modified re-ordering window */
          /* the first SN is VR(UR) */
-         if (!kwUmmCheckSnInReordWindow(*vrUr,&KW_UMUL))
+         if (!rlcUmmCheckSnInReordWindow(*vrUr,&RLC_UMUL))
          {
             /* TODO : should it be VR(UR) + 1 ?... check, earlier it was so */
-            KwSn sn = *vrUr; /* SN's which need to be re-assembled */
-            KwSn lowerEdge;  /* to hold the lower-edge of the 
+            RlcSn sn = *vrUr; /* SN's which need to be re-assembled */
+            RlcSn lowerEdge;  /* to hold the lower-edge of the 
                                 re-ordering window */
 
             /* The new value ov VR(UR) is the lower end of the window i
              * and SN's still this value need to be re-assembled */
             
-            *vrUr = (*vrUh - KW_UMUL.umWinSz) &  KW_UMUL.modBitMask;         
-            lowerEdge = KW_UM_GET_VALUE(*vrUr ,KW_UMUL);
+            *vrUr = (*vrUh - RLC_UMUL.umWinSz) &  RLC_UMUL.modBitMask;         
+            lowerEdge = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
             
-            while (KW_UM_GET_VALUE(sn, KW_UMUL) < lowerEdge)
+            while (RLC_UM_GET_VALUE(sn, RLC_UMUL) < lowerEdge)
             {
                if (recBuf[sn])
                {
-                  kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
-                  KW_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+                  rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
+                  RLC_FREE_WC(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
                   recBuf[sn] = NULLP;
                }
-               sn = (sn + 1) & KW_UMUL.modBitMask;
+               sn = (sn + 1) & RLC_UMUL.modBitMask;
             }
          }
       }
       if (recBuf[*vrUr])
       {
-         KwSn sn       = *vrUr;
-         KwSn tSn      = KW_UM_GET_VALUE(sn,KW_UMUL); 
-         KwSn tVrUr;       
+         RlcSn sn       = *vrUr;
+         RlcSn tSn      = RLC_UM_GET_VALUE(sn,RLC_UMUL); 
+         RlcSn tVrUr;       
 
          /* set VR(UR) to next SN > current VR(UR) which is not received */
-         KwSn nextVrUr = (*vrUr + 1) & KW_UMUL.modBitMask;
-         kwUmmFindNextVRUR(&KW_UMUL, nextVrUr);
+         RlcSn nextVrUr = (*vrUr + 1) & RLC_UMUL.modBitMask;
+         rlcUmmFindNextVRUR(&RLC_UMUL, nextVrUr);
 
          /* re-assemble SDUs with SN < Vr(UR) */
-         tVrUr = KW_UM_GET_VALUE(*vrUr,KW_UMUL);
+         tVrUr = RLC_UM_GET_VALUE(*vrUr,RLC_UMUL);
          while (recBuf[sn] && tSn < tVrUr)
          {
-            kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
-            KW_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf));
+            rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
+            RLC_FREE_WC(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
             recBuf[sn] = NULLP;
-            sn = (sn + 1) & KW_UMUL.modBitMask;
-            tSn = KW_UM_GET_VALUE(sn, KW_UMUL);
+            sn = (sn + 1) & RLC_UMUL.modBitMask;
+            tSn = RLC_UM_GET_VALUE(sn, RLC_UMUL);
          }
       }
 
-      tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_UMUL_REORD_TMR);
+      tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_UMUL_REORD_TMR);
 
       if (tmrRunning) 
       {
-         KwSn tVrUx = KW_UM_GET_VALUE(*vrUx, KW_UMUL);
-         KwSn tVrUr = KW_UM_GET_VALUE(*vrUr ,KW_UMUL);
+         RlcSn tVrUx = RLC_UM_GET_VALUE(*vrUx, RLC_UMUL);
+         RlcSn tVrUr = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
 
-         KwSn tVrUh = KW_UM_GET_VALUE(*vrUh, KW_UMUL);
+         RlcSn tVrUh = RLC_UM_GET_VALUE(*vrUh, RLC_UMUL);
 
-         S16 ret = kwUmmCheckSnInReordWindow(*vrUx, &KW_UMUL);
+         S16 ret = rlcUmmCheckSnInReordWindow(*vrUx, &RLC_UMUL);
 
          if ( (tVrUx <= tVrUr) || ((!ret) && (tVrUx != tVrUh))) 
          {
-            kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+            rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
             tmrRunning = FALSE;
          }
       }
 
       if (!tmrRunning)
       {
-         if (KW_UM_GET_VALUE(*vrUh, KW_UMUL) > KW_UM_GET_VALUE(*vrUr, KW_UMUL))
+         if (RLC_UM_GET_VALUE(*vrUh, RLC_UMUL) > RLC_UM_GET_VALUE(*vrUr, RLC_UMUL))
          {
-            kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR); 
+            rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR); 
             *vrUx = *vrUh;
          }
       }
       count++;
    }/* end while count < pduCount */
 #ifdef LTE_L2_MEAS
-   kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
+   rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
 #endif /* LTE_L2_MEAS */
    RETVOID;   
 }
@@ -418,17 +418,17 @@ KwPduInfo *pduInfo;             /* Pdu  data and related information */
  * @return  Void
 */
 #ifdef ANSI
-PRIVATE Void kwUmmReAssembleSdus
+PRIVATE Void rlcUmmReAssembleSdus
 (
-KwCb         *gCb,
-KwUlRbCb     *rbCb,   
-KwUmRecBuf   *umRecBuf 
+RlcCb         *gCb,
+RlcUlRbCb     *rbCb,   
+RlcUmRecBuf   *umRecBuf 
 )
 #else
-PRIVATE Void kwUmmReAssembleSdus(gCb,rbCb,umRecBuf)
-KwCb         *gCb;
-KwUlRbCb     *rbCb;     
-KwUmRecBuf   *umRecBuf; 
+PRIVATE Void rlcUmmReAssembleSdus(gCb,rbCb,umRecBuf)
+RlcCb         *gCb;
+RlcUlRbCb     *rbCb;     
+RlcUmRecBuf   *umRecBuf; 
 #endif
 {
    U32      liCount;        /* LI count */
@@ -440,7 +440,7 @@ KwUmRecBuf   *umRecBuf;
    Buffer   *remPdu;        /* Remaining PDU */
    Buffer   **partialSdu;   /* Partial SDU */
 
-   TRC2(kwUmmReAssembleSdus)  
+   TRC2(rlcUmmReAssembleSdus)  
 
 
    liCount = umRecBuf->umHdr.numLi;
@@ -494,10 +494,10 @@ KwUmRecBuf   *umRecBuf;
                 (sn == ((rbCb->m.umUl.sn + 1) & rbCb->m.umUl.modBitMask)))
             {
                SCatMsg(*partialSdu,sdu,M1M2);
-               KW_FREE_BUF(sdu);
+               RLC_FREE_BUF(sdu);
                if (liCount > 0 || !(fi & 1))
                {
-                  kwUtlSndDatInd(gCb,rbCb,*partialSdu);
+                  rlcUtlSndDatInd(gCb,rbCb,*partialSdu);
                   *partialSdu = NULLP;
                }
             }
@@ -506,11 +506,11 @@ KwUmRecBuf   *umRecBuf;
                 /* Partial Sdu stored is not valid now.So free it */
                if (*partialSdu)
                {
-                  KW_FREE_BUF(*partialSdu);
+                  RLC_FREE_BUF(*partialSdu);
                   *partialSdu = NULLP;
                }
                   
-               KW_FREE_BUF(sdu);
+               RLC_FREE_BUF(sdu);
                sdu = NULLP;
             }
          }
@@ -518,13 +518,13 @@ KwUmRecBuf   *umRecBuf;
          {
             if (*partialSdu)
             {
-               KW_FREE_BUF(*partialSdu);  /* RLC mem leak fix */
+               RLC_FREE_BUF(*partialSdu);  /* RLC mem leak fix */
                *partialSdu = NULLP;
             }
             
             if (liCount > 0 || !( fi & 1))
             {
-               kwUtlSndDatInd(gCb,rbCb,sdu);
+               rlcUtlSndDatInd(gCb,rbCb,sdu);
             }
             else
             {
@@ -545,7 +545,7 @@ KwUmRecBuf   *umRecBuf;
          }
          else
          {
-            kwUtlSndDatInd(gCb, rbCb, sdu);
+            rlcUtlSndDatInd(gCb, rbCb, sdu);
          }
       }
       /*  
@@ -553,7 +553,7 @@ KwUmRecBuf   *umRecBuf;
          just send the SDU to the upper layer */
       else
       {
-         kwUtlSndDatInd(gCb, rbCb, sdu);
+         rlcUtlSndDatInd(gCb, rbCb, sdu);
       }
    }
    rbCb->m.umUl.sn = sn;
@@ -570,7 +570,7 @@ KwUmRecBuf   *umRecBuf;
  *       - If direction of the RB is downlink : 
  *         Remove all the SDUs in the SDU queue.
  *       - If direction of the RB is uplink   : 
- *         Call kwUmmReAssembleSdus() for each PDU with SN < VR(UH)
+ *         Call rlcUmmReAssembleSdus() for each PDU with SN < VR(UH)
  *
  * @param[in] gCb        RLC Instance control block
  * @param[in] rlcID      Identity of the RLC entity for which 
@@ -581,42 +581,42 @@ KwUmRecBuf   *umRecBuf;
  * @return  Void
 */ 
 #ifdef ANSI
-PUBLIC Void kwUmmUlReEstablish
+Void rlcUmmUlReEstablish
 (
-KwCb         *gCb,
+RlcCb         *gCb,
 CmLteRlcId   *rlcId,
-KwUlRbCb     *rbCb
+RlcUlRbCb     *rbCb
 )
 #else
-PUBLIC Void kwUmmUlReEstablish(gCb, rlcId, rbCb)
-KwCb         *gCb;
+Void rlcUmmUlReEstablish(gCb, rlcId, rbCb)
+RlcCb         *gCb;
 CmLteRlcId   *rlcId;
-KwUlRbCb     *rbCb;
+RlcUlRbCb     *rbCb;
 #endif
 {
-   KwSn         curSn;
-   KwSn         vrUh;
-   KwUmRecBuf   **recBuf;   /* UM Reception Buffer */
-   KwKwuSapCb   *kwKwSap;   /* KWU SAP Information */
+   RlcSn         curSn;
+   RlcSn         vrUh;
+   RlcUmRecBuf   **recBuf;   /* UM Reception Buffer */
+   RlcKwuSapCb   *rlcKwSap;   /* KWU SAP Information */
 
-   TRC2(kwUmmUlReEstablish)
+   TRC2(rlcUmmUlReEstablish)
 
 
    curSn = rbCb->m.umUl.vrUr;
-   vrUh  = KW_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
+   vrUh  = RLC_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
    recBuf =  rbCb->m.umUl.recBuf;
 
-   if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR))
+   if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
    {
-       kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+       rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
    }
    
-   while (KW_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
+   while (RLC_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
    {
       if ( recBuf[curSn] != NULLP )
       {
-         kwUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
-         KW_FREE_WC(gCb,recBuf[curSn],sizeof(KwUmRecBuf));
+         rlcUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
+         RLC_FREE_WC(gCb,recBuf[curSn],sizeof(RlcUmRecBuf));
          recBuf[curSn] = NULLP;
       } 
       curSn = (curSn + 1) & rbCb->m.umUl.modBitMask;
@@ -625,10 +625,10 @@ KwUlRbCb     *rbCb;
    rbCb->m.umUl.vrUh = 0;
    rbCb->m.umUl.vrUx = 0;
 
-   kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP;
+   rlcKwSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
 
    /* In the UM Mode always send reestablish-indication to Upper Latyer*/
-   KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, *rlcId);
+   RlcUiKwuReEstCmpInd(&rlcKwSap->pst, rlcKwSap->suId, *rlcId);
 
    RETVOID;
 }
@@ -651,19 +651,19 @@ KwUlRbCb     *rbCb;
  *      -# FALSE
 */
 #ifdef ANSI
-PRIVATE S16 kwUmmExtractHdr
+PRIVATE S16 rlcUmmExtractHdr
 (
-KwCb       *gCb,
-KwUlRbCb   *rbCb, 
+RlcCb       *gCb,
+RlcUlRbCb   *rbCb, 
 Buffer     *pdu, 
-KwUmHdr    *umHdr 
+RlcUmHdr    *umHdr 
 )
 #else
-PRIVATE S16 kwUmmExtractHdr(gCb, rbCb, pdu, umHdr)
-KwCb       *gCb;
-KwUlRbCb   *rbCb; 
+PRIVATE S16 rlcUmmExtractHdr(gCb, rbCb, pdu, umHdr)
+RlcCb       *gCb;
+RlcUlRbCb   *rbCb; 
 Buffer     *pdu; 
-KwUmHdr    *umHdr; 
+RlcUmHdr    *umHdr; 
 #endif
 {
    U8        e;         /* Extension Bit */
@@ -674,7 +674,7 @@ KwUmHdr    *umHdr;
    S16       ret;       /* Return Value */
 #endif
 
-   TRC3(kwUmmExtractHdr)
+   TRC3(rlcUmmExtractHdr)
 
 
    SFndLenMsg(pdu,&pduSz);
@@ -690,7 +690,7 @@ KwUmHdr    *umHdr;
                   rbCb->rlcId.ueId,
                   rbCb->rlcId.cellId);
 
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
 #else
       SRemPreMsg(dst,pdu);
@@ -711,7 +711,7 @@ KwUmHdr    *umHdr;
                   "SRemPreMsgMult Failed for 10 bits SN UEID:%d CELLID:%d",
                   rbCb->rlcId.ueId,
                   rbCb->rlcId.cellId);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
 #else
       SRemPreMsgMult(dst,2,pdu);
@@ -731,7 +731,7 @@ KwUmHdr    *umHdr;
    umHdr->numLi = 0;
    
    totalSz = 0;
-   while(e && umHdr->numLi < KW_MAX_UL_LI )
+   while(e && umHdr->numLi < RLC_MAX_UL_LI )
    {
 #if (ERRCLASS & ERRCLS_DEBUG)
       ret = SRemPreMsgMult(dst,2,pdu);
@@ -741,7 +741,7 @@ KwUmHdr    *umHdr;
                   "SRemPreMsgMult Failed UEID:%d CELLID:%d",
                   rbCb->rlcId.ueId,
                   rbCb->rlcId.cellId);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
 #else
       SRemPreMsgMult(dst,2,pdu);
@@ -754,7 +754,7 @@ KwUmHdr    *umHdr;
                   "Received LI as 0 UEID:%d CELLID:%d",
                   rbCb->rlcId.ueId,
                   rbCb->rlcId.cellId);
-         RETVALUE(RFAILED); 
+         return RFAILED; 
       }
       totalSz += umHdr->li[umHdr->numLi];
       if ( pduSz <=  totalSz )
@@ -770,7 +770,7 @@ KwUmHdr    *umHdr;
                   pduSz,
                   rbCb->rlcId.ueId,
                   rbCb->rlcId.cellId);
-         RETVALUE(RFAILED); /* the situation where in the PDU size 
+         return RFAILED; /* the situation where in the PDU size 
                             is something that does not match with 
                             the size in LIs*/
       }
@@ -779,7 +779,7 @@ KwUmHdr    *umHdr;
 
       e = ((dst[0]) & 0x80) >> 7;
    
-      if ( e && umHdr->numLi < KW_MAX_UL_LI)
+      if ( e && umHdr->numLi < RLC_MAX_UL_LI)
       {
          U8 tmp = ((dst[1]) & 0x08) >> 3;
          umHdr->li[umHdr->numLi] = ( dst[1] & 0x07) << 8;
@@ -793,7 +793,7 @@ KwUmHdr    *umHdr;
                      "SRemPreMsg Failed UEID:%d CELLID:%d",
                      rbCb->rlcId.ueId,
                      rbCb->rlcId.cellId);
-            RETVALUE(RFAILED);
+            return RFAILED;
          }
 #else
          SRemPreMsg(dst,pdu);
@@ -807,7 +807,7 @@ KwUmHdr    *umHdr;
                      "Received LI as 0 UEID:%d CELLID:%d",
                      rbCb->rlcId.ueId,
                      rbCb->rlcId.cellId);
-            RETVALUE(RFAILED); 
+            return RFAILED; 
          }
          totalSz += umHdr->li[umHdr->numLi];
          pduSz--;
@@ -815,20 +815,20 @@ KwUmHdr    *umHdr;
 
          if (pduSz < totalSz)
          {
-            RETVALUE(RFAILED); /* the situation where in the PDU size is 
+            return RFAILED; /* the situation where in the PDU size is 
                                something that does not match with the 
                                size in LIs*/
          }
 
          e = tmp;
       }
-   } /* while(e && umHdr->numLi < KW_MAX_LI ) */
+   } /* while(e && umHdr->numLi < RLC_MAX_LI ) */
    if (e)
    {
-      /* PDU was constructed with LIs that exceeded KW_MAX_LI */
-      RETVALUE(RFAILED);
+      /* PDU was constructed with LIs that exceeded RLC_MAX_LI */
+      return RFAILED;
    }
-   RETVALUE(ROK); 
+   return ROK; 
 }
    
 /**
@@ -840,49 +840,49 @@ KwUmHdr    *umHdr;
  * @return  Void
 */
 #ifdef ANSI
-PUBLIC Void kwUmmReOrdTmrExp
+Void rlcUmmReOrdTmrExp
 (
-KwCb       *gCb,
-KwUlRbCb   *rbCb     
+RlcCb       *gCb,
+RlcUlRbCb   *rbCb     
 )
 #else
-PUBLIC Void kwUmmReOrdTmrExp(gCb, rbCb)
-KwCb       *gCb;
-KwUlRbCb   *rbCb;   
+Void rlcUmmReOrdTmrExp(gCb, rbCb)
+RlcCb       *gCb;
+RlcUlRbCb   *rbCb;   
 #endif
 {
-   KwSn prevVrUr;   /* prevVrUr */
+   RlcSn prevVrUr;   /* prevVrUr */
 
-   TRC3(kwUmmReOrdTmrExp)
+   TRC3(rlcUmmReOrdTmrExp)
 
 
-   prevVrUr = KW_UMUL.vrUr;
+   prevVrUr = RLC_UMUL.vrUr;
 
    /* set VR(UR) to SN >= VR(UX) that has not been received */
-   kwUmmFindNextVRUR(&KW_UMUL, KW_UMUL.vrUx);
+   rlcUmmFindNextVRUR(&RLC_UMUL, RLC_UMUL.vrUx);
 
-   while (KW_UM_GET_VALUE(prevVrUr,KW_UMUL) < 
-          KW_UM_GET_VALUE(KW_UMUL.vrUr,KW_UMUL))
+   while (RLC_UM_GET_VALUE(prevVrUr,RLC_UMUL) < 
+          RLC_UM_GET_VALUE(RLC_UMUL.vrUr,RLC_UMUL))
    {
-      if (KW_UMUL.recBuf[prevVrUr])
+      if (RLC_UMUL.recBuf[prevVrUr])
       {
-         kwUmmReAssembleSdus(gCb, rbCb, KW_UMUL.recBuf[prevVrUr]);
-         if(KW_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
+         rlcUmmReAssembleSdus(gCb, rbCb, RLC_UMUL.recBuf[prevVrUr]);
+         if(RLC_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
          {
-            KW_FREE_BUF(KW_UMUL.recBuf[prevVrUr]->pdu);
+            RLC_FREE_BUF(RLC_UMUL.recBuf[prevVrUr]->pdu);
          }
-         KW_FREE_WC(gCb, KW_UMUL.recBuf[prevVrUr], sizeof(KwUmRecBuf));
-         KW_UMUL.recBuf[prevVrUr] = NULLP;
+         RLC_FREE_WC(gCb, RLC_UMUL.recBuf[prevVrUr], sizeof(RlcUmRecBuf));
+         RLC_UMUL.recBuf[prevVrUr] = NULLP;
       }
 
       prevVrUr = (prevVrUr + 1) & rbCb->m.umUl.modBitMask;
    }
 
-   if (KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL) > 
-       KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL))
+   if (RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL) > 
+       RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL))
    {
-      kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
-      KW_UMUL.vrUx = KW_UMUL.vrUh;
+      rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
+      RLC_UMUL.vrUx = RLC_UMUL.vrUh;
    }
 }
 
@@ -901,45 +901,45 @@ KwUlRbCb   *rbCb;
  */
 
 #ifdef ANSI
-PUBLIC Void kwUmmFreeUlRbCb
+Void rlcUmmFreeUlRbCb
 (
-KwCb       *gCb,
-KwUlRbCb   *rbCb
+RlcCb       *gCb,
+RlcUlRbCb   *rbCb
 )
 #else
-PUBLIC Void kwUmmFreeUlRbCb(gCb,rbCb)
-KwCb       *gCb;
-KwUlRbCb   *rbCb;
+Void rlcUmmFreeUlRbCb(gCb,rbCb)
+RlcCb       *gCb;
+RlcUlRbCb   *rbCb;
 #endif
 {
-   KwSn         curSn = 0;           /* sequence number of PDU */
-   KwSn         windSz;              /* PDU window size */
-   KwUmRecBuf   **umRecBuf;          /* UM module receive buffer */
+   RlcSn         curSn = 0;           /* sequence number of PDU */
+   RlcSn         windSz;              /* PDU window size */
+   RlcUmRecBuf   **umRecBuf;          /* UM module receive buffer */
 
-   TRC2(kwUmmFreeUlRbCb)
+   TRC2(rlcUmmFreeUlRbCb)
 
 
    windSz  = rbCb->m.umUl.umWinSz << 1;
 
    umRecBuf =  rbCb->m.umUl.recBuf;
 
-   if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR))
+   if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
    {
-      kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR);
+      rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
    }
    while (curSn < windSz)
    {
       if (umRecBuf[curSn] != NULLP)
       {
-         KW_FREE_BUF_WC(umRecBuf[curSn]->pdu);
+         RLC_FREE_BUF_WC(umRecBuf[curSn]->pdu);
          umRecBuf[curSn]->pdu = NULLP;
 
-         KW_FREE_WC(gCb, umRecBuf[curSn], sizeof(KwUmRecBuf));
+         RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(RlcUmRecBuf));
          umRecBuf[curSn] = NULLP;
       }
       curSn++;
    }
-   KW_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(KwUmRecBuf*));
+   RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(RlcUmRecBuf*));
    rbCb->m.umUl.recBuf = NULLP;
    RETVOID;
 }