/****************************************************************************
* Packing Functions
***************************************************************************/
-#ifdef ANSI
-PUBLIC S16 cmPkKwuBndReq
-(
-Pst * pst,
-SuId suId,
-SpId spId
-)
-#else
-PUBLIC S16 cmPkKwuBndReq(pst, suId, spId)
-Pst * pst;
-SuId suId;
-SpId spId;
-#endif
+S16 cmPkKwuBndReq(Pst * pst,SuId suId,SpId spId)
{
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuBndReq)
-
mBuf = NULLP;
if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
}
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuBndCfm
-(
-Pst * pst,
-SuId suId,
-U8 status
-)
-#else
-PUBLIC S16 cmPkKwuBndCfm(pst, suId, status)
-Pst * pst;
-SuId suId;
-U8 status;
-#endif
+S16 cmPkKwuBndCfm(Pst * pst,SuId suId,uint8_t status)
{
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuBndCfm)
mBuf = NULLP;
return (ret1);
}
- CMCHKPKLOG(oduUnpackUInt8, status, mBuf, EKWU005, pst);
+ CMCHKPKLOG(oduPackUInt8, status, mBuf, EKWU005, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
pst->event = (Event) KWU_EVT_BND_CFM;
return (SPstTsk(pst,mBuf));
}
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuUbndReq
-(
-Pst * pst,
-SuId suId,
-Reason reason
-)
-#else
-PUBLIC S16 cmPkKwuUbndReq(pst, suId, reason)
-Pst * pst;
-SuId suId;
-Reason reason;
-#endif
+S16 cmPkKwuUbndReq(Pst * pst,SuId suId,Reason reason)
{
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuUbndReq)
mBuf = NULLP;
return (SPstTsk(pst,mBuf));
} /* cmPkKwuUbndReq */
-#ifdef ANSI
-uint8_t cmPkKwuDatReqInfo
-(
-KwuDatReqInfo *param,
-Buffer *mBuf
-)
-#else
-uint8_t cmPkKwuDatReqInfo(param, mBuf)
-KwuDatReqInfo *param;
-Buffer *mBuf;
-#endif
+uint8_t cmPkRlcDatReqInfo(RlcDatReqInfo *param,Buffer *mBuf)
{
-
- TRC3(cmPkKwuDatReqInfo);
-
#ifdef CCPU_OPT
switch(param->lcType) {
case CM_LTE_LCH_CCCH:
case CM_LTE_LCH_PCCH:
CMCHKPK(cmPkLteTimingInfo, ¶m->tm.tmg, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(oduUnpackUInt8, param->emtcDiReason,mBuf);
- CMCHKPK(oduUnpackUInt8, param->pnb,mBuf);
+ CMCHKPK(oduPackUInt8, param->emtcDiReason,mBuf);
+ CMCHKPK(oduPackUInt8, param->pnb,mBuf);
#endif
break;
case CM_LTE_LCH_DTCH:
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
#endif
- CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
+ CMCHKPK(oduPackUInt32, param->sduId, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
-} /* cmPkKwuDatReqInfo */
+} /* cmPkRlcDatReqInfo */
\f
-#ifdef ANSI
-uint8_t cmPkKwuDatReq
-(
-Pst * pst,
-KwuDatReqInfo* datReq,
-Buffer * mBuf
-)
-#else
-uint8_t cmPkKwuDatReq(pst, datReq, mBuf)
-Pst * pst;
-KwuDatReqInfo* datReq;
-Buffer * mBuf;
-#endif
+uint8_t cmPkRlcDatReq(Pst * pst,RlcDatReqInfo* datReq,Buffer * mBuf)
{
#ifdef LCKWU
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* LCKWU */
S16 ret1 = ROK;
#ifndef SS_RBUF
- KwuDatReqInfo* datReqInfo;
+ RlcDatReqInfo* datReqInfo;
#endif
- TRC3(cmPkKwuDatReq)
#ifndef SS_RBUF
switch(pst->selector)
{
* the contents and pass the pointer of the allocated memory. The
* subsequent free would be done during the Unpack function of the
* primitive. */
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReqInfo,
- sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datReqInfo,
+ sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
+ memcpy(datReqInfo,datReq,sizeof(RlcDatReqInfo));
CMCHKPK(oduPackPointer,(PTR)datReqInfo, mBuf);
}
else
case ODU_SELECTOR_LC:
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
+ ret1 = cmPkRlcDatReqInfo( (datReq), mBuf);
if(ret1 != ROK)
{
SPutMsg(mBuf);
return ( ret1 );
}
#else
- cmPkKwuDatReqInfo( (datReq), mBuf);
+ cmPkRlcDatReqInfo( (datReq), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if(pst->srcEnt == ENTNH)
{
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
- sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datReq,
+ sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
return RFAILED;
#ifdef LCKWU
case ODU_SELECTOR_LC:
{
- ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
+ ret1 = cmPkRlcDatReqInfo( (datReq), mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
if(ret1 != ROK)
{
ret1 = SPstTsk(pst,mBuf);
if(pst->selector == ODU_SELECTOR_LC)
{
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
- sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datReq,
+ sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
return RFAILED;
}
return (ret1);
#endif
-} /* cmPkKwuDatReq */
+} /* cmPkRlcDatReq */
\f
-#ifdef ANSI
-uint8_t cmPkKwuDatIndInfo
-(
-KwuDatIndInfo *param,
-Buffer *mBuf
-)
-#else
-uint8_t cmPkKwuDatIndInfo(param, mBuf)
-KwuDatIndInfo *param;
-Buffer *mBuf;
-#endif
+uint8_t cmPkKwuDatIndInfo(KwuDatIndInfo *param,Buffer *mBuf)
{
- TRC3(cmPkKwuDatIndInfo);
- CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
+ CMCHKPK(oduPackUInt8, param->isOutOfSeq, mBuf);
#ifdef CCPU_OPT
CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
#endif
}
\f
-#ifdef ANSI
-uint8_t cmPkKwuDatInd
-(
-Pst * pst,
-KwuDatIndInfo* datInd,
-Buffer * mBuf
-)
-#else
-uint8_t cmPkKwuDatInd(pst, datInd, mBuf)
-Pst * pst;
-KwuDatIndInfo* datInd;
-Buffer * mBuf;
-#endif
+uint8_t cmPkKwuDatInd(Pst * pst,KwuDatIndInfo* datInd,Buffer * mBuf)
{
#ifdef LCKWU
S16 ret1 = ROK;
#endif
KwuDatIndInfo *datIndInfo = NULLP;
- TRC3(cmPkKwuDatInd)
#ifdef TENB_SPLIT_ARCH
/* SSI_CHANGES: */
* the contents and pass the pointer of the allocated memory. The
* subsequent free would be done during the Unpack function of the
* primitive. */
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datIndInfo,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datIndInfo,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return (ret1);
}
- cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
+ memcpy(datIndInfo, datInd,sizeof(KwuDatIndInfo));
CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf);
}
break;
} /* cmPkKwuDatInd */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuDatCfmInfo
-(
-KwuDatCfmInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmPkKwuDatCfmInfo(param, mBuf)
-KwuDatCfmInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmPkKwuDatCfmInfo(KwuDatCfmInfo *param,Buffer *mBuf)
{
- register U32 iter;
+ register uint32_t iter;
- TRC3(cmPkKwuDatCfmInfo);
for(iter = 0; iter < param->numSduIds; iter++)
{
- CMCHKPK(oduUnpackUInt32, param->sduIds[iter], mBuf);
+ CMCHKPK(oduPackUInt32, param->sduIds[iter], mBuf);
}
- CMCHKPK(oduUnpackUInt32, param->numSduIds, mBuf);
+ CMCHKPK(oduPackUInt32, param->numSduIds, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
} /* cmPkKwuDatCfmInfo */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuDatCfm
-(
-Pst * pst,
-SuId suId,
-KwuDatCfmInfo* datCfm
-)
-#else
-PUBLIC S16 cmPkKwuDatCfm(pst, suId, datCfm)
-Pst * pst;
-SuId suId;
-KwuDatCfmInfo* datCfm;
-#endif
+S16 cmPkKwuDatCfm(Pst * pst,SuId suId,KwuDatCfmInfo* datCfm)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1= ROK;
#endif
Buffer *mBuf;
- TRC3(cmPkKwuDatCfm)
mBuf = NULLP;
#else
cmPkKwuDatCfmInfo( (datCfm), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datCfm,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datCfm,
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
} /* cmPkKwuDatCfm */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuDiscSduReq
-(
-Pst * pst,
-SpId spId,
-KwuDiscSduInfo* discSdu
-)
-#else
-PUBLIC S16 cmPkKwuDiscSduReq(pst, spId, discSdu)
-Pst * pst;
-SpId spId;
-KwuDiscSduInfo* discSdu;
-#endif
+S16 cmPkKwuDiscSduReq(Pst * pst,SpId spId,KwuDiscSduInfo* discSdu)
{
#ifdef LCKWU
S16 ret1;
Buffer *mBuf;
KwuDiscSduInfo* discSduInfo = NULLP;
- TRC3(cmPkKwuDiscSduReq)
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
* the contents and pass the pointer of the allocated memory. The
* subsequent free would be done during the Unpack function of the
* primitive. */
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSduInfo,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&discSduInfo,
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return (ret1);
}
- cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
+ memcpy(discSduInfo, discSdu,sizeof(KwuDiscSduInfo));
CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf);
}
break;
} /* cmPkKwuDiscSduReq */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuStaIndInfo
-(
-KwuStaIndInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmPkKwuStaIndInfo(param, mBuf)
-KwuStaIndInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmPkKwuStaIndInfo(KwuStaIndInfo *param,Buffer *mBuf)
{
S16 i;
- TRC3(cmPkKwuStaIndInfo);
for (i = (param->numSdu - 1); i >= 0; i--)
{
- CMCHKPK(oduUnpackUInt32, param->sduId[(U16)i], mBuf);
+ CMCHKPK(oduPackUInt32, param->sduId[(uint16_t)i], mBuf);
}
- CMCHKPK(oduUnpackUInt32, param->numSdu, mBuf);
+ CMCHKPK(oduPackUInt32, param->numSdu, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
}
-#ifdef ANSI
-PUBLIC S16 cmPkKwuFlowCntrlIndInfo
-(
-KwuFlowCntrlIndInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmPkKwuFlowCntrlIndInfo(param, mBuf)
-KwuFlowCntrlIndInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmPkKwuFlowCntrlIndInfo(KwuFlowCntrlIndInfo *param,Buffer *mBuf)
{
- TRC3(cmPkKwuFlowCntrlIndInfo);
- CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
+ CMCHKPK(oduPackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
} /* cmPkKwuFlowCntrlIndInfo */
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo
-(
-KwuFlowCntrlIndInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf)
-KwuFlowCntrlIndInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuFlowCntrlIndInfo(KwuFlowCntrlIndInfo *param,Buffer *mBuf)
{
- TRC3(cmUnpkKwuFlowCntrlIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->pktAdmitCnt, mBuf);
return ROK;
} /* cmUnpkKwuFlowCntrlIndInfo */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuStaInd
-(
-Pst * pst,
-SuId suId,
-KwuStaIndInfo* staInd
-)
-#else
-PUBLIC S16 cmPkKwuStaInd(pst, suId, staInd)
-Pst * pst;
-SuId suId;
-KwuStaIndInfo* staInd;
-#endif
+S16 cmPkKwuStaInd(Pst * pst,SuId suId,KwuStaIndInfo* staInd)
{
#ifdef LCKWU
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* LCKWU */
Buffer *mBuf;
- TRC3(cmPkKwuStaInd)
mBuf = NULLP;
#else
cmPkKwuStaIndInfo( (staInd), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staInd,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
} /* cmPkKwuStaInd */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuReEstCmpInd
-(
-Pst * pst,
-SuId suId,
-CmLteRlcId rlcId
-)
-#else
-PUBLIC S16 cmPkKwuReEstCmpInd(pst, suId, rlcId)
-Pst * pst;
-SuId suId;
-CmLteRlcId rlcId;
-#endif
+S16 cmPkKwuReEstCmpInd(Pst * pst,SuId suId,CmLteRlcId rlcId)
{
#ifdef LCKWU
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* LCKWU */
Buffer *mBuf;
- TRC3(cmPkKwuReEstCmpInd)
mBuf = NULLP;
} /* cmPkKwuReEstCmpInd */
/* kwu_c_001.main_3 added support for L2 Measurement */
-#ifdef ANSI
-PUBLIC S16 cmPkKwuDiscSduCfm
-(
-Pst *pst,
-SpId spId,
-KwuDiscSduInfo *discCfmSdu
-)
-#else
-PUBLIC S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu)
-Pst *pst;
-SpId spId;
-KwuDiscSduInfo *discCfmSdu;
-#endif
+S16 cmPkKwuDiscSduCfm(Pst *pst,SpId spId,KwuDiscSduInfo *discCfmSdu)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
S16 ret1 = ROK;
#endif
Buffer *mBuf;
- TRC3(cmPkKwuDiscSduCfm)
mBuf = NULLP;
#else
cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)discCfmSdu,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)discCfmSdu,
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
return (SPstTsk(pst,mBuf));
} /* cmPkKwuDiscSduCfm */
\f
-#ifdef ANSI
-PUBLIC S16 cmPkKwuFlowCntrlInd
-(
-Pst *pst,
-SuId suId,
-KwuFlowCntrlIndInfo *flowCntrlIndInfo
-)
-#else
-PUBLIC S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
-Pst *pst;
-SuId suId;
-KwuFlowCntrlIndInfo *flowCntrlIndInfo;
-#endif
+S16 cmPkKwuFlowCntrlInd(Pst *pst,SuId suId,KwuFlowCntrlIndInfo *flowCntrlIndInfo)
{
Buffer *mBuf;
- TRC3(cmPkKwuFlowCntrlInd)
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- SPutStaticBuffer(pst->region,
+ SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region,
pst->pool,
(Data *)flowCntrlIndInfo,
sizeof(KwuFlowCntrlIndInfo),0);
{
cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
- if (SPutStaticBuffer(pst->region,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region,
pst->pool,
(Data *)flowCntrlIndInfo,
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
} /* cmPkKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
-#ifdef ANSI
-PUBLIC S16 cmPkKwuDatAckInfo
-(
-KwuDatAckInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmPkKwuDatAckInfo(param, mBuf)
-KwuDatAckInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmPkKwuDatAckInfo(KwuDatAckInfo *param,Buffer *mBuf)
{
- TRC3(cmPkKwuDatAckIndInfo);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
+ CMCHKPK(oduPackUInt32, param->sduId, mBuf);
return ROK;
}
-#ifdef ANSI
-PUBLIC S16 cmPkKwuDatAckInd
-(
-Pst * pst,
-SuId suId,
-KwuDatAckInfo* datInd
-)
-#else
-PUBLIC S16 cmPkKwuDatAckInd(pst, suId, datInd)
-Pst * pst;
-SuId suId;
-KwuDatAckInfo* datInd;
-#endif
+S16 cmPkKwuDatAckInd(Pst * pst,SuId suId,KwuDatAckInfo* datInd)
{
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuDatAckInd);
mBuf = NULLP;
return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
+ if (SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
#endif /* LTE_L2_MEAS */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuBndReq
-(
-KwuBndReq func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuBndReq(func, pst, mBuf)
-KwuBndReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuBndReq(KwuBndReq func,Pst *pst,Buffer *mBuf)
{
SuId suId = 0;
SpId spId = 0;
- TRC3(cmUnpkKwuBndReq)
-
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst);
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
SPutMsg(mBuf);
}
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuBndCfm
-(
-KwuBndCfm func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuBndCfm(func, pst, mBuf)
-KwuBndCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuBndCfm(KwuBndCfm func,Pst *pst,Buffer *mBuf)
{
SuId suId = 0;
- U8 status = 0;
+ uint8_t status = 0;
- TRC3(cmUnpkKwuBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
- CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EKWU023, pst);
+ CMCHKUNPKLOG(oduUnpackUInt8, &status, mBuf, EKWU023, pst);
SPutMsg(mBuf);
return ((*func)(pst, suId, status));
}
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuUbndReq
-(
-KwuUbndReq func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuUbndReq(func, pst, mBuf)
-KwuUbndReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuUbndReq(KwuUbndReq func,Pst *pst,Buffer *mBuf)
{
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkKwuUbndReq)
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
} /* cmUnpkKwuUbndReq */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatReqInfo
-(
-KwuDatReqInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDatReqInfo(param, mBuf)
-KwuDatReqInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmUnpkRlcDatReqInfo(RlcDatReqInfo *param,Buffer *mBuf)
{
- TRC3(cmUnpkKwuDatReqInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶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(oduPackUInt8,¶m->pnb , mBuf);
- CMCHKUNPK(oduPackUInt8,¶m->emtcDiReason , mBuf);
+ CMCHKUNPK(oduUnpackUInt8,¶m->pnb , mBuf);
+ CMCHKUNPK(oduUnpackUInt8,¶m->emtcDiReason , mBuf);
#endif
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->tm.tmg, mBuf);
}
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatReq
-(
-KwuDatReq func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDatReq(func, pst, mBuf)
-KwuDatReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDatReq(KwuDatReq func,Pst *pst,Buffer *mBuf)
{
#if(ERRCLASS & ERRCLS_DEBUG)
S16 ret1 = ROK;
#endif
S16 retVal;
- KwuDatReqInfo *datReq = NULLP;
- KwuDatReqInfo datReqTmp;
+ RlcDatReqInfo *datReq = NULLP;
+ RlcDatReqInfo datReqTmp;
- TRC3(cmUnpkKwuDatReq)
switch(pst->selector)
{
/* Allocate the memory statically as there is no free
* in RLC */
datReq = &datReqTmp;
- cmMemset((U8 *)datReq, 0, sizeof(KwuDatReqInfo));
+ memset(datReq, 0, sizeof(RlcDatReqInfo));
#if(ERRCLASS & ERRCLS_DEBUG)
- ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf);
+ ret1 = cmUnpkRlcDatReqInfo( (datReq), mBuf);
if(ret1 != ROK)
{
SPutMsg(mBuf);
return ( ret1 );
}
#else
- cmUnpkKwuDatReqInfo( (datReq), mBuf);
+ cmUnpkRlcDatReqInfo( (datReq), mBuf);
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
break;
* free the memory here. */
if(pst->selector == ODU_SELECTOR_LWLC)
{
- retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
- sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY);
+ retVal = SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datReq,
+ sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY);
}
return (retVal);
} /* cmUnpkKwuDatReq */
\f
-#ifdef ANSI
-uint8_t cmUnpkKwuDatIndInfo
-(
-KwuDatIndInfo *param,
-Buffer *mBuf
-)
-#else
-uint8_t cmUnpkKwuDatIndInfo(param, mBuf)
-KwuDatIndInfo *param;
-Buffer *mBuf;
-#endif
+uint8_t cmUnpkKwuDatIndInfo(KwuDatIndInfo *param,Buffer *mBuf)
{
- TRC3(cmUnpkKwuDatIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
#ifdef CCPU_OPT
CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf);
#endif
- CMCHKUNPK(oduPackUInt8, ¶m->isOutOfSeq, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, ¶m->isOutOfSeq, mBuf);
return ROK;
}
\f
-#ifdef ANSI
-uint8_t cmUnpkKwuDatInd
-(
-KwuDatInd func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-uint8_t cmUnpkKwuDatInd(func, pst, mBuf)
-KwuDatInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+uint8_t cmUnpkKwuDatInd(KwuDatInd func,Pst *pst,Buffer *mBuf)
{
S16 ret1 = ROK, retVal;
KwuDatIndInfo *datInd = NULLP;
KwuDatIndInfo datIndTmp;
- TRC3(cmUnpkKwuDatInd)
switch(pst->selector)
{
* doesn't free any memory */
if(pst->dstEnt != ENTPJ)
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datInd,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
* free the memory here. */
if((pst->selector == ODU_SELECTOR_LWLC) && (pst->dstEnt == ENTPJ))
{
- retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
+ retVal = SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
}
return (retVal);
} /* cmUnpkKwuDatInd */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatCfmInfo
-(
-KwuDatCfmInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDatCfmInfo(param, mBuf)
-KwuDatCfmInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDatCfmInfo(KwuDatCfmInfo *param,Buffer *mBuf)
{
register S32 iter;
- TRC3(cmUnpkKwuDatCfmInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(oduPackUInt32, ¶m->numSduIds, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶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(oduPackUInt32, ¶m->sduIds[iter], mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->sduIds[iter], mBuf);
}
return ROK;
}
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatCfm
-(
-KwuDatCfm func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDatCfm(func, pst, mBuf)
-KwuDatCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDatCfm(KwuDatCfm func,Pst *pst,Buffer *mBuf)
{
S16 ret1 = ROK;
SuId suId = 0;
KwuDatCfmInfo *datCfm = NULLP;
- TRC3(cmUnpkKwuDatCfm)
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datCfm,\
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return (ret1);
}
- cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
+ memset(datCfm, 0, sizeof(KwuDatCfmInfo));
ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
} /* cmUnpkKwuDatCfm */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDiscSduReq
-(
-KwuDiscSduReq func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDiscSduReq(func, pst, mBuf)
-KwuDiscSduReq func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDiscSduReq(KwuDiscSduReq func,Pst *pst,Buffer *mBuf)
{
S16 ret1 = ROK;
SpId spId = 0;
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&discSdu,\
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return (ret1);
}
- cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
+ memset(discSdu, 0, sizeof(KwuDiscSduInfo));
ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
} /* cmUnpkKwuDiscSduReq */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuStaIndInfo
-(
-KwuStaIndInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuStaIndInfo(param, mBuf)
-KwuStaIndInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuStaIndInfo(KwuStaIndInfo *param,Buffer *mBuf)
{
- U32 i;
-
- TRC3(cmUnpkKwuStaIndInfo);
+ uint32_t i;
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(oduPackUInt32, ¶m->numSdu, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->numSdu, mBuf);
for (i = 0; i < param->numSdu; i++)
{
- CMCHKUNPK(oduPackUInt32, ¶m->sduId[i], mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->sduId[i], mBuf);
}
return ROK;
} /* cmUnpkKwuStaIndInfo */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuStaInd
-(
-KwuStaInd func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuStaInd(func, pst, mBuf)
-KwuStaInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuStaInd(KwuStaInd func,Pst *pst,Buffer *mBuf)
{
S16 ret1 = ROK;
SuId suId = 0;
KwuStaIndInfo *staInd = NULLP;
- TRC3(cmUnpkKwuStaInd)
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&staInd,\
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return (ret1);
}
- cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
+ memset(staInd, 0, sizeof(KwuStaIndInfo));
ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
} /* cmUnpkKwuStaInd */
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuReEstCmpInd
-(
-KwuReEstCmpInd func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf)
-KwuReEstCmpInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuReEstCmpInd(KwuReEstCmpInd func,Pst *pst,Buffer *mBuf)
{
#if(ERRCLASS & ERRCLS_DEBUG)
S16 ret1;
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)
{
} /* cmUnpkKwuReEstCmpInd */
/* kwu_c_001.main_3 added support for L2 Measurement */
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDiscSduCfm
-(
-KwuDiscSduCfm func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf)
-KwuDiscSduCfm func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDiscSduCfm(KwuDiscSduCfm func,Pst *pst,Buffer *mBuf)
{
S16 ret1 = ROK;
- SpId spId = 0;
+ SpId spId = 0;
KwuDiscSduInfo *discSdu = NULLP;
- TRC3(cmUnpkKwuDiscSduCfm);
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
break;
case ODU_SELECTOR_LC:
{
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&discSdu,\
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
+ memset(discSdu, 0, sizeof(KwuDiscSduInfo));
ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
return ((*func)(pst, spId, discSdu));
} /* cmUnpkKwuDiscSduCfm */
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuFlowCntrlInd
-(
-KwuFlowCntrlInd func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf)
-KwuFlowCntrlInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuFlowCntrlInd(KwuFlowCntrlInd func,Pst *pst,Buffer *mBuf)
{
SuId suId;
KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
-
- TRC3(cmUnpkKwuFlowCntrlInd);
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
switch(pst->selector)
#ifdef LCKWU
case ODU_SELECTOR_LC:
{
- if(SGetStaticBuffer(pst->region,
+ if(SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region,
pst->pool,
(Data **)&flowCntrlInfo,
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
} /* cmUnpkKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatAckInfo
-(
-KwuDatAckInfo *param,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDatAckInfo(param, mBuf)
-KwuDatAckInfo *param;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDatAckInfo(KwuDatAckInfo *param,Buffer *mBuf)
{
- TRC3(cmUnpkKwuDatAckInfo);
- CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->sduId, mBuf);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
}
\f
-#ifdef ANSI
-PUBLIC S16 cmUnpkKwuDatAckInd
-(
-KwuDatAckInd func,
-Pst *pst,
-Buffer *mBuf
-)
-#else
-PUBLIC S16 cmUnpkKwuDatAckInd(func, pst, mBuf)
-KwuDatAckInd func;
-Pst *pst;
-Buffer *mBuf;
-#endif
+S16 cmUnpkKwuDatAckInd(KwuDatAckInd func,Pst *pst,Buffer *mBuf)
{
S16 ret1;
SuId suId = 0;
KwuDatAckInfo *datInd = NULLP;
- TRC3(cmUnpkKwuDatAckInd);
- if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
+ if((ret1 = SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&datInd,\
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
return (ret1);
}
- cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
+ memset(datInd, 0, sizeof(KwuDatAckInfo));
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);