__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR001, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR002, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR003, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR004, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR005, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR006, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR007, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR008, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR009, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR010, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR011, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR012, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR013, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR014, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR015, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR021, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR022, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR023, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR024, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, transId, cfgReqInfo));
+ return ((*func)(pst, transId, cfgReqInfo));
}
/* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
#endif
{
TRC3(cmPkRgrTtiInd)
- CMCHKPK(SPkU16, param->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
TRC3(cmUnpkRgrTtiIndInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sfn, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
+ return ROK;
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR025, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
pst->event = (Event) EVTRGRTTIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR028, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK)
{
(ErrVal)ERGR029, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR030, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, ttiInd));
+ return ((*func)(pst, suId, ttiInd));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR031, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR032, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR033, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTMACSCHCFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR036, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR037, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, transId, status));
+ return ((*func)(pst, transId, status));
}
/* rgr_c_001.main_4: ADD-Added for SI Enhancement. */
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR038, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR039, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR040, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR041, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRSICFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR042, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR043, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR044, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, status));
+ return ((*func)(pst, suId, transId, status));
}
#endif/*RGR_SI_SCH*/
TRC3(cmPkRgrCfgTransId)
for (i=RGR_CFG_TRANSID_SIZE-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->trans[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrCfgTransId)
for (i=0; i<RGR_CFG_TRANSID_SIZE; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->trans[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrDlHqCfg)
- CMCHKPK(SPkU8, param->maxMsg4HqTx, mBuf);
- CMCHKPK(SPkU8, param->maxDlHqTx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->maxMsg4HqTx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxDlHqTx, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrDlHqCfg)
- CMCHKUNPK(SUnpkU8, ¶m->maxDlHqTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxMsg4HqTx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxDlHqTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxMsg4HqTx, mBuf);
+ return ROK;
}
TRC3(cmPkRgrRntiCfg)
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->startRnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->startRnti, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
TRC3(cmPkRgrEmtcRntiCfg)
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->rntiCeModeBRange, mBuf);
CMCHKPK(cmPkLteRnti, param->rntiCeModeBStart, mBuf);
CMCHKPK(cmPkLteRnti, param->rntiCeModeARange, mBuf);
CMCHKPK(cmPkLteRnti, param->rntiCeModeAStart, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeARange, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeBStart, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rntiCeModeBRange, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
TRC3(cmPkRgrDlCmnCodeRateCfg)
- CMCHKPK(SPkU8, param->ccchCqi, mBuf);
- CMCHKPK(SPkU16, param->pdcchCodeRate, mBuf);
- CMCHKPK(SPkU16, param->bcchPchRaCodeRate, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pdcchCodeRate, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->bcchPchRaCodeRate, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrDlCmnCodeRateCfg)
- CMCHKUNPK(SUnpkU16, ¶m->bcchPchRaCodeRate, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pdcchCodeRate, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ccchCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->bcchPchRaCodeRate, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pdcchCodeRate, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ccchCqi, mBuf);
+ return ROK;
}
TRC3(cmPkRgrCfiCfg)
- CMCHKPK(SPkU8, param->cfi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrCfiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->cfi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfi, mBuf);
+ return ROK;
}
TRC3(cmPkRgrPuschSubBandCfg)
for (i=param->numSubbands-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->dmrs[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dmrs[i], mBuf);
}
- CMCHKPK(SPkU8, param->size, mBuf);
- CMCHKPK(SPkU8, param->numSubbands, mBuf);
- CMCHKPK(SPkU8, param->subbandStart, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubbands, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->subbandStart, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgrPuschSubBandCfg)
- CMCHKUNPK(SUnpkU8, ¶m->subbandStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubbands, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->subbandStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubbands, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->size, mBuf);
for (i=0; i<param->numSubbands; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->dmrs[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dmrs[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUlCmnCodeRateCfg)
- CMCHKPK(SPkU8, param->ccchCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUlCmnCodeRateCfg)
- CMCHKUNPK(SUnpkU8, ¶m->ccchCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ccchCqi, mBuf);
+ return ROK;
}
TRC3(cmPkRgrUlTrgCqiCfg)
- CMCHKPK(SPkU8, param->trgCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUlTrgCqiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->trgCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->trgCqi, mBuf);
+ return ROK;
}
TRC3(cmPkRgrBwCfg)
- CMCHKPK(SPkU8, param->ulTotalBw, mBuf);
- CMCHKPK(SPkU8, param->dlTotalBw, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmPkRgrEmtcSiCfg)
- CMCHKPK(SPkU8, param->siHoppingEnable, mBuf);
- CMCHKPK(SPkU32, param->modPrd, mBuf);
- CMCHKPK(SPkU8, param->siWinSizeBr, mBuf);
- CMCHKPK(SPkU8, param->sib1Repetition, mBuf);
- CMCHKPK(SPkU8, param->siRepetition, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->siHoppingEnable, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->modPrd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->siWinSizeBr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sib1Repetition, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->siRepetition, mBuf);
- CMCHKPK(SPkU16, param->startSymbolLc, mBuf);
- //CMCHKPK(SPkU8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->startSymbolLc, mBuf);
+ //CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
/*Changes by SIMRAN*/
if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
{
- CMCHKPK(SPkU16, param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
}
else
{
//CMCHKPK(SPkU64,param->fddDLOrTddSfBitmapLC.u.ptn40, mBuf);
for (i=0; i<2; i++) {
- CMCHKPK(SPkU32, param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
}
}
- CMCHKPK(SPkU8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
- //CMCHKPK(SPkU16, param->fddDlOrTddSfBitmapBR, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
+ //CMCHKPK(oduUnpackUInt16, param->fddDlOrTddSfBitmapBR, mBuf);
for (i= (param->numSi-1); i >= 0; i--) {
- CMCHKPK(SPkU8, param->schdInfo[i].emtcSiNarrowBand, mBuf);
- CMCHKPK(SPkU16, param->schdInfo[i].emtcSiTbs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->schdInfo[i].emtcSiNarrowBand, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->schdInfo[i].emtcSiTbs, mBuf);
}
for (i= (param->numSi-1); i >= 0; i--) {
- CMCHKPK(SPkU32, param->siPeriodicity[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->siPeriodicity[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmPkRgrEmtcRachCfg)
- CMCHKPK(SPkU8, param->emtcCeLvlSupported, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcCeLvlSupported, mBuf);
for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcRarHopping, mBuf);
- CMCHKPK(SPkU16, param->ceLevelInfo[i].raEmtcWinSize, mBuf);
- CMCHKPK(SPkU16, param->ceLevelInfo[i].raEmtcContResTmr, mBuf);
- CMCHKPK(SPkU16, param->ceLevelInfo[i].emtcPreambleTransMax, mBuf);
- CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcPreambleMap.firstPreamble, mBuf);
- CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcPreambleMap.lastPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcRarHopping, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcWinSize, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcContResTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].emtcPreambleTransMax, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.firstPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.lastPreamble, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmPkRgrEmtcPdschCfg)
- CMCHKPK(SPkU16, param->emtcMaxRepCeModeA, mBuf);
- CMCHKPK(SPkU16, param->emtcMaxRepCeModeB, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
#endif
{
TRC3(cmPkRgrEmtcPuschCfg)
- CMCHKPK(SPkU16, param->emtcMaxRepCeModeA, mBuf);
- CMCHKPK(SPkU16, param->emtcMaxRepCeModeB, mBuf);
- CMCHKPK(SPkU8, param->emtcHoppingOffset, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcHoppingOffset, mBuf);
+ return ROK;
}
TRC3(cmPkRgrEmtcPucchCfg)
for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
- CMCHKPK(SPkU16, param->emtcN1pucchAnInfoLst[i], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcN1pucchAnInfoLst[i], mBuf);
}
- CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
- CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
- CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
- CMCHKPK(SPkU8, param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
TRC3(cmPkRgrEmtcPrachCeParamCfg)
- CMCHKPK(SPkU8, param->emtcPrachCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->emtcPrachFreqOffset, mBuf);
- CMCHKPK(SPkU16, param->emtcPrachStartSubFrame, mBuf);
- CMCHKPK(SPkU8, param->emtcMaxPremAttemptCE, mBuf);
- CMCHKPK(SPkU8, param->emtcNumRepPerPreambleAtt, mBuf);
- CMCHKPK(SPkU8, param->emtcNumMpdcchNBtoMonitor, mBuf);
- CMCHKPK(SPkU8, param->emtcMpdcchNBtoMonitor[0], mBuf);
- CMCHKPK(SPkU8, param->emtcMpdcchNBtoMonitor[1], mBuf);
- CMCHKPK(SPkU16, param->emtcMpdcchNumRep, mBuf);
- CMCHKPK(SPkU8, param->emtcPrachHoppingCfg, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->emtcPrachCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPrachFreqOffset, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcPrachStartSubFrame, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcMaxPremAttemptCE, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcNumRepPerPreambleAtt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcNumMpdcchNBtoMonitor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNBtoMonitor[0], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNBtoMonitor[1], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcMpdcchNumRep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPrachHoppingCfg, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmPkRgrEmtcPrachCfg)
- CMCHKPK(SPkU8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
- CMCHKPK(SPkU8, param->emtcPrachHopingOffset, mBuf);
- CMCHKPK(SPkU8, param->emtcInitialCElevel, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPrachHopingOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcInitialCElevel, mBuf);
for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
CMCHKPK(cmPkRgrEmtcPrachCeParamCfg, ¶m->emtcPrachCEparmLst[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
TRC3(cmPkRgrEmtcCfg)
- CMCHKPK(SPkU16, param->pci, mBuf);
- CMCHKPK(SPkU32, param->emtcT300Tmr, mBuf);
- CMCHKPK(SPkU32, param->emtcT301Tmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->emtcT300Tmr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->emtcT301Tmr, mBuf);
CMCHKPK(cmPkRgrEmtcSiCfg, ¶m->emtcSiCfg, mBuf);
CMCHKPK(cmPkRgrEmtcRachCfg, ¶m->emtcRachCfg, mBuf);
CMCHKPK(cmPkRgrEmtcPdschCfg, ¶m->emtcPdschCfg, mBuf);
CMCHKPK(cmPkRgrEmtcPrachCfg, ¶m->emtcPrachCfg, mBuf);
CMCHKPK(cmPkRgrEmtcPucchCfg, ¶m->emtcPucchCfg, mBuf);
CMCHKPK(cmPkRgrEmtcRntiCfg, ¶m->emtcMacRnti, mBuf);
- CMCHKPK(SPkU8, param->emtcPdschNbIdx, mBuf);
- CMCHKPK(SPkU8, param->emtcMpdcchNbIdx, mBuf);
- CMCHKPK(SPkU8, param->emtcPuschNbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPdschNbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcPuschNbIdx, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* EMTC related pack changes end*/
S32 i;
U32 tmpEnum;
TRC3(cmUnpkRgrEmtcSiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->numSi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
for (i=0; i < param->numSi ; i++) {
- CMCHKUNPK(SUnpkU32,(U32*)&tmpEnum,mBuf);
+ CMCHKUNPK(oduPackUInt32,(U32*)&tmpEnum,mBuf);
param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
}
for (i=0; i < param->numSi ; i++) {
- CMCHKUNPK(SUnpkU16, ¶m->schdInfo[i].emtcSiTbs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->schdInfo[i].emtcSiNarrowBand, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->schdInfo[i].emtcSiTbs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->schdInfo[i].emtcSiNarrowBand, mBuf);
}
- //CMCHKUNPK(SUnpkU16, ¶m->fddDlOrTddSfBitmapBR, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
+ //CMCHKUNPK(oduPackUInt16, ¶m->fddDlOrTddSfBitmapBR, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
/*Changes by SIMRAN*/
if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
{
- CMCHKUNPK(SUnpkU16, ¶m->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
}
else
{
for (i=1; i>=0; i--) {
- CMCHKUNPK(SUnpkU32, ¶m->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
}
}
- CMCHKUNPK(SUnpkU16, ¶m->startSymbolLc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->siRepetition, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sib1Repetition, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->siWinSizeBr, mBuf);
- CMCHKUNPK(SUnpkU32, (U32*)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->startSymbolLc, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->siRepetition, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sib1Repetition, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->siWinSizeBr, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)&tmpEnum, mBuf);
param->modPrd = (RgrModPeriodicity) tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->siHoppingEnable, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->siHoppingEnable, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgrEmtcRachCfg)
for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
- CMCHKUNPK(SUnpkU8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
- CMCHKUNPK(SUnpkU16, &(param->ceLevelInfo[i].emtcPreambleTransMax), mBuf);
- CMCHKUNPK(SUnpkU16, &(param->ceLevelInfo[i].raEmtcContResTmr), mBuf);
- CMCHKUNPK(SUnpkU16, &(param->ceLevelInfo[i].raEmtcWinSize), mBuf);
- CMCHKUNPK(SUnpkU8,&(param->ceLevelInfo[i].emtcRarHopping), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].emtcPreambleTransMax), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcContResTmr), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcWinSize), mBuf);
+ CMCHKUNPK(oduPackUInt8,&(param->ceLevelInfo[i].emtcRarHopping), mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->emtcCeLvlSupported, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcCeLvlSupported, mBuf);
+ return ROK;
}
{
TRC3(cmUnpkRgrEmtcPdschCfg)
- CMCHKUNPK(SUnpkU16, ¶m->emtcMaxRepCeModeB, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->emtcMaxRepCeModeA, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeB, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeA, mBuf);
+ return ROK;
}
#ifdef ANSI
#endif
{
TRC3(cmUnpkRgrEmtcPuschCfg)
- CMCHKUNPK(SUnpkU8, ¶m->emtcHoppingOffset, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->emtcMaxRepCeModeB, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->emtcMaxRepCeModeA, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcHoppingOffset, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeB, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcMaxRepCeModeA, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrEmtcPucchCfg)
- CMCHKUNPK(SUnpkU8, ¶m->emtcPucchNumRepCEMsg4Lvl3, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPucchNumRepCEMsg4Lvl2, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPucchNumRepCEMsg4Lvl1, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPucchNumRepCEMsg4Lvl0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl3, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl2, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl1, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPucchNumRepCEMsg4Lvl0, mBuf);
for (i=0; i < RGR_MAX_CE_LEVEL ; i++) {
- CMCHKUNPK(SUnpkU16, ¶m->emtcN1pucchAnInfoLst[i], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcN1pucchAnInfoLst[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
TRC3(cmUnpkRgrEmtcPrachCeParamCfg)
- CMCHKUNPK(SUnpkU8, ¶m->emtcPrachHoppingCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->emtcMpdcchNumRep, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcMpdcchNBtoMonitor[1], mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcMpdcchNBtoMonitor[0], mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcNumMpdcchNBtoMonitor, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcNumRepPerPreambleAtt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcMaxPremAttemptCE, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->emtcPrachStartSubFrame, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPrachFreqOffset, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPrachCfgIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPrachHoppingCfg, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcMpdcchNumRep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNBtoMonitor[1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNBtoMonitor[0], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcNumMpdcchNBtoMonitor, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcNumRepPerPreambleAtt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcMaxPremAttemptCE, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->emtcPrachStartSubFrame, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPrachFreqOffset, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPrachCfgIdx, mBuf);
+ return ROK;
}
for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
CMCHKUNPK(cmUnpkRgrEmtcPrachCeParamCfg, ¶m->emtcPrachCEparmLst[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->emtcInitialCElevel, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPrachHopingOffset, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcMpdcchStartSFCssRaFdd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcInitialCElevel, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPrachHopingOffset, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchStartSFCssRaFdd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
{
TRC3(cmUnpkRgrEmtcCfg)
- CMCHKUNPK(SUnpkU8, ¶m->emtcPuschNbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcMpdcchNbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcPdschNbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPuschNbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcMpdcchNbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcPdschNbIdx, mBuf);
CMCHKUNPK(cmUnpkRgrEmtcRntiCfg, ¶m->emtcMacRnti, mBuf);
CMCHKUNPK(cmUnpkRgrEmtcPucchCfg, ¶m->emtcPucchCfg, mBuf);
CMCHKUNPK(cmUnpkRgrEmtcPrachCfg, ¶m->emtcPrachCfg, mBuf);
CMCHKUNPK(cmUnpkRgrEmtcPdschCfg, ¶m->emtcPdschCfg, mBuf);
CMCHKUNPK(cmUnpkRgrEmtcRachCfg, ¶m->emtcRachCfg, mBuf);
CMCHKUNPK(cmUnpkRgrEmtcSiCfg, ¶m->emtcSiCfg, mBuf);
- CMCHKUNPK(SUnpkU32,¶m->emtcT301Tmr, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->emtcT300Tmr, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pci, mBuf);
+ CMCHKUNPK(oduPackUInt32,¶m->emtcT301Tmr, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->emtcT300Tmr, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pci, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* EMTC related unpack changes end*/
TRC3(cmUnpkRgrBwCfg)
- CMCHKUNPK(SUnpkU8, ¶m->dlTotalBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulTotalBw, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlTotalBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulTotalBw, mBuf);
+ return ROK;
}
TRC3(cmPkRgrPhichCfg)
- CMCHKPK(SPkU8, param->isDurExtend, mBuf);
- CMCHKPK(SPkU32, param->ngEnum, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isDurExtend, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ngEnum, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrPhichCfg)
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ngEnum = (RgrPhichNg) tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->isDurExtend, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDurExtend, mBuf);
+ return ROK;
}
TRC3(cmPkRgrPucchCfg)
- CMCHKPK(SPkU8, param->maxPucchRb, mBuf);
- CMCHKPK(SPkU8, param->cyclicShift, mBuf);
- CMCHKPK(SPkU8, param->deltaShift, mBuf);
- CMCHKPK(SPkU16, param->n1PucchAn, mBuf);
- CMCHKPK(SPkU8, param->resourceSize, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxPucchRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cyclicShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->deltaShift, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->n1PucchAn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resourceSize, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrPucchCfg)
- CMCHKUNPK(SUnpkU8, ¶m->resourceSize, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->n1PucchAn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->deltaShift, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cyclicShift, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxPucchRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resourceSize, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->n1PucchAn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->deltaShift, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cyclicShift, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxPucchRb, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrSrsCfg)
- CMCHKPK(SPkU8, param->srsSubFrameCfg, mBuf);
- CMCHKPK(SPkU32, param->srsBwEnum, mBuf);
- CMCHKPK(SPkU32, param->srsCfgPrdEnum, mBuf);
- CMCHKPK(SPkU8, param->isSrsCfgSetup, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->srsSubFrameCfg, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsBwEnum, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsCfgPrdEnum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSrsCfgSetup, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrSrsCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isSrsCfgSetup, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSrsCfgSetup, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->srsCfgPrdEnum = (RgrSrsCfgPrd) tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->srsBwEnum = (RgrSrsBwCfg) tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->srsSubFrameCfg, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSubFrameCfg, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmPkRgrRachCfg)
- CMCHKPK(SPkU8, param->prachResource, mBuf);
- CMCHKPK(SPkU16, param->msgSizeGrpA, mBuf);
- CMCHKPK(SPkU8, param->sizeRaPreambleGrpA, mBuf);
- CMCHKPK(SPkU8, param->numRaPreamble, mBuf);
- CMCHKPK(SPkU8, param->maxMsg3Tx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachResource, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->msgSizeGrpA, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sizeRaPreambleGrpA, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRaPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
for (i=param->raOccasion.size-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->raOccasion.subFrameNum[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->raOccasion.subFrameNum[i], mBuf);
}
- CMCHKPK(SPkU32, param->raOccasion.sfnEnum, mBuf);
- CMCHKPK(SPkU8, param->raOccasion.size, mBuf);
- CMCHKPK(SPkU8, param->raWinSize, mBuf);
- CMCHKPK(SPkU8, param->preambleFormat, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->raOccasion.sfnEnum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->raOccasion.size, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->raWinSize, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->preambleFormat, mBuf);
#ifdef RGR_V1
/* rgr_c_001.main_5: cccpu00112372: Added contention resolution
* timer configuration */
- CMCHKPK(SPkU8, param->contResTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->contResTmr, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef RGR_V1
/* rgr_c_001.main_5: cccpu00112372: Added contention resolution
* timer configuration */
- CMCHKUNPK(SUnpkU8, ¶m->contResTmr, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->contResTmr, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->preambleFormat, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->raWinSize, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->raOccasion.size, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->preambleFormat, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->raWinSize, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->raOccasion.size, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->raOccasion.sfnEnum = (RgrRaSfn) tmpEnum;
for (i=0; i<param->raOccasion.size; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->raOccasion.subFrameNum[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->raOccasion.subFrameNum[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->maxMsg3Tx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRaPreamble, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sizeRaPreambleGrpA, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->msgSizeGrpA, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachResource, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxMsg3Tx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRaPreamble, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sizeRaPreambleGrpA, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->msgSizeGrpA, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachResource, mBuf);
+ return ROK;
}
for (idx=param->numSi-1; idx >= 0; idx--) {
/* Enum to be packed/unpacked as U32 instead of S32 */
- CMCHKPK(SPkU32, param->siPeriodicity[idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->siPeriodicity[idx], mBuf);
}
- CMCHKPK(SPkU8, param->numSi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
/*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
- CMCHKPK(SPkU32, (U32)param->modPrd, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->modPrd, mBuf);
#endif/*RGR_SI_SCH*/
- CMCHKPK(SPkU8, param->retxCnt, mBuf);
- CMCHKPK(SPkU8, param->siWinSize, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->retxCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->siWinSize, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrSiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->siWinSize, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->retxCnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->siWinSize, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->retxCnt, mBuf);
#ifdef RGR_SI_SCH
/*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->modPrd = (RgrModPeriodicity) tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->numSi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
if(param->numSi > sizeof(param->siPeriodicity)/
sizeof(param->siPeriodicity[0]))
/* Enum to be packed/unpacked as U32 instead of S32 */
for (idx=0; idx < param->numSi; idx++) {
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->siPeriodicity[idx] = (RgrSiPeriodicity) tmpEnum;
}
#endif/*RGR_SI_SCH*/
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrTpcRntiCfg)
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
CMCHKPK(cmPkLteRnti, param->startTpcRnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrTpcRntiCfg)
CMCHKUNPK(cmUnpkLteRnti, ¶m->startTpcRnti, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ return ROK;
}
CMCHKPK(cmPkRgrTpcRntiCfg, ¶m->pucchPwrFmt3, mBuf);
CMCHKPK(SPkS8, param->deltaPreambleMsg3, mBuf);
CMCHKPK(SPkS8, param->p0NominalPucch, mBuf);
- CMCHKPK(SPkU32, param->alpha, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->alpha, mBuf);
CMCHKPK(SPkS8, param->p0NominalPusch, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrUlPwrCfg)
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPusch, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->alpha = (RgrPwrAlpha) tmpEnum;
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPucch, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->deltaPreambleMsg3, mBuf);
CMCHKUNPK(cmUnpkRgrTpcRntiCfg, ¶m->pucchPwrFmt3a, mBuf);
CMCHKUNPK(cmUnpkRgrTpcRntiCfg, ¶m->puschPwrFmt3, mBuf);
CMCHKUNPK(cmUnpkRgrTpcRntiCfg, ¶m->puschPwrFmt3a, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrPuschCfg)
- CMCHKPK(SPkU8, param->hopOffst, mBuf);
- CMCHKPK(SPkU8, param->isIntraHop, mBuf);
- CMCHKPK(SPkU8, param->numSubBands, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->hopOffst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isIntraHop, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubBands, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrPuschCfg)
- CMCHKUNPK(SUnpkU8, ¶m->numSubBands, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isIntraHop, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hopOffst, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubBands, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isIntraHop, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hopOffst, mBuf);
+ return ROK;
}
TRC3(cmPkRgrCodeBookRstCfg)
for (i=1-1; i >= 0; i--) {
- CMCHKPK(SPkU32, param->pmiBitMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pmiBitMap[i], mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgrCodeBookRstCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
for (i=0; i<1; i++) {
- CMCHKUNPK(SUnpkU32, ¶m->pmiBitMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->pmiBitMap[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrPreambleSetCfg)
- CMCHKPK(SPkU8, param->size, mBuf);
- CMCHKPK(SPkU8, param->start, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->start, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrPreambleSetCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->start, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->size, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->start, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->size, mBuf);
+ return ROK;
}
TRC3(cmPkRgrCmnLchCfg)
- CMCHKPK(SPkU8, param->ulTrchType, mBuf);
- CMCHKPK(SPkU8, param->dlTrchType, mBuf);
- CMCHKPK(SPkU8, param->dir, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dir, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlTrchType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulTrchType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dir, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlTrchType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulTrchType, mBuf);
+ return ROK;
}
TRC3(cmPkRgrDlfsCfg)
- CMCHKPK(SPkU8, param->thresholdCqi, mBuf);
- CMCHKPK(SPkU8, param->isDlFreqSel, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->thresholdCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isDlFreqSel, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrDlfsCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isDlFreqSel, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->thresholdCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDlFreqSel, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->thresholdCqi, mBuf);
+ return ROK;
}
TRC3(cmPkRgrTddPrachInfo)
- CMCHKPK(SPkU8, param->ulStartSfIdx, mBuf);
- CMCHKPK(SPkU8, param->halfFrm, mBuf);
- CMCHKPK(SPkU32, param->sfn, mBuf);
- CMCHKPK(SPkU8, param->freqIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ulStartSfIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->halfFrm, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->freqIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrTddPrachInfo)
- CMCHKUNPK(SUnpkU8, ¶m->freqIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->freqIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->sfn = tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->halfFrm, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulStartSfIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->halfFrm, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulStartSfIdx, mBuf);
+ return ROK;
}
for (i=param->numRsc-1; i >= 0; i--) {
CMCHKPK(cmPkRgrTddPrachInfo, ¶m->prachInfo[i], mBuf);
}
- CMCHKPK(SPkU8, param->numRsc, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numRsc, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgrTddPrachRscInfo)
- CMCHKUNPK(SUnpkU8, ¶m->numRsc, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRsc, mBuf);
for (i=0; i<param->numRsc; i++) {
CMCHKUNPK(cmUnpkRgrTddPrachInfo, ¶m->prachInfo[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrEnbPfs)
for(idx = RGR_MAX_NUM_QCI-1; idx >= 0; idx--)
{
- CMCHKPK(SPkU32, param->qciWgt[idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->qciWgt[idx], mBuf);
}
- CMCHKPK(SPkU8, param->fairCoeffi, mBuf);
- CMCHKPK(SPkU8, param->tptCoeffi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->fairCoeffi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tptCoeffi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
S32 idx;
TRC3(cmUnpkRgrEnbPfs)
- CMCHKUNPK(SUnpkU8, ¶m->tptCoeffi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->fairCoeffi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tptCoeffi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->fairCoeffi, mBuf);
for(idx = 0; idx < RGR_MAX_NUM_QCI; idx++)
{
- CMCHKUNPK(SUnpkU32, ¶m->qciWgt[idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->qciWgt[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/*rgr_c_001.main_7 - Added support for SPS*/
{
TRC3(cmPkRgrSpsCellCfg)
- CMCHKPK(SPkU16, param->maxSpsUePerUlSf, mBuf);
- CMCHKPK(SPkU16, param->maxSpsUePerDlSf, mBuf);
- CMCHKPK(SPkU8, param->maxSpsDlBw, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->maxSpsUePerUlSf, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->maxSpsUePerDlSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxSpsDlBw, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrSpsDlCellCfg)
- CMCHKUNPK(SUnpkU8, ¶m->maxSpsDlBw, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->maxSpsUePerDlSf, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->maxSpsUePerUlSf, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxSpsDlBw, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->maxSpsUePerDlSf, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->maxSpsUePerUlSf, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef RG_5GTF
for (idx = MAX_5GTF_SUBFRAME_INFO - 1; idx >= 0 ;--idx)
{
- CMCHKPK(SPkU32, param->dynConfig[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dynConfig[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->uePerGrp, mBuf);
- CMCHKPK(SPkU8, param->ueGrpPerTti, mBuf);
- CMCHKPK(SPkU8, param->numUes, mBuf);
- CMCHKPK(SPkU8, param->numOfCC, mBuf);
- CMCHKPK(SPkU8, param->bwPerCC, mBuf);
- CMCHKPK(SPkU8, param->cfi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->uePerGrp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ueGrpPerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numUes, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numOfCC, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->bwPerCC, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
+ return ROK;
}
PUBLIC S16 cmUnPkRgr5gtfCellCfg
{
S8 idx = 0;
- CMCHKUNPK(SUnpkU8, ¶m->cfi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bwPerCC, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numOfCC, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numUes, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ueGrpPerTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->uePerGrp, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bwPerCC, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numOfCC, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numUes, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueGrpPerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->uePerGrp, mBuf);
for (idx = 0; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
{
- CMCHKUNPK(SUnpkU32, ¶m->dynConfig[(U8)idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->dynConfig[(U8)idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
TRC3(cmPkRgrlteUCellCfg)
- CMCHKPK(SPkU8, param->isLaaCell, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isLaaCell, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkRgrLteUCellCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isLaaCell, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLaaCell, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_START */
{
TRC3(cmPkRgrLteAdvancedUeConfig)
- CMCHKPK(SPkU8, param->isUeCellEdge, mBuf);
- CMCHKPK(SPkU8, param->isAbsUe, mBuf);
- CMCHKPK(SPkU32, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isUeCellEdge, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAbsUe, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
+ return ROK;
}
/***********************************************************
{
TRC3(cmUnpkRgrLteAdvancedUeConfig)
- CMCHKUNPK(SUnpkU32, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isAbsUe, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isUeCellEdge, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAbsUe, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isUeCellEdge, mBuf);
+ return ROK;
}
/***********************************************************
S8 indx = 0;
TRC3(cmPkRgrAbsConfig)
- CMCHKPK(SPkU32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--)
{
- CMCHKPK(SPkU8, param->absPattern[(U8)indx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->absPattern[(U8)indx], mBuf);
}
- CMCHKPK(SPkU32, param->absPatternType, mBuf);
- CMCHKPK(SPkU32, param->absLoadPeriodicity, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->absPatternType, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->absLoadPeriodicity, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
TRC3(cmPkRgrSfrConfig)
- CMCHKPK(SPkU32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU32, param->pwrThreshold.pHigh, mBuf);
- CMCHKPK(SPkU32, param->pwrThreshold.pLow, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pHigh, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pLow, mBuf);
#endif
- CMCHKPK(SPkU8, param->cellEdgeRbRange.endRb, mBuf);
- CMCHKPK(SPkU8, param->cellEdgeRbRange.startRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.endRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.startRb, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmPkRgrDsfrConfig)
- CMCHKPK(SPkU32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmUnpkRgrDsfrConfig)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->status, mBuf);
+ return ROK;
}
{
TRC3(cmPkRgrCellLteAdvancedFeatureCfg)
- CMCHKPK(SPkU32, param->pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
CMCHKPK(cmPkRgrDsfrConfig, ¶m->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
CMCHKPK(cmPkRgrSfrConfig, ¶m->sfrCfg, mBuf);
CMCHKPK(cmPkRgrAbsConfig, ¶m->absCfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
S8 indx = 0;
TRC3(cmUnpkRgrAbsConfig)
- CMCHKUNPK(SUnpkU32, ¶m->absLoadPeriodicity, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->absPatternType, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->absLoadPeriodicity, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->absPatternType, mBuf);
for (indx = 0; indx <RGR_ABS_PATTERN_LEN; indx++)
{
- CMCHKUNPK(SUnpkU8, ¶m->absPattern[(U8)indx], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->absPattern[(U8)indx], mBuf);
}
- CMCHKUNPK(SUnpkU32, (U32*)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)¶m->status, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrSfrConfig)
- CMCHKUNPK(SUnpkU8, ¶m->cellEdgeRbRange.startRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cellEdgeRbRange.endRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.startRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.endRb, mBuf);
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU32, (U32*)¶m->pwrThreshold.pLow, mBuf);
- CMCHKUNPK(SUnpkU32, (U32*)¶m->pwrThreshold.pHigh, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)¶m->pwrThreshold.pLow, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)¶m->pwrThreshold.pHigh, mBuf);
#endif
- CMCHKUNPK(SUnpkU32, (U32*)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)¶m->status, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKUNPK(cmUnpkRgrAbsConfig, ¶m->absCfg, mBuf);
CMCHKUNPK(cmUnpkRgrSfrConfig, ¶m->sfrCfg, mBuf);
CMCHKUNPK(cmUnpkRgrDsfrConfig, ¶m->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
- CMCHKUNPK(SUnpkU32, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_END */
{
TRC3(cmPkMacSchedGnbCfg)
- CMCHKPK(SPkU8, param->maxDlUePerTti, mBuf);
- CMCHKPK(SPkU8, param->maxUlUePerTti, mBuf);
- CMCHKPK(SPkU8, param->numCells, mBuf);
- CMCHKPK(SPkU8, param->dlSchdType, mBuf);
- CMCHKPK(SPkU8, param->ulSchdType, mBuf);
- CMCHKPK(SPkU8, param->numTxAntPorts, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->maxDlUePerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxUlUePerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlSchdType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulSchdType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numTxAntPorts, mBuf);
+ return ROK;
} /* cmPkRgrSchedEnbCfg */
/***********************************************************
TRC3(cmUnpkMacSchedGnbCfg)
- CMCHKUNPK(SUnpkU8, ¶m->numTxAntPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulSchdType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlSchdType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCells, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxUlUePerTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxDlUePerTti, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->numTxAntPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulSchdType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlSchdType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUlUePerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxDlUePerTti, mBuf);
+ return ROK;
} /* cmUnpkMacSchedGnbCfg */
\f
CMCHKPK(cmPkRgr5gtfCellCfg, ¶m->Cell5gtfCfg, mBuf);
#endif
#ifdef LTE_ADV
- CMCHKPK(SPkU8, param->isPucchFormat3Sptd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPucchFormat3Sptd, mBuf);
#endif
/*LAA: Pack LAA params*/
CMCHKPK(cmPkRgrLteUCellCfg, ¶m->lteUCfg, mBuf);
- CMCHKPK(SPkU32, param->msg4pAVal, mBuf);
- CMCHKPK(SPkU8, param->isAutoCfgModeEnb, mBuf);
- CMCHKPK(SPkU8, param->isDynCfiEnb, mBuf);
- CMCHKPK(SPkU16, param->phichTxPwrOffset, mBuf);
- CMCHKPK(SPkU16, param->rarTxPwrOffset, mBuf);
- CMCHKPK(SPkU16, param->pcchTxPwrOffset, mBuf);
- CMCHKPK(SPkU16, param->bcchTxPwrOffset, mBuf);
-
- CMCHKPK(SPkU16, param->t300TmrVal, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->msg4pAVal, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->phichTxPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rarTxPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pcchTxPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->bcchTxPwrOffset, mBuf);
+
+ CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKPK(cmPkRgrSpsCellCfg, ¶m->spsCfg, mBuf);
/* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
- CMCHKPK(SPkU8, param->rrmTtiIndPrd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rrmTtiIndPrd, mBuf);
#ifdef LTE_TDD
CMCHKPK(cmPkRgrTddPrachRscInfo, ¶m->prachRscInfo, mBuf);
- CMCHKPK(SPkU8, param->spclSfCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->ulDlCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->spclSfCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulDlCfgIdx, mBuf);
#endif
CMCHKPK(cmPkRgrCellCsgParamCfg, ¶m->csgParamCfg, mBuf);
for (i=param->numCmnLcs-1; i >= 0; i--) {
CMCHKPK(cmPkRgrCmnLchCfg, ¶m->cmnLcCfg[i], mBuf);
}
- CMCHKPK(SPkU8, param->numCmnLcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCmnLcs, mBuf);
CMCHKPK(cmPkRgrPreambleSetCfg, ¶m->macPreambleSet, mBuf);
CMCHKPK(cmPkRgrPuschCfg, ¶m->puschCfg, mBuf);
CMCHKPK(cmPkRgrUlPwrCfg, ¶m->pwrCfg, mBuf);
CMCHKPK(cmPkRgrCfiCfg, ¶m->cfiCfg, mBuf);
CMCHKPK(cmPkRgrRntiCfg, ¶m->macRnti, mBuf);
CMCHKPK(cmPkRgrDlHqCfg, ¶m->dlHqCfg, mBuf);
- CMCHKPK(SPkU8, param->dlfsSchdType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlfsSchdType, mBuf);
CMCHKPK(SPkS8, param->pMax, mBuf);
- CMCHKPK(SPkU8, param->cellModSchm, mBuf);
- CMCHKPK(SPkU8, param->isCpDlExtend, mBuf);
- CMCHKPK(SPkU8, param->isCpUlExtend, mBuf);
- CMCHKPK(SPkU8, param->maxUlUeNewTxPerTti, mBuf);
- CMCHKPK(SPkU8, param->maxDlUeNewTxPerTti, mBuf);
- CMCHKPK(SPkU8, param->maxDlRetxBw, mBuf);
- CMCHKPK(SPkU8, param->maxDlBwPerUe, mBuf);
- CMCHKPK(SPkU8, param->maxUlBwPerUe, mBuf);
- CMCHKPK(SPkU8, param->maxCcchPerDlSf, mBuf);
- CMCHKPK(SPkU8, param->maxUePerDlSf, mBuf);
- CMCHKPK(SPkU8, param->maxUePerUlSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellModSchm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isCpDlExtend, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isCpUlExtend, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxUlUeNewTxPerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxDlUeNewTxPerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxDlRetxBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxDlBwPerUe, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxUlBwPerUe, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxCcchPerDlSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxUePerDlSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxUePerUlSf, mBuf);
#ifdef RGR_V1
/* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
of MSG3s */
- CMCHKPK(SPkU8, param->maxMsg3PerUlSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxMsg3PerUlSf, mBuf);
#endif
- CMCHKPK(SPkU8, param->macInst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->macInst, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
#ifdef EMTC_ENABLE
/* EMTC related changes start*/
- CMCHKPK(SPkU8, param->emtcEnable, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
CMCHKPK(cmPkRgrEmtcCfg, ¶m->emtcCellCfg, mBuf);
/* EMTC related changes ends*/
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef EMTC_ENABLE
/* EMTC related changes start*/
CMCHKUNPK(cmUnpkRgrEmtcCfg, ¶m->emtcCellCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->emtcEnable, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcEnable, mBuf);
/* EMTC related changes ends*/
#endif
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->macInst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->macInst, mBuf);
#ifdef RGR_V1
/* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
of MSG3s */
- CMCHKUNPK(SUnpkU8, ¶m->maxMsg3PerUlSf, mBuf);
-#endif
- CMCHKUNPK(SUnpkU8, ¶m->maxUePerUlSf, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxUePerDlSf, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxCcchPerDlSf, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxUlBwPerUe, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxDlBwPerUe, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxDlRetxBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxDlUeNewTxPerTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxUlUeNewTxPerTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isCpUlExtend, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isCpDlExtend, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cellModSchm, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxMsg3PerUlSf, mBuf);
+#endif
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUePerUlSf, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUePerDlSf, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxCcchPerDlSf, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUlBwPerUe, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxDlBwPerUe, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxDlRetxBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxDlUeNewTxPerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUlUeNewTxPerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isCpUlExtend, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isCpDlExtend, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellModSchm, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pMax, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlfsSchdType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlfsSchdType, mBuf);
CMCHKUNPK(cmUnpkRgrDlHqCfg, ¶m->dlHqCfg, mBuf);
CMCHKUNPK(cmUnpkRgrRntiCfg, ¶m->macRnti, mBuf);
CMCHKUNPK(cmUnpkRgrCfiCfg, ¶m->cfiCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUlPwrCfg, ¶m->pwrCfg, mBuf);
CMCHKUNPK(cmUnpkRgrPuschCfg, ¶m->puschCfg, mBuf);
CMCHKUNPK(cmUnpkRgrPreambleSetCfg, ¶m->macPreambleSet, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCmnLcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCmnLcs, mBuf);
for (i=0; i<param->numCmnLcs; i++) {
CMCHKUNPK(cmUnpkRgrCmnLchCfg, ¶m->cmnLcCfg[i], mBuf);
}
CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, ¶m->csgParamCfg, mBuf);
#ifdef LTE_TDD
- CMCHKUNPK(SUnpkU8, ¶m->ulDlCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->spclSfCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulDlCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->spclSfCfgIdx, mBuf);
CMCHKUNPK(cmUnpkRgrTddPrachRscInfo, ¶m->prachRscInfo, mBuf);
#endif
/* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
- CMCHKUNPK(SUnpkU8, ¶m->rrmTtiIndPrd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rrmTtiIndPrd, mBuf);
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKUNPK(cmUnpkRgrSpsDlCellCfg, ¶m->spsCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->t300TmrVal, mBuf);
- CMCHKPK(SUnpkU16, ¶m->bcchTxPwrOffset, mBuf);
- CMCHKPK(SUnpkU16, ¶m->pcchTxPwrOffset, mBuf);
- CMCHKPK(SUnpkU16, ¶m->rarTxPwrOffset, mBuf);
- CMCHKPK(SUnpkU16, ¶m->phichTxPwrOffset, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isDynCfiEnb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isAutoCfgModeEnb, mBuf);
- CMCHKPK(SUnpkU32, (U32*)¶m->msg4pAVal, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t300TmrVal, mBuf);
+ CMCHKPK(oduPackUInt16, ¶m->bcchTxPwrOffset, mBuf);
+ CMCHKPK(oduPackUInt16, ¶m->pcchTxPwrOffset, mBuf);
+ CMCHKPK(oduPackUInt16, ¶m->rarTxPwrOffset, mBuf);
+ CMCHKPK(oduPackUInt16, ¶m->phichTxPwrOffset, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDynCfiEnb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAutoCfgModeEnb, mBuf);
+ CMCHKPK(oduPackUInt32, (U32*)¶m->msg4pAVal, mBuf);
/*LAA: Unpack LAA Cell params*/
CMCHKUNPK(cmUnpkRgrLteUCellCfg, ¶m->lteUCfg, mBuf);
#ifdef LTE_ADV
- CMCHKUNPK(SUnpkU8, ¶m->isPucchFormat3Sptd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucchFormat3Sptd, mBuf);
#endif
#ifdef RG_5GTF
CMCHKUNPK(cmUnPkRgr5gtfCellCfg, ¶m->Cell5gtfCfg, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeAprdDlCqiCfg)
/*Pack Aperiodic Trigger List only for Pcell */
#ifdef LTE_ADV
- CMCHKPK(SPkU8, param->triggerSet2, mBuf);
- CMCHKPK(SPkU8, param->triggerSet1, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->triggerSet2, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->triggerSet1, mBuf);
#endif
- CMCHKPK(SPkU32, param->aprdModeEnum, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->aprdModeEnum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeAprdDlCqiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->aprdModeEnum = (RgrAprdCqiMode) tmpEnum;
#ifdef LTE_ADV
- CMCHKUNPK(SUnpkU8, ¶m->triggerSet1, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->triggerSet2, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->triggerSet1, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->triggerSet2, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUePrdDlCqiCfg)
- CMCHKPK(SPkU16, param->cqiPmiCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->k, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiPmiCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->k, mBuf);
CMCHKPK(SPkS8, param->cqiOffst, mBuf);
- CMCHKPK(SPkU8, param->subframeOffst, mBuf);
- CMCHKPK(SPkU32, param->prdicityEnum, mBuf);
- CMCHKPK(SPkU32, param->prdModeEnum, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->subframeOffst, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->prdicityEnum, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUePrdDlCqiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->prdModeEnum = tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->prdicityEnum = tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->subframeOffst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->subframeOffst, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->cqiOffst, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->k, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiPmiCfgIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->k, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiPmiCfgIdx, mBuf);
+ return ROK;
}
TRC3(cmPkRgrUeDlPCqiSetup)
- CMCHKPK(SPkU32, param->prdModeEnum, mBuf);
- CMCHKPK(SPkU8, param->sANCQI, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sANCQI, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
- CMCHKPK(SPkU16, param->riCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->riEna, mBuf);
- CMCHKPK(SPkU8, param->k, mBuf);
- CMCHKPK(SPkU8, param->cqiRepType, mBuf);
- CMCHKPK(SPkU16, param->cqiPCfgIdx, mBuf);
- CMCHKPK(SPkU16, param->cqiPResIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->riCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->riEna, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->k, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiRepType, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiPCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiPResIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeDlPCqiSetup)
- CMCHKUNPK(SUnpkU16, ¶m->cqiPResIdx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiPCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiRepType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->k, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->riEna, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiPResIdx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiPCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiRepType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->k, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->riEna, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
- CMCHKUNPK(SUnpkU16, ¶m->riCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sANCQI, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->riCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sANCQI, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->prdModeEnum = (RgrPrdCqiMode) tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUePrdDlCqiCfg)
CMCHKPK(cmPkRgrUeDlPCqiSetup, ¶m->cqiSetup, mBuf);
- CMCHKPK(SPkU8, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUePrdDlCqiCfg)
- CMCHKUNPK(SUnpkU8, ¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
CMCHKUNPK(cmUnpkRgrUeDlPCqiSetup, ¶m->cqiSetup, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeUlSrsSetupCfg)
- CMCHKPK(SPkU8, param->fDomPosi, mBuf);
- CMCHKPK(SPkU8, param->txComb, mBuf);
- CMCHKPK(SPkU8, param->sANSrs, mBuf);
- CMCHKPK(SPkU8, param->duration, mBuf);
- CMCHKPK(SPkU32, param->cycShift, mBuf);
- CMCHKPK(SPkU32, param->srsHopBw, mBuf);
- CMCHKPK(SPkU32, param->srsBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->fDomPosi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txComb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sANSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->duration, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->cycShift, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsHopBw, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsBw, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
- CMCHKPK(SPkU16, param->srsCfgIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeUlSrsSetupCfg)
/*rgr_c_001.main_9 DEL removed unwanted comments*/
- CMCHKUNPK(SUnpkU16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->srsBw = (RgrUlSrsBwInfo) tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->srsHopBw = (RgrUlSrsHoBwInfo) tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->cycShift = (RgrUlSrsCycShiftInfo) tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->duration, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sANSrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txComb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->fDomPosi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->duration, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sANSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txComb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->fDomPosi, mBuf);
+ return ROK;
}
/* ccpu00131601:DEL - dTMax Packing removed since this param will not
* be required by Scheduler*/
- CMCHKPK(SPkU8, param->srCfgIdx, mBuf);
- CMCHKPK(SPkU16, param->srResIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->srCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srResIdx, mBuf);
+ return ROK;
}
{
TRC3(cmUnpkRgrUeSrSetupCfg)
- CMCHKUNPK(SUnpkU16, ¶m->srResIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srResIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srCfgIdx, mBuf);
/* ccpu00131601:DEL - dTMax UnPacking removed since this param will not
* be required by Scheduler*/
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeSrCfg)
CMCHKPK(cmPkRgrUeSrSetupCfg, ¶m->srSetup, mBuf);
- CMCHKPK(SPkU8, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeSrCfg)
- CMCHKUNPK(SUnpkU8, ¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
CMCHKUNPK(cmUnpkRgrUeSrSetupCfg, ¶m->srSetup, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKPK(cmPkRgrUeUlSrsSetupCfg, ¶m->srsSetup, mBuf);
- CMCHKPK(SPkU8, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeUlSrsCfg)
- CMCHKUNPK(SUnpkU8, ¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKUNPK(cmUnpkRgrUeUlSrsSetupCfg, ¶m->srsSetup, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkRgrUePrdDlCqiCfg, ¶m->prdCqiCfg, mBuf);
#endif
CMCHKPK(cmPkRgrUeAprdDlCqiCfg, ¶m->aprdCqiCfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, ¶m->aprdCqiCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, ¶m->prdCqiCfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeMeasGapCfg)
- CMCHKPK(SPkU8, param->gapOffst, mBuf);
- CMCHKPK(SPkU8, param->gapPrd, mBuf);
- CMCHKPK(SPkU8, param->isMesGapEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->gapOffst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->gapPrd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isMesGapEnabled, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeMeasGapCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isMesGapEnabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->gapPrd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->gapOffst, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isMesGapEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->gapPrd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->gapOffst, mBuf);
+ return ROK;
}
/*rgr_c_001.main_9 ADD DRX functionality under flag*/
TRC3(cmPkRgrDrxLongCycleOffst)
- CMCHKPK(SPkU16, param->drxStartOffst, mBuf);
- CMCHKPK(SPkU16, param->longDrxCycle, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->drxStartOffst, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->longDrxCycle, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrDrxLongCycleOffst)
- CMCHKUNPK(SUnpkU16, ¶m->longDrxCycle, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->drxStartOffst, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->longDrxCycle, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->drxStartOffst, mBuf);
+ return ROK;
}
TRC3(cmPkRgrDrxShortDrx)
- CMCHKPK(SPkU8, param->drxShortCycleTmr, mBuf);
- CMCHKPK(SPkU16, param->shortDrxCycle, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->drxShortCycleTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->shortDrxCycle, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrDrxShortDrx)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->shortDrxCycle, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->drxShortCycleTmr, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->shortDrxCycle, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->drxShortCycleTmr, mBuf);
+ return ROK;
}
\f
/***********************************************************
CMCHKPK(cmPkRgrDrxShortDrx, ¶m->drxShortDrx, mBuf);
CMCHKPK(cmPkRgrDrxLongCycleOffst, ¶m->drxLongCycleOffst, mBuf);
- CMCHKPK(SPkU16, param->drxRetxTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->drxRetxTmr, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8, param->drxRetxTmrR13Pres, mBuf);
- CMCHKPK(SPkU8, param->drxOnDurTmrR13Pres, mBuf);
- CMCHKPK(SPkU16, param->emtcDrxUlRetxTmr, mBuf);
- CMCHKPK(SPkU8, param->isEmtcUe, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->drxRetxTmrR13Pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->drxOnDurTmrR13Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->emtcDrxUlRetxTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isEmtcUe, mBuf);
#endif
- CMCHKPK(SPkU16, param->drxInactvTmr, mBuf);
- CMCHKPK(SPkU16, param->drxOnDurTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->drxInactvTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->drxOnDurTmr, mBuf);
/*rgr_c_001.main_9 ADD added changes for R9*/
#ifdef LTEMAC_R9
CMCHKPK(cmPkTknS32, ¶m->cqiMask, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTEMAC_R9
CMCHKUNPK(cmUnpkTknS32, ¶m->cqiMask, mBuf);
#endif
- CMCHKUNPK(SUnpkU16, ¶m->drxOnDurTmr, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->drxInactvTmr, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->drxOnDurTmr, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->drxInactvTmr, mBuf);
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8, ¶m->isEmtcUe, mBuf);
- CMCHKUNPK(SUnpkU16,¶m->emtcDrxUlRetxTmr, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->drxOnDurTmrR13Pres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->drxRetxTmrR13Pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isEmtcUe, mBuf);
+ CMCHKUNPK(oduPackUInt16,¶m->emtcDrxUlRetxTmr, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->drxOnDurTmrR13Pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->drxRetxTmrR13Pres, mBuf);
#endif
- CMCHKUNPK(SUnpkU16, ¶m->drxRetxTmr, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->drxRetxTmr, mBuf);
CMCHKUNPK(cmUnpkRgrDrxLongCycleOffst, ¶m->drxLongCycleOffst, mBuf);
CMCHKUNPK(cmUnpkRgrDrxShortDrx, ¶m->drxShortDrx, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*rgr_c_001.main_9 ADD added DRX changes under DRX*/
TRC3(cmPkRgrUeCapCfg)
- CMCHKPK(SPkU8, param->txAntSel, mBuf);
- CMCHKPK(SPkU8, param->simCqiAckNack, mBuf);
- CMCHKPK(SPkU8, param->resAloocType1, mBuf);
- CMCHKPK(SPkU8, param->intraSfFeqHop, mBuf);
- CMCHKPK(SPkU8, param->pwrClass, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->txAntSel, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->simCqiAckNack, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAloocType1, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->intraSfFeqHop, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pwrClass, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeCapCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pwrClass, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->intraSfFeqHop, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->resAloocType1, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->simCqiAckNack, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntSel, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pwrClass, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->intraSfFeqHop, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAloocType1, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->simCqiAckNack, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntSel, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmPkRgrUeAckNackRepCfg)
- CMCHKPK(SPkU32, param->ackNackRepFactor, mBuf);
- CMCHKPK(SPkU16, param->pucchAckNackRep, mBuf);
- CMCHKPK(SPkU8, param->isAckNackEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->ackNackRepFactor, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchAckNackRep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAckNackEnabled, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeAckNackRepCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isAckNackEnabled, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchAckNackRep, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAckNackEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchAckNackRep, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ackNackRepFactor = (RgrAckNackRepFactor) tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeTxModeCfg)
- CMCHKPK(SPkU32, param->txModeEnum, mBuf);
- CMCHKPK(SPkU32, param->tmTrnstnState, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->txModeEnum, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tmTrnstnState, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrUeTxModeCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->tmTrnstnState = (RgrTxModeTrnstn) tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->txModeEnum = (RgrTxMode) tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeUlHqCfg)
- CMCHKPK(SPkU8, param->deltaHqOffst, mBuf);
- CMCHKPK(SPkU8, param->maxUlHqTx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->deltaHqOffst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeUlHqCfg)
- CMCHKUNPK(SUnpkU8, ¶m->maxUlHqTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->deltaHqOffst, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUlHqTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->deltaHqOffst, mBuf);
+ return ROK;
}
TRC3(cmPkRgrUeGrpPwrCfg)
- CMCHKPK(SPkU8, param->idx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->idx, mBuf);
CMCHKPK(cmPkLteRnti, param->tpcRnti, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeGrpPwrCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->tpcRnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->idx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->idx, mBuf);
+ return ROK;
}
/*rgr_c_001.main_7 - Added support for SPS*/
S32 i;
TRC3(cmPkRgrUeSpsDlCfg)
- CMCHKPK(SPkU16, param->explicitRelCnt, mBuf);
- CMCHKPK(SPkU32, param->dlSpsPrdctyEnum, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->explicitRelCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dlSpsPrdctyEnum, mBuf);
for (i=param->numPucchVal-1; i >= 0; i--) {
- CMCHKPK(SPkU32, param->n1PucchVal[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->n1PucchVal[i], mBuf);
}
- CMCHKPK(SPkU8, param->numPucchVal, mBuf);
- CMCHKPK(SPkU8, param->numSpsHqProc, mBuf);
- CMCHKPK(SPkU8, param->isDlSpsEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numPucchVal, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSpsHqProc, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isDlSpsEnabled, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgrUeSpsDlCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isDlSpsEnabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSpsHqProc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numPucchVal, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDlSpsEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSpsHqProc, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numPucchVal, mBuf);
for (i=0; i<param->numPucchVal; i++) {
- CMCHKUNPK(SUnpkU32, ¶m->n1PucchVal[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->n1PucchVal[i], mBuf);
}
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->dlSpsPrdctyEnum = tmpEnum;
- CMCHKUNPK(SUnpkU16, ¶m->explicitRelCnt, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->explicitRelCnt, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmPkRgrUeSpsUlCfg)
- CMCHKPK(SPkU8, param->isLcSRMaskEnab, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isLcSRMaskEnab, mBuf);
for (i=param->lcCnt-1; i >= 0; i--) {
/* SPS Changes starts */
- CMCHKPK(SPkU8, param->spsLcInfo[i].isSpsEnabled, mBuf);
- CMCHKPK(SPkU8, param->spsLcInfo[i].lcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].isSpsEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].lcId, mBuf);
/* SPS Changes ends */
}
- CMCHKPK(SPkU8, param->lcCnt, mBuf);
- CMCHKPK(SPkU32, param->ulSpsPrdctyEnum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lcCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ulSpsPrdctyEnum, mBuf);
CMCHKPK(SPkS8, param->pwrCfg.p0UePuschVal, mBuf);
CMCHKPK(SPkS8, param->pwrCfg.p0NominalPuschVal, mBuf);
- CMCHKPK(SPkU8, param->pwrCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pwrCfgPres, mBuf);
#ifdef LTE_TDD
- CMCHKPK(SPkU8, param->twoIntervalCfg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->twoIntervalCfg, mBuf);
#endif
- CMCHKPK(SPkU32, param->implicitRelCnt, mBuf);
- CMCHKPK(SPkU8, param->isUlSpsEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->implicitRelCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isUlSpsEnabled, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgrUeSpsUlCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isUlSpsEnabled, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isUlSpsEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->implicitRelCnt = tmpEnum;
#ifdef LTE_TDD
- CMCHKUNPK(SUnpkU8, ¶m->twoIntervalCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->twoIntervalCfg, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->pwrCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pwrCfgPres, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pwrCfg.p0NominalPuschVal, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pwrCfg.p0UePuschVal, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ulSpsPrdctyEnum = tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->lcCnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcCnt, mBuf);
for (i=0; i<param->lcCnt; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->spsLcInfo[i].lcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->spsLcInfo[i].isSpsEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->spsLcInfo[i].lcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->spsLcInfo[i].isSpsEnabled, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isLcSRMaskEnab, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLcSRMaskEnab, mBuf);
+ return ROK;
}
CMCHKPK(cmPkRgrUeSpsUlCfg, ¶m->ulSpsCfg, mBuf);
CMCHKPK(cmPkRgrUeSpsDlCfg, ¶m->dlSpsCfg, mBuf);
CMCHKPK(cmPkLteRnti, param->spsRnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->spsRnti, mBuf);
CMCHKUNPK(cmUnpkRgrUeSpsDlCfg, ¶m->dlSpsCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeSpsUlCfg, ¶m->ulSpsCfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeUlPwrCfg)
- CMCHKPK(SPkU8, param->trgCqi, mBuf);
- CMCHKPK(SPkU8, param->pSRSOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
CMCHKPK(SPkS8, param->p0UePucch, mBuf);
CMCHKPK(SPkS8, param->p0UePusch, mBuf);
- CMCHKPK(SPkU8, param->isDeltaMCSEnabled, mBuf);
- CMCHKPK(SPkU8, param->isAccumulated, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
CMCHKPK(cmPkRgrUeGrpPwrCfg, ¶m->uePucchPwr, mBuf);
CMCHKPK(cmPkRgrUeGrpPwrCfg, ¶m->uePuschPwr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, ¶m->uePuschPwr, mBuf);
CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, ¶m->uePucchPwr, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isAccumulated, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isDeltaMCSEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAccumulated, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDeltaMCSEnabled, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->p0UePusch, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->p0UePucch, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pSRSOffset, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->trgCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->pSRSOffset, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->trgCqi, mBuf);
+ return ROK;
}
TRC3(cmPkRgrUeQosCfg)
- CMCHKPK(SPkU32, param->ueBr, mBuf);
- CMCHKPK(SPkU32, param->dlAmbr, mBuf);
- CMCHKPK(SPkU8, param->ambrPres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->ueBr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dlAmbr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ambrPres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeQosCfg)
- CMCHKUNPK(SUnpkU8, ¶m->ambrPres, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->dlAmbr, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->ueBr, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ambrPres, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->dlAmbr, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->ueBr, mBuf);
+ return ROK;
}
/***********************************************************
TRC3(cmPkRgrUePuschDedCfg)
- CMCHKPK(SPkU8, param->bCQIIdx, mBuf);
- CMCHKPK(SPkU8, param->bRIIdx, mBuf);
- CMCHKPK(SPkU8, param->bACKIdx, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->bCQIIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->bRIIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->bACKIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUePuschDedCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bACKIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bRIIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bCQIIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bACKIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bRIIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bCQIIdx, mBuf);
+ return ROK;
}
/***********************************************************
TRC3(cmPkRgrUeTxAntSelCfg)
- CMCHKPK(SPkU32, param->selType, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->selType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeTxAntSelCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->selType = (RgrUeTxAntSelType) tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUeTaTmrCfg)
- CMCHKPK(SPkU16, param->taTmr, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->taTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrUeTaTmrCfg)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->taTmr, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->taTmr, mBuf);
+ return ROK;
}
RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
RgrEpdcchAddModLst *epdcchAddModLst;
- CMCHKUNPK(SUnpkU8,¶m->pdschReptLevModeA,mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->pdschReptLevModeA,mBuf);
/*UnPacking PUCCH Rep */
- CMCHKUNPK(SUnpkU8,&(emtcPucchRepCfg->modeANumPucchRepFormat2),mBuf);
- CMCHKUNPK(SUnpkU8,&(emtcPucchRepCfg->modeANumPucchRepFormat1),mBuf);
- CMCHKUNPK(SUnpkU8,&(emtcPucchRepCfg->isPucchRepPres),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat2),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat1),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->isPucchRepPres),mBuf);
for(indx = 0; indx < RGR_MAX_EPDCCH_SET; indx++)
{
epdcchAddModLst = &(emtcEpdcchCfg->epdcchAddModLst[indx]);
- CMCHKUNPK(SUnpkU32,&(epdcchAddModLst->extaddgrp2.mpddchNB),mBuf);
- CMCHKUNPK(SUnpkU16,&(epdcchAddModLst->extaddgrp2.mpdcchNumRep),mBuf);
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD),mBuf);
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
+ CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->extaddgrp2.mpddchNB),mBuf);
+ CMCHKUNPK(oduPackUInt16,&(epdcchAddModLst->extaddgrp2.mpdcchNumRep),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
CMCHKUNPK(cmUnpkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
CMCHKUNPK(cmUnpkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
- CMCHKUNPK(SUnpkU32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
- CMCHKUNPK(SUnpkU32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
+ CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
+ CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
for(idx = 0; idx < 5; idx++)
{
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->resBlkAssignment.rbAssignment[idx]),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.rbAssignment[idx]),mBuf);
}
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->resBlkAssignment.numPRBpairs),mBuf);
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->transmissionType),mBuf);
- CMCHKUNPK(SUnpkU8,&(epdcchAddModLst->setConfigId),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.numPRBpairs),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->transmissionType),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->setConfigId),mBuf);
}
CMCHKUNPK(cmUnpkTknU32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
for(indx = 0; indx < 5; indx++)
{
- CMCHKUNPK(SUnpkU8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
+ CMCHKUNPK(oduPackUInt8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
}
- CMCHKUNPK(SUnpkU8, &(emtcEpdcchCfg->sfPtn.pres), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->pres), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->isHdFddEnbld), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(emtcEpdcchCfg->sfPtn.pres), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->pres), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->isHdFddEnbld), mBuf);
#ifdef EMTC_DEBUG_CONSOLE_PRINTS
printf("\n EMTC RGR UE unpack\n");
#endif
- RETVALUE(ROK);
+ return ROK;
}
RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
RgrEpdcchAddModLst *epdcchAddModLst;
- CMCHKPK(SPkU8, param->isHdFddEnbld, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- CMCHKPK(SPkU8, emtcEpdcchCfg->sfPtn.pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, emtcEpdcchCfg->sfPtn.pres, mBuf);
for(indx = 4; indx >=0; indx--)
{
- CMCHKPK(SPkU8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
+ CMCHKPK(oduUnpackUInt8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
}
CMCHKPK(cmPkTknU32,&emtcEpdcchCfg->startSymbolr11,mBuf);
for(indx = RGR_MAX_EPDCCH_SET-1 ; indx >= 0; indx--)
{
epdcchAddModLst = &(emtcEpdcchCfg->epdcchAddModLst[indx]);
- CMCHKPK(SPkU8,epdcchAddModLst->setConfigId,mBuf);
- CMCHKPK(SPkU8,epdcchAddModLst->transmissionType,mBuf);
- CMCHKPK(SPkU8,epdcchAddModLst->resBlkAssignment.numPRBpairs,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->setConfigId,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->transmissionType,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.numPRBpairs,mBuf);
for(idx = 4; idx >= 0; idx--)
{
- CMCHKPK(SPkU8,epdcchAddModLst->resBlkAssignment.rbAssignment[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.rbAssignment[idx],mBuf);
}
- CMCHKPK(SPkU32,epdcchAddModLst->dmrsScrambSeq,mBuf);
- CMCHKPK(SPkU32,epdcchAddModLst->pucchResStartoffset,mBuf);
+ CMCHKPK(oduUnpackUInt32,epdcchAddModLst->dmrsScrambSeq,mBuf);
+ CMCHKPK(oduUnpackUInt32,epdcchAddModLst->pucchResStartoffset,mBuf);
CMCHKPK(cmPkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
CMCHKPK(cmPkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
- CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.pres,mBuf);
- CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
- CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
- CMCHKPK(SPkU8,epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD,mBuf);
- CMCHKPK(SPkU16,epdcchAddModLst->extaddgrp2.mpdcchNumRep,mBuf);
- CMCHKPK(SPkU32,epdcchAddModLst->extaddgrp2.mpddchNB,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.pres,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
+ CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD,mBuf);
+ CMCHKPK(oduUnpackUInt16,epdcchAddModLst->extaddgrp2.mpdcchNumRep,mBuf);
+ CMCHKPK(oduUnpackUInt32,epdcchAddModLst->extaddgrp2.mpddchNB,mBuf);
}
/*Packing PUCCH Rep */
- CMCHKPK(SPkU8,emtcPucchRepCfg->isPucchRepPres, mBuf);
- CMCHKPK(SPkU8,emtcPucchRepCfg->modeANumPucchRepFormat1,mBuf);
- CMCHKPK(SPkU8,emtcPucchRepCfg->modeANumPucchRepFormat2,mBuf);
- CMCHKPK(SPkU8,param->pdschReptLevModeA,mBuf);
+ CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->isPucchRepPres, mBuf);
+ CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat1,mBuf);
+ CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat2,mBuf);
+ CMCHKPK(oduUnpackUInt8,param->pdschReptLevModeA,mBuf);
#ifdef EMTC_DEBUG_CONSOLE_PRINTS
printf("\n EMTC RGR UE pack\n");
- RETVALUE(ROK);
+ return ROK;
}
#endif
Buffer *mBuf
)
{
- CMCHKUNPK(SUnpkU8, ¶m->grpId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->BeamId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCC, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->maxPrb, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->BeamId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCC, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxPrb, mBuf);
+ return ROK;
}
PUBLIC S16 cmPkRgr5gtfUeCfg
Buffer *mBuf
)
{
- CMCHKPK(SPkU8, param->maxPrb, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->numCC, mBuf);
- CMCHKPK(SPkU8, param->BeamId, mBuf);
- CMCHKPK(SPkU8, param->grpId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->maxPrb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCC, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->BeamId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
+ return ROK;
}
#endif
#ifdef EMTC_ENABLE
CMCHKPK(cmPkRgrEmtcUeCfg, ¶m->emtcUeCfg, mBuf);
#endif
- CMCHKPK(SPkU8, param->csgMmbrSta, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
- CMCHKPK(SPkU32, param->accessStratumRls, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKPK(cmPkRgrLteAdvancedUeConfig, ¶m->ueLteAdvCfg, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
/*rgr_c_001.main_9 ADD added changes for HDFDD*/
#ifdef LTEMAC_HDFDD
- CMCHKPK(SPkU8, param->isHdFddEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
#endif
#ifdef TFU_UPGRADE
CMCHKPK(cmPkRgrUeSpsCfg, ¶m->ueSpsCfg, mBuf);
#ifdef LTE_TDD
- CMCHKPK(SPkU32, param->ackNackModeEnum, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ackNackModeEnum, mBuf);
#endif
CMCHKPK(cmPkTknU8, ¶m->dedPreambleId, mBuf);
CMCHKPK(cmPkRgrUeCapCfg, ¶m->ueCapCfg, mBuf);
CMCHKPK(cmPkRgrUeMeasGapCfg, ¶m->ueMesGapCfg, mBuf);
CMCHKPK(cmPkRgrUeAckNackRepCfg, ¶m->ueAckNackCfg, mBuf);
- CMCHKPK(SPkU8, param->isTtiBundlEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
/*rgr_c_001.main_9 ADD added changes for DRX*/
/* Anshika - Pack only if DRX is enabled */
{
CMCHKPK(cmPkRgrUeDrxCfg, ¶m->ueDrxCfg, mBuf);
}
- CMCHKPK(SPkU8, param->ueDrxCfg.isDrxEnabled, mBuf); /* This has to be packed even if
+ CMCHKPK(oduUnpackUInt8, param->ueDrxCfg.isDrxEnabled, mBuf); /* This has to be packed even if
DRX is disabled */
- CMCHKPK(SPkU32, param->ueCatEnum, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
#ifdef RGR_V1
/* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
* retxBSR-timer */
CMCHKPK(cmPkRgrUeTxModeCfg, ¶m->txMode, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
* retxBSR-timer */
CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, ¶m->ueBsrTmrCfg, mBuf);
#endif
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ueCatEnum = (CmLteUeCategory) tmpEnum;
/*rgr_c_001.main_9 ADD added changes for DRX*/
/* Anshika - Unpack only if DRX is enabled */
- CMCHKUNPK(SUnpkU8, ¶m->ueDrxCfg.isDrxEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueDrxCfg.isDrxEnabled, mBuf);
if(TRUE == param->ueDrxCfg.isDrxEnabled)
{
CMCHKUNPK(cmUnpkRgrUeDrxCfg, ¶m->ueDrxCfg, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isTtiBundlEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isTtiBundlEnabled, mBuf);
CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, ¶m->ueAckNackCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, ¶m->ueMesGapCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeCapCfg, ¶m->ueCapCfg, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->dedPreambleId, mBuf);
#ifdef LTE_TDD
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ackNackModeEnum = tmpEnum;
#endif
#endif
/*rgr_c_001.main_9 ADD added changes for HDFDD*/
#ifdef LTEMAC_HDFDD
- CMCHKUNPK(SUnpkU8, ¶m->isHdFddEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isHdFddEnbld, mBuf);
#endif
CMCHKUNPK(cmUnpkRgrUePuschDedCfg, ¶m->puschDedCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, ¶m->ulTxAntSel, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKUNPK(cmUnpkRgrLteAdvancedUeConfig, ¶m->ueLteAdvCfg, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->accessStratumRls, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->csgMmbrSta, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->accessStratumRls, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->csgMmbrSta, mBuf);
#ifdef EMTC_ENABLE
CMCHKUNPK(cmUnpkRgrEmtcUeCfg, ¶m->emtcUeCfg, mBuf);
CMCHKUNPK(cmUnpkRgr5gtfUeCfg, ¶m->ue5gtfCfg, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrLchQosCfg)
- CMCHKPK(SPkU32, param->mbr, mBuf);
- CMCHKPK(SPkU32, param->gbr, mBuf);
- CMCHKPK(SPkU8, param->qci, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrLchQosCfg)
- CMCHKUNPK(SUnpkU8, ¶m->qci, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->gbr, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->mbr, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->gbr, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->mbr, mBuf);
+ return ROK;
}
/*rgr_c_001.main_7 - Added support for SPS*/
TRC3(cmPkRgrLchSpsCfg)
/* SPS_DEV */
- CMCHKPK(SPkU8, param->isSpsEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isSpsEnabled, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrLchSpsCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isSpsEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSpsEnabled, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrDlLchCfg)
/*rgr_c_001.main_7 - Added support for SPS*/
- CMCHKPK(SPkU8, param->rlcReorderTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rlcReorderTmr, mBuf);
CMCHKPK(cmPkRgrLchSpsCfg, ¶m->dlSpsCfg, mBuf);
CMCHKPK(cmPkRgrLchQosCfg, ¶m->dlQos, mBuf);
- CMCHKPK(SPkU8, param->dlTrchType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrDlLchCfg)
- CMCHKUNPK(SUnpkU8, ¶m->dlTrchType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlTrchType, mBuf);
CMCHKUNPK(cmUnpkRgrLchQosCfg, ¶m->dlQos, mBuf);
/*rgr_c_001.main_7 - Added support for SPs*/
CMCHKUNPK(cmUnpkRgrLchSpsCfg, ¶m->dlSpsCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rlcReorderTmr, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rlcReorderTmr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrUlLchCfg)
- CMCHKPK(SPkU8, param->qci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrUlLchCfg)
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->qci, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
+ return ROK;
}
S32 i;
#endif
TRC3(cmPkRgrUlLcgCfg)
- CMCHKPK(SPkU32, param->mbr, mBuf);
- CMCHKPK(SPkU32, param->gbr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
/*rgr_c_001.main_9 ADD added changes for L2 measurements*/
#ifdef LTE_L2_MEAS
{
CMCHKPK(cmPkRgrUlLchCfg, ¶m->lchUlCfg[i], mBuf);
}
- CMCHKPK(SPkU8, param->numLch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numLch, mBuf);
#endif
- CMCHKPK(SPkU8, param->lcgId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
+ return ROK;
}
#endif
TRC3(cmUnpkRgrUlLcgCfg)
- CMCHKUNPK(SUnpkU8, ¶m->lcgId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
/*rgr_c_001.main_9 ADD added changes for L2 measurements*/
#ifdef LTE_L2_MEAS
- CMCHKUNPK(SUnpkU8, ¶m->numLch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numLch, mBuf);
for (i = 0; i< param->numLch; i++)
{
CMCHKUNPK(cmUnpkRgrUlLchCfg, ¶m->lchUlCfg[i], mBuf);
}
#endif
- CMCHKUNPK(SUnpkU32, ¶m->gbr, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->mbr, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->gbr, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->mbr, mBuf);
+ return ROK;
}
#ifdef ANSI
Buffer *mBuf;
#endif
{
- CMCHKPK(SPkU8, param->lcId, mBuf);
- CMCHKPK(SPkU8, param->qci, mBuf);
- CMCHKPK(SPkU8, param->lcgId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->lcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
+ return ROK;
}
#ifdef ANSI
PUBLIC S16 cmUnpkRgrUlLchQciCfg
Buffer *mBuf;
#endif
{
- CMCHKUNPK(SUnpkU8, ¶m->lcgId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->qci, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->lcId, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcId, mBuf);
+ return ROK;
}
\f
{
TRC3(cmPkRgrLchCfg)
- CMCHKPK(SPkU8, param->lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
CMCHKPK(cmPkRgrUlLchQciCfg, ¶m->ulLchQciInfo, mBuf);
CMCHKPK(cmPkRgrDlLchCfg, ¶m->dlInfo, mBuf);
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
CMCHKUNPK(cmUnpkRgrDlLchCfg, ¶m->dlInfo, mBuf);
CMCHKUNPK(cmUnpkRgrUlLchQciCfg, ¶m->ulLchQciInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->lcgId, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
+ return ROK;
}
CMCHKPK(cmPkRgrUlLcgCfg, ¶m->ulInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(cmUnpkRgrUlLcgCfg, ¶m->ulInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkMacSchedGnbCfg, ¶m->u.schedGnbCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrCfg)
- CMCHKUNPK(SUnpkU8, ¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
case MAC_GNB_CFG:
CMCHKUNPK(cmUnpkMacSchedGnbCfg, ¶m->u.schedGnbCfg, mBuf);
CMCHKUNPK(cmUnpkRgrLcgCfg, ¶m->u.lcgCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrActvTime)
CMCHKPK(cmPkLteTimingInfo, ¶m->actvTime, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrActvTime)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->actvTime, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrCellRecfg)
CMCHKPK(cmPkRgrCellCntrlCmdCfg, ¶m->cntrlCmdCfg, mBuf);
CMCHKPK(cmPkRgrCellCsgParamCfg, ¶m->csgParamCfg, mBuf);
- CMCHKPK(SPkU8, param->isDynCfiEnb, mBuf);
- CMCHKPK(SPkU8, param->isAutoCfgModeEnb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKPK(cmPkRgrCellLteAdvancedFeatureCfg, ¶m->rgrLteAdvCfg, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKPK(SPkU16, param->t300TmrVal, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
/* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
#ifdef RGR_SI_SCH
CMCHKPK(cmPkRgrSiCfg, ¶m->siReCfg, mBuf);
CMCHKPK(cmPkRgrCfiCfg, ¶m->cfiRecfg, mBuf);
CMCHKPK(cmPkRgrDlHqCfg, ¶m->dlHqRecfg, mBuf);
CMCHKPK(cmPkRgrActvTime, ¶m->recfgActvTime, mBuf);
- CMCHKPK(SPkU32, param->recfgTypes, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->recfgTypes, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgrCellRecfg)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->recfgTypes, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->recfgTypes, mBuf);
CMCHKUNPK(cmUnpkRgrActvTime, ¶m->recfgActvTime, mBuf);
CMCHKUNPK(cmUnpkRgrDlHqCfg, ¶m->dlHqRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrCfiCfg, ¶m->cfiRecfg, mBuf);
#ifdef RGR_SI_SCH
CMCHKUNPK(cmUnpkRgrSiCfg, ¶m->siReCfg, mBuf);
#endif /* RGR_SI_SCH */
- CMCHKUNPK(SUnpkU16, ¶m->t300TmrVal, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t300TmrVal, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKUNPK(cmUnpkRgrCellLteAdvancedFeatureCfg, ¶m->rgrLteAdvCfg, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKUNPK(SUnpkU8, ¶m->isAutoCfgModeEnb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isDynCfiEnb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAutoCfgModeEnb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDynCfiEnb, mBuf);
CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, ¶m->csgParamCfg, mBuf);
CMCHKUNPK(cmUnpkRgrCellCntrlCmdCfg, ¶m->cntrlCmdCfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef EMTC_ENABLE
/* Note: As we add more members to emtcUeRecfg,
create a new function for pkUnpk */
- CMCHKPK(SPkU8, param->emtcUeRecfg.isHdFddEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcUeRecfg.isHdFddEnbld, mBuf);
#endif
- CMCHKPK(SPkU8, param->csgMmbrSta, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
- CMCHKPK(SPkU32, param->accessStratumRls, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
#ifdef LTE_ADV
- CMCHKPK(SPkU8, param->simulAckNackCQIFormat3, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->simulAckNackCQIFormat3, mBuf);
CMCHKPK(cmPkRgrUeSCellAckPucchCfg, ¶m->sCellAckN1ResCfg,mBuf);
CMCHKPK(cmPkRgrUeSecCellInfo, ¶m->ueSCellCfgInfo,mBuf);
#endif
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKPK(SPkU8, param->ueLteAdvCfg.isUeCellEdge, mBuf);
- CMCHKPK(SPkU8, param->ueLteAdvCfg.isAbsUe, mBuf);
- CMCHKPK(SPkU32, param->ueLteAdvCfg.pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isUeCellEdge, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isAbsUe, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ueLteAdvCfg.pres, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
/*ccpu00130497: Removed the duplicate packing*/
#ifdef TFU_UPGRADE
/*rgr_c_001.main_9 ADD added changes for HDFDD*/
#ifdef LTEMAC_HDFDD
- CMCHKPK(SPkU8, param->isHdFddEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
#endif
#ifdef TFU_UPGRADE
CMCHKPK(cmPkRgrUeTxAntSelCfg, ¶m->ulTxAntSel, mBuf);
/* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
- CMCHKPK(SPkU32, param->ueCatEnum, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
CMCHKPK(cmPkRgrCodeBookRstCfg, ¶m->ueCodeBookRstRecfg, mBuf);
CMCHKPK(cmPkRgrUeMeasGapCfg, ¶m->ueMeasGapRecfg, mBuf);
CMCHKPK(cmPkRgrUeCapCfg, ¶m->ueCapRecfg, mBuf);
CMCHKPK(cmPkRgrUeAckNackRepCfg, ¶m->ueAckNackRecfg, mBuf);
- CMCHKPK(SPkU8, param->isTtiBundlEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
/*rgr_c_001.main_9 ADD added changes for DRX*/
/* Anshika - Pack only if DRX is enabled */
{
CMCHKPK(cmPkRgrUeDrxCfg, ¶m->ueDrxRecfg, mBuf);
}
- CMCHKPK(SPkU8, param->ueDrxRecfg.isDrxEnabled, mBuf); /* This has to be packed even if
+ CMCHKPK(oduUnpackUInt8, param->ueDrxRecfg.isDrxEnabled, mBuf); /* This has to be packed even if
DRX is disabled */
CMCHKPK(cmPkRgrUeUlPwrCfg, ¶m->ueUlPwrRecfg, mBuf);
#ifdef RGR_V1
/*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
/* LTE_ADV_FLAG_REMOVED_START */
/* KW fix for LTE_ADV */
- CMCHKPK(SPkU32, param->ueRecfgTypes, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ueRecfgTypes, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_START */
/*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
/* KW fix for LTE_ADV */
- CMCHKUNPK(SUnpkU32, ¶m->ueRecfgTypes, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->ueRecfgTypes, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
CMCHKUNPK(cmUnpkRgrUeTxModeCfg, ¶m->txMode, mBuf);
/*rgr_c_001.main_9 ADD added changes for DRX*/
/* Anshika - Unpack only if DRX is enabled */
- CMCHKUNPK(SUnpkU8, ¶m->ueDrxRecfg.isDrxEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueDrxRecfg.isDrxEnabled, mBuf);
if(TRUE == param->ueDrxRecfg.isDrxEnabled)
{
CMCHKUNPK(cmUnpkRgrUeDrxCfg, ¶m->ueDrxRecfg, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isTtiBundlEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isTtiBundlEnabled, mBuf);
CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, ¶m->ueAckNackRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeCapCfg, ¶m->ueCapRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, ¶m->ueMeasGapRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, ¶m->ueCodeBookRstRecfg, mBuf);
/* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ueCatEnum = (CmLteUeCategory) tmpEnum;
CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, ¶m->ulTxAntSel, mBuf);
/*rgr_c_001.main_7 - Added support for SPS*/
/*rgr_c_001.main_9 ADD added changes for HDFDD*/
#ifdef LTEMAC_HDFDD
- CMCHKUNPK(SUnpkU8, ¶m->isHdFddEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isHdFddEnbld, mBuf);
#endif
CMCHKUNPK(cmUnpkRgrUePuschDedCfg, ¶m->puschDedCfg, mBuf);
#endif
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKUNPK(SUnpkU32, ¶m->ueLteAdvCfg.pres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ueLteAdvCfg.isAbsUe, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ueLteAdvCfg.isUeCellEdge, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->ueLteAdvCfg.pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueLteAdvCfg.isAbsUe, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueLteAdvCfg.isUeCellEdge, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
#ifdef LTE_ADV
CMCHKUNPK(cmUnpkRgrUeSecCellInfo, ¶m->ueSCellCfgInfo,mBuf);
CMCHKUNPK(cmUnpkRgrUeSCellAckPucchCfg, ¶m->sCellAckN1ResCfg,mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->simulAckNackCQIFormat3, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->simulAckNackCQIFormat3, mBuf);
#endif
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->accessStratumRls, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->accessStratumRls, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->csgMmbrSta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->csgMmbrSta, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(SUnpkU8, ¶m->emtcUeRecfg.isHdFddEnbld, mBuf);
+ CMCHKPK(oduPackUInt8, ¶m->emtcUeRecfg.isHdFddEnbld, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgrLchRecfg)
/*rgr_c_001.main_7 - Added support for SPS*/
- CMCHKPK(SPkU8, param->lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
CMCHKPK(cmPkRgrUlLchQciCfg, ¶m->ulLchQciInfo, mBuf);
CMCHKPK(cmPkRgrLchSpsCfg, ¶m->dlRecfg.dlSpsRecfg, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkRgrLchSpsCfg, ¶m->dlRecfg.dlSpsRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrUlLchQciCfg, ¶m->ulLchQciInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->lcgId, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
+ return ROK;
}
#endif
TRC3(cmPkRgrLcgRecfg)
- CMCHKPK(SPkU32, param->ulRecfg.mbr, mBuf);
- CMCHKPK(SPkU32, param->ulRecfg.gbr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ulRecfg.mbr, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ulRecfg.gbr, mBuf);
#ifdef RG_UNUSED
for (i = param->ulRecfg.numLch - 1; i >= 0; i--)
{
CMCHKPK(cmPkRgrUlLchCfg, ¶m->ulRecfg.lchUlCfg[i], mBuf);
}
- CMCHKPK(SPkU8, param->ulRecfg.numLch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulRecfg.numLch, mBuf);
#endif
- CMCHKPK(SPkU8, param->ulRecfg.lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulRecfg.lcgId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulRecfg.lcgId, mBuf);
#ifdef RG_UNUSED
- CMCHKUNPK(SUnpkU8, ¶m->ulRecfg.numLch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulRecfg.numLch, mBuf);
for (i = 0; i < param->ulRecfg.numLch; i++)
{
CMCHKUNPK(cmUnpkRgrUlLchCfg, ¶m->ulRecfg.lchUlCfg[i], mBuf);
}
#endif
- CMCHKUNPK(SUnpkU32, ¶m->ulRecfg.gbr, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->ulRecfg.mbr, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->ulRecfg.gbr, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->ulRecfg.mbr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkRgrCellRecfg, ¶m->u.cellRecfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->recfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->recfgType, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrRecfg)
- CMCHKUNPK(SUnpkU8, ¶m->recfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->recfgType, mBuf);
switch(param->recfgType) {
case RGR_CELL_CFG:
CMCHKUNPK(cmUnpkRgrCellRecfg, ¶m->u.cellRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrLcgRecfg, ¶m->u.lcgRecfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_ADV
Buffer *mBuf;
#endif
{
- CMCHKPK(SPkU16, param->sCellId, mBuf);
- CMCHKPK(SPkU8, param->sCellIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
+ return ROK;
}
\f
/***********************************************************
{
CMCHKPK(cmPkRgrUeDlSecCellRelInfo, ¶m->ueSCellRelDedCfg[(U8)idx],mBuf);
}
- CMCHKPK(SPkU8, param->numSCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
switch(param->delType) {
case RGR_LCG_CFG:
- CMCHKPK(SPkU8, param->u.lcgDel.lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.lcgDel.lcgId, mBuf);
CMCHKPK(cmPkLteRnti, param->u.lcgDel.crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->u.lcgDel.cellId, mBuf);
break;
case RGR_LCH_CFG:
- CMCHKPK(SPkU8, param->u.lchDel.lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.lchDel.lcgId, mBuf);
CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
#ifdef LTE_ADV
case RGR_SCELL_UE_CFG:
CMCHKPK(cmPkRgrUeSecCellRelInfo, ¶m->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
- CMCHKPK(SPkU32, param->u.ueScellRel.ueDelTypes, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->u.ueScellRel.ueDelTypes, mBuf);
CMCHKPK(cmPkLteRnti, param->u.ueScellRel.crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->u.ueScellRel.cellId, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->delType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->delType, mBuf);
+ return ROK;
}
Buffer *mBuf;
#endif
{
- CMCHKUNPK(SUnpkU8, ¶m->sCellIdx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sCellId, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
+ return ROK;
}
\f
{
U8 idx;
- CMCHKUNPK(SUnpkU8, ¶m->numSCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
for(idx = 0; idx < param->numSCells;idx++)
{
CMCHKUNPK(cmUnpkRgrUeDlSecCellRelInfo, ¶m->ueSCellRelDedCfg[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
TRC3(cmUnpkRgrDel)
- CMCHKUNPK(SUnpkU8, ¶m->delType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->delType, mBuf);
switch(param->delType) {
case RGR_CELL_CFG:
CMCHKUNPK(cmUnpkLteCellId, ¶m->u.cellDel.cellId, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->u.lchDel.cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->u.lchDel.crnti, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->u.lchDel.lcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->u.lchDel.lcgId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.lchDel.lcgId, mBuf);
break;
case RGR_LCG_CFG:
CMCHKUNPK(cmUnpkLteCellId, ¶m->u.lcgDel.cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->u.lcgDel.crnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->u.lcgDel.lcgId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.lcgDel.lcgId, mBuf);
break;
#ifdef LTE_ADV
case RGR_SCELL_UE_CFG:
CMCHKUNPK(cmUnpkLteCellId, ¶m->u.ueScellRel.cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->u.ueScellRel.crnti, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->u.ueScellRel.ueDelTypes, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->u.ueScellRel.ueDelTypes, mBuf);
CMCHKUNPK(cmUnpkRgrUeSecCellRelInfo, ¶m->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
TRC3(cmPkRgrPrbCfg)
for(count = RGR_SCH_MAX_PA_PER_PRB - 1; count >= 0; count --)
{
- CMCHKPK(SPkU32, param->paLevelPerPrb[count], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->paLevelPerPrb[count], mBuf);
}
for(count = param->numCellCentreUEs - 1; count >= 0; count --)
{
{
CMCHKPK(cmPkLteRnti, param->cellEdgeUe[count], mBuf);
}
- CMCHKPK(SPkU8, param->numCellCentreUEs, mBuf);
- CMCHKPK(SPkU8, param->numCellEdgeUEs, mBuf);
- CMCHKPK(SPkU8, param->isSonIcicEnable, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numCellCentreUEs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCellEdgeUEs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSonIcicEnable, mBuf);
+ return ROK;
}
/***********************************************************
{
S32 count;
TRC3(cmUnpkRgrSonPrbCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isSonIcicEnable, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCellEdgeUEs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCellCentreUEs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSonIcicEnable, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCellEdgeUEs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCellCentreUEs, mBuf);
for (count = 0; count < param->numCellEdgeUEs; count++)
{
CMCHKUNPK(cmUnpkLteRnti, ¶m->cellEdgeUe[count], mBuf);
}
for(count = 0; count < RGR_SCH_MAX_PA_PER_PRB; count ++)
{
- CMCHKUNPK(SUnpkU32,(U32 *) ¶m->paLevelPerPrb[count], mBuf);
+ CMCHKUNPK(oduPackUInt32,(U32 *) ¶m->paLevelPerPrb[count], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
CMCHKPK(cmPkRgrSonPrbCfg, ¶m->u.prbCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->cfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->cfgType, mBuf);
+ return ROK;
}
/***********************************************************
{
TRC3(cmUnpkRgrSonCfg)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->cfgType, mBuf);
switch(param->cfgType)
{
case RGR_SON_PRB_CFG :
CMCHKUNPK(cmUnpkRgrSonPrbCfg, ¶m->u.prbCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
\f
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_ADV
/***********************************************************
{
TRC3(cmUnPkRgrSCellActDeactInfo)
- CMCHKUNPK(SUnpkU8, ¶m->sCellIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
+ return ROK;
}
/***********************************************************
U8 idx;
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numOfSCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numOfSCells, mBuf);
for(idx = 0; idx < param->numOfSCells;idx++)
{
CMCHKUNPK(cmUnPkRgrSCellActDeactInfo, ¶m->sCellActDeactInfo[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmPkRgrSCellActDeactInfo)
- CMCHKPK(SPkU8, param->sCellIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKPK(cmPkRgrSCellActDeactInfo, ¶m->sCellActDeactInfo[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->numOfSCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numOfSCells, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->action, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->action, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgrCfgReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->action, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
switch(param->action) {
case SCH_CONFIG:
CMCHKUNPK(cmUnpkRgrCfg, ¶m->u.cfgInfo, mBuf);
break;
#endif /* LTE_ADV */
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef RGR_V1
/* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
TRC3(cmPkRgrUeBsrTmrCfg)
- CMCHKPK(SPkU16, param->prdBsrTmr, mBuf);
- CMCHKPK(SPkU16, param->retxBsrTmr, mBuf);
- CMCHKPK(SPkU8, param->isPrdBsrTmrPres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->prdBsrTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->retxBsrTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPrdBsrTmrPres, mBuf);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkRgrUeBsrTmrCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isPrdBsrTmrPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->retxBsrTmr, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prdBsrTmr, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPrdBsrTmrPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->retxBsrTmr, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prdBsrTmr, mBuf);
+ return ROK;
}
#endif /* RGR_V1 */
/* rgr_c_001.main_4-ADD-Added for SI Enhancement. */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
sizeof(RgrSiCfgReqInfo)) != ROK) {
(ErrVal)ERGR049, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRSICFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
/***********************************************************
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR050, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR051, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,
sizeof(RgrSiCfgReqInfo))) != ROK) {
(ErrVal)ERGR052, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8 *)cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
if (pst->selector == ODU_SELECTOR_LC)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR053, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
+ return ((*func)(pst, spId, transId, cfgReqInfo));
}
/***********************************************************
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(SPkS32, param->cfgType, mBuf);
- CMCHKPK(SPkU8, param->siId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->siId, mBuf);
if(NULLP != param->pdu)
{
if (SFndLenMsg(param->pdu, &msgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
SPutMsg(param->pdu);
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
}
CMCHKPK(cmPkMsgLen, 0, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
if(msgLen > 0)
{
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, ¶m->pdu) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
}
}
- CMCHKUNPK(SUnpkU8, ¶m->siId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->siId, mBuf);
/*CMCHKUNPK(SUnpkS32, (S32 *)¶m->cfgType, mBuf);*/
/*Merge from Mohit Changes*/
CMCHKUNPK(SUnpkS32,(S32 *)&cfgType, mBuf);
param->cfgType = (RgrSiCfgType) cfgType;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrWarningSiCfgReqInfo(pst, warningSiCfgReqInfo, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* if the application wants to retain this structure, the below
(ErrVal)ERGR065, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRWARNINGSICFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}/*cmPkRgrWarningSiCfgReq*/
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR066, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR067, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&warningSiCfgReqInfo,
(ErrVal)ERGR068, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR069, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, warningSiCfgReqInfo));
+ return ((*func)(pst, spId, transId, warningSiCfgReqInfo));
} /* cmUnpkRgrWarningSiCfgReq */
\f
TRC3(cmPkRgrWarningSiCfgReqInfo)
- CMCHKPK(SPkU8, param->emtcEnable, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- CMCHKPK(SPkU8, param->siId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->siId, mBuf);
count = param->siPduLst.count;
node = param->siPduLst.last;
if(NULLP != pdu)
{
if (SFndLenMsg(pdu->pdu, &msgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SCatMsg(mBuf, pdu->pdu, M1M2) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
/* The PDU is not Released. This has to be done by
* the caller of the packing function */
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)node, sizeof(RgrSegmentInfo));
node= prevNode;
}
- CMCHKPK(SPkU32, count, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
+ return ROK;
}
\f
TRC3(cmUnpkRgrWarningSiCfgReqInfo)
cmLListInit(¶m->siPduLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++)
{
if(SFndLenMsg(mBuf, &msgLen) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(msgLen > 0)
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SSegMsg(mBuf, totalMsgLen-msgLen, &pdu) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&node,
sizeof(CmLList))) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
node->node = (PTR)pdu;
cmLListAdd2Tail(¶m->siPduLst, node);
}
- CMCHKUNPK(SUnpkU8, ¶m->siId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->siId, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKPK(SUnpkU8, ¶m->emtcEnable, mBuf);
+ CMCHKPK(oduPackUInt8, ¶m->emtcEnable, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR070, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, siId, mBuf);
+ CMCHKPK(oduUnpackUInt8, siId, mBuf);
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK)
(ErrVal)ERGR082, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
(ErrVal)ERGR071, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRWARNINGSISTOPREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}/*cmPkRgrWarningSiStopReq */
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR072, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR083, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKUNPK(SUnpkU8, &siId, mBuf);
+ CMCHKUNPK(oduPackUInt8, &siId, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, siId));
+ return ((*func)(pst, spId, transId, siId));
} /*cmUnpkRgrWarningSiStopReq */
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR073, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK)
+ if (oduUnpackUInt8(status, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ERGR074, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(siId, mBuf) != ROK)
+ if (oduUnpackUInt8(siId, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ERGR075, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK)
(ErrVal)ERGR076, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
(ErrVal)ERGR077, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRWARNINGSICFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkRgrWarningSiCfgCfm */
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR078, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR079, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&siId, mBuf) != ROK)
+ if (oduPackUInt8(&siId, mBuf) != ROK)
{
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR080, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK)
+ if (oduPackUInt8(&status, mBuf) != ROK)
{
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR081, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, siId, status));
+ return ((*func)(pst, suId, transId, siId, status));
}/* cmUnpkRgrwarningSiCfgCfm */
#endif/*RGR_SI_SCH*/
#endif
SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
sizeof(RgrLoadInfReqInfo)) != ROK) {
(ErrVal)ERGR049, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRLOADINFREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
/***********************************************************
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR050, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR051, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfReq,
(ErrVal)ERGR052, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8 *)loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR053, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, loadInfReq));
+ return ((*func)(pst, spId, transId, loadInfReq));
}
/***********************************************************
TRC3(cmPkRgrLoadInfReqInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- CMCHKPK(SPkU8, param->rgrCcPHighStartRb, mBuf);
- CMCHKPK(SPkU8, param->rgrCcPHighEndRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rgrCcPHighStartRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rgrCcPHighEndRb, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
{
TRC3(cmUnpkRgrLoadInfReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->rgrCcPHighEndRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rgrCcPHighStartRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rgrCcPHighEndRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rgrCcPHighStartRb, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_END */
{
TRC3(cmPkRgrUeCqiReptCfg)
- CMCHKPK(SPkU8, param->numColltdCqiRept, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numColltdCqiRept, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
{
TRC3(cmUnpkRgrUeCqiReptCfg)
- CMCHKUNPK(SUnpkU8, ¶m->numColltdCqiRept, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numColltdCqiRept, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
#endif
SPutSBuf(pst->region, pst->pool, (Data *)staInd,
sizeof(RgrStaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrStaIndInfo(staInd, mBuf) != ROK)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)staInd,
sizeof(RgrStaIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)staInd,
(ErrVal)ERGR057, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRSTAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*rgr_c_001.main_9 ADD added changes for CQI management*/
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR058, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&staInd,
(ErrVal)ERGR059, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrStaIndInfo(staInd, mBuf) != ROK)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR060, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, staInd));
+ return ((*func)(pst, suId, staInd));
}
\f
/*rgr_c_001.main_9 ADD added changes for CQI management*/
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
CMCHKPK(cmPkRgrUeCqiInfo, ¶m->ueCqiInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*rgr_c_001.main_9 ADD added changes for CQI management*/
/***********************************************************
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*rgr_c_001.main_9 ADD added changes for CQI management*/
/***********************************************************
{
CMCHKPK(cmPkRgrUeCqiRept, ¶m->cqiRept[idx], mBuf);
}
- CMCHKPK(SPkU8, param->numCqiRept, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCqiRept, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRgrUeCqiInfo */
/*rgr_c_001.main_9 ADD added changes for CQI management*/
U8 idx;
TRC3(cmUnpkRgrUeCqiInfo)
- CMCHKUNPK(SUnpkU8, ¶m->numCqiRept, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCqiRept, mBuf);
for (idx = 0; idx < param->numCqiRept; idx++)
{
CMCHKUNPK(cmUnpkRgrUeCqiRept, ¶m->cqiRept[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRgrUeCqiInfo */
/***********************************************************
TRC3(cmPkRgrSubBandCqiInfo)
- CMCHKPK(SPkU8, param->cqi[0], mBuf);
- CMCHKPK(SPkU8, param->cqi[1], mBuf);
- CMCHKPK(SPkU8, param->subBandIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->subBandIdx, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRgrSubBandCqiInfo */
/*rgr_c_001.main_9 ADD added changes for CQI management*/
TRC3(cmPkRgrUeCqiRept)
- CMCHKPK(SPkU8, param->cqi[0], mBuf);
- CMCHKPK(SPkU8, param->cqi[1], mBuf);
- CMCHKPK(SPkU8, param->cqiMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiMode, mBuf);
for (idx = param->numSubBand - 1; idx >= 0; idx--)
{
count = idx;
CMCHKPK(cmPkRgrSubBandCqiInfo, ¶m->sbCqiInfo[count], mBuf);
}
- CMCHKPK(SPkU8, param->numSubBand, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubBand, mBuf);
+ return ROK;
} /* cmPkRgrUeCqiRept */
/***********************************************************
TRC3(cmUnpkRgrSubBandCqiInfo)
- CMCHKUNPK(SUnpkU8, ¶m->subBandIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqi[1], mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqi[0], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->subBandIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[0], mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRgrSubBandCqiInfo*/
/*rgr_c_001.main_9 ADD added changes for CQI management*/
U8 idx;
TRC3(cmUnpkRgrUeCqiRept)
- CMCHKUNPK(SUnpkU8, ¶m->numSubBand, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubBand, mBuf);
for (idx = 0; idx < param->numSubBand; idx++)
{
CMCHKUNPK(cmUnpkRgrSubBandCqiInfo, ¶m->sbCqiInfo[idx], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->cqiMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqi[1], mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqi[0], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[0], mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRgrUeCqiRept */
#endif /* End of ifdef RGR_CQI_REPT */
#endif
SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrLoadInfIndInfo(loadInfInd, mBuf) != ROK)
sizeof(RgrLoadInfIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
sizeof(RgrLoadInfIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
(ErrVal)ERGR057, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRLOADINFIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/***********************************************************
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR058, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfInd,
(ErrVal)ERGR059, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* dsfr_pal_fixes ** 22-March-2013 ** SKS */
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR060, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, loadInfInd));
+ return ((*func)(pst, suId, loadInfInd));
}
\f
TRC3(cmPkRgrLoadInfIndInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- CMCHKPK(SPkU16, param->bw, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
if(RGR_ABS == param->type)
{
for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
{
- CMCHKPK(SPkU32, param->u.absLoadInfo[idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->u.absLoadInfo[idx], mBuf);
}
}
else
CMCHKPK(cmPkTknStrOSXL, ¶m->u.rntpInfo, mBuf);
}
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkRgrLoadInfIndInfo)
- CMCHKUNPK(SUnpkU32, ¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->type, mBuf);
if(RGR_ABS == param->type)
{
for(idx = RGR_ABS_PATTERN_LEN -1 ; idx >= 0; idx--)
{
- CMCHKUNPK(SUnpkU32, ¶m->u.absLoadInfo[(U8)idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->u.absLoadInfo[(U8)idx], mBuf);
}
}
else
/* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Start */
tknStr = ¶m->u.rntpInfo;
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if(tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
if ((SGetSBuf(pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGR052, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Value */
for (ndx = 1; ndx <= tknStr->len; ndx++)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[tknStr->len - ndx], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - ndx], mBuf);
}
}
}
/* dsfr_pal_fixes ** 21-March-2013 ** SKS ** End */
/* dsfr_pal_fixes ** 22-March-2013 ** SKS */
- CMCHKUNPK(SUnpkU16, ¶m->bw, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->bw, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_END */
if(param->pAPrsnt)
{
- CMCHKPK(SPkU32, param->pA, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pA, mBuf);
}
- CMCHKPK(SPkU8, param->pAPrsnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pAPrsnt, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
U32 tmpEnum;
TRC3(cmUnpkRgrUepACfg)
- CMCHKUNPK(SUnpkU8, (U8 *)¶m->pAPrsnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, (U8 *)¶m->pAPrsnt, mBuf);
if (param->pAPrsnt)
{
- CMCHKUNPK(SUnpkU32, (U32*)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)&tmpEnum, mBuf);
param->pA = (RgrUeDlPwrCntrlPaCfg) tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/*rgr_c_001.main_9 ADD PDSCH ded cfg*/
CMCHKPK(cmPkRgrUepACfg, ¶m->uepACfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
CMCHKUNPK(cmUnpkRgrUepACfg, ¶m->uepACfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
#endif
{
TRC3(cmPkRgrUeUlPwrDedSCellCfg)
- CMCHKPK(SPkU8, param->pSRSOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
CMCHKPK(SPkS8, param->p0UePusch, mBuf);
- CMCHKPK(SPkU8, param->isDeltaMCSEnabled, mBuf);
- CMCHKPK(SPkU8, param->isAccumulated, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkRgrUeUlPwrDedSCellCfg)
- CMCHKUNPK(SUnpkU8, ¶m->isAccumulated, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isDeltaMCSEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAccumulated, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isDeltaMCSEnabled, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->p0UePusch, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pSRSOffset, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->pSRSOffset, mBuf);
+ return ROK;
}
#endif
{
CMCHKPK(cmPkRgrUeUlPwrDedSCellCfg,¶m->ueSCellUlDedPwrCfg, mBuf);
- CMCHKPK(SPkU8, param->isUlCaEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isUlCaEnabled, mBuf);
CMCHKPK(cmPkRgrUeTxModeCfg, ¶m->txMode, mBuf);
#ifdef TFU_UPGRADE
/*rgr_c_001.main_9 ADD PDSCH ded cfg*/
#endif
CMCHKPK(cmPkRgrUeDlCqiCfg,¶m->ueSCellDlCqiCfg, mBuf);
CMCHKPK(cmPkTknU32, ¶m->sCellDeActTmr, mBuf);
- CMCHKPK(SPkU16, param->sCellId, mBuf);
- CMCHKPK(SPkU8, param->sCellIdx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkRgrUeSecCellCfg, ¶m->ueSCellDedCfg[(U8)idx],mBuf);
}
- CMCHKPK(SPkU8, param->numSCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
- CMCHKPK(SPkU8, param->useExtBSRSizes, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->useExtBSRSizes, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
Buffer *mBuf;
#endif
{
- CMCHKUNPK(SUnpkU8, ¶m->sCellIdx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
CMCHKUNPK(cmUnpkTknU32, ¶m->sCellDeActTmr, mBuf);
CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, ¶m->ueSCellDlCqiCfg, mBuf);
#ifdef TFU_UPGRADE
CMCHKUNPK(cmUnpkRgrUePdschDedCfg, ¶m->uePdschDedCfg, mBuf);
#endif
CMCHKUNPK(cmUnpkRgrUeTxModeCfg, ¶m->txMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isUlCaEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isUlCaEnabled, mBuf);
CMCHKUNPK(cmUnpkRgrUeUlPwrDedSCellCfg, ¶m->ueSCellUlDedPwrCfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
{
U8 idx;
- CMCHKUNPK(SUnpkU8, ¶m->useExtBSRSizes, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->useExtBSRSizes, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
for(idx = 0; idx < param->numSCells;idx++)
{
CMCHKUNPK(cmUnpkRgrUeSecCellCfg, ¶m->ueSCellDedCfg[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/* Sprint 3 */
/***********************************************************
{
for(idx = param->u.format1Bcs.sCellAckN1ResTb2Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(SPkU16, param->u.format1Bcs.sCellAckN1ResTb2[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
for(idx = param->u.format1Bcs.sCellAckN1ResTb1Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(SPkU16, param->u.format1Bcs.sCellAckN1ResTb1[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
}
else
{
for(idx = param->u.format3.sCellAckN3ResAntP1Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(SPkU16, param->u.format3.sCellAckN3ResAntP1[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
for(idx = param->u.format3.sCellAckN3ResAntP0Count- 1; idx >=0 ;idx--)
{
- CMCHKPK(SPkU16, param->u.format3.sCellAckN3ResAntP0[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
}
- CMCHKPK(SPkU32, param->pucchFormatType, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pucchFormatType, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkRgrUeSCellAckPucchCfg);
- CMCHKUNPK(SUnpkU32, (U32*)¶m->pucchFormatType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)¶m->pucchFormatType, mBuf);
//if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
{
- CMCHKUNPK(SUnpkU8, ¶m->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb1Count; idx++)
{
- CMCHKUNPK(SUnpkU16, ¶m->u.format1Bcs.sCellAckN1ResTb1[idx], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->u.format1Bcs.sCellAckN1ResTb1[idx], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb2Count; idx++)
{
- CMCHKUNPK(SUnpkU16, ¶m->u.format1Bcs.sCellAckN1ResTb2[idx], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->u.format1Bcs.sCellAckN1ResTb2[idx], mBuf);
}
}
else
{
- CMCHKUNPK(SUnpkU8, ¶m->u.format3.sCellAckN3ResAntP0Count, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.format3.sCellAckN3ResAntP0Count, mBuf);
for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP0Count; idx++)
{
- CMCHKUNPK(SUnpkU16, ¶m->u.format3.sCellAckN3ResAntP0[idx], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->u.format3.sCellAckN3ResAntP0[idx], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->u.format3.sCellAckN3ResAntP1Count, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.format3.sCellAckN3ResAntP1Count, mBuf);
for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP1Count; idx++)
{
- CMCHKUNPK(SUnpkU16, ¶m->u.format3.sCellAckN3ResAntP1[idx], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->u.format3.sCellAckN3ResAntP1[idx], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
sizeof(RgrUeStaIndInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
(ErrVal)ERGR057, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGRUESTAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*rgr_c_001.main_9 ADD added changes for CQI management*/
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR058, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueStaInd,
(ErrVal)ERGR059, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGR060, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, ueStaInd));
+ return ((*func)(pst, suId, ueStaInd));
}
\f
/***********************************************************
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
- CMCHKPK(SPkU8, param->status, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
TRC3(cmUnpkRgrUeStaIndInfo)
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmPkRgrCellCsgParamCfg)
- CMCHKPK(SPkU8, param->minUlResNonCsg, mBuf);
- CMCHKPK(SPkU8, param->minDlResNonCsg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->minUlResNonCsg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->minDlResNonCsg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkRgrCellCsgParamCfg)
- CMCHKUNPK(SUnpkU8, ¶m->minDlResNonCsg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->minUlResNonCsg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->minDlResNonCsg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->minUlResNonCsg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
switch(param->cmdType)
{
case RGR_CNTRL_CMD_RACH_OVRLD:
- CMCHKUNPK(SPkU8, param->cmdDesc.rachOvrLd.backOffVal, mBuf);
- CMCHKUNPK(SPkU8, param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffVal, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
break;
case RGR_CNTRL_CMD_CPU_OVRLD:
- CMCHKUNPK(SPkU8, param->cmdDesc.cpuOvrLd.instruction, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.cpuOvrLd.instruction, mBuf);
break;
default:
break;
}
- CMCHKUNPK(SPkU32, param->cmdType, mBuf);
+ CMCHKUNPK(oduUnpackUInt32, param->cmdType, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
TRC3(cmUnpkRgrCellCntrlCmdCfg)
- CMCHKUNPK(SUnpkU32, &tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
param->cmdType = (RgrCellCntrlCmdType) tmpEnum;
switch(param->cmdType)
{
case RGR_CNTRL_CMD_RACH_OVRLD:
- CMCHKUNPK(SUnpkU8, ¶m->cmdDesc.rachOvrLd.backOffEnb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cmdDesc.rachOvrLd.backOffVal, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cmdDesc.rachOvrLd.backOffEnb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cmdDesc.rachOvrLd.backOffVal, mBuf);
break;
case RGR_CNTRL_CMD_CPU_OVRLD:
- CMCHKUNPK(SUnpkU8, ¶m->cmdDesc.cpuOvrLd.instruction, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cmdDesc.cpuOvrLd.instruction, mBuf);
break;
default:
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* End of if defined(LCRGR) */
Code Review / o-du / l2.git / blobdiff