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));
return (SPstTsk(pst,mBuf));
} /* cmPkKwuUbndReq */
-uint8_t cmPkKwuDatReqInfo(KwuDatReqInfo *param,Buffer *mBuf)
+uint8_t cmPkRlcDatReqInfo(RlcDatReqInfo *param,Buffer *mBuf)
{
#ifdef CCPU_OPT
switch(param->lcType) {
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
-uint8_t cmPkKwuDatReq(Pst * pst,KwuDatReqInfo* datReq,Buffer * mBuf)
+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
#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);
}
- memcpy(datReqInfo,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
uint8_t cmPkKwuDatIndInfo(KwuDatIndInfo *param,Buffer *mBuf)
{
- CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
+ CMCHKPK(oduPackUInt8, param->isOutOfSeq, mBuf);
#ifdef CCPU_OPT
CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
#endif
* 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)
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 */
#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);
* 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)
for (i = (param->numSdu - 1); i >= 0; i--)
{
- CMCHKPK(oduUnpackUInt32, param->sduId[(uint16_t)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;
}
S16 cmPkKwuFlowCntrlIndInfo(KwuFlowCntrlIndInfo *param,Buffer *mBuf)
{
- CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
+ CMCHKPK(oduPackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
{
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->pktAdmitCnt, mBuf);
return ROK;
} /* cmUnpkKwuFlowCntrlIndInfo */
#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);
#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);
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)
{
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
+ CMCHKPK(oduPackUInt32, param->sduId, mBuf);
return ROK;
}
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);
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));
} /* cmUnpkKwuUbndReq */
\f
-S16 cmUnpkKwuDatReqInfo(KwuDatReqInfo *param,Buffer *mBuf)
+S16 cmUnpkRlcDatReqInfo(RlcDatReqInfo *param,Buffer *mBuf)
{
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);
S16 ret1 = ROK;
#endif
S16 retVal;
- KwuDatReqInfo *datReq = NULLP;
- KwuDatReqInfo datReqTmp;
+ RlcDatReqInfo *datReq = NULLP;
+ RlcDatReqInfo datReqTmp;
switch(pst->selector)
/* Allocate the memory statically as there is no free
* in RLC */
datReq = &datReqTmp;
- memset(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 */
#ifdef CCPU_OPT
CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf);
#endif
- CMCHKUNPK(oduPackUInt8, ¶m->isOutOfSeq, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, ¶m->isOutOfSeq, mBuf);
return ROK;
}
* 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);
register S32 iter;
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;
}
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)
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)
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;
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)
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)
#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)
S16 cmUnpkKwuDatAckInfo(KwuDatAckInfo *param,Buffer *mBuf)
{
- CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, ¶m->sduId, mBuf);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
return ROK;
KwuDatAckInfo *datInd = NULLP;
- 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)