*********************************************************************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 */
\f
#ifdef __cplusplus
(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
/*
(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
/*
}
#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
/*
*
-* Fun: cmPkCkwTmInfo
+* Fun: cmPkRlcTmInfo
*
-* Desc: pack the structure CkwTmInfo
+* Desc: pack the structure RlcTmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwTmInfo
+PUBLIC S16 cmPkRlcTmInfo
(
-CkwTmInfo *param,
+RlcTmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwTmInfo(param, mBuf)
-CkwTmInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmPkCkwUmInfo
+* Fun: cmPkRlcUmInfo
*
-* Desc: pack the structure CkwUmInfo
+* Desc: pack the structure RlcUmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwUmInfo
+PUBLIC S16 cmPkRlcUmInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwUmInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmPkCkwAmInfo
+* Fun: cmPkRlcAmInfo
*
-* Desc: pack the structure CkwAmInfo
+* Desc: pack the structure RlcAmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwAmInfo
+PUBLIC S16 cmPkRlcAmInfo
(
-CkwAmInfo *param,
+RlcAmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwAmInfo(param, mBuf)
-CkwAmInfo *param;
+PUBLIC 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 */
\f
/*
{
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
/*
*
-* Fun: cmPkCkwEntCfgInfo
+* Fun: cmPkRlcEntCfgInfo
*
-* Desc: pack the structure CkwEntCfgInfo
+* Desc: pack the structure RlcEntCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwEntCfgInfo
+PUBLIC S16 cmPkRlcEntCfgInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwEntCfgInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC 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;
}
}
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 */
\f
/*
*
-* Fun: cmPkCkwCfgInfo
+* Fun: cmPkRlcCfgInfo
*
-* Desc: pack the structure CkwCfgInfo
+* Desc: pack the structure RlcCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgInfo
+PUBLIC S16 cmPkRlcCfgInfo
(
-CkwCfgInfo *param,
+RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwCfgInfo(param, pst, mBuf)
-CkwCfgInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmPkCkwCfgReq
+* Fun: cmPkRlcEntCfgCfmInfo
*
-* Desc: pack the primitive KwUiCkwCfgReq
+* Desc: pack the structure RlcEntCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgReq
+PUBLIC S16 cmPkRlcEntCfgCfmInfo
(
-Pst *pst,
-SpId spId,
-CkwCfgInfo *cfgInfo
-)
-#else
-PUBLIC S16 cmPkCkwCfgReq(pst, spId, cfgInfo)
-Pst *pst;
-SpId spId;
-CkwCfgInfo *cfgInfo;
-#endif
-{
- S16 ret1;
- Buffer *mBuf;
- mBuf = NULLP;
- TRC3(cmPkCkwCfgReq)
-
- 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)
- {
-#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 */
- }
-
- CMCHKPKLOG(SPkS16, spId, mBuf, ECKW013, pst);
- pst->event = (Event) CKW_EVT_CFG_REQ;
-
- RETVALUE(SPstTsk(pst,mBuf));
-} /* cmPkCkwCfgReq */
-
-\f
-/*
-*
-* 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;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmPkCkwCfgCfmInfo
+* Fun: cmPkRlcCfgCfmInfo
*
-* Desc: pack the structure CkwCfgCfmInfo
+* Desc: pack the structure RlcCfgCfmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgCfmInfo
+PUBLIC S16 cmPkRlcCfgCfmInfo
(
-CkwCfgCfmInfo *param,
+RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
-CkwCfgCfmInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmPkCkwCfgCfm
+* Fun: cmPkRlcCfgCfm
*
-* Desc: pack the primitive KwUiCkwCfgCfm
+* Desc: pack the primitive KwUiRlcCfgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkCkwCfgCfm
+PUBLIC S16 cmPkRlcCfgCfm
(
Pst *pst,
SuId suId,
-CkwCfgCfmInfo *cfgCfmInfo
+RlcCfgCfmInfo *cfgCfmInfo
)
#else
-PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
+PUBLIC 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)
{
(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)
{
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;
CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
pst->event = (Event) CKW_EVT_CFG_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
-} /* cmPkCkwCfgCfm */
+ return (SPstTsk(pst,mBuf));
+} /* cmPkRlcCfgCfm */
/*
*
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
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 */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPK(cmPkCmStatus, &status, mBuf);
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 */
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
} /*end of function cmUnpkCkwBndReq*/
\f
/*
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
/*
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
/*
*
-* Fun: cmUnpkCkwTmInfo
+* Fun: cmUnpkRlcTmInfo
*
-* Desc: pack the structure CkwTmInfo
+* Desc: pack the structure RlcTmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwTmInfo
+PUBLIC S16 cmUnpkRlcTmInfo
(
-CkwTmInfo *param,
+RlcTmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
-CkwTmInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmUnpkCkwUmInfo
+* Fun: cmUnpkRlcUmInfo
*
-* Desc: pack the structure CkwUmInfo
+* Desc: pack the structure RlcUmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwUmInfo
+PUBLIC S16 cmUnpkRlcUmInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmUnpkCkwAmInfo
+* Fun: cmUnpkRlcAmInfo
*
-* Desc: pack the structure CkwAmInfo
+* Desc: pack the structure RlcAmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwAmInfo
+PUBLIC S16 cmUnpkRlcAmInfo
(
-CkwAmInfo *param,
+RlcAmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
-CkwAmInfo *param;
+PUBLIC 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 */
\f
/*
{
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
/*
*
-* Fun: cmUnpkCkwEntCfgCfmInfo
+* Fun: cmUnpkRlcEntCfgCfmInfo
*
-* Desc: unpack the structure CkwEntCfgInfo
+* Desc: unpack the structure RlcEntCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
+PUBLIC S16 cmUnpkRlcEntCfgCfmInfo
(
-CkwEntCfgCfmInfo *param,
+RlcEntCfgCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
-CkwEntCfgCfmInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmUnpkCkwCfgCfmInfo
+* Fun: cmUnpkRlcCfgCfmInfo
*
-* Desc: pack the structure CkwCfgCfmInfo
+* Desc: pack the structure RlcCfgCfmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgCfmInfo
+PUBLIC S16 cmUnpkRlcCfgCfmInfo
(
-CkwCfgCfmInfo *param,
+RlcCfgCfmInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
-CkwCfgCfmInfo *param;
+PUBLIC 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 */
\f
/*
*
-* Fun: cmUnpkCkwEntCfgInfo
+* Fun: cmUnpkRlcEntCfgInfo
*
-* Desc: pack the structure CkwEntCfgCfmInfo
+* Desc: pack the structure RlcEntCfgCfmInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwEntCfgInfo
+PUBLIC S16 cmUnpkRlcEntCfgInfo
(
-CkwEntCfgInfo *param,
+RlcEntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
-CkwEntCfgInfo *param;
+PUBLIC 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);
{
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 */
\f
/*
*
-* Fun: cmUnpkCkwCfgInfo
+* Fun: cmUnpkRlcCfgInfo
*
-* Desc: unpack the structure CkwCfgInfo
+* Desc: unpack the structure RlcCfgInfo
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgInfo
+PUBLIC S16 cmUnpkRlcCfgInfo
(
-CkwCfgInfo *param,
+RlcCfgInfo *param,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
-CkwCfgInfo *param;
+PUBLIC 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);
+ CMCHKUNPKLOG(cmUnpkRlcEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
}
- RETVALUE(ROK);
-} /* cmUnpkCkwCfgInfo */
-
-\f
-/*
-*
-* Fun: cmUnpkCkwCfgReq
-*
-* Desc: unpack the primitive KwUiCkwCfgReq
-*
-* Ret: ROK -ok
-*
-* Notes: None
-*
-* File: ckw.c
-*
-*/
-#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgReq
-(
-CkwCfgReq func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
-CkwCfgReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
-{
- S16 ret1;
- SpId spId = 0;
- CkwCfgInfo *cfgInfo = NULLP;
-
- TRC3(cmUnpkCkwCfgReq)
-
- 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);
- }
-
- cmMemset((U8 *)cfgInfo, 0, sizeof(CkwCfgInfo));
-
- CMCHKUNPK(SUnpkS16, &(spId), mBuf);
- switch(pst->selector)
- {
-#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 */
- }
- SPutMsg(mBuf);
-
- RETVALUE((*func)(pst, spId, cfgInfo));
-} /* cmUnpkCkwCfgReq */
+ return ROK;
+} /* cmUnpkRlcCfgInfo */
\f
/*
*
-* Fun: cmUnpkCkwCfgCfm
+* Fun: cmUnpkRlcCfgCfm
*
-* Desc: unpack the primitive KwUiCkwCfgCfm
+* Desc: unpack the primitive KwUiRlcCfgCfm
*
* Ret: ROK -ok
*
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCkwCfgCfm
+PUBLIC S16 cmUnpkRlcCfgCfm
(
-CkwCfgCfm func,
+RlcCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
-CkwCfgCfm func;
+PUBLIC 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)
(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)
{
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;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, cfgCfmInfo));
-} /* cmUnpkCkwCfgCfm */
+ return ((*func)(pst, suId, cfgCfmInfo));
+} /* cmUnpkRlcCfgCfm */
/*
*
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*
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)
(ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
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 */
(ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
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 */
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)
(ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
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 */
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+ return ((*func)(pst, suId, transId, ueInfo, status));
} /* cmUnpkCkwUeIdChgCfm */
Code Review / o-du / l2.git / blobdiff