X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Flrg.c;h=054df2073e19045b1ec80d174ed13f047488f18a;hb=0a26c487f1b6bbb5217e47b15fa8273b2e749283;hp=08ad06247478b06aa3937b2aba1c65064f41c662;hpb=829bbd114f1c3dc00c1da47bca0a8207c049df3f;p=o-du%2Fl2.git

diff --git a/src/cm/lrg.c b/src/cm/lrg.c
index 08ad06247..054df2073 100755
--- a/src/cm/lrg.c
+++ b/src/cm/lrg.c
@@ -35,25 +35,9 @@
 */
 
 /* 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 "lrg.h"           /* LRG 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 "lrg.x"           /* LRG Interface includes */
 
 #if (defined(LCLRG))
@@ -73,13 +57,13 @@ Configuration Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgCfgReq
+S16 cmPkLrgCfgReq
 (
 Pst * pst,
 RgMngmt * cfg
 )
 #else
-PUBLIC S16 cmPkLrgCfgReq(pst, cfg)
+S16 cmPkLrgCfgReq(pst, cfg)
 Pst * pst;
 RgMngmt * cfg;
 #endif
@@ -93,9 +77,9 @@ RgMngmt * cfg;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG001, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cfg, EVTLRGCFGREQ, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -103,11 +87,11 @@ RgMngmt * cfg;
             (ErrVal)ELRG002, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    pst->event = (Event) EVTLRGCFGREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -125,14 +109,14 @@ Configuration Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgCfgReq
+S16 cmUnpkLrgCfgReq
 (
 LrgCfgReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgCfgReq(func, pst, mBuf)
+S16 cmUnpkLrgCfgReq(func, pst, mBuf)
 LrgCfgReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -150,10 +134,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG003, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfg));
+   return ((*func)(pst, &cfg));
 }
 
 
@@ -171,13 +155,13 @@ Configuration Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchCfgReq
+S16 cmPkLrgSchCfgReq
 (
 Pst * pst,
 RgMngmt * cfg
 )
 #else
-PUBLIC S16 cmPkLrgSchCfgReq(pst, cfg)
+S16 cmPkLrgSchCfgReq(pst, cfg)
 Pst * pst;
 RgMngmt * cfg;
 #endif
@@ -191,22 +175,21 @@ RgMngmt * cfg;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG004, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
-      if (cmPkRgMngmt(pst, cfg, EVTLRGSCHCFGREQ, mBuf) != ROK) {
+   if (pst->selector == ODU_SELECTOR_LC) {
+      if (cmPkRgMngmt(pst, cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG005, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
-   pst->event = (Event) EVTLRGSCHCFGREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -224,14 +207,14 @@ Configuration Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCfgReq
+S16 cmUnpkLrgSchCfgReq
 (
 LrgSchCfgReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchCfgReq(func, pst, mBuf)
+S16 cmUnpkLrgSchCfgReq(func, pst, mBuf)
 LrgSchCfgReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -242,17 +225,17 @@ Buffer *mBuf;
    
    TRC3(cmUnpkLrgSchCfgReq)
 
-   if (cmUnpkRgMngmt(pst, &cfg, EVTLRGSCHCFGREQ, mBuf) != ROK) {
+   if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG006, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfg));
+   return ((*func)(pst, &cfg));
 }
 
 
@@ -270,13 +253,13 @@ Configuration Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgCfgCfm
+S16 cmPkLrgCfgCfm
 (
 Pst * pst,
 RgMngmt * cfm
 )
 #else
-PUBLIC S16 cmPkLrgCfgCfm(pst, cfm)
+S16 cmPkLrgCfgCfm(pst, cfm)
 Pst * pst;
 RgMngmt * cfm;
 #endif
@@ -290,9 +273,9 @@ RgMngmt * cfm;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG007, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cfm, EVTLRGCFGCFM, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -300,12 +283,12 @@ RgMngmt * cfm;
             (ErrVal)ELRG008, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGCFGCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -323,14 +306,14 @@ Configuration Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgCfgCfm
+S16 cmUnpkLrgCfgCfm
 (
 LrgCfgCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgCfgCfm(func, pst, mBuf)
+S16 cmUnpkLrgCfgCfm(func, pst, mBuf)
 LrgCfgCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -347,10 +330,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG009, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfm));
+   return ((*func)(pst, &cfm));
 }
 
 
@@ -368,13 +351,13 @@ Configuration Confirm from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchCfgCfm
+S16 cmPkLrgSchCfgCfm
 (
 Pst * pst,
 RgMngmt * cfg
 )
 #else
-PUBLIC S16 cmPkLrgSchCfgCfm(pst, cfg)
+S16 cmPkLrgSchCfgCfm(pst, cfg)
 Pst * pst;
 RgMngmt * cfg;
 #endif
@@ -388,22 +371,22 @@ RgMngmt * cfg;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG010, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
-      if (cmPkRgMngmt(pst, cfg, EVTLRGSCHCFGCFM, mBuf) != ROK) {
+   if (pst->selector == ODU_SELECTOR_LC) {
+      if (cmPkRgMngmt(pst, cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG011, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
-   pst->event = (Event) EVTLRGSCHCFGCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   pst->event = (Event) EVTMACSCHGENCFGCFM;
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -421,14 +404,14 @@ Configuration Confirm from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCfgCfm
+S16 cmUnpkLrgSchCfgCfm
 (
 LrgSchCfgCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchCfgCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchCfgCfm(func, pst, mBuf)
 LrgSchCfgCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -438,17 +421,17 @@ Buffer *mBuf;
    
    TRC3(cmUnpkLrgSchCfgCfm)
   
-   if (cmUnpkRgMngmt(pst, &cfg, EVTLRGSCHCFGCFM, mBuf) != ROK) {
+   if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
       SPutMsg(mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG012, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfg));
+   return ((*func)(pst, &cfg));
 }
 
 
@@ -466,13 +449,13 @@ Statistics Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgStsReq
+S16 cmPkLrgStsReq
 (
 Pst * pst,
 RgMngmt * sts
 )
 #else
-PUBLIC S16 cmPkLrgStsReq(pst, sts)
+S16 cmPkLrgStsReq(pst, sts)
 Pst * pst;
 RgMngmt * sts;
 #endif
@@ -486,9 +469,9 @@ RgMngmt * sts;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG013, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, sts, EVTLRGSTSREQ, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -496,12 +479,12 @@ RgMngmt * sts;
             (ErrVal)ELRG014, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGSTSREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -519,14 +502,14 @@ Statistics Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgStsReq
+S16 cmUnpkLrgStsReq
 (
 LrgStsReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgStsReq(func, pst, mBuf)
+S16 cmUnpkLrgStsReq(func, pst, mBuf)
 LrgStsReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -543,10 +526,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG015, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &sts));
+   return ((*func)(pst, &sts));
 }
 
 
@@ -564,13 +547,13 @@ Statistics Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgStsCfm
+S16 cmPkLrgStsCfm
 (
 Pst * pst,
 RgMngmt * cfm
 )
 #else
-PUBLIC S16 cmPkLrgStsCfm(pst, cfm)
+S16 cmPkLrgStsCfm(pst, cfm)
 Pst * pst;
 RgMngmt * cfm;
 #endif
@@ -584,9 +567,9 @@ RgMngmt * cfm;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG016, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cfm, EVTLRGSTSCFM, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -594,12 +577,12 @@ RgMngmt * cfm;
             (ErrVal)ELRG017, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGSTSCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -617,14 +600,14 @@ Statistics Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgStsCfm
+S16 cmUnpkLrgStsCfm
 (
 LrgStsCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgStsCfm(func, pst, mBuf)
+S16 cmUnpkLrgStsCfm(func, pst, mBuf)
 LrgStsCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -641,10 +624,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG018, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfm));
+   return ((*func)(pst, &cfm));
 }
 
 
@@ -662,13 +645,13 @@ Status Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgStaReq
+S16 cmPkLrgStaReq
 (
 Pst * pst,
 RgMngmt * sta
 )
 #else
-PUBLIC S16 cmPkLrgStaReq(pst, sta)
+S16 cmPkLrgStaReq(pst, sta)
 Pst * pst;
 RgMngmt * sta;
 #endif
@@ -682,7 +665,7 @@ RgMngmt * sta;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG019, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgMngmt(pst, sta, EVTLRGSSTAREQ, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -691,11 +674,11 @@ RgMngmt * sta;
             (ErrVal)ELRG020, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    
    pst->event = (Event) EVTLRGSSTAREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -713,14 +696,14 @@ Status Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaReq
+S16 cmUnpkLrgStaReq
 (
 LrgStaReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgStaReq(func, pst, mBuf)
+S16 cmUnpkLrgStaReq(func, pst, mBuf)
 LrgStaReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -738,10 +721,10 @@ Buffer *mBuf;
             (ErrVal)ELRG021, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &sta));
+   return ((*func)(pst, &sta));
 }
 
 
@@ -759,13 +742,13 @@ Status Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgStaCfm
+S16 cmPkLrgStaCfm
 (
 Pst * pst,
 RgMngmt * cfm
 )
 #else
-PUBLIC S16 cmPkLrgStaCfm(pst, cfm)
+S16 cmPkLrgStaCfm(pst, cfm)
 Pst * pst;
 RgMngmt * cfm;
 #endif
@@ -779,7 +762,7 @@ RgMngmt * cfm;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG022, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if (cmPkRgMngmt(pst, cfm, EVTLRGSSTACFM, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -788,11 +771,11 @@ RgMngmt * cfm;
             (ErrVal)ELRG023, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    
    pst->event = (Event) EVTLRGSSTACFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -810,14 +793,14 @@ Status Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaCfm
+S16 cmUnpkLrgStaCfm
 (
 LrgStaCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgStaCfm(func, pst, mBuf)
+S16 cmUnpkLrgStaCfm(func, pst, mBuf)
 LrgStaCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -835,10 +818,10 @@ Buffer *mBuf;
             (ErrVal)ELRG024, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfm));
+   return ((*func)(pst, &cfm));
 }
 
 
@@ -856,13 +839,13 @@ Status Indication from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgStaInd
+S16 cmPkLrgStaInd
 (
 Pst * pst,
 RgMngmt * usta
 )
 #else
-PUBLIC S16 cmPkLrgStaInd(pst, usta)
+S16 cmPkLrgStaInd(pst, usta)
 Pst * pst;
 RgMngmt * usta;
 #endif
@@ -876,9 +859,9 @@ RgMngmt * usta;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG025, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, usta, EVTLRGUSTAIND, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -886,12 +869,12 @@ RgMngmt * usta;
             (ErrVal)ELRG026, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGUSTAIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -909,14 +892,14 @@ Status Indication from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgStaInd
+S16 cmUnpkLrgStaInd
 (
 LrgStaInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgStaInd(func, pst, mBuf)
+S16 cmUnpkLrgStaInd(func, pst, mBuf)
 LrgStaInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -933,10 +916,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG027, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &usta));
+   return ((*func)(pst, &usta));
 }
 
 
@@ -954,13 +937,13 @@ Status Indication from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchStaInd
+S16 cmPkLrgSchStaInd
 (
 Pst * pst,
 RgMngmt * sta
 )
 #else
-PUBLIC S16 cmPkLrgSchStaInd(pst, sta)
+S16 cmPkLrgSchStaInd(pst, sta)
 Pst * pst;
 RgMngmt * sta;
 #endif
@@ -974,9 +957,9 @@ RgMngmt * sta;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG028, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -984,12 +967,12 @@ RgMngmt * sta;
             (ErrVal)ELRG029, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGSCHSTAIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -1007,14 +990,14 @@ Status Indication from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchStaInd
+S16 cmUnpkLrgSchStaInd
 (
 LrgSchStaInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchStaInd(func, pst, mBuf)
+S16 cmUnpkLrgSchStaInd(func, pst, mBuf)
 LrgSchStaInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -1031,10 +1014,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG030, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &sta));
+   return ((*func)(pst, &sta));
 }
 
 
@@ -1052,13 +1035,13 @@ Control Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgCntrlReq
+S16 cmPkLrgCntrlReq
 (
 Pst * pst,
 RgMngmt * cntrl
 )
 #else
-PUBLIC S16 cmPkLrgCntrlReq(pst, cntrl)
+S16 cmPkLrgCntrlReq(pst, cntrl)
 Pst * pst;
 RgMngmt * cntrl;
 #endif
@@ -1072,9 +1055,9 @@ RgMngmt * cntrl;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG031, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -1082,12 +1065,12 @@ RgMngmt * cntrl;
             (ErrVal)ELRG032, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGCNTRLREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -1105,14 +1088,14 @@ Control Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgCntrlReq
+S16 cmUnpkLrgCntrlReq
 (
 LrgCntrlReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgCntrlReq(func, pst, mBuf)
+S16 cmUnpkLrgCntrlReq(func, pst, mBuf)
 LrgCntrlReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -1129,10 +1112,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG033, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cntrl));
+   return ((*func)(pst, &cntrl));
 }
 
 
@@ -1150,13 +1133,13 @@ Control Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchCntrlReq
+S16 cmPkLrgSchCntrlReq
 (
 Pst * pst,
 RgMngmt * cntrl
 )
 #else
-PUBLIC S16 cmPkLrgSchCntrlReq(pst, cntrl)
+S16 cmPkLrgSchCntrlReq(pst, cntrl)
 Pst * pst;
 RgMngmt * cntrl;
 #endif
@@ -1170,9 +1153,9 @@ RgMngmt * cntrl;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG034, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -1180,12 +1163,12 @@ RgMngmt * cntrl;
             (ErrVal)ELRG035, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGSCHCNTRLREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -1203,14 +1186,14 @@ Control Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCntrlReq
+S16 cmUnpkLrgSchCntrlReq
 (
 LrgSchCntrlReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchCntrlReq(func, pst, mBuf)
+S16 cmUnpkLrgSchCntrlReq(func, pst, mBuf)
 LrgSchCntrlReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -1227,10 +1210,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG036, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cntrl));
+   return ((*func)(pst, &cntrl));
 }
 
 
@@ -1248,13 +1231,13 @@ Control Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgCntrlCfm
+S16 cmPkLrgCntrlCfm
 (
 Pst * pst,
 RgMngmt * cfm
 )
 #else
-PUBLIC S16 cmPkLrgCntrlCfm(pst, cfm)
+S16 cmPkLrgCntrlCfm(pst, cfm)
 Pst * pst;
 RgMngmt * cfm;
 #endif
@@ -1268,9 +1251,9 @@ RgMngmt * cfm;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG037, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -1278,12 +1261,12 @@ RgMngmt * cfm;
             (ErrVal)ELRG038, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGCNTRLCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -1301,14 +1284,14 @@ Control Confirm from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgCntrlCfm
+S16 cmUnpkLrgCntrlCfm
 (
 LrgCntrlCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLrgCntrlCfm(func, pst, mBuf)
 LrgCntrlCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -1325,10 +1308,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG039, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cfm));
+   return ((*func)(pst, &cfm));
 }
 
 
@@ -1346,13 +1329,13 @@ Control Confirm from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchCntrlCfm
+S16 cmPkLrgSchCntrlCfm
 (
 Pst * pst,
 RgMngmt * cntrl
 )
 #else
-PUBLIC S16 cmPkLrgSchCntrlCfm(pst, cntrl)
+S16 cmPkLrgSchCntrlCfm(pst, cntrl)
 Pst * pst;
 RgMngmt * cntrl;
 #endif
@@ -1366,9 +1349,9 @@ RgMngmt * cntrl;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG040, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       if (cmPkRgMngmt(pst, cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
@@ -1376,12 +1359,12 @@ RgMngmt * cntrl;
             (ErrVal)ELRG041, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(mBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
    
    pst->event = (Event) EVTLRGSCHCNTRLCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -1399,14 +1382,14 @@ Control Confirm from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchCntrlCfm
+S16 cmUnpkLrgSchCntrlCfm
 (
 LrgSchCntrlCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchCntrlCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchCntrlCfm(func, pst, mBuf)
 LrgSchCntrlCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -1423,10 +1406,10 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG042, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &cntrl));
+   return ((*func)(pst, &cntrl));
 }
 
 
@@ -1445,14 +1428,14 @@ Trace Indication from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgTrcInd
+S16 cmPkLrgTrcInd
 (
 Pst * pst,
 RgMngmt * trc,
 Buffer * trcBuf
 )
 #else
-PUBLIC S16 cmPkLrgTrcInd(pst, trc, trcBuf)
+S16 cmPkLrgTrcInd(pst, trc, trcBuf)
 Pst * pst;
 RgMngmt * trc;
 Buffer * trcBuf;
@@ -1468,9 +1451,9 @@ Buffer * trcBuf;
          (ErrVal)ELRG043, (ErrVal)0, "Packing failed");
 #endif
       SPutMsg(trcBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       MsgLen msgLen;
       if (SFndLenMsg(trcBuf, &msgLen) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1479,7 +1462,7 @@ Buffer * trcBuf;
             (ErrVal)ELRG044, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(trcBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       if (SCatMsg(mBuf, trcBuf, M1M2) != ROK) {
 #if (ERRCLASS & ERRCLS_ADD_RES)
@@ -1488,7 +1471,7 @@ Buffer * trcBuf;
             (ErrVal)ELRG045, (ErrVal)0, "Packing failed");
 #endif
          SPutMsg(trcBuf);
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
       SPutMsg(trcBuf);
       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
@@ -1501,11 +1484,11 @@ Buffer * trcBuf;
 #endif
       SPutMsg(trcBuf);
       SPutMsg(mBuf);
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    
    pst->event = (Event) EVTLRGTRCIND;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 
@@ -1524,14 +1507,14 @@ Trace Indication from MAC to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgTrcInd
+S16 cmUnpkLrgTrcInd
 (
 LrgTrcInd func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgTrcInd(func, pst, mBuf)
+S16 cmUnpkLrgTrcInd(func, pst, mBuf)
 LrgTrcInd func;
 Pst *pst;
 Buffer *mBuf;
@@ -1550,18 +1533,18 @@ Buffer *mBuf;
             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
             (ErrVal)ELRG047, (ErrVal)0, "Packing failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
-   if (pst->selector == LRG_SEL_LC) {
+   if (pst->selector == ODU_SELECTOR_LC) {
       MsgLen msgLen, totalMsgLen;
       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
       if (SSegMsg(mBuf, totalMsgLen-msgLen, &trcBuf) != ROK)
-         RETVALUE(RFAILED);
+         return RFAILED;
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &trc, trcBuf));
+   return ((*func)(pst, &trc, trcBuf));
 }
 
 
@@ -1581,13 +1564,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgGenCfg
+S16 cmPkRgGenCfg
 (
 RgGenCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgGenCfg(param, mBuf)
+S16 cmPkRgGenCfg(param, mBuf)
 RgGenCfg *param;
 Buffer *mBuf;
 #endif
@@ -1596,15 +1579,15 @@ Buffer *mBuf;
    TRC3(cmPkRgGenCfg)
 
 #ifdef LTE_ADV
-   CMCHKPK(SPkU8, param->isSCellActDeactAlgoEnable, mBuf);
-   CMCHKPK(SPkU8, param->forceCntrlSrbBoOnPCel, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->isSCellActDeactAlgoEnable, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->forceCntrlSrbBoOnPCel, mBuf);
 #endif
-   CMCHKPK(SPkU8, param->startCellId, mBuf);
-   CMCHKPK(SPkU8, param->numRguSaps, mBuf);
-   CMCHKPK(SPkU8, param->tmrRes, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->startCellId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numRguSaps, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->tmrRes, mBuf);
    CMCHKPK(cmPkMemoryId, &param->mem, mBuf);
    CMCHKPK(cmPkPst, &param->lmPst, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1625,13 +1608,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgGenCfg
+S16 cmUnpkRgGenCfg
 (
 RgGenCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgGenCfg(param, mBuf)
+S16 cmUnpkRgGenCfg(param, mBuf)
 RgGenCfg *param;
 Buffer *mBuf;
 #endif
@@ -1641,14 +1624,14 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkPst, &param->lmPst, mBuf);
    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->tmrRes, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numRguSaps, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->startCellId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->tmrRes, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numRguSaps, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->startCellId, mBuf);
 #ifdef LTE_ADV
-   CMCHKUNPK(SUnpkU8, &param->forceCntrlSrbBoOnPCel, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->isSCellActDeactAlgoEnable, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->forceCntrlSrbBoOnPCel, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->isSCellActDeactAlgoEnable, mBuf);
 #endif
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1669,13 +1652,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgUpSapCfg
+S16 cmPkRgUpSapCfg
 (
 RgUpSapCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgUpSapCfg(param, mBuf)
+S16 cmPkRgUpSapCfg(param, mBuf)
 RgUpSapCfg *param;
 Buffer *mBuf;
 #endif
@@ -1685,14 +1668,14 @@ Buffer *mBuf;
 
    CMCHKPK(SPkS16, param->suId, mBuf);
    CMCHKPK(SPkS16, param->spId, mBuf);
-   CMCHKPK(SPkU8, param->route, mBuf);
-   CMCHKPK(SPkU8, param->inst, mBuf);
-   CMCHKPK(SPkU8, param->ent, mBuf);
-   CMCHKPK(SPkU16, param->procId, mBuf);
-   CMCHKPK(SPkU8, param->prior, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->route, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->inst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ent, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->procId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->prior, mBuf);
    CMCHKPK(cmPkMemoryId, &param->mem, mBuf);
-   CMCHKPK(SPkU8, param->selector, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->selector, mBuf);
+   return ROK;
 }
 
 
@@ -1713,13 +1696,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgUpSapCfg
+S16 cmUnpkRgUpSapCfg
 (
 RgUpSapCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgUpSapCfg(param, mBuf)
+S16 cmUnpkRgUpSapCfg(param, mBuf)
 RgUpSapCfg *param;
 Buffer *mBuf;
 #endif
@@ -1727,16 +1710,16 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgUpSapCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->selector, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->selector, mBuf);
    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->prior, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->procId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ent, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->inst, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->route, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->prior, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->procId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ent, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->inst, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->route, mBuf);
    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->suId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1757,13 +1740,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgLowSapCfg
+S16 cmPkRgLowSapCfg
 (
 RgLowSapCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgLowSapCfg(param, mBuf)
+S16 cmPkRgLowSapCfg(param, mBuf)
 RgLowSapCfg *param;
 Buffer *mBuf;
 #endif
@@ -1774,14 +1757,14 @@ Buffer *mBuf;
    CMCHKPK(cmPkTmrCfg, &param->bndTmr, mBuf);
    CMCHKPK(SPkS16, param->suId, mBuf);
    CMCHKPK(SPkS16, param->spId, mBuf);
-   CMCHKPK(SPkU8, param->route, mBuf);
-   CMCHKPK(SPkU8, param->inst, mBuf);
-   CMCHKPK(SPkU8, param->ent, mBuf);
-   CMCHKPK(SPkU16, param->procId, mBuf);
-   CMCHKPK(SPkU8, param->prior, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->route, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->inst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->ent, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->procId, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->prior, mBuf);
    CMCHKPK(cmPkMemoryId, &param->mem, mBuf);
-   CMCHKPK(SPkU8, param->selector, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->selector, mBuf);
+   return ROK;
 }
 
 
@@ -1802,13 +1785,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgLowSapCfg
+S16 cmUnpkRgLowSapCfg
 (
 RgLowSapCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgLowSapCfg(param, mBuf)
+S16 cmUnpkRgLowSapCfg(param, mBuf)
 RgLowSapCfg *param;
 Buffer *mBuf;
 #endif
@@ -1816,17 +1799,17 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgLowSapCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->selector, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->selector, mBuf);
    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->prior, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->procId, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->ent, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->inst, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->route, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->prior, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->procId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->ent, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->inst, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->route, mBuf);
    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->suId, mBuf);
    CMCHKUNPK(cmUnpkTmrCfg, &param->bndTmr, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 #ifdef MAC_SCH_STATS
@@ -1848,13 +1831,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgAckNack
+S16 cmPkRgAckNack
 (
 RgAckNack *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgAckNack (param, mBuf)
+S16 cmPkRgAckNack (param, mBuf)
 RgAckNack *param;
 Buffer *mBuf;
 #endif
@@ -1862,11 +1845,11 @@ Buffer *mBuf;
 
    TRC3(cmPkRgAckNack)
 
-   CMCHKPK(SPkU16, param->numOfAcks, mBuf);
-   CMCHKPK(SPkU16, param->numOfNacks, mBuf);
-   CMCHKPK(SPkU8, param->mcs, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfAcks, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfNacks, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmPkRgAckNack */
 
 
@@ -1886,13 +1869,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSchNackAckStats
+S16 cmPkRgSchNackAckStats
 (
 RgSchNackAckStats *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSchNackAckStats (param, mBuf)
+S16 cmPkRgSchNackAckStats (param, mBuf)
 RgSchNackAckStats *param;
 Buffer *mBuf;
 #endif
@@ -1909,7 +1892,7 @@ Buffer *mBuf;
       CMCHKPK(cmPkRgAckNack, &param->dlCqiStat[i], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -1929,27 +1912,27 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgHqNumRetx
+S16 cmPkRgHqNumRetx
 (
 RgSchHqNumRetx *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgHqNumRetx (param, mBuf)
+S16 cmPkRgHqNumRetx (param, mBuf)
 RgSchHqNumRetx *param;
 Buffer *mBuf;
 #endif
 {
    TRC3(cmPkRgHqNumRetx)
 
-   CMCHKPK(SPkU32, param->totalTx, mBuf);
-   CMCHKPK(SPkU16, param->numOfHQ_4, mBuf);
-   CMCHKPK(SPkU16, param->numOfHQ_3, mBuf);
-   CMCHKPK(SPkU16, param->numOfHQ_2, mBuf);
-   CMCHKPK(SPkU16, param->numOfHQ_1, mBuf);
-   CMCHKPK(SPkU8, param->mcs, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->totalTx, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfHQ_4, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfHQ_3, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfHQ_2, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfHQ_1, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmPkRgHqNumRetx */
 
 
@@ -1969,13 +1952,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSchHqRetxStats
+S16 cmPkRgSchHqRetxStats
 (
 RgSchHqRetxStats *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSchHqRetxStats (param, mBuf)
+S16 cmPkRgSchHqRetxStats (param, mBuf)
 RgSchHqRetxStats *param;
 Buffer *mBuf;
 #endif
@@ -1992,7 +1975,7 @@ Buffer *mBuf;
       CMCHKPK(cmPkRgHqNumRetx, &param->dlCqiStat[i], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmPkRgSchHqRetxStats */
 
 /* unpcaking functions */
@@ -2013,13 +1996,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgAckNack
+S16 cmUnpkRgAckNack
 (
 RgAckNack *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgAckNack (param, mBuf)
+S16 cmUnpkRgAckNack (param, mBuf)
 RgAckNack *param;
 Buffer *mBuf;
 #endif
@@ -2027,11 +2010,11 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgAckNack)
 
-   CMCHKUNPK(SUnpkU8, &param->mcs, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfNacks, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfAcks, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfNacks, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfAcks, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnkRgAckNack */
 
 
@@ -2051,13 +2034,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSchNackAckStats
+S16 cmUnpkRgSchNackAckStats
 (
 RgSchNackAckStats *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSchNackAckStats (param, mBuf)
+S16 cmUnpkRgSchNackAckStats (param, mBuf)
 RgSchNackAckStats *param;
 Buffer *mBuf;
 #endif
@@ -2073,7 +2056,7 @@ Buffer *mBuf;
       CMCHKUNPK(cmUnpkRgAckNack, &param->ulCqiStat[i], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnpkRgSchNackAckStats */
 
 
@@ -2093,27 +2076,27 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgHqNumRetx
+S16 cmUnpkRgHqNumRetx
 (
 RgSchHqNumRetx *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgHqNumRetx (param, mBuf)
+S16 cmUnpkRgHqNumRetx (param, mBuf)
 RgSchHqNumRetx *param;
 Buffer *mBuf;
 #endif
 {
    TRC3(cmUnpkRgHqNumRetx)
 
-   CMCHKUNPK(SUnpkU8, &param->mcs, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfHQ_1, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfHQ_2, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfHQ_3, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfHQ_4, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->totalTx, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfHQ_1, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfHQ_2, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfHQ_3, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfHQ_4, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->totalTx, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnpkRgHqNumRetx */
 
 
@@ -2133,13 +2116,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSchHqRetxStats
+S16 cmUnpkRgSchHqRetxStats
 (
 RgSchHqRetxStats *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSchHqRetxStats (param, mBuf)
+S16 cmUnpkRgSchHqRetxStats (param, mBuf)
 RgSchHqRetxStats *param;
 Buffer *mBuf;
 #endif
@@ -2155,7 +2138,7 @@ Buffer *mBuf;
       CMCHKUNPK(cmUnpkRgHqNumRetx, &param->ulCqiStat[i], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* cmUnpkRgSchHqRetxStats */
 
 #endif /* MAC_SCH_STATS */
@@ -2177,13 +2160,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgGenSts
+S16 cmPkRgGenSts
 (
 RgGenSts *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgGenSts(param, mBuf)
+S16 cmPkRgGenSts(param, mBuf)
 RgGenSts *param;
 Buffer *mBuf;
 #endif
@@ -2195,10 +2178,10 @@ Buffer *mBuf;
    CMCHKPK(cmPkRgSchHqRetxStats, &param->hqRetxStats, mBuf);
    CMCHKPK(cmPkRgSchNackAckStats, &param->nackAckStats, mBuf);
 #endif /* MAC_SCH_STATS */
-   CMCHKPK(SPkU16, param->numCellCfg, mBuf);
-   CMCHKPK(SPkU32, param->numUeCfg, mBuf);
-   CMCHKPK(SPkU32, param->numHarqFail, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->numCellCfg, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->numUeCfg, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->numHarqFail, mBuf);
+   return ROK;
 }
 
 
@@ -2219,13 +2202,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgGenSts
+S16 cmUnpkRgGenSts
 (
 RgGenSts *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgGenSts(param, mBuf)
+S16 cmUnpkRgGenSts(param, mBuf)
 RgGenSts *param;
 Buffer *mBuf;
 #endif
@@ -2233,14 +2216,14 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgGenSts)
 
-   CMCHKUNPK(SUnpkU32, &param->numHarqFail, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->numUeCfg, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numCellCfg, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->numHarqFail, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->numUeCfg, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numCellCfg, mBuf);
 #ifdef MAC_SCH_STATS
    CMCHKUNPK(cmUnpkRgSchNackAckStats, &param->nackAckStats, mBuf);
    CMCHKUNPK(cmUnpkRgSchHqRetxStats, &param->hqRetxStats, mBuf);
 #endif /* MAC_SCH_STATS */
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2261,13 +2244,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSapSts
+S16 cmPkRgSapSts
 (
 RgSapSts *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSapSts(param, mBuf)
+S16 cmPkRgSapSts(param, mBuf)
 RgSapSts *param;
 Buffer *mBuf;
 #endif
@@ -2275,10 +2258,10 @@ Buffer *mBuf;
 
    TRC3(cmPkRgSapSts)
 
-   CMCHKPK(SPkU32, param->numPduDrop, mBuf);
-   CMCHKPK(SPkU32, param->numPduTxmit, mBuf);
-   CMCHKPK(SPkU32, param->numPduRcvd, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->numPduDrop, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->numPduTxmit, mBuf);
+   CMCHKPK(oduUnpackUInt32, param->numPduRcvd, mBuf);
+   return ROK;
 }
 
 
@@ -2299,13 +2282,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSapSts
+S16 cmUnpkRgSapSts
 (
 RgSapSts *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSapSts(param, mBuf)
+S16 cmUnpkRgSapSts(param, mBuf)
 RgSapSts *param;
 Buffer *mBuf;
 #endif
@@ -2313,10 +2296,10 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgSapSts)
 
-   CMCHKUNPK(SUnpkU32, &param->numPduRcvd, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->numPduTxmit, mBuf);
-   CMCHKUNPK(SUnpkU32, &param->numPduDrop, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt32, &param->numPduRcvd, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->numPduTxmit, mBuf);
+   CMCHKUNPK(oduPackUInt32, &param->numPduDrop, mBuf);
+   return ROK;
 }
 
 
@@ -2337,13 +2320,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSchInstCfg
+S16 cmPkRgSchInstCfg
 (
 RgSchInstCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSchInstCfg(param, mBuf)
+S16 cmPkRgSchInstCfg(param, mBuf)
 RgSchInstCfg *param;
 Buffer *mBuf;
 #endif
@@ -2361,10 +2344,10 @@ Buffer *mBuf;
    for (i=param->numSaps-1; i >= 0; i--) {
       CMCHKPK(cmPkRgUpSapCfg, &param->rgmSap[i], mBuf);
    }
-   CMCHKPK(SPkU8, param->numSaps, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->numSaps, mBuf);
    CMCHKPK(cmPkRgGenCfg, &param->genCfg, mBuf);
-   CMCHKPK(SPkU8, param->instId, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->instId, mBuf);
+   return ROK;
 }
 
 
@@ -2385,13 +2368,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSchInstCfg
+S16 cmUnpkRgSchInstCfg
 (
 RgSchInstCfg *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSchInstCfg(param, mBuf)
+S16 cmUnpkRgSchInstCfg(param, mBuf)
 RgSchInstCfg *param;
 Buffer *mBuf;
 #endif
@@ -2400,9 +2383,9 @@ Buffer *mBuf;
    S32 i;
    TRC3(cmUnpkRgSchInstCfg)
 
-   CMCHKUNPK(SUnpkU8, &param->instId, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->instId, mBuf);
    CMCHKUNPK(cmUnpkRgGenCfg, &param->genCfg, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numSaps, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numSaps, mBuf);
    for (i=0; i<param->numSaps; i++) {
       CMCHKUNPK(cmUnpkRgUpSapCfg, &param->rgmSap[i], mBuf);
    }
@@ -2412,7 +2395,7 @@ Buffer *mBuf;
    for (i=0; i<param->numSaps; i++) {
       CMCHKUNPK(cmUnpkRgLowSapCfg, &param->tfuSap[i], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2433,14 +2416,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgCfg
+S16 cmPkRgCfg
 (
 RgCfg *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgCfg(param, elmnt, mBuf)
+S16 cmPkRgCfg(param, elmnt, mBuf)
 RgCfg *param;
 S16 elmnt;
 Buffer *mBuf;
@@ -2466,9 +2449,9 @@ Buffer *mBuf;
             CMCHKPK(cmPkRgGenCfg, &param->s.genCfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2489,14 +2472,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgCfg
+S16 cmUnpkRgCfg
 (
 RgCfg *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgCfg(param, elmnt, mBuf)
+S16 cmUnpkRgCfg(param, elmnt, mBuf)
 RgCfg *param;
 S16 elmnt;
 Buffer *mBuf;
@@ -2522,9 +2505,9 @@ Buffer *mBuf;
             CMCHKUNPK(cmUnpkRgSchInstCfg, &param->s.schInstCfg, mBuf);
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2545,13 +2528,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSapSta
+S16 cmPkRgSapSta
 (
 RgSapSta *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSapSta(param, mBuf)
+S16 cmPkRgSapSta(param, mBuf)
 RgSapSta *param;
 Buffer *mBuf;
 #endif
@@ -2559,8 +2542,8 @@ Buffer *mBuf;
 
    TRC3(cmPkRgSapSta)
 
-   CMCHKPK(SPkU8, param->sapState, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->sapState, mBuf);
+   return ROK;
 }
 
 
@@ -2581,13 +2564,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSapSta
+S16 cmUnpkRgSapSta
 (
 RgSapSta *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSapSta(param, mBuf)
+S16 cmUnpkRgSapSta(param, mBuf)
 RgSapSta *param;
 Buffer *mBuf;
 #endif
@@ -2595,8 +2578,8 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgSapSta)
 
-   CMCHKUNPK(SUnpkU8, &param->sapState, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->sapState, mBuf);
+   return ROK;
 }
 
 
@@ -2617,14 +2600,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSts
+S16 cmPkRgSts
 (
 RgSts *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSts(param, elmnt, mBuf)
+S16 cmPkRgSts(param, elmnt, mBuf)
 RgSts *param;
 S16 elmnt;
 Buffer *mBuf;
@@ -2653,9 +2636,9 @@ Buffer *mBuf;
             break;
       }
    CMCHKPK(cmPkAction, param->action, mBuf);
-   CMCHKPK(SPkU8, param->sapInst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sapInst, mBuf);
    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2676,14 +2659,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSts
+S16 cmUnpkRgSts
 (
 RgSts *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSts(param, elmnt, mBuf)
+S16 cmUnpkRgSts(param, elmnt, mBuf)
 RgSts *param;
 S16 elmnt;
 Buffer *mBuf;
@@ -2693,7 +2676,7 @@ Buffer *mBuf;
    TRC3(cmUnpkRgSts)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->sapInst, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->sapInst, mBuf);
    CMCHKUNPK(cmUnpkAction, &param->action, mBuf);
       switch(elmnt) {
          case STGEN:
@@ -2714,7 +2697,7 @@ Buffer *mBuf;
          default :
             break;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2735,7 +2718,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSsta
+S16 cmPkRgSsta
 (
 Pst *pst,
 RgSsta *param,
@@ -2746,7 +2729,7 @@ U8 eventType,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
+S16 cmPkRgSsta(pst, param, elmnt, eventType, mBuf)
 Pst *pst;
 RgSsta *param;
 S16 elmnt;
@@ -2797,9 +2780,9 @@ Buffer *mBuf;
          default :
             break;
       }
-   CMCHKPK(SPkU8, param->sapInst, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->sapInst, mBuf);
    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2820,7 +2803,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSsta
+S16 cmUnpkRgSsta
 (
 Pst    *pst,
 RgSsta *param,
@@ -2828,7 +2811,7 @@ S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
+S16 cmUnpkRgSsta(pst, param, elmnt, mBuf)
 Pst    *pst;
 RgSsta *param;
 S16 elmnt;
@@ -2839,7 +2822,7 @@ Buffer *mBuf;
    TRC3(cmUnpkRgSsta)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->sapInst, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->sapInst, mBuf);
       switch(elmnt) {
          case STGEN:
             /*ccpu00118255 - ADD - Check for eventType before Unpack */
@@ -2854,7 +2837,7 @@ Buffer *mBuf;
                         (ErrVal)ELRG048, (ErrVal)0, "Packing failed");
 #endif
                   SPutMsg(mBuf);
-                  RETVALUE(RFAILED);
+                  return RFAILED;
                }
                /* KWORK_FIX: Moved the memset under the NULL check */
                if (param->s.sysId.ptNmb != NULLP)
@@ -2879,7 +2862,7 @@ Buffer *mBuf;
          default :
             break;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2900,13 +2883,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgUstaDgn
+S16 cmPkRgUstaDgn
 (
 RgUstaDgn *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgUstaDgn(param, mBuf)
+S16 cmPkRgUstaDgn(param, mBuf)
 RgUstaDgn *param;
 Buffer *mBuf;
 #endif
@@ -2921,8 +2904,8 @@ Buffer *mBuf;
          default :
             break;
       }
-   CMCHKPK(SPkU8, param->type, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+   return ROK;
 }
 
 
@@ -2943,13 +2926,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgUstaDgn
+S16 cmUnpkRgUstaDgn
 (
 RgUstaDgn *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgUstaDgn(param, mBuf)
+S16 cmUnpkRgUstaDgn(param, mBuf)
 RgUstaDgn *param;
 Buffer *mBuf;
 #endif
@@ -2957,7 +2940,7 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgUstaDgn)
 
-   CMCHKUNPK(SUnpkU8, &param->type, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
       switch(param->type) {
          case LRG_USTA_DGNVAL_MEM:
             CMCHKUNPK(cmUnpkMemoryId, &param->u.mem, mBuf);
@@ -2965,7 +2948,7 @@ Buffer *mBuf;
          default :
             break;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -2986,13 +2969,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgUsta
+S16 cmPkRgUsta
 (
 RgUsta *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgUsta(param, mBuf)
+S16 cmPkRgUsta(param, mBuf)
 RgUsta *param;
 Buffer *mBuf;
 #endif
@@ -3002,7 +2985,7 @@ Buffer *mBuf;
 
    CMCHKPK(cmPkRgUstaDgn, &param->dgn, mBuf);
    CMCHKPK(cmPkCmAlarm, &param->cmAlarm, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3023,13 +3006,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgUsta
+S16 cmUnpkRgUsta
 (
 RgUsta *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgUsta(param, mBuf)
+S16 cmUnpkRgUsta(param, mBuf)
 RgUsta *param;
 Buffer *mBuf;
 #endif
@@ -3039,7 +3022,7 @@ Buffer *mBuf;
 
    CMCHKUNPK(cmUnpkCmAlarm, &param->cmAlarm, mBuf);
    CMCHKUNPK(cmUnpkRgUstaDgn, &param->dgn, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3060,13 +3043,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgTrc
+S16 cmPkRgTrc
 (
 RgTrc *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgTrc(param, mBuf)
+S16 cmPkRgTrc(param, mBuf)
 RgTrc *param;
 Buffer *mBuf;
 #endif
@@ -3074,9 +3057,9 @@ Buffer *mBuf;
 
    TRC3(cmPkRgTrc)
 
-   CMCHKPK(SPkU8, param->evnt, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->evnt, mBuf);
    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3097,13 +3080,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgTrc
+S16 cmUnpkRgTrc
 (
 RgTrc *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgTrc(param, mBuf)
+S16 cmUnpkRgTrc(param, mBuf)
 RgTrc *param;
 Buffer *mBuf;
 #endif
@@ -3112,8 +3095,8 @@ Buffer *mBuf;
    TRC3(cmUnpkRgTrc)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->evnt, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->evnt, mBuf);
+   return ROK;
 }
 
 
@@ -3134,13 +3117,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgDbgCntrl
+S16 cmPkRgDbgCntrl
 (
 RgDbgCntrl *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgDbgCntrl(param, mBuf)
+S16 cmPkRgDbgCntrl(param, mBuf)
 RgDbgCntrl *param;
 Buffer *mBuf;
 #endif
@@ -3148,8 +3131,8 @@ Buffer *mBuf;
 
    TRC3(cmPkRgDbgCntrl)
 
-   CMCHKPK(SPkU32, param->dbgMask, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt32, param->dbgMask, mBuf);
+   return ROK;
 }
 
 #ifdef PHY_ERROR_LOGING
@@ -3169,27 +3152,27 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSchUlAllocCntrl
+S16 cmPkRgSchUlAllocCntrl
 (
 RgSchUlAllocCntrl *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSchUlAllocCntrl(param, mBuf)
+S16 cmPkRgSchUlAllocCntrl(param, mBuf)
 RgSchUlAllocCntrl *param;
 Buffer *mBuf;
 #endif
 {
    TRC3(cmPkRgSchUlAllocCntrl)
 
-   CMCHKPK(SPkU8, param->mcs, mBuf);
-   CMCHKPK(SPkU16, param->numOfRb, mBuf);
-   CMCHKPK(SPkU16, param->rbStart, mBuf);
-   CMCHKPK(SPkU8, param->testStart, mBuf);
-   CMCHKPK(SPkU8, param->enaLog, mBuf);
-   CMCHKPK(SPkU16, param->logTime, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->numOfRb, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->rbStart, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->testStart, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->enaLog, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->logTime, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /***********************************************************
@@ -3208,27 +3191,27 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSchUlAllocCntrl
+S16 cmUnpkRgSchUlAllocCntrl
 (
 RgSchUlAllocCntrl *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSchUlAllocCntrl(param, mBuf)
+S16 cmUnpkRgSchUlAllocCntrl(param, mBuf)
 RgSchUlAllocCntrl *param;
 Buffer *mBuf;
 #endif
 {
    TRC3(cmUnpkRgSchUlAllocCntrl)
 
-   CMCHKUNPK(SUnpkU16, &param->logTime, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->enaLog, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->testStart, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->rbStart, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->numOfRb, mBuf);   
-   CMCHKUNPK(SUnpkU8, &param->mcs, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->logTime, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->enaLog, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->testStart, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->rbStart, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->numOfRb, mBuf);   
+   CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3250,13 +3233,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgDbgCntrl
+S16 cmUnpkRgDbgCntrl
 (
 RgDbgCntrl *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgDbgCntrl(param, mBuf)
+S16 cmUnpkRgDbgCntrl(param, mBuf)
 RgDbgCntrl *param;
 Buffer *mBuf;
 #endif
@@ -3264,8 +3247,8 @@ Buffer *mBuf;
 
    TRC3(cmUnpkRgDbgCntrl)
 
-   CMCHKUNPK(SUnpkU32, &param->dbgMask, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt32, &param->dbgMask, mBuf);
+   return ROK;
 }
 
 
@@ -3286,13 +3269,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgSapCntrl
+S16 cmPkRgSapCntrl
 (
 RgSapCntrl *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgSapCntrl(param, mBuf)
+S16 cmPkRgSapCntrl(param, mBuf)
 RgSapCntrl *param;
 Buffer *mBuf;
 #endif
@@ -3302,7 +3285,7 @@ Buffer *mBuf;
 
    CMCHKPK(SPkS16, param->spId, mBuf);
    CMCHKPK(SPkS16, param->suId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3323,13 +3306,13 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgSapCntrl
+S16 cmUnpkRgSapCntrl
 (
 RgSapCntrl *param,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgSapCntrl(param, mBuf)
+S16 cmUnpkRgSapCntrl(param, mBuf)
 RgSapCntrl *param;
 Buffer *mBuf;
 #endif
@@ -3339,7 +3322,7 @@ Buffer *mBuf;
 
    CMCHKUNPK(SUnpkS16, &param->suId, mBuf);
    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3360,14 +3343,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgCntrl
+S16 cmPkRgCntrl
 (
 RgCntrl *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgCntrl(param, elmnt, mBuf)
+S16 cmPkRgCntrl(param, elmnt, mBuf)
 RgCntrl *param;
 S16 elmnt;
 Buffer *mBuf;
@@ -3399,7 +3382,7 @@ Buffer *mBuf;
                   break;
 #ifdef SS_DIAG
                case SALOG:
-                  CMCHKPK(SPkU32,  param->s.logMask, mBuf);
+                  CMCHKPK(oduUnpackUInt32,  param->s.logMask, mBuf);
                   break;
 #endif
 #ifdef PHY_ERROR_LOGING
@@ -3414,10 +3397,10 @@ Buffer *mBuf;
          default :
             break;
       }
-   CMCHKPK(SPkU8, param->subAction, mBuf);
-   CMCHKPK(SPkU8, param->action, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->subAction, mBuf);
+   CMCHKPK(oduUnpackUInt8, param->action, mBuf);
    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3438,14 +3421,14 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgCntrl
+S16 cmUnpkRgCntrl
 (
 RgCntrl *param,
 S16 elmnt,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgCntrl(param, elmnt, mBuf)
+S16 cmUnpkRgCntrl(param, elmnt, mBuf)
 RgCntrl *param;
 S16 elmnt;
 Buffer *mBuf;
@@ -3455,8 +3438,8 @@ Buffer *mBuf;
    TRC3(cmUnpkRgCntrl)
 
    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->action, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->subAction, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->subAction, mBuf);
       switch(elmnt) {
          case STGEN:
             switch(param->subAction) {
@@ -3470,7 +3453,7 @@ Buffer *mBuf;
                   break;
 #ifdef SS_DIAG
                case SALOG:
-                  CMCHKUNPK(SUnpkU32, &param->s.logMask, mBuf);
+                  CMCHKUNPK(oduPackUInt32, &param->s.logMask, mBuf);
                   break;
 #endif
 #ifdef PHY_ERROR_LOGING
@@ -3495,7 +3478,7 @@ Buffer *mBuf;
          default :
             break;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3516,7 +3499,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmPkRgMngmt
+S16 cmPkRgMngmt
 (
 Pst *pst,
 RgMngmt *param,
@@ -3524,7 +3507,7 @@ U8 eventType,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmPkRgMngmt(pst, param, eventType, mBuf)
+S16 cmPkRgMngmt(pst, param, eventType, mBuf)
 Pst *pst;
 RgMngmt *param;
 U8 eventType;
@@ -3540,7 +3523,7 @@ Buffer *mBuf;
          case EVTLRGSCHCNTRLREQ:
          case  EVTLRGSCHCNTRLCFM:
             if(cmPkRgCntrl(&param->t.cntrl, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          case EVTLRGTRCIND:
             CMCHKPK(cmPkRgTrc, &param->t.trc, mBuf);
@@ -3555,33 +3538,33 @@ Buffer *mBuf;
 #ifdef LRG_V1
             if(cmPkRgSsta(pst, &param->t.ssta, param->hdr.elmId.elmnt,
                      eventType, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
 #else /* LRG_V1 is not defined */
             if(cmPkRgSsta(pst, &param->t.ssta, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
 #endif /* end of LRG_V1*/            
             break;
          case EVTLRGSTSREQ:
          case  EVTLRGSTSCFM:
             if(cmPkRgSts(&param->t.sts, param->hdr.elmId.elmnt, mBuf)!= ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          case EVTLRGCFGREQ:
          case  EVTLRGCFGCFM:
             if(cmPkRgCfg(&param->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
-         case EVTLRGSCHCFGREQ:
-         case  EVTLRGSCHCFGCFM:
+         case EVTMACSCHGENCFGREQ:
+         case  EVTMACSCHGENCFGCFM:
             if(cmPkRgCfg(&param->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
    CMCHKPK(cmPkCmStatus, &param->cfm, mBuf);
    CMCHKPK(cmPkHeader, &param->hdr, mBuf);
-   RETVALUE(ROK);
+   return ROK;
 }
 
 
@@ -3602,7 +3585,7 @@ Buffer *mBuf;
 *
 **********************************************************/
 #ifdef ANSI
-PUBLIC S16 cmUnpkRgMngmt
+S16 cmUnpkRgMngmt
 (
 Pst *pst,
 RgMngmt *param,
@@ -3610,7 +3593,7 @@ U8 eventType,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
+S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
 Pst *pst;
 RgMngmt *param;
 U8 eventType;
@@ -3625,20 +3608,20 @@ Buffer *mBuf;
       switch(eventType) {
          case EVTLRGCFGREQ:
          case  EVTLRGCFGCFM:
-         case EVTLRGSCHCFGREQ:
-         case  EVTLRGSCHCFGCFM:
+         case EVTMACSCHGENCFGREQ:
+         case  EVTMACSCHGENCFGCFM:
             if(cmUnpkRgCfg(&param->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          case EVTLRGSTSREQ:
          case  EVTLRGSTSCFM:
             if(cmUnpkRgSts(&param->t.sts, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          case EVTLRGSSTAREQ:
          case  EVTLRGSSTACFM:
             if(cmUnpkRgSsta(pst, &param->t.ssta, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          case EVTLRGUSTAIND:
          case EVTLRGSCHSTAIND:
@@ -3652,12 +3635,12 @@ Buffer *mBuf;
          case EVTLRGSCHCNTRLREQ:
          case  EVTLRGSCHCNTRLCFM:
             if(cmUnpkRgCntrl(&param->t.cntrl, param->hdr.elmId.elmnt, mBuf) != ROK)
-               RETVALUE(RFAILED);
+               return RFAILED;
             break;
          default :
-            RETVALUE(RFAILED);
+            return RFAILED;
       }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /* lrg_c_001.main_3 - ADD -  Added the functions pertaining to LTE_L2_MEAS  */
@@ -3694,11 +3677,11 @@ Buffer        *mBuf;
    
    for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
    {
-       CMCHKPK(SPkU8, nmbActvUeQci->qci[idx], mBuf);
+       CMCHKPK(oduUnpackUInt8, nmbActvUeQci->qci[idx], mBuf);
    }
-   CMCHKPK(SPkU8, nmbActvUeQci->numQci, mBuf);
-   CMCHKPK(SPkU8, nmbActvUeQci->sampPrd, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, nmbActvUeQci->numQci, mBuf);
+   CMCHKPK(oduUnpackUInt8, nmbActvUeQci->sampPrd, mBuf);
+   return ROK;
 }
 
 /**
@@ -3732,10 +3715,10 @@ Buffer        *mBuf;
    
    for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
    {
-       CMCHKPK(SPkU8, avgPrbQciReq->qci[idx], mBuf);
+       CMCHKPK(oduUnpackUInt8, avgPrbQciReq->qci[idx], mBuf);
    }
-   CMCHKPK(SPkU8, avgPrbQciReq->numQci, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, avgPrbQciReq->numQci, mBuf);
+   return ROK;
 
 }
 
@@ -3753,13 +3736,13 @@ L2 Measurement Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasReq
+S16 cmPkLrgSchL2MeasReq
 (
 Pst * pst,
 LrgSchMeasReqInfo  *measInfo
 )
 #else
-PUBLIC S16 cmPkLrgSchL2MeasReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasReq(pst, measInfo)
 Pst * pst;
 LrgSchMeasReqInfo  *measInfo;
 #endif
@@ -3773,7 +3756,7 @@ LrgSchMeasReqInfo  *measInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
    {
@@ -3793,11 +3776,11 @@ LrgSchMeasReqInfo  *measInfo;
    }
 
    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
-   CMCHKPK(SPkU32, measInfo->timePrd, mBuf);
-   CMCHKPK(SPkU16, measInfo->measType, mBuf);
+   CMCHKPK(oduUnpackUInt32, measInfo->timePrd, mBuf);
+   CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
    pst->event = (Event) EVTLRGSCHL2MEASREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 /**
 * @brief This API is used to stop a 
@@ -3813,13 +3796,13 @@ L2 Measurement Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasStopReq
+S16 cmPkLrgSchL2MeasStopReq
 (
 Pst * pst,
 LrgSchMeasStopReqInfo *measInfo
 )
 #else
-PUBLIC S16 cmPkLrgSchL2MeasStopReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasStopReq(pst, measInfo)
 Pst * pst;
 LrgSchMeasStopReqInfo *measInfo;
 #endif
@@ -3833,14 +3816,14 @@ LrgSchMeasStopReqInfo *measInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
-   /*CMCHKPK(SPkU16, measInfo->timePrd, mBuf);*/
-   CMCHKPK(SPkU16, measInfo->measType, mBuf);
+   /*CMCHKPK(oduUnpackUInt16, measInfo->timePrd, mBuf);*/
+   CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
    pst->event = (Event) EVTLRGSCHL2MEASSTOPREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }/*cmPkLrgSchL2MeasStopReq*/
 
 /**
@@ -3857,13 +3840,13 @@ L2 Measurement Request from LM to MAC.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasSendReq
+S16 cmPkLrgSchL2MeasSendReq
 (
 Pst * pst,
 LrgSchMeasSndReqInfo *measInfo
 )
 #else
-PUBLIC S16 cmPkLrgSchL2MeasSendReq(pst, measInfo)
+S16 cmPkLrgSchL2MeasSendReq(pst, measInfo)
 Pst * pst;
 LrgSchMeasSndReqInfo *measInfo;
 #endif
@@ -3876,14 +3859,14 @@ LrgSchMeasSndReqInfo *measInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
-   CMCHKPK(SPkU32, measInfo->timePrd, mBuf);
-   CMCHKPK(SPkU16, measInfo->measType, mBuf);
+   CMCHKPK(oduUnpackUInt32, measInfo->timePrd, mBuf);
+   CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
    pst->event = (Event) EVTLRGSCHL2MEASSENDREQ;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }/*cmPkLrgSchL2MeasSendReq*/
 
 /**
@@ -3914,14 +3897,14 @@ Buffer           *mBuf;
 
    TRC3(cmUnpkNmbActvUeQciReq)
 
-   CMCHKUNPK(SUnpkU8, &param->sampPrd, mBuf);
-   CMCHKUNPK(SUnpkU8, &param->numQci, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->sampPrd, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
    {
-      CMCHKUNPK(SUnpkU8, &param->qci[idx - 1], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->qci[idx - 1], mBuf);
    }
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /**
@@ -3952,12 +3935,12 @@ Buffer           *mBuf;
 
    TRC3(cmUnpkAvgPrbQciReq)
 
-   CMCHKUNPK(SUnpkU8, &param->numQci, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
    {
-      CMCHKUNPK(SUnpkU8, &param->qci[idx - 1], mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->qci[idx - 1], mBuf);
    }
-   RETVALUE(ROK);
+   return ROK;
 
 }
 
@@ -3976,14 +3959,14 @@ Measurement  Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasReq
+S16 cmUnpkLrgSchL2MeasReq
 (
 LrgSchL2MeasReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchL2MeasReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasReq(func, pst, mBuf)
 LrgSchL2MeasReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -3994,8 +3977,8 @@ Buffer *mBuf;
    TRC3(cmUnpkLrgSchL2MeasReq)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
-   CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
-   CMCHKUNPK(SUnpkU32, &measInfo.timePrd, mBuf);
+   CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
+   CMCHKUNPK(oduPackUInt32, &measInfo.timePrd, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
    {
@@ -4014,7 +3997,7 @@ Buffer *mBuf;
       CMCHKUNPK(cmUnpkNmbActvUeQciReq, &measInfo.nmbActvUeQciDl, mBuf);
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &measInfo));
+   return ((*func)(pst, &measInfo));
 }
 
 /**
@@ -4032,14 +4015,14 @@ Measurement  Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasStopReq
+S16 cmUnpkLrgSchL2MeasStopReq
 (
 LrgSchL2MeasStopReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchL2MeasStopReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasStopReq(func, pst, mBuf)
 LrgSchL2MeasStopReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -4050,11 +4033,11 @@ Buffer *mBuf;
    TRC3(cmUnpkLrgSchL2MeasStopReq)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
-   CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
-   /*CMCHKUNPK(SUnpkU16, &measInfo.timePrd, mBuf);*/
+   CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
+   /*CMCHKUNPK(oduPackUInt16, &measInfo.timePrd, mBuf);*/
    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &measInfo));
+   return ((*func)(pst, &measInfo));
 }/*cmUnpkLrgSchL2MeasStopReq*/
 
 /**
@@ -4072,14 +4055,14 @@ Measurement  Request from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasSendReq
+S16 cmUnpkLrgSchL2MeasSendReq
 (
 LrgSchL2MeasSendReq func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchL2MeasSendReq(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasSendReq(func, pst, mBuf)
 LrgSchL2MeasSendReq func;
 Pst *pst;
 Buffer *mBuf;
@@ -4087,11 +4070,11 @@ Buffer *mBuf;
 {
    LrgSchMeasSndReqInfo measInfo;
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
-   CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
-   CMCHKUNPK(SUnpkU32, &measInfo.timePrd, mBuf);
+   CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
+   CMCHKUNPK(oduPackUInt32, &measInfo.timePrd, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &measInfo));
+   return ((*func)(pst, &measInfo));
 }/*cmUnpkLrgSchL2MeasSendReq*/
 
 /**
@@ -4108,13 +4091,13 @@ L2 Measurement confirm from MAC to LM
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasStopCfm
+S16 cmPkLrgSchL2MeasStopCfm
 (
 Pst * pst,
 LrgSchMeasCfmInfo  *measInfo
 )
 #else
-PUBLIC S16 cmPkLrgSchL2MeasStopCfm(pst, measInfo)
+S16 cmPkLrgSchL2MeasStopCfm(pst, measInfo)
 Pst * pst;
 LrgSchMeasCfmInfo  *measInfo;
 #endif
@@ -4128,14 +4111,14 @@ LrgSchMeasCfmInfo  *measInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG050, (ErrVal)0, "SGetMsg failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
    CMCHKPK(cmPkCmStatus, &measInfo->cfm, mBuf);
-   CMCHKPK(SPkU16, measInfo->measType, mBuf);
+   CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
    pst->event = (Event) EVTLRGSCHL2MEASSTOPCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }/*cmPkLrgSchL2MeasStopCfm*/
 /**
 * @brief This API is used to Send a 
@@ -4151,14 +4134,14 @@ Measurement  Confirm from SCH to LM.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasStopCfm
+S16 cmUnpkLrgSchL2MeasStopCfm
 (
 LrgSchL2MeasStopCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchL2MeasStopCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasStopCfm(func, pst, mBuf)
 LrgSchL2MeasStopCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -4169,12 +4152,12 @@ Buffer *mBuf;
    TRC3(cmUnpkLrgSchL2MeasCfm)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
-   CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
+   CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
    CMCHKUNPK(cmUnpkCmStatus, &measInfo.cfm, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
 
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &measInfo));
+   return ((*func)(pst, &measInfo));
 }/*cmUnpkLrgSchL2MeasStopCfm*/
 
 /**
@@ -4208,12 +4191,12 @@ Buffer             *mBuf;
    for(idx = 0; idx < param->numQci; idx++)
    {
 /*LRG : Review Tag*/
-     CMCHKPK(SPkU8, param->numActvUeQci[idx].qciValue, mBuf);
-     CMCHKPK(SPkU8, param->numActvUeQci[idx].numActvUeQci, mBuf);
+     CMCHKPK(oduUnpackUInt8, param->numActvUeQci[idx].qciValue, mBuf);
+     CMCHKPK(oduUnpackUInt8, param->numActvUeQci[idx].numActvUeQci, mBuf);
 /*LRG : Review Tag*/
    }
-   CMCHKPK(SPkU8, param->numQci, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numQci, mBuf);
+   return ROK;
 }
 
 /**
@@ -4246,12 +4229,12 @@ Buffer             *mBuf;
    for(idx = 0; idx < param->numQci; idx++)
    {
 /*LRG : Review Tag*/
-      CMCHKPK(SPkU8, param->prbPercQci[idx].qciValue, mBuf);
-      CMCHKPK(SPkU8, param->prbPercQci[idx].prbPercQci, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->prbPercQci[idx].qciValue, mBuf);
+      CMCHKPK(oduUnpackUInt8, param->prbPercQci[idx].prbPercQci, mBuf);
 /*LRG : Review Tag*/
    } 
-   CMCHKPK(SPkU8, param->numQci, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->numQci, mBuf);
+   return ROK;
 }
 
 /**
@@ -4280,10 +4263,10 @@ Buffer             *mBuf;
 {
 
    TRC3(cmPkRaPrmbsCfm)
-   CMCHKPK(SPkU16, param->randSelPreHighRange, mBuf);
-   CMCHKPK(SPkU16, param->randSelPreLowRange, mBuf);
-   CMCHKPK(SPkU16, param->dedPreambles, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt16, param->randSelPreHighRange, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->randSelPreLowRange, mBuf);
+   CMCHKPK(oduUnpackUInt16, param->dedPreambles, mBuf);
+   return ROK;
 }
 
 /**
@@ -4312,8 +4295,8 @@ Buffer        *mBuf;
 {
 
    TRC3(cmPkAvgPrbCfm)
-   CMCHKPK(SPkU8, param->prbPerc, mBuf);
-   RETVALUE(ROK);
+   CMCHKPK(oduUnpackUInt8, param->prbPerc, mBuf);
+   return ROK;
 }
 
 /**
@@ -4330,13 +4313,13 @@ L2 Measurement confirm from MAC to LM
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmPkLrgSchL2MeasCfm
+S16 cmPkLrgSchL2MeasCfm
 (
 Pst * pst,
 LrgSchMeasCfmInfo  *measInfo
 )
 #else
-PUBLIC S16 cmPkLrgSchL2MeasCfm(pst, measInfo)
+S16 cmPkLrgSchL2MeasCfm(pst, measInfo)
 Pst * pst;
 LrgSchMeasCfmInfo  *measInfo;
 #endif
@@ -4351,7 +4334,7 @@ LrgSchMeasCfmInfo  *measInfo;
          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
          (ErrVal)ELRG050, (ErrVal)0, "SGetMsg failed");
 #endif
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
    {
@@ -4383,26 +4366,26 @@ LrgSchMeasCfmInfo  *measInfo;
    }
    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
    {
-      CMCHKPK(SPkU32, measInfo->tbTransDlTotalCnt, mBuf);
+      CMCHKPK(oduUnpackUInt32, measInfo->tbTransDlTotalCnt, mBuf);
    }   
    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
    {
-      CMCHKPK(SPkU32, measInfo->tbTransDlFaulty, mBuf);
+      CMCHKPK(oduUnpackUInt32, measInfo->tbTransDlFaulty, mBuf);
    }   
    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
    {
-      CMCHKPK(SPkU32, measInfo->tbTransUlTotalCnt, mBuf);
+      CMCHKPK(oduUnpackUInt32, measInfo->tbTransUlTotalCnt, mBuf);
    }   
    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
    {
-      CMCHKPK(SPkU32, measInfo->tbTransUlFaulty, mBuf);
+      CMCHKPK(oduUnpackUInt32, measInfo->tbTransUlFaulty, mBuf);
    }   
    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
    CMCHKPK(cmPkCmStatus, &measInfo->cfm, mBuf);
-   CMCHKPK(SPkU16, measInfo->measType, mBuf);
+   CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
    pst->event = (Event) EVTLRGSCHL2MEASCFM;
-   RETVALUE(SPstTsk(pst,mBuf));
+   return (SPstTsk(pst,mBuf));
 }
 
 /**
@@ -4432,15 +4415,15 @@ Buffer          *mBuf;
    U8          idx;
 
    TRC3(cmUnpkNumUeQciCfm)
-   CMCHKUNPK(SUnpkU8, &param->numQci, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
    {
 /*LRG : Review Tag*/
-       CMCHKUNPK(SUnpkU8, &param->numActvUeQci[idx - 1].numActvUeQci, mBuf);
-       CMCHKUNPK(SUnpkU8, &param->numActvUeQci[idx - 1].qciValue, mBuf);
+       CMCHKUNPK(oduPackUInt8, &param->numActvUeQci[idx - 1].numActvUeQci, mBuf);
+       CMCHKUNPK(oduPackUInt8, &param->numActvUeQci[idx - 1].qciValue, mBuf);
 /*LRG : Review Tag*/
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /**
@@ -4471,15 +4454,15 @@ Buffer          *mBuf;
 
    TRC3(cmUnpkAvgPrbQciCfm)
 
-   CMCHKUNPK(SUnpkU8, &param->numQci, mBuf);
+   CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
    for(idx = param->numQci; idx > 0; idx--)
    {
 /*LRG : Review Tag*/
-      CMCHKUNPK(SUnpkU8, &param->prbPercQci[idx - 1].prbPercQci, mBuf);
-      CMCHKUNPK(SUnpkU8, &param->prbPercQci[idx - 1].qciValue, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->prbPercQci[idx - 1].prbPercQci, mBuf);
+      CMCHKUNPK(oduPackUInt8, &param->prbPercQci[idx - 1].qciValue, mBuf);
 /*LRG : Review Tag*/
    }
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /**
@@ -4509,10 +4492,10 @@ Buffer         *mBuf;
 
    TRC3(cmUnpkRaPrmbsCfm)
 
-   CMCHKUNPK(SUnpkU16, &param->dedPreambles, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->randSelPreLowRange, mBuf);
-   CMCHKUNPK(SUnpkU16, &param->randSelPreHighRange, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt16, &param->dedPreambles, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->randSelPreLowRange, mBuf);
+   CMCHKUNPK(oduPackUInt16, &param->randSelPreHighRange, mBuf);
+   return ROK;
 }
 
 /**
@@ -4542,8 +4525,8 @@ Buffer         *mBuf;
 
    TRC3(cmUnpkAvgPrbCfm)
 
-   CMCHKUNPK(SUnpkU8, &param->prbPerc, mBuf);
-   RETVALUE(ROK);
+   CMCHKUNPK(oduPackUInt8, &param->prbPerc, mBuf);
+   return ROK;
 }
 
 /**
@@ -4560,14 +4543,14 @@ Measurement  Confirm from LM to SCH.
 *      -# ROK
 **/
 #ifdef ANSI
-PUBLIC S16 cmUnpkLrgSchL2MeasCfm
+S16 cmUnpkLrgSchL2MeasCfm
 (
 LrgSchL2MeasCfm func,
 Pst *pst,
 Buffer *mBuf
 )
 #else
-PUBLIC S16 cmUnpkLrgSchL2MeasCfm(func, pst, mBuf)
+S16 cmUnpkLrgSchL2MeasCfm(func, pst, mBuf)
 LrgSchL2MeasCfm func;
 Pst *pst;
 Buffer *mBuf;
@@ -4578,24 +4561,24 @@ Buffer *mBuf;
    TRC3(cmUnpkLrgSchL2MeasCfm)
 
    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
-   CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
+   CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
    CMCHKUNPK(cmUnpkCmStatus, &measInfo.cfm, mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
    {
-      CMCHKPK(SUnpkU32, &measInfo.tbTransUlFaulty, mBuf);
+      CMCHKPK(oduPackUInt32, &measInfo.tbTransUlFaulty, mBuf);
    }    
    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
    {
-      CMCHKPK(SUnpkU32, &measInfo.tbTransUlTotalCnt, mBuf);
+      CMCHKPK(oduPackUInt32, &measInfo.tbTransUlTotalCnt, mBuf);
    }   
    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
    {
-      CMCHKPK(SUnpkU32, &measInfo.tbTransDlFaulty, mBuf);
+      CMCHKPK(oduPackUInt32, &measInfo.tbTransDlFaulty, mBuf);
    }   
    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
    {
-      CMCHKPK(SUnpkU32, &measInfo.tbTransDlTotalCnt, mBuf);
+      CMCHKPK(oduPackUInt32, &measInfo.tbTransDlTotalCnt, mBuf);
    }   
    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_UL)
    {
@@ -4626,7 +4609,7 @@ Buffer *mBuf;
      CMCHKUNPK(cmUnpkNumUeQciCfm, &measInfo.numUeQciDlCfm, mBuf);
    }
    SPutMsg(mBuf);
-   RETVALUE((*func)(pst, &measInfo));
+   return ((*func)(pst, &measInfo));
 }
 #endif
 #endif