X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Frgu.c;h=87c188a954359b1367a88ef7ccc5122148f93d45;hb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;hp=1125b6bc3408945f944b3eac45a8eeb3a00e9b00;hpb=d10b52519198632f93deae9574adc69c7ce12efa;p=o-du%2Fl2.git

diff --git a/src/cm/rgu.c b/src/cm/rgu.c
index 1125b6bc3..87c188a95 100755
--- 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));
 }
 
 
@@ -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));
 }
 
 
@@ -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));
 }
 
 
@@ -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));
 }
 
 
@@ -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));
 }
 
 
@@ -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));
 }
 
 
@@ -420,7 +405,7 @@ Buffer *mBuf;
 *
 * @details
 *
-*     Function : packSendDlData
+*     Function : packDlData
 *
 *  @param[in]   Pst*  pst
 *  @param[in]   SpId  spId
@@ -428,22 +413,15 @@ Buffer *mBuf;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
-PUBLIC S16 packSendDlData
+PUBLIC uint16_t packDlData
 (
 Pst* pst,
 SpId spId,
 RlcMacData  *dlData
 )
-#else
-PUBLIC S16 packSendDlData(pst, spId, dlData)
-Pst* pst;
-SpId spId;
-RlcMacData  dlData;
-#endif
 {
    Buffer *mBuf = NULLP;
-   TRC3(packSendDlData)
+   TRC3(packDlData)
 
    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -452,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
    {
@@ -476,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, 
@@ -487,7 +465,7 @@ RlcMacData  dlData;
              (ErrVal)ERGU025, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       dlData = NULLP;
    }
@@ -497,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));
 }
 
 
@@ -516,7 +494,7 @@ RlcMacData  dlData;
 *
 * @details
 *
-*     Function : unpackSendDlData
+*     Function : unpackDlData
 *
 *  @param[in]   Pst*  pst
 *  @param[in]   SpId  spId
@@ -524,34 +502,26 @@ RlcMacData  dlData;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
-PUBLIC S16 unpackSendDlData
+PUBLIC S16 unpackDlData
 (
-RguDDatReq func,
+RlcMacDlData func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 unpackSendDlData(func, pst, mBuf)
-RguDDatReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId spId;
-//   RguDDatReqInfo *datReq;
    RlcMacData *dlData;
    
-   TRC3(unpackSendDlData)
+   TRC3(unpackDlData)
 
    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 
    {
@@ -563,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 */
@@ -581,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));
 }
 
 
@@ -607,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)      
@@ -631,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
    {
@@ -648,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, 
@@ -659,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));
 }
 
 
@@ -693,38 +639,15 @@ RlcMacData  *ulData;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
-PUBLIC S16 unpackRcvdUlData
-(
-RguDDatInd func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 unpackRcvdUlData(func, pst, mBuf)
-RguDDatInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+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 
    {
@@ -736,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)      
@@ -747,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));
 }
 
 
@@ -789,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;
 }
 
 
@@ -838,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;
 }
 
 /**
@@ -883,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
    {
@@ -900,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) {
@@ -910,7 +833,7 @@ RguL2MUlThrpMeasReqInfo* measReq;
              (ErrVal)ERGU052, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       measReq = NULLP;
    }
@@ -927,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));
 }
 
 
@@ -976,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 
    {
@@ -992,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)      
@@ -1003,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
@@ -1021,7 +944,7 @@ Buffer *mBuf;
 *
 * @details
 *
-*     Function : packSendBOStatus,
+*     Function : packBOStatus,
 *
 *  @param[in]   Pst*  pst
 *  @param[in]   SpId  spId
@@ -1029,19 +952,12 @@ Buffer *mBuf;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
-PUBLIC S16 packSendBOStatus
+PUBLIC uint16_t packBOStatus
 (
 Pst* pst,
 SpId spId,
 RlcMacBOStatus  *boStatus
 )
-#else
-PUBLIC S16 packSendBOStatus(pst, spId, staRsp)
-Pst* pst;
-SpId spId;
-RlcMacBOStatus  *boStatus;
-#endif
 {
    RlcMacBOStatus  *boStaInfo = NULL;
    Buffer *mBuf = NULLP;
@@ -1053,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)); 
@@ -1071,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
    {
@@ -1086,7 +1002,7 @@ RlcMacBOStatus  *boStatus;
             (ErrVal)ERGU057, (ErrVal)0, "Packing failed");
 #endif      
         SPutMsg(mBuf);
-        RETVALUE(RFAILED);
+        return RFAILED;
      }
    }
    if (SPkS16(spId, mBuf) != ROK) {
@@ -1100,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);
 }
 
@@ -1115,7 +1031,7 @@ RlcMacBOStatus  *boStatus;
 *
 * @details
 *
-*     Function : unpackSendBOStatus
+*     Function : unpackBOStatus
 *
 *  @param[in]   Pst*  pst
 *  @param[in]   SpId  spId
@@ -1123,24 +1039,17 @@ RlcMacBOStatus  *boStatus;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
-PUBLIC S16 unpackSendBOStatus
+PUBLIC uint16_t unpackBOStatus
 (
-RguDStaRsp func,
+RlcMacBoStatus func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 unpackSendBOStatus(func, pst, mBuf)
-RguDStaRsp func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SpId spId;
    RlcMacBOStatus *boSta;
 
-   TRC3(unpackSendBOStatus)
+   TRC3(unpackBOStatus)
 
    if (SUnpkS16(&spId, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -1149,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
    {
@@ -1166,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)      
@@ -1176,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;
 }
 
 
@@ -1234,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));
@@ -1250,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);
    }
@@ -1284,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)
@@ -1302,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));
 }
 
 
@@ -1353,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
    {   
@@ -1375,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      
    }
@@ -1398,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 */
 
@@ -1419,19 +1328,12 @@ Buffer *mBuf;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
 PUBLIC S16 packSchedRep
 (
 Pst* pst,
 SuId suId,
-RlcMacSchedRep  * schRep
+RlcMacSchedRepInfo  * schRep
 )
-#else
-PUBLIC S16 packSchedRep(pst, suId, staInd)
-Pst* pst;
-SuId suId;
-RlcMacSchedRep  * schRep;
-#endif
 {
    Buffer *mBuf = NULLP;
    TRC3(packSchedRep)
@@ -1442,12 +1344,12 @@ RlcMacSchedRep  * schRep;
           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
           (ErrVal)ERGU076, (ErrVal)0, "Packing failed");
 #endif      
-      SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRep));
-      RETVALUE(RFAILED);
+      SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
+      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
    {
@@ -1458,19 +1360,19 @@ RlcMacSchedRep  * schRep;
                (ErrVal)ERGU077, (ErrVal)0, "Packing failed");
 #endif      
         SPutSBuf(pst->region, pst->pool, (Data *)schRep, 
-                                         sizeof(RlcMacSchedRep));
+                                         sizeof(RlcMacSchedRepInfo));
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       } 
       if (SPutSBuf(pst->region, pst->pool, (Data *)schRep,
-                                  sizeof(RlcMacSchedRep)) != ROK) {
+                                  sizeof(RlcMacSchedRepInfo)) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
              (ErrVal)ERGU079, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       schRep= NULLP;
    }
@@ -1482,14 +1384,14 @@ RlcMacSchedRep  * schRep;
 #endif      
       if (schRep != NULLP)
       {
-         SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRep));
+         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));
 }
 
 
@@ -1509,23 +1411,15 @@ RlcMacSchedRep  * schRep;
 *  @return   S16
 *      -# ROK
 **/
-#ifdef ANSI
 PUBLIC S16 unpackSchedRep
 (
-RguDStaInd func,
+RlcMacSchedRep func,
 Pst *pst,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 unpackSchedRep(func, pst, mBuf)
-RguDStaInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
 {
    SuId suId;
-//   RguDStaIndInfo *staInd;
-   RlcMacSchedRep *schRep;
+   RlcMacSchedRepInfo *schRep;
    
    TRC3(unpackSchedRep)
 
@@ -1536,22 +1430,22 @@ 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 
    {
-      if ((SGetSBuf(pst->region, pst->pool, (Data **)&schRep, sizeof(RlcMacSchedRep))) != ROK) {
+      if ((SGetSBuf(pst->region, pst->pool, (Data **)&schRep, sizeof(RlcMacSchedRepInfo))) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (unpackSchedRepInfo(schRep, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)      
@@ -1560,12 +1454,12 @@ Buffer *mBuf;
              (ErrVal)ERGU082, (ErrVal)0, "UnPacking failed");
 #endif      
          SPutMsg(mBuf);
-         SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRep));
-         RETVALUE(RFAILED);
+         SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
+         return RFAILED;
       }
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, suId, schRep));
+   return ((*func)(pst, suId, schRep));
 }
 
 #ifdef ANSI
@@ -1581,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
@@ -1608,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
@@ -1633,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;
 }
 
 /**
@@ -1676,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
    {
@@ -1691,7 +1585,7 @@ RguFlowCntrlInd   *flowCntrlInd;
                (ErrVal)ERGU077, (ErrVal)0, "Packing failed");
 #endif      
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       } 
    }
    if (SPkS16(suId, mBuf) != ROK) {
@@ -1701,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
@@ -1723,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
@@ -1743,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
@@ -1768,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;
 }
 
 /**
@@ -1817,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 
    {
@@ -1832,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)      
@@ -1842,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));
 }
 
 /***********************************************************
@@ -1885,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;
 }
 
 
@@ -1929,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;
 }
 
 
@@ -1974,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;
 }
 
 
@@ -2019,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;
 }
 
 
@@ -2064,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);
    }
@@ -2078,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;
 }
 
 
@@ -2128,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;
@@ -2141,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;
 }
 
 
@@ -2189,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;
 }
 
 
@@ -2234,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;
 }
 
 
@@ -2275,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;
 }
 
 
@@ -2334,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;
 }
 
 
@@ -2403,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;
 }
 
 
@@ -2474,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++) 
       {
@@ -2490,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;
 }
 
 
@@ -2535,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;
 }
 
 
@@ -2585,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;
 }
 
 
@@ -2625,7 +2519,7 @@ Buffer *mBuf;
 
       CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2662,7 +2556,7 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2700,22 +2594,22 @@ Buffer *mBuf;
 
    TRC3(packRlcMacDataInfo);
 
-   for (i=param->nmbPdu-1; i >= 0; i--)
+   for (i=param->numPdu-1; i >= 0; i--)
    {
-      MsgLen msgLen = 0;
-      if (SFndLenMsg(param->pduInfo[i].pduBuf, &msgLen) != ROK)
-         RETVALUE(RFAILED);
-      if (SCatMsg(mBuf, param->pduInfo[i].pduBuf, M1M2) != ROK)
-          RETVALUE(RFAILED);      
+      msgLen = 0;
+      //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;
 }
 
 
@@ -2752,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(cmPkMsgLen, &param->pduInfo[i].pduLen, 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;
 }
 
 
@@ -2811,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;
 }
 
 
@@ -2866,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;
@@ -2875,9 +2769,9 @@ Buffer *mBuf;
          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
          break;
       default :
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2915,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 */
 
 
@@ -2956,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 */
 
 
@@ -2996,7 +2890,7 @@ Buffer *mBuf;
 
    CMCHKPK(SPkS16, param->totBufSize, mBuf);
    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3034,7 +2928,7 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->totBufSize, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3071,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;
 }
 
 
@@ -3115,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;
 }
 
 
@@ -3143,19 +3037,12 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
 PUBLIC S16 packSchedRepInfo
 (
-RlcMacSchedRep *param,
+RlcMacSchedRepInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 packSchedRepInfo(param, mBuf)
-RlcMacSchedRep *param;
-Buffer *mBuf;
-#endif
 {
-   S32 i;
    S32 idx;
 
    TRC3(packSchedRepInfo);
@@ -3163,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 */
 
 
@@ -3191,19 +3078,12 @@ Buffer *mBuf;
 *     File  : 
 *
 **********************************************************/
-#ifdef ANSI
 PUBLIC S16 unpackSchedRepInfo
 (
-RlcMacSchedRep *param,
+RlcMacSchedRepInfo *param,
 Buffer *mBuf
 )
-#else
-PUBLIC S16 unpackSchedRepInfo(param, mBuf)
-RlcMacSchedRep *param;
-Buffer *mBuf;
-#endif
 {
-   S32 i;
    S32 idx;
 
    TRC3(unpackSchedRepInfo);
@@ -3211,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