X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Fckw.c;h=637ce7861532a47ea488f5fc5324cddfc7358173;hb=def50dc175cebc67238db5f1acd5ff322a2279bd;hp=feec780e55cda5324230eae084670661ad289eb9;hpb=2af23ef78e09b945e68188eefc0d9fa0bc14a4d4;p=o-du%2Fl2.git

diff --git a/src/cm/ckw.c b/src/cm/ckw.c
index feec780e5..637ce7861 100755
--- a/src/cm/ckw.c
+++ b/src/cm/ckw.c
@@ -29,32 +29,11 @@
 
 *********************************************************************21*/
 
-#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 "cm5.h"           /* common timer defines */
-#include "cm_tkns.h"       /* common tokens defines */
-#include "cm_mblk.h"       /* common memory allocation library 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 "ckw.h"           /* CKW defines */
+#include "common_def.h"
+#include "ckw.h"
+#include "ckw.x"
 
 /* extern (.x) include files */
-#include "gen.x"           /* general */
-#include "ssi.x"           /* system services */
-
-#include "cm5.x"           /* common timer library */
-#include "cm_tkns.x"       /* common tokens */
-#include "cm_mblk.x"       /* common memory allocation */
-#include "cm_llist.x"      /* common link list */
-#include "cm_hash.x"       /* common hash list */
-#include "cm_lte.x"        /* common LTE includes */
-#include "cm_lib.x"        /* common memory allocation library */
-#include "ckw.x"           /* CKW */
 
 
 #ifdef __cplusplus
@@ -76,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;
@@ -92,7 +71,6 @@ SpId spId;
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkCkwBndReq)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -104,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*/
 
 /*
@@ -127,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;
@@ -143,7 +121,6 @@ Reason reason;
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkCkwUbndReq)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -155,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*/
 
 /*
@@ -178,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)
     {
@@ -207,21 +183,21 @@ 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*/
 
 
 /*
 *
-*    Fun:    cmPkCkwTmInfo
+*    Fun:    cmPkRlcTmInfo
 *
-*    Desc:    pack the structure CkwTmInfo
+*    Desc:    pack the structure RlcTmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -231,30 +207,29 @@ U8 status;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwTmInfo
+S16 cmPkRlcTmInfo
 (
-CkwTmInfo      *param,
+RlcTmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwTmInfo(param, mBuf)
-CkwTmInfo      *param;
+S16 cmPkRlcTmInfo(param, mBuf)
+RlcTmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkCkwTmInfo)
 
-    CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
+    CMCHKPK(oduUnpackUInt32, param->dl.buffSize, mBuf);
 
-    RETVALUE(ROK);
-} /* cmPkCkwTmInfo */
+    return ROK;
+} /* cmPkRlcTmInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwUmInfo
+*    Fun:    cmPkRlcUmInfo
 *
-*    Desc:    pack the structure CkwUmInfo
+*    Desc:    pack the structure RlcUmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -264,51 +239,50 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUmInfo
+S16 cmPkRlcUmInfo
 (
-CkwEntCfgInfo  *param,
+RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwUmInfo(param, mBuf)
-CkwEntCfgInfo  *param;
+S16 cmPkRlcUmInfo(param, mBuf)
+RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkCkwUmInfo)
 
     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);
-} /* cmPkCkwUmInfo */
+    return ROK;
+} /* cmPkRlcUmInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwAmInfo
+*    Fun:    cmPkRlcAmInfo
 *
-*    Desc:    pack the structure CkwAmInfo
+*    Desc:    pack the structure RlcAmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -318,33 +292,32 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwAmInfo
+S16 cmPkRlcAmInfo
 (
-CkwAmInfo      *param,
+RlcAmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwAmInfo(param, mBuf)
-CkwAmInfo      *param;
+S16 cmPkRlcAmInfo(param, mBuf)
+RlcAmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkCkwAmInfo)
 
     /* 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);
-} /* cmPkCkwAmInfo */
+    return ROK;
+} /* cmPkRlcAmInfo */
 
 
 /*
@@ -361,31 +334,30 @@ 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 */
 
 
 /*
 *
-*    Fun:    cmPkCkwEntCfgInfo
+*    Fun:    cmPkRlcEntCfgInfo
 *
-*    Desc:    pack the structure CkwEntCfgInfo
+*    Desc:    pack the structure RlcEntCfgInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -395,34 +367,33 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwEntCfgInfo
+S16 cmPkRlcEntCfgInfo
 (
-CkwEntCfgInfo  *param,
+RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwEntCfgInfo(param, mBuf)
-CkwEntCfgInfo  *param;
+S16 cmPkRlcEntCfgInfo(param, mBuf)
+RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmPkCkwEntCfgInfo)
 
     switch(param->entMode)
     {
        case CM_LTE_MODE_TM:
           {
-             CMCHKPK(cmPkCkwTmInfo, &(param->m.tmInfo), mBuf);
+             CMCHKPK(cmPkRlcTmInfo, &(param->m.tmInfo), mBuf);
              break;
           }
        case CM_LTE_MODE_UM:
           {
-             CMCHKPK(cmPkCkwUmInfo, param, mBuf);
+             CMCHKPK(cmPkRlcUmInfo, param, mBuf);
              break;
           }
        case CM_LTE_MODE_AM:
           {
-             CMCHKPK(cmPkCkwAmInfo, &(param->m.amInfo), mBuf);
+             CMCHKPK(cmPkRlcAmInfo, &(param->m.amInfo), mBuf);
              break;
           }
     }
@@ -449,22 +420,22 @@ 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);
-} /* cmPkCkwEntCfgInfo */
+    return ROK;
+} /* cmPkRlcEntCfgInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwCfgInfo
+*    Fun:    cmPkRlcCfgInfo
 *
-*    Desc:    pack the structure CkwCfgInfo
+*    Desc:    pack the structure RlcCfgInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -474,42 +445,41 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwCfgInfo
+S16 cmPkRlcCfgInfo
 (
-CkwCfgInfo     *param,
+RlcCfgInfo     *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwCfgInfo(param, pst, mBuf)
-CkwCfgInfo     *param;
+S16 cmPkRlcCfgInfo(param, pst, mBuf)
+RlcCfgInfo     *param;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
    S16 idx;
 
-   TRC3(cmPkCkwCfgInfo)
 
     for (idx = param->numEnt-1; idx >= 0; idx--)
     {
-       CMCHKPK(cmPkCkwEntCfgInfo, &(param->entCfg[idx]), mBuf);
+       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);
-} /* cmPkCkwCfgInfo */
+    return ROK;
+} /* cmPkRlcCfgInfo */
 
 
 /*
 *
-*    Fun:    packUeCreateReq
+*    Fun:    cmPkRlcEntCfgCfmInfo
 *
-*    Desc:    pack the primitive UE Create Req
+*    Desc:    pack the structure RlcEntCfgInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -519,89 +489,31 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 packUeCreateReq
+S16 cmPkRlcEntCfgCfmInfo
 (
-Pst               *pst,
-CkwCfgInfo        *cfgInfo
-)
-#else
-PUBLIC S16 packUeCreateReq(pst, cfgInfo)
-Pst               *pst;
-CkwCfgInfo        *cfgInfo;
-#endif
-{
-    S16 ret1;
-    Buffer *mBuf;
-    mBuf = NULLP;
-    TRC3(packUeCreateReq)
-
-    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
-    {
-#if (ERRCLASS & ERRCLS_ADD_RES)
-       if(ret1 != ROK)
-       {
-          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
-                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
-               (ErrVal)ECKW011, (ErrVal)0, "SGetMsg() failed");
-       }
-#endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
-    }
-
-    switch(pst->selector)
-    {
-       case CKW_SEL_LWLC:
-          {
-             CMCHKPK(cmPkPtr,(PTR) cfgInfo, mBuf);
-             break;
-          }
-    }
-    pst->event = (Event) RLC_EVT_UE_CREATE_REQ;
-
-    RETVALUE(SPstTsk(pst,mBuf));
-} /* packUeCreateReq */
-
-
-/*
-*
-*    Fun:    cmPkCkwEntCfgCfmInfo
-*
-*    Desc:    pack the structure CkwEntCfgInfo
-*
-*    Ret:    ROK  -ok
-*
-*    Notes:    None
-*
-*    File:     ckw.c
-*
-*/
-#ifdef ANSI
-PUBLIC S16 cmPkCkwEntCfgCfmInfo
-(
-CkwEntCfgCfmInfo  *param,
+RlcEntCfgCfmInfo  *param,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwEntCfgCfmInfo(param, mBuf)
-CkwEntCfgCfmInfo  *param;
+S16 cmPkRlcEntCfgCfmInfo(param, mBuf)
+RlcEntCfgCfmInfo  *param;
 Buffer            *mBuf;
 #endif
 {
-    TRC3(cmPkCkwEntCfgCfmInfo)
 
     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);
-} /* cmPkCkwEntCfgCfmInfo */
+    return ROK;
+} /* cmPkRlcEntCfgCfmInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwCfgCfmInfo
+*    Fun:    cmPkRlcCfgCfmInfo
 *
-*    Desc:    pack the structure CkwCfgCfmInfo
+*    Desc:    pack the structure RlcCfgCfmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -611,42 +523,41 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwCfgCfmInfo
+S16 cmPkRlcCfgCfmInfo
 (
-CkwCfgCfmInfo  *param,
+RlcCfgCfmInfo  *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
-CkwCfgCfmInfo  *param;
+S16 cmPkRlcCfgCfmInfo(param, pst, mBuf)
+RlcCfgCfmInfo  *param;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
     S16         idx;
 
-    TRC3(cmPkCkwCfgCfmInfo)
 
     for (idx = param->numEnt-1; idx >= 0; idx--)
     {
-       CMCHKPK(cmPkCkwEntCfgCfmInfo, &(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);
-} /* cmPkCkwCfgCfmInfo */
+    return ROK;
+} /* cmPkRlcCfgCfmInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwCfgCfm
+*    Fun:    cmPkRlcCfgCfm
 *
-*    Desc:    pack the primitive KwUiCkwCfgCfm
+*    Desc:    pack the primitive RlcUiRlcCfgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -656,23 +567,22 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwCfgCfm
+S16 cmPkRlcCfgCfm
 (
 Pst               *pst,
 SuId              suId,
-CkwCfgCfmInfo     *cfgCfmInfo
+RlcCfgCfmInfo     *cfgCfmInfo
 )
 #else
-PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
+S16 cmPkRlcCfgCfm(pst, suId, cfgCfmInfo)
 Pst               *pst;
 SuId              suId;
-CkwCfgCfmInfo     *cfgCfmInfo;
+RlcCfgCfmInfo     *cfgCfmInfo;
 #endif
 {
     S16 ret1;
     Buffer *mBuf;
     mBuf = NULLP;
-    TRC3(cmPkCkwCfgCfm)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -684,15 +594,15 @@ CkwCfgCfmInfo     *cfgCfmInfo;
                (ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     switch(pst->selector)
     {
 #ifdef LCCKW
-       case CKW_SEL_LC:
+       case ODU_SELECTOR_LC:
           {
-             ret1 = cmPkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
+             ret1 = cmPkRlcCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
 #if (ERRCLASS & ERRCLS_ADD_RES)
              if(ret1 != ROK)
              {
@@ -700,14 +610,14 @@ CkwCfgCfmInfo     *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(CkwCfgCfmInfo)) != ROK)
+                      sizeof(RlcCfgCfmInfo)) != ROK)
              {
                 SPutMsg(mBuf);
-                RETVALUE(RFAILED);
+                return RFAILED;
              }
 
              break;
@@ -718,8 +628,8 @@ CkwCfgCfmInfo     *cfgCfmInfo;
     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
     pst->event = (Event) CKW_EVT_CFG_CFM;
 
-    RETVALUE(SPstTsk(pst,mBuf));
-} /* cmPkCkwCfgCfm */
+    return (SPstTsk(pst,mBuf));
+} /* cmPkRlcCfgCfm */
 
 /*
 *
@@ -735,30 +645,29 @@ CkwCfgCfmInfo     *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
 *
@@ -768,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
@@ -788,7 +697,6 @@ CkwUeInfo         *newUeInfo;
     S16    ret1;
     Buffer *mBuf = NULLP;
 
-    TRC3(cmPkCkwUeIdChgReq)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -801,7 +709,7 @@ CkwUeInfo         *newUeInfo;
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
@@ -809,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 */
 
@@ -830,7 +738,7 @@ CkwUeInfo         *newUeInfo;
 *
 *    Fun:    cmPkCkwUeIdChgCfm
 *
-*    Desc:   pack the primitive KwUiCkwUeIdChgCfm
+*    Desc:   pack the primitive RlcUiCkwUeIdChgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -840,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
@@ -860,7 +768,6 @@ CmStatus          status;
     S16    ret1;
     Buffer *mBuf = NULLP;
 
-    TRC3(cmPkCkwUeIdChgCfm)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -873,7 +780,7 @@ CmStatus          status;
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 
-       RETVALUE(ret1);
+       return (ret1);
     }
     
     CMCHKPK(cmPkCmStatus, &status, mBuf); 
@@ -882,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 */
 
@@ -911,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;
@@ -927,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*/
 
 /*
@@ -950,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;
@@ -966,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*/
 
 /*
@@ -988,37 +893,36 @@ 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*/
 
 
 /*
 *
-*    Fun:    cmUnpkCkwTmInfo
+*    Fun:    cmUnpkRlcTmInfo
 *
-*    Desc:    pack the structure CkwTmInfo
+*    Desc:    pack the structure RlcTmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1028,30 +932,29 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwTmInfo
+S16 cmUnpkRlcTmInfo
 (
-CkwTmInfo      *param,
+RlcTmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
-CkwTmInfo      *param;
+S16 cmUnpkRlcTmInfo(param, mBuf)
+RlcTmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkCkwTmInfo)
 
-    CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
+    CMCHKUNPK(oduPackUInt32, &(param->dl.buffSize), mBuf);
 
-    RETVALUE(ROK);
-} /* cmUnpkCkwTmInfo */
+    return ROK;
+} /* cmUnpkRlcTmInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwUmInfo
+*    Fun:    cmUnpkRlcUmInfo
 *
-*    Desc:    pack the structure CkwUmInfo
+*    Desc:    pack the structure RlcUmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1061,51 +964,50 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwUmInfo
+S16 cmUnpkRlcUmInfo
 (
-CkwEntCfgInfo  *param,
+RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
-CkwEntCfgInfo  *param;
+S16 cmUnpkRlcUmInfo(param, mBuf)
+RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkCkwUmInfo)
 
     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);
-} /* cmUnpkCkwUmInfo */
+    return ROK;
+} /* cmUnpkRlcUmInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwAmInfo
+*    Fun:    cmUnpkRlcAmInfo
 *
-*    Desc:    pack the structure CkwAmInfo
+*    Desc:    pack the structure RlcAmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1115,33 +1017,32 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwAmInfo
+S16 cmUnpkRlcAmInfo
 (
-CkwAmInfo      *param,
+RlcAmInfo      *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
-CkwAmInfo      *param;
+S16 cmUnpkRlcAmInfo(param, mBuf)
+RlcAmInfo      *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkCkwAmInfo)
 
     /* 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);
-} /* cmUnpkCkwAmInfo */
+    return ROK;
+} /* cmUnpkRlcAmInfo */
 
 
 /*
@@ -1158,31 +1059,30 @@ 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 */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwEntCfgCfmInfo
+*    Fun:    cmUnpkRlcEntCfgCfmInfo
 *
-*    Desc:    unpack the structure CkwEntCfgInfo
+*    Desc:    unpack the structure RlcEntCfgInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1192,32 +1092,31 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
+S16 cmUnpkRlcEntCfgCfmInfo
 (
-CkwEntCfgCfmInfo  *param,
+RlcEntCfgCfmInfo  *param,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
-CkwEntCfgCfmInfo  *param;
+S16 cmUnpkRlcEntCfgCfmInfo(param, mBuf)
+RlcEntCfgCfmInfo  *param;
 Buffer            *mBuf;
 #endif
 {
-    TRC3(cmUnpkCkwEntCfgCfmInfo)
 
-    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);
-} /* cmUnpkCkwEntCfgCfmInfo */
+    return ROK;
+} /* cmUnpkRlcEntCfgCfmInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwCfgCfmInfo
+*    Fun:    cmUnpkRlcCfgCfmInfo
 *
-*    Desc:    pack the structure CkwCfgCfmInfo
+*    Desc:    pack the structure RlcCfgCfmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1227,42 +1126,41 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgCfmInfo
+S16 cmUnpkRlcCfgCfmInfo
 (
-CkwCfgCfmInfo  *param,
+RlcCfgCfmInfo  *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
-CkwCfgCfmInfo  *param;
+S16 cmUnpkRlcCfgCfmInfo(param, pst, mBuf)
+RlcCfgCfmInfo  *param;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
-    U8         idx;
+    uint8_t         idx;
 
-    TRC3(cmUnpkCkwCfgCfmInfo)
 
-    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(cmUnpkCkwEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
+       CMCHKUNPK(cmUnpkRlcEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
     }
 
-    RETVALUE(ROK);
-} /* cmUnpkCkwCfgCfmInfo */
+    return ROK;
+} /* cmUnpkRlcCfgCfmInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwEntCfgInfo
+*    Fun:    cmUnpkRlcEntCfgInfo
 *
-*    Desc:    pack the structure CkwEntCfgCfmInfo
+*    Desc:    pack the structure RlcEntCfgCfmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1272,25 +1170,24 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwEntCfgInfo
+S16 cmUnpkRlcEntCfgInfo
 (
-CkwEntCfgInfo  *param,
+RlcEntCfgInfo  *param,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
-CkwEntCfgInfo  *param;
+S16 cmUnpkRlcEntCfgInfo(param, mBuf)
+RlcEntCfgInfo  *param;
 Buffer         *mBuf;
 #endif
 {
-    TRC3(cmUnpkCkwEntCfgInfo)
 
-    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);
@@ -1319,30 +1216,30 @@ Buffer         *mBuf;
     {
        case CM_LTE_MODE_TM:
           {
-             CMCHKUNPK(cmUnpkCkwTmInfo, &(param->m.tmInfo), mBuf);
+             CMCHKUNPK(cmUnpkRlcTmInfo, &(param->m.tmInfo), mBuf);
              break;
           }
        case CM_LTE_MODE_UM:
           {
-             CMCHKUNPK(cmUnpkCkwUmInfo, param, mBuf);
+             CMCHKUNPK(cmUnpkRlcUmInfo, param, mBuf);
              break;
           }
        case CM_LTE_MODE_AM:
           {
-             CMCHKUNPK(cmUnpkCkwAmInfo, &(param->m.amInfo), mBuf);
+             CMCHKUNPK(cmUnpkRlcAmInfo, &(param->m.amInfo), mBuf);
              break;
           }
     }
 
-    RETVALUE(ROK);
-} /* cmUnpkCkwEntCfgInfo */
+    return ROK;
+} /* cmUnpkRlcEntCfgInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwCfgInfo
+*    Fun:    cmUnpkRlcCfgInfo
 *
-*    Desc:    unpack the structure CkwCfgInfo
+*    Desc:    unpack the structure RlcCfgInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1352,101 +1249,41 @@ Buffer         *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgInfo
+S16 cmUnpkRlcCfgInfo
 (
-CkwCfgInfo     *param,
+RlcCfgInfo     *param,
 Pst            *pst,
 Buffer         *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
-CkwCfgInfo     *param;
+S16 cmUnpkRlcCfgInfo(param, pst, mBuf)
+RlcCfgInfo     *param;
 Pst            *pst;
 Buffer         *mBuf;
 #endif
 {
-    U8         idx;
+    uint8_t         idx;
 
-    TRC3(cmUnpkCkwCfgInfo)
 
-    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(cmUnpkCkwEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
+       CMCHKUNPKLOG(cmUnpkRlcEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
     }
 
-    RETVALUE(ROK);
-} /* cmUnpkCkwCfgInfo */
-
-
-/*
-*
-*    Fun:    unpackUeCreateReq
-*
-*    Desc:    unpack the primitive UE create request
-*
-*    Ret:    ROK  -ok
-*
-*    Notes:    None
-*
-*    File:     ckw.c
-*
-*/
-#ifdef ANSI
-PUBLIC S16 unpackUeCreateReq
-(
-CkwCfgReq         func,
-Pst               *pst,
-Buffer            *mBuf
-)
-#else
-PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
-CkwCfgReq         func;
-Pst               *pst;
-Buffer            *mBuf;
-#endif
-{
-    S16 ret1;
-    CkwCfgInfo    *cfgInfo = NULLP;
-    
-    TRC3(unpackUeCreateReq)
-
-    if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgInfo,\
-                sizeof(CkwCfgInfo))) != ROK)
-    {
-#if (ERRCLASS & ERRCLS_ADD_RES)
-      /*MBUF_FIXX*/
-          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
-                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
-               (ErrVal)ECKW033, (ErrVal)0, "SGetMsg() failed");
-      
-#endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
-    }
-
-    switch(pst->selector)
-    {
-       case CKW_SEL_LWLC:
-          {
-             CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf); 
-             break;
-          }
-    }
-    SPutMsg(mBuf);
-
-    RETVALUE((*func)(pst, cfgInfo));
-} /* cmUnpkCkwCfgReq */
+    return ROK;
+} /* cmUnpkRlcCfgInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwCfgCfm
+*    Fun:    cmUnpkRlcCfgCfm
 *
-*    Desc:    unpack the primitive KwUiCkwCfgCfm
+*    Desc:    unpack the primitive RlcUiRlcCfgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -1456,27 +1293,26 @@ Buffer            *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgCfm
+S16 cmUnpkRlcCfgCfm
 (
-CkwCfgCfm         func,
+RlcCfgCfm         func,
 Pst               *pst,
 Buffer            *mBuf
 )
 #else
-PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
-CkwCfgCfm         func;
+S16 cmUnpkRlcCfgCfm(func, pst, mBuf)
+RlcCfgCfm         func;
 Pst               *pst;
 Buffer            *mBuf;
 #endif
 {
     S16 ret1;
     SuId             suId = 0;
-    CkwCfgCfmInfo    *cfgCfmInfo = NULLP;
+    RlcCfgCfmInfo    *cfgCfmInfo = NULLP;
     
-    TRC3(cmUnpkCkwCfgCfm)
 
     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
-                sizeof(CkwCfgCfmInfo))) != ROK)
+                sizeof(RlcCfgCfmInfo))) != ROK)
     {
 #if (ERRCLASS & ERRCLS_ADD_RES)
        if(ret1 != ROK)
@@ -1486,19 +1322,19 @@ Buffer            *mBuf;
                (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
-    cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
+    memset(cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
 
     CMCHKUNPK(SUnpkS16, &suId, mBuf);
 
     switch(pst->selector)
     {
 #ifdef LCCKW
-       case CKW_SEL_LC:
+       case ODU_SELECTOR_LC:
        {
-          ret1 = cmUnpkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
+          ret1 = cmUnpkRlcCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
 #if(ERRCLASS & ERRCLS_DEBUG)
           if(ret1 != ROK)
           {
@@ -1506,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;
@@ -1515,8 +1351,8 @@ Buffer            *mBuf;
     }
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, cfgCfmInfo));
-} /* cmUnpkCkwCfgCfm */
+    return ((*func)(pst, suId, cfgCfmInfo));
+} /* cmUnpkRlcCfgCfm */
 
 /*
 *
@@ -1532,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
 *
@@ -1565,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;
@@ -1580,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)
@@ -1600,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)
@@ -1613,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 */
 
@@ -1627,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)
@@ -1640,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 */
 
@@ -1654,7 +1488,7 @@ Buffer            *mBuf;
 *
 *    Fun:     cmUnpkCkwUeIdChgCfm
 *
-*    Desc:    unpack the primitive KwUiCkwUeIdChgCfm
+*    Desc:    unpack the primitive RlcUiCkwUeIdChgCfm
 *
 *    Ret:     ROK  -ok
 *
@@ -1664,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;
@@ -1679,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)
@@ -1701,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)
@@ -1714,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 */
 
@@ -1722,7 +1555,7 @@ Buffer            *mBuf;
 
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+    return ((*func)(pst, suId, transId, ueInfo, status));
 
 } /* cmUnpkCkwUeIdChgCfm */