*********************************************************************21*/
\f
/* header include files (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-
-#include "gen.h" /* general */
-#include "ssi.h" /* system services */
-#include "cm5.h" /* common timer defines */
-#include "cm_tkns.h" /* common tokens defines */
-#include "cm_mblk.h" /* common memory allocation library defines */
-#include "cm_llist.h" /* common link list defines */
-#include "cm_hash.h" /* common hash list defines */
-#include "cm_lte.h" /* common LTE defines */
+#include "common_def.h"
#ifdef TENB_SPLIT_ARCH
#include "ss_queue.h"
#include "ss_task.h"
#include "kwu.h" /* KWU defines */
/* extern (.x) include files */
-#include "gen.x" /* general */
-#include "ssi.x" /* system services */
-
-#include "cm5.x" /* common timer library */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_mblk.x" /* common memory allocation */
-#include "cm_llist.x" /* common link list */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lte.x" /* common LTE includes */
-#include "cm_lib.x" /* common memory allocation library */
#ifdef TENB_SPLIT_ARCH
#include "ss_queue.x"
#include "ss_task.x"
(ErrVal)EKWU001, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, spId, mBuf, EKWU002, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU003, pst);
pst->event = (Event) KWU_EVT_BND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)EKWU004, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
- CMCHKPKLOG(SPkU8, status, mBuf, EKWU005, pst);
+ CMCHKPKLOG(oduUnpackUInt8, status, mBuf, EKWU005, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
pst->event = (Event) KWU_EVT_BND_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)EKWU007, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, reason, mBuf, EKWU008, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU009, pst);
pst->event = (Event) KWU_EVT_UBND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuUbndReq */
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatReqInfo
+uint8_t cmPkKwuDatReqInfo
(
KwuDatReqInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuDatReqInfo(param, mBuf)
+uint8_t cmPkKwuDatReqInfo(param, mBuf)
KwuDatReqInfo *param;
Buffer *mBuf;
#endif
case CM_LTE_LCH_PCCH:
CMCHKPK(cmPkLteTimingInfo, ¶m->tm.tmg, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8, param->emtcDiReason,mBuf);
- CMCHKPK(SPkU8, param->pnb,mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcDiReason,mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pnb,mBuf);
#endif
break;
case CM_LTE_LCH_DTCH:
case CM_LTE_LCH_DCCH:
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
#endif
- CMCHKPK(SPkU32, param->sduId, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkKwuDatReqInfo */
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatReq
+uint8_t cmPkKwuDatReq
(
Pst * pst,
-SpId spId,
KwuDatReqInfo* datReq,
Buffer * mBuf
)
#else
-PUBLIC S16 cmPkKwuDatReq(pst, spId, datReq, mBuf)
+uint8_t cmPkKwuDatReq(pst, datReq, mBuf)
Pst * pst;
-SpId spId;
KwuDatReqInfo* datReq;
Buffer * mBuf;
#endif
#ifndef SS_RBUF
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- if(pst->srcEnt == ENTPJ)
+ if(pst->srcEnt == ENTDUAPP)
{
/* When the Selector is LWLC, we need to allocate memory, copy
* the contents and pass the pointer of the allocated memory. The
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
- CMCHKPK(cmPkPtr,(PTR)datReqInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datReqInfo, mBuf);
}
else
{
- CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datReq, mBuf);
}
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDatReqInfo( (datReq), mBuf);
sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
#ifdef L2_L3_SPLIT
if(datReq->rlcId.rbType == CM_LTE_SRB)
{
#else
pst->event = (Event) KWU_EVT_DAT_REQ;
#endif
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
#else
if (pst->srcEnt == ENTPJ)
{
switch(pst->selector)
{
#ifdef LCKWU
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
}
break;
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datReq, mBuf);
}
break;
#endif /* LCKWU */
CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
pst->event = (Event) KWU_EVT_DAT_REQ;
ret1 = SPstTsk(pst,mBuf);
- if(pst->selector == KWU_SEL_LC)
+ if(pst->selector == ODU_SELECTOR_LC)
{
if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ret1);
+ return (ret1);
#endif
} /* cmPkKwuDatReq */
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatIndInfo
+uint8_t cmPkKwuDatIndInfo
(
KwuDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmPkKwuDatIndInfo(param, mBuf)
+uint8_t cmPkKwuDatIndInfo(param, mBuf)
KwuDatIndInfo *param;
Buffer *mBuf;
#endif
{
TRC3(cmPkKwuDatIndInfo);
- CMCHKPK(SPkU8, param->isOutOfSeq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
#ifdef CCPU_OPT
CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
#endif
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuDatInd
+uint8_t cmPkKwuDatInd
(
Pst * pst,
-SuId suId,
KwuDatIndInfo* datInd,
Buffer * mBuf
)
#else
-PUBLIC S16 cmPkKwuDatInd(pst, suId, datInd, mBuf)
+uint8_t cmPkKwuDatInd(pst, datInd, mBuf)
Pst * pst;
-SuId suId;
KwuDatIndInfo* datInd;
Buffer * mBuf;
#endif
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
/* When the Selector is LWLC, we need to allocate memory, copy
* the contents and pass the pointer of the allocated memory. The
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
- CMCHKPK(cmPkPtr,(PTR)datIndInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkKwuDatIndInfo( (datInd), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU012, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDatIndInfo( (datInd), mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPKLOG(SPkS16, suId, mBuf, EKWU013, pst);
pst->event = (Event) KWU_EVT_DAT_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDatInd */
\f
TRC3(cmPkKwuDatCfmInfo);
for(iter = 0; iter < param->numSduIds; iter++)
{
- CMCHKPK(SPkU32, param->sduIds[iter], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduIds[iter], mBuf);
}
- CMCHKPK(SPkU32, param->numSduIds, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numSduIds, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkKwuDatCfmInfo */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR)datCfm, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datCfm, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkKwuDatCfmInfo( (datCfm), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU014, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDatCfmInfo( (datCfm), mBuf);
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU015, pst);
pst->event = (Event) KWU_EVT_DAT_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDatCfm */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
/* When the Selector is LWLC, we need to allocate memory, copy
* the contents and pass the pointer of the allocated memory. The
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
- CMCHKPK(cmPkPtr,(PTR)discSduInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkKwuDiscSduInfo( (discSdu), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU016, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDiscSduInfo( (discSdu), mBuf);
CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst);
pst->event = (Event) KWU_EVT_DISC_SDU_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDiscSduReq */
\f
for (i = (param->numSdu - 1); i >= 0; i--)
{
- CMCHKPK(SPkU32, param->sduId[(U16)i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduId[(U16)i], mBuf);
}
- CMCHKPK(SPkU32, param->numSdu, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numSdu, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
{
TRC3(cmPkKwuFlowCntrlIndInfo);
- CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkKwuFlowCntrlIndInfo */
#ifdef ANSI
TRC3(cmUnpkKwuFlowCntrlIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->pktAdmitCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkKwuFlowCntrlIndInfo */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) staInd, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) staInd, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkKwuStaIndInfo( (staInd), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuStaIndInfo( (staInd), mBuf);
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
pst->event = (Event) KWU_EVT_STA_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuStaInd */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
#ifdef LCKWU
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkLteRlcId( &rlcId, mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkLteRlcId( &rlcId, mBuf);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
pst->event = (Event) KWU_EVT_REEST_CMP_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuReEstCmpInd */
/* kwu_c_001.main_3 added support for L2 Measurement */
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR)discCfmSdu, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)discCfmSdu, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
ret1 = cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, spId, mBuf, ERRKWU, pst);
pst->event = (Event) KWU_EVT_DISC_SDU_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDiscSduCfm */
\f
#ifdef ANSI
pst->pool,
(Data *)flowCntrlIndInfo,
sizeof(KwuFlowCntrlIndInfo),0);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LCKWU
switch(pst->selector)
{
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) flowCntrlIndInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) flowCntrlIndInfo, mBuf);
}
break;
}
CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
pst->event = (Event) KWU_EVT_FLOW_CNTRL_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
TRC3(cmPkKwuDatAckIndInfo);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKPK(SPkU32, param->sduId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
+ return ROK;
}
#ifdef ANSI
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret1 = cmPkKwuDatAckInfo( (datInd), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
pst->event = (Event) KWU_EVT_DAT_ACK_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDatAckInd */
#endif /* LTE_L2_MEAS */
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
TRC3(cmUnpkKwuBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
- CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EKWU023, pst);
+ CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EKWU023, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
} /* cmUnpkKwuUbndReq */
\f
TRC3(cmUnpkKwuDatReqInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
#ifdef CCPU_OPT
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
case CM_LTE_LCH_BCCH:
case CM_LTE_LCH_PCCH:
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8,¶m->pnb , mBuf);
- CMCHKUNPK(SUnpkU8,¶m->emtcDiReason , mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->pnb , mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->emtcDiReason , mBuf);
#endif
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->tm.tmg, mBuf);
case CM_LTE_LCH_DCCH:
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
S16 ret1 = ROK;
#endif
S16 retVal;
- SpId spId = 0;
KwuDatReqInfo *datReq = NULLP;
KwuDatReqInfo datReqTmp;
TRC3(cmUnpkKwuDatReq)
-
- CMCHKUNPK(SUnpkS16, &(spId), mBuf);
-
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &datReq, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &datReq, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
/* Allocate the memory statically as there is no free
* in RLC */
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU027, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmUnpkKwuDatReqInfo( (datReq), mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- retVal = (*func)(pst, spId, datReq, mBuf);
+ retVal = (*func)(pst, datReq, mBuf);
/* If LWLC is configured, we need to
* free the memory here. */
- if(pst->selector == KWU_SEL_LWLC)
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY);
}
- RETVALUE(retVal);
+ return (retVal);
} /* cmUnpkKwuDatReq */
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatIndInfo
+uint8_t cmUnpkKwuDatIndInfo
(
KwuDatIndInfo *param,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatIndInfo(param, mBuf)
+uint8_t cmUnpkKwuDatIndInfo(param, mBuf)
KwuDatIndInfo *param;
Buffer *mBuf;
#endif
#ifdef CCPU_OPT
CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->isOutOfSeq, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isOutOfSeq, mBuf);
+ return ROK;
}
\f
#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatInd
+uint8_t cmUnpkKwuDatInd
(
KwuDatInd func,
Pst *pst,
Buffer *mBuf
)
#else
-PUBLIC S16 cmUnpkKwuDatInd(func, pst, mBuf)
+uint8_t cmUnpkKwuDatInd(func, pst, mBuf)
KwuDatInd func;
Pst *pst;
Buffer *mBuf;
#endif
{
S16 ret1 = ROK, retVal;
- SuId suId = 0;
KwuDatIndInfo *datInd = NULLP;
KwuDatIndInfo datIndTmp;
TRC3(cmUnpkKwuDatInd)
- CMCHKUNPK(SUnpkS16, &(suId), mBuf);
-
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &datInd, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &datInd, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
/*SGetStaticBuffer used as RRC has an equivalent free but PDCP
* doesn't free any memory */
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
}
else
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU029, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- retVal = (*func)(pst, suId, datInd, mBuf);
+ retVal = (*func)(pst, datInd, mBuf);
/* If LWLC is configured and the destination entity is PDCP, we need to
* free the memory here. */
- if((pst->selector == KWU_SEL_LWLC) && (pst->dstEnt == ENTPJ))
+ if((pst->selector == ODU_SELECTOR_LWLC) && (pst->dstEnt == ENTPJ))
{
retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
}
- RETVALUE(retVal);
+ return (retVal);
} /* cmUnpkKwuDatInd */
\f
TRC3(cmUnpkKwuDatCfmInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numSduIds, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numSduIds, mBuf);
#ifdef L2_L3_SPLIT /*Work Around */
if (param->numSduIds >= KWU_MAX_DAT_CFM)
#endif
for(iter = param->numSduIds -1; iter >= 0 ; iter--)
{
- CMCHKUNPK(SUnpkU32, ¶m->sduIds[iter], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduIds[iter], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &datCfm, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &datCfm, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
(ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU031, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, datCfm));
+ return ((*func)(pst, suId, datCfm));
} /* cmUnpkKwuDatCfm */
\f
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
(ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU033, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
break;
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, discSdu));
+ return ((*func)(pst, spId, discSdu));
} /* cmUnpkKwuDiscSduReq */
\f
TRC3(cmUnpkKwuStaIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numSdu, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numSdu, mBuf);
for (i = 0; i < param->numSdu; i++)
{
- CMCHKUNPK(SUnpkU32, ¶m->sduId[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduId[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkKwuStaIndInfo */
\f
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *)&staInd, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *)&staInd, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
(ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, staInd));
+ return ((*func)(pst, suId, staInd));
} /* cmUnpkKwuStaInd */
\f
switch(pst->selector)
{
#ifdef LCKWU
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
#if(ERRCLASS & ERRCLS_DEBUG)
ret1 = cmUnpkLteRlcId( &rlcId, mBuf);
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmUnpkLteRlcId( &rlcId, mBuf);
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, rlcId));
+ return ((*func)(pst, suId, rlcId));
} /* cmUnpkKwuReEstCmpInd */
/* kwu_c_001.main_3 added support for L2 Measurement */
switch(pst->selector)
{
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf);
}
break;
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
(ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, discSdu));
+ return ((*func)(pst, spId, discSdu));
} /* cmUnpkKwuDiscSduCfm */
#ifdef ANSI
PUBLIC S16 cmUnpkKwuFlowCntrlInd
switch(pst->selector)
{
#ifdef LCKWU
- case KWU_SEL_LC:
+ case ODU_SELECTOR_LC:
{
if(SGetStaticBuffer(pst->region,
pst->pool,
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf);
}
break;
- case KWU_SEL_LWLC:
+ case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInfo, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInfo, mBuf);
}
break;
#endif
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, flowCntrlInfo));
+ return ((*func)(pst, suId, flowCntrlInfo));
} /* cmUnpkKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
\f
{
TRC3(cmUnpkKwuDatAckInfo);
- CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
(ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)ERRKWU, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE((*func)(pst, suId, datInd));
+ return ((*func)(pst, suId, datInd));
} /* cmUnpkKwuDatAckInd */
#endif /* LTE_L2_MEAS */
#endif /* LCKWU */
Code Review / o-du / l2.git / blobdiff