X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=inline;f=src%2Fcm%2Fkwu.c;h=06899000e45633af9a3e7c828a8b5ac3e1630b22;hb=def50dc175cebc67238db5f1acd5ff322a2279bd;hp=6cb2f7887865821f60fc29a0885036f40241cb68;hpb=105199ef642ffe9736ea24a01d4546578fa25e60;p=o-du%2Fl2.git diff --git a/src/cm/kwu.c b/src/cm/kwu.c index 6cb2f7887..06899000e 100755 --- a/src/cm/kwu.c +++ b/src/cm/kwu.c @@ -56,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; @@ -72,7 +72,6 @@ SpId spId; S16 ret1; Buffer *mBuf; - TRC3(cmPkKwuBndReq) mBuf = NULLP; @@ -86,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; @@ -126,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; @@ -153,7 +151,6 @@ Reason reason; S16 ret1; Buffer *mBuf; - TRC3(cmPkKwuUbndReq) mBuf = NULLP; @@ -167,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) { @@ -200,34 +196,34 @@ 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, KwuDatReqInfo* datReq, Buffer * mBuf ) #else -PUBLIC S16 cmPkKwuDatReq(pst, datReq, mBuf) +uint8_t cmPkKwuDatReq(pst, datReq, mBuf) Pst * pst; KwuDatReqInfo* datReq; Buffer * mBuf; @@ -241,7 +237,6 @@ Buffer * mBuf; #ifndef SS_RBUF KwuDatReqInfo* datReqInfo; #endif - TRC3(cmPkKwuDatReq) #ifndef SS_RBUF switch(pst->selector) { @@ -264,14 +259,14 @@ 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; @@ -285,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); @@ -296,7 +291,7 @@ Buffer * mBuf; sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } } @@ -308,7 +303,7 @@ 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; } #ifdef L2_L3_SPLIT @@ -323,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) { @@ -364,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 ODU_SELECTOR_LWLC: { - CMCHKPK(cmPkPtr,(PTR)datReq, mBuf); + CMCHKPK(oduPackPointer,(PTR)datReq, mBuf); } break; #endif /* LCKWU */ @@ -386,47 +381,46 @@ Buffer * mBuf; 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, KwuDatIndInfo* datInd, Buffer * mBuf ) #else -PUBLIC S16 cmPkKwuDatInd(pst, datInd, mBuf) +uint8_t cmPkKwuDatInd(pst, datInd, mBuf) Pst * pst; KwuDatIndInfo* datInd; Buffer * mBuf; @@ -442,7 +436,6 @@ Buffer * mBuf; #endif KwuDatIndInfo *datIndInfo = NULLP; - TRC3(cmPkKwuDatInd) #ifdef TENB_SPLIT_ARCH /* SSI_CHANGES: */ @@ -471,11 +464,11 @@ 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 ODU_SELECTOR_LC: @@ -488,7 +481,7 @@ 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); @@ -502,49 +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; } 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; @@ -555,19 +547,18 @@ 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 ODU_SELECTOR_LWLC: { - CMCHKPK(cmPkPtr,(PTR)datCfm, mBuf); + CMCHKPK(oduPackPointer,(PTR)datCfm, mBuf); } break; case ODU_SELECTOR_LC: @@ -580,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); @@ -589,7 +580,7 @@ KwuDatCfmInfo* datCfm; sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; @@ -600,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; @@ -630,11 +621,10 @@ 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) @@ -656,11 +646,11 @@ 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 ODU_SELECTOR_LC: @@ -673,7 +663,7 @@ 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); @@ -685,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; @@ -776,19 +763,18 @@ 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 ODU_SELECTOR_LWLC: { - CMCHKPK(cmPkPtr,(PTR) staInd, mBuf); + CMCHKPK(oduPackPointer,(PTR) staInd, mBuf); } break; case ODU_SELECTOR_LC: @@ -801,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); @@ -810,7 +796,7 @@ KwuStaIndInfo* staInd; sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; @@ -821,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; @@ -852,12 +838,11 @@ 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) @@ -873,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); @@ -886,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; @@ -909,19 +894,18 @@ 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 ODU_SELECTOR_LWLC: { - CMCHKPK(cmPkPtr,(PTR)discCfmSdu, mBuf); + CMCHKPK(oduPackPointer,(PTR)discCfmSdu, mBuf); } break; case ODU_SELECTOR_LC: @@ -934,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); @@ -943,7 +927,7 @@ KwuDiscSduInfo *discCfmSdu; sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; @@ -954,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; @@ -979,7 +963,6 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; { Buffer *mBuf; - TRC3(cmPkKwuFlowCntrlInd) mBuf = NULLP; @@ -989,7 +972,7 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; pst->pool, (Data *)flowCntrlIndInfo, sizeof(KwuFlowCntrlIndInfo),0); - RETVALUE(RFAILED); + return RFAILED; } #ifdef LCKWU switch(pst->selector) @@ -1004,14 +987,14 @@ KwuFlowCntrlIndInfo *flowCntrlIndInfo; sizeof(KwuFlowCntrlIndInfo),0) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } } break; case ODU_SELECTOR_LWLC: { - CMCHKPK(cmPkPtr,(PTR) flowCntrlIndInfo, mBuf); + CMCHKPK(oduPackPointer,(PTR) flowCntrlIndInfo, mBuf); } break; } @@ -1020,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; @@ -1061,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); @@ -1077,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; @@ -1112,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; @@ -1166,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); @@ -1200,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); @@ -1213,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; @@ -1241,13 +1217,12 @@ Buffer *mBuf; KwuDatReqInfo *datReq = NULLP; KwuDatReqInfo datReqTmp; - TRC3(cmUnpkKwuDatReq) switch(pst->selector) { case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *) &datReq, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *) &datReq, mBuf); } break; case ODU_SELECTOR_LC: @@ -1255,7 +1230,7 @@ Buffer *mBuf; /* 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) @@ -1264,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); @@ -1278,7 +1253,7 @@ 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, datReq, mBuf); @@ -1289,43 +1264,42 @@ Buffer *mBuf; 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; @@ -1335,13 +1309,12 @@ Buffer *mBuf; KwuDatIndInfo *datInd = NULLP; KwuDatIndInfo datIndTmp; - TRC3(cmUnpkKwuDatInd) switch(pst->selector) { case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *) &datInd, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *) &datInd, mBuf); } break; case ODU_SELECTOR_LC: @@ -1361,7 +1334,7 @@ Buffer *mBuf; (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed"); } #endif /* ERRCLASS & ERRCLS_ADD_RES */ - RETVALUE(ret1); + return (ret1); } } else @@ -1377,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 */ } @@ -1387,7 +1360,7 @@ 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, datInd, mBuf); /* If LWLC is configured and the destination entity is PDCP, we need to @@ -1397,27 +1370,26 @@ Buffer *mBuf; 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) @@ -1425,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; @@ -1448,7 +1420,6 @@ Buffer *mBuf; SuId suId = 0; KwuDatCfmInfo *datCfm = NULLP; - TRC3(cmUnpkKwuDatCfm) CMCHKUNPK(SUnpkS16, &(suId), mBuf); @@ -1456,7 +1427,7 @@ Buffer *mBuf; { case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *) &datCfm, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *) &datCfm, mBuf); } break; case ODU_SELECTOR_LC: @@ -1472,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) @@ -1484,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 */ } @@ -1496,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; @@ -1529,7 +1500,7 @@ Buffer *mBuf; { case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf); } break; case ODU_SELECTOR_LC: @@ -1544,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) @@ -1556,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; @@ -1568,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; @@ -1621,7 +1591,6 @@ Buffer *mBuf; SuId suId = 0; KwuStaIndInfo *staInd = NULLP; - TRC3(cmUnpkKwuStaInd) CMCHKUNPK(SUnpkS16, &(suId), mBuf); @@ -1629,7 +1598,7 @@ Buffer *mBuf; { case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *)&staInd, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *)&staInd, mBuf); } break; case ODU_SELECTOR_LC: @@ -1645,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) @@ -1658,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 */ } @@ -1670,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; @@ -1698,10 +1667,7 @@ 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) { @@ -1716,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); @@ -1727,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; @@ -1749,7 +1715,6 @@ Buffer *mBuf; SpId spId = 0; KwuDiscSduInfo *discSdu = NULLP; - TRC3(cmUnpkKwuDiscSduCfm); CMCHKUNPK(SUnpkS16, &(spId), mBuf); @@ -1757,7 +1722,7 @@ Buffer *mBuf; { case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf); } break; case ODU_SELECTOR_LC: @@ -1773,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) @@ -1796,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; @@ -1819,7 +1784,6 @@ Buffer *mBuf; SuId suId; KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP; - TRC3(cmUnpkKwuFlowCntrlInd); CMCHKUNPK(SUnpkS16, &(suId), mBuf); switch(pst->selector) @@ -1833,7 +1797,7 @@ Buffer *mBuf; sizeof(KwuFlowCntrlIndInfo),0) != ROK) { SPutMsg(mBuf); - RETVALUE(RFAILED); + return RFAILED; } cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf); @@ -1842,7 +1806,7 @@ Buffer *mBuf; case ODU_SELECTOR_LWLC: { - CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInfo, mBuf); + CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInfo, mBuf); } break; #endif @@ -1850,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; @@ -1893,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) @@ -1906,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); @@ -1920,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 */