X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Fckw.c;h=99e175004c494246f253c77742d9ede07d66b9ae;hb=2193e4cf01012809495be026097e8d7eacb9f0ac;hp=a472ef38c5afd343bd4b406f8989640ae8c422bb;hpb=d10b52519198632f93deae9574adc69c7ce12efa;p=o-du%2Fl2.git

diff --git a/src/cm/ckw.c b/src/cm/ckw.c
index a472ef38c..99e175004 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;
@@ -104,13 +83,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 +106,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;
@@ -155,13 +134,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,14 +157,14 @@ Reason reason;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwBndCfm
+S16 cmPkCkwBndCfm
 (
 Pst *pst,
 SuId suId,
 U8 status
 )
 #else
-PUBLIC S16 cmPkCkwBndCfm(pst, suId, status)
+S16 cmPkCkwBndCfm(pst, suId, status)
 Pst *pst;
 SuId suId;
 U8 status;
@@ -207,21 +186,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 +210,30 @@ 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)
+    TRC3(cmPkRlcTmInfo)
 
-    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 +243,51 @@ 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)
+    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);
-} /* cmPkCkwUmInfo */
+    return ROK;
+} /* cmPkRlcUmInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwAmInfo
+*    Fun:    cmPkRlcAmInfo
 *
-*    Desc:    pack the structure CkwAmInfo
+*    Desc:    pack the structure RlcAmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -318,33 +297,33 @@ 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)
+    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);
-} /* cmPkCkwAmInfo */
+    return ROK;
+} /* cmPkRlcAmInfo */
 
 
 /*
@@ -361,31 +340,31 @@ 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 +374,34 @@ 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)
+    TRC3(cmPkRlcEntCfgInfo)
 
     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 +428,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 +453,42 @@ 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)
+   TRC3(cmPkRlcCfgInfo)
 
     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,116 +498,32 @@ 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;
-          }
-/* HLAL */
-#if 0          
-#ifdef LCCKW
-       case CKW_SEL_LC:
-          {
-             ret1 = cmPkCkwCfgInfo( (cfgInfo), pst, mBuf);
-#if (ERRCLASS & ERRCLS_ADD_RES)
-             if(ret1 != ROK)
-             {
-                SPutMsg(mBuf);
-                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
-                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
-                      (ErrVal)ECKW012, (ErrVal)ret1, "Packing failure");
-                RETVALUE( ret1 );
-             }
-#endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-             if (SPutSBuf(pst->region, pst->pool, (Data *)cfgInfo,
-                      sizeof(CkwCfgInfo)) != ROK)
-             {
-                SPutMsg(mBuf);
-                RETVALUE(RFAILED);
-             }
-
-             break;
-          }
-#endif /* LCCKW */
-#endif /* HLAL */
-    }
-    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)
+    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);
-} /* cmPkCkwEntCfgCfmInfo */
+    return ROK;
+} /* cmPkRlcEntCfgCfmInfo */
 
 
 /*
 *
-*    Fun:    cmPkCkwCfgCfmInfo
+*    Fun:    cmPkRlcCfgCfmInfo
 *
-*    Desc:    pack the structure CkwCfgCfmInfo
+*    Desc:    pack the structure RlcCfgCfmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -638,42 +533,42 @@ 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)
+    TRC3(cmPkRlcCfgCfmInfo)
 
     for (idx = param->numEnt-1; idx >= 0; idx--)
     {
-       CMCHKPK(cmPkCkwEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
+       CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(U8)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
 *
@@ -683,23 +578,23 @@ 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)
+    TRC3(cmPkRlcCfgCfm)
 
     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
     {
@@ -711,15 +606,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)
              {
@@ -727,14 +622,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;
@@ -745,8 +640,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 */
 
 /*
 *
@@ -762,13 +657,13 @@ 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
@@ -778,14 +673,14 @@ Buffer    *mBuf;
    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
 *
@@ -795,7 +690,7 @@ Buffer    *mBuf;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUeIdChgReq
+S16 cmPkCkwUeIdChgReq
 (
 Pst               *pst,
 SpId              spId,
@@ -804,7 +699,7 @@ 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;
@@ -828,7 +723,7 @@ CkwUeInfo         *newUeInfo;
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
@@ -836,20 +731,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 */
 
@@ -857,7 +752,7 @@ CkwUeInfo         *newUeInfo;
 *
 *    Fun:    cmPkCkwUeIdChgCfm
 *
-*    Desc:   pack the primitive KwUiCkwUeIdChgCfm
+*    Desc:   pack the primitive RlcUiCkwUeIdChgCfm
 *
 *    Ret:    ROK  -ok
 *
@@ -867,7 +762,7 @@ CkwUeInfo         *newUeInfo;
 *
 */
 #ifdef ANSI
-PUBLIC S16 cmPkCkwUeIdChgCfm
+S16 cmPkCkwUeIdChgCfm
 (
 Pst               *pst,
 SuId              suId,
@@ -876,7 +771,7 @@ 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;
@@ -900,7 +795,7 @@ CmStatus          status;
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 
-       RETVALUE(ret1);
+       return (ret1);
     }
     
     CMCHKPK(cmPkCmStatus, &status, mBuf); 
@@ -909,13 +804,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 */
 
@@ -938,14 +833,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;
@@ -960,7 +855,7 @@ Buffer         *mBuf;
     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, spId));
+    return ((*func)(pst, suId, spId));
 } /*end of function cmUnpkCkwBndReq*/
 
 /*
@@ -977,14 +872,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;
@@ -998,7 +893,7 @@ Buffer         *mBuf;
     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*/
 
 /*
@@ -1015,14 +910,14 @@ 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;
@@ -1034,18 +929,18 @@ Buffer         *mBuf;
     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
 *
@@ -1055,30 +950,30 @@ 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)
+    TRC3(cmUnpkRlcTmInfo)
 
-    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
 *
@@ -1088,51 +983,51 @@ 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)
+    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);
-} /* cmUnpkCkwUmInfo */
+    return ROK;
+} /* cmUnpkRlcUmInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwAmInfo
+*    Fun:    cmUnpkRlcAmInfo
 *
-*    Desc:    pack the structure CkwAmInfo
+*    Desc:    pack the structure RlcAmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1142,33 +1037,33 @@ 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)
+    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);
-} /* cmUnpkCkwAmInfo */
+    return ROK;
+} /* cmUnpkRlcAmInfo */
 
 
 /*
@@ -1185,31 +1080,31 @@ 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
 *
@@ -1219,32 +1114,32 @@ 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)
+    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);
-} /* cmUnpkCkwEntCfgCfmInfo */
+    return ROK;
+} /* cmUnpkRlcEntCfgCfmInfo */
 
 
 /*
 *
-*    Fun:    cmUnpkCkwCfgCfmInfo
+*    Fun:    cmUnpkRlcCfgCfmInfo
 *
-*    Desc:    pack the structure CkwCfgCfmInfo
+*    Desc:    pack the structure RlcCfgCfmInfo
 *
 *    Ret:    ROK  -ok
 *
@@ -1254,42 +1149,42 @@ 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;
 
-    TRC3(cmUnpkCkwCfgCfmInfo)
+    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(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
 *
@@ -1299,25 +1194,25 @@ 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)
+    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);
@@ -1346,30 +1241,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
 *
@@ -1379,122 +1274,42 @@ 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;
 
-    TRC3(cmUnpkCkwCfgInfo)
+    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(cmUnpkCkwEntCfgInfo,&(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);
+       CMCHKUNPKLOG(cmUnpkRlcEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
     }
 
-    switch(pst->selector)
-    {
-       case CKW_SEL_LWLC:
-          {
-             CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf); 
-             break;
-          }
-/* HLAL */
-#if 0
-#ifdef LCCKW
-       case CKW_SEL_LC:
-       {
-          ret1 = cmUnpkCkwCfgInfo( (cfgInfo), pst, mBuf);
-#if(ERRCLASS & ERRCLS_DEBUG)
-          if(ret1 != ROK)
-          {
-             SPutMsg(mBuf);
-             SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
-                   __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
-                  (ErrVal)ECKW034, (ErrVal)ret1, "Unpacking failure");
-             RETVALUE( ret1 );
-          }
-#endif /* ERRCLASS & ERRCLS_DEBUG */
-          break;
-       }
-#endif /* LCCKW */
-#endif /* HLAL */
-
-    }
-    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
 *
@@ -1504,27 +1319,27 @@ 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)
+    TRC3(cmUnpkRlcCfgCfm)
 
     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
-                sizeof(CkwCfgCfmInfo))) != ROK)
+                sizeof(RlcCfgCfmInfo))) != ROK)
     {
 #if (ERRCLASS & ERRCLS_ADD_RES)
        if(ret1 != ROK)
@@ -1534,19 +1349,19 @@ Buffer            *mBuf;
                (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
-    cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
+    cmMemset((U8 *)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)
           {
@@ -1554,7 +1369,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;
@@ -1563,8 +1378,8 @@ Buffer            *mBuf;
     }
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, cfgCfmInfo));
-} /* cmUnpkCkwCfgCfm */
+    return ((*func)(pst, suId, cfgCfmInfo));
+} /* cmUnpkRlcCfgCfm */
 
 /*
 *
@@ -1580,13 +1395,13 @@ 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
@@ -1596,14 +1411,14 @@ Buffer    *mBuf;
    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
 *
@@ -1613,14 +1428,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;
@@ -1636,7 +1451,7 @@ Buffer            *mBuf;
 
 
     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)
@@ -1648,7 +1463,7 @@ Buffer            *mBuf;
                (ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
       
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
@@ -1661,7 +1476,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 */
 
@@ -1675,7 +1490,7 @@ Buffer            *mBuf;
                (ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
        
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
@@ -1688,13 +1503,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 */
 
@@ -1702,7 +1517,7 @@ Buffer            *mBuf;
 *
 *    Fun:     cmUnpkCkwUeIdChgCfm
 *
-*    Desc:    unpack the primitive KwUiCkwUeIdChgCfm
+*    Desc:    unpack the primitive RlcUiCkwUeIdChgCfm
 *
 *    Ret:     ROK  -ok
 *
@@ -1712,14 +1527,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;
@@ -1736,7 +1551,7 @@ Buffer            *mBuf;
     cmMemset((U8 *)&status, (U8)0, (PTR)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)
@@ -1749,7 +1564,7 @@ Buffer            *mBuf;
                (ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
        }
 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
-       RETVALUE(ret1);
+       return (ret1);
     }
 
     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
@@ -1762,7 +1577,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 */
 
@@ -1770,7 +1585,7 @@ Buffer            *mBuf;
 
     SPutMsg(mBuf);
 
-    RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+    return ((*func)(pst, suId, transId, ueInfo, status));
 
 } /* cmUnpkCkwUeIdChgCfm */