*********************************************************************21*/
/* header include files (.h) */
-#include "envopt.h" /* Environment options */
-#include "envdep.h" /* Environment dependent options */
-#include "envind.h" /* Environment independent options */
-#include "gen.h" /* General layer */
-#include "ssi.h" /* System service interface */
-#include "cm5.h" /* Common timer library */
-#include "cm_llist.h" /* Common linked list library */
-#include "cm_hash.h" /* Common hash library */
-#include "cm_tkns.h" /* Common tokens */
-#include "cm_lte.h" /* Common LTE Defines */
+#include "common_def.h"
#include "ctf.h" /* CTF interface defines */
/* header/extern include files (.x) */
-#include "gen.x" /* General layer */
-#include "ssi.x" /* System services interface */
-#include "cm_lib.x" /* Common linrary function */
-#include "cm_llist.x" /* Common link list library */
-#include "cm_hash.x" /* Common hash list library */
-#include "cm_tkns.x" /* Common tokens */
-#include "cm_lte.x" /* Common LTE library */
#ifdef TENB_AS_SECURITY
#include "cm_mblk.x"
#endif
#include "ctf.x"
#ifdef TENB_AS_SECURITY
-#define cmPkCtfCrnti SPkU16
-#define cmPkCtfCellId SPkU16
-#define cmUnpkCtfCellId SUnpkU16
-#define cmUnpkCtfCrnti SUnpkU16
+#define cmPkCtfCrnti oduUnpackUInt16
+#define cmPkCtfCellId oduUnpackUInt16
+#define cmUnpkCtfCellId oduPackUInt16
+#define cmUnpkCtfCrnti oduPackUInt16
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfBndReq
+S16 cmPkCtfBndReq
(
Pst* pst,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 cmPkCtfBndReq(pst, suId, spId)
+S16 cmPkCtfBndReq(pst, suId, spId)
Pst* pst;
SuId suId;
SpId spId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfBndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF001, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF002, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF003, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfBndReq
+S16 cmUnpkCtfBndReq
(
CtfBndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfBndReq(func, pst, mBuf)
+S16 cmUnpkCtfBndReq(func, pst, mBuf)
CtfBndReq func;
Pst *pst;
Buffer *mBuf;
SuId suId = 0;
SpId spId = 0;
- TRC3(cmUnpkCtfBndReq)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF004, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF005, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfBndCfm
+S16 cmPkCtfBndCfm
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
-PUBLIC S16 cmPkCtfBndCfm(pst, suId, status)
+S16 cmPkCtfBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfBndCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF006, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ECTF007, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF008, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfBndCfm
+S16 cmUnpkCtfBndCfm
(
CtfBndCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfBndCfm(func, pst, mBuf)
+S16 cmUnpkCtfBndCfm(func, pst, mBuf)
CtfBndCfm func;
Pst *pst;
Buffer *mBuf;
#endif
{
SuId suId = 0;
- U8 status;
+ uint8_t status;
- TRC3(cmUnpkCtfBndCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF009, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF010, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUbndReq
+S16 cmPkCtfUbndReq
(
Pst* pst,
SpId spId,
Reason reason
)
#else
-PUBLIC S16 cmPkCtfUbndReq(pst, spId, reason)
+S16 cmPkCtfUbndReq(pst, spId, reason)
Pst* pst;
SpId spId;
Reason reason;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfUbndReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF011, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF012, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF013, (ErrVal)0,(Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUbndReq
+S16 cmUnpkCtfUbndReq
(
CtfUbndReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUbndReq(func, pst, mBuf)
+S16 cmUnpkCtfUbndReq(func, pst, mBuf)
CtfUbndReq func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkCtfUbndReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF014, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF015, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
- RETVALUE(ROK);
+ return ROK;
}
#ifdef TENB_AS_SECURITY
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfNhKeyInfo
+S16 cmPkCtfNhKeyInfo
(
CtfNhKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfNhKeyInfo(param, mBuf)
+S16 cmPkCtfNhKeyInfo(param, mBuf)
CtfNhKeyInfo *param;
Buffer *mBuf;
#endif
S16 idx;
- TRC3(cmPkCtfNhKeyInfo)
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- CMCHKPK(SPkU16, param->physCellId, mBuf);
- CMCHKPK(SPkU16, param->dlCarrFreq, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dlCarrFreq, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKenbStarInfo
+S16 cmPkCtfKenbStarInfo
(
CtfKenbStarInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKenbStarInfo(param, mBuf)
+S16 cmPkCtfKenbStarInfo(param, mBuf)
CtfKenbStarInfo *param;
Buffer *mBuf;
#endif
S16 idx;
- TRC3(cmPkCtfKenbStarInfo)
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- CMCHKPK(SPkU16, param->physCellId, mBuf);
- CMCHKPK(SPkU16, param->dlCarrFreq, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dlCarrFreq, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfAskeyInfo
+S16 cmPkCtfAskeyInfo
(
CtfAsKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfAskeyInfo(param, mBuf)
+S16 cmPkCtfAskeyInfo(param, mBuf)
CtfAsKeyInfo *param;
Buffer *mBuf;
#endif
S16 idx;
- TRC3(cmPkCtfAskeyInfo)
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- CMCHKPK(SPkU8, param->ciphAlgoType, mBuf);
- CMCHKPK(SPkU8, param->intgAlgoType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ciphAlgoType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->intgAlgoType, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfReqInfo
+S16 cmPkCtfKdfReqInfo
(
CtfKdfReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKdfReqInfo(param, mBuf)
+S16 cmPkCtfKdfReqInfo(param, mBuf)
CtfKdfReqInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfKdfReqInfo)
switch (param->keyDerType)
{
CMCHKPK(cmPkCtfNhKeyInfo , ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->keyDerType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->keyDerType, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfReq
+S16 cmPkCtfKdfReq
(
Pst* pst,
SpId spId,
CtfKdfReqInfo* kdfReqInfo
)
#else
-PUBLIC S16 cmPkCtfKdfReq(pst, spId, transId, kdfReqInfo)
+S16 cmPkCtfKdfReq(pst, spId, transId, kdfReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId transId;
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfKdfReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfKdfReqInfo(kdfReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
- #if 0
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
-#if (ERRCLASS & ERRCLS_ADD_RES)
- /* ctf_c_001.main_3 Compilation warning fix with g++ */
- SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
- (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
- (ErrVal)ECTF018, (ErrVal)0, (Txt*)&"Packing failed");
-#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
- SPutMsg(mBuf);
- RETVALUE(RFAILED);
- }
- #endif
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF021, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTCTFKDFREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#endif
/*START OF CNM PACK & UNPACK FUNCTIONS*/
/********************************************************************************************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmVendorSpecificInfo
+S16 cmPkCtfCnmVendorSpecificInfo
(
CtfCnmVendorSpecificInfo *param,
Buffer *mBuf
#endif
{
S32 i;
- TRC3(cmPkCtfCnmVendorSpecificInfo);
if(param->numOfVendorSpecifcParam <= CTF_CNM_MAX_VENDOR_PARAMS)
{
for(i= param->numOfVendorSpecifcParam-1; i >= 0; i--)
{
- CMCHKPK(SPkU32,(U32)param->vendorSpecifcParam[i], mBuf);
+ CMCHKPK(oduUnpackUInt32,(uint32_t)param->vendorSpecifcParam[i], mBuf);
}
}
- CMCHKPK(SPkU16, param->numOfVendorSpecifcParam, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->numOfVendorSpecifcParam, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfCtfCnmCellSyncReq
+S16 cmPkCtfCtfCnmCellSyncReq
(
CtfCnmCellSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCtfCnmCellSyncReq(param, mBuf)
+S16 cmPkCtfCtfCnmCellSyncReq(param, mBuf)
CtfCnmCellSyncReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCtfCnmCellSyncReq);
- CMCHKPK(SPkU16, param->nbrEarfcn, mBuf);
- CMCHKPK(SPkU16, param->nbrPCellId, mBuf);
- CMCHKPK(SPkU8, param->nbrTxAntCount, mBuf);
- CMCHKPK(SPkU8, param->nbrCellCp, mBuf);
- CMCHKPK(SPkU8, param->nbrCellNRb, mBuf);
- CMCHKPK(SPkU8, param->nbrSpecSfCfg, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nbrEarfcn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nbrPCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrTxAntCount, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrCellCp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrCellNRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrSpecSfCfg, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfcfgReqInfo
+S16 cmPkCtfcfgReqInfo
(
CtfCnmInitSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfcfgReqInfo(param, mBuf)
+S16 cmPkCtfcfgReqInfo(param, mBuf)
CtfCnmInitSyncReq *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkCtfcfgReqInfo);
- CMCHKPK(SPkU8, param->searchType, mBuf);
- CMCHKPK(SPkU8, param->mibRequest, mBuf);
- CMCHKPK(SPkU16, param->earfcn, mBuf);
- CMCHKPK(SPkU8, param->measBandWidth, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->searchType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mibRequest, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->earfcn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->measBandWidth, mBuf);
if(param->numOfPciList <= CTF_CNM_MAX_CELL_SEARCH)
{
for(i= param->numOfPciList-1; i >= 0; i--)
CMCHKPK(cmPkCtfCtfCnmCellSyncReq, ¶m->pciList[i], mBuf);
}
}
- CMCHKPK(SPkU16, param->numOfPciList, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->numOfPciList, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmVendorSpecificInfo
+S16 cmUnpkCtfCnmVendorSpecificInfo
(
CtfCnmVendorSpecificInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmVendorSpecificInfo(param, mBuf)
+S16 cmUnpkCtfCnmVendorSpecificInfo(param, mBuf)
CtfCnmVendorSpecificInfo *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkCtfCnmVendorSpecificInfo);
- CMCHKUNPK(SUnpkU16, ¶m->numOfVendorSpecifcParam, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfVendorSpecifcParam, mBuf);
for(i=0; (i<param->numOfVendorSpecifcParam)&&(i < CTF_CNM_MAX_VENDOR_PARAMS); i++)
{
- CMCHKUNPK(SUnpkU32, ¶m->vendorSpecifcParam[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->vendorSpecifcParam[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCtfCnmCellSyncReq
+S16 cmUnpkCtfCtfCnmCellSyncReq
(
CtfCnmCellSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCtfCnmCellSyncReq(param, mBuf)
+S16 cmUnpkCtfCtfCnmCellSyncReq(param, mBuf)
CtfCnmCellSyncReq *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCtfCnmCellSyncReq);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrSpecSfCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrCellNRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrCellCp, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrTxAntCount, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->nbrPCellId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->nbrEarfcn, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrSpecSfCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrCellNRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrCellCp, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrTxAntCount, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->nbrPCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->nbrEarfcn, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfsyncReqInfo
+S16 cmUnpkCtfsyncReqInfo
(
CtfCnmInitSyncReq *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfsyncReqInfo(param, mBuf)
+S16 cmUnpkCtfsyncReqInfo(param, mBuf)
CtfCnmInitSyncReq *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkCtfsyncReqInfo);
- CMCHKUNPK(SUnpkU16, ¶m->numOfPciList, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfPciList, mBuf);
for(i=0; (i < param->numOfPciList)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
{
CMCHKUNPK(cmUnpkCtfCtfCnmCellSyncReq, ¶m->pciList[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->measBandWidth, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->earfcn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mibRequest, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->searchType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->measBandWidth, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->earfcn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mibRequest, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->searchType, mBuf);
+ return ROK;
}
/**
* @brief Configuration Request from App to CL for
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmCellSyncReq
+S16 cmPkCtfCnmCellSyncReq
(
Pst* pst,
SpId spId,
CtfCnmCellSyncReq * cfgReqInfo
)
#else
-PUBLIC S16 cmPkCtfCnmCellSyncReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCtfCnmCellSyncReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmCellSyncReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfCtfCnmCellSyncReq(cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
}
pst->event = (Event)EVTCTFCNMSYNCREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmCellSyncReq
+S16 cmUnpkCtfCnmCellSyncReq
(
CtfCnmCellSyncReqMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmCellSyncReq(func, pst, mBuf)
+S16 cmUnpkCtfCnmCellSyncReq(func, pst, mBuf)
CtfCnmCellSyncReqMsg func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmCellSyncReq *SyncReqMsg = NULLP;
- TRC3(cmUnpkCtfCnmCellSyncReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&SyncReqMsg, sizeof(CtfCnmCellSyncReq))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&SyncReqMsg, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&SyncReqMsg, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCtfCnmCellSyncReq(SyncReqMsg, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)SyncReqMsg, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, SyncReqMsg));
+ return ((*func)(pst, spId, &transId, SyncReqMsg));
}
/*-----------------------------------------------------*/
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmInitSyncReq
+S16 cmPkCtfCnmInitSyncReq
(
Pst* pst,
SpId spId,
CtfCnmInitSyncReq * cfgReqInfo
)
#else
-PUBLIC S16 cmPkCtfCnmInitSyncReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCtfCnmInitSyncReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmInitSyncReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfcfgReqInfo(cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
}
pst->event = (Event)EVTCTFCNMINITSYNCREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*-----------------------------------------------------------------*/
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmInitSyncReq
+S16 cmUnpkCtfCnmInitSyncReq
(
CtfCnmInitSyncReqMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmInitSyncReq(func, pst, mBuf)
+S16 cmUnpkCtfCnmInitSyncReq(func, pst, mBuf)
CtfCnmInitSyncReqMsg func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmInitSyncReq *syncReqInfo = NULLP;
- TRC3(cmUnpkCtfCnmInitSyncReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncReqInfo, sizeof(CtfCnmInitSyncReq))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&syncReqInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&syncReqInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfsyncReqInfo(syncReqInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)syncReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncReqInfo));
+ return ((*func)(pst, spId, &transId, syncReqInfo));
}
/*-----------------------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmPkCtfctfCnmMibInfo
+S16 cmPkCtfctfCnmMibInfo
(
CtfCnmMibInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfctfCnmMibInfo(param, mBuf)
+S16 cmPkCtfctfCnmMibInfo(param, mBuf)
CtfCnmMibInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfctfCnmMibInfo)
- CMCHKPK(SPkU16, param->sfn, mBuf);
- CMCHKPK(SPkU8, param->numTxAntennas, mBuf);
- CMCHKPK(SPkU8, param->phichDuration, mBuf);
- CMCHKPK(SPkU8, param->phichResource, mBuf);
- CMCHKPK(SPkU8, param->dlSystemBandWidht, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numTxAntennas, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phichDuration, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phichResource, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlSystemBandWidht, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfctfCnmInitSyncInfo
+S16 cmPkCtfctfCnmInitSyncInfo
(
CtfCnmInitSyncInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfctfCnmInitSyncInfo(param, mBuf)
+S16 cmPkCtfctfCnmInitSyncInfo(param, mBuf)
CtfCnmInitSyncInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfctfCnmInitSyncInfo)
- CMCHKPK(SPkU16, param->pci, mBuf);
- CMCHKPK(SPkU8, param->rsrp, mBuf);
- CMCHKPK(SPkU8, param->mibValidFlag, mBuf);
- CMCHKPK(SPkU16, param->localSfn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rsrp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mibValidFlag, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->localSfn, mBuf);
CMCHKPK(cmPkCtfctfCnmMibInfo, ¶m->ctfCnmMibInfo, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmPkCtfcfgRspInfo
+S16 cmPkCtfcfgRspInfo
(
CtfCnmInitSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfcfgRspInfo(param, mBuf)
+S16 cmPkCtfcfgRspInfo(param, mBuf)
CtfCnmInitSyncRsp *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkCtfcfgRspInfo)
- CMCHKPK(SPkU8, param->status, mBuf);
- CMCHKPK(SPkU16, param->earfcn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->earfcn, mBuf);
if(param->numOfNeighbourInfo <= CTF_CNM_MAX_CELL_SEARCH)
{
for(i= param->numOfNeighbourInfo-1; i >= 0; i--)
CMCHKPK(cmPkCtfctfCnmInitSyncInfo, ¶m->ctfCnmInitSyncInfo[i], mBuf);
}
}
- CMCHKPK(SPkU8, param->numOfNeighbourInfo, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numOfNeighbourInfo, mBuf);
+ return ROK;
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmInitSyncRsp
+S16 cmPkCtfCnmInitSyncRsp
(
Pst* pst,
SpId spId,
CtfCnmInitSyncRsp * cfgRspInfo
)
#else
-PUBLIC S16 cmPkCtfCnmInitSyncRsp(pst, spId, transId, cfgRspInfo)
+S16 cmPkCtfCnmInitSyncRsp(pst, spId, transId, cfgRspInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmInitSyncRsp)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfcfgRspInfo(cfgRspInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgRspInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgRspInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
}
pst->event = (Event)EVTCTFCNMINITSYNCRSP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*-----------------------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfctfCnmMibInfo
+S16 cmUnpkCtfctfCnmMibInfo
(
CtfCnmMibInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfctfCnmMibInfo(param, mBuf)
+S16 cmUnpkCtfctfCnmMibInfo(param, mBuf)
CtfCnmMibInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfctfCnmMibInfo);
- CMCHKUNPK(SUnpkU8, ¶m->dlSystemBandWidht, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phichResource, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phichDuration, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numTxAntennas, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sfn, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlSystemBandWidht, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phichResource, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phichDuration, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numTxAntennas, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkctfCnmInitSyncInfo
+S16 cmUnpkctfCnmInitSyncInfo
(
CtfCnmInitSyncInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkctfCnmInitSyncInfo(param, mBuf)
+S16 cmUnpkctfCnmInitSyncInfo(param, mBuf)
CtfCnmInitSyncInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkctfCnmInitSyncInfo);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
CMCHKUNPK(cmUnpkCtfctfCnmMibInfo, ¶m->ctfCnmMibInfo, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->localSfn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mibValidFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rsrp, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pci, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->localSfn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mibValidFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rsrp, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pci, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmInitSyncRspMsg
+S16 cmUnpkCtfCnmInitSyncRspMsg
(
CtfCnmInitSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmInitSyncRspMsg(param, mBuf)
+S16 cmUnpkCtfCnmInitSyncRspMsg(param, mBuf)
CtfCnmInitSyncRsp *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkCtfCnmInitSyncRspMsg);
- CMCHKUNPK(SUnpkU8, ¶m->numOfNeighbourInfo, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numOfNeighbourInfo, mBuf);
for(i=0; (i < param->numOfNeighbourInfo)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
{
CMCHKUNPK(cmUnpkctfCnmInitSyncInfo, ¶m->ctfCnmInitSyncInfo[i], mBuf);
}
- CMCHKUNPK(SUnpkU16, ¶m->earfcn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->earfcn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmInitSyncRsp
+S16 cmUnpkCtfCnmInitSyncRsp
(
CtfCnmInitSyncRspMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmInitSyncRsp(func, pst, mBuf)
+S16 cmUnpkCtfCnmInitSyncRsp(func, pst, mBuf)
CtfCnmInitSyncRspMsg func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmInitSyncRsp *syncRspInfo = NULLP;
- TRC3(cmUnpkCtfCnmInitSyncRsp)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspInfo, sizeof(CtfCnmInitSyncRsp))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if(cmUnpkPtr((PTR *)&syncRspInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if(oduUnpackPointer((PTR *)&syncRspInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if(cmUnpkCtfCnmInitSyncRspMsg(syncRspInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)syncRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncRspInfo));
+ return ((*func)(pst, spId, &transId, syncRspInfo));
}
/*-----------------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellSyncRsp
+S16 cmPkCtfCellSyncRsp
(
CtfCnmCellSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellSyncRsp(param, mBuf)
+S16 cmPkCtfCellSyncRsp(param, mBuf)
CtfCnmCellSyncRsp *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCellSyncRsp)
- CMCHKPK(SPkU8, param->status, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmCellSyncRsp
+S16 cmPkCtfCnmCellSyncRsp
(
Pst* pst,
SpId spId,
CtfCnmCellSyncRsp * cfgRspInfo
)
#else
-PUBLIC S16 cmPkCtfCnmCellSyncRsp(pst, spId, transId, cfgRspInfo)
+S16 cmPkCtfCnmCellSyncRsp(pst, spId, transId, cfgRspInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmCellSyncRsp)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfCellSyncRsp(cfgRspInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgRspInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgRspInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
}
pst->event = (Event)EVTCTFCNMSYNCRSP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmSyncRspMsg
+S16 cmUnpkCtfCnmSyncRspMsg
(
CtfCnmCellSyncRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmSyncRspMsg(param, mBuf)
+S16 cmUnpkCtfCnmSyncRspMsg(param, mBuf)
CtfCnmCellSyncRsp *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCnmSyncRspMsg);
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmCellSyncRsp
+S16 cmUnpkCtfCnmCellSyncRsp
(
CtfCnmCellSyncRspMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmCellSyncRsp(func, pst, mBuf)
+S16 cmUnpkCtfCnmCellSyncRsp(func, pst, mBuf)
CtfCnmCellSyncRspMsg func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmCellSyncRsp *syncRspMsg = NULLP;
- TRC3(cmUnpkCtfCnmCellSyncRsp)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspMsg, sizeof(CtfCnmCellSyncRsp))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&syncRspMsg, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&syncRspMsg, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCnmSyncRspMsg(syncRspMsg, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)syncRspMsg, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncRspMsg));
+ return ((*func)(pst, spId, &transId, syncRspMsg));
}
/*---------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmPkCtfcfgIndInfo
+S16 cmPkCtfcfgIndInfo
(
CtfCnmCellSyncInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfcfgIndInfo(param, mBuf)
+S16 cmPkCtfcfgIndInfo(param, mBuf)
CtfCnmCellSyncInd *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfcfgIndInfo);
- CMCHKPK(SPkU8, param->status, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCnmCellSyncInd
+S16 cmPkCtfCnmCellSyncInd
(
Pst* pst,
SpId spId,
CtfCnmCellSyncInd * cfgIndInfo
)
#else
-PUBLIC S16 cmPkCtfCnmCellSyncInd(pst, spId, transId, cfgIndInfo)
+S16 cmPkCtfCnmCellSyncInd(pst, spId, transId, cfgIndInfo)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCnmCellSyncInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfcfgIndInfo(cfgIndInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgIndInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgIndInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
}
pst->event = (Event)EVTCTFCNMSYNCIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*---------------------------------------------------------------*/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmSyncIndMsg
+S16 cmUnpkCtfCnmSyncIndMsg
(
CtfCnmCellSyncInd *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmSyncIndMsg(param, mBuf)
+S16 cmUnpkCtfCnmSyncIndMsg(param, mBuf)
CtfCnmCellSyncInd *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCnmSyncIndMsg);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCnmCellSyncInd
+S16 cmUnpkCtfCnmCellSyncInd
(
CtfCnmCellSyncIndMsg func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCnmCellSyncInd(func, pst, mBuf)
+S16 cmUnpkCtfCnmCellSyncInd(func, pst, mBuf)
CtfCnmCellSyncIndMsg func;
Pst *pst;
Buffer *mBuf;
SpId spId = 0;
CtfCfgTransId transId;
CtfCnmCellSyncInd *syncIndMsg = NULLP;
- TRC3(cmUnpkCtfCnmInitSyncRsp)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncIndMsg, sizeof(CtfCnmCellSyncInd))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&syncIndMsg, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&syncIndMsg, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCnmSyncIndMsg(syncIndMsg, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)syncIndMsg, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncIndMsg));
+ return ((*func)(pst, spId, &transId, syncIndMsg));
}
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgReq
+S16 cmPkCtfCfgReq
(
Pst* pst,
SpId spId,
CtfCfgReqInfo* cfgReqInfo
)
#else
-PUBLIC S16 cmPkCtfCfgReq(pst, spId, transId, cfgReqInfo)
+S16 cmPkCtfCfgReq(pst, spId, transId, cfgReqInfo)
Pst* pst;
SpId spId;
CtfCfgTransId transId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCfgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF016, (ErrVal)0, "Packing failed");
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduPackPointer((PTR)cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
cmRelCtfCfgReq(pst, cfgReqInfo);
}
pst->event = (Event) EVTCTFCFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef TENB_AS_SECURITY
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfNhKeyInfo
+S16 cmUnpkCtfNhKeyInfo
(
CtfNhKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfNhKeyInfo(param, mBuf)
+S16 cmUnpkCtfNhKeyInfo(param, mBuf)
CtfNhKeyInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkCtfNhKeyInfo)
- CMCHKUNPK(SUnpkU16, ¶m->dlCarrFreq, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->physCellId, mBuf);
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKenbStarInfo
+S16 cmUnpkCtfKenbStarInfo
(
CtfKenbStarInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKenbStarInfo(param, mBuf)
+S16 cmUnpkCtfKenbStarInfo(param, mBuf)
CtfKenbStarInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkCtfKenbStarInfo)
- CMCHKUNPK(SUnpkU16, ¶m->dlCarrFreq, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->physCellId, mBuf);
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfAskeyInfo
+S16 cmUnpkCtfAskeyInfo
(
CtfAsKeyInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfAskeyInfo(param, mBuf)
+S16 cmUnpkCtfAskeyInfo(param, mBuf)
CtfAskeyInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkCtfAskeyInfo)
- CMCHKUNPK(SUnpkU8, ¶m->intgAlgoType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ciphAlgoType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->intgAlgoType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ciphAlgoType, mBuf);
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
* **********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfReqInfo
+S16 cmUnpkCtfKdfReqInfo
(
CtfKdfReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKdfReqInfo(param, mBuf)
+S16 cmUnpkCtfKdfReqInfo(param, mBuf)
CtfKdfReqInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfKdfReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->keyDerType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->keyDerType, mBuf);
switch (param->keyDerType)
{
case CTF_KDF_TYPE1:
CMCHKUNPK(cmUnpkCtfNhKeyInfo, ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfReq
+S16 cmUnpkCtfKdfReq
(
CtfKdfReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKdfReq(func, pst, mBuf)
+S16 cmUnpkCtfKdfReq(func, pst, mBuf)
CtfKdfReq func;
Pst *pst;
Buffer *mBuf;
CtfCfgTransId transId;
CtfKdfReqInfo *kdfReqInfo = NULLP;
- TRC3(cmUnpkCtfKdfReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&kdfReqInfo, sizeof(CtfKdfReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- /*if (cmUnpkPtr((PTR *)&cfgReqInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ /*if (oduUnpackPointer((PTR *)&cfgReqInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}*/
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfKdfReqInfo(kdfReqInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, kdfReqInfo));
+ return ((*func)(pst, spId, transId, kdfReqInfo));
}
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgReq
+S16 cmUnpkCtfCfgReq
(
CtfCfgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgReq(func, pst, mBuf)
+S16 cmUnpkCtfCfgReq(func, pst, mBuf)
CtfCfgReq func;
Pst *pst;
Buffer *mBuf;
CtfCfgTransId transId;
CtfCfgReqInfo *cfgReqInfo = NULLP;
- TRC3(cmUnpkCtfCfgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CtfCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&cfgReqInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&cfgReqInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfCfgReqInfo(pst,cfgReqInfo, mBuf) != ROK) {
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
+ return ((*func)(pst, spId, transId, cfgReqInfo));
}
#ifdef TENB_AS_SECURITY
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfNhKeyCfmInfo
+S16 cmPkCtfNhKeyCfmInfo
(
CtfNhKeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfNhKeyCfmInfo(param, mBuf)
+S16 cmPkCtfNhKeyCfmInfo(param, mBuf)
CtfNhKeyCfmInfo *param;
Buffer *mBuf;
#endif
S16 idx;
- TRC3(cmPkCtfNhKeyCfmInfo)
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKenbStarCfmInfo
+S16 cmPkCtfKenbStarCfmInfo
(
CtfKenbStarCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKenbStarCfmInfo(param, mBuf)
+S16 cmPkCtfKenbStarCfmInfo(param, mBuf)
CtfKenbStarCfmInfo *param;
Buffer *mBuf;
#endif
S16 idx;
- TRC3(cmPkCtfKenbStarCfmInfo)
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfAskeyCfmInfo
+S16 cmPkCtfAskeyCfmInfo
(
CtfAskeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfAskeyCfmInfo(param, mBuf)
+S16 cmPkCtfAskeyCfmInfo(param, mBuf)
CtfAskeyCfmInfo *param;
Buffer *mBuf;
#endif
S16 idx;
- TRC3(cmPkCtfCtfAskeyCfmInfo)
for(idx=15;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->cpCiphKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->cpCiphKey[idx],mBuf);
}
for(idx=15;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->upCiphKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->upCiphKey[idx],mBuf);
}
for(idx=15;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->intKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->intKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
* **********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfCfmInfo
+S16 cmPkCtfKdfCfmInfo
(
CtfKdfCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfKdfCfmInfo(param, mBuf)
+S16 cmPkCtfKdfCfmInfo(param, mBuf)
CtfKdfCfmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfKdfCfmInfo)
switch (param->keyDerType)
{
CMCHKPK(cmPkCtfNhKeyCfmInfo, ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->keyDerType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->keyDerType, mBuf);
+ return ROK;
}
/**
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfKdfCfm
+S16 cmPkCtfKdfCfm
(
Pst* pst,
SuId suId,
CtfCfgTransId transId,
CtfKdfCfmInfo *kdfCfmInfo,
-U8 status
+uint8_t status
)
#else
-PUBLIC S16 cmPkCtfKdfCfm(pst, suId, transId, status)
+S16 cmPkCtfKdfCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfKdfCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfKdfCfmInfo(kdfCfmInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo)) != ROK)
(ErrVal)ECTF021, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFKDFCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#endif
\f
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgCfm
+S16 cmPkCtfCfgCfm
(
Pst* pst,
SuId suId,
CtfCfgTransId transId,
-U8 status
+uint8_t status
)
#else
-PUBLIC S16 cmPkCtfCfgCfm(pst, suId, transId, status)
+S16 cmPkCtfCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfCfgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ECTF027, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFCFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfEnbStopInd
+S16 cmPkCtfEnbStopInd
(
Pst* pst,
SuId suId,
CtfCfgTransId transId
)
#else
-PUBLIC S16 cmPkCtfEnbStopInd(pst, suId, transId)
+S16 cmPkCtfEnbStopInd(pst, suId, transId)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfEnbStopInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFENBSTOPIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef TENB_AS_SECURITY
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfNhKeyCfmInfo
+S16 cmUnpkCtfNhKeyCfmInfo
(
CtfNhKeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfNhKeyCfmInfo(param, mBuf)
+S16 cmUnpkCtfNhKeyCfmInfo(param, mBuf)
CtfNhKeyCfmInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkCtfNhKeyCfmInfo)
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKenbStarCfmInfo
+S16 cmUnpkCtfKenbStarCfmInfo
(
CtfKenbStarCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKenbStarCfmInfo(param, mBuf)
+S16 cmUnpkCtfKenbStarCfmInfo(param, mBuf)
CtfKenbStarCfmInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkCtfKenbStarCfmInfo)
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfAskeyCfmInfo
+S16 cmUnpkCtfAskeyCfmInfo
(
CtfAskeyCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfAskeyCfmInfo(param, mBuf)
+S16 cmUnpkCtfAskeyCfmInfo(param, mBuf)
CtfAskeyCfmInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmUnpkCtfCtfAskeyCfmInfo)
for(idx=0;idx<16;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->intKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->intKey[idx],mBuf);
}
for(idx=0;idx<16;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->upCiphKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->upCiphKey[idx],mBuf);
}
for(idx=0;idx<16;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->cpCiphKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->cpCiphKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
* **********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfCfmInfo
+S16 cmUnpkCtfKdfCfmInfo
(
CtfKdfCfmInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfKdfCfmInfo(param, mBuf)
+S16 cmUnpkCtfKdfCfmInfo(param, mBuf)
CtfKdfCfmInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfKdfCfmInfo)
- CMCHKUNPK(SUnpkU8, ¶m->keyDerType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->keyDerType, mBuf);
switch (param->keyDerType)
{
case CTF_KDF_TYPE1:
CMCHKUNPK(cmUnpkCtfNhKeyCfmInfo, ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfKdfCfm
+S16 cmUnpkCtfKdfCfm
(
CtfKdfCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
+S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
CtfKdfCfm func;
Pst *pst;
Buffer *mBuf;
{
SuId suId = 0;
CtfCfgTransId transId;
- U8 status;
+ uint8_t status;
CtfKdfCfmInfo kdfCfmInfo;
- TRC3(cmUnpkCtfKdfCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfKdfCfmInfo(&kdfCfmInfo, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF032, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId,&kdfCfmInfo, status));
+ return ((*func)(pst, suId, transId,&kdfCfmInfo, status));
}
#endif
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgCfm
+S16 cmUnpkCtfCfgCfm
(
CtfCfgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
+S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
CtfCfgCfm func;
Pst *pst;
Buffer *mBuf;
{
SuId suId = 0;
CtfCfgTransId transId;
- U8 status;
+ uint8_t status;
- TRC3(cmUnpkCtfCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF032, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, status));
+ return ((*func)(pst, suId, transId, status));
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfEnbStopInd
+S16 cmUnpkCtfEnbStopInd
(
CtfEnbStopInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfEnbStopInd(func, pst, mBuf)
+S16 cmUnpkCtfEnbStopInd(func, pst, mBuf)
CtfEnbStopInd func;
Pst *pst;
Buffer *mBuf;
SuId suId = 0;
CtfCfgTransId transId;
- TRC3(cmUnpkCtfCfgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId));
+ return ((*func)(pst, suId, transId));
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeIdChgReq
+S16 cmPkCtfUeIdChgReq
(
Pst* pst,
SpId spId,
CtfUeInfo * newUeInfo
)
#else
-PUBLIC S16 cmPkCtfUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
+S16 cmPkCtfUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst* pst;
SpId spId;
CtfCfgTransId transId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfUeIdChgReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfUeInfo(newUeInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
- if (cmPkPtr((PTR)newUeInfo, mBuf) != ROK) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduPackPointer((PTR)newUeInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfUeInfo(ueInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
- if (cmPkPtr((PTR)ueInfo, mBuf) != ROK) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduPackPointer((PTR)ueInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF040, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF041, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTCTFUEIDCHGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeIdChgReq
+S16 cmUnpkCtfUeIdChgReq
(
CtfUeIdChgReq func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeIdChgReq(func, pst, mBuf)
+S16 cmUnpkCtfUeIdChgReq(func, pst, mBuf)
CtfUeIdChgReq func;
Pst *pst;
Buffer *mBuf;
CtfUeInfo *ueInfo = NULLP;
CtfUeInfo *newUeInfo = NULLP;
- TRC3(cmUnpkCtfUeIdChgReq)
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)& __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF042, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF043, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF044, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&ueInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&ueInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfUeInfo(ueInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF045, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo, sizeof(CtfUeInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&newUeInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&newUeInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfUeInfo(newUeInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF047, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
+ return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
}
\f
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
* @param[in] CtfUeInfo * ueInfo
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeIdChgCfm
+S16 cmPkCtfUeIdChgCfm
(
Pst* pst,
SuId suId,
CmStatus status
)
#else
-PUBLIC S16 cmPkCtfUeIdChgCfm(pst, suId, transId, ueInfo, status)
+S16 cmPkCtfUeIdChgCfm(pst, suId, transId, ueInfo, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfUeIdChgCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF048, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCmStatus(&status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfUeInfo(ueInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
- if (cmPkPtr((PTR)ueInfo, mBuf) != ROK) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduPackPointer((PTR)ueInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF054, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTCTFUEIDCHGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
* @param[in] CtfUeInfo * ueInfo
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeIdChgCfm
+S16 cmUnpkCtfUeIdChgCfm
(
CtfUeIdChgCfm func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeIdChgCfm(func, pst, mBuf)
+S16 cmUnpkCtfUeIdChgCfm(func, pst, mBuf)
CtfUeIdChgCfm func;
Pst *pst;
Buffer *mBuf;
CtfUeInfo *ueInfo = NULLP;
CmStatus status;
- TRC3(cmUnpkCtfUeIdChgCfm)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF055, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF056, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(ErrVal)ECTF057, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&ueInfo, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&ueInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfUeInfo(ueInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF058, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCmStatus(&status, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF059, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+ return ((*func)(pst, suId, transId, ueInfo, status));
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgTransId
+S16 cmPkCtfCfgTransId
(
CtfCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCfgTransId(param, mBuf)
+S16 cmPkCtfCfgTransId(param, mBuf)
CtfCfgTransId *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmPkCtfCfgTransId)
for (i=CTF_CFG_TRANSID_SIZE-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->trans[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgTransId
+S16 cmUnpkCtfCfgTransId
(
CtfCfgTransId *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgTransId(param, mBuf)
+S16 cmUnpkCtfCfgTransId(param, mBuf)
CtfCfgTransId *param;
Buffer *mBuf;
#endif
{
S32 i;
- TRC3(cmUnpkCtfCfgTransId)
for (i=0; i<CTF_CFG_TRANSID_SIZE; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->trans[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeInfo
+S16 cmPkCtfUeInfo
(
CtfUeInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfUeInfo(param, mBuf)
+S16 cmPkCtfUeInfo(param, mBuf)
CtfUeInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfUeInfo)
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeInfo
+S16 cmUnpkCtfUeInfo
(
CtfUeInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeInfo(param, mBuf)
+S16 cmUnpkCtfUeInfo(param, mBuf)
CtfUeInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfUeInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfBwCfgInfo
+S16 cmPkCtfBwCfgInfo
(
CtfBwCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfBwCfgInfo(param, mBuf)
+S16 cmPkCtfBwCfgInfo(param, mBuf)
CtfBwCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfBwCfgInfo)
- CMCHKPK(SPkU8, param->eUtraBand, mBuf);
- CMCHKPK(SPkU32, param->ulBw, mBuf);
- CMCHKPK(SPkU32, param->dlBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->eUtraBand, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ulBw, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dlBw, mBuf);
/* ctf_c_001.main_4: Removed packing of param->pres */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfBwCfgInfo
+S16 cmUnpkCtfBwCfgInfo
(
CtfBwCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfBwCfgInfo(param, mBuf)
+S16 cmUnpkCtfBwCfgInfo(param, mBuf)
CtfBwCfgInfo *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
- TRC3(cmUnpkCtfBwCfgInfo)
+ uint32_t tmpEnum;
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->dlBw = (CtfBandwidth)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ulBw = (CtfBandwidth)tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->eUtraBand, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->eUtraBand, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfTxSchemeCfg
+S16 cmPkCtfTxSchemeCfg
(
CtfTxSchemeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfTxSchemeCfg(param, mBuf)
+S16 cmPkCtfTxSchemeCfg(param, mBuf)
CtfTxSchemeCfg *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfTxSchemeCfg)
- CMCHKPK(SPkU32, param->cycPfx, mBuf);
- CMCHKPK(SPkU32, param->scSpacing, mBuf);
- CMCHKPK(SPkU32, param->duplexMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->cycPfx, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->scSpacing, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->duplexMode, mBuf);
/* ctf_c_001.main_4: Removed packing of param->pres */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfTxSchemeCfg
+S16 cmUnpkCtfTxSchemeCfg
(
CtfTxSchemeCfg *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfTxSchemeCfg(param, mBuf)
+S16 cmUnpkCtfTxSchemeCfg(param, mBuf)
CtfTxSchemeCfg *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkCtfTxSchemeCfg)
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->duplexMode = (CtfDuplexMode)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->scSpacing = (CtfSCSpacing)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->cycPfx = (CtfCPCfg)tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfAntennaCfgInfo
+S16 cmPkCtfAntennaCfgInfo
(
CtfAntennaCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfAntennaCfgInfo(param, mBuf)
+S16 cmPkCtfAntennaCfgInfo(param, mBuf)
CtfAntennaCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfAntennaCfgInfo)
- CMCHKPK(SPkU32, param->antPortsCnt, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->antPortsCnt, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfAntennaCfgInfo
+S16 cmUnpkCtfAntennaCfgInfo
(
CtfAntennaCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfAntennaCfgInfo(param, mBuf)
+S16 cmUnpkCtfAntennaCfgInfo(param, mBuf)
CtfAntennaCfgInfo *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkCtfAntennaCfgInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->antPortsCnt = (CtfAntennaPortsCount)tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPrachCfgInfo
+S16 cmPkCtfPrachCfgInfo
(
CtfPrachCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPrachCfgInfo(param, mBuf)
+S16 cmPkCtfPrachCfgInfo(param, mBuf)
CtfPrachCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPrachCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->prachFreqOffset, mBuf);
- CMCHKPK(SPkU8, param->highSpeedFlag, mBuf);
- CMCHKPK(SPkU8, param->zeroCorrelationZoneCfg, mBuf);
- CMCHKPK(SPkU8, param->prachCfgIndex, mBuf);
- CMCHKPK(SPkU16, param->rootSequenceIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachFreqOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->highSpeedFlag, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->zeroCorrelationZoneCfg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachCfgIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rootSequenceIndex, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPrachCfgInfo
+S16 cmUnpkCtfPrachCfgInfo
(
CtfPrachCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPrachCfgInfo(param, mBuf)
+S16 cmUnpkCtfPrachCfgInfo(param, mBuf)
CtfPrachCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfPrachCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU16, ¶m->rootSequenceIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachCfgIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->zeroCorrelationZoneCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->highSpeedFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachFreqOffset, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rootSequenceIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachCfgIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->zeroCorrelationZoneCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->highSpeedFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachFreqOffset, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPdschCfgInfo
+S16 cmPkCtfPdschCfgInfo
(
CtfPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPdschCfgInfo(param, mBuf)
+S16 cmPkCtfPdschCfgInfo(param, mBuf)
CtfPdschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPdschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->p_b, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->p_b, mBuf);
CMCHKPK(SPkS16, param->refSigPwr, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPdschCfgInfo
+S16 cmUnpkCtfPdschCfgInfo
(
CtfPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPdschCfgInfo(param, mBuf)
+S16 cmUnpkCtfPdschCfgInfo(param, mBuf)
CtfPdschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfPdschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
CMCHKUNPK(SUnpkS16, ¶m->refSigPwr, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->p_b, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->p_b, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPuschCfgBasic
+S16 cmPkCtfPuschCfgBasic
(
CtfPuschCfgBasic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPuschCfgBasic(param, mBuf)
+S16 cmPkCtfPuschCfgBasic(param, mBuf)
CtfPuschCfgBasic *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPuschCfgBasic)
- CMCHKPK(SPkU8, param->enable64QAM, mBuf);
- CMCHKPK(SPkU8, param->hoppingOffset, mBuf);
- CMCHKPK(SPkU32, param->hoppingMode, mBuf);
- CMCHKPK(SPkU8, param->noOfsubBands, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->enable64QAM, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingOffset, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hoppingMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->noOfsubBands, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPuschCfgBasic
+S16 cmUnpkCtfPuschCfgBasic
(
CtfPuschCfgBasic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPuschCfgBasic(param, mBuf)
+S16 cmUnpkCtfPuschCfgBasic(param, mBuf)
CtfPuschCfgBasic *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkCtfPuschCfgBasic)
- CMCHKUNPK(SUnpkU8, ¶m->noOfsubBands, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->noOfsubBands, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->hoppingMode = (CtfPuschHoppingMode)tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->hoppingOffset, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->enable64QAM, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingOffset, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->enable64QAM, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPuschUlRS
+S16 cmPkCtfPuschUlRS
(
CtfPuschUlRS *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPuschUlRS(param, mBuf)
+S16 cmPkCtfPuschUlRS(param, mBuf)
CtfPuschUlRS *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPuschUlRS)
- CMCHKPK(SPkU8, param->cycShift, mBuf);
- CMCHKPK(SPkU8, param->grpNum, mBuf);
- CMCHKPK(SPkU8, param->seqHopEnabled, mBuf);
- CMCHKPK(SPkU8, param->grpHopEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cycShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->seqHopEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpHopEnabled, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPuschUlRS
+S16 cmUnpkCtfPuschUlRS
(
CtfPuschUlRS *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPuschUlRS(param, mBuf)
+S16 cmUnpkCtfPuschUlRS(param, mBuf)
CtfPuschUlRS *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfPuschUlRS)
- CMCHKUNPK(SUnpkU8, ¶m->grpHopEnabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->seqHopEnabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->grpNum, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cycShift, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpHopEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->seqHopEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpNum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cycShift, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPuschCfgInfo
+S16 cmPkCtfPuschCfgInfo
(
CtfPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPuschCfgInfo(param, mBuf)
+S16 cmPkCtfPuschCfgInfo(param, mBuf)
CtfPuschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPuschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
CMCHKPK(cmPkCtfPuschUlRS, ¶m->puschUlRS, mBuf);
CMCHKPK(cmPkCtfPuschCfgBasic, ¶m->puschBasicCfg, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPuschCfgInfo
+S16 cmUnpkCtfPuschCfgInfo
(
CtfPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPuschCfgInfo(param, mBuf)
+S16 cmUnpkCtfPuschCfgInfo(param, mBuf)
CtfPuschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfPuschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
CMCHKUNPK(cmUnpkCtfPuschCfgBasic, ¶m->puschBasicCfg, mBuf);
CMCHKUNPK(cmUnpkCtfPuschUlRS, ¶m->puschUlRS, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPhichCfgInfo
+S16 cmPkCtfPhichCfgInfo
(
CtfPhichCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPhichCfgInfo(param, mBuf)
+S16 cmPkCtfPhichCfgInfo(param, mBuf)
CtfPhichCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPhichCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU32, param->resource, mBuf);
- CMCHKPK(SPkU32, param->duration, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->resource, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->duration, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPhichCfgInfo
+S16 cmUnpkCtfPhichCfgInfo
(
CtfPhichCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPhichCfgInfo(param, mBuf)
+S16 cmUnpkCtfPhichCfgInfo(param, mBuf)
CtfPhichCfgInfo *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkCtfPhichCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->duration = (CtfPhichDuration)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->resource = (CtfPhichResource)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPucchCfgInfo
+S16 cmPkCtfPucchCfgInfo
(
CtfPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPucchCfgInfo(param, mBuf)
+S16 cmPkCtfPucchCfgInfo(param, mBuf)
CtfPucchCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfPucchCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU32, param->deltaShift, mBuf);
- CMCHKPK(SPkU16, param->n1PUCCH, mBuf);
- CMCHKPK(SPkU8, param->nCS, mBuf);
- CMCHKPK(SPkU8, param->nRB, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->deltaShift, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->n1PUCCH, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nCS, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nRB, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPucchCfgInfo
+S16 cmUnpkCtfPucchCfgInfo
(
CtfPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPucchCfgInfo(param, mBuf)
+S16 cmUnpkCtfPucchCfgInfo(param, mBuf)
CtfPucchCfgInfo *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkCtfPucchCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->nRB, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nCS, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->n1PUCCH, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nRB, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nCS, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->n1PUCCH, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->deltaShift = (CtfPucchDeltaShift)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfSrsUlCfgInfo
+S16 cmPkCtfSrsUlCfgInfo
(
CtfSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfSrsUlCfgInfo(param, mBuf)
+S16 cmPkCtfSrsUlCfgInfo(param, mBuf)
CtfSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfSrsUlCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->srsSetup.srsMaxUpPts, mBuf);
- CMCHKPK(SPkU8, param->srsSetup.srsANSimultTx, mBuf);
- CMCHKPK(SPkU8, param->srsSetup.sfCfg, mBuf);
- CMCHKPK(SPkU8, param->srsSetup.srsBw, mBuf);
- CMCHKPK(SPkU8, param->srsCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.srsMaxUpPts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.srsANSimultTx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.sfCfg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.srsBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfSrsUlCfgInfo
+S16 cmUnpkCtfSrsUlCfgInfo
(
CtfSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfSrsUlCfgInfo(param, mBuf)
+S16 cmUnpkCtfSrsUlCfgInfo(param, mBuf)
CtfSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfSrsUlCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->srsCfgType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.srsBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.sfCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.srsANSimultTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.srsMaxUpPts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.sfCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.srsANSimultTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.srsMaxUpPts, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfTddSfCfgInfo
+S16 cmPkCtfTddSfCfgInfo
(
CtfTddSfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfTddSfCfgInfo(param, mBuf)
+S16 cmPkCtfTddSfCfgInfo(param, mBuf)
CtfTddSfCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfTddSfCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->spclSfPatterns, mBuf);
- CMCHKPK(SPkU8, param->sfAssignment, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->spclSfPatterns, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sfAssignment, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
/* ctf_c_001.main_4: Added support for vendor specific parameters */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfVendorSpecParams
+S16 cmPkCtfVendorSpecParams
(
CtfVendorSpecific *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfVendorSpecParams(param, mBuf)
+S16 cmPkCtfVendorSpecParams(param, mBuf)
CtfVendorSpecific *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfVendorSpecParams)
if( param->buffLen != 0) {
SAddPreMsgMultInOrder(param->paramBuffer,param->buffLen,mBuf);
}
- CMCHKPK(SPkU16,param->buffLen,mBuf);
+ CMCHKPK(oduUnpackUInt16,param->buffLen,mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfVendorSpecParams
+S16 cmUnpkCtfVendorSpecParams
(
Pst *pst,
CtfVendorSpecific *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfVendorSpecParams(pst, param, mBuf)
+S16 cmUnpkCtfVendorSpecParams(pst, param, mBuf)
Pst *pst;
CtfVendorSpecific *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfVendorSpecParams)
- CMCHKUNPK(SUnpkU16, ¶m->buffLen, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->buffLen, mBuf);
if(param->buffLen != 0) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)¶m->paramBuffer, param->buffLen)) != ROK) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF060, (ErrVal)0, (Txt*)&"Unpacking failed");
#endif
- RETVALUE(RFAILED) ;
+ return RFAILED ;
}
SRemPreMsgMult(param->paramBuffer, param->buffLen,mBuf) ;
}
param->paramBuffer = NULLP ;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfTddSfCfgInfo
+S16 cmUnpkCtfTddSfCfgInfo
(
CtfTddSfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfTddSfCfgInfo(param, mBuf)
+S16 cmUnpkCtfTddSfCfgInfo(param, mBuf)
CtfTddSfCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfTddSfCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->sfAssignment, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->spclSfPatterns, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sfAssignment, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->spclSfPatterns, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmPkCtfUnLicnsdCellParam)
CMCHKPK(SPkS32, param->txPowerLimit, mBuf);
- CMCHKPK(SPkU8, param->coExistMethod, mBuf);
- CMCHKPK(SPkU8, param->lteOnPeriod, mBuf);
- CMCHKPK(SPkU8, param->ccaMethod, mBuf);
- CMCHKPK(SPkU8, param->adaptiveTx, mBuf);
- CMCHKPK(SPkU16, param->transPeriod, mBuf);
- CMCHKPK(SPkU16, param->listenPrd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->coExistMethod, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lteOnPeriod, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ccaMethod, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->adaptiveTx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->transPeriod, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->listenPrd, mBuf);
CMCHKPK(SPkS16, param->energyTh, mBuf);
- CMCHKPK(SPkU16, param->scanTimePrd, mBuf);
- CMCHKPK(SPkU16, param->activityTh, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->scanTimePrd, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->activityTh, mBuf);
for(idx = 0; idx < param->numFreq; idx++)
{
- CMCHKPK(SPkU32, param->earfcn[idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->earfcn[idx], mBuf);
}
- CMCHKPK(SPkU8, param->numFreq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numFreq, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellCfgInfo
+S16 cmPkCtfCellCfgInfo
(
CtfCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellCfgInfo(param, mBuf)
+S16 cmPkCtfCellCfgInfo(param, mBuf)
CtfCellCfgInfo *param;
Buffer *mBuf;
#endif
#ifdef EMTC_ENABLE
S32 i;
#endif
- TRC3(cmPkCtfCellCfgInfo)
#ifdef EMTC_ENABLE
for (i = CTF_MAX_CE_LEVEL-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
- CMCHKPK(SPkU8, param->ceLevelInfo[i].lastPreamble, mBuf);
- CMCHKPK(SPkU8, param->ceLevelInfo[i].firstPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].lastPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].firstPreamble, mBuf);
}
- CMCHKPK(SPkU8, param->mPdcchStart, mBuf);
- CMCHKPK(SPkU8, param->catMenabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mPdcchStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->catMenabled, mBuf);
#endif
if(param->unLicnsdCfgPres)
{
printf("pverma param->unLicnsdCfgPres cm/ctf -->%d\n",param->unLicnsdCfgPres);
CMCHKPK(cmPkCtfUnLicnsdCellParam, ¶m->lteUCfg, mBuf);
}
- CMCHKPK(SPkU8, param->unLicnsdCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->unLicnsdCfgPres, mBuf);
/*Added for rgu dynamic delta*/
- CMCHKPK(SPkU8, param->numDlUePerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numDlUePerTti, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
- CMCHKPK(SPkU16, param->ulEarfcn, mBuf);
- CMCHKPK(SPkU16, param->dlEarfcn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ulEarfcn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dlEarfcn, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
/* Packing PHY configuration parameters */
- CMCHKPK(SPkU32, param->period, mBuf);
- CMCHKPK(SPkU32, param->counter, mBuf);
- CMCHKPK(SPkU16, param->opMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->period, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->counter, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->opMode, mBuf);
/* ctf_c_001.main_3: Added the pack for newly added fileds inside the CFG structure*/
- CMCHKPK(SPkU8, param->rachSrRepModePres, mBuf);
- CMCHKPK(SPkU16, param->rachSrRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rachSrRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rachSrRepMode, mBuf);
- CMCHKPK(SPkU8, param->dataRepModePres, mBuf);
- CMCHKPK(SPkU16, param->dataRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dataRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dataRepMode, mBuf);
- CMCHKPK(SPkU8, param->phySyncModePres, mBuf);
- CMCHKPK(SPkU16, param->phySyncMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phySyncModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->phySyncMode, mBuf);
- CMCHKPK(SPkU8, param->rxAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->rxAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rxAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rxAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->txAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->txAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->pucchProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->pucchProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->puschProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->puschProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->puschProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->srsDopEstFactorPres, mBuf);
- CMCHKPK(SPkU16, param->srsDopEstFactor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsDopEstFactorPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srsDopEstFactor, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio0Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio0Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio0, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio4Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio4, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio4Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio4, mBuf);
- CMCHKPK(SPkU8, param->pucchNoiseGammaPres, mBuf);
- CMCHKPK(SPkU16, param->pucchNoiseGamma, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchNoiseGammaPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchNoiseGamma, mBuf);
- CMCHKPK(SPkU8, param->extWinMarginPres, mBuf);
- CMCHKPK(SPkU16, param->extWinMargin, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->extWinMarginPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->extWinMargin, mBuf);
- CMCHKPK(SPkU8, param->dciPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->dciPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dciPowOs, mBuf);
- CMCHKPK(SPkU8, param->cfiPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->cfiPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfiPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cfiPowOs, mBuf);
- CMCHKPK(SPkU8, param->syncSigPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->syncSigPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->syncSigPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->syncSigPowOs, mBuf);
CMCHKPK(cmPkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
CMCHKPK(cmPkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKPK(cmPkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKPK(cmPkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKPK(cmPkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
- CMCHKPK(SPkU8, param->physCellId, mBuf);
- CMCHKPK(SPkU8, param->physCellIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellIdPres, mBuf);
CMCHKPK(SPkS16, param->macSapId, mBuf);
CMCHKPK(SPkS16, param->schSapId, mBuf);
- CMCHKPK(SPkU8, param->cellIdGrpId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellIdGrpId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC3(cmPkCtfUnLicnsdCellParam)
- CMCHKUNPK(SUnpkU8, ¶m->numFreq, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numFreq, mBuf);
for(idx = 0; idx < param->numFreq; idx++)
{
- CMCHKUNPK(SUnpkU32, ¶m->earfcn[idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->earfcn[idx], mBuf);
}
- CMCHKUNPK(SUnpkU16, ¶m->activityTh, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->scanTimePrd, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->activityTh, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->scanTimePrd, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->energyTh, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->listenPrd, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->transPeriod, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->adaptiveTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ccaMethod, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->lteOnPeriod, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->coExistMethod, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->listenPrd, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->transPeriod, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->adaptiveTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ccaMethod, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lteOnPeriod, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->coExistMethod, mBuf);
CMCHKUNPK(SUnpkS32, ¶m->txPowerLimit, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellCfgInfo
+S16 cmUnpkCtfCellCfgInfo
(
CtfCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellCfgInfo(param, mBuf)
+S16 cmUnpkCtfCellCfgInfo(param, mBuf)
CtfCellCfgInfo *param;
Buffer *mBuf;
#endif
#ifdef EMTC_ENABLE
S32 i;
#endif
- TRC3(cmUnpkCtfCellCfgInfo)
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cellIdGrpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdGrpId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->schSapId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->macSapId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellIdPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellIdPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellId, mBuf);
CMCHKUNPK(cmUnpkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKUNPK(cmUnpkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKUNPK(cmUnpkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->syncSigPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->syncSigPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->syncSigPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->syncSigPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cfiPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cfiPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cfiPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfiPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dciPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dciPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->extWinMargin, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->extWinMarginPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->extWinMargin, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->extWinMarginPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchNoiseGamma, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchNoiseGammaPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchNoiseGamma, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchNoiseGammaPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio4, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio4Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio4, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio4Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio0, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio0Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio0Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->srsDopEstFactor, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsDopEstFactorPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsDopEstFactor, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsDopEstFactorPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->puschProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->puschProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->puschProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->txAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rxAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rxAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rxAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rxAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->phySyncMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phySyncModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->phySyncMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phySyncModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dataRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dataRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dataRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dataRepModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rachSrRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rachSrRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rachSrRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rachSrRepModePres, mBuf);
/* UnPacking PHY configuration parameters */
- CMCHKUNPK(SUnpkU16, ¶m->opMode, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->counter, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->period, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->opMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->counter, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->period, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dlEarfcn, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->ulEarfcn, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dlEarfcn, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->ulEarfcn, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
/* Added for rgu dynamic delta change*/
- CMCHKUNPK(SUnpkU8, ¶m->numDlUePerTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->unLicnsdCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numDlUePerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->unLicnsdCfgPres, mBuf);
if(param->unLicnsdCfgPres)
{
CMCHKUNPK(cmUnpkCtfUnLicnsdCellParam, ¶m->lteUCfg, mBuf);
}
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8, ¶m->catMenabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mPdcchStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->catMenabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mPdcchStart, mBuf);
for (i = 0; i < CTF_MAX_CE_LEVEL; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->ceLevelInfo[i].firstPreamble, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ceLevelInfo[i].lastPreamble, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevelInfo[i].firstPreamble, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevelInfo[i].lastPreamble, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellRecfgInfo
+S16 cmPkCtfCellRecfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellRecfgInfo(param, mBuf)
+S16 cmPkCtfCellRecfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCellRecfgInfo)
#ifdef ENABLE_API_LOG
- CMCHKPK(SPkU8, param->enableAPILog, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->enableAPILog, mBuf);
#endif /* ENABLE_API_LOG */
/* ctf_c_001.main_3: Added the pack for newly added fileds inside the CFG structure*/
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
- CMCHKPK(SPkU8, param->rachSrRepModePres, mBuf);
- CMCHKPK(SPkU16, param->rachSrRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rachSrRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rachSrRepMode, mBuf);
- CMCHKPK(SPkU8, param->dataRepModePres, mBuf);
- CMCHKPK(SPkU16, param->dataRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dataRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dataRepMode, mBuf);
- CMCHKPK(SPkU8, param->phySyncModePres, mBuf);
- CMCHKPK(SPkU16, param->phySyncMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phySyncModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->phySyncMode, mBuf);
- CMCHKPK(SPkU8, param->rxAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->rxAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rxAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rxAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->txAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->txAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->pucchProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->pucchProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->puschProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->puschProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->puschProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->srsDopEstFactorPres, mBuf);
- CMCHKPK(SPkU16, param->srsDopEstFactor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsDopEstFactorPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srsDopEstFactor, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio0Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio0Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio0, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio4Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio4, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio4Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio4, mBuf);
- CMCHKPK(SPkU8, param->pucchNoiseGammaPres, mBuf);
- CMCHKPK(SPkU16, param->pucchNoiseGamma, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchNoiseGammaPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchNoiseGamma, mBuf);
- CMCHKPK(SPkU8, param->extWinMarginPres, mBuf);
- CMCHKPK(SPkU16, param->extWinMargin, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->extWinMarginPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->extWinMargin, mBuf);
- CMCHKPK(SPkU8, param->dciPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->dciPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dciPowOs, mBuf);
- CMCHKPK(SPkU8, param->cfiPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->cfiPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfiPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cfiPowOs, mBuf);
- CMCHKPK(SPkU8, param->syncSigPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->syncSigPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->syncSigPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->syncSigPowOs, mBuf);
CMCHKPK(cmPkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
CMCHKPK(cmPkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKPK(cmPkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKPK(cmPkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKPK(cmPkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
- CMCHKPK(SPkU8, param->physCellId, mBuf);
- CMCHKPK(SPkU8, param->physCellIdPres, mBuf);
- CMCHKPK(SPkU8, param->cellIdGrpId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellIdGrpId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- CMCHKPK(SPkU32, param->ctfReCfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->ctfReCfgType, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellRecfgInfo
+S16 cmUnpkCtfCellRecfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellRecfgInfo(param, mBuf)
+S16 cmUnpkCtfCellRecfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
- TRC3(cmUnpkCtfCellRecfgInfo)
+ uint32_t tmpEnum;
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ctfReCfgType = (CtfReCfgType)tmpEnum;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cellIdGrpId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellIdPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdGrpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellIdPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellId, mBuf);
CMCHKUNPK(cmUnpkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKUNPK(cmUnpkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKUNPK(cmUnpkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->syncSigPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->syncSigPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->syncSigPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->syncSigPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cfiPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cfiPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cfiPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfiPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dciPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dciPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->extWinMargin, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->extWinMarginPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->extWinMargin, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->extWinMarginPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchNoiseGamma, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchNoiseGammaPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchNoiseGamma, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchNoiseGammaPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio4, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio4Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio4, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio4Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio0, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio0Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio0Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->srsDopEstFactor, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsDopEstFactorPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsDopEstFactor, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsDopEstFactorPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->puschProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->puschProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->puschProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->txAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rxAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rxAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rxAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rxAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->phySyncMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phySyncModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->phySyncMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phySyncModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dataRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dataRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dataRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dataRepModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rachSrRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rachSrRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rachSrRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rachSrRepModePres, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
printf("param->pilotSigPwr = %d\nparam->priSigPwr = %d\n param->secSigPwr = %d\n",param->pilotSigPwr,param->priSigPwr,param->secSigPwr);
#ifdef ENABLE_API_LOG
- CMCHKUNPK(SUnpkU8, ¶m->enableAPILog, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->enableAPILog, mBuf);
#endif /* ENABLE_API_LOG */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedPdschCfgInfo
+S16 cmPkCtfDedPdschCfgInfo
(
CtfDedPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedPdschCfgInfo(param, mBuf)
+S16 cmPkCtfDedPdschCfgInfo(param, mBuf)
CtfDedPdschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedPdschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKPK(SPkU32, param->pA, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->pA, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedPdschCfgInfo
+S16 cmUnpkCtfDedPdschCfgInfo
(
CtfDedPdschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedPdschCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedPdschCfgInfo(param, mBuf)
CtfDedPdschCfgInfo *param;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
- TRC3(cmUnpkCtfDedPdschCfgInfo)
+ uint32_t tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->pA = (CtfPdschPaParam)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedPucchCfgInfo
+S16 cmPkCtfDedPucchCfgInfo
(
CtfDedPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedPucchCfgInfo(param, mBuf)
+S16 cmPkCtfDedPucchCfgInfo(param, mBuf)
CtfDedPucchCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedPucchCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
/*ctf_c_001.main_4:115549: packing tddAckNackFBMode and tddAckNackCfgPres */
if (param->tddAckNackCfgPres != FALSE)
{
- CMCHKPK(SPkU32, param->tddAckNackFBMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tddAckNackFBMode, mBuf);
}
- CMCHKPK(SPkU8, param->tddAckNackCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tddAckNackCfgPres, mBuf);
#endif /* CTF_VER3 */
- CMCHKPK(SPkU16, param->pucchSetup.n1PUCCHRep, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchSetup.n1PUCCHRep, mBuf);
#ifdef CTF_VER3
/*ctf_c_001.main_4:115549: packing pucchSetup.repFactPres */
if (param->pucchSetup.repFactPres)
{
- CMCHKPK(SPkU32, param->pucchSetup.repFact, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pucchSetup.repFact, mBuf);
}
- CMCHKPK(SPkU8, param->pucchSetup.repFactPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchSetup.repFactPres, mBuf);
#else
- CMCHKPK(SPkU32, param->pucchSetup.repFact, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pucchSetup.repFact, mBuf);
#endif /* CTF_VER3 */
- CMCHKPK(SPkU8, param->dedPucchCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedPucchCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedPucchCfgInfo
+S16 cmUnpkCtfDedPucchCfgInfo
(
CtfDedPucchCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedPucchCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedPucchCfgInfo(param, mBuf)
CtfDedPucchCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedPucchCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->dedPucchCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedPucchCfgType, mBuf);
#ifdef CTF_VER3
/* ctf_c_001.main_4:115549: unpacking pucchSetup.repFactPres */
- CMCHKUNPK(SUnpkU8, ¶m->pucchSetup.repFactPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchSetup.repFactPres, mBuf);
if (param->pucchSetup.repFactPres)
{
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->pucchSetup.repFact, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->pucchSetup.repFact, mBuf);
}
#else
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->pucchSetup.repFact, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->pucchSetup.repFact, mBuf);
#endif /*CTF_VER3 */
- CMCHKUNPK(SUnpkU16, ¶m->pucchSetup.n1PUCCHRep, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchSetup.n1PUCCHRep, mBuf);
#ifdef CTF_VER3
/*ctf_c_001.main_4:115549: unpacking tddAckNackCfgPres and tddAckNackFBMode */
- CMCHKUNPK(SUnpkU8, ¶m->tddAckNackCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tddAckNackCfgPres, mBuf);
if (param->tddAckNackCfgPres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->tddAckNackFBMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tddAckNackFBMode, mBuf);
}
#endif /* CTF_VER3 */
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedPuschCfgInfo
+S16 cmPkCtfDedPuschCfgInfo
(
CtfDedPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedPuschCfgInfo(param, mBuf)
+S16 cmPkCtfDedPuschCfgInfo(param, mBuf)
CtfDedPuschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedPuschCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->betaOffsetCqiIdx, mBuf);
- CMCHKPK(SPkU8, param->betaOffsetRiIdx, mBuf);
- CMCHKPK(SPkU8, param->betaOffsetAckIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->betaOffsetCqiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->betaOffsetRiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->betaOffsetAckIdx, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedPuschCfgInfo
+S16 cmUnpkCtfDedPuschCfgInfo
(
CtfDedPuschCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedPuschCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedPuschCfgInfo(param, mBuf)
CtfDedPuschCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedPuschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->betaOffsetAckIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->betaOffsetRiIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->betaOffsetCqiIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->betaOffsetAckIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->betaOffsetRiIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->betaOffsetCqiIdx, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCqiRptModePeriodic
+S16 cmPkCtfCqiRptModePeriodic
(
CtfCqiRptModePeriodic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCqiRptModePeriodic(param, mBuf)
+S16 cmPkCtfCqiRptModePeriodic(param, mBuf)
CtfCqiRptModePeriodic *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCqiRptModePeriodic)
/* ctf_c_001.main_2: added packning for cqiMask*/
#ifdef CTF_VER1
- CMCHKPK(SPkU32, (U32 )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.cqiMask.pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.cqiMask.pres, mBuf);
#endif /* CTF_VER1 */
- CMCHKPK(SPkU8, param->cqiSetup.simultaneousAckNack, mBuf);
- CMCHKPK(SPkU16, param->cqiSetup.riCfgIndx, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.riCfgPres, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.subbandCqi.k, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.formatIndicator, mBuf);
- CMCHKPK(SPkU16, param->cqiSetup.cqiPmiCfgIndx, mBuf);
- CMCHKPK(SPkU16, param->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
- CMCHKPK(SPkU8, param->cqiPeriodicCfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.simultaneousAckNack, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiSetup.riCfgIndx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.riCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.subbandCqi.k, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.formatIndicator, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiSetup.cqiPmiCfgIndx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPeriodicCfgType, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCqiRptModePeriodic
+S16 cmUnpkCtfCqiRptModePeriodic
(
CtfCqiRptModePeriodic *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCqiRptModePeriodic(param, mBuf)
+S16 cmUnpkCtfCqiRptModePeriodic(param, mBuf)
CtfCqiRptModePeriodic *param;
Buffer *mBuf;
#endif
{
#ifdef CTF_VER1
- U32 tmpEnum;
+ uint32_t tmpEnum;
#endif
- TRC3(cmUnpkCtfCqiRptModePeriodic)
-
- CMCHKUNPK(SUnpkU8, ¶m->cqiPeriodicCfgType, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiSetup.cqiPmiCfgIndx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.formatIndicator, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.subbandCqi.k, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.riCfgPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiSetup.riCfgIndx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.simultaneousAckNack, mBuf);
+
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPeriodicCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.cqiPmiCfgIndx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.formatIndicator, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.subbandCqi.k, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.riCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.riCfgIndx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.simultaneousAckNack, mBuf);
/* ctf_c_001.main_2: added Unpackning for cqiMask*/
#ifdef CTF_VER1
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.cqiMask.pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.cqiMask.pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->cqiSetup.cqiMask.cqiMaskSetup = tmpEnum;
#endif /* CTF_VER1 */
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCqiReportCfgInfo
+S16 cmPkCtfCqiReportCfgInfo
(
CtfCqiReportCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCqiReportCfgInfo(param, mBuf)
+S16 cmPkCtfCqiReportCfgInfo(param, mBuf)
CtfCqiReportCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCqiReportCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
*/
if(param->reportMode.aPeriodicRpt.pres != FALSE)
{
- CMCHKPK(SPkU32, param->reportMode.aPeriodicRpt.aPeriodicRptMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->reportMode.aPeriodicRpt.aPeriodicRptMode, mBuf);
}
- CMCHKPK(SPkU8, param->reportMode.aPeriodicRpt.pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportMode.aPeriodicRpt.pres, mBuf);
if(param->reportMode.periodicRpt.pres != FALSE)
{
CMCHKPK(cmPkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
}
- CMCHKPK(SPkU8, param->reportMode.periodicRpt.pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportMode.periodicRpt.pres, mBuf);
#else /* CTF_VER2 */
CMCHKPK(cmPkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
break;
case CTF_CQI_RPTMODE_APRDIOC:
- CMCHKPK(SPkU32, param->reportMode.aPeriodicRpt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->reportMode.aPeriodicRpt, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->reportingMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportingMode, mBuf);
#endif /* CTF_VER2 */
/* ctf_c_001.main_2: added packning for pmiRiRpt*/
#ifdef CTF_VER1
- CMCHKPK(SPkU32, param->pmiRiRpt.pmiRiRptSetup, mBuf);
- CMCHKPK(SPkU8, param->pmiRiRpt.pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pmiRiRpt.pmiRiRptSetup, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmiRiRpt.pres, mBuf);
#endif /* CTF_VER1 */
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCqiReportCfgInfo
+S16 cmUnpkCtfCqiReportCfgInfo
(
CtfCqiReportCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCqiReportCfgInfo(param, mBuf)
+S16 cmUnpkCtfCqiReportCfgInfo(param, mBuf)
CtfCqiReportCfgInfo *param;
Buffer *mBuf;
#endif
{
#if defined (CTF_VER1) || defined (CTF_VER2)
- U32 tmpEnum;
+ uint32_t tmpEnum;
#endif
- TRC3(cmUnpkCtfCqiReportCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
/* ctf_c_001.main_2: added Unpackning for cqiMask*/
#ifdef CTF_VER1
- CMCHKUNPK(SUnpkU8, ¶m->pmiRiRpt.pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmiRiRpt.pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->pmiRiRpt.pmiRiRptSetup = tmpEnum;
#endif /* CTF_VER1 */
*ctf_c_001.main_2: Added provision to send Periodic and aPeriodic CQI
*report configuration in the same message
*/
- CMCHKUNPK(SUnpkU8, ¶m->reportMode.periodicRpt.pres, mBuf)
+ CMCHKUNPK(oduPackUInt8, ¶m->reportMode.periodicRpt.pres, mBuf)
if(param->reportMode.periodicRpt.pres != FALSE)
{
CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->reportMode.aPeriodicRpt.pres, mBuf)
+ CMCHKUNPK(oduPackUInt8, ¶m->reportMode.aPeriodicRpt.pres, mBuf)
if(param->reportMode.aPeriodicRpt.pres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->reportMode.aPeriodicRpt.aPeriodicRptMode =
(CtfCqiRptModeAperiodic)tmpEnum;
}
#else /* CTF_VER2 */
- CMCHKUNPK(SUnpkU8, ¶m->reportingMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->reportingMode, mBuf);
switch(param->reportingMode) {
case CTF_CQI_RPTMODE_APRDIOC:
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->reportMode.aPeriodicRpt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->reportMode.aPeriodicRpt, mBuf);
break;
case CTF_CQI_RPTMODE_PRDIOC:
CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* CTF_VER2 */
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedSrsUlCfgInfo
+S16 cmPkCtfDedSrsUlCfgInfo
(
CtfDedSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedSrsUlCfgInfo(param, mBuf)
+S16 cmPkCtfDedSrsUlCfgInfo(param, mBuf)
CtfDedSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedSrsUlCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->dedSrsSetup.cyclicShift, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.txComb, mBuf);
- CMCHKPK(SPkU16, param->dedSrsSetup.srsCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.duration, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.freqDmnPos, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.srsHopngBw, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.srsBw, mBuf);
- CMCHKPK(SPkU8, param->dedSrsUlCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.cyclicShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.txComb, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dedSrsSetup.srsCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.duration, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.freqDmnPos, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.srsHopngBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.srsBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsUlCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedSrsUlCfgInfo
+S16 cmUnpkCtfDedSrsUlCfgInfo
(
CtfDedSrsUlCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedSrsUlCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedSrsUlCfgInfo(param, mBuf)
CtfDedSrsUlCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedSrsUlCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsUlCfgType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.srsBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.srsHopngBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.freqDmnPos, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.duration, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dedSrsSetup.srsCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.txComb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.cyclicShift, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsUlCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.srsHopngBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.freqDmnPos, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.duration, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dedSrsSetup.srsCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.txComb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.cyclicShift, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedSRCfgInfo
+S16 cmPkCtfDedSRCfgInfo
(
CtfDedSRCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedSRCfgInfo(param, mBuf)
+S16 cmPkCtfDedSRCfgInfo(param, mBuf)
CtfDedSRCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedSRCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->dedSrSetup.srCfgIdx, mBuf);
- CMCHKPK(SPkU16, param->dedSrSetup.srPUCCHRi, mBuf);
- CMCHKPK(SPkU8, param->dedSRCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrSetup.srCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dedSrSetup.srPUCCHRi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSRCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedSRCfgInfo
+S16 cmUnpkCtfDedSRCfgInfo
(
CtfDedSRCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedSRCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedSRCfgInfo(param, mBuf)
CtfDedSRCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedSRCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->dedSRCfgType, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dedSrSetup.srPUCCHRi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrSetup.srCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSRCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dedSrSetup.srPUCCHRi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrSetup.srCfgIdx, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* TFU_UPGRADE */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedAntCfgInfo
+S16 cmPkCtfDedAntCfgInfo
(
CtfDedAntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedAntCfgInfo(param, mBuf)
+S16 cmPkCtfDedAntCfgInfo(param, mBuf)
CtfDedAntCfgInfo *param;
Buffer *mBuf;
#endif
{
#ifdef CTF_VER2
- U8 idx;
+ uint8_t idx;
#endif /* CTF_VER2 */
- TRC3(cmPkCtfDedAntCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU32, param->ueTxAntSelection.txAntSelect, mBuf);
- CMCHKPK(SPkU8, param->ueTxAntSelection.cfgType, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ueTxAntSelection.txAntSelect, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ueTxAntSelection.cfgType, mBuf);
/* ctf_c_001.main_3 txMode is of type enum and is 32bit length */
- CMCHKPK(SPkU32, (U32)param->txMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->txMode, mBuf);
#ifdef CTF_VER2
/*
*ctf_c_001.main_2: Added Packing of CodeBookSubsetRestriction parameter
switch(param->codeBookSubsetRes.ctfCdBkRestType)
{
case N2TX_ANT_TM3:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm3, mBuf);
break;
case N4TX_ANT_TM3:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm3, mBuf);
break;
case N2TX_ANT_TM4:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm4, mBuf);
break;
case N4TX_ANT_TM4:
for(idx = 0; idx < 8; idx++)
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm4[idx], mBuf);
break;
case N2TX_ANT_TM5:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm5, mBuf);
break;
case N4TX_ANT_TM5:
- CMCHKPK(SPkU16, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt16, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm5, mBuf);
break;
case N2TX_ANT_TM6:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm6, mBuf);
break;
case N4TX_ANT_TM6:
- CMCHKPK(SPkU16, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt16, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm6, mBuf);
break;
default :
break;
}
- CMCHKPK(SPkU32, param->codeBookSubsetRes.ctfCdBkRestType, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->codeBookSubsetRes.ctfCdBkRestType, mBuf);
#endif /* CTF_VER2 */
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedAntCfgInfo
+S16 cmUnpkCtfDedAntCfgInfo
(
CtfDedAntCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedAntCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedAntCfgInfo(param, mBuf)
CtfDedAntCfgInfo *param;
Buffer *mBuf;
#endif
S16 idx;
#endif /* CTF_VER2 */
- U32 tmpEnum;
+ uint32_t tmpEnum;
- TRC3(cmUnpkCtfDedAntCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
/*
* Added Unpacking for CodeBookSubsetRestriction parameter
*/
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->codeBookSubsetRes.ctfCdBkRestType = (CtfCdBkSubsetRestnType)tmpEnum;
switch(param->codeBookSubsetRes.ctfCdBkRestType)
{
case N2TX_ANT_TM3:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm3, mBuf);
break;
case N4TX_ANT_TM3:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm3, mBuf);
break;
case N2TX_ANT_TM4:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm4, mBuf);
break;
case N4TX_ANT_TM4:
for(idx = 7; idx >= 0; idx--)
{
- CMCHKUNPK(SUnpkU8, &(param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, &(param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm4[idx]), mBuf);
}
break;
case N2TX_ANT_TM5:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm5, mBuf);
break;
case N4TX_ANT_TM5:
- CMCHKUNPK(SUnpkU16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm5, mBuf);
break;
case N2TX_ANT_TM6:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm6, mBuf);
break;
case N4TX_ANT_TM6:
- CMCHKUNPK(SUnpkU16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm6, mBuf);
break;
default :
}
#endif /* CTF_VER2 */
/* ctf_c_001.main_3 Enum is 32bit length */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->txMode = (CtfUeTxAntMode)tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->ueTxAntSelection.cfgType, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueTxAntSelection.cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ueTxAntSelection.txAntSelect = (CtfUeTxAntSelectType)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeSecCellCfgInfo
+S16 cmPkCtfUeSecCellCfgInfo
(
CtfUeSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfUeSecCellCfgInfo(*param, mBuf)
+S16 cmPkCtfUeSecCellCfgInfo(*param, mBuf)
CtfUeSecCellCfgInfo *param;
Buffer *mBuf;
#endif
{
- CMCHKPK(SPkU16, param->sCellId, mBuf);
- CMCHKPK(SPkU8, param->sCellIdx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfSecCellCfgInfo
+S16 cmPkCtfSecCellCfgInfo
(
CtfSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfSecCellCfgInfo(*param, mBuf)
+S16 cmPkCtfSecCellCfgInfo(*param, mBuf)
CtfSecCellCfgInfo *param;
Buffer *mBuf;
#endif
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[(U8)idx], mBuf);
+ CMCHKPK(cmPkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[(uint8_t)idx], mBuf);
}
- CMCHKPK(SPkU32, param->sCellAction, mBuf);
- CMCHKPK(SPkU8, param->numSCells, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sCellAction, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeSecCellCfgInfo
+S16 cmUnpkCtfUeSecCellCfgInfo
(
CtfUeSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeSecCellCfgInfo(*param, mBuf)
+S16 cmUnpkCtfUeSecCellCfgInfo(*param, mBuf)
CtfUeSecCellCfgInfo *param;
Buffer *mBuf;
#endif
{
- CMCHKUNPK(SUnpkU8, ¶m->sCellIdx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfSecCellCfgInfo
+S16 cmUnpkCtfSecCellCfgInfo
(
CtfSecCellCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfSecCellCfgInfo(*param, mBuf)
+S16 cmUnpkCtfSecCellCfgInfo(*param, mBuf)
CtfSecCellCfgInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- CMCHKUNPK(SUnpkU8, ¶m->numSCells, mBuf);
- CMCHKUNPK(SUnpkU32, (U32*)¶m->sCellAction, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->sCellAction, mBuf);
for(idx = 0 ; idx < param->numSCells; idx++)
{
CMCHKUNPK(cmUnpkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfUeCatCfgInfo
+S16 cmPkCtfUeCatCfgInfo
(
CtfUeCatCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfUeCatCfgInfo(param, mBuf)
+S16 cmPkCtfUeCatCfgInfo(param, mBuf)
CtfUeCatCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfUeCatCfgInfo)
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKPK(SPkU32, param->ueCategory, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->ueCategory, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfUeCatCfgInfo
+S16 cmUnpkCtfUeCatCfgInfo
(
CtfUeCatCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfUeCatCfgInfo(param, mBuf)
+S16 cmUnpkCtfUeCatCfgInfo(param, mBuf)
CtfUeCatCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfUeCatCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->ueCategory, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->ueCategory, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedCfgInfo
+S16 cmPkCtfDedCfgInfo
(
CtfDedCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedCfgInfo(param, mBuf)
+S16 cmPkCtfDedCfgInfo(param, mBuf)
CtfDedCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedCfgInfo)
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8, param->isEmtcUe, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isEmtcUe, mBuf);
#endif
CMCHKPK(cmPkCtfDedAntCfgInfo, ¶m->antInfo, mBuf);
#ifndef TFU_UPGRADE
CMCHKPK(cmPkCtfUeCatCfgInfo, ¶m->ueCatCfg, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedCfgInfo
+S16 cmUnpkCtfDedCfgInfo
(
CtfDedCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedCfgInfo(param, mBuf)
+S16 cmUnpkCtfDedCfgInfo(param, mBuf)
CtfDedCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedCfgInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
#endif /* TFU_UPGRADE */
CMCHKUNPK(cmUnpkCtfDedAntCfgInfo, ¶m->antInfo, mBuf);
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8, ¶m->isEmtcUe, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isEmtcUe, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedRecfgInfo
+S16 cmPkCtfDedRecfgInfo
(
CtfDedRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedRecfgInfo(param, mBuf)
+S16 cmPkCtfDedRecfgInfo(param, mBuf)
CtfDedRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedRecfgInfo)
CMCHKPK(cmPkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
/*ctf_c_001.main_1*/
#endif
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedRecfgInfo
+S16 cmUnpkCtfDedRecfgInfo
(
CtfDedRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedRecfgInfo(param, mBuf)
+S16 cmUnpkCtfDedRecfgInfo(param, mBuf)
CtfDedRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedRecfgInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(cmUnpkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellReleaseInfo
+S16 cmPkCtfCellReleaseInfo
(
CtfCellReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellReleaseInfo(param, mBuf)
+S16 cmPkCtfCellReleaseInfo(param, mBuf)
CtfCellReleaseInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCellReleaseInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellReleaseInfo
+S16 cmUnpkCtfCellReleaseInfo
(
CtfCellReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellReleaseInfo(param, mBuf)
+S16 cmUnpkCtfCellReleaseInfo(param, mBuf)
CtfCellReleaseInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCellReleaseInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfDedReleaseInfo
+S16 cmPkCtfDedReleaseInfo
(
CtfDedReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfDedReleaseInfo(param, mBuf)
+S16 cmPkCtfDedReleaseInfo(param, mBuf)
CtfDedReleaseInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfDedReleaseInfo)
CMCHKPK(cmPkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfDedReleaseInfo
+S16 cmUnpkCtfDedReleaseInfo
(
CtfDedReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfDedReleaseInfo(param, mBuf)
+S16 cmUnpkCtfDedReleaseInfo(param, mBuf)
CtfDedReleaseInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfDedReleaseInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(cmUnpkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgInfo
+S16 cmPkCtfCfgInfo
(
CtfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCfgInfo(param, mBuf)
+S16 cmPkCtfCfgInfo(param, mBuf)
CtfCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCfgInfo)
switch(param->cfgElem) {
case CTF_UE_CFG:
CMCHKPK(cmPkCtfCellCfgInfo, ¶m->u.cellCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgElem, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgElem, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgInfo
+S16 cmUnpkCtfCfgInfo
(
CtfCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgInfo(param, mBuf)
+S16 cmUnpkCtfCfgInfo(param, mBuf)
CtfCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgElem, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
case CTF_CELL_CFG:
CMCHKUNPK(cmUnpkCtfCellCfgInfo, ¶m->u.cellCfg, mBuf);
CMCHKUNPK(cmUnpkCtfDedCfgInfo, ¶m->u.dedCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfReCfgInfo
+S16 cmPkCtfReCfgInfo
(
CtfReCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfReCfgInfo(param, mBuf)
+S16 cmPkCtfReCfgInfo(param, mBuf)
CtfReCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfReCfgInfo)
switch(param->cfgElem) {
case CTF_UE_CFG:
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgElem, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgElem, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfReCfgInfo
+S16 cmUnpkCtfReCfgInfo
(
CtfReCfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfReCfgInfo(param, mBuf)
+S16 cmUnpkCtfReCfgInfo(param, mBuf)
CtfReCfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfReCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgElem, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
case CTF_CELL_CFG:
CMCHKUNPK(cmUnpkCtfCellRecfgInfo, ¶m->u.cellRecfg, mBuf);
CMCHKUNPK(cmUnpkCtfCellStop, ¶m->u.cellRecfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfReleaseInfo
+S16 cmPkCtfReleaseInfo
(
CtfReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfReleaseInfo(param, mBuf)
+S16 cmPkCtfReleaseInfo(param, mBuf)
CtfReleaseInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfReleaseInfo)
switch(param->cfgElem) {
case CTF_UE_CFG:
CMCHKPK(cmPkCtfCellReleaseInfo, ¶m->u.cellRel, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgElem, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgElem, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfReleaseInfo
+S16 cmUnpkCtfReleaseInfo
(
CtfReleaseInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfReleaseInfo(param, mBuf)
+S16 cmUnpkCtfReleaseInfo(param, mBuf)
CtfReleaseInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfReleaseInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgElem, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
case CTF_CELL_CFG:
CMCHKUNPK(cmUnpkCtfCellReleaseInfo, ¶m->u.cellRel, mBuf);
CMCHKUNPK(cmUnpkCtfDedReleaseInfo, ¶m->u.dedRel, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCfgReqInfo
+S16 cmPkCtfCfgReqInfo
(
CtfCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCfgReqInfo(param, mBuf)
+S16 cmPkCtfCfgReqInfo(param, mBuf)
CtfCfgReqInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCfgReqInfo)
/* ctf_c_001.main_4: Added support for vendor specific parameters */
#ifdef CTF_VER3
CMCHKPK(cmPkCtfCfgInfo, ¶m->u.cfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCfgReqInfo
+S16 cmUnpkCtfCfgReqInfo
(
Pst *pst,
CtfCfgReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCfgReqInfo(param, mBuf)
+S16 cmUnpkCtfCfgReqInfo(param, mBuf)
Pst *pst;
CtfCfgReqInfo *param;
Buffer *mBuf;
S16 retVal;
#endif
- TRC3(cmUnpkCtfCfgReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
case CTF_CONFIG:
CMCHKUNPK(cmUnpkCtfCfgInfo, ¶m->u.cfg, mBuf);
CMCHKUNPK(cmUnpkCtfReleaseInfo, ¶m->u.release, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef CTF_VER3
if((retVal = cmUnpkCtfVendorSpecParams(pst, ¶m->vendorParams, mBuf)) != ROK)
- RETVALUE(retVal);
+ return (retVal);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* Starts - Fix for CR ccpu00123185 */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellPwrcfgInfo
+S16 cmPkCtfCellPwrcfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellPwrcfgInfo(param, mBuf)
+S16 cmPkCtfCellPwrcfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCellPwrcfgInfo)
/* Added the pack for newly added reference signal Power*/
- CMCHKPK(SPkU32, (U32)param->ctfCellStatus, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->ctfCellStatus, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKPK(SPkS16, param->pdschCfg.refSigPwr, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellPwrcfgInfo
+S16 cmUnpkCtfCellPwrcfgInfo
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellPwrcfgInfo(param, mBuf)
+S16 cmUnpkCtfCellPwrcfgInfo(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCellPwrcfgInfo)
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->ctfCellStatus, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->ctfCellStatus, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfCellStop
+S16 cmPkCtfCellStop
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfCellStop(param, mBuf)
+S16 cmPkCtfCellStop(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkCtfCellStop)
/* Added the pack for newly added reference signal Power*/
- CMCHKPK(SPkU32, (U32)param->ctfCellStatus, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->ctfCellStatus, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKPK(SPkS16, param->pdschCfg.refSigPwr, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfCellStop
+S16 cmUnpkCtfCellStop
(
CtfCellRecfgInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfCellStop(param, mBuf)
+S16 cmUnpkCtfCellStop(param, mBuf)
CtfCellRecfgInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfCellStop)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->ctfCellStatus, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->ctfCellStatus, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* Periodic REM Scan for TPM */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkPerRemScanCellInfo
+S16 cmPkPerRemScanCellInfo
(
CtfPeriodicRemCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkPerRemScanCellInfo(param, mBuf)
+S16 cmPkPerRemScanCellInfo(param, mBuf)
CtfPeriodicRemCellInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmPkPerRemScanCellInfo)
- CMCHKPK(SPkU16,param->pci, mBuf);
- CMCHKPK(SPkU8, param->rsrp, mBuf);
- CMCHKPK(SPkU8, param->dlBw, mBuf);
- CMCHKPK(SPkU8, param->numTx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16,param->pci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rsrp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numTx, mBuf);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPeriodicCellSearchRsp
+S16 cmPkCtfPeriodicCellSearchRsp
(
CtfPeriodicRemCellSearchRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkCtfPeriodicCellSearchRsp(param, mBuf)
+S16 cmPkCtfPeriodicCellSearchRsp(param, mBuf)
CtfPeriodicRemCellSearchRsp *param;
Buffer *mBuf;
#endif
{
S16 idx;
- TRC3(cmPkCtfPeriodicCellSearchRsp)
for(idx = param->numCells - 1; idx >=0; idx--)
{
CMCHKPK(cmPkPerRemScanCellInfo, ¶m->cellInfo[idx], mBuf);
}
- CMCHKPK(SPkU8, param->numCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmPkCtfPeriodicRemCellSearchRsp
+S16 cmPkCtfPeriodicRemCellSearchRsp
(
Pst* pst,
SpId spId,
CtfPeriodicRemCellSearchRsp *CellCfgRsp
)
#else
-PUBLIC S16 cmPkCtfPeriodicRemCellSearchRsp(pst, spId, transId, CellCfgRsp)
+S16 cmPkCtfPeriodicRemCellSearchRsp(pst, spId, transId, CellCfgRsp)
Pst* pst;
SpId spId;
CtfCfgTransId *transId;
#endif
{
Buffer *mBuf = NULLP;
- TRC3(cmPkCtfPeriodicRemCellSearchRsp)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector == CTF_SEL_LC) {
+ if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfPeriodicCellSearchRsp(CellCfgRsp, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LWLC) {
+ else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)CellCfgRsp, mBuf) != ROK) {
+ if (oduPackPointer((PTR)CellCfgRsp, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
}
pst->event = (Event)EVTCTFPREMCELLSRCHRSP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPerRemScanCellInfo
+S16 cmUnpkCtfPerRemScanCellInfo
(
CtfPeriodicRemCellInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPerRemScanCellInfo(param, mBuf)
+S16 cmUnpkCtfPerRemScanCellInfo(param, mBuf)
CtfPeriodicRemCellInfo *param;
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkCtfPerRemScanCellInfo);
- CMCHKUNPK(SUnpkU8, ¶m->numTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rsrp, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pci, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->numTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rsrp, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pci, mBuf);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 cmUnpkCtfPerRemCellSrch
+S16 cmUnpkCtfPerRemCellSrch
(
CtfPeriodicRemCellSearchRsp *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkCtfPerRemCellSrch(param, mBuf)
+S16 cmUnpkCtfPerRemCellSrch(param, mBuf)
CtfPeriodicRemCellSearchRsp *param;
Buffer *mBuf;
#endif
{
S16 idx;
- TRC3(cmUnpkCtfPerRemCellSrch);
- CMCHKUNPK(SUnpkU8, ¶m->numCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCells, mBuf);
for(idx = 0; idx < (param->numCells); idx++)
{
CMCHKUNPK(cmUnpkCtfPerRemScanCellInfo, ¶m->cellInfo[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 cmUnpkPerRemCellSrchRsp
+S16 cmUnpkPerRemCellSrchRsp
(
CtfPerRemCellSrchRsp func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkPerRemCellSrchRsp(func, pst, mBuf)
+S16 cmUnpkPerRemCellSrchRsp(func, pst, mBuf)
CtfPerRemCellSrchRsp func;
Pst *pst;
Buffer *mBuf;
SuId suId = 0;
CtfCfgTransId transId;
CtfPeriodicRemCellSearchRsp *CellSrchRsp = NULLP;
- TRC3(cmUnpkPerRemCellSrchRsp)
if (SUnpkS16(&suId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (pst->selector != CTF_SEL_LWLC) {
+ if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&CellSrchRsp,
sizeof(CtfPeriodicRemCellSearchRsp))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (pst->selector == CTF_SEL_LWLC) {
- if (cmUnpkPtr((PTR *)&CellSrchRsp, mBuf) != ROK) {
+ if (pst->selector == ODU_SELECTOR_LWLC) {
+ if (oduUnpackPointer((PTR *)&CellSrchRsp, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- else if (pst->selector == CTF_SEL_LC)
+ else if (pst->selector == ODU_SELECTOR_LC)
if (cmUnpkCtfPerRemCellSrch(CellSrchRsp, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)CellSrchRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, &transId, CellSrchRsp));
+ return ((*func)(pst, suId, &transId, CellSrchRsp));
}
/* Periodic REM Scan for TPM End */
Code Review / o-du / l2.git / blobdiff