* 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;
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuBndReq)
mBuf = NULLP;
\f
#ifdef ANSI
-PUBLIC S16 cmPkKwuBndCfm
+S16 cmPkKwuBndCfm
(
Pst * pst,
SuId suId,
U8 status
)
#else
-PUBLIC S16 cmPkKwuBndCfm(pst, suId, status)
+S16 cmPkKwuBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
U8 status;
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuBndCfm)
mBuf = NULLP;
\f
#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;
S16 ret1;
Buffer *mBuf;
- TRC3(cmPkKwuUbndReq)
mBuf = NULLP;
#endif
{
- TRC3(cmPkKwuDatReqInfo);
#ifdef CCPU_OPT
switch(param->lcType) {
#ifndef SS_RBUF
KwuDatReqInfo* datReqInfo;
#endif
- TRC3(cmPkKwuDatReq)
#ifndef SS_RBUF
switch(pst->selector)
{
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
+ memcpy(datReqInfo,datReq,sizeof(KwuDatReqInfo));
CMCHKPK(oduPackPointer,(PTR)datReqInfo, mBuf);
}
else
Buffer *mBuf;
#endif
{
- TRC3(cmPkKwuDatIndInfo);
CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
#ifdef CCPU_OPT
#endif
KwuDatIndInfo *datIndInfo = NULLP;
- TRC3(cmPkKwuDatInd)
#ifdef TENB_SPLIT_ARCH
/* SSI_CHANGES: */
return (ret1);
}
- cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
+ memcpy(datIndInfo, datInd,sizeof(KwuDatIndInfo));
CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf);
}
break;
\f
#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;
- TRC3(cmPkKwuDatCfmInfo);
for(iter = 0; iter < param->numSduIds; iter++)
{
CMCHKPK(oduUnpackUInt32, param->sduIds[iter], mBuf);
\f
#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;
#endif
Buffer *mBuf;
- TRC3(cmPkKwuDatCfm)
mBuf = NULLP;
\f
#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;
Buffer *mBuf;
KwuDiscSduInfo* discSduInfo = NULLP;
- TRC3(cmPkKwuDiscSduReq)
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
return (ret1);
}
- cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
+ memcpy(discSduInfo, discSdu,sizeof(KwuDiscSduInfo));
CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf);
}
break;
\f
#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--)
{
}
#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(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
} /* 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(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
\f
#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;
#endif /* LCKWU */
Buffer *mBuf;
- TRC3(cmPkKwuStaInd)
mBuf = NULLP;
\f
#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;
#endif /* LCKWU */
Buffer *mBuf;
- TRC3(cmPkKwuReEstCmpInd)
mBuf = NULLP;
/* 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;
#endif
Buffer *mBuf;
- TRC3(cmPkKwuDiscSduCfm)
mBuf = NULLP;
} /* cmPkKwuDiscSduCfm */
\f
#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;
{
Buffer *mBuf;
- TRC3(cmPkKwuFlowCntrlInd)
mBuf = NULLP;
#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(oduUnpackUInt32, param->sduId, mBuf);
}
#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;
Buffer *mBuf;
- TRC3(cmPkKwuDatAckInd);
mBuf = NULLP;
\f
#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;
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
+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;
SuId suId = 0;
U8 status = 0;
- TRC3(cmUnpkKwuBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EKWU023, pst);
\f
#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;
SpId spId = 0;
Reason reason = 0;
- TRC3(cmUnpkKwuUbndReq)
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
\f
#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(oduPackUInt32, ¶m->sduId, mBuf);
\f
#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;
KwuDatReqInfo *datReq = NULLP;
KwuDatReqInfo 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(KwuDatReqInfo));
#if(ERRCLASS & ERRCLS_DEBUG)
ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf);
if(ret1 != ROK)
Buffer *mBuf;
#endif
{
- TRC3(cmUnpkKwuDatIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
KwuDatIndInfo *datInd = NULLP;
KwuDatIndInfo datIndTmp;
- TRC3(cmUnpkKwuDatInd)
switch(pst->selector)
{
\f
#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(oduPackUInt32, ¶m->numSduIds, mBuf);
}
#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;
SuId suId = 0;
KwuDatCfmInfo *datCfm = NULLP;
- TRC3(cmUnpkKwuDatCfm)
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
return (ret1);
}
- cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
+ memset(datCfm, 0, sizeof(KwuDatCfmInfo));
ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
\f
#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;
return (ret1);
}
- cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
+ memset(discSdu, 0, sizeof(KwuDiscSduInfo));
ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
\f
#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;
- TRC3(cmUnpkKwuStaIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numSdu, mBuf);
\f
#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;
SuId suId = 0;
KwuStaIndInfo *staInd = NULLP;
- TRC3(cmUnpkKwuStaInd)
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
return (ret1);
}
- cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
+ memset(staInd, 0, sizeof(KwuStaIndInfo));
ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
#if(ERRCLASS & ERRCLS_DEBUG)
\f
#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;
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)
/* 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;
SpId spId = 0;
KwuDiscSduInfo *discSdu = NULLP;
- TRC3(cmUnpkKwuDiscSduCfm);
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
#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
+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;
SuId suId;
KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
- TRC3(cmUnpkKwuFlowCntrlInd);
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
switch(pst->selector)
#ifdef LTE_L2_MEAS
\f
#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(oduPackUInt32, ¶m->sduId, mBuf);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
\f
#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;
SuId suId = 0;
KwuDatAckInfo *datInd = NULLP;
- TRC3(cmUnpkKwuDatAckInd);
if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
return (ret1);
}
- cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
+ memset(datInd, 0, sizeof(KwuDatAckInfo));
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);