Replaced old SSI function with new macros jira id - ODUHIGH-212

[o-du/l2.git] / src / cm / rgu.c

diff --git a/src/cm/rgu.c b/src/cm/rgu.c
index 809f60e..87c188a 100755 (executable)
--- a/src/cm/rgu.c
+++ b/src/cm/rgu.c
@@ -35,25 +35,10 @@
 */
 
 /* header include files (.h) */
-#include "envopt.h"        /* environment options */
-#include "envdep.h"        /* environment dependent */
-#include "envind.h"        /* environment independent */
-#include "gen.h"           /* general */
-#include "ssi.h"           /* system services */
-#include "cm_tkns.h"       /* Common Token Defines */
-#include "cm_llist.h"      /* Common Link List Defines */
-#include "cm_hash.h"       /* Common Hash List Defines */
-#include "cm_lte.h"        /* Common LTE Defines */
+#include "common_def.h"
 #include "rgu.h"           /* RGU Interface defines */
 
 /* header/extern include files (.x) */
-#include "gen.x"           /* general */
-#include "ssi.x"           /* system services */
-#include "cm_tkns.x"       /* Common Token Definitions */
-#include "cm_llist.x"      /* Common Link List Definitions */
-#include "cm_lib.x"        /* Common Library Definitions */
-#include "cm_hash.x"       /* Common Hash List Definitions */
-#include "cm_lte.x"        /* Common LTE Defines */
 #include "rgu.x"           /* RGU Interface includes */
 
 #ifdef SS_RBUF
@@ -100,7 +85,7 @@ SpId spId;
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU001, (ErrVal)0, "Packing failed");
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -109,7 +94,7 @@ SpId spId;
           (ErrVal)ERGU002, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -118,10 +103,10 @@ SpId spId;
           (ErrVal)ERGU003, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRGUBNDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -164,7 +149,7 @@ Buffer *mBuf;
           (ErrVal)ERGU004, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SUnpkS16(&spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -173,10 +158,10 @@ Buffer *mBuf;
           (ErrVal)ERGU005, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, spId));
+   return ((*func)(pst, suId, spId));
 }
 
 \f
@@ -216,7 +201,7 @@ Reason reason;
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU006, (ErrVal)0, "Packing failed");
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(reason, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -225,7 +210,7 @@ Reason reason;
           (ErrVal)ERGU007, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -234,10 +219,10 @@ Reason reason;
           (ErrVal)ERGU008, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRGUUBNDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -280,7 +265,7 @@ Buffer *mBuf;
           (ErrVal)ERGU009, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SUnpkS16(&reason, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -289,10 +274,10 @@ Buffer *mBuf;
           (ErrVal)ERGU010, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, spId, reason));
+   return ((*func)(pst, spId, reason));
 }
 
 \f
@@ -333,16 +318,16 @@ U8 status;
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU011, (ErrVal)0, "Packing failed");
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SPkU8(status, mBuf) != ROK) {
+   if (oduUnpackUInt8(status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU012, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (SPkS16(suId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -351,10 +336,10 @@ U8 status;
           (ErrVal)ERGU013, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRGUBNDCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -398,19 +383,19 @@ Buffer *mBuf;
           (ErrVal)ERGU014, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (SUnpkU8(&status, mBuf) != ROK) {
+   if (oduPackUInt8(&status, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU015, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, status));
+   return ((*func)(pst, suId, status));
 }
 
 \f
@@ -445,12 +430,12 @@ RlcMacData  *dlData
           (ErrVal)ERGU022, (ErrVal)0, "Packing failed");
 #endif      
       SPutSBuf(pst->region, pst->pool, (Data *)dlData, sizeof(RlcMacData));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR) dlData, mBuf);
+      CMCHKPK(oduPackPointer,(PTR) dlData, mBuf);
    }
    else
    {
@@ -469,7 +454,7 @@ RlcMacData  *dlData
          SPutSBuf(pst->region, pst->pool, (Data *)dlData,
                                        sizeof(RlcMacData));
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
 
       if (SPutSBuf(pst->region, pst->pool, 
@@ -480,7 +465,7 @@ RlcMacData  *dlData
              (ErrVal)ERGU025, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       dlData = NULLP;
    }
@@ -490,16 +475,16 @@ RlcMacData  *dlData
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU024, (ErrVal)0, "Packing failed");
 #endif      
-      if (dlData != NULLP);
+      if (dlData != NULLP)
       {
          SPutSBuf(pst->region, pst->pool, 
                   (Data *)dlData, sizeof(RlcMacData));
       }
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    pst->event = (Event) EVTRLCDLDAT;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -531,12 +516,12 @@ Buffer *mBuf
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &dlData, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &dlData, mBuf);
    }
    else 
    {
@@ -548,7 +533,7 @@ Buffer *mBuf
              (ErrVal)ERGU026, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       cmMemset((U8*)dlData, (U8)0, sizeof(RlcMacData));
   /*rgu_c_001.main_5 - ADD - L2M Support */
@@ -566,15 +551,15 @@ Buffer *mBuf
          SPutMsg(mBuf);
          SPutSBuf(pst->region, pst->pool, (Data *)dlData,
                                      sizeof(RlcMacData));
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
 
    /* TODO : change function call to send RlcMacData as below: */
-   RETVALUE((*func)(pst, spId, dlData));
+   return ((*func)(pst, spId, dlData));
    
-   //RETVALUE((*func)(pst, spId, datReq));
+   //return ((*func)(pst, spId, datReq));
 }
 
 \f
@@ -592,22 +577,9 @@ Buffer *mBuf
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
-PUBLIC S16 packRcvdUlData
-(
-Pst* pst,
-SuId suId,
-RlcMacData  *ulData
-)
-#else
-PUBLIC S16 packRcvdUlData(pst, suId, ulData)
-Pst* pst;
-SuId suId;
-RlcMacData  *ulData;
-#endif
+uint8_t packRlcUlData(Pst* pst, RlcMacData  *ulData)
 {
    Buffer *mBuf = NULLP;
-   TRC3(packRcvdUlData)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -616,12 +588,12 @@ RlcMacData  *ulData;
           (ErrVal)ERGU035, (ErrVal)0, "Packing failed");
 #endif      
       SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR)ulData, mBuf);
+      CMCHKPK(oduPackPointer,(PTR)ulData, mBuf);
    }
    else
    {
@@ -633,7 +605,7 @@ RlcMacData  *ulData;
 #endif            
          SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
 
       if (SPutStaticBuffer(pst->region, pst->pool, 
@@ -644,23 +616,12 @@ RlcMacData  *ulData;
              (ErrVal)ERGU038, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       ulData = NULLP;
    }
-   if (SPkS16(suId, mBuf) != ROK) {
-#if (ERRCLASS & ERRCLS_ADD_RES)      
-      SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
-          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
-          (ErrVal)ERGU037, (ErrVal)0, "Packing failed");
-#endif      
-      SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
-      SPutMsg(mBuf);
-      RETVALUE(RFAILED);
-   }
-
    pst->event = (Event) EVTRLCULDAT;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -678,31 +639,15 @@ RlcMacData  *ulData;
 *  @return   S16
 *      -# ROK
 **/
-PUBLIC S16 unpackRcvdUlData
-(
-RlcMacUlData func,
-Pst *pst,
-Buffer *mBuf
-)
+uint8_t unpackRcvdUlData(RlcMacUlDataFunc func, Pst *pst, Buffer *mBuf)
 {
-   SuId suId;
    RlcMacData *ulData;
    
    TRC3(unpackRcvdUlData)
 
-   if (SUnpkS16(&suId, mBuf) != ROK) {
-#if (ERRCLASS & ERRCLS_ADD_RES)      
-      SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
-          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
-          (ErrVal)ERGU039, (ErrVal)0, "UnPacking failed");
-#endif      
-      SPutMsg(mBuf);
-      RETVALUE(RFAILED);
-   }
-
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &ulData, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &ulData, mBuf);
    }
    else 
    {
@@ -714,7 +659,7 @@ Buffer *mBuf
              (ErrVal)ERGU040, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (unpackRlcMacDataInfo(ulData, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -725,11 +670,11 @@ Buffer *mBuf
          SPutMsg(mBuf);
          SPutStaticBuffer(pst->region, pst->pool, 
                     (Data *)ulData, sizeof(RlcMacData),0);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, ulData));
+   return ((*func)(pst, ulData));
 }
 
 
@@ -767,15 +712,15 @@ Buffer *mBuf;
    S32 loop;
    TRC3(cmPkRguL2MUlThrpMeasReqInfo);
 
-   CMCHKPK(SPkU8, param->enbMeas, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->enbMeas, mBuf);
    for (loop=param->numLcId-1; loop >= 0; loop--)
    {
-      CMCHKPK(SPkU8, param->lcId[loop], mBuf);
+      CMCHKPK(oduUnpackUInt8, param->lcId[loop], mBuf);
    }
    CMCHKPK(cmPkLteLcId, param->numLcId, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -816,10 +761,10 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkLteLcId, &param->numLcId, mBuf);
    for (loop=0; loop<param->numLcId; loop++)
    {
-      CMCHKUNPK(SUnpkU8, &param->lcId[loop], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->lcId[loop], mBuf);
    }
-   CMCHKUNPK(SUnpkU8, &param->enbMeas, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->enbMeas, mBuf);
+   return ROK;
 }
 
 /**
@@ -861,11 +806,11 @@ RguL2MUlThrpMeasReqInfo* measReq;
           (ErrVal)ERGU049, (ErrVal)0, "Packing failed");
 #endif      
       SPutSBuf(pst->region, pst->pool, (Data *)measReq, sizeof(RguL2MUlThrpMeasReqInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR) measReq, mBuf);
+      CMCHKPK(oduPackPointer,(PTR) measReq, mBuf);
    }
    else
    {
@@ -878,7 +823,7 @@ RguL2MUlThrpMeasReqInfo* measReq;
          SPutSBuf(pst->region, pst->pool, (Data *)measReq, 
                                     sizeof(RguL2MUlThrpMeasReqInfo));
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (SPutSBuf(pst->region, pst->pool, (Data *)measReq, 
                            sizeof(RguL2MUlThrpMeasReqInfo)) != ROK) {
@@ -888,7 +833,7 @@ RguL2MUlThrpMeasReqInfo* measReq;
              (ErrVal)ERGU052, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       measReq = NULLP;
    }
@@ -905,11 +850,11 @@ RguL2MUlThrpMeasReqInfo* measReq;
                              sizeof(RguL2MUlThrpMeasReqInfo));
       }
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTRGUL2MULTHRPMEASREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -954,11 +899,11 @@ Buffer *mBuf;
           (ErrVal)ERGU053, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &measReq, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &measReq, mBuf);
    }
    else 
    {
@@ -970,7 +915,7 @@ Buffer *mBuf;
              (ErrVal)ERGU054, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (cmUnpkRguL2MUlThrpMeasReqInfo(measReq, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -981,11 +926,11 @@ Buffer *mBuf;
          SPutMsg(mBuf);
          SPutSBuf(pst->region, pst->pool, (Data *)measReq, 
                                 sizeof(RguL2MUlThrpMeasReqInfo));
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, spId, measReq));
+   return ((*func)(pst, spId, measReq));
 }
 
 #endif
@@ -1024,13 +969,13 @@ RlcMacBOStatus  *boStatus
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGU056, (ErrVal)0, "Packing failed");
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 #ifdef ERRCLS_KW
    /* boStaInfo cant be NULL here */
    if (boStaInfo == NULLP)
    {
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 #endif
    cmMemcpy((U8 *)boStaInfo, (U8 *)boStatus, sizeof(RlcMacBOStatus)); 
@@ -1042,11 +987,11 @@ RlcMacBOStatus  *boStatus
 #endif      
          SPutSBuf(pst->region, pst->pool, (Data *)boStaInfo, sizeof(RlcMacBOStatus));
 
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR) boStaInfo, mBuf);
+      CMCHKPK(oduPackPointer,(PTR) boStaInfo, mBuf);
    }
    else
    {
@@ -1057,7 +1002,7 @@ RlcMacBOStatus  *boStatus
             (ErrVal)ERGU057, (ErrVal)0, "Packing failed");
 #endif      
         SPutMsg(mBuf);
-        RETVALUE(RFAILED);
+        return RFAILED;
      }
    }
    if (SPkS16(spId, mBuf) != ROK) {
@@ -1071,11 +1016,11 @@ RlcMacBOStatus  *boStatus
          SPutSBuf(pst->region, pst->pool, (Data *)boStaInfo, sizeof(RlcMacBOStatus));
       }
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event)EVTRLCBOSTA;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
    SPutMsg(mBuf);
 }
 
@@ -1113,12 +1058,12 @@ Buffer *mBuf
           (ErrVal)ERGU060, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &boSta, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &boSta, mBuf);
    }
    else
    {
@@ -1130,7 +1075,7 @@ Buffer *mBuf
              (ErrVal)ERGU061, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (unpackBOStatusInfo(boSta, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -1140,13 +1085,13 @@ Buffer *mBuf
 #endif      
          SPutMsg(mBuf);
          SPutSBuf(pst->region, pst->pool, (Data *)boSta, sizeof(RlcMacBOStatus));
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
   // (*func)(pst, spId, boSta);
    SPutSBuf(pst->region, pst->pool, (Data *)boSta, sizeof(RlcMacBOStatus));
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1198,7 +1143,7 @@ RguHarqStatusInd  *harqStatusInd;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ERGU070, (ErrVal)0, "Packing failed");
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    cmMemcpy((U8 *)harqStaInd, (U8 *)harqStatusInd, sizeof(RguHarqStatusInd));
@@ -1214,24 +1159,24 @@ RguHarqStatusInd  *harqStatusInd;
 #else      
       SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR) harqStaInd, mBuf); 
+      CMCHKPK(oduPackPointer,(PTR) harqStaInd, mBuf); 
    }
    else
    {
       for(idx = 0; idx < harqStaInd->numTbs; idx++)
       {
-         CMCHKPK(SPkU16, harqStaInd->status[idx], mBuf);
+         CMCHKPK(oduUnpackUInt16, harqStaInd->status[idx], mBuf);
       }
       for(idx = 0; idx < harqStaInd->numTbs; idx++)
       {
-         CMCHKPK(SPkU32, harqStaInd->tbId[idx], mBuf);
+         CMCHKPK(oduUnpackUInt32, harqStaInd->tbId[idx], mBuf);
       }
-      CMCHKPK(SPkU8, harqStaInd->numTbs, mBuf);
+      CMCHKPK(oduUnpackUInt8, harqStaInd->numTbs, mBuf);
       CMCHKPK(cmPkLteRnti, harqStaInd->ueId, mBuf);
       CMCHKPK(cmPkLteCellId, harqStaInd->cellId, mBuf);
    }
@@ -1248,13 +1193,13 @@ RguHarqStatusInd  *harqStatusInd;
       SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 #ifdef XEON_SPECIFIC_CHANGES
    if (SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd,
             sizeof(RguHarqStatusInd)) != ROK) {
 #else   
-   if (pst->selector != RGU_SEL_LWLC)
+   if (pst->selector != ODU_SELECTOR_LWLC)
    {
       if(SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, 
                sizeof(RguHarqStatusInd), 0) != ROK)
@@ -1266,14 +1211,14 @@ RguHarqStatusInd  *harqStatusInd;
                (ErrVal)ERGU072, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
 #ifndef XEON_SPECIFIC_CHANGES      
    }
 #endif   
 
    pst->event = (Event) EVTRGUHQSTAIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 \f
 
@@ -1317,15 +1262,15 @@ Buffer *mBuf;
           (ErrVal)ERGU073, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 #ifdef XEON_SPECIFIC_CHANGES
    if ((SGetSBuf(pst->region, pst->pool, (Data **)&hqStaInd, 
         sizeof(RguHarqStatusInd))) != ROK) {
 #else   
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &hqStaInd, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &hqStaInd, mBuf);
    }  
    else
    {   
@@ -1339,18 +1284,18 @@ Buffer *mBuf;
                (ErrVal)ERGU074, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       CMCHKUNPK(cmUnpkLteCellId, &hqStaInd->cellId, mBuf);
       CMCHKUNPK(cmUnpkLteRnti, &hqStaInd->ueId, mBuf);
-      CMCHKUNPK(SUnpkU8, &hqStaInd->numTbs, mBuf);
+      CMCHKUNPK(oduPackUInt8, &hqStaInd->numTbs, mBuf);
       for(idx = hqStaInd->numTbs; idx > 0; idx--)
       {
-         CMCHKUNPK(SUnpkU32, &hqStaInd->tbId[idx - 1], mBuf);
+         CMCHKUNPK(oduPackUInt32, &hqStaInd->tbId[idx - 1], mBuf);
       }
       for(idx = hqStaInd->numTbs; idx > 0; idx--)
       {
-         CMCHKUNPK(SUnpkU16, &hqStaInd->status[idx - 1], mBuf);
+         CMCHKUNPK(oduPackUInt16, &hqStaInd->status[idx - 1], mBuf);
       }
 #ifndef XEON_SPECIFIC_CHANGES      
    }
@@ -1362,7 +1307,7 @@ Buffer *mBuf;
 #else   
    SPutStaticBuffer(pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd), 0);
 #endif   
-   RETVALUE(ROK);
+   return ROK;
 }
 #endif /* LTE_L2_MEAS */
 
@@ -1400,11 +1345,11 @@ RlcMacSchedRepInfo  * schRep
           (ErrVal)ERGU076, (ErrVal)0, "Packing failed");
 #endif      
       SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR) schRep, mBuf);
+      CMCHKPK(oduPackPointer,(PTR) schRep, mBuf);
    }
    else
    {
@@ -1417,7 +1362,7 @@ RlcMacSchedRepInfo  * schRep
         SPutSBuf(pst->region, pst->pool, (Data *)schRep, 
                                          sizeof(RlcMacSchedRepInfo));
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       } 
       if (SPutSBuf(pst->region, pst->pool, (Data *)schRep,
                                   sizeof(RlcMacSchedRepInfo)) != ROK) {
@@ -1427,7 +1372,7 @@ RlcMacSchedRepInfo  * schRep
              (ErrVal)ERGU079, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       schRep= NULLP;
    }
@@ -1442,11 +1387,11 @@ RlcMacSchedRepInfo  * schRep
          SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
       }
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    pst->event = (Event) EVTSCHREP;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 \f
@@ -1485,11 +1430,11 @@ Buffer *mBuf
           (ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &schRep, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &schRep, mBuf);
    }
    else 
    {
@@ -1500,7 +1445,7 @@ Buffer *mBuf
          (ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (unpackSchedRepInfo(schRep, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -1510,11 +1455,11 @@ Buffer *mBuf
 #endif      
          SPutMsg(mBuf);
          SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, schRep));
+   return ((*func)(pst, suId, schRep));
 }
 
 #ifdef ANSI
@@ -1530,11 +1475,11 @@ Buffer             *mBuf;
 #endif
 {
   TRC3(cmPkRguLcFlowCntrlInfo);
-  CMCHKPK(SPkU32, param->maxBo4FlowCtrl, mBuf);
-  CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
+  CMCHKPK(oduUnpackUInt32, param->maxBo4FlowCtrl, mBuf);
+  CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
   CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
 
-  RETVALUE(ROK);
+  return ROK;
 }
 
 #ifdef ANSI
@@ -1557,9 +1502,9 @@ Buffer             *mBuf;
   {
     cmPkRguLcFlowCntrlInfo(&param->lcInfo[idx],mBuf);
   }
-  CMCHKPK(SPkU32, param->numLcs, mBuf);
+  CMCHKPK(oduUnpackUInt32, param->numLcs, mBuf);
   CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
-  RETVALUE(ROK);
+  return ROK;
 }
 
 #ifdef ANSI
@@ -1582,9 +1527,9 @@ Buffer          *mBuf;
   {
     cmPkRguUeFlowCntrlInfo(&param->ueFlowCntrlInfo[idx],mBuf);
   }
-  CMCHKPK(SPkU32, param->numUes, mBuf);
+  CMCHKPK(oduUnpackUInt32, param->numUes, mBuf);
   CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-  RETVALUE(ROK);
+  return ROK;
 }
 \f
 /**
@@ -1625,11 +1570,11 @@ RguFlowCntrlInd   *flowCntrlInd;
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU076, (ErrVal)0, "Packing failed");
 #endif      
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKPK(cmPkPtr,(PTR) flowCntrlInd, mBuf);
+      CMCHKPK(oduPackPointer,(PTR) flowCntrlInd, mBuf);
    }
    else
    {
@@ -1640,7 +1585,7 @@ RguFlowCntrlInd   *flowCntrlInd;
                (ErrVal)ERGU077, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       } 
    }
    if (SPkS16(suId, mBuf) != ROK) {
@@ -1650,11 +1595,11 @@ RguFlowCntrlInd   *flowCntrlInd;
           (ErrVal)ERGU078, (ErrVal)0, "Packing failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    
    pst->event = (Event) EVTRGUFLOWCNTRLIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 #ifdef ANSI
@@ -1672,10 +1617,10 @@ Buffer           *mBuf;
   TRC3(cmUnpkRguLcFlowCntrlInfo);
 
   CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
-  CMCHKUNPK(SUnpkU32, &param->pktAdmitCnt, mBuf);
-  CMCHKUNPK(SUnpkU32, &param->maxBo4FlowCtrl, mBuf);
+  CMCHKUNPK(oduPackUInt32, &param->pktAdmitCnt, mBuf);
+  CMCHKUNPK(oduPackUInt32, &param->maxBo4FlowCtrl, mBuf);
   
-  RETVALUE(ROK);
+  return ROK;
 }
 #ifdef ANSI
 PUBLIC S16 cmUnpkRguUeFlowCntrlInfo
@@ -1692,12 +1637,12 @@ Buffer           *mBuf;
   U32 idx;
   TRC3(cmUnpkRguUeFlowCntrlInfo);
   CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
-  CMCHKUNPK(SUnpkU32, &param->numLcs, mBuf);
+  CMCHKUNPK(oduPackUInt32, &param->numLcs, mBuf);
   for(idx=0; idx < param->numLcs; idx++)
   {
     cmUnpkRguLcFlowCntrlInfo(&param->lcInfo[idx],mBuf);
   }
-  RETVALUE(ROK);
+  return ROK;
 }
 
 #ifdef ANSI
@@ -1717,12 +1662,12 @@ Buffer           *mBuf;
   TRC3(cmUnpkRguFlowCntrlInfo);
 
   CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
-  CMCHKUNPK(SUnpkU32, &param->numUes, mBuf);
+  CMCHKUNPK(oduPackUInt32, &param->numUes, mBuf);
   for (idx=0; idx < param->numUes; idx++)
   {
     cmUnpkRguUeFlowCntrlInfo(&param->ueFlowCntrlInfo[idx],mBuf);
   }
-  RETVALUE(ROK);
+  return ROK;
 }
 
 /**
@@ -1766,11 +1711,11 @@ Buffer *mBuf;
           (ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
 #endif      
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == RGU_SEL_LWLC)
+   if (pst->selector == ODU_SELECTOR_LWLC)
    {
-      CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInd, mBuf);
+      CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInd, mBuf);
    }
    else 
    {
@@ -1781,7 +1726,7 @@ Buffer *mBuf;
          (ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (cmUnpkRguFlowCntrlInfo(flowCntrlInd, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -1791,11 +1736,11 @@ Buffer *mBuf;
 #endif      
          SPutMsg(mBuf);
          SPutSBuf(pst->region, pst->pool, (Data *)flowCntrlInd, sizeof(RguFlowCntrlInd));
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, flowCntrlInd));
+   return ((*func)(pst, suId, flowCntrlInd));
 }
 
 /***********************************************************
@@ -1834,14 +1779,14 @@ Buffer *mBuf;
      /* rgu_c_001.main_3: ccpu00111328: S16 is renamed as MsgLen */
       MsgLen msgLen = 0;
       if (SFndLenMsg(param->mBuf[i], &msgLen) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       if (SCatMsg(mBuf, param->mBuf[i], M1M2) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       SPutMsg(param->mBuf[i]);
       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
    }
-   CMCHKPK(SPkU8, param->numPdu, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numPdu, mBuf);
+   return ROK;
 }
 
 
@@ -1878,16 +1823,16 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRguPduInfo);
 
-   CMCHKUNPK(SUnpkU8, &param->numPdu, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numPdu, mBuf);
    for (i=0; i<param->numPdu; i++) {
       MsgLen msgLen, totalMsgLen;
       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->mBuf[i]) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1923,14 +1868,14 @@ Buffer *mBuf;
 
    TRC3(cmPkRguDBoReport);
 
-   CMCHKPK(SPkU32, param->oldestSduArrTime, mBuf);
-   CMCHKPK(SPkU32, param->staPduBo, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->oldestSduArrTime, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->staPduBo, mBuf);
 #ifdef CCPU_OPT
-   CMCHKPK(SPkU8, param->staPduPrsnt, mBuf);
-   CMCHKPK(SPkU16, param->estRlcHdrSz, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->staPduPrsnt, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->estRlcHdrSz, mBuf);
 #endif
    CMCHKPK(SPkS32, param->bo, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1968,13 +1913,13 @@ Buffer *mBuf;
 
    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
 #ifdef CCPU_OPT
-   CMCHKUNPK(SUnpkU16, &param->estRlcHdrSz, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->staPduPrsnt, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->estRlcHdrSz, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->staPduPrsnt, mBuf);
 #endif
    
-   CMCHKUNPK(SUnpkU32, &param->staPduBo, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->oldestSduArrTime, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt32, &param->staPduBo, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->oldestSduArrTime, mBuf);
+   return ROK;
 }
 
 \f
@@ -2013,9 +1958,9 @@ Buffer *mBuf;
    if (param->pdu != NULLP)
    {
       if (SFndLenMsg(param->pdu, &msgLen) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       SPutMsg(param->pdu);
       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
    }
@@ -2027,17 +1972,17 @@ Buffer *mBuf;
       case CM_LTE_LCH_PCCH:
          CMCHKPK(cmPkLteTimingInfo, &param->u.timeToTx, mBuf);
 #ifdef EMTC_ENABLE
-        CMCHKPK(SPkU8,param->pnb,mBuf);
+        CMCHKPK(oduUnpackUInt8,param->pnb,mBuf);
 #endif
          break;
       default :
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   CMCHKPK(SPkU32, param->transId, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->transId, mBuf);
    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2077,12 +2022,12 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->transId, mBuf);
    switch(param->lcType) {
       case CM_LTE_LCH_BCCH:
       case CM_LTE_LCH_PCCH:
 #ifdef EMTC_ENABLE
-         CMCHKUNPK(SUnpkU8,&param->pnb, mBuf);
+         CMCHKUNPK(oduPackUInt8,&param->pnb, mBuf);
 #endif
          CMCHKUNPK(cmUnpkLteTimingInfo, &param->u.timeToTx, mBuf);
          break;
@@ -2090,18 +2035,18 @@ Buffer *mBuf;
          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
          break;
       default :
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
    SFndLenMsg(mBuf, &msgLen);
    if (msgLen > 0)
    {
       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2138,13 +2083,13 @@ Buffer *mBuf;
    TRC3(cmPkRguLchDatReq);
 
 #ifdef L2_OPTMZ
-   CMCHKPK(SPkU8, param->freeBuff, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->freeBuff, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->setMaxUlPrio, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->setMaxUlPrio, mBuf);
    CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
    CMCHKPK(cmPkRguDBoReport, &param->boReport, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2183,11 +2128,11 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkRguDBoReport, &param->boReport, mBuf);
    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->setMaxUlPrio, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->setMaxUlPrio, mBuf);
 #ifdef L2_OPTMZ
-   CMCHKUNPK(SUnpkU8, &param->freeBuff, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->freeBuff, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 \f
@@ -2224,13 +2169,13 @@ Buffer *mBuf;
    TRC3(cmPkRguDatReqTb);
    /*rgu_c_001.main_5 - ADD - L2M Support */
 #ifdef LTE_L2_MEAS
-   CMCHKPK(SPkU32, param->tbId, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
 #endif
    for (i=param->nmbLch-1; i >= 0; i--) {
       CMCHKPK(cmPkRguLchDatReq, &param->lchData[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->nmbLch, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
+   return ROK;
 }
 
 
@@ -2283,15 +2228,15 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRguDatReqTb);
 
-   CMCHKUNPK(SUnpkU8, &param->nmbLch, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->nmbLch, mBuf);
    for (i=0; i<param->nmbLch; i++) {
       CMCHKUNPK(cmUnpkRguLchDatReq, &param->lchData[i], mBuf);
    }
    /*rgu_c_001.main_5 - ADD - L2M Support */
 #ifdef LTE_L2_MEAS
-   CMCHKUNPK(SUnpkU32, &param->tbId, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->tbId, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 \f
@@ -2352,13 +2297,13 @@ Buffer *mBuf;
       {
          CMCHKPK(cmPkRguDatReqTb, &datReq->datReqTb[i], mBuf);
       }
-      CMCHKPK(SPkU8, datReq->nmbOfTbs, mBuf);
-      CMCHKPK(SPkU32, datReq->transId, mBuf);
+      CMCHKPK(oduUnpackUInt8, datReq->nmbOfTbs, mBuf);
+      CMCHKPK(oduUnpackUInt32, datReq->transId, mBuf);
       CMCHKPK(cmPkLteRnti, datReq->rnti, mBuf);
    }
-   CMCHKPK(SPkU8, param->nmbOfUeGrantPerTti, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->nmbOfUeGrantPerTti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2423,13 +2368,13 @@ Buffer *mBuf;
    retVal = ROK;
 #endif
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->nmbOfUeGrantPerTti, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->nmbOfUeGrantPerTti, mBuf);
    for(idx = 0; idx < param->nmbOfUeGrantPerTti; idx++)
    { 
       RguDDatReqPerUe *datReq = &param->datReq[idx];
       CMCHKUNPK(cmUnpkLteRnti, &datReq->rnti, mBuf);
-      CMCHKUNPK(SUnpkU32, &datReq->transId, mBuf);
-      CMCHKUNPK(SUnpkU8, &datReq->nmbOfTbs, mBuf);
+      CMCHKUNPK(oduPackUInt32, &datReq->transId, mBuf);
+      CMCHKUNPK(oduPackUInt8, &datReq->nmbOfTbs, mBuf);
       /* rgu_c_001.main_4 - Changes for MIMO feature addition */
       for (i=0; i<RGU_MAX_TB; i++) 
       {
@@ -2439,14 +2384,14 @@ Buffer *mBuf;
          retVal = cmUnpkRguDatReqTb(pst, &datReq->datReqTb[i], mBuf);
          if(retVal != ROK)
          {
-            RETVALUE(RFAILED);
+            return RFAILED;
          }
 #else
          CMCHKUNPK(cmUnpkRguDatReqTb, &datReq->datReqTb[i], mBuf);
 #endif
       }
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2484,15 +2429,15 @@ Buffer *mBuf;
    TRC3(cmPkRguCDatIndInfo);
 
    if (SFndLenMsg(param->pdu, &msgLen) != ROK)
-      RETVALUE(RFAILED);
+      return RFAILED;
    if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
-      RETVALUE(RFAILED);
+      return RFAILED;
    SPutMsg(param->pdu);
    CMCHKPK(cmPkMsgLen, msgLen, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2534,10 +2479,10 @@ Buffer *mBuf;
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
-      RETVALUE(RFAILED);
+      return RFAILED;
    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
-      RETVALUE(RFAILED);
-   RETVALUE(ROK);
+      return RFAILED;
+   return ROK;
 }
 
 
@@ -2574,7 +2519,7 @@ Buffer *mBuf;
 
       CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2611,7 +2556,7 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2649,22 +2594,22 @@ Buffer *mBuf;
 
    TRC3(packRlcMacDataInfo);
 
-   for (i=param->nmbPdu-1; i >= 0; i--)
+   for (i=param->numPdu-1; i >= 0; i--)
    {
       msgLen = 0;
-      if (SFndLenMsg(param->pduInfo[i].pduBuf, &msgLen) != ROK)
-         RETVALUE(RFAILED);
-      if (SCatMsg(mBuf, param->pduInfo[i].pduBuf, M1M2) != ROK)
-          RETVALUE(RFAILED);      
+      //if (SFndLenMsg(param->pduInfo[i].pduBuf, &msgLen) != ROK)
+      //   return RFAILED;
+      //if (SCatMsg(mBuf, param->pduInfo[i].pduBuf, M1M2) != ROK)
+      //    return RFAILED;      
       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
       CMCHKPK(cmPkLteLcId, param->pduInfo[i].lcId, mBuf);
-      CMCHKPK(cmPkBool, param->pduInfo[i].commCh, mBuf);
+      CMCHKPK(oduPackBool, param->pduInfo[i].commCh, mBuf);
    }
-   CMCHKPK(SPkU8, param->nmbPdu, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numPdu, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   CMCHKPK(cmPkLteTimingInfo, &param->timeToTx, mBuf);
-   RETVALUE(ROK);
+   //CMCHKPK(cmPkLteTimingInfo, &param->timeToTx, mBuf);
+   return ROK;
 }
 
 
@@ -2701,23 +2646,23 @@ Buffer *mBuf;
 
    TRC3(unpackRlcMacDataInfo);
    
-   CMCHKUNPK(cmUnpkLteTimingInfo, &param->timeToTx, mBuf);
+   //CMCHKUNPK(cmUnpkLteTimingInfo, &param->timeToTx, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->nmbPdu, mBuf);
-   for (i=0; i<param->nmbPdu; i++) 
+   CMCHKUNPK(oduPackUInt8, &param->numPdu, mBuf);
+   for (i=0; i<param->numPdu; i++) 
    {
       MsgLen totalMsgLen;
 
-      CMCHKUNPK(cmUnpkBool, &param->pduInfo[i].commCh, mBuf);
+      CMCHKUNPK(oduUnpackBool, &param->pduInfo[i].commCh, mBuf);
       CMCHKUNPK(cmUnpkLteLcId, &param->pduInfo[i].lcId, mBuf);
       CMCHKUNPK(cmUnpkMsgLen, &param->pduInfo[i].pduLen, mBuf);
       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
-         RETVALUE(RFAILED);
-      if (SSegMsg(mBuf, totalMsgLen-param->pduInfo[i].pduLen, &param->pduInfo[i].pduBuf) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
+      //if (SSegMsg(mBuf, totalMsgLen-param->pduInfo[i].pduLen, &param->pduInfo[i].pduBuf) != ROK)
+      //   return RFAILED;
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 \f
@@ -2760,18 +2705,18 @@ Buffer *mBuf;
       case CM_LTE_LCH_PCCH:
          CMCHKPK(cmPkLteTimingInfo, &param->u.timeToTx, mBuf);
 #ifdef EMTC_ENABLE
-         CMCHKPK(SPkU8,param->pnb,mBuf);
-         CMCHKPK(SPkU8,param->emtcDiReason,mBuf);
+         CMCHKPK(oduUnpackUInt8,param->pnb,mBuf);
+         CMCHKPK(oduUnpackUInt8,param->emtcDiReason,mBuf);
 #endif
          break;
       default :
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
    CMCHKPK(SPkS32, param->bo, mBuf);
    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2815,8 +2760,8 @@ Buffer *mBuf;
       case CM_LTE_LCH_BCCH:
       case CM_LTE_LCH_PCCH:
 #ifdef EMTC_ENABLE
-         CMCHKUNPK(SUnpkU8,&param->emtcDiReason , mBuf);
-         CMCHKUNPK(SUnpkU8,&param->pnb , mBuf);
+         CMCHKUNPK(oduPackUInt8,&param->emtcDiReason , mBuf);
+         CMCHKUNPK(oduPackUInt8,&param->pnb , mBuf);
 #endif
          CMCHKUNPK(cmUnpkLteTimingInfo, &param->u.timeToTx, mBuf);
          break;
@@ -2824,9 +2769,9 @@ Buffer *mBuf;
          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
          break;
       default :
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2864,10 +2809,10 @@ Buffer *mBuf;
 
    CMCHKPK(SPkS32, param->bo, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   CMCHKPK(cmPkBool, param->commCh, mBuf);
+   CMCHKPK(oduPackBool, param->commCh, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 } /* End of packBOStatusInfo */
 
 
@@ -2905,10 +2850,10 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
-   CMCHKUNPK(cmUnpkBool, &param->commCh, mBuf);
+   CMCHKUNPK(oduUnpackBool, &param->commCh, mBuf);
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 } /* End of unpackBOStatusInfo */
 
 \f
@@ -2945,7 +2890,7 @@ Buffer *mBuf;
 
    CMCHKPK(SPkS16, param->totBufSize, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2983,7 +2928,7 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->totBufSize, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 \f
@@ -3020,14 +2965,14 @@ Buffer *mBuf;
    TRC3(cmPkRguStaIndTb);
 
 #ifdef LTE_L2_MEAS
-   CMCHKPK(SPkU16, param->status, mBuf);
-   CMCHKPK(SPkU32, param->tbId, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->status, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
 #endif   
    for (i=param->nmbLch-1; i >= 0; i--) {
       CMCHKPK(cmPkRguLchStaInd, &param->lchStaInd[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->nmbLch, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
+   return ROK;
 }
 
 
@@ -3064,15 +3009,15 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRguStaIndTb);
 
-   CMCHKUNPK(SUnpkU8, &param->nmbLch, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->nmbLch, mBuf);
    for (i=0; i<param->nmbLch; i++) {
       CMCHKUNPK(cmUnpkRguLchStaInd, &param->lchStaInd[i], mBuf);
    }
 #ifdef LTE_L2_MEAS
-   CMCHKUNPK(SUnpkU32, &param->tbId, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->status, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->tbId, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->status, mBuf);
 #endif   
-   RETVALUE(ROK);
+   return ROK;
 }
 
 \f
@@ -3105,14 +3050,14 @@ Buffer *mBuf
    for(idx = (param->nmbLch-1); idx >= 0; idx--)
    {
       CMCHKPK(cmPkRguLchStaInd, &param->lchSta[idx].lchStaInd, mBuf);
-      CMCHKPK(cmPkBool, param->lchSta[idx].commCh, mBuf);
+      CMCHKPK(oduPackBool, param->lchSta[idx].commCh, mBuf);
    }
-   CMCHKPK(SPkU8, param->nmbLch, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
    CMCHKPK(cmPkLteTimingInfo, &param->timeToTx, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* End of packSchedRepInfo */
 
 
@@ -3146,14 +3091,14 @@ Buffer *mBuf
    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timeToTx, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->nmbLch, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->nmbLch, mBuf);
    for(idx = 0; idx < param->nmbLch; idx++)
    {
-      CMCHKUNPK(cmUnpkBool, &param->lchSta[idx].commCh, mBuf);
+      CMCHKUNPK(oduUnpackBool, &param->lchSta[idx].commCh, mBuf);
       CMCHKUNPK(cmUnpkRguLchStaInd, &param->lchSta[idx].lchStaInd, mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* End of unpackSchedRepInfo */
 
 #endif