X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fcm%2Fkwu.c;h=06899000e45633af9a3e7c828a8b5ac3e1630b22;hb=27d8d877e837c2879a452538cdbe81afe48bed62;hp=d9c6408e643058c008cd54b78cb0ce3f6ca83a97;hpb=829bbd114f1c3dc00c1da47bca0a8207c049df3f;p=o-du%2Fl2.git diff --git a/src/cm/kwu.c b/src/cm/kwu.c index d9c6408e6..06899000e 100755 --- a/src/cm/kwu.c +++ b/src/cm/kwu.c @@ -30,18 +30,7 @@ *********************************************************************21*/ /* 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" @@ -50,16 +39,6 @@ #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" @@ -77,14 +56,14 @@ * Packing Functions ***************************************************************************/ #ifdef ANSI -PUBLIC S16 cmPkKwuBndReq +S16 cmPkKwuBndReq ( Pst * pst, SuId suId, SpId spId ) #else -PUBLIC S16 cmPkKwuBndReq(pst, suId, spId) +S16 cmPkKwuBndReq(pst, suId, spId) Pst * pst; SuId suId; SpId spId; @@ -93,7 +72,6 @@ SpId spId; S16 ret1; Buffer *mBuf; - TRC3(cmPkKwuBndReq) mBuf = NULLP; @@ -107,33 +85,32 @@ SpId spId; (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)); } #ifdef ANSI -PUBLIC S16 cmPkKwuBndCfm +S16 cmPkKwuBndCfm ( Pst * pst, SuId suId, -U8 status +uint8_t status ) #else -PUBLIC S16 cmPkKwuBndCfm(pst, suId, status) +S16 cmPkKwuBndCfm(pst, suId, status) Pst * pst; SuId suId; -U8 status; +uint8_t status; #endif { S16 ret1; Buffer *mBuf; - TRC3(cmPkKwuBndCfm) mBuf = NULLP; @@ -147,25 +124,25 @@ U8 status; (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)); } #ifdef ANSI -PUBLIC S16 cmPkKwuUbndReq +S16 cmPkKwuUbndReq ( Pst * pst, SuId suId, Reason reason ) #else -PUBLIC S16 cmPkKwuUbndReq(pst, suId, reason) +S16 cmPkKwuUbndReq(pst, suId, reason) Pst * pst; SuId suId; Reason reason; @@ -174,7 +151,6 @@ Reason reason; S16 ret1; Buffer *mBuf; - TRC3(cmPkKwuUbndReq) mBuf = NULLP; @@ -188,29 +164,28 @@ Reason reason; (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 { - TRC3(cmPkKwuDatReqInfo); #ifdef CCPU_OPT switch(param->lcType) { @@ -221,37 +196,35 @@ Buffer *mBuf; 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 */ #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 @@ -264,13 +237,12 @@ Buffer * mBuf; #ifndef SS_RBUF KwuDatReqInfo* datReqInfo; #endif - TRC3(cmPkKwuDatReq) #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 @@ -287,18 +259,18 @@ Buffer * mBuf; (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); + memcpy(datReqInfo,datReq,sizeof(KwuDatReqInfo)); + 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); @@ -308,7 +280,7 @@ Buffer * 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); @@ -319,7 +291,7 @@ Buffer * mBuf; sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } } @@ -331,10 +303,9 @@ Buffer * 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, spId, mBuf, EKWU011, pst); #ifdef L2_L3_SPLIT if(datReq->rlcId.rbType == CM_LTE_SRB) { @@ -347,7 +318,7 @@ Buffer * mBuf; #else pst->event = (Event) KWU_EVT_DAT_REQ; #endif - RETVALUE(SPstTsk(pst,mBuf)); + return (SPstTsk(pst,mBuf)); #else if (pst->srcEnt == ENTPJ) { @@ -378,7 +349,7 @@ Buffer * mBuf; switch(pst->selector) { #ifdef LCKWU - case KWU_SEL_LC: + case ODU_SELECTOR_LC: { ret1 = cmPkKwuDatReqInfo( (datReq), mBuf); #if (ERRCLASS & ERRCLS_ADD_RES) @@ -388,14 +359,14 @@ Buffer * mBuf; 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 */ @@ -404,56 +375,53 @@ Buffer * mBuf; 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 */ #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; } #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 @@ -468,7 +436,6 @@ Buffer * mBuf; #endif KwuDatIndInfo *datIndInfo = NULLP; - TRC3(cmPkKwuDatInd) #ifdef TENB_SPLIT_ARCH /* SSI_CHANGES: */ @@ -480,7 +447,7 @@ Buffer * mBuf; 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 @@ -497,14 +464,14 @@ Buffer * mBuf; (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); + memcpy(datIndInfo, datInd,sizeof(KwuDatIndInfo)); + CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf); } break; - case KWU_SEL_LC: + case ODU_SELECTOR_LC: { #if (ERRCLASS & ERRCLS_ADD_RES) ret1 = cmPkKwuDatIndInfo( (datInd), mBuf); @@ -514,21 +481,11 @@ Buffer * 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); #endif /* ERRCLASS & ERRCLS_ADD_RES */ -#if 0 - /*Commenting out the below block as no Memory Allocation happens - * in Protocol. This code will be removed once testing is done */ - if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd, - sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY) != ROK) - { - SPutMsg(mBuf); - RETVALUE(RFAILED); - } -#endif } break; default: @@ -538,50 +495,48 @@ Buffer * 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 */ #ifdef ANSI -PUBLIC S16 cmPkKwuDatCfmInfo +S16 cmPkKwuDatCfmInfo ( KwuDatCfmInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmPkKwuDatCfmInfo(param, mBuf) +S16 cmPkKwuDatCfmInfo(param, mBuf) KwuDatCfmInfo *param; Buffer *mBuf; #endif { - register U32 iter; + register uint32_t iter; - 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 */ #ifdef ANSI -PUBLIC S16 cmPkKwuDatCfm +S16 cmPkKwuDatCfm ( Pst * pst, SuId suId, KwuDatCfmInfo* datCfm ) #else -PUBLIC S16 cmPkKwuDatCfm(pst, suId, datCfm) +S16 cmPkKwuDatCfm(pst, suId, datCfm) Pst * pst; SuId suId; KwuDatCfmInfo* datCfm; @@ -592,22 +547,21 @@ KwuDatCfmInfo* datCfm; #endif Buffer *mBuf; - TRC3(cmPkKwuDatCfm) 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); @@ -617,7 +571,7 @@ KwuDatCfmInfo* datCfm; 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); @@ -626,7 +580,7 @@ KwuDatCfmInfo* datCfm; sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; @@ -637,25 +591,25 @@ KwuDatCfmInfo* datCfm; __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 */ #ifdef ANSI -PUBLIC S16 cmPkKwuDiscSduReq +S16 cmPkKwuDiscSduReq ( Pst * pst, SpId spId, KwuDiscSduInfo* discSdu ) #else -PUBLIC S16 cmPkKwuDiscSduReq(pst, spId, discSdu) +S16 cmPkKwuDiscSduReq(pst, spId, discSdu) Pst * pst; SpId spId; KwuDiscSduInfo* discSdu; @@ -667,16 +621,15 @@ KwuDiscSduInfo* discSdu; Buffer *mBuf; KwuDiscSduInfo* discSduInfo = NULLP; - TRC3(cmPkKwuDiscSduReq) 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 @@ -693,14 +646,14 @@ KwuDiscSduInfo* discSdu; (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); + memcpy(discSduInfo, discSdu,sizeof(KwuDiscSduInfo)); + CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf); } break; - case KWU_SEL_LC: + case ODU_SELECTOR_LC: { #if (ERRCLASS & ERRCLS_ADD_RES) ret1 = cmPkKwuDiscSduInfo( (discSdu), mBuf); @@ -710,19 +663,11 @@ KwuDiscSduInfo* discSdu; 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); #endif /* ERRCLASS & ERRCLS_ADD_RES */ -#if 0 - if (SPutSBuf(pst->region, pst->pool, (Data *)discSdu, - sizeof(KwuDiscSduInfo)) != ROK) - { - SPutMsg(mBuf); - RETVALUE(RFAILED); - } -#endif break; } } @@ -730,85 +675,82 @@ KwuDiscSduInfo* discSdu; CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst); pst->event = (Event) KWU_EVT_DISC_SDU_REQ; - RETVALUE(SPstTsk(pst,mBuf)); + return (SPstTsk(pst,mBuf)); } /* cmPkKwuDiscSduReq */ #ifdef ANSI -PUBLIC S16 cmPkKwuStaIndInfo +S16 cmPkKwuStaIndInfo ( KwuStaIndInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmPkKwuStaIndInfo(param, mBuf) +S16 cmPkKwuStaIndInfo(param, mBuf) KwuStaIndInfo *param; Buffer *mBuf; #endif { S16 i; - TRC3(cmPkKwuStaIndInfo); for (i = (param->numSdu - 1); i >= 0; i--) { - CMCHKPK(SPkU32, param->sduId[(U16)i], mBuf); + CMCHKPK(oduUnpackUInt32, param->sduId[(uint16_t)i], mBuf); } - CMCHKPK(SPkU32, param->numSdu, mBuf); + CMCHKPK(oduUnpackUInt32, param->numSdu, mBuf); CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf); - RETVALUE(ROK); + return ROK; } #ifdef ANSI -PUBLIC S16 cmPkKwuFlowCntrlIndInfo +S16 cmPkKwuFlowCntrlIndInfo ( KwuFlowCntrlIndInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmPkKwuFlowCntrlIndInfo(param, mBuf) +S16 cmPkKwuFlowCntrlIndInfo(param, mBuf) KwuFlowCntrlIndInfo *param; Buffer *mBuf; #endif { - TRC3(cmPkKwuFlowCntrlIndInfo); - CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf); + CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf); CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf); - RETVALUE(ROK); + return ROK; } /* cmPkKwuFlowCntrlIndInfo */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo +S16 cmUnpkKwuFlowCntrlIndInfo ( KwuFlowCntrlIndInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf) +S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf) KwuFlowCntrlIndInfo *param; Buffer *mBuf; #endif { - TRC3(cmUnpkKwuFlowCntrlIndInfo); CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf); - CMCHKUNPK(SUnpkU32, ¶m->pktAdmitCnt, mBuf); + CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf); - RETVALUE(ROK); + return ROK; } /* cmUnpkKwuFlowCntrlIndInfo */ #ifdef ANSI -PUBLIC S16 cmPkKwuStaInd +S16 cmPkKwuStaInd ( Pst * pst, SuId suId, KwuStaIndInfo* staInd ) #else -PUBLIC S16 cmPkKwuStaInd(pst, suId, staInd) +S16 cmPkKwuStaInd(pst, suId, staInd) Pst * pst; SuId suId; KwuStaIndInfo* staInd; @@ -821,22 +763,21 @@ KwuStaIndInfo* staInd; #endif /* LCKWU */ Buffer *mBuf; - TRC3(cmPkKwuStaInd) 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); @@ -846,7 +787,7 @@ KwuStaIndInfo* staInd; 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); @@ -855,7 +796,7 @@ KwuStaIndInfo* staInd; sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; @@ -866,25 +807,25 @@ KwuStaIndInfo* staInd; __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 */ #ifdef ANSI -PUBLIC S16 cmPkKwuReEstCmpInd +S16 cmPkKwuReEstCmpInd ( Pst * pst, SuId suId, CmLteRlcId rlcId ) #else -PUBLIC S16 cmPkKwuReEstCmpInd(pst, suId, rlcId) +S16 cmPkKwuReEstCmpInd(pst, suId, rlcId) Pst * pst; SuId suId; CmLteRlcId rlcId; @@ -897,18 +838,17 @@ CmLteRlcId rlcId; #endif /* LCKWU */ Buffer *mBuf; - TRC3(cmPkKwuReEstCmpInd) 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); @@ -918,7 +858,7 @@ CmLteRlcId rlcId; 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); @@ -931,19 +871,19 @@ CmLteRlcId rlcId; 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 */ #ifdef ANSI -PUBLIC S16 cmPkKwuDiscSduCfm +S16 cmPkKwuDiscSduCfm ( Pst *pst, SpId spId, KwuDiscSduInfo *discCfmSdu ) #else -PUBLIC S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu) +S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu) Pst *pst; SpId spId; KwuDiscSduInfo *discCfmSdu; @@ -954,22 +894,21 @@ KwuDiscSduInfo *discCfmSdu; #endif Buffer *mBuf; - TRC3(cmPkKwuDiscSduCfm) 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); @@ -979,7 +918,7 @@ KwuDiscSduInfo *discCfmSdu; 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); @@ -988,7 +927,7 @@ KwuDiscSduInfo *discCfmSdu; sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; @@ -999,24 +938,24 @@ KwuDiscSduInfo *discCfmSdu; __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 */ #ifdef ANSI -PUBLIC S16 cmPkKwuFlowCntrlInd +S16 cmPkKwuFlowCntrlInd ( Pst *pst, SuId suId, KwuFlowCntrlIndInfo *flowCntrlIndInfo ) #else -PUBLIC S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo) +S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo) Pst *pst; SuId suId; KwuFlowCntrlIndInfo *flowCntrlIndInfo; @@ -1024,7 +963,6 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; { Buffer *mBuf; - TRC3(cmPkKwuFlowCntrlInd) mBuf = NULLP; @@ -1034,12 +972,12 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; 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); @@ -1049,14 +987,14 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; 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; } @@ -1065,38 +1003,37 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; 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 #ifdef ANSI -PUBLIC S16 cmPkKwuDatAckInfo +S16 cmPkKwuDatAckInfo ( KwuDatAckInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmPkKwuDatAckInfo(param, mBuf) +S16 cmPkKwuDatAckInfo(param, mBuf) KwuDatAckInfo *param; Buffer *mBuf; #endif { - TRC3(cmPkKwuDatAckIndInfo); CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf); - CMCHKPK(SPkU32, param->sduId, mBuf); - RETVALUE(ROK); + CMCHKPK(oduUnpackUInt32, param->sduId, mBuf); + return ROK; } #ifdef ANSI -PUBLIC S16 cmPkKwuDatAckInd +S16 cmPkKwuDatAckInd ( Pst * pst, SuId suId, KwuDatAckInfo* datInd ) #else -PUBLIC S16 cmPkKwuDatAckInd(pst, suId, datInd) +S16 cmPkKwuDatAckInd(pst, suId, datInd) Pst * pst; SuId suId; KwuDatAckInfo* datInd; @@ -1106,12 +1043,11 @@ KwuDatAckInfo* datInd; Buffer *mBuf; - TRC3(cmPkKwuDatAckInd); mBuf = NULLP; if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) { - RETVALUE(RFAILED); + return RFAILED; } ret1 = cmPkKwuDatAckInfo( (datInd), mBuf); @@ -1122,33 +1058,33 @@ KwuDatAckInfo* datInd; 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 */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuBndReq +S16 cmUnpkKwuBndReq ( KwuBndReq func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuBndReq(func, pst, mBuf) +S16 cmUnpkKwuBndReq(func, pst, mBuf) KwuBndReq func; Pst *pst; Buffer *mBuf; @@ -1157,52 +1093,49 @@ Buffer *mBuf; SuId suId = 0; SpId spId = 0; - TRC3(cmUnpkKwuBndReq) - CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst); CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst); SPutMsg(mBuf); - RETVALUE((*func)(pst, suId, spId)); + return ((*func)(pst, suId, spId)); } #ifdef ANSI -PUBLIC S16 cmUnpkKwuBndCfm +S16 cmUnpkKwuBndCfm ( KwuBndCfm func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuBndCfm(func, pst, mBuf) +S16 cmUnpkKwuBndCfm(func, pst, mBuf) KwuBndCfm func; Pst *pst; Buffer *mBuf; #endif { SuId suId = 0; - U8 status = 0; + uint8_t status = 0; - 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)); } #ifdef ANSI -PUBLIC S16 cmUnpkKwuUbndReq +S16 cmUnpkKwuUbndReq ( KwuUbndReq func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuUbndReq(func, pst, mBuf) +S16 cmUnpkKwuUbndReq(func, pst, mBuf) KwuUbndReq func; Pst *pst; Buffer *mBuf; @@ -1211,33 +1144,31 @@ Buffer *mBuf; SpId spId = 0; Reason reason = 0; - TRC3(cmUnpkKwuUbndReq) CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst); CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst); SPutMsg(mBuf); - RETVALUE((*func)(pst, spId, reason)); + return ((*func)(pst, spId, reason)); } /* cmUnpkKwuUbndReq */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuDatReqInfo +S16 cmUnpkKwuDatReqInfo ( KwuDatReqInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDatReqInfo(param, mBuf) +S16 cmUnpkKwuDatReqInfo(param, mBuf) KwuDatReqInfo *param; Buffer *mBuf; #endif { - 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); @@ -1245,8 +1176,8 @@ Buffer *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); @@ -1258,22 +1189,22 @@ Buffer *mBuf; case CM_LTE_LCH_DCCH: break; default : - RETVALUE(RFAILED); + return RFAILED; } #endif - RETVALUE(ROK); + return ROK; } #ifdef ANSI -PUBLIC S16 cmUnpkKwuDatReq +S16 cmUnpkKwuDatReq ( KwuDatReq func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDatReq(func, pst, mBuf) +S16 cmUnpkKwuDatReq(func, pst, mBuf) KwuDatReq func; Pst *pst; Buffer *mBuf; @@ -1283,44 +1214,23 @@ Buffer *mBuf; 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: { -#if 0 - /*This will be removed once the testing is done on all platforms */ - if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReq,\ - sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK) - { -#if (ERRCLASS & ERRCLS_ADD_RES) - /*MBUF_FIXX*/ - SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId, - __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES, - (ErrVal)EKWU026, (ErrVal)0, "SGetMsg() failed"); - -#endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); - } - -#endif /* Allocate the memory statically as there is no free * in RLC */ datReq = &datReqTmp; - cmMemset((U8 *)datReq, 0, sizeof(KwuDatReqInfo)); + memset(datReq, 0, sizeof(KwuDatReqInfo)); #if(ERRCLASS & ERRCLS_DEBUG) ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf); if(ret1 != ROK) @@ -1329,7 +1239,7 @@ Buffer *mBuf; 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); @@ -1343,76 +1253,71 @@ Buffer *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 */ #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 { - TRC3(cmUnpkKwuDatIndInfo); CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf); #ifdef CCPU_OPT CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf); #endif - CMCHKUNPK(SUnpkU8, ¶m->isOutOfSeq, mBuf); - RETVALUE(ROK); + CMCHKUNPK(oduPackUInt8, ¶m->isOutOfSeq, mBuf); + return ROK; } #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 */ @@ -1429,7 +1334,7 @@ Buffer *mBuf; (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed"); } #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } } else @@ -1445,7 +1350,7 @@ Buffer *mBuf; 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 */ } @@ -1455,37 +1360,36 @@ Buffer *mBuf; 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 */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuDatCfmInfo +S16 cmUnpkKwuDatCfmInfo ( KwuDatCfmInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDatCfmInfo(param, mBuf) +S16 cmUnpkKwuDatCfmInfo(param, mBuf) KwuDatCfmInfo *param; Buffer *mBuf; #endif { register S32 iter; - 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) @@ -1493,20 +1397,20 @@ Buffer *mBuf; #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 -PUBLIC S16 cmUnpkKwuDatCfm +S16 cmUnpkKwuDatCfm ( KwuDatCfm func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDatCfm(func, pst, mBuf) +S16 cmUnpkKwuDatCfm(func, pst, mBuf) KwuDatCfm func; Pst *pst; Buffer *mBuf; @@ -1516,18 +1420,17 @@ Buffer *mBuf; SuId suId = 0; KwuDatCfmInfo *datCfm = NULLP; - TRC3(cmUnpkKwuDatCfm) CMCHKUNPK(SUnpkS16, &(suId), mBuf); 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) @@ -1540,10 +1443,10 @@ Buffer *mBuf; (ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed"); } #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } - cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo)); + memset(datCfm, 0, sizeof(KwuDatCfmInfo)); ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf); #if(ERRCLASS & ERRCLS_DEBUG) if(ret1 != ROK) @@ -1552,7 +1455,7 @@ Buffer *mBuf; 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 */ } @@ -1564,24 +1467,24 @@ Buffer *mBuf; (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 */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuDiscSduReq +S16 cmUnpkKwuDiscSduReq ( KwuDiscSduReq func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDiscSduReq(func, pst, mBuf) +S16 cmUnpkKwuDiscSduReq(func, pst, mBuf) KwuDiscSduReq func; Pst *pst; Buffer *mBuf; @@ -1595,12 +1498,12 @@ Buffer *mBuf; 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) @@ -1612,10 +1515,10 @@ Buffer *mBuf; (ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed"); #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } - cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo)); + memset(discSdu, 0, sizeof(KwuDiscSduInfo)); ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf); #if(ERRCLASS & ERRCLS_DEBUG) if(ret1 != ROK) @@ -1624,7 +1527,7 @@ Buffer *mBuf; 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; @@ -1636,50 +1539,49 @@ Buffer *mBuf; (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 */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuStaIndInfo +S16 cmUnpkKwuStaIndInfo ( KwuStaIndInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuStaIndInfo(param, mBuf) +S16 cmUnpkKwuStaIndInfo(param, mBuf) KwuStaIndInfo *param; Buffer *mBuf; #endif { - U32 i; + uint32_t i; - 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 */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuStaInd +S16 cmUnpkKwuStaInd ( KwuStaInd func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuStaInd(func, pst, mBuf) +S16 cmUnpkKwuStaInd(func, pst, mBuf) KwuStaInd func; Pst *pst; Buffer *mBuf; @@ -1689,18 +1591,17 @@ Buffer *mBuf; SuId suId = 0; KwuStaIndInfo *staInd = NULLP; - TRC3(cmUnpkKwuStaInd) CMCHKUNPK(SUnpkS16, &(suId), mBuf); 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) @@ -1713,10 +1614,10 @@ Buffer *mBuf; (ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed"); } #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } - cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo)); + memset(staInd, 0, sizeof(KwuStaIndInfo)); ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf); #if(ERRCLASS & ERRCLS_DEBUG) @@ -1726,7 +1627,7 @@ Buffer *mBuf; 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 */ } @@ -1738,23 +1639,23 @@ Buffer *mBuf; __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 */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuReEstCmpInd +S16 cmUnpkKwuReEstCmpInd ( KwuReEstCmpInd func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf) +S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf) KwuReEstCmpInd func; Pst *pst; Buffer *mBuf; @@ -1766,15 +1667,12 @@ Buffer *mBuf; SuId suId = 0; CmLteRlcId rlcId; - TRC3(cmUnpkKwuReEstCmpInd) - - cmMemset((U8 *)&rlcId, 0, sizeof(CmLteRlcId)); - + memset(&rlcId, 0, sizeof(CmLteRlcId)); CMCHKUNPK(SUnpkS16, &(suId), mBuf); switch(pst->selector) { #ifdef LCKWU - case KWU_SEL_LC: + case ODU_SELECTOR_LC: { #if(ERRCLASS & ERRCLS_DEBUG) ret1 = cmUnpkLteRlcId( &rlcId, mBuf); @@ -1784,7 +1682,7 @@ Buffer *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); @@ -1795,19 +1693,19 @@ Buffer *mBuf; } SPutMsg(mBuf); - RETVALUE((*func)(pst, suId, rlcId)); + return ((*func)(pst, suId, rlcId)); } /* cmUnpkKwuReEstCmpInd */ /* kwu_c_001.main_3 added support for L2 Measurement */ #ifdef ANSI -PUBLIC S16 cmUnpkKwuDiscSduCfm +S16 cmUnpkKwuDiscSduCfm ( KwuDiscSduCfm func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf) +S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf) KwuDiscSduCfm func; Pst *pst; Buffer *mBuf; @@ -1817,18 +1715,17 @@ Buffer *mBuf; SpId spId = 0; KwuDiscSduInfo *discSdu = NULLP; - TRC3(cmUnpkKwuDiscSduCfm); 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) @@ -1841,9 +1738,9 @@ Buffer *mBuf; (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed"); } #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } - cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo)); + memset(discSdu, 0, sizeof(KwuDiscSduInfo)); ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf); #if(ERRCLASS & ERRCLS_DEBUG) @@ -1864,21 +1761,21 @@ Buffer *mBuf; __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 +S16 cmUnpkKwuFlowCntrlInd ( KwuFlowCntrlInd func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf) +S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf) KwuFlowCntrlInd func; Pst *pst; Buffer *mBuf; @@ -1887,13 +1784,12 @@ Buffer *mBuf; SuId suId; KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP; - TRC3(cmUnpkKwuFlowCntrlInd); CMCHKUNPK(SUnpkS16, &(suId), mBuf); switch(pst->selector) { #ifdef LCKWU - case KWU_SEL_LC: + case ODU_SELECTOR_LC: { if(SGetStaticBuffer(pst->region, pst->pool, @@ -1901,16 +1797,16 @@ Buffer *mBuf; 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 @@ -1918,40 +1814,39 @@ Buffer *mBuf; SPutMsg(mBuf); - RETVALUE((*func)(pst, suId, flowCntrlInfo)); + return ((*func)(pst, suId, flowCntrlInfo)); } /* cmUnpkKwuFlowCntrlInd */ #ifdef LTE_L2_MEAS #ifdef ANSI -PUBLIC S16 cmUnpkKwuDatAckInfo +S16 cmUnpkKwuDatAckInfo ( KwuDatAckInfo *param, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDatAckInfo(param, mBuf) +S16 cmUnpkKwuDatAckInfo(param, mBuf) KwuDatAckInfo *param; Buffer *mBuf; #endif { - TRC3(cmUnpkKwuDatAckInfo); - CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf); + CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf); CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf); - RETVALUE(ROK); + return ROK; } #ifdef ANSI -PUBLIC S16 cmUnpkKwuDatAckInd +S16 cmUnpkKwuDatAckInd ( KwuDatAckInd func, Pst *pst, Buffer *mBuf ) #else -PUBLIC S16 cmUnpkKwuDatAckInd(func, pst, mBuf) +S16 cmUnpkKwuDatAckInd(func, pst, mBuf) KwuDatAckInd func; Pst *pst; Buffer *mBuf; @@ -1961,7 +1856,6 @@ Buffer *mBuf; SuId suId = 0; KwuDatAckInfo *datInd = NULLP; - TRC3(cmUnpkKwuDatAckInd); if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\ sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK) @@ -1974,10 +1868,10 @@ Buffer *mBuf; (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed"); } #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } - cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo)); + memset(datInd, 0, sizeof(KwuDatAckInfo)); CMCHKUNPK(SUnpkS16, &(suId), mBuf); ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf); @@ -1988,11 +1882,11 @@ Buffer *mBuf; 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 */