U8, U16, U32 data type changes

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

diff --git a/src/cm/ckw.c b/src/cm/ckw.c
index caad5b4..637ce78 100755 (executable)
--- a/src/cm/ckw.c
+++ b/src/cm/ckw.c
@@ -55,14 +55,14 @@ EXTERN "C" {
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwBndReq
+S16 cmPkCkwBndReq
 (
 Pst *pst,
 SuId suId,
 SpId spId
 )
 #else
-PUBLIC S16 cmPkCkwBndReq(pst, suId, spId)
+S16 cmPkCkwBndReq(pst, suId, spId)
 Pst *pst;
 SuId suId;
 SpId spId;
@@ -71,7 +71,6 @@ SpId spId;
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkCkwBndReq)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -83,13 +82,13 @@ SpId spId;
                (ErrVal)ECKW001, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW002, pst);
     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW003, pst);
     pst->event = (Event) CKW_EVT_BND_REQ;
 
-    RETVALUE(SPstTsk(pst,mBuf));
+    return (SPstTsk(pst,mBuf));
 } /*end of function cmPkCkwBndReq*/
 \f
 /*
@@ -106,14 +105,14 @@ SpId spId;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUbndReq
+S16 cmPkCkwUbndReq
 (
 Pst *pst,
 SpId spId,
 Reason reason
 )
 #else
-PUBLIC S16 cmPkCkwUbndReq(pst, spId, reason)
+S16 cmPkCkwUbndReq(pst, spId, reason)
 Pst *pst;
 SpId spId;
 Reason reason;
@@ -122,7 +121,6 @@ Reason reason;
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkCkwUbndReq)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -134,13 +132,13 @@ Reason reason;
                (ErrVal)ECKW004, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
     CMCHKPKLOG(SPkS16, reason, mBuf, ECKW005, pst);
     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW006, pst);
     pst->event = (Event) CKW_EVT_UBND_REQ;
 
-    RETVALUE(SPstTsk(pst,mBuf));
+    return (SPstTsk(pst,mBuf));
 } /*end of function cmPkCkwUbndReq*/
 \f
 /*
@@ -157,23 +155,22 @@ Reason reason;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwBndCfm
+S16 cmPkCkwBndCfm
 (
 Pst *pst,
 SuId suId,
-U8 status
+uint8_t status
 )
 #else
-PUBLIC S16 cmPkCkwBndCfm(pst, suId, status)
+S16 cmPkCkwBndCfm(pst, suId, status)
 Pst *pst;
 SuId suId;
-U8 status;
+uint8_t status;
 #endif
 {
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkCkwBndCfm)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -186,13 +183,13 @@ U8 status;
        }
 
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
-    CMCHKPKLOG(SPkU8, status, mBuf, ECKW008, pst);
+    CMCHKPKLOG(oduUnpackUInt8, status, mBuf, ECKW008, pst);
     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW009, pst);
     pst->event = (Event) CKW_EVT_BND_CFM;
 
-    RETVALUE(SPstTsk(pst,mBuf));
+    return (SPstTsk(pst,mBuf));
 } /*end of function cmPkCkwBndCfm*/
 
 \f
@@ -210,22 +207,21 @@ U8 status;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcTmInfo
+S16 cmPkRlcTmInfo
 (
 RlcTmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcTmInfo(param, mBuf)
+S16 cmPkRlcTmInfo(param, mBuf)
 RlcTmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkRlcTmInfo)
 
-    CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
+    CMCHKPK(oduUnpackUInt32, param->dl.buffSize, mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcTmInfo */
 
 \f
@@ -243,43 +239,42 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcUmInfo
+S16 cmPkRlcUmInfo
 (
 RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcUmInfo(param, mBuf)
+S16 cmPkRlcUmInfo(param, mBuf)
 RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkRlcUmInfo)
 
     switch(param->dir)
     {
        case CKW_CFG_DIR_DL:
           {
-             CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
+             CMCHKPK(oduUnpackUInt8, param->m.umInfo.dl.snLen, mBuf);
              break;
           }
        case CKW_CFG_DIR_UL:
           {
-             CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
-             CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
+             CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reOrdTmr, mBuf);
+             CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.snLen, mBuf);
              break;
           }
        /* Patch ckw_c_001.main_3 */
        case CKW_CFG_DIR_BOTH:
           {
-             CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
-             CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
-             CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
+             CMCHKPK(oduUnpackUInt8, param->m.umInfo.dl.snLen, mBuf);
+             CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reOrdTmr, mBuf);
+             CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.snLen, mBuf);
              break;
           }
     }
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcUmInfo */
 
 \f
@@ -297,32 +292,31 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcAmInfo
+S16 cmPkRlcAmInfo
 (
 RlcAmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcAmInfo(param, mBuf)
+S16 cmPkRlcAmInfo(param, mBuf)
 RlcAmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkRlcAmInfo)
 
     /* UP LINK */
-    CMCHKPK(SPkU8, param->ul.reOrdTmr, mBuf);
-    CMCHKPK(SPkU16, param->ul.staProhTmr, mBuf);
-    CMCHKPK(SPkU8, param->ul.snLen, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->ul.reOrdTmr, mBuf);
+    CMCHKPK(oduUnpackUInt16, param->ul.staProhTmr, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->ul.snLen, mBuf);
 
     /* DOWN LINK */
-    CMCHKPK(SPkU8, param->dl.maxRetx, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->dl.maxRetx, mBuf);
     CMCHKPK(SPkS32, param->dl.pollByte, mBuf);
     CMCHKPK(SPkS16, param->dl.pollPdu, mBuf);
-    CMCHKPK(SPkU16, param->dl.pollRetxTmr, mBuf);
-    CMCHKPK(SPkU8, param->dl.snLen, mBuf);
+    CMCHKPK(oduUnpackUInt16, param->dl.pollRetxTmr, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->dl.snLen, mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcAmInfo */
 
 \f
@@ -340,23 +334,22 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwLChInfo
+S16 cmPkCkwLChInfo
 (
 CkwLChInfo     *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwLChInfo(param, mBuf)
+S16 cmPkCkwLChInfo(param, mBuf)
 CkwLChInfo     *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkCkwLChInfo)
 
-    CMCHKPK(SPkU8, param->type, mBuf);
-    CMCHKPK(SPkU8, param->lChId, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->lChId, mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkCkwLChInfo */
 
 \f
@@ -374,18 +367,17 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcEntCfgInfo
+S16 cmPkRlcEntCfgInfo
 (
 RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcEntCfgInfo(param, mBuf)
+S16 cmPkRlcEntCfgInfo(param, mBuf)
 RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkRlcEntCfgInfo)
 
     switch(param->entMode)
     {
@@ -428,14 +420,14 @@ Buffer         *mBuf;
     CMCHKPK(SPkS16, param->rguSapId, mBuf);
 #endif
     CMCHKPK(SPkS16, param->discardTmr, mBuf);
-    CMCHKPK(SPkU8, param->dir, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
     CMCHKPK(cmPkLteRlcMode, param->entMode, mBuf);
-    CMCHKPK(SPkU8, param->qci, mBuf);
-    CMCHKPK(SPkU8, param->rbType, mBuf);
-    CMCHKPK(SPkU8, param->rbId, mBuf);
-    CMCHKPK(SPkU8, param->cfgType, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->rbId, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcEntCfgInfo */
 
 \f
@@ -453,14 +445,14 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcCfgInfo
+S16 cmPkRlcCfgInfo
 (
 RlcCfgInfo     *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcCfgInfo(param, pst, mBuf)
+S16 cmPkRlcCfgInfo(param, pst, mBuf)
 RlcCfgInfo     *param;
 Pst            *pst;
 Buffer         *mBuf;
@@ -468,19 +460,18 @@ Buffer         *mBuf;
 {
    S16 idx;
 
-   TRC3(cmPkRlcCfgInfo)
 
     for (idx = param->numEnt-1; idx >= 0; idx--)
     {
        CMCHKPK(cmPkRlcEntCfgInfo, &(param->entCfg[idx]), mBuf);
     }
 
-    CMCHKPK(SPkU8, param->numEnt, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->numEnt, mBuf);
     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
-    CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW010, pst);
+    CMCHKPKLOG(oduUnpackUInt32, param->transId, mBuf, ECKW010, pst);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcCfgInfo */
 
 \f
@@ -498,24 +489,23 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcEntCfgCfmInfo
+S16 cmPkRlcEntCfgCfmInfo
 (
 RlcEntCfgCfmInfo  *param,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcEntCfgCfmInfo(param, mBuf)
+S16 cmPkRlcEntCfgCfmInfo(param, mBuf)
 RlcEntCfgCfmInfo  *param;
 Buffer            *mBuf;
 #endif
 {
-    TRC3(cmPkRlcEntCfgCfmInfo)
 
     CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
-    CMCHKPK(SPkU8, param->rbType, mBuf);
-    CMCHKPK(SPkU8, param->rbId, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->rbId, mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcEntCfgCfmInfo */
 
 \f
@@ -533,14 +523,14 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcCfgCfmInfo
+S16 cmPkRlcCfgCfmInfo
 (
 RlcCfgCfmInfo  *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkRlcCfgCfmInfo(param, pst, mBuf)
+S16 cmPkRlcCfgCfmInfo(param, pst, mBuf)
 RlcCfgCfmInfo  *param;
 Pst            *pst;
 Buffer         *mBuf;
@@ -548,19 +538,18 @@ Buffer         *mBuf;
 {
     S16         idx;
 
-    TRC3(cmPkRlcCfgCfmInfo)
 
     for (idx = param->numEnt-1; idx >= 0; idx--)
     {
-       CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
+       CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(uint8_t)idx]), mBuf);
     }
 
-    CMCHKPK(SPkU8, param->numEnt, mBuf);
+    CMCHKPK(oduUnpackUInt8, param->numEnt, mBuf);
     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
-    CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
+    CMCHKPKLOG(oduUnpackUInt32, param->transId, mBuf, ECKW014, pst);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmPkRlcCfgCfmInfo */
 
 \f
@@ -568,7 +557,7 @@ Buffer         *mBuf;
 *
 *    Fun:    cmPkRlcCfgCfm
 *
-*    Desc:    pack the primitive KwUiRlcCfgCfm
+*    Desc:    pack the primitive RlcUiRlcCfgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -578,14 +567,14 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkRlcCfgCfm
+S16 cmPkRlcCfgCfm
 (
 Pst               *pst,
 SuId              suId,
 RlcCfgCfmInfo     *cfgCfmInfo
 )
 #else
-PUBLIC S16 cmPkRlcCfgCfm(pst, suId, cfgCfmInfo)
+S16 cmPkRlcCfgCfm(pst, suId, cfgCfmInfo)
 Pst               *pst;
 SuId              suId;
 RlcCfgCfmInfo     *cfgCfmInfo;
@@ -594,7 +583,6 @@ RlcCfgCfmInfo     *cfgCfmInfo;
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkRlcCfgCfm)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -606,7 +594,7 @@ RlcCfgCfmInfo     *cfgCfmInfo;
                (ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     switch(pst->selector)
@@ -622,14 +610,14 @@ RlcCfgCfmInfo     *cfgCfmInfo;
                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
                       (ErrVal)ECKW016, (ErrVal)ret1, "Packing failure");
-                RETVALUE( ret1 );
+                return ( ret1 );
              }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
              if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
                       sizeof(RlcCfgCfmInfo)) != ROK)
              {
                 SPutMsg(mBuf);
-                RETVALUE(RFAILED);
+                return RFAILED;
              }
 
              break;
@@ -640,7 +628,7 @@ RlcCfgCfmInfo     *cfgCfmInfo;
     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
     pst->event = (Event) CKW_EVT_CFG_CFM;
 
-    RETVALUE(SPstTsk(pst,mBuf));
+    return (SPstTsk(pst,mBuf));
 } /* cmPkRlcCfgCfm */
 
 /*
@@ -657,30 +645,29 @@ RlcCfgCfmInfo     *cfgCfmInfo;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUeInfo
+S16 cmPkCkwUeInfo
 (
 CkwUeInfo *param,
 Buffer    *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwUeInfo(param, mBuf)
+S16 cmPkCkwUeInfo(param, mBuf)
 CkwUeInfo *param;
 Buffer    *mBuf;
 #endif
 {
-   TRC2(cmPkCkwUeInfo)
 
    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /*
 *
 *    Fun:    cmPkCkwUeIdChgReq
 *
-*    Desc:   pack the primitive KwUiCkwUeIdChgReq
+*    Desc:   pack the primitive RlcUiCkwUeIdChgReq
 *
 *    Ret:    ROK  -ok
 *
@@ -690,19 +677,19 @@ Buffer    *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUeIdChgReq
+S16 cmPkCkwUeIdChgReq
 (
 Pst               *pst,
 SpId              spId,
-U32               transId,
+uint32_t               transId,
 CkwUeInfo         *ueInfo,
 CkwUeInfo         *newUeInfo
 )
 #else
-PUBLIC S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
+S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
 Pst               *pst;
 SpId              spId;
-U32               transId;
+uint32_t               transId;
 CkwUeInfo         *ueInfo;
 CkwUeInfo         *newUeInfo;
 #endif
@@ -710,7 +697,6 @@ CkwUeInfo         *newUeInfo;
     S16    ret1;
     Buffer *mBuf = NULLP;
 
-    TRC3(cmPkCkwUeIdChgReq)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -723,7 +709,7 @@ CkwUeInfo         *newUeInfo;
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
@@ -731,20 +717,20 @@ CkwUeInfo         *newUeInfo;
              sizeof(CkwUeInfo)) != ROK)
     {
        SPutMsg(mBuf);
-       RETVALUE(RFAILED);
+       return RFAILED;
     }
     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
              sizeof(CkwUeInfo)) != ROK)
     {
        SPutMsg(mBuf);
-       RETVALUE(RFAILED);
+       return RFAILED;
     }
-    CMCHKPKLOG(SPkU32, transId, mBuf, ECKW019, pst);
+    CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, ECKW019, pst);
     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW020, pst);
     pst->event = (Event) CKW_EVT_UEIDCHG_REQ;
 
-    RETVALUE(SPstTsk(pst, mBuf));
+    return (SPstTsk(pst, mBuf));
 
 } /* cmPkCkwUeIdChgReq */
 
@@ -752,7 +738,7 @@ CkwUeInfo         *newUeInfo;
 *
 *    Fun:    cmPkCkwUeIdChgCfm
 *
-*    Desc:   pack the primitive KwUiCkwUeIdChgCfm
+*    Desc:   pack the primitive RlcUiCkwUeIdChgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -762,19 +748,19 @@ CkwUeInfo         *newUeInfo;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUeIdChgCfm
+S16 cmPkCkwUeIdChgCfm
 (
 Pst               *pst,
 SuId              suId,
-U32               transId,
+uint32_t               transId,
 CkwUeInfo         *ueInfo,
 CmStatus          status
 )
 #else
-PUBLIC S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
+S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
 Pst               *pst;
 SuId              suId;
-U32               transId;
+uint32_t               transId;
 CkwUeInfo         *ueInfo;
 CmStatus          status;
 #endif
@@ -782,7 +768,6 @@ CmStatus          status;
     S16    ret1;
     Buffer *mBuf = NULLP;
 
-    TRC3(cmPkCkwUeIdChgCfm)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -795,7 +780,7 @@ CmStatus          status;
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 
-       RETVALUE(ret1);
+       return (ret1);
     }
     
     CMCHKPK(cmPkCmStatus, &status, mBuf); 
@@ -804,13 +789,13 @@ CmStatus          status;
              sizeof(CkwUeInfo)) != ROK)
     {
        SPutMsg(mBuf);
-       RETVALUE(RFAILED);
+       return RFAILED;
     }
-    CMCHKPKLOG(SPkU32, transId, mBuf, ECKW022, pst);
+    CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, ECKW022, pst);
     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW023, pst);
     pst->event = (Event) CKW_EVT_UEIDCHG_CFM;
 
-    RETVALUE(SPstTsk(pst, mBuf));
+    return (SPstTsk(pst, mBuf));
 
 } /* cmPkCkwUeIdChgCfm */
 
@@ -833,14 +818,14 @@ CmStatus          status;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwBndReq
+S16 cmUnpkCkwBndReq
 (
 CkwBndReq      func,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwBndReq(func, pst, mBuf)
+S16 cmUnpkCkwBndReq(func, pst, mBuf)
 CkwBndReq      func;
 Pst            *pst;
 Buffer         *mBuf;
@@ -849,13 +834,12 @@ Buffer         *mBuf;
     SuId       suId = 0;
     SpId       spId = 0;
     
-    TRC3(cmUnpkCkwBndReq)
 
     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW024, pst);
     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, spId));
+    return ((*func)(pst, suId, spId));
 } /*end of function cmUnpkCkwBndReq*/
 \f
 /*
@@ -872,14 +856,14 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwUbndReq
+S16 cmUnpkCkwUbndReq
 (
 CkwUbndReq     func,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwUbndReq(func, pst, mBuf)
+S16 cmUnpkCkwUbndReq(func, pst, mBuf)
 CkwUbndReq     func;
 Pst            *pst;
 Buffer         *mBuf;
@@ -888,12 +872,11 @@ Buffer         *mBuf;
     SpId       spId = 0;
     Reason     reason = 0;
     
-    TRC3(cmUnpkCkwUbndReq)
 
     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
     CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
     SPutMsg(mBuf);
-    RETVALUE((*func)(pst, spId, reason));
+    return ((*func)(pst, spId, reason));
 } /*end of function cmUnpkCkwUbndReq*/
 \f
 /*
@@ -910,29 +893,28 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwBndCfm
+S16 cmUnpkCkwBndCfm
 (
 CkwBndCfm      func,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwBndCfm(func, pst, mBuf)
+S16 cmUnpkCkwBndCfm(func, pst, mBuf)
 CkwBndCfm      func;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
     SuId       suId = 0;
-    U8         status = 0;
+    uint8_t         status = 0;
     
-    TRC3(cmUnpkCkwBndCfm)
 
     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
-    CMCHKUNPKLOG(SUnpkU8, &status, mBuf, ECKW029, pst);
+    CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, ECKW029, pst);
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, status));
+    return ((*func)(pst, suId, status));
 } /*end of function cmUnpkCkwBndCfm*/
 
 \f
@@ -950,22 +932,21 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcTmInfo
+S16 cmUnpkRlcTmInfo
 (
 RlcTmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcTmInfo(param, mBuf)
+S16 cmUnpkRlcTmInfo(param, mBuf)
 RlcTmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkRlcTmInfo)
 
-    CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
+    CMCHKUNPK(oduPackUInt32, &(param->dl.buffSize), mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcTmInfo */
 
 \f
@@ -983,43 +964,42 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcUmInfo
+S16 cmUnpkRlcUmInfo
 (
 RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcUmInfo(param, mBuf)
+S16 cmUnpkRlcUmInfo(param, mBuf)
 RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkRlcUmInfo)
 
     switch(param->dir)
     {
        case CKW_CFG_DIR_DL:
           {
-             CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
+             CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.dl.snLen), mBuf);
              break;
           }
        case CKW_CFG_DIR_UL:
           {
-             CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
-             CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
+             CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.snLen), mBuf);
+             CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
              break;
           }
        /* Patch ckw_c_001.main_3 */
        case CKW_CFG_DIR_BOTH:
           {
-             CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
-             CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
-             CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
+             CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.snLen), mBuf);
+             CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
+             CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.dl.snLen), mBuf);
              break;
           }
     }
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcUmInfo */
 
 \f
@@ -1037,32 +1017,31 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcAmInfo
+S16 cmUnpkRlcAmInfo
 (
 RlcAmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcAmInfo(param, mBuf)
+S16 cmUnpkRlcAmInfo(param, mBuf)
 RlcAmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkRlcAmInfo)
 
     /* DOWN LINK */
-    CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
-    CMCHKUNPK(SUnpkU16, &(param->dl.pollRetxTmr), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->dl.snLen), mBuf);
+    CMCHKUNPK(oduPackUInt16, &(param->dl.pollRetxTmr), mBuf);
     CMCHKUNPK(SUnpkS16, &(param->dl.pollPdu), mBuf);
     CMCHKUNPK(SUnpkS32, &(param->dl.pollByte), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->dl.maxRetx), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->dl.maxRetx), mBuf);
 
     /* UP LINK */
-    CMCHKUNPK(SUnpkU8, &(param->ul.snLen), mBuf);
-    CMCHKUNPK(SUnpkU16, &(param->ul.staProhTmr), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->ul.snLen), mBuf);
+    CMCHKUNPK(oduPackUInt16, &(param->ul.staProhTmr), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->ul.reOrdTmr), mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcAmInfo */
 
 \f
@@ -1080,23 +1059,22 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwLChInfo
+S16 cmUnpkCkwLChInfo
 (
 CkwLChInfo     *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwLChInfo(param, mBuf)
+S16 cmUnpkCkwLChInfo(param, mBuf)
 CkwLChInfo     *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkCkwLChInfo)
 
-    CMCHKUNPK(SUnpkU8, &(param->lChId), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->type), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->lChId), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->type), mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkCkwLChInfo */
 
 \f
@@ -1114,24 +1092,23 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcEntCfgCfmInfo
+S16 cmUnpkRlcEntCfgCfmInfo
 (
 RlcEntCfgCfmInfo  *param,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcEntCfgCfmInfo(param, mBuf)
+S16 cmUnpkRlcEntCfgCfmInfo(param, mBuf)
 RlcEntCfgCfmInfo  *param;
 Buffer            *mBuf;
 #endif
 {
-    TRC3(cmUnpkRlcEntCfgCfmInfo)
 
-    CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->rbId), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->rbType), mBuf);
     CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcEntCfgCfmInfo */
 
 \f
@@ -1149,34 +1126,33 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcCfgCfmInfo
+S16 cmUnpkRlcCfgCfmInfo
 (
 RlcCfgCfmInfo  *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcCfgCfmInfo(param, pst, mBuf)
+S16 cmUnpkRlcCfgCfmInfo(param, pst, mBuf)
 RlcCfgCfmInfo  *param;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
-    U8         idx;
+    uint8_t         idx;
 
-    TRC3(cmUnpkRlcCfgCfmInfo)
 
-    CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
+    CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW030, pst);
     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->numEnt), mBuf);
 
     for (idx = 0; idx < param->numEnt; idx++)
     {
        CMCHKUNPK(cmUnpkRlcEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
     }
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcCfgCfmInfo */
 
 \f
@@ -1194,25 +1170,24 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcEntCfgInfo
+S16 cmUnpkRlcEntCfgInfo
 (
 RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcEntCfgInfo(param, mBuf)
+S16 cmUnpkRlcEntCfgInfo(param, mBuf)
 RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkRlcEntCfgInfo)
 
-    CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->qci), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->cfgType), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->rbId), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->rbType), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->qci), mBuf);
     CMCHKUNPK(cmUnpkLteRlcMode, &(param->entMode), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->dir), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->dir), mBuf);
     CMCHKUNPK(SUnpkS16, &(param->discardTmr), mBuf);
 #ifdef TENB_MULT_CELL_SUPPRT
     CMCHKUNPK(SUnpkS16, &(param->rguSapId), mBuf);
@@ -1256,7 +1231,7 @@ Buffer         *mBuf;
           }
     }
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcEntCfgInfo */
 
 \f
@@ -1274,34 +1249,33 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcCfgInfo
+S16 cmUnpkRlcCfgInfo
 (
 RlcCfgInfo     *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcCfgInfo(param, pst, mBuf)
+S16 cmUnpkRlcCfgInfo(param, pst, mBuf)
 RlcCfgInfo     *param;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
-    U8         idx;
+    uint8_t         idx;
 
-    TRC3(cmUnpkRlcCfgInfo)
 
-    CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
+    CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW031, pst);
     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
-    CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
+    CMCHKUNPK(oduPackUInt8, &(param->numEnt), mBuf);
 
     for (idx = 0; idx < param->numEnt; idx++)
     {
        CMCHKUNPKLOG(cmUnpkRlcEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
     }
 
-    RETVALUE(ROK);
+    return ROK;
 } /* cmUnpkRlcCfgInfo */
 
 \f
@@ -1309,7 +1283,7 @@ Buffer         *mBuf;
 *
 *    Fun:    cmUnpkRlcCfgCfm
 *
-*    Desc:    unpack the primitive KwUiRlcCfgCfm
+*    Desc:    unpack the primitive RlcUiRlcCfgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -1319,14 +1293,14 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkRlcCfgCfm
+S16 cmUnpkRlcCfgCfm
 (
 RlcCfgCfm         func,
 Pst               *pst,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmUnpkRlcCfgCfm(func, pst, mBuf)
+S16 cmUnpkRlcCfgCfm(func, pst, mBuf)
 RlcCfgCfm         func;
 Pst               *pst;
 Buffer            *mBuf;
@@ -1336,7 +1310,6 @@ Buffer            *mBuf;
     SuId             suId = 0;
     RlcCfgCfmInfo    *cfgCfmInfo = NULLP;
     
-    TRC3(cmUnpkRlcCfgCfm)
 
     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
                 sizeof(RlcCfgCfmInfo))) != ROK)
@@ -1349,10 +1322,10 @@ Buffer            *mBuf;
                (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
-    cmMemset((U8 *)cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
+    memset(cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
 
     CMCHKUNPK(SUnpkS16, &suId, mBuf);
 
@@ -1369,7 +1342,7 @@ Buffer            *mBuf;
              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
                   (ErrVal)ECKW036, (ErrVal)ret1, "Unpacking failure");
-             RETVALUE( ret1 );
+             return ( ret1 );
           }
 #endif /* ERRCLASS & ERRCLS_DEBUG */
           break;
@@ -1378,7 +1351,7 @@ Buffer            *mBuf;
     }
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, cfgCfmInfo));
+    return ((*func)(pst, suId, cfgCfmInfo));
 } /* cmUnpkRlcCfgCfm */
 
 /*
@@ -1395,30 +1368,29 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwUeInfo
+S16 cmUnpkCkwUeInfo
 (
 CkwUeInfo *param,
 Buffer    *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwUeInfo(param, mBuf)
+S16 cmUnpkCkwUeInfo(param, mBuf)
 CkwUeInfo *param;
 Buffer    *mBuf;
 #endif
 {
-   TRC2(cmUnpkCkwUeInfo)
 
    CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
    CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
 
-   RETVALUE(ROK);
+   return ROK;
 }
 
 /*
 *
 *    Fun:    cmUnpkCkwUeIdChgReq
 *
-*    Desc:    unpack the primitive KwUiCkwUeIdChgReq
+*    Desc:    unpack the primitive RlcUiCkwUeIdChgReq
 *
 *    Ret:    ROK  -ok
 *
@@ -1428,14 +1400,14 @@ Buffer    *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwUeIdChgReq
+S16 cmUnpkCkwUeIdChgReq
 (
 CkwUeIdChgReq     func,
 Pst               *pst,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
+S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
 CkwUeIdChgReq     func;
 Pst               *pst;
 Buffer            *mBuf;
@@ -1443,15 +1415,14 @@ Buffer            *mBuf;
 {
     S16       ret1;
     SpId      spId = 0;
-    U32       transId = 0;
+    uint32_t       transId = 0;
     CkwUeInfo *ueInfo = NULLP;
     CkwUeInfo *newUeInfo = NULLP;
     
-    TRC3(cmUnpkCkwUeIdChgReq)
 
 
     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
-    CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW037, pst);
+    CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW037, pst);
 
     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
                 sizeof(CkwUeInfo))) != ROK)
@@ -1463,10 +1434,10 @@ Buffer            *mBuf;
                (ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
       
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
-    cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
+    memset(ueInfo, 0, sizeof(CkwUeInfo));
 
     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
 #if(ERRCLASS & ERRCLS_DEBUG)
@@ -1476,7 +1447,7 @@ Buffer            *mBuf;
        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
              (ErrVal)ECKW039, (ErrVal)ret1, "Unpacking failure");
-       RETVALUE( ret1 );
+       return ( ret1 );
     }
 #endif /* ERRCLASS & ERRCLS_DEBUG */
 
@@ -1490,10 +1461,10 @@ Buffer            *mBuf;
                (ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
        
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
-    cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
+    memset(newUeInfo, 0, sizeof(CkwUeInfo));
 
     ret1 = cmUnpkCkwUeInfo((newUeInfo), mBuf);
 #if(ERRCLASS & ERRCLS_DEBUG)
@@ -1503,13 +1474,13 @@ Buffer            *mBuf;
        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
              (ErrVal)ECKW041, (ErrVal)ret1, "Unpacking failure");
-       RETVALUE( ret1 );
+       return ( ret1 );
     }
 #endif /* ERRCLASS & ERRCLS_DEBUG */
 
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
+    return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
 
 } /* cmUnpkCkwUeIdChgReq */
 
@@ -1517,7 +1488,7 @@ Buffer            *mBuf;
 *
 *    Fun:     cmUnpkCkwUeIdChgCfm
 *
-*    Desc:    unpack the primitive KwUiCkwUeIdChgCfm
+*    Desc:    unpack the primitive RlcUiCkwUeIdChgCfm
 *
 *    Ret:     ROK  -ok
 *
@@ -1527,14 +1498,14 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwUeIdChgCfm
+S16 cmUnpkCkwUeIdChgCfm
 (
 CkwUeIdChgCfm     func,
 Pst               *pst,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
+S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
 CkwUeIdChgCfm     func;
 Pst               *pst;
 Buffer            *mBuf;
@@ -1542,16 +1513,15 @@ Buffer            *mBuf;
 {
     S16       ret1;
     SuId      suId = 0;
-    U32       transId = 0;
+    uint32_t       transId = 0;
     CkwUeInfo *ueInfo = NULLP;
     CmStatus  status;
     
-    TRC3(cmUnpkCkwUeIdChgCfm)
 
-    cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
+    memset(&status, 0, sizeof(CmStatus));
 
     CMCHKUNPK(SUnpkS16, &suId, mBuf);
-    CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW042, pst);
+    CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW042, pst);
 
     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
                 sizeof(CkwUeInfo))) != ROK)
@@ -1564,10 +1534,10 @@ Buffer            *mBuf;
                (ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
-    cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
+    memset(ueInfo, 0, sizeof(CkwUeInfo));
 
     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
 #if(ERRCLASS & ERRCLS_DEBUG)
@@ -1577,7 +1547,7 @@ Buffer            *mBuf;
        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
              (ErrVal)ECKW044, (ErrVal)ret1, "Unpacking failure");
-       RETVALUE( ret1 );
+       return ( ret1 );
     }
 #endif /* ERRCLASS & ERRCLS_DEBUG */
 
@@ -1585,7 +1555,7 @@ Buffer            *mBuf;
 
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+    return ((*func)(pst, suId, transId, ueInfo, status));
 
 } /* cmUnpkCkwUeIdChgCfm */