int16_t _ret; \
_ret = SGetSBufWls(0, 0, (Data **)&_datPtr, _size); \
if(_ret == ROK) \
- cmMemset((U8*)_datPtr, 0, _size); \
+ memset((U8*)_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
uint8_t packLcSlotInd (Pst *pst, SlotIndInfo *slotInd)
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
/* pack SFN and slot value */
- CMCHKPK(SPkU16,slotInd->sfn, mBuf);
- CMCHKPK(SPkU16,slotInd->slot, mBuf);
+ CMCHKPK(oduUnpackUInt16,slotInd->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt16,slotInd->slot, mBuf);
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
* @return
* -# ROK
**/
-PUBLIC int MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
+PUBLIC uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
{
printf("\nReceived Scheduler gen config at MAC");
pst->dstInst = DEFAULT_CELLS + 1;
uint16_t ret = ROK;
MacCellCb *macCellCb;
- cmMemset((uint8_t *)&cfmPst, 0, sizeof(Pst));
+ memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
MAC_ALLOC(macCellCb, sizeof(MacCellCb));
if(macCellCb == NULLP)
{
SchCellCfg schCellCfg;
Pst cfgPst;
- int ret;
+ uint8_t ret;
- cmMemset((uint8_t *)&cfgPst, 0, sizeof(Pst));
+ memset((uint8_t *)&cfgPst, 0, sizeof(Pst));
schCellCfg.cellId = macCellCfg->cellId;
schCellCfg.phyCellId = macCellCfg->phyCellId;
schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
uint16_t cellIdx;
MacCellCfgCfm macCellCfgCfm;
- cmMemset((uint8_t *)&pst, 0, sizeof(Pst));
+ memset((uint8_t *)&pst, 0, sizeof(Pst));
GET_CELL_IDX(cellId, cellIdx);
macCellCfgCfm.cellId = macCb.macCell[cellIdx]->macCellCfg.cellId;
DU_LOG("\nMAC : Slot Indication received");
/*starting Task*/
- SStartTask(&startTime, PID_MAC_TTI_IND);
+ ODU_START_TASK(&startTime, PID_MAC_TTI_IND);
/* send slot indication to scheduler */
ret = sendSlotIndMacToSch(slotInd);
}
/*stoping Task*/
- SStopTask(startTime, PID_MAC_TTI_IND);
+ ODU_STOP_TASK(startTime, PID_MAC_TTI_IND);
return ret;
} /* fapiMacSlotInd */
if (_padBuf == NULLP) \
{ \
RLOG0(L_ERROR, "RGERR_MUX_BLD_CEHDR_FAIL");\
- RETVALUE(RFAILED);\
+ return RFAILED;\
} \
if (mInfo->endptr == NULLP) { \
sduEnd = _sduBuf; \
{\
if(_inst >= RG_MAX_INST)\
{\
- RETVALUE(RFAILED);\
+ return RFAILED;\
}\
}
|| rgCb[inst].inactiveCell != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell already exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
|| cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,
"Invalid Bandwidth configuration: ul %d dl %d",
cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,
"Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef TENB_MULT_CELL_SUPPRT
if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
cellCfg->rguDlSapId,
cellCfg->rguUlSapId,
cellCfg->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgCellCfg */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Transmission Mode=%d not supported",
ueCfg->txMode.tm);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Active cell */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Active Cell does not exist for cellId%d",
ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if Ue already configured */
if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Ue already exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "Invalid Uplink HARQ config %d ",
ueCfg->ueUlHqCfg.maxUlHqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef TENB_MULT_CELL_SUPPRT
if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
ueCfg->rguDlSapId,
ueCfg->rguUlSapId,
ueCfg->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgUeCfg */
if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for dedicated LC failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (lcCfg->lcType == CM_LTE_LCH_BCCH
if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for common logical channels failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel type %d",
lcCfg->lcType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
if ( lcCfg->qci < RG_QCI_MIN ||
)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid qci %x",lcCfg->qci);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*validate qci */
#endif /*LTE_L2_MEAS */
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgLcCfg */
&& ((*cell = rgCb[inst].inactiveCell) == NULLP))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell does not exist");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((*cell)->cellId != cellRecfg->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId, "Cell does not exist %d\n",cellRecfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,
"Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgCellRecfg */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Transmission Mode=%d not supported",
ueRecfg->txMode.tm);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Active cell */
|| ((*cell)->cellId != ueRecfg->cellId))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,ueRecfg->cellId, "Active Cell does not exist\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fix : syed UE ID change at MAC will now be controlled
if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"[%d]Old Ue does not exist", ueRecfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config for UE %d",
ueRecfg->ueUlHqRecfg.maxUlHqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgUeRecfg */
|| ((*cell)->cellId != lcRecfg->cellId))
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue for dedicated channels */
if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Ue does not exist for dedicated logical channel");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
{
RLOG_ARG1(L_ERROR, DBG_CRNTI,lcRecfg->crnti,"Dedicated UL LC does not exist %d",lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Invalid lcgId for uplink logical channel lcg %d lc %d",
lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgLcRecfg */
/* Start: LTEMAC_2.1_DEV_CFG */
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",reset->crnti, reset->cellId));
RLOG_ARG1(L_ERROR,DBG_CRNTI,reset->crnti,"Active Cell does not exist %d",reset->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,reset->crnti,"UE does not exist");
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgUeReset*/
/* End: LTEMAC_2.1_DEV_CFG */
if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize the cell */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization for cell failed");
rgCFGFreeInactvCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
if (RFAILED == RgLaaCellCbInit(cell))
{
rgCFGFreeInactvCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Allocate a buffer for flowCntrlInd.*/
SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
sizeof(RguFlowCntrlInd));
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgCellCfg */
#ifdef LTE_ADV
"[%d]Ue already exist in scell %d during scell addition\n",
ueSCellCb->ueId,
cell->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create UeCb */
{
RGDBGERRNEW(dstMacInst, (rgPBuf(dstMacInst),
"[%d]UeCb creation failed\n", ueSCellCb->ueId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
{
RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
"[%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDBMInsUeCb(cell, ueCb);
ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
}
- RETVALUE(ROK);
+ return ROK;
}/* rgCfgAddUeSCellCfg */
/**
RGDBGERRNEW(inst,(rgPBuf(inst),
"[%d]Active Cell does not exist %d\n",
ueRecfg->oldCrnti, ueRecfg->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGDBGPRM(inst,(rgPBuf(inst),
{
RGDBGERRNEW(inst,(rgPBuf(inst),
"[%d]Ue does not exist\n", ueRecfg->oldCrnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
} /*end of for loop */
*isCfmRqrd = FALSE;
- RETVALUE(ROK);
+ return ROK;
} /* rgFillAndAddSCellCfg */
#endif /* LTE_ADV */
if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb creation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb Harq Entity Initialization failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
handover = TRUE;
}
/* Update satistics */
rgUpdtUeCnt(inst,RG_CFG_ADD);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeCfg */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,
"Dedicated logical channel configuration failed %d",lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
/*ERAB Multl Cell fix*/
{
RLOG_ARG1(L_ERROR, DBG_CRNTI, lcCfg->crnti, "Common logical channel configuration"
"failed %d\n", lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
errInfo->errCause = RGERR_NONE;
RLOG_ARG1(L_INFO, DBG_CRNTI,lcCfg->crnti, "CRG LC config done for UE: lcId %d\n", lcCfg->lcId);
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgLcCfg */
cell->rachCfg = cellRecfg->rachRecfg;
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgCellRecfg */
rgUHMCrgUeRecfg(cell, ue, ueRecfg);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeRecfg */
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgLcRecfg */
/* Start: LTEMAC_2.1_DEV_CFG */
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeReset */
/* End: LTEMAC_2.1_DEV_CFG */
RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,"Cell does not exist");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Delete cell from inactive list */
rgCFGFreeInactvCellCb(cell);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
}
/* Delete from the cell list */
errInfo->errCause = RGERR_NONE;
RGDBGINFO(inst,(rgPBuf(inst), "Cell %d deleted\n", cellDelInfo->u.cellDel.cellId));
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgCellDel */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueDelInfo->u.ueDel.crnti,"Cell does not exist %d",
ueDelInfo->u.ueDel.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
/* Fix: syed Context Deletion is relied upon SCH indication */
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeDel */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Cell does not exist %d",
lcDelInfo->u.lchDel.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,
"UE does not exist for dedicated logical channel");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate downlink info */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"DL LC %d does not exist",
lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDBMDelDlDedLcCb(ue, dlLc);
dirVld = TRUE;
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"UL LC %d does not exist",
lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDBMDelUlDedLcCb(ue, ulLc);
dirVld = TRUE;
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Invalid direction %d for LC Delete",
lcDelInfo->u.lchDel.dir);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
/*ERAB - multicell fix*/
rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
#endif
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgLcDel */
/***********************************************************
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Active Cell does not exist: Cell %d",
lcCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE does not exist for dedicated logical channel %d",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate logical channel Id */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel Id %d",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate downlink info */
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated DL LC %d already configured",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
dirVld = TRUE;
}
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Invalid lcgId for uplink logical channel %d",
lcCfg->ulInfo.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated UL LC %d already configured",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
dirVld = TRUE;
}
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid Direction %d",
lcCfg->dir);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgDedLcCfg */
&& ((*cell)->cellId != lcCfg->cellId))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Active Cell exists for common channels");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the inactive cell for common logical channels */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Inactive Cell does not exist for common channels");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate downlink info */
if (lcCfg->dir & CRG_DIR_TX)
if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on DLSCH already configured for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
if (rgDBMGetBcchOnBch(*cell) != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on BCH already configured for cell %d");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid transport channel %d for cell",
lcCfg->dlInfo.dlTrchType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
if (rgDBMGetPcch(*cell) != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"PCCH already configured for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (RG_DLCCCH_ISCFGD(*cell))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"DL CCCH already configured for cell %d");
- RETVALUE(RFAILED);
+ return RFAILED;
}
dirVld = TRUE;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid UL common lcType %d for cell ",
lcCfg->lcType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (RG_ULCCCH_ISCFGD(*cell))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"UL CCCH already configured for cell ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
dirVld = TRUE;
}
if (!dirVld)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid Direction %d", lcCfg->dir);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgCmnLcCfg */
/***********************************************************
{
rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgDedLcCfg */
config\n", lcCfg->lcId);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgCmnLcCfg */
#ifdef LTE_L2_MEAS
/***********************************************************
if(NULLP == regReq)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell == NULLP) || (cell->cellId != regReq->cellId))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize */
cell->schInstMap.cellSapId = regReq->cellSapId;
cell->schInstMap.schInst = pst->srcInst;
cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacCellRegReq */
- RETVALUE(ret);
+ return (ret);
}
}
#endif
RGDBGINFO(inst,(rgPBuf(inst), "CRG Configuration request processed\n"));
- RETVALUE(ret);
+ return (ret);
} /* rgCOMCfgReq */
/**
* @brief Handler for processing Cell/Ue/Logical channel configuration request
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cfg->u.cellCfg.cellId, "Cell configuration validation FAILED\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgCFGCrgCellCfg(inst,&cfg->u.cellCfg, errInfo);
break;
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CRNTI,cfg->u.ueCfg.crnti, "Ue configuration validation FAILED\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgCFGCrgUeCfg(inst,cell, &cfg->u.ueCfg, errInfo);
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cfg->u.cellCfg.cellId,
"LC configuration validation FAILED: LC %d\n", cfg->u.lchCfg.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgCFGCrgLcCfg(inst,cell, ue, &cfg->u.lchCfg, errInfo,isCfmRqrd,transId);
break;
default:
{
RLOG1(L_ERROR, "Should never come here: cfgType %d",cfg->cfgType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ret);
+ return (ret);
} /* rgCOMHndlCfgReq */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,recfg->u.cellRecfg.cellId,
"Cell Recfg Validation FAILED");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgCFGCrgCellRecfg(inst,cell, &recfg->u.cellRecfg, errInfo);
break;
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue SCell configuration FAILED for inst [%d]\n",
recfg->u.ueRecfg.oldCrnti, inst));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.ueRecfg.cellId,
"Ue Re-configuration validation FAILED OLD CRNTI:%d",
recfg->u.ueRecfg.oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgCFGCrgUeRecfg(inst,cell, ue, &recfg->u.ueRecfg, errInfo);
}
RLOG_ARG2(L_ERROR,DBG_CELLID,recfg->u.lchRecfg.cellId,
"LC Re-configuration validation FAILED LCID:%d CRNTI:%d",
recfg->u.lchRecfg.lcId,recfg->u.lchRecfg.crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
{
RLOG1(L_ERROR, "Should never come here: recfgType %d",
recfg->recfgType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ret);
+ return (ret);
} /* rgCOMHndlRecfgReq */
/*Start: LTEMAC_2.1_DEV_CFG */
errInfo->errCause = RGERR_NONE;
RGDBGINFO(inst,(rgPBuf(inst), "CRG UE Reset processed \n"));
- RETVALUE(ROK);
+ return ROK;
} /* rgCOMHndlResetReq */
/*End: LTEMAC_2.1_DEV_CFG */
{
RLOG1(L_ERROR, "Should never come here: delType %d",
del->delType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ret);
+ return (ret);
} /* rgCOMHndlDelReq */
#ifdef LTE_ADV
/* Send positive confirmation to primary cell*/
RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
- RETVALUE(ROK);
+ return ROK;
} /* RgPrgPMacSMacUeSCellCfgReq */
/**
{
RGDBGERRNEW(inst,(rgPBuf(inst),
"[%d]Ue does not exist\n", cfgCfm->ueId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(cfgCfm->event)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "Invalid configuration confirm event %d\n",
cfgCfm->event));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* RgPrgSMacPMacCfgCfm */
/**
* cell is already deleted for this cell*/
if(sCell == NULLP)
{
- RETVALUE(ROK);
+ return ROK;
}
/* Retrive the UeCb from sec cell*/
if ((sCellUe = rgDBMGetUeCb(sCell, ueSCellDelInfo->ueId)) == NULLP)
{
RGDBGERRNEW(inst, (rgPBuf(inst), "[%d]UE:does not exist in sCell(%d)\n",
ueSCellDelInfo->ueId, sCell->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*PMAC_Reest: ueId and newRnti is different that means its a UeId change
{
RGDBGERRNEW(inst, (rgPBuf(inst), "[%d]UE:UE context already exist in\
sCell(%d)",ueSCellDelInfo->newRnti, sCell->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDBMDelUeCb(sCell, sCellUe);
rgCFGFreeUeCb(sCell, sCellUe);
}
- RETVALUE(ROK);
+ return ROK;
} /* RgPrgPMacSMacUeSCellDelReq */
#endif /*LTE_ADV */
/**********************************************************************
/* Initialize ue list */
if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#ifdef LTEMAC_SPS
/* Initialize SPS Ue list */
if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#endif /* LTEMAC_SPS */
/* Initialize BCCH/PCCH logical channels */
/* Initialize rach ue list */
rgDBMInitRachLst(cellCb);
- RETVALUE(ret);
+ return (ret);
} /* rgDBMInitCell */
RgUeCb ue;
TRC2(rgDBMInitUeCbLst)
- RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
+ return (cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
} /* rgDBMInitUeCbLst */
{
TRC2(rgDBMDeInitUeCbLst)
- RETVALUE(cmHashListDeinit(&cellCb->ueLst));
+ return (cmHashListDeinit(&cellCb->ueLst));
} /* rgDBMDeInitUeCbLst */
RgUeCb ue;
TRC2(rgDBMInitSpsUeCbLst)
- RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
+ return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
} /* rgDBMInitSpsUeCbLst */
{
TRC2(rgDBMDeInitSpsUeCbLst)
- RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
+ return (cmHashListDeinit(&cellCb->spsUeLst));
} /* rgDBMDeInitSpsUeCbLst */
{
TRC2(rgDBMInsUeCb)
- RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
+ return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
(U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
} /* rgDBMInsUeCb */
{
TRC2(rgDBMInsSpsUeCb)
- RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
+ return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
(U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
} /* end of rgDBMInsSpsUeCb */
cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCb);
- RETVALUE(ueCb);
+ return (ueCb);
} /* rgDBMGetUeCb */
#ifdef LTEMAC_SPS
cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
- RETVALUE(ueCb);
+ return (ueCb);
} /* rgDBMGetSpsUeCb */
#endif /* LTEMAC_SPS */
TRC2(rgDBMGetNextUeCb)
cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
- RETVALUE(nextUeCb);
+ return (nextUeCb);
} /* rgDBMGetNextUeCb */
#ifdef LTEMAC_SPS
TRC2(rgDBMGetNextSpsUeCb)
cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
- RETVALUE(nextUeCb);
+ return (nextUeCb);
} /* end of rgDBMGetNextSpsUeCb */
#endif /* LTEMAC_SPS */
{
TRC2(rgDBMDelUeCb)
- RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
+ return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
} /* rgDBMDelUeCb */
#ifdef LTEMAC_SPS
{
TRC2(rgDBMDelSpsUeCb)
- RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
+ return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
} /* end of rgDBMDelSpsUeCb */
#endif /* LTEMAC_SPS */
if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
- RETVALUE(&ueCb->dl.lcCb[idx-1]);
+ return (&ueCb->dl.lcCb[idx-1]);
} /* rgDBMGetDlDedLcCb */
if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
- RETVALUE(&ueCb->ul.lcCb[idx-1]);
+ return (&ueCb->ul.lcCb[idx-1]);
} /* rgDBMGetDlDedLcCb */
/**
if(cellCb->bcchBchInfo.lcId == lcId)
{
- RETVALUE(ROK);
+ return ROK;
}
if(cellCb->pcchInfo.lcId == lcId)
{
- RETVALUE(ROK);
+ return ROK;
}
for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
{
if(cellCb->bcchDlschInfo[idx].lcId == lcId)
{
- RETVALUE(ROK);
+ return ROK;
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgDBMChkCmnLcCb */
/**
if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->bcchBchInfo));
+ return (&(cellCb->bcchBchInfo));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgDBMGetBcchOnBch */
/**
{
if(cellCb->bcchDlschInfo[idx].lcId == lcId)
{
- RETVALUE(&(cellCb->bcchDlschInfo[idx]));
+ return (&(cellCb->bcchDlschInfo[idx]));
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgDBMGetBcchOnDlsch */
/**
if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->pcchInfo));
+ return (&(cellCb->pcchInfo));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgDBMGetPcch */
/**
{
if(((RgUeCb *)tmpNode->node)->ueId == key)
{
- RETVALUE((RgUeCb *)(tmpNode->node));
+ return ((RgUeCb *)(tmpNode->node));
}
CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgDBMGetUeCbFromRachLst */
/**
if(!ueCb)
{
- RETVALUE( cellCb->raInfo.ueRachLst.first ?
+ return ( cellCb->raInfo.ueRachLst.first ?
(RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
}
- RETVALUE( ueCb->rachLstEnt.next ?
+ return ( ueCb->rachLstEnt.next ?
(RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
} /* rgDBMGetNextUeCbFromRachLst */
rgFreeSBuf(inst,(Data **)&(hqE->procs[idx1]), sizeof(RgDlHqProcCb));
}
RLOG0(L_ERROR, "Memory Alloc Failure for RgDlHqProcCb");
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqE->procs[idx1]->procId = idx1;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMHqEntInit */
/**
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqP->tbInfo[tbIndex-1].numSchLch = 0;
hqP->tbInfo[tbIndex-1].contResCe = NOTPRSNT;
hqP->tbInfo[tbIndex-1].contResId = NULLP;
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMRlsHqProc */
/**
/* Pick the proc based on the index provided */
*hqP = (ue->dl.hqEnt.procs[idx]);
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMGetHqProcFrmId */
/*PRIVATE U32 dataAvl; */
hqP->tbInfo[i].timingInfo.slot, hqP->procId,
hqP->tbInfo[i].pdcch.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
hqP->tbInfo[i].timingInfo.slot, hqP->procId,
hqP->tbInfo[i].pdcch.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
/*Padding is not done so data for this UE will not be
rgDHMRlsHqProcTB(cellCb, hqP, 2);
}
- RETVALUE(ROK);
+ return ROK;
}
if (rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
&(datInfo->memCp)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fill the TFU Dat Req with information from Harq Proc */
cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
datReq->lnk.node = (PTR)datReq;
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMSndDatReq */
/**
}
rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(i=0;i<datReq->nmbOfTbs;i++)
rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
printf("\nrgDHMHndlDedDatReq:: hqP %p \n", (Void *)hqProc);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef L2_OPTMZ
}
rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*
SFndLenMsg(hqProc->tbInfo[i].tb, &len);
*/
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMHndlDedDatReq */
/**
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_HARQ);
rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
LRG_CAUSE_HQ_PROC_BUSY, &dgn);
- RETVALUE(RFAILED);
+ return RFAILED;
}
bldPdu.datReq = datReq;
hqProc->tbInfo[0].pdcch.rnti);
RG_FREE_MSG(datReq->pdu);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMHndlCmnDatReq */
/**
{
err->errType = RGERR_DHM_SND_STA_IND;
err->errCause = RG_DHM_MEM_ALLOC_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
err->errType = RGERR_DHM_SND_STA_IND;
err->errCause = RG_DHM_MEM_ALLOC_FAIL;
/* Need to return as memory allocation will fail for other UEs also*/
- RETVALUE(RFAILED);
+ return RFAILED;
}
dStaInd[rguDlSpId]->nmbOfUeGrantPerTti = 0;
rguDlSap[rguDlSpId] = ue->rguDlSap;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMSndConsolidatedStaInd */
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
tb = &(hqP->tbInfo[tbIndex-1].tb);
}
hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sf = NULLP;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
RGDBGERRNEW(inst,(rgPBuf(inst), "For user [%d]Cell does not exist %d\n",
hqEntInfo->crnti,hqEntInfo->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, hqEntInfo->crnti)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE does not exist for this hqEntInfo\n",
hqEntInfo->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDHMUeReset(cell, &ue->dl.hqEnt);
- RETVALUE(ROK);
+ return ROK;
}
U32 gSaveVal;
\f
if(NULLP == rlshqUeInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell == NULLP)
RLOG_ARG0(L_ERROR,DBG_CELLID,rlshqUeInfo->cellId,
"No cellCb found with cellId");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(NULLP == rlshqUeInfo->ueHqInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx1 = 0; idx1 < rlshqUeInfo->numUes; idx1++)
/*starting Task*/
SStopTask(startTime,PID_MAC_AM_HARQ_RLS);
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacRlsHqReq */
}
#define RG_UNPACK_SHORT_BSR(_bsr, _mBuf, _ret) {\
- _ret = SUnpkU8((_bsr), (_mBuf)); \
+ _ret = oduPackUInt8((_bsr), (_mBuf)); \
}
#define RG_UNPACK_TRUNC_BSR(_bsr, _mBuf, _ret) {\
- _ret = SUnpkU8((_bsr), (_mBuf)); \
+ _ret = oduPackUInt8((_bsr), (_mBuf)); \
}
#define RG_UNPACK_PHR(_phr, _mBuf, _ret) {\
- _ret = SUnpkU8((_phr), (_mBuf)); \
+ _ret = oduPackUInt8((_phr), (_mBuf)); \
}
#define RG_UNPACK_CRNTI(_rnti, _mBuf, _ret) {\
/* For EXT PHR DEMUX */
#define RG_UNPACK_EXT_PHR_CI(_ci, _mBuf, _ret) {\
- _ret = SUnpkU8((_ci), (_mBuf)); \
+ _ret = oduPackUInt8((_ci), (_mBuf)); \
}
#define RG_UNPACK_EXT_PHR(_extPhr, _mBuf, _ret) {\
- _ret = SUnpkU8((_extPhr), (_mBuf)); \
+ _ret = oduPackUInt8((_extPhr), (_mBuf)); \
}
{
RLOG1(L_ERROR, "Allocation of RgSubHdr failed for LCID:%d",lcId);
err->errCause = RGERR_DUX_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
*sdu = sduAloc;
RG_INIT_SDU(sduAloc, lcId, sduLen);
cmLListAdd2Tail(&pdu->sduLst, &sduAloc->sduLstEnt);
- RETVALUE(ROK);
+ return ROK;
}
/**
TRC2(rgDUXExtSubHdr)
*len = 0;
- if(SUnpkU8(&byte,mBuf) != ROK)
+ if(oduPackUInt8(&byte,mBuf) != ROK)
{
- RLOG0(L_ERROR, "SUnpkU8 failed");
+ RLOG0(L_ERROR, "oduPackUInt8 failed");
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Extract the lcid */
RG_EXT_LCID(*lcId, byte);
if(*lcId <= RG_DEDLC_MAX_LCID)
{ /* variable size MAC Sub PDU */
RG_EXT_FORMT_BIT(fmt,byte);
- if(SUnpkU8(&byte, mBuf) != ROK)
+ if(oduPackUInt8(&byte, mBuf) != ROK)
{
- RLOG0(L_ERROR, "SUnpkU8 failed");
+ RLOG0(L_ERROR, "oduPackUInt8 failed");
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
*len = byte;
if(fmt)
{
- if(SUnpkU8(&byte,mBuf) != ROK)
+ if(oduPackUInt8(&byte,mBuf) != ROK)
{
- RLOG0(L_ERROR, "SUnpkU8 failed");
+ RLOG0(L_ERROR, "oduPackUInt8 failed");
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
*len = (*len << 8) | byte;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDUXExtSubHdr */
/**
{
RLOG1(L_ERROR,"Unpacking of EXT PHR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Not handling Type 2 PHR report as simultaneous PUSCH/PUCCH
{
RLOG1(L_ERROR,"Unpacking of EXT PHR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* extPhrOctet: Bits : 7 6 5 4 3 2 1 0
{
RLOG1(L_ERROR,"Unpacking of EXT PHR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
extPhr->servCellPhr[extPhr->numServCells].pCmax = (extPhrPCmax & 0x3F);
}
{
RLOG1(L_ERROR,"Unpacking of PHR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ceInfo->bitMask |= RG_PHR_CE_PRSNT;
}
{
RLOG1(L_ERROR,"Unpacking of Trunc BSR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ceInfo->bitMask |= RG_TRUNC_BSR_CE_PRSNT;
}
{
RLOG1(L_ERROR,"Unpacking of Short BSR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ceInfo->bitMask |= RG_SHORT_BSR_CE_PRSNT;
}
{
RLOG1(L_ERROR,"Unpacking of Long BSR failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
RG_EXT_BS(longBsr,
ceInfo->ces.bsr.longBsr.bs1,
{
RLOG1(L_ERROR,"Unpacking of C-RNTI failed LCID:%d",lcId);
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ceInfo->bitMask |= RG_CRNTI_CE_PRSNT;
}
default:
RLOG1(L_ERROR, "Invalid LCID:%u received",lcId);
err->errCause = RGERR_DUX_INV_LCID_RX;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDUXExtCe */
if(rgDUXInsSdu(inst,pdu, &sdu,lcId, subPduLen, err) != ROK)
{
RG_FREE_MSG(*mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
tmpBuf1 = *mBuf;
RG_FREE_MSG(tmpBuf1);
RLOG0(L_ERROR,"SSegMsg failed");
err->errCause = RGERR_DUX_RLC_PDU_CREAT_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
sdu->mBuf = tmpBuf1;
*mBuf = tmpBuf2;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDUXExtSdu */
/**
if(*mBuf == NULLP)
{
RLOG0(L_ERROR, "Null Buffer Recevived");
- RETVALUE(RFAILED);
+ return RFAILED;
}
do
{
{
RG_FREE_MSG(*mBuf);
RLOG0(L_ERROR, "Failed to extract pad sub headers");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(lcId == RG_PAD_LCID)
{ /*at end of MAC PDU, Padding started */
RG_FREE_MSG(*mBuf);
- RETVALUE(ROK);
+ return ROK;
}
if(lcId <= RG_DEDLC_MAX_LCID)
{
* will be responsible for freeing mBuf */
*mBuf = NULLP;
RLOG0(L_ERROR, "failed to Extract the sdus");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(*mBuf == NULLP) /* if message read completes then return */
{
- RETVALUE(ROK);
+ return ROK;
}
}
else
{
RG_FREE_MSG(*mBuf);
RLOG0(L_ERROR, " failed to Extract the ces");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(SFndLenMsg(*mBuf,&len) != ROK)
RG_FREE_MSG(*mBuf);
RLOG0(L_ERROR,"mBuf length check failed");
err->errCause = RGERR_DUX_UNPACK_FAILURE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}while(len);
RG_FREE_MSG(*mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* rgDUXDemuxData */
/**********************************************************************
RG_FREE_MSG(mBuf);
break;
}
- SExitTsk();
- RETVALUE(ROK);
+ ODU_EXIT_TASK();
+ return ROK;
}/* end of rgActvTsk */
\f
if ((measCb = rgL2mAllocMeasCb(cell, measInfo, err)) == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Allocation of RgL2MeasCb failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
//Memcpy is already done in rgL2mAllocMeasCb
/*cmMemcpy((U8 *)&measCb->measReq, (CONSTANT U8 *)measInfo,\
}
cell->qciArray[measInfo->t.prbReq.qci[idx]].mask = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgL2mCreateMeasCb */
LRG_L2MEAS_AVG_PRB_PER_QCI_UL, err)) != ROK)
{
/* Clear Downlink MeasCb created Above If exists*/
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgL2mMeasReq */
/** @brief This function sends the measurement confirm
* from mac to scheduler
(cellCb->cellId != measInfo->cellId))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,"unable to get the cellCb");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Call L2M Function to store Meas req */
ret = rgL2mMeasReq(cellCb, measInfo, &err);
RLOG_ARG2(L_ERROR,DBG_CELLID,measInfo->cellId,
"Meas req Failed errType(%d) errCause(%d)",
err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* -- RgSchMacL2MeasReq-- */
/**
RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
"Unable to get the cellCb");
- RETVALUE(RFAILED);
+ return RFAILED;
}
node = cellCb->l2mList.first;
while(node != NULLP)
measCfm.measType = measInfo->measType;
measCfm.cfm.status = LCM_PRIM_OK;
rgSndL2MeasStopCfm(cellCb, &measCfm);
- RETVALUE(ret);
+ return (ret);
} /* -- RgSchMacL2MeasStopReq-- */
/**
RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
"Unable to get the cellCb");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*set sndL2Meas as applicatoin sent l2 meas info request*/
cellCb->sndL2Meas = TRUE;
- RETVALUE(ret);
+ return (ret);
}/*RgSchMacL2MeasSendReq*/
/** @brief This function inserts the MeasCb in to data base
{
cell->l2mList.crnt = lnk;
cmLListInsCrnt(&(cell->l2mList), node);
- RETVALUE(ROK);
+ return ROK;
}
else
{
} /* End of While */
cmLListAdd2Tail(&(cell->l2mList), node);
- RETVALUE(ROK);
+ return ROK;
} /* rgL2mInsertMeasCb */
/** @brief This function allocates memory from the heap
"Allocation of RgL2MeasCb failed");
err->errType = RGERR_L2M_MEASREQ;
err->errCause = RGERR_RAM_MEM_EXHAUST;
- RETVALUE(NULLP);
+ return (NULLP);
}
cmMemcpy((U8 *)&measCb->measReq, (U8 *)measInfo, sizeof(RgInfL2MeasReq));
RGCPYTIMEINFO(cell->crntTime, measCb->startTime);
- RETVALUE(measCb);
+ return (measCb);
} /* rgL2mAllocMeasCb */
continue;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgL2MEas */
#endif /* LTE_L2_MEAS */
{
RLOG0(L_ERROR,"Call to RgLiTfuBndReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgLIMTfuBndReq */
{
RLOG0(L_ERROR,"Call to RgLiTfuUbndReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgLIMTfuUbndReq */
{
RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
tfuSap->sapCfg.suId, suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgLMMBndCfm (pst, suId, status);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuBndCfm */
/** @brief This function Validates the SAP information received along with the
{
RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
tfuSap->sapCfg.suId, suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (tfuSap->sapSta.sapState != LRG_BND)
{
RLOG1(L_ERROR,"Lower SAP not enabled SuId (%d)",
tfuSap->sapCfg.suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgLIMValidateSap */
#endif
/** @brief This function frees up the TfuDatIndInfo structure
{
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"SAP Validation failed");
rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
- RETVALUE(ret);
+ return (ret);
}
#endif
/* Now call the TOM (Tfu ownership module) primitive to process further */
/*stoping Task*/
SStopTask(startTime, PID_MAC_TFU_DATIND);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuDatInd*/
#ifdef RG_UNUSED
/* This case will never be hit if sap is not bound then we dont get TTI */
rgLIMUtlFreeDatReqEvnt(datReq, TRUE);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,datReq->cellId,"Call to RgLiTfuDatReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgLIMTfuDatReq*/
#ifdef L2_OPTMZ
{
RLOG_ARG1(L_ERROR,DBG_CELLID,delDatReq->cellId,"Lower SAP not bound (%d)",
tfuSap->sapSta.sapState);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,delDatReq->cellId,"Call to RgLiTfuDelDatReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgLIMTfuDatReq*/
#endif /*L2_OPTMZ */
if (rgLIMValidateSap (pst->dstInst - RG_INST_START, suId) != ROK)
{
RGDBGERRNEW(pst->dstInst - RG_INST_START, (rgPBuf(pst->dstInst - RG_INST_START),"RgLiTfuNonRtInd() SAP Validation failed.\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
rgDHMFreeTbBufs(pst->dstInst - RG_INST_START);
- RETVALUE(ROK);
+ return ROK;
} /* RgLiTfuNonRtInd */
#endif
/* Initialize lower mac */
lwrMacInit();
- RETVALUE(ROK);
+ return ROK;
} /* rgActvInit */
\f
RgMiLrgCfgCfm(&cfmPst, &cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgCfgReq --*/
\f
cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
RgMiLrgStsCfm(&cfmPst,&cfm);
RLOG0(L_ERROR, "Gen Cfg not done");
- RETVALUE(ROK);
+ return ROK;
}
switch(sts->hdr.elmId.elmnt)
break;
}
RgMiLrgStsCfm(&cfmPst,&cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgStsReq --*/
\f
!= ROK)
{
RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
- RETVALUE(ROK);
+ return ROK;
}
cmMemset((U8 *)(cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
rgGetSId(&cfm.t.ssta.s.sysId);
cfm.hdr.elmId.elmnt = sta->hdr.elmId.elmnt;
RgMiLrgStaCfm(&cfmPst, &cfm);
RLOG0(L_ERROR, "Gen Cfg not done");
- RETVALUE(ROK);
+ return ROK;
}
switch(sta->hdr.elmId.elmnt)
!= ROK)
{
RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
- RETVALUE(ROK);
+ return ROK;
}
cmMemset((U8 *)(cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
rgGetSId(&cfm.t.ssta.s.sysId);
RLOG1(L_ERROR, "Invalid elmnt=%d",sta->hdr.elmId.elmnt);
break;
}
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgStaReq --*/
\f
cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
RgMiLrgCntrlCfm(&cfmPst, &cfm);
RLOG0(L_ERROR, "Gen Cfg not done");
- RETVALUE(ROK);
+ return ROK;
}
/* General Config done, process the Control request */
RLOG1(L_ERROR, "invalid elmnt=%d",cntrl->hdr.elmId.elmnt);
break;
}
- RETVALUE(ret);
+ return (ret);
}/*-- RgMiLrgCntrlReq --*/
\f
/* Check if Gen Config has been done */
if(rgCb[inst].rgInit.cfgDone != TRUE)
- RETVALUE(LCM_REASON_GENCFG_NOT_DONE);
+ return (LCM_REASON_GENCFG_NOT_DONE);
switch(sapType)
{
/* would never reach here */
break;
}
- RETVALUE(ret);
+ return (ret);
}
\f
/* Check if General Configuration is done already */
if (rgCb[inst].rgInit.cfgDone == TRUE)
{
- RETVALUE(LCM_REASON_INVALID_MSGTYPE);
+ return (LCM_REASON_INVALID_MSGTYPE);
}
if ((cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_TC) &&
(cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_LC))
{
RLOG0(L_ERROR, "unsupported Selector value for RGU");
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
/* Update the Pst structure for LM interface */
cmMemcpy((U8 *)&rgCb[inst].rgInit.lmPst, (U8 *)&cfg->s.genCfg.lmPst,
if(cfg->s.genCfg.numRguSaps == 0)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgGenCfg(): Invalid numRguSap.\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* allocate RGR saps */
(sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps)) != ROK)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgGenCfg(): Failed to allocate mem for RGU SAP's.\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgCb[inst].numRguSaps = cfg->s.genCfg.numRguSaps;
(Data *)rgCb[inst].rguSap,
(sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif
/* Set Config done in TskInit */
rgCb[inst].rgInit.cfgDone = TRUE;
- RETVALUE(ret);
+ return (ret);
}
\f
arg.wait = tmrVal;
cmPlcCbTq(&arg);
- RETVALUE(ROK);
+ return ROK;
}
\f
}
- RETVALUE(ret);
+ return (ret);
}
\f
ret = RFAILED;
break;
}
- RETVALUE(ret);
+ return (ret);
}
if(rgCb[inst].rgInit.usta == FALSE)
{
- RETVALUE(ROK);
+ return ROK;
}
cmMemset((U8 *)&usta, 0, sizeof(RgMngmt));
rgCb[inst].rgInit.lmPst.pool = rgCb[inst].genCfg.ustaResp.response.mem.pool;
usta.hdr.transId = rgCb[inst].genCfg.ustaResp.transId;
- RETVALUE(RgMiLrgStaInd(&rgCb[inst].rgInit.lmPst, &usta));
+ return (RgMiLrgStaInd(&rgCb[inst].rgInit.lmPst, &usta));
}
\f
if(rgCb[inst].tfuSap.sapCfg.suId != suId)
{
RLOG0(L_ERROR, "Invalid SuId");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check the Sap State */
break;
case LRG_BND:
/* SAP is already bound */
- RETVALUE(ROK);
+ return ROK;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfmPst = rgCb[inst].rgInit.lmPst;
ret = RgMiLrgCntrlCfm(&cfmPst, &cntrlCfm);
- RETVALUE(ret);
+ return (ret);
}
\f
/* Check if any MAC timer has expired */
cmPrcTmr(&rgCb[macInst].tmrTqCp, rgCb[macInst].tmrTq, (PFV) rgLMMTmrExpiry);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgActvTmr */
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
RLOG0(L_ERROR, "Muxing of Contention Resolution CE sub-header is failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
RG_PACK_CE(pdu->contResId->resId[0], RG_CRES_LEN, ceBuf, ret);
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
RLOG0(L_ERROR, "Muxing of Contention Resolution CE is failed")
- RETVALUE(RFAILED);
+ return RFAILED;
}
pdu->schdTbSz -= RG_CRES_ELM_LEN;
}
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
RLOG0(L_ERROR, "Muxing of TA CE sub-hdr is failed")
- RETVALUE(RFAILED);
+ return RFAILED;
}
taVal = pdu->ta.val;
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
RLOG0(L_ERROR, "Muxing of TA CE is failed")
- RETVALUE(RFAILED);
+ return RFAILED;
}
pdu->schdTbSz -= RG_TA_ELM_LEN;
RLOG1(L_DEBUG,"TA muxed by MAC: %u", pdu->ta.val);
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
RLOG0(L_ERROR, "Muxing of SCELL Activation CE sub-hdr is failed")
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Adding the ACT CE */
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
RLOG0(L_ERROR, "Muxing of SCELL Activation CE is failed")
- RETVALUE(RFAILED);
+ return RFAILED;
}
pdu->schdTbSz -= RG_SCELL_CE_ELM_LEN;
/*LcId is not yet decided in 5G-NR spec for MAC CEs Hence, not writing code
* new MAC CEs. */
- RETVALUE(ROK);
+ return ROK;
} /* rgMUXAddCes */
/**
{
err->errCause = RGERR_MUX_BLD_SDUHDR_FAIL;
RLOG1(L_ERROR, "RGERR_MUX_BLD_SDUHDR_FAIL for LCID:%d",lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef L2_OPTMZ /* no need to pack as passing not muxing all LCs PDUs to 1*/
{
err->errCause = RGERR_MUX_BLD_SDU_FAIL;
RLOG1(L_ERROR, "RGERR_MUX_BLD_SDU_FAIL for LCID:%d",lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
*schdTbSz -= elmTotLen;
lcId, ((S16)elmTotLen), lenBytes,lcId);
RLOG3(L_ERROR, "msglen %d schdTbSz %d LCID:%d",
((S16)msgLen), ((S16)*schdTbSz),lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
{
err->errCause = RGERR_MUX_BLD_PADHDR_FAIL;
RLOG0(L_ERROR, "RGERR_MUX_BLD_PADHDR_FAIL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*schdTbSz -= 1;
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*schdTbSz = 0;
}
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*schdTbSz -= RG_MAX_PAD_ARR_SZ;
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*schdTbSz = 0;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgMUXAddPadd */
#ifndef L2_OPTMZ
if(rgMUXInsSdu(inst,&pdu->schdTbSz,
RG_CCCH_LCID, cDatReq->pdu, sduBuf, err) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
RG_FREE_MSG(cDatReq->pdu);
}
sduBuf, err) != ROK)
{
RLOG1(L_ERROR, "FAILED for LCID:%d",datReqTb->lchData[idx1].lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RG_FREE_MSG(datReqTb->lchData[idx1].pdu.mBuf[idx2]);
{
RLOG2(L_ERROR, "FAILED TB Size %d LCID:%d",
((S16)pdu->schdTbSz),datReqTb->lchData[idx1].lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RG_FREE_MSG(datReqTb->lchData[idx1].pdu.mBuf[idx2]);
if(rgMUXAddPadd(inst,&pdu->schdTbSz, sduBuf, FALSE, err) != ROK)
{
RLOG1(L_ERROR, "FAILED for TB Size:%d",(S16)pdu->schdTbSz);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
err->errType = RGERR_MUX_BLD_PDU;
RLOG1(L_FATAL, "Memory allocation failed during MUXing of MAC TB: MacInst %d", inst);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgMUXAddCes(inst, pdu, mBuf, err) != ROK)
RG_FREE_MSG(mBuf);
err->errType = RGERR_MUX_BLD_PDU;
RLOG1(L_ERROR, "Failed to Multiplex MAC CEs: MacInst %d", inst);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgMUXAddSdus(inst, pdu, mBuf, err) != ROK)
RG_FREE_MSG(mBuf);
err->errType = RGERR_MUX_BLD_PDU;
RLOG1(L_ERROR, "FAILED to Multiplex MAC SDU: MacInst %d", inst);
- RETVALUE(RFAILED);
+ return RFAILED;
}
*txPdu = mBuf;
- RETVALUE(ROK);
+ return ROK;
} /* rgMUXBldPdu */
RG_CCCH_LCID, cDatReq->pdu,
sHdrBuf, NULLP, err) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* L2 Optimization for mUe/Tti: RLC pdu mbuf pointer will be passed
* to CL it is stored in DlHqProc->TbInfo and it will be used in
sHdrBuf, NULLP, err) != ROK)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* L2 Optimization for mUe/Tti:Increment numPdu by 1
{
RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED TB Size %d\n",
((S16)pdu->schdTbSz)));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* L2 Optimization for mUe/Tti:Increment numPdu by 1
* Store pdu buffer in tb to send it to CL/PHY. Increment
if(rgMUXAddPadd(inst, &pdu->schdTbSz, sduBuf, NULLP, FALSE, err) != ROK)
{
//RGDBGERRNEW((rgPBuf, "FAILED"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
tb->padSize = padSize;
- RETVALUE(ROK);
+ return ROK;
}
/**
RG_FREE_TB(tb);
err->errType = RGERR_MUX_BLD_PDU;
//RGDBGERRNEW((rgPBuf, "FAILED"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgMUXAddSdus(inst, pdu, mBuf1, tb, err) != ROK)
{
err->errType = RGERR_MUX_BLD_PDU;
//RGDBGERRNEW((rgPBuf, "FAILED"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
// UDAY
// SPrntMsg(tb->macHdr, 0, 0);
// prc_trace_format_string(0x40,3,": padSize=%ld", tb->padSize);
tb->tbPres = TRUE;
- RETVALUE(ROK);
+ return ROK;
} /* rgMUXBldPdu */
/* Buffer couldnt get allocated. Return a failure */
err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "FAILED to getMsg");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (TRUE == alloc->backOffInd.pres)
err->errCause = RGERR_MUX_BLD_BI_FAIL;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_BI_FAIL");
RG_FREE_MSG(datBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
schdTbSz--;
}
err->errCause = RGERR_MUX_BLD_RAPIDHDR_FAIL;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPIDHDR_FAIL");
RG_FREE_MSG(datBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Prepare the data */
err->errCause = RGERR_MUX_BLD_RAPID_FAIL;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPID_FAIL");
RG_FREE_MSG(datBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
schdTbSz -= RG_RAR_ELEM_LEN+RG_RAR_SHDR_LEN;
}
{
RG_FREE_MSG(datBuf);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"FAILED to mux add padding");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*txPdu = datBuf;
- RETVALUE(ROK);
+ return ROK;
} /* rgMUXBldRarPdu */
/***********************************************************
{
riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
}
- RETVALUE(riv);
+ return (riv);
} /* rgMUXCalcRiv */
/* Send positive confirmation to primary cell*/
RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
- RETVALUE(ROK);
+ return ROK;
} /* RgPrgPMacSMacUeSCellLchModReq */
RGDBGERRNEW(inst,(rgPBuf(inst),
"[%d]Active Cell does not exist %d\n",
lcDel->u.lchDel.crnti, lcDel->u.lchDel.cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGDBGPRM(inst,(rgPBuf(inst),
{
RGDBGERRNEW(inst,(rgPBuf(inst),
"[%d]Ue does not exist\n", lcDel->u.lchDel.crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
{
*isCfmRqrd = FALSE;
}
}
- RETVALUE(ROK);
+ return ROK;
}
*isCfmRqrd = FALSE;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
*isCfmRqrd = FALSE;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgPomSndUeSCellLchAddToSmac */
/**
/* Send positive confirmation to primary cell*/
RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
- RETVALUE(ROK);
+ return ROK;
} /* RgPrgPMacSMacUeSCellLchDelReq */
/* Send positive confirmation to primary cell*/
RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
- RETVALUE(ROK);
+ return ROK;
} /* RgPrgPMacSMacUeSCellLchAddReq */
/**
* @brief Validates the logical channel configuration request from PMAC to SMAC.
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Validation for dedicated LC failed\n",
lcCfg->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid logical channel type %d\n",\
lcCfg->crnti, lcCfg->lcType));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
if ( lcCfg->qci < RG_QCI_MIN ||
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid qci %x\n",
lcCfg->crnti, lcCfg->qci));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*validate qci */
#endif /*LTE_L2_MEAS */
RGDBGINFONEW(inst,(rgPBuf(inst),"[%d]UEID CRG LCconfig validation done:cellId:%d lcId:%d\n",
lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for the logical channel configuration request from
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel configuration"
"failed in SCell%d\n", lcCfg->crnti, lcCfg->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]SCell LC config done: cellId %d lcId %d\n",
lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
- RETVALUE(ROK);
+ return ROK;
} /* rgPomUeSCellLcAdd */
/***********************************************************
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist: Cell %d\n",
lcCfg->crnti, lcCfg->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE does not exist for dedicated logical"
"channel %d\n", lcCfg->crnti, lcCfg->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate logical channel Id */
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid logical channel Id %d\n",
lcCfg->crnti, lcCfg->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}*/
/* Validate downlink info */
if (lcCfg->dir & PRG_DIR_TX)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated DL LC %d already configured\n",
lcCfg->crnti, lcCfg->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* dirVld = TRUE;*/
}
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Invalid lcgId for uplink logical"
"channel %d\n", lcCfg->crnti, lcCfg->ulInfo.lcgId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated UL LC %d already configured\n",
lcCfg->crnti, lcCfg->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* dirVld = TRUE;*/
}
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid Direction %d \n",
lcCfg->crnti, lcCfg->dir));
- RETVALUE(RFAILED);
+ return RFAILED;
}
*/
RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel %d validated"
"for cell %d\n", lcCfg->crnti, lcCfg->lcId, lcCfg->cellId));
- RETVALUE(ROK);
+ return ROK;
} /* rgPomVldtSCellDedLchCfg */
/***********************************************************
*
rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
}
RGDBGINFO(inst,(rgPBuf(inst), "Dedicated LC config done\n"));
- RETVALUE(ROK);
+ return ROK;
} /* rgPomUeSCellDedLcCfg */
/**
|| ((*cell)->cellId != lchCfgCb->cellId))
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",lchCfgCb->crnti, lchCfgCb->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue for dedicated channels */
if ((*ue = rgDBMGetUeCb(*cell, lchCfgCb->crnti)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
lchCfgCb->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lchCfgCb->lcId)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
lchCfgCb->crnti, lchCfgCb->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* if (lchCfgCb->ulLchRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid lcgId for uplink logical channel: lcg %d"
"lc %d\n",lchCfgCb->crnti, lchCfgCb->ulLchRecfg.lcgId, lchCfgCb->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}*/
- RETVALUE(ROK);
+ return ROK;
} /*rgPomVltdModLch*/
/**
* @brief Handler for the logical channel re-configuration request from
RGDBGINFO(inst,(rgPBuf(inst), "LC %d of Ue %d of cell %d Reconfigured\n",
lchCfgCb->lcId, ue->ueId, cell->cellId));
- RETVALUE(ROK);
+ return ROK;
} /* rgPomUeSCellLcMod */
/**
* @brief Function to validate SCellLchDel.
|| ((*cell)->cellId != delLcCb->cellId))
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",delLcCb->crnti, delLcCb->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue for dedicated channels */
if ((*ue = rgDBMGetUeCb(*cell, delLcCb->crnti)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
delLcCb->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((*ulLc = rgDBMGetUlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
delLcCb->crnti, delLcCb->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((*dlLc = rgDBMGetDlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]DL LC %d does not exist\n",
delLcCb->crnti, delLcCb->lcId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /*rgPomVltdDelLch*/
/**
* @brief Handler for the logical channel delete request from
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid direction %d for LC Delete\n",
delLcCb->crnti, delLcCb->dir));
- RETVALUE(RFAILED);
+ return RFAILED;
}*/
RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]UE's Logical channel %d deleted from cell %d\n",
delLcCb->crnti, delLcCb->lcId,
delLcCb->cellId));
- RETVALUE(ROK);
+ return ROK;
} /* rgPomUeSCellLcDel */
#endif /*LTE_ADV */
/**********************************************************************
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)ueSCellCfgInfo, sizeof(RgPrgUeSCellCfgInfo),\
mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTPRGUESCELLCFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if(SRemPreMsgMult((Data *)&ueSCellCfgInfo, sizeof(RgPrgUeSCellCfgInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGPRG_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &ueSCellCfgInfo));
+ return ((*func)(pst, &ueSCellCfgInfo));
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)cfgCfm, sizeof(RgPrgCfgCfmInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(cfgCfm->event)
{
}
break;
}
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if(SRemPreMsgMult((Data *)&cfgCfm, sizeof(RgPrgCfgCfmInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGPRG_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &cfgCfm));
+ return ((*func)(pst, &cfgCfm));
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)ueSCellDelInfo, sizeof(RgPrgUeSCellDelInfo), mBuf)\
!= ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTPRGUESCELLDELREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGPRG_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &ueSCellDelInfo));
+ return ((*func)(pst, &ueSCellDelInfo));
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)lchCfgInfo, sizeof(RgPrgUeSCellLchAddInfo),\
mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTPRGUESCELLLCHADDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if(SRemPreMsgMult((Data *)&lchCfgInfo, sizeof(RgPrgUeSCellLchAddInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGPRG_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &lchCfgInfo));
+ return ((*func)(pst, &lchCfgInfo));
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)delLcCb, sizeof(RgPrgUeSCellLchDelInfo),\
mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTPRGUESCELLLCHDELREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)lchCfgInfo, sizeof(RgPrgUeSCellLchModInfo),\
mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTPRGUESCELLLCHMODREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
if(SRemPreMsgMult((Data *)&lchCfgInfo, sizeof(RgPrgUeSCellLchModInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGPRG_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &lchCfgInfo));
+ return ((*func)(pst, &lchCfgInfo));
}
if(SRemPreMsgMult((Data *)&lchCfgInfo, sizeof(RgPrgUeSCellLchDelInfo), mBuf) != ROK)
{
RGPRG_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGPRG_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &lchCfgInfo));
+ return ((*func)(pst, &lchCfgInfo));
}
#endif /*LCPRG*/
TRC3(RgPrgPMacSMacUeSCellCfg);
- RETVALUE((*RgPrgPMacSMacUeSCellCfgReqMt[0])(pst, ueSCellCfgInfo));
+ return ((*RgPrgPMacSMacUeSCellCfgReqMt[0])(pst, ueSCellCfgInfo));
}
/* Matrix for config confirm from SMac to Pmac*/
TRC3(RgPrgSMacPMacCfg);
- RETVALUE((*RgPrgSMacPMacCfgCfmMt[0])(pst, cfgCfm));
+ return ((*RgPrgSMacPMacCfgCfmMt[0])(pst, cfgCfm));
}
/* Matrix for Ue SCell delete req/Ue Id change req from PMac to SMac */
TRC3(RgPrgPMacSMacUeSCellDel);
- RETVALUE((*RgPrgPMacSMacUeSCellDelReqMt[0])(pst, ueSCellDelInfo));
+ return ((*RgPrgPMacSMacUeSCellDelReqMt[0])(pst, ueSCellDelInfo));
}
TRC3(RgPrgPMacSMacUeScellLchMod);
- RETVALUE((*RgPrgPMacSMacUeScellModLchReqMt[0])(pst, lchCfgInfo));
+ return ((*RgPrgPMacSMacUeScellModLchReqMt[0])(pst, lchCfgInfo));
}
TRC3(RgPrgPMacSMacUeScellLchDel);
- RETVALUE((*RgPrgPMacSMacUeScellDelLchReqMt[0])(pst, delLcCb));
+ return ((*RgPrgPMacSMacUeScellDelLchReqMt[0])(pst, delLcCb));
}
TRC3(RgPrgPMacSMacUeScellLchAdd);
- RETVALUE((*RgPrgPMacSMacUeScellAddLchReqMt[0])(pst, lchCfgInfo));
+ return ((*RgPrgPMacSMacUeScellAddLchReqMt[0])(pst, lchCfgInfo));
}
#endif /* LTE_ADV */
TRC3(RgLiTfuBndReq)
- RETVALUE((*RgLiTfuBndReqMt[pst->selector])(pst, suId, spId));
+ return ((*RgLiTfuBndReqMt[pst->selector])(pst, suId, spId));
}
TRC3(RgLiTfuSchBndReq)
- RETVALUE((*RgLiTfuSchBndReqMt[pst->selector])(pst, suId, spId));
+ return ((*RgLiTfuSchBndReqMt[pst->selector])(pst, suId, spId));
}
TRC3(RgLiTfuUbndReq)
- RETVALUE((*RgLiTfuUbndReqMt[pst->selector])(pst, spId, reason));
+ return ((*RgLiTfuUbndReqMt[pst->selector])(pst, spId, reason));
}
TRC3(RgLiTfuSchUbndReq)
- RETVALUE((*RgLiTfuSchUbndReqMt[pst->selector])(pst, spId, reason));
+ return ((*RgLiTfuSchUbndReqMt[pst->selector])(pst, spId, reason));
}
TRC3(RgLiTfuRecpReq)
- RETVALUE((*RgLiTfuRecpReqMt[pst->selector])(pst, spId, recpReq));
+ return ((*RgLiTfuRecpReqMt[pst->selector])(pst, spId, recpReq));
}
TRC3(RgLiTfuCntrlReq)
- RETVALUE((*RgLiTfuCntrlReqMt[pst->selector])(pst, spId, cntrlReq));
+ return ((*RgLiTfuCntrlReqMt[pst->selector])(pst, spId, cntrlReq));
}
TRC3(RgLiTfuDatReq)
- RETVALUE((*RgLiTfuDatReqMt[pst->selector])(pst, spId, datReq));
+ return ((*RgLiTfuDatReqMt[pst->selector])(pst, spId, datReq));
}
TRC3(RgLiTfuDelDatReq)
- RETVALUE((*RgLiTfuDelDatReqMt[pst->selector])(pst, spId, delDatReq));
+ return ((*RgLiTfuDelDatReqMt[pst->selector])(pst, spId, delDatReq));
}
#endif /* L2_OPTMZ*/
UNUSED(suId);
UNUSED(spId);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(spId);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(spId);
UNUSED(reason);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(spId);
UNUSED(reason);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(spId);
UNUSED(recpReq);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(spId);
UNUSED(cntrlReq);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(spId);
UNUSED(datReq);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(spId);
UNUSED(delDatReq);
- RETVALUE(ROK);
+ return ROK;
}
#endif /*L2_OPTMZ*/
(*RgMiLrgCfgCfmMt[pst->selector])(pst, cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgCfgCfm --*/
(*RgMiLrgSchCfgCfmMt[pst->selector])(pst, cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgSchCfgCfm --*/
(*RgMiLrgStsCfmMt[pst->selector])(pst, cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgStsCfm --*/
(*RgMiLrgStaCfmMt[pst->selector])(pst,cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgStaCfm --*/
(*RgMiLrgCntrlCfmMt[pst->selector])(pst,cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgCntrlCfm --*/
(*RgMiLrgSchCntrlCfmMt[pst->selector])(pst,cfm);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgSchCntrlCfm --*/
(*RgMiLrgStaIndMt[pst->selector])(pst,usta);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgStaInd --*/
(*RgMiLrgSchStaIndMt[pst->selector])(pst,usta);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgSchStaInd --*/
(*RgMiLrgTrcIndMt[pst->selector])(pst,trc,mBuf);
- RETVALUE(ROK);
+ return ROK;
}/*-- RgMiLrgTrcInd --*/
(*RgMiLrgSchL2mMeasCfmMt[pst->selector])(pst,cfm);
- RETVALUE(ROK);
+ return ROK;
} /* RgMiLrgSchL2MeasCfm */
(*RgMiLrgSchL2mMeasStopCfmMt[pst->selector])(pst,cfm);
- RETVALUE(ROK);
+ return ROK;
} /* RgMiLrgSchL2MeasStopCfm */
{
TRC3(PtMiLrgCfgCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgCfgCfm */
/**
{
TRC3(PtMiLrgSchCfgCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgSchCfgCfm */
{
TRC3(PtMiLrgStsCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgStsCfm */
#endif
{
TRC3(PtMiLrgStaCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgStaCfm */
#endif
{
TRC3(PtMiLrgStaInd)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgStaInd */
/**
#endif
{
TRC3(PtMiLrgSchStaInd)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgSchStaInd */
\f
#endif
{
TRC3(PtMiLrgCntrlCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgCntrlCfm */
/**
#endif
{
TRC3(PtMiLrgSchCntrlCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgSchCntrlCfm */
\f
#endif
{
TRC3(PtMiLrgTrcInd)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgTrcInd */
#ifdef LTE_L2_MEAS
/**
{
TRC3(PtMiLrgSchL2MeasCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgSchL2MeasCfm */
/**
{
TRC3(PtMiLrgSchL2MeasStopCfm)
- RETVALUE(ROK);
+ return ROK;
}/* end of PtMiLrgSchL2MeasStopCfm */
#endif
#endif /*--PTRGMILRG--*/
TRC3(RgUiRgrBndCfm);
- RETVALUE((*RgUiRgrBndCfmMt[pst->selector])(pst, suId, status));
+ return ((*RgUiRgrBndCfmMt[pst->selector])(pst, suId, status));
}
/**
TRC3(RgUiRgmBndCfm);
- RETVALUE((*RgUiRgmBndCfmMt[pst->selector])(pst, suId, status));
+ return ((*RgUiRgmBndCfmMt[pst->selector])(pst, suId, status));
}
TRC3(RgUiRgrTtiInd);
- RETVALUE((*RgUiRgrTtiIndMt[pst->selector])(pst, suId, ttiInd));
+ return ((*RgUiRgrTtiIndMt[pst->selector])(pst, suId, ttiInd));
}
TRC3(RgUiRgrCfgCfm);
- RETVALUE((*RgUiRgrCfgCfmMt[pst->selector])(pst, transId, status));
+ return ((*RgUiRgrCfgCfmMt[pst->selector])(pst, transId, status));
}
TRC3(RgUiCrgBndCfm);
- RETVALUE((*RgUiCrgBndCfmMt[pst->selector])(pst, suId, status));
+ return ((*RgUiCrgBndCfmMt[pst->selector])(pst, suId, status));
}
TRC3(RgUiCrgCfgCfm);
- RETVALUE((*RgUiCrgCfgCfmMt[pst->selector])(pst, suId, transId, status));
+ return ((*RgUiCrgCfgCfmMt[pst->selector])(pst, suId, transId, status));
}
TRC3(RgUiRguBndCfm);
- RETVALUE((*RgUiRguBndCfmMt[pst->selector])(pst, suId, status));
+ return ((*RgUiRguBndCfmMt[pst->selector])(pst, suId, status));
}
TRC3(RgUiRguCDatInd);
- RETVALUE((*RgUiRguCDatIndMt[pst->selector])(pst, suId, datInd));
+ return ((*RgUiRguCDatIndMt[pst->selector])(pst, suId, datInd));
}
TRC3(RgUiRguDDatInd);
#if defined(MAC_RLC_UL_RBUF) && !defined(SS_RBUF)
- RETVALUE(RgUiRguDDatIndRbuf(datInd));
+ return (RgUiRguDDatIndRbuf(datInd));
#else
- RETVALUE((*RgUiRguDDatIndMt[pst->selector])(pst, suId, datInd));
+ return ((*RgUiRguDDatIndMt[pst->selector])(pst, suId, datInd));
#endif
}
TRC3(RgUiRguCStaInd);
- RETVALUE((*RgUiRguCStaIndMt[pst->selector])(pst, suId, staInd));
+ return ((*RgUiRguCStaIndMt[pst->selector])(pst, suId, staInd));
}
TRC3(RgUiRguDStaInd);
- RETVALUE((*RgUiRguDStaIndMt[pst->selector])(pst, suId, staInd));
+ return ((*RgUiRguDStaIndMt[pst->selector])(pst, suId, staInd));
}
#ifdef LTE_L2_MEAS
#if defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF)
S16 ret=ROK;
ret = RgUiRguHqStaIndRbuf(pst,suId,harqStatusInd);
- RETVALUE(ret);
+ return (ret);
#else
- RETVALUE((*RgUiRguHqStaIndMt[pst->selector])(pst, suId, harqStatusInd));
+ return ((*RgUiRguHqStaIndMt[pst->selector])(pst, suId, harqStatusInd));
#endif
} /* RgUiRguHqStaInd */
RguFlowCntrlInd *flowCntrlInd;
#endif
{
- RETVALUE((*RgUiRguFlowCntrlIndMt[pst->selector])(pst, suId, flowCntrlInd));
+ return ((*RgUiRguFlowCntrlIndMt[pst->selector])(pst, suId, flowCntrlInd));
}
/* Added for SI Enhancement*/
#ifdef RGR_SI_SCH
TRC3(RgUiRgrSiCfgCfm);
- RETVALUE((*RgUiRgrSiCfgCfmMt[pst->selector])(pst, suId, transId, status));
+ return ((*RgUiRgrSiCfgCfmMt[pst->selector])(pst, suId, transId, status));
}
{
TRC3(RgUiRgrWarningSiCfgCfm);
- RETVALUE((*RgUiRgrWarningSiCfgCfmMt[pst->selector])
+ return ((*RgUiRgrWarningSiCfgCfmMt[pst->selector])
(pst, suId, transId, siId, status));
}
TRC3(RgUiRgrStaInd);
- RETVALUE((*RgUiRgrStaIndMt[pst->selector])(pst, suId, staInd));
+ return ((*RgUiRgrStaIndMt[pst->selector])(pst, suId, staInd));
}
#endif /* End of RGR_CQI_REPT */
TRC3(RgUiRgrLoadInfInd);
- RETVALUE((*RgUiRgrLoadInfIndMt[pst->selector])(pst, suId, loadInfInd));
+ return ((*RgUiRgrLoadInfIndMt[pst->selector])(pst, suId, loadInfInd));
}
/* LTE_ADV_FLAG_REMOVED_END */
TRC3(RgUiRgrUeStaInd);
- RETVALUE((*RgUiRgrUeStaIndMt[pst->selector])(pst, suId, ueStaInd));
+ return ((*RgUiRgrUeStaIndMt[pst->selector])(pst, suId, ueStaInd));
}
#endif /*--ifdef RG--*/
UNUSED(suId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(transId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
#endif /*--ifdef PTRGUICRG--*/
UNUSED(suId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(datInd);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(datInd);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(staInd);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(staInd);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_L2_MEAS
UNUSED(suId);
UNUSED(harqStatusInd);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
UNUSED(suId);
UNUSED(flowCntrlInd);
- RETVALUE(ROK);
+ return ROK;
}
\f
UNUSED(suId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(ttiInd);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(transId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(transId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(siId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
#endif/* RGR_SI_SCH */
UNUSED(suId);
UNUSED(staInd);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* End of RGR_CQI_REPT */
UNUSED(suId);
UNUSED(loadInfInd);
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_END */
UNUSED(suId);
UNUSED(ueStaInd);
- RETVALUE(ROK);
+ return ROK;
}
#endif /*--ifdef PTRGUIRGR--*/
UNUSED(suId);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(prbRprtInd);
- RETVALUE(ROK);
+ return ROK;
}
UNUSED(suId);
UNUSED(transModeInd);
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
TRC2(RgUiRgmSendPrbRprtInd);
- RETVALUE((*RgUiRgmSendPrbRprtIndMt[pst->selector])(pst, suId, prbRprtInd));
+ return ((*RgUiRgmSendPrbRprtIndMt[pst->selector])(pst, suId, prbRprtInd));
}
/**
{
TRC2(RgUiRgmChangeTransModeInd);
- RETVALUE((*RgUiRgmChangeTransModeIndMt[pst->selector])(pst, suId, transModeInd));
+ return ((*RgUiRgmChangeTransModeIndMt[pst->selector])(pst, suId, transModeInd));
}
#if defined(MAC_RLC_UL_RBUF) && !defined(SS_RBUF)
SRngIncrWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].pktRate++;
}
- RETVALUE(ret);
+ return (ret);
}
#endif
#ifdef RLC_MAC_DAT_REQ_RBUF
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
#ifdef LTE_L2_MEAS
SRngIncrWIndx(SS_RNG_BUF_MAC_HARQ);
SsRngInfoTbl[SS_RNG_BUF_MAC_HARQ].pktRate++;
}
- RETVALUE(ret);
+ return (ret);
}
#endif
#endif
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED for CRNTI:%d",tmpCrnti);
err->errCause = RGERR_RAM_MEM_EXHAUST;
- RETVALUE(NULLP);
+ return (NULLP);
}
/* Inititialize Ue control block */
rgDBMInsUeCbInRachLst(cell, ueCb);
}
- RETVALUE(ueCb);
+ return (ueCb);
} /* rgRAMCreateUeCb */
/**
rgRAMFreeUeCb(inst,ueCb);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgRAMFreeCell */
/**
* @brief Function for handling RA response scheduled for a subframe.
if(NULLP == rarInfo->raRntiInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = (timingInfo.slot % RG_NUM_SUB_FRAMES);
rarInfo->raRntiInfo[idx1].crntiInfo[idx2].tmpCrnti,
TRUE, err) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
continue;
}
} /* end of raRntis loop */
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlRaResp */
/**********************************************************************
/* Update stats */
rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Add loop here to scan for all UEs in the consolidated DDatReq*/
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
continue;
- // RETVALUE(RFAILED);
+ // return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, datReq->datReq[idx].rnti)) == NULLP)
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
/* Return from here as above functions found more datReq than expected*/
- /* RETVALUE(ret); */
+ /* return (ret); */
}
#endif
/* Conitnue for next UE */
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
/* Return from here as above functions found more datReq than expected*/
- //RETVALUE(ret);
+ //return (ret);
}
#endif
continue;
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
/* Return from here as above functions found more datReq than expected*/
- // RETVALUE(ret);
+ // return (ret);
}
#endif
} /* for loop for num of Ue per TTI*/
#endif
/* Data send successfully to PHY. lets retuns ROK*/
- RETVALUE(ROK);
+ return ROK;
} /* rgROMDedDatReq */
{
rgUpdtRguCmnSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (datReq->lcId == cell->dlCcchId)
/*Added check for RFAILED as above function can return RFAILED*/
#endif
- RETVALUE(ret);
+ return (ret);
} /* rgROMCmnDatReq */
/**
"rgROMHndlCcchDatReq(): Invalid ue Id");
#endif
err->errCause = RGERR_ROM_INV_UE_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
LRG_CAUSE_DELAYED_DATREQ, &dgn);
#endif
err->errCause = RGERR_ROM_DELAYED_DATREQ;
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqPId = (U8)(datReq->transId);
/* Release First TB */
rgDHMRlsHqProcTB(cell, hqProc, 1);
/* err shall be filled in appropriately by DHM */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgROMHndlCcchDatReq */
LRG_CAUSE_DELAYED_DATREQ, &dgn);
#endif
err->errCause = RGERR_ROM_DELAYED_DATREQ;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef RGR_SI_SCH
SCpyMsgMsg(datReq->pdu, RG_GET_MEM_REGION(rgCb[inst]),
RG_GET_MEM_POOL(rgCb[inst]), &bcch->tb);
- RETVALUE(ROK);
+ return ROK;
}
bch = rgDBMGetBcchOnBch(cell);
{
/* Store BCH data received in Scheduled slot */
sf->bch.tb = datReq->pdu;
- RETVALUE(ROK);
+ return ROK;
}
#endif/*RGR_SI_SCH*/
{
/* Store PCCH-DLSCH data received in Scheduled slot */
sf->pcch.tb = datReq->pdu;
- RETVALUE(ROK);
+ return ROK;
}
/* Handle lcCb fetch failure */
"rgROMHndlBcchPcchDatReq(): Invalid Lc Id");
err->errCause = RGERR_ROM_INV_LC_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgROMHndlBcchPcchDatReq */
/**
rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
schPst.event = 0;
//TODO: commented for compilation without SCH RgMacSchDedBoUpdt(&schPst, &boRpt);
- RETVALUE(ROK);
+ return ROK;
}
RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,"Invalid cell for CRNTI:%d LCID:%d ",
staRsp->rnti,staRsp->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgROMDedStaRsp */
S16 RgMacSchBrdcmDedBoUpdtReq(
schPst.event = 0;
//TODO: commented for compilation without SCH RgMacSchDedBoUpdtReq (&schPst,&boRpt);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for StaRsp received on RGU for a common logical channel.
"Invalid cell for CRNTI:%d LCID:%d",staRsp->u.rnti,staRsp->lcId);
err.errType = RGERR_ROM_CMNSTARSP;
err.errCause = RGERR_ROM_INV_CELL_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* handle status response on CCCH */
rgROMHndlBcchPcchStaRsp(cell, staRsp, &err);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgROMCmnStaRsp */
#ifdef LTE_L2_MEAS
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,measReq->cellId,"Invalid cell CRNTI:%d",
measReq->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgROML2MUlThrpMeasReq */
#endif
rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
//TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
- RETVALUE(ROK);
+ return ROK;
} /* rgROMHndlCcchStaRsp */
/* Handle lcCb fetch failure */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LCID:%d",staRsp->lcId);
err->errCause = RGERR_ROM_INV_LC_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* MS_WORKAROUND : This is to ensure that the queue for BCH is not filled with old BO requests :
This assumes that BO is not received more than 4 frames in advance from the enodeb application */
if ((staRsp->u.timeToTx.sfn != nextBchSfn) ||
((staRsp->u.timeToTx.sfn == cell->crntTime.sfn) && (cell->crntTime.slot >= 7)))
{
- RETVALUE(ROK);
+ return ROK;
}
}
/*
rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
//TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
- RETVALUE(ROK);
+ return ROK;
} /* rgROMHndlBcchPcchStaRsp */
/* ADD Changes for Downlink UE Timing Optimization */
* request than the allocation. Do nothing for this. */
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
"RX new data while remDatReqCnt is 0 for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*Decrement the remaining data request to be received countter
dlSf->txDone = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgROMUpdDlSfRemDataCnt*/
#endif
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion ");
- RETVALUE(ret);
+ return (ret);
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
#ifndef L2_OPTMZ
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",datReq->rnti);
- RETVALUE(ret);
+ return (ret);
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
#ifndef L2_OPTMZ
err->errCause = RGERR_TOM_MEM_EXHAUST;
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",
datReq->rnti);
- RETVALUE(ret);
+ return (ret);
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
#ifndef L2_OPTMZ
} /* end of while */
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgTOMUtlFillDatReqPdus*/
/** @brief This function does all the processing related to a single downlink
sizeof(TfuDatReqInfo))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to Allocate TfuDatReqInfo");
- RETVALUE(ret);
+ return (ret);
}
else
{
if ((ret = rgTOMEmtcUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
{
RG_FREE_MEM(datInfo);
- RETVALUE(ret);
+ return (ret);
}
#endif
/* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data for cell");
RG_FREE_MEM(datInfo);
- RETVALUE(ret);
+ return (ret);
}
if((datInfo->pdus.count) || (datInfo->bchDat.pres == TRUE))
{
RG_FREE_MEM(datInfo);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of */
U32 rgMacGT;
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RLOG0(L_ERROR,"Allocation of DUX event failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*stoping Task*/
SStopTask(startTime, PID_TOMUTL_CMALLCEVT);
- RETVALUE(ROK);
+ return ROK;
} /* end of */
/** @brief This function frees up the RgMacPdu structure that has been
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RLOG0(L_ERROR,"Allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*stoping Task*/
SStopTask(startTime, PID_TOMINF_CMALLCEVT);
- RETVALUE(ROK);
+ return ROK;
} /* end of */
/** @brief This function frees up the RgMacPdu structure that has been
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
/* code for common channel dat indications */
if ((ret = rgAllocShrablSBuf (inst,(Data**)&cDatInd, sizeof(RgRguCmnDatInd))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cDatInd->cellId = cellCb->cellId;
cDatInd->rnti = ueCb->ueId;
#endif
sdu->mBuf = NULLP;
rgUIMSndCmnDatInd(inst,cellCb->rguUlSap,cDatInd);
- RETVALUE(ROK);
+ return ROK;
} /* end of common channel processing */
#ifndef SS_RBUF
if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
glblueCb5 = ueCb;
elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
if (NULLP == elem)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
dDatInd = (RgRguDedDatInd *)elem;
cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
- RETVALUE(ret);
+ return (ret);
}
#ifndef SS_RBUF
if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
if (NULLP == elem)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
dDatInd = (RgRguDedDatInd *)elem;
cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
- RETVALUE(ret);
+ return (ret);
}
}
#ifndef SS_RBUF
rgFreeSharableSBuf(inst,(Data **)&dDatInd,sizeof(RgRguDedDatInd));
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of */
/** @brief This function frees up the RgMacPdu structure that has been
if(ROK != ret)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueInfo->rnti = rnti;
}
}
cmLListAdd2Tail(&sfInfo->ueLst, &ueInfo->ueLstEnt);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgTOMUtlInsSchInfo */
#include <stdlib.h>
{
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to get the cellCb for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Avoiding memset as all the fields are getting initialized further */
err.errType = RGERR_TOM_DATIND;
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
node = datInd->datIndLst.first;
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListInit(&sfInfo->ueLst);
sfInfo->cellId = datInd->cellId;
err.errType = RGERR_TOM_DATIND;
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
rgTOMInfFreePduEvnt (sfInfo);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ret = rgDUXDemuxData (inst,pdu, &ceInfo,
{
rgTOMInfFreePduEvnt (sfInfo);
rgTOMUtlFreePduEvnt (pdu, FALSE);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* free up the PDU memory */
rgTOMUtlFreePduEvnt (pdu, FALSE);
rgGetPstToInst(&schPst, inst,cellCb->schInstMap.schInst);
sfInfo->cellSapId = cellCb->schInstMap.cellSapId;
//TODO: commented for compilation without SCH RgMacSchSfRecp(&schPst, sfInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgTOMDatInd */
/**
#if (ERRCLASS & ERRCLS_DEBUG)
if(NULLP == (bch = rgDBMGetBcchOnBch(cell)))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmnLcInfo->bchInfo.lcId != bch->lcId)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
staInd->cellId = cell->cellId;
staInd->rnti = RG_INVALID_RNTI;
#endif
if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
/*Store the received BCH Data in the scheduled subframe*/
#if (ERRCLASS & ERRCLS_DEBUG)
if(NULLP == (pcch = rgDBMGetPcch(cell)))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmnLcInfo->pcchInfo.lcId != pcch->lcId)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
staInd->cellId = cell->cellId;
staInd->rnti = RG_INVALID_RNTI;
*/
if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(NULLP ==
(bcch=rgDBMGetBcchOnDlsch(cell,cmnLcInfo->bcchInfo.lcId)))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(TRUE == cmnLcInfo->bcchInfo.sndStatInd)
{
sizeof(RguCStaIndInfo)) != ROK)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
staInd->cellId = cell->cellId;
staInd->rnti = RG_INVALID_RNTI;
#endif
if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#endif/*RGR_SI_SCH*/
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlCmnChnl */
/**
if(NULLP == ueInfo->allocInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlSchdUe */
#ifdef LTE_L2_MEAS
if((ret = rgAllocSBuf(inst,(Data**)&(cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)].
ueUlAllocInfo), ueInfo->numUes * sizeof(RgUeUlAlloc))) != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
#ifdef XEON_SPECIFIC_CHANGES
}
}
RGCPYTIMEINFO(timingInfo, ulSf->schdTime);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlUlUeInfo */
#endif
/**
}
}
RgUiRguFlowCntrlInd(pst, cell->rguDlSap->sapCfg.spId,flowCntrlInd); /* TODO: Rishi confirm if the suId and pst pointer is correct */
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Function is called by the scheduler once it has completed the
if(NULLP == sfInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell = rgCb[inst].cell) == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,sfInfo->cellId, "No cellCb found with cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
dlSf = &cell->subFrms[(sfInfo->timingInfo.slot % RG_NUM_SUB_FRAMES)];
if(rgHndlUlUeInfo(cell, sfInfo->ulUeInfo.timingInfo,
&sfInfo->ulUeInfo) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef XEON_SPECIFIC_CHANGES
}
/*stoping Task*/
SStopTask(startTime, PID_MAC_SF_ALLOC_REQ);
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacSfAllocReq */
/**
* @brief Handler for processing data indication recieved from PHY for UEs.
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
prevUeCb = rgDBMGetUeCb (cellCb, ceInfo->ces.cRnti);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
"CRNTI CE(%d) received through tmpCrnti(%d)",
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Processing for MSG3 failed",datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for processing data indication recieved from PHY for UEs.
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"CRNTI:%d Received MSG3 with CCCH",ceInfo->ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Processing for MSG3 failed", datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fix: syed Drop any duplicate Msg3(CCCH Sdu) */
if (ueCb->dl.hqEnt.numHqProcs)
/* HqE is already initialized by a previuos Msg3 */
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed. Duplicate "
"MSG3 received. Dropping", datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgDHMHqEntInit(inst,&ueCb->dl.hqEnt,
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Harq Initialization failed ",
datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
"CCCH SDU received through tmpCrnti(%d)",datInfo->rnti);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed",
datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_L2_MEAS
ueCb->ul.lcgArr[2].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs3];
ueCb->ul.lcgArr[3].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs4];
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgTOMUtlL2MStoreBufSz*/
/** @brief : Compiles list of LCs received in UL data for DTCH RBs
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
}
- RETVALUE(ret);
+ return (ret);
} /* RgUiRguBndReq */
RGLOGERROR(inst,ERRCLS_INT_PAR, ERG011, (ErrVal)rgCb[inst].rguSap[spId].sapCfg.spId,
"Invalid SAP Id:RgUiRguUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRguUbndReq */
/**
* @brief API for sending bind confirm from MAC to RLC
{
RLOG0(L_ERROR,"RgUiRguBndCfm Failed ");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgUIMRguBndCfm*/
if (datReq == NULLP)
{
RLOG0(L_ERROR,"Input Message Buffer is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgCb[inst].rguSap[spId].sapCfg.spId == spId)
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[id3]);
}
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[id3]);
}
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update RGU SAP statistics for received sdu count */
ret = rgROMDedDatReq(inst,datReq);
SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,sizeof(RguDDatReqInfo), SS_SHARABLE_MEMORY);
datReq = NULLP;
- RETVALUE(ret);
+ return (ret);
} /* RgUiRguDDatReq */
if (datReq == NULLP)
{
RLOG0(L_ERROR,"Input Message Buffer is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgCb[inst].rguSap[spId].sapCfg.spId == spId)
RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguCDatReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#if (ERRCLASS & ERRCLS_ADD_RES)
RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguCDatReq failed ",spId);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
ret = SPutStaticBuffer(pst->region, pst->pool,(Data *)datReq,sizeof(RguCDatReqInfo) , SS_SHARABLE_MEMORY);
datReq = NULLP;
- RETVALUE(ret);
+ return (ret);
} /* RgUiRguCDatReq */
/*stoping Task*/
SStopTask(startTime, PID_MAC_STA_RSP);
- RETVALUE(ret);
+ return (ret);
} /* RgUiRguDStaRsp */
if (staRsp == NULLP)
{
RLOG0(L_ERROR,"Input Response Buffer is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguCStaRsp failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#if (ERRCLASS & ERRCLS_ADD_RES)
RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguCStaRsp failed",spId);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,staRsp->cellId,"Processing Of Status Response Failed");
- RETVALUE(ret);
+ return (ret);
}
ret = SPutStaticBuffer(pst->region, pst->pool, (Data *)staRsp,sizeof(RguCStaRspInfo) , SS_SHARABLE_MEMORY);
staRsp = NULLP;
- RETVALUE(ret);
+ return (ret);
} /* RgUiRguCStaRsp */
#ifdef LTE_L2_MEAS
if (measReq == NULLP)
{
RLOG0(L_ERROR,"Input Response Buffer is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#if (ERRCLASS & ERRCLS_ADD_RES)
RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SPutStaticBuffer(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo) , SS_SHARABLE_MEMORY);
measReq= NULLP;
- RETVALUE(ret);
+ return (ret);
} /* RgUiRguL2MUlThrpMeasReq */
#endif
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"RgUiRguDStaInd Failed");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgUIMSndDedStaInd */
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"RgUiRguCStaInd Failed");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgUIMSndCmnStaInd */
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"RgUiRguDdatInd Failed");
- RETVALUE(ret);
+ return (ret);
}
#else
SRngIncrWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].pktRate++;
#endif
- RETVALUE(ret);
+ return (ret);
} /* rgUIMSndDedDatInd */
{
RGDBGERRNEW(inst,(rgPBuf(inst),"RgUiRguCDatInd Failed\n"));
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"RgUiRguCDatInd Failed");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgUIMSndCmnDatInd */
/**
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
}
- RETVALUE(ret);
+ return (ret);
} /* RgUiCrgBndReq */
RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgUbndReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgUbndReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiCrgUbndReq */
/**
if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
{
RLOG0(L_ERROR,"RgUiCrgBndCfm Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgUIMCrgBndCfm*/
/**
{
RLOG0(L_ERROR,"Input Param crgReqInfo is NULL ");
rgUIMCrgCfgCfm(inst,transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Upper SAP Id and State validation */
cfgReqInfo = NULLP;
rgUIMCrgCfgCfm(inst,transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
sizeof(CrgCfgReqInfo));
cfgReqInfo = NULLP;
rgUIMCrgCfgCfm(inst,transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgCOMCfgReq(inst,transId, cfgReqInfo);
SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
if (ret != ROK)
{
RLOG0(L_ERROR,"Configuration Request Handling Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiCrgCfgReq */
/**
if (ret != ROK)
{
RLOG0(L_ERROR,"RgUiCrgCfgCfm Failed ");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgUIMCrgCfgCfm */
#if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
if((elmIndx = (U32)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC)) == NULLP)
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
if (size == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* allocate buffer */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RGLOGERROR(inst,ERRCLS_DEBUG, ERG028, 0, "Unable to Allocate Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef ALIGN_64BIT
/* zero out the allocated memory */
cmMemset((U8 *)*pData, 0x00, size);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgAllocSBuf */
if (size == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* allocate buffer */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RGLOGERROR(inst,ERRCLS_DEBUG, ERG028, 0, "Unable to Allocate Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* zero out the allocated memory */
cmMemset((U8 *)*pData, 0x00, size);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgAllocSBuf */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RGLOGERROR(inst,ERRCLS_DEBUG, ERG030, 0, "Unable to Allocate Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgGetMsg */
{
RGLOGERROR(inst,ERRCLS_INT_PAR, ERG031, memSize,
"rgAllocEventMem(): memSize invalid\n");
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
#endif /* */
{
RLOG0(L_ERROR,"cmAllocEvnt Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*stoping Task*/
SStopTask(startTime, PID_MACUTL_CMALLCEVT);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgAllocEventMem*/
/*
#else
ret = cmGetMem(memCp, len, (Ptr *)ptr);
#endif /* */
- RETVALUE(ret);
+ return (ret);
} /* end of rgGetEventMem*/
/***********************************************************
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcgRegReq->cellId,"Cell does not exist ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, lcgRegReq->crnti)) == NULLP)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,cell->cellId,"CRNTI:%d does not exist",
lcgRegReq->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->ul.lcgArr[lcgRegReq->lcgId].isGbr = lcgRegReq->isGbr;
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacLcgRegReq */
#ifdef LTEMAC_SPS
{
RLOG_ARG0(L_ERROR, DBG_CELLID,ulSpsResetInfo->cellId,"Cell does not exist ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, ulSpsResetInfo->crnti)) == NULLP)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,cell->cellId,"CRNTI:%d does not exist",
ulSpsResetInfo->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->ul.implRelCntr = 0;
ue->ul.explRelCntr = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacUlSpsResetReq */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,lcInfo->cellId, "Cell does not exist ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, lcInfo->crnti)) == NULLP)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,cell->cellId,"CRNTI:%d does not exist",
lcInfo->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Store the sps-rnti and SPS LC information in the UE */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Ue insertion into SPS list failed SPS CRNTI:%d", ue->spsRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacSpsLcRegReq */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellId, "Cell does not exist ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, crnti)) == NULLP)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,cellId,"CRNTI:%d Ue does not exist", crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* No need to reset the SPS LC Ids as they will not be looked at*/
/* Delete UE from the SPS UE List */
rgDBMDelSpsUeCb(cell, ue);
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacSpsLcDeregReq */
#endif /* LTEMAC_SPS */
RLOG_ARG4(L_ERROR,DBG_CELLID,cell->cellId,
"RNTI:%d Failed to get UECB[%lu:%lu] or NEW RNTI:%d",
rnti, ((PTR)ue), ((PTR)newUe), newRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
CM_LOG_DEBUG(CM_LOG_ID_MAC, "MAC:UE[%d] id changed to %d\n", rnti, newRnti);
rgDBMDelUeCbFromRachLst(cell, newUe);
rgFreeSBuf(inst,(Data **)&newUe, sizeof(*newUe));
- RETVALUE(ROK);
+ return ROK;
} /* end of rgUtlHndlCrntiChng */
#ifdef LTE_ADV
} /* loop of if */
} /* loop of for */
- RETVALUE(ROK);
+ return ROK;
} /* rgDelUeFrmAllSCell */
/**
ret = RFAILED;
}
#endif
- RETVALUE(ret);
+ return (ret);
} /* rgUtlVltdAddSCellCfg */
/**
{
RGDBGERRNEW(inst,(rgPBuf(inst),"[%d]RNTI:Failed to get ueCb \
newRnti=%d\n", rnti, newRnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* For all added SCells, prepare and send ueIdChngReq */
for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
} /* loop of if */
} /* loop of for */
- RETVALUE(ROK);
+ return ROK;
} /* rgUtlSndCrntiChngReq2AllSMacs */
#endif /* LTE_ADV */
if(NULLP == rlsRnti)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell == NULLP) ||
RLOG_ARG1(L_ERROR,DBG_CELLID,rlsRnti->cellId,
"No cellCb found with cellId for RNTI:%d",
rlsRnti->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fix : syed Clearing UE context when SCH indicates to do so
* UE DEL from CRG interface is now dummy. */
RLOG_ARG2(L_ERROR,DBG_CELLID,rlsRnti->cellId,
"CRNTI change failed for RNTI:%d new RNTI:%d",
rlsRnti->rnti,rlsRnti->newRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
if(rgUtlSndCrntiChngReq2AllSMacs(cell, rlsRnti->rnti, rlsRnti->newRnti) != ROK)
{
/* TODO: do we need to send DelInd to SCH in failure case*/
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef L2_OPTMZ
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacRlsRntiReq */
#ifdef L2_OPTMZ
{
MsgLen len = 0;
SFndLenMsg(tb->macHdr, &len);
- RETVALUE(len?TRUE : FALSE);
+ return (len?TRUE : FALSE);
}
#endif
kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMDL_POLL_RETX_TMR);
}
- RETVALUE(pollBit);
+ return (pollBit);
}
/**
#endif
{
TRC2(kwAmmDiscSdu);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/**
if( ROK != kwDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
{
printf("\n RLC UECb Not found...\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Skip if mode is not AM */
if((rbCb == NULLP) || (rbCb->mode != CM_LTE_MODE_AM))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK != SExamMsg((Data *)(&fByte),
rlcSdu, 0))
{
printf("\n Failure in Rlc Hdr SExamMsg\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(KW_CNTRL_PDU == ((fByte & KW_DC_POS) >> KW_DC_SHT))
retVal = ROK;
}
- RETVALUE(retVal);
+ return (retVal);
}
}
*prevNackSn = sn;
- RETVALUE(sizeToBeEncd);
+ return (sizeToBeEncd);
}
/**
if (KW_CNTRL_PDU == amHdr->dc)
{
//printf ("++++++++++++ 5GNRLOG HDR extracted CTRL : \n");
- RETVALUE(ROK);
+ return ROK;
}
amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT;
}
//printf ("++++++++++++ 5GNRLOG HDR extracted DATA : sn %d \n", sn);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef OLD
amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT;
if (KW_CNTRL_PDU == amHdr->dc)
{
- RETVALUE(ROK);
+ return ROK;
}
/* kw002.201 : Changed the extraction of hdr elements to avoid */
/* function calls */
if (! hdrInfo.val)
{
RLOG0(L_ERROR, "Received LI as 0");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* store the extracted LI value */
{
RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]",
amHdr->numLi, KW_MAX_UL_LI);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* first 2 bytes + Add one for Odd LI*/
{
RLOG3(L_ERROR,"SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ",
amHdr->sn, totalSz, pduSz);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
rbCb->rlcId.cellId);
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
if (recBuf->allRcvd == TRUE)
{
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
}
/* This is a duplicate segment */
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
if ((seg) && (seg->amHdr.so <= soEnd))
/* This is a duplicate segment */
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
/* If we have come this far, we have to add this segment to the */
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
tseg->lstEnt.node = (PTR)tseg;
kwAmmUpdExpByteSeg(gCb,&AMUL,tseg);
- RETVALUE(TRUE);
+ return (TRUE);
}
/**
gCb->genSts.unexpPdusRecv++;
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
if (amHdr->si == 0)
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif /* ERRCLASS & ERRCLS_RES */
kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
gCb->genSts.unexpPdusRecv++;
RLC_FREE_BUF(pdu);
- RETVALUE(FALSE);
+ return (FALSE);
}
recBuf->isDelvUpperLayer = FALSE;
recBuf->pdu = pdu;
recBuf->allRcvd = TRUE;
gRlcStats.amRlcStats.numRlcAmCellSduRx++;
KW_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(KwAmHdr));
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
/* We received a segment. We need to add that to the existing */
/* segments, if any. */
- RETVALUE(kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
+ return (kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
}
}
AMUL.expSo = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
}
}
- RETVALUE(ROK);
+ return ROK;
}
{
if (gCb->genCfg.maxUe == measCb->val.ipThMeas.numUes)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (gCb->genCfg.maxUe == freeIdx)
{
}
kwRbCb->rbL2Cb.measOn |= measCb->measType;
}
- RETVALUE(ROK);
+ return ROK;
}/*kwAddToDlL2Meas*/
#endif /*LTE_L2_MEAS*/
\f
"Invalid RB Mode ueId(%d),cellId(%d)",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rbCb->mode = entCfg->entMode;
rbCb->discTmrInt = entCfg->discardTmr;
- RETVALUE(ROK);
+ return ROK;
}
\f
entCfg->entMode,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(CKW_CFG_REAS_RB_MODE_MIS);
+ return (CKW_CFG_REAS_RB_MODE_MIS);
}
switch (rbCb->mode)
if (entCfg->lCh[0].type == CM_LTE_LCH_DCCH)
{
- RETVALUE(CKW_CFG_REAS_LCHTYPE_MIS);
+ return (CKW_CFG_REAS_LCHTYPE_MIS);
}
ueCb->lCh[rbCb->lch.lChId - 1].dlRbCb = NULLP;
ueCb->lCh[entCfg->lCh[0].lChId - 1].dlRbCb = rbCb;
/* AGHOSH */
rbCb->discTmrInt = entCfg->discardTmr;
/* AGHOSH */
- RETVALUE(CKW_CFG_REAS_NONE);
+ return (CKW_CFG_REAS_NONE);
}
\f
RLOG_ARG1(L_ERROR,DBG_RBID,entCfg->rbId,
"Add DLRb,CellId is 0 for UEID:%d",
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((entCfg->rguSapId >= gCb->genCfg.maxRguSaps) || (entCfg->rguSapId < 0))
{
KWDBGP_ERROR(gCb, "rlcCfgAddDlRb(ueId(%u), cellId(%u), Invalid rguSapId (%d)\n",
ueId, cellId, entCfg->rguSapId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
KW_MAX_RB_PER_CELL,
cellId,
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (((entCfg->lCh[0].type == CM_LTE_LCH_BCCH) ||
"RbId [%d] already exists UEID:%d",
entCfg->rbId,
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else /* Cell CB UNKNOWN */
"cellCb Creation failed RBID:%d UEID:%d",
entCfg->rbId,
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_LCHID);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create RB CB */
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_RB_CREAT_FAIL);
- RETVALUE(RFAILED);
+ return RFAILED;
}
kwRbCb->rlcId.rbId = entCfg->rbId;
cellCb->rbCb[entCfg->rbId] = kwRbCb;
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, reason);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
"Invalid RbId for RbType[%d] UEID:%d",
entCfg->rbType,
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((((entCfg->lCh[0].type == CM_LTE_LCH_DCCH) &&
(entCfg->entMode != CM_LTE_MODE_UM) &&
"CellId[%u]:rbId [%d] already exists",
cellId,
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else /* UE CB UNKNOWN */
"UeId [%u]:ueCb Creation Failed RBID:%d",
ueId,
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_LCHID);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create RB CB */
"Memory allocation failed RBID:%d CELLID:%d",
entCfg->rbId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* copy the RB Cb into UECb */
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_NOK, reason);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
"Filling of RbCb failed UEID:%d CELLID:%d",
ueId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
kwRbCb->qci = entCfg->qci;
#ifdef LTE_L2_MEAS
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
- RETVALUE(ROK);
+ return ROK;
}
\f
KW_MAX_RB_PER_CELL,
ueId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get cellCb */
kwDbmFetchDlCellCb(gCb,cellId, &cellCb);
ueId,
entCfg->rbId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get rbCb */
"CELLID:%d RBID:%d not found",
cellId,
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Take backup of rbCb before updating.
entCfg->rbId);
cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(RlcDlRbCb));
- RETVALUE(ret);
+ return (ret);
}
}
else
cellId,
entCfg->rbId,
entCfg->rbType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get ueCb */
ret = kwDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb);
"UEID:%d UeCb not found RBID:%d",
ueId,
entCfg->rbId);
- RETVALUE(ret);
+ return (ret);
}
/* Get rbCb */
"CELLID:%d RBID:%d not found",
cellId,
entCfg->rbId);
- RETVALUE(ret);
+ return (ret);
}
/* Take backup of rbCb before updating.
entCfg->rbId);
cmMemcpy((U8*)rbCb, (U8 *)&tRbCb, sizeof(RlcDlRbCb));
- RETVALUE(ret);
+ return (ret);
}
}
/* Fill entCfm structure */
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
- RETVALUE(ROK);
+ return ROK;
}
\f
KW_MAX_RB_PER_CELL,
ueId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get cellCb */
kwDbmFetchDlCellCb(gCb,cellId, &cellCb);
"CellCb not found UEID:%d RBID:%d",
ueId,
entCfg->rbId);
- RETVALUE(ret);
+ return (ret);
}
/* Get rbCb */
"CellId[%u]:RbId[%d] not found",
cellId,
entCfg->rbId);
- RETVALUE(ret);
+ return (ret);
}
/* Assign NULLP to rbCb in rbCbLst */
entCfg->rbType,
ueId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get ueCb */
"UeId [%d]: UeCb not found RBID:%d",
ueId,
entCfg->rbId);
- RETVALUE(ret);
+ return (ret);
}
/* Get rbCb */
"CellId[%u]:RbId[%d] not found",
cellId,
entCfg->rbId);
- RETVALUE(ret);
+ return (ret);
}
ueCb->lCh[kwRbCb->lch.lChId - 1].dlRbCb = NULLP;
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType, CKW_CFG_CFM_OK,
CKW_CFG_REAS_NONE);
- RETVALUE(ret);
+ return (ret);
}
\f
"CellId[%u]:RbId[%d] not found",
cellId,
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rbCb->rlcId.ueId = ueId;
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
- RETVALUE(ROK);
+ return ROK;
}
\f
"ueId(%d), cellId(%d)",
ueId,
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch Ue Cb */
"UEID:%d UeCb not found RBID:%d",
ueId,
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
KW_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
CKW_CFG_CFM_OK, CKW_CFG_REAS_NONE);
- RETVALUE(ROK);
+ return ROK;
}
RLOG_ARG1(L_DEBUG,DBG_RBID,entCfg->rbId,
"cellId is 0 (%d) ",
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch Ue Cb */
RLOG_ARG1(L_ERROR, DBG_CELLID,cellId,
"CellCb not found for RBID:%d",
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Delete Ue Cb */
KW_CFG_FILL_CFG_CFM(entCfm, rbId, entCfg->rbType, CKW_CFG_CFM_OK,
CKW_CFG_REAS_NONE);
- RETVALUE(ROK);
+ return ROK;
}
/**
"Old UeId[%d] same as new UeId[%d]",
ueInfo->ueId,
newUeInfo->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK == kwDbmFetchDlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
newUeInfo->ueId);
status->reason = CKW_CFG_REAS_UE_EXISTS;
status->status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK != kwDbmFetchDlUeCb(gCb,ueInfo->ueId, ueInfo->cellId, &ueCb))
ueInfo->ueId);
status->reason = CKW_CFG_REAS_UE_UNKWN;
status->status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
ueInfo->ueId);
status->reason = CKW_CFG_REAS_UE_CREAT_FAIL;
status->status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* update the hash key with new values */
newUeInfo->ueId);
status->reason = CKW_CFG_REAS_UE_CREAT_FAIL;
status->status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/********************************************************************30**
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
}
}
- RETVALUE(ROK);
+ return ROK;
}
{
if (gCb->genCfg.maxUe == measCb->val.ipThMeas.numUes)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (gCb->genCfg.maxUe == freeIdx)
{
}
kwRbCb->rbL2Cb.measOn |= measCb->measType;
}
- RETVALUE(ROK);
+ return ROK;
}/*kwAddToDlL2Meas*/
#endif /*LTE_L2_MEAS*/
\f
"INVALID RB Mode cellId(%d), rbId(%d)",
rbCb->rlcId.cellId,
entCfg->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rbCb->mode = entCfg->entMode;
- RETVALUE(ROK);
+ return ROK;
}
\f
break;
}
}
- RETVALUE(CKW_CFG_REAS_NONE);
+ return (CKW_CFG_REAS_NONE);
}
\f
if (cellId == 0)
{
status->reason = CKW_CFG_REAS_CELL_UNKWN;
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0))
{
KWDBGP_ERROR(gCb, "kwValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
ueId, cellId, cfgToValidate->rguSapId);
status->reason = CKW_CFG_REAS_INVALID_RGUSAP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((CKW_CFG_ADD == cfgToValidate->cfgType) ||
(cfgToValidate->lCh[1].lChId <= 0)))
{
status->reason = CKW_CFG_REAS_INVALID_LCHID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cfgToValidate->entMode == CM_LTE_MODE_UM) &&
(cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_5BIT_SN_LEN) &&
cfgToValidate->rbId,
cfgToValidate->m.umInfo.ul.snLen);
status->reason = CKW_CFG_REAS_INVALID_SNLEN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Process Adding new RB */
if (ueId == 0)
if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cfgToValidate->lCh[0].type != CM_LTE_LCH_CCCH) &&
{
status->reason= (cfgToValidate->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
CKW_CFG_REAS_LCHTYPE_MIS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cfgToValidate->entMode == CM_LTE_MODE_TM)
{
status->reason = CKW_CFG_REAS_LCHTYPE_MIS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!(((cfgToValidate->lCh[0].type == CM_LTE_LCH_DCCH) &&
(cfgToValidate->entMode != CM_LTE_MODE_UM))||
(cfgToValidate->lCh[0].type == CM_LTE_LCH_DTCH)) )
{
status->reason = CKW_CFG_REAS_RB_MODE_MIS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
\f
cfgToValidate,
&cfgEntData->entUlCfgCfm.status))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_NONE;
"Memory allocation failure CELLID:%d",
cfgTmpData->cellId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
kwDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
}
if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP))
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (!cfgEntData->rbCb)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
"Memory allocation failure CELLID:%d",
cfgTmpData->cellId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
kwDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
}
if(cfgEntData->rbCb != NULLP)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
if (!cfgEntData->rbCb)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/*Allocating the memory for receive buffer */
cfgTmpData->ueId);
/*how can a modify request come for a cell which does not exist*/
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfgEntData->rbCb = cfgTmpData->cellCb->rbCb[cfgToValidate->rbId];
{
/* something is wrong the rbId for this cell does not exist */
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
else
{
"UeId [%d]: UeCb not found",
cfgTmpData->ueId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get rbCb */
if ( cfgEntData->rbCb == NULLP)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
break;
}
if(cfgToValidate->entMode != cfgEntData->rbCb->mode)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_MODE_MIS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cfgToValidate->m.umInfo.ul.snLen != cfgEntData->rbCb->m.umUl.snLen)
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_SNLEN_MIS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
\f
RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
}
- RETVALUE(ROK);
+ return ROK;
}
\f
RLOG_ARG1(L_ERROR,DBG_UEID,cfgTmpData->ueId,
"UeId is 0 for CELLID;%d",
cfgTmpData->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch Ue Cb */
"UeId [%d]: UeCb not found",
cfgTmpData->ueId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch Cell Cb */
{
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
cellId,
cfgToValidate->rbId);
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
{
CFM_STATUS.reason = CKW_CFG_REAS_SAME_UEID;
CFM_STATUS.status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK == kwDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
newUeInfo->ueId);
CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS;
CFM_STATUS.status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK != kwDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
ueInfo->ueId);
CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN;
CFM_STATUS.status = CKW_CFG_CFM_NOK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#undef CFM_STATUS
- RETVALUE(ROK);
+ return ROK;
}
KW_GET_MEM_POOL(gCb)))
{
RLOG0(L_ERROR, "UeLstCp Initialization Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize cellCb Hash List */
{
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
RLOG0(L_ERROR, "CellLstCp Initialization Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* kw005.201 added support for L2 Measurement */
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize tbHlCp Hash List */
cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* LTE_L2_MEAS */
- RETVALUE(ROK);
+ return ROK;
} /* kwDbmDlInit */
\f
RLOG_ARG1(L_FATAL,DBG_UEID,ueId,
"Memory allocation failed cellID:%d",
cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,
"UeId[%u] HashList Insertion Failed",
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.numUe++;
- RETVALUE(ROK);
+ return ROK;
} /* kwDbmCreateUeCb */
\f
TRC3(kwDbmFetchDlUeCb)
- RETVALUE(cmHashListFind(&(gCb->u.dlCb->ueLstCp),
+ return (cmHashListFind(&(gCb->u.dlCb->ueLstCp),
(U8 *)&(ueId),
sizeof(CmLteRnti),
KW_DEF_SEQ_NUM,
if (*cellCb == NULLP)
{
RLOG_ARG0(L_FATAL, DBG_CELLID,cellId,"Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
(U16) sizeof(CmLteCellId)))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellId,"HashList Insertion Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* kwDbmCreateDlCellCb */
\f
(PTR*) cellCb))
{
RLOG_ARG0(L_ERROR,DBG_CELLID, cellId,"CellCb not found");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* kwDbmFetchCellCb */
\f
kwDbmDlDeInit(gCb);
- RETVALUE(ROK);
+ return ROK;
} /* kwDbmShutdown */
KW_GET_MEM_POOL(gCb)))
{
RLOG0(L_ERROR, "UeLstCp Initialization Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize cellCb Hash List */
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
RLOG0(L_ERROR, "CellLstCp Initialization Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK != cmHashListInit(&(gCb->u.ulCb->transIdLstCp),
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
cmHashListDeinit(&gCb->u.ulCb->cellLstCp);
RLOG0(L_ERROR, "transIdLstCp Initialization Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* kw005.201 added support for L2 Measurement */
/* Initialize qcI Hash List */
#endif /* LTE_L2_MEAS */
- RETVALUE(ROK);
+ return ROK;
} /* kwDbmUlInit */
\f
RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,
"UeId[%u] HashList Insertion Failed",
ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* kw005.201 ccpu00117318, updating the statistics */
gCb->genSts.numUe++;
- RETVALUE(ROK);
+ return ROK;
}
\f
RLOG1(L_DEBUG, "(transId(%d))", cfg->transId);
#endif
- RETVALUE(cmHashListInsert(&(gCb->u.ulCb->transIdLstCp),
+ return (cmHashListInsert(&(gCb->u.ulCb->transIdLstCp),
(PTR)cfg,
(U8 *)&(cfg->transId),
(U16) sizeof(cfg->transId)));
KW_DEF_SEQ_NUM,(PTR *) cfg))
{
RLOG1(L_ERROR,"TransId [%ld] not found",transId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
if(cmHashListDelete(&(gCb->u.ulCb->transIdLstCp),(PTR) (cfg)) != ROK)
{
RLOG0(L_ERROR,"HashList Deletion failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
{
if(kwDbmDelUlTransaction(gCb, cfg) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfg = NULLP;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(kwDbmFetchUlUeCb)
- RETVALUE(cmHashListFind(&(gCb->u.ulCb->ueLstCp),
+ return (cmHashListFind(&(gCb->u.ulCb->ueLstCp),
(U8 *)&(ueId), sizeof(CmLteRnti),
KW_DEF_SEQ_NUM,
(PTR *) ueCb));
{
RLOG_ARG0(L_ERROR,DBG_CELLID,tCellCb->cellId,
"HashList Insertion Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
{
TRC2(rlcDlInitExt);
- RETVALUE(ROK);
+ return ROK;
} /* kwInitExt */
if (inst >= MAX_RLC_INSTANCES)
{
/* intance greater than MAX instances */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rlcCb[inst] != NULLP)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if (SGetSBuf(region, 0, (Data **)&tRlcCb,
(Size)sizeof (RlcCb)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize rlcCb */
RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
- RETVALUE(ROK);
+ return ROK;
} /* kwActvInit */
\f
}
#endif /* LCKWU */
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from SM",
}
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
#endif /* LCKWU */
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
}
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
#endif
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
break;
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
#endif
kwUtlFreeDlMem();
#endif
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
}
RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",
pst->event);
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
break;
}
}
- SExitTsk();
+ ODU_EXIT_TASK();
- RETVALUE(ret);
+ return (ret);
} /* kwActvTsk */
KWLOGERROR(ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId, \
"KwUiKwuBndReq: KWU SAP State is Invalid during Bind Req"); \
KW_SEND_SAPID_ALARM(spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);\
- RETVALUE(RFAILED); \
+ return RFAILED; \
} \
}
#else
KWLOGERROR(_cb,ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId,\
"KwUiCkwBndReq: CKW SAP State is Invalid during Bind Req");\
KW_SEND_SAPID_ALARM(_cb,spId, LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);\
- RETVALUE(RFAILED); \
+ return RFAILED; \
} \
}
#endif
KWLOGERROR(_cb,ERRCLS_INT_PAR, EKWxxx, (ErrVal) spId,\
"KwUiCkwBndReq: UDX SAP State is Invalid during Bind Req");\
KW_SEND_SAPID_ALARM(_cb,spId, LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_STATE);\
- RETVALUE(RFAILED); \
+ return RFAILED; \
} \
}
#endif
s->bRev = sId.bRev;
s->ptNmb = sId.ptNmb;
- RETVALUE(TRUE);
+ return (TRUE);
} /* end of kwGetSId */
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
KW_SEND_SAPID_ALARM(tRlcCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((suId >= tRlcCb->genCfg.maxRguSaps) || (suId < 0))
KW_SEND_SAPID_ALARM(tRlcCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Send an alarm with proper event and cause */
KW_SEND_SAPID_ALARM(tRlcCb, suId, event, cause);
- RETVALUE(ROK);
+ return ROK;
} /* KwLiRguBndCfm */
/**
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcMacData));
- RETVALUE(ROK);
+ return ROK;
}/* End of RlcProcUlData */
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG_ARG1(L_ERROR,DBG_LCID,datInd->lcId, "Invalid LcId, Max is [%d]",
KW_MAX_LCH_PER_CELL);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
RLOG_ARG1(L_ERROR, DBG_CELLID,datInd->cellId, "LcId [%d] not found",
datInd->lcId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Dispatch to TM Module */
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
- RETVALUE(ROK);
+ return ROK;
} /* KwLiRguCDatInd */
/**
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
{
RLOG1(L_DEBUG,"KwLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
kwUtlRcvFrmLi(RLC_GET_RLCCB(pst->dstInst),datInd);
#endif
#endif
- RETVALUE(ROK);
+ return ROK;
} /* KwLiRguDDatInd */
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRepInfo));
- RETVALUE(ROK);
+ return ROK;
}
/**
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
EKW040,
(ErrVal) suId,
"KwLiRguCStaInd: Invalid RGU suId\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (tRlcCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
{
"Received in RLC UL CELLID:%d",
staInd->cellId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
KW_MAX_LCH_PER_CELL,
staInd->cellId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
/* Fertch RbCb from lcId */
"LcId [%d] not found CELLID:%d",
staInd->lcId);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Dispatch to TM Module */
#else
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
#endif
- RETVALUE(ROK);
+ return ROK;
} /* KwLiRguCStaInd */
/**
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"Received in RLC UL ");
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0))
{
EKW040,
(ErrVal) suId,
"KwLiRguDStaInd: Invalid RGU suId\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
kwUtlSndToLi(gCb, suId, staInd);
/* kw002.201 :Freeing from proper region */
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
- RETVALUE(ROK);
+ return ROK;
} /* KwLiRguDStaInd */
/**
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
ret = kwDbmFetchDlUeCb(tRlcCb, ueKey.ueId, ueKey.cellId, &ueCb);
if (ret != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*Call kwUtlProcHarqInd as many times as number of Tbs present*/
kwUtlProcHarqInd(tRlcCb, staInd, ueCb, tbIdx);
}
- RETVALUE(ROK);
+ return ROK;
} /* KwLiRguHqStaInd */
#endif /* LTE_L2_MEAS */
KW_MAX_UE,
cfg->maxUe);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if(cfg->maxKwuSaps > KW_MAX_KWUSAPS)
KW_MAX_KWUSAPS,
cfg->maxKwuSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if(cfg->maxUdxSaps > KW_MAX_UDXSAPS)
KW_MAX_UDXSAPS,
cfg->maxUdxSaps);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > KW_MAX_RGUSAPS))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if(gCb->init.cfgDone == TRUE)
{
/* reconfiguration not supported */
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
gCb->genCfg = *cfg;
if (gCb->u.dlCb == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
/* allocate memory to the KWU sap's */
{
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
"kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
RLOG0(L_FATAL,"RLC DL Initialization failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#if 0
/* Register the timer */
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- RETVALUE(LCM_REASON_REGTMR_FAIL);
+ return (LCM_REASON_REGTMR_FAIL);
}
#endif
/* initializations for background processing of freeing memory */
RLC_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
RLC_FREE(gCb,gCb->u.dlCb, sizeof (RlcDlCb));
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#ifdef LTE_L2_MEAS
if (gCb->u.ulCb == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
/* allocate memory to the KWU sap's */
{
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
"kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLC_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
RLC_FREE(gCb,gCb->u.ulCb, sizeof (RlcUlCb));
- RETVALUE(LCM_REASON_REGTMR_FAIL);
+ return (LCM_REASON_REGTMR_FAIL);
}
#endif
#ifdef LTE_L2_MEAS
RLOG0(L_ERROR, "Received Invalid RLC Mode");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
/* Timer Initialization */
gCb->kwTqCp.tmrLen = KW_TMR_LEN;
gCb->init.cfgDone = TRUE;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check configuration is done or not */
if ((tRlcCb->init.cfgDone != TRUE) &&
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG1(L_DEBUG, "KwMiRlcConfigReq elmId(%d)", cfg->hdr.elmId.elmnt);
cfg->cfm.status = LCM_PRIM_OK;
cfg->cfm.reason = LCM_REASON_NOT_APPL;
kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- RETVALUE(ROK);
+ return ROK;
}
else
{
cfg->cfm.status = LCM_PRIM_NOK;
cfg->cfm.reason = reason;
kwLmmSendCfm(tRlcCb,pst, cfg, TCFG, &cfg->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cntrl->cfm.reason = LCM_REASON_INVALID_INSTANCE;
kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!(tRlcCb->init.cfgDone))
cntrl->cfm.status = LCM_PRIM_NOK;
cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG1(L_DEBUG, "KwMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
kwLmmSendCfm(tRlcCb,pst, cntrl, TCNTRL, &cntrl->hdr);
- RETVALUE(ROK);
+ return ROK;
}
/**
sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
kwLmmSendCfm(tRlcCb,pst, sta, TSSTA, &sta->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
}
kwLmmSendCfm(tRlcCb,pst, &rSta, TSSTA, &sta->hdr);
- RETVALUE(ROK);
+ return ROK;
}
/**
rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
kwLmmSendCfm(tRlcCb,pst, &rSts, TCNTRL, &sts->hdr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG2(L_DEBUG, "KwMiLkwStsReq(elmId(%d),action(%d))",
}
kwLmmSendCfm(tRlcCb,pst, &rSts, TSTS, &sts->hdr);
- RETVALUE(ROK);
+ return ROK;
}
/* kw005.201 added support for L2 Measurement */
#endif /* ERRCLASS & ERRCLS_ADD_RES */
kwUtlSndUlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
kwUtlSndDlL2MeasNCfm(tRlcCb, measReqEvt, &measCfmEvt);
RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt))
- RETVALUE(ROK);
+ return ROK;
}
/* for UL IP throughput meas enable for all QCIs */
if(measEvt == NULLP)
{
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(KwL2MeasReqEvt));
}
/*RLC_FREE(tRlcCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
- RETVALUE(ret);
+ return (ret);
} /* KwMiLkwL2MeasReq */
/**
{
/*Redirect the request to DL task */
rlcUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
- /*RETVALUE(ROK);*/
+ /*return ROK;*/
}
/*cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
status = LCM_PRIM_OK;
KwMiLkwL2MeasStopCfm(&tRlcCb->genCfg.lmPst, measType,status);
- RETVALUE(ret);
+ return (ret);
}
/**
@brief
/*Redirect the request to DL task */
rlcUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),measType);
/* L2 MEAS AGHOSH */
- /*RETVALUE(ROK);*/
+ /*return ROK;*/
}
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
/* Validate the protocol parameters */
if((cfg->sapId >= (S16)gCb->genCfg.maxKwuSaps) || (cfg->sapId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
RLOG2(L_ERROR,"RLC Mode [%d] : Invalid kwuSap State [%d]",
gCb->genCfg.rlcMode, kwuSapCb->state);
/* reconfiguration not allowed */
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
KW_FILL_SAP_HELPER(kwuSapCb, cfg, gCb);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
/* Validate config parameters */
if ((cfg->sapId >= KW_MAX_CKWSAPS) || (cfg->sapId < 0) )
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
/* Get Sap control block */
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
if(ckwSap->state != KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid kwuSap State [%d]",ckwSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Fill the parameters */
KW_FILL_SAP_HELPER(ckwSap, cfg, gCb);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
/* Validate the protocol parameters */
if((cfg->sapId >= KW_MAX_UDXSAPS) || (cfg->sapId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
/* Get Sap control block */
if(udxDlSap->state != KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(udxUlSap->state != KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
cmInitTimers(&(udxUlSap->bndTmr), 1);
}
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
{
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
"kwLmmCfgRguSap: Invalid RGU sapId\n");
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
{
RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
gCb->genCfg.rlcMode, rguSap->state);
- RETVALUE(LCM_REASON_RECONFIG_FAIL);
+ return (LCM_REASON_RECONFIG_FAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
cmInitTimers(&(rguSap->bndTmr), 1);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
break;
}
- RETVALUE(reason);
+ return (reason);
}
/**
RLC_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
if (reason != LCM_REASON_NOT_APPL)
{
- RETVALUE(reason);
+ return (reason);
}
switch(cntrl->t.cntrl.action)
break;
}
}
- RETVALUE(reason);
+ return (reason);
}
/**
#if (ERRCLASS & ERRCLS_INT_PAR)
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- RETVALUE(LCM_REASON_INVALID_SAP);
+ return (LCM_REASON_INVALID_SAP);
}
/* validate SuId */
if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
(cntrl->t.cntrl.s.sapCntrl.suId >= KW_MAX_UDXSAPS))
{
- RETVALUE(LCM_REASON_INVALID_SAP);
+ return (LCM_REASON_INVALID_SAP);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(UDX_SAP.state == KW_SAP_NOT_CFG)
{
RLOG0(L_ERROR,"udxUlSap not configured yet");
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
else
{
/* control request received for an already bound SAP */
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
}
break;
}
break;
default:
- RETVALUE(LCM_REASON_INVALID_ACTION);
+ return (LCM_REASON_INVALID_ACTION);
break;
} /* end of switch */
#undef UDX_SAP
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
{
KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
"kwLmmLSapCntrl: Invalid RGU suId\n");
- RETVALUE(LCM_REASON_INVALID_SAP);
+ return (LCM_REASON_INVALID_SAP);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
if(rguSap->state == KW_SAP_NOT_CFG)
{
RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
else
{
/* control request received for an already bound SAP */
- RETVALUE(LCM_REASON_INVALID_STATE);
+ return (LCM_REASON_INVALID_STATE);
}
}
break;
}
break;
default:
- RETVALUE(LCM_REASON_INVALID_ACTION);
+ return (LCM_REASON_INVALID_ACTION);
break;
} /* end of switch */
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
(sta->spId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
sta->state = kwSapCb->state;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
/* Validate the protocol parameters */
if((sta->suId >= KW_MAX_RGUSAPS) || (sta->suId < 0))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
gCb->u.dlCb->rguDlSap[sta->suId].state :
gCb->u.ulCb->rguUlSap[sta->suId].state ;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
(sta->spId < 0 ) ||
(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
sta->state = gCb->u.ulCb->ckwSap.state;
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/* Validate protocol parameters */
if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS))
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
#endif
RLC_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
}
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
/* Validate protocol parameters */
if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
switch(elmnt)
{
ckwSap = &sts->t.sts.s.ckwSap;
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
ckwSap->statMsgs = gCb->u.ulCb->ckwSap.sts.statMsgs;
break;
}
default:
- RETVALUE(LCM_REASON_INVALID_ELMNT);
+ return (LCM_REASON_INVALID_ELMNT);
}
SGetDateTime(&sts->t.sts.dt);
- RETVALUE(LCM_REASON_NOT_APPL);
+ return (LCM_REASON_NOT_APPL);
}
/**
{
/* rg005.201 removed SPutSBuf on error */
RLOG0(L_ERROR,"SCpyMsgMsg Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Send Trace Indication to Layer manager */
KwMiLkwTrcInd(&pst, &trc, dstMbuf);
if (SFndLenMsg(mBuf, &bufLen) != ROK)
{
RLOG0(L_ERROR,"SFndLenMsg Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the recvd buffer size is less than request trace len */
if(bufLen < gCb->trcLen)
!= ROK)
{
RLOG0(L_ERROR,"SCpyMsgMsg Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Send Trace Indication to Layer manager */
(Void) SPutSMem(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb));
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)
{
RLOG0(L_ERROR,"SCpyMsgFix Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
{
RLOG0(L_FATAL,"Memory Allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Copy the tempBuf data to dst mBuf */
if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
{
RLOG0(L_ERROR,"SCpyMsgFix Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Free the memory allocated for tempBuf */
KwMiLkwTrcInd(&pst, &trc, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
if (inst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
gCb = RLC_GET_RLCCB(inst);
cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
- RETVALUE(ROK);
+ return ROK;
} /* end of kwActvTmr */
/* jump to specific primitive depending on configured selector */
(*kwLiRguBndReqMt[post->selector])(post, suId, spId);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwLiRguBndReq */
/* jump to specific primitive depending on configured selector */
(*kwLiRguUbndReqMt[post->selector])(post, spId, reason);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwLiRguUbndReq */
SPutStaticBuffer(post->region, post->pool,
(Data *) datReq, sizeof(RguDDatReqInfo), 0);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
/* jump to specific primitive depending on configured selector */
(*rlcMacSendDlDataOpts[post->selector])(post, spId, dlData);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of KwLiRguDDatReq */
post->event= EVTRGUDSTARSP;
if((kwLiRguStaRspRbuf(post, spId, staRsp)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* jump to specific primitive depending on configured selector */
(*rlcMacSendBOStatusOpts[post->selector])(post, spId, boSta);
- RETVALUE(ROK);
+ return ROK;
} /* end of RlcMacSendBOStatus */
/* jump to specific primitive depending on configured selector */
(*kwLiRguL2MUlThrpMeasReqMt[post->selector])(post, spId, l2mUlThrpMeasReq);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwLiRguL2MUlThrpMeasReq */
break;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].pktDrop++;
ret1 = RFAILED;
}
- RETVALUE(ret1);
+ return (ret1);
} /* cmPkKwuDatReq */
#endif
SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].pktDrop++;
ret1 = RFAILED;
}
- RETVALUE(ret1);
+ return (ret1);
} /* cmPkKwuDatReq */
#endif
/* jump to specific primitive depending on configured selector */
(*kwMiRlcConfigCfmMt[pst->selector])(pst, cfm);
- RETVALUE(ROK);
+ return ROK;
}
/* jump to specific primitive depending on configured selector */
(*kwMiLkwCntrlCfmMt[pst->selector])(pst, cfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwMiLkwCntrlCfm */
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStaIndMt[pst->selector])(pst, usta);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwMiLkwStaInd */
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStaCfmMt[pst->selector])(pst, cfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwMiLkwStaCfm */
/* jump to specific primitive depending on configured selector */
(*kwMiLkwStsCfmMt[pst->selector])(pst, action, cfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwMiLkwStsCfm */
/* jump to specific primitive depending on configured selector */
(*kwMiLkwTrcIndMt[pst->selector])(pst, trc, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwMiLkwTrcInd */
(*KwMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
(*KwMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
TRC2(PtMiRlcConfigCfm() : function is not implemented)
- RETVALUE(ROK);
+ return ROK;
} /* end of PtMiRlcConfigCfm */
/*
TRC2(PtMiLkwCntrlCfm() : function is not implemented)
- RETVALUE(ROK);
+ return ROK;
} /* end of PtMiLkwCntrlCfm */
TRC2(PtMiLkwStaInd() : function is not implemented)
- RETVALUE(ROK);
+ return ROK;
} /* end of PtMiLkwStaInd */
UNUSED(pst);
UNUSED(cfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of PtMiLkwStaCfm */
UNUSED(action);
UNUSED(cfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of PtMiLkwStsCfm */
UNUSED(trc);
UNUSED(mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of PtMiLkwTrcInd */
/* kw005.201 added support for L2 Measurement */
UNUSED(pst);
UNUSED(measEvt);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
UNUSED(measType);
UNUSED(status);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuBndCfmMt[pst->selector])(pst, suId, status);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuBndCfm */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatIndMt[pst->selector])(pst, datInd, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuDatInd */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatCfmMt[pst->selector])(pst, suId, datCfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuDatCfm */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuStaIndMt[pst->selector])(pst, suId, staInd);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuStaInd */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuReEstCmpIndMt[pst->selector])(pst, suId, rlcId);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuReEstCmpInd */
/* kw005.201 added support for L2 Measurement */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDiscSduCfmMt[pst->selector])(pst, suId, discCfm);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuDiscSduCfm */
/* jump to specific primitive depending on configured selector */
(*kwUiKwuFlowCntrlIndMt[pst->selector])(pst, suId, flowCntrlIndInfo);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
/* jump to specific primitive depending on configured selector */
(*kwUiKwuDatAckIndMt[pst->selector])(pst, suId, datAckInd);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiKwuDatAckInd */
#endif /* LTE_L2_MEAS */
/* jump to specific primitive depending on configured selector */
(*kwUiCkwBndCfmMt[pst->selector])(pst, suId, status);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiCkwBndCfm */
/* jump to specific primitive depending on configured selector */
(*kwUiRlcCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiRlcCfgCfm */
/* jump to specific primitive depending on configured selector */
(*kwUiCkwUeIdChgCfmMt[pst->selector])(pst, suId, transId, ueInfo, status);
- RETVALUE(ROK);
+ return ROK;
} /* end of KwUiRlcCfgCfm */
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
elmIndx = (Void *)SRngGetRIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
kwUtlFreeDlMem();
#endif
- RETVALUE(ROK);
+ return ROK;
}
if((elmIndx = SRngGetRIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC)) == NULLP)
break;
}
- RETVALUE(ROK);
+ return ROK;
}
statsCb->stats.rnti = (U32)rnti;
statsCb->inUse = TRUE;
- RETVALUE(statsCb);
+ return (statsCb);
}
/*
printf("\n STATS Unexpected CellID = %d\n", (int)cellId);
}
- RETVALUE(l2CellStats[cellId-1]);
+ return (l2CellStats[cellId-1]);
}
/*
}
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/**
MsgLen tmpLen;
TRC3(cmUnpkUdxStruct)
- RETVALUE(SCpyMsgFix(srcMBuf,offset,size,dstBuf,&tmpLen));
+ return (SCpyMsgFix(srcMBuf,offset,size,dstBuf,&tmpLen));
} /*end of function cmPkUdxBndReq*/
{
TRC3(cmPkUdxStruct)
- RETVALUE(SAddPstMsgMult(srcBuf,size,dstMBuf));
+ return (SAddPstMsgMult(srcBuf,size,dstMBuf));
} /*end of function cmPkUdxBndReq*/
/*
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_BND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /*end of function cmPkUdxBndReq*/
\f
/*
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, reason, mBuf, EUDXXXX, pst);
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_UBND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /*end of function cmPkUdxUbndReq*/
\f
/*
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
- CMCHKPKLOG(SPkU8, status, mBuf, EUDXXXX, pst);
+ CMCHKPKLOG(oduUnpackUInt8, status, mBuf, EUDXXXX, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_BND_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /*end of function cmPkUdxBndCfm*/
\f
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch(pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPKLOG(cmPkPtr,(PTR)cfgInfo,mBuf,EUDXXXX,pst);
+ CMCHKPKLOG(oduPackPointer,(PTR)cfgInfo,mBuf,EUDXXXX,pst);
break;
}
#endif /* LCUDX */
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_CFG_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkUdxCfgReq */
\f
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch(pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPKLOG(cmPkPtr,(PTR)cfgCfmInfo,mBuf,EUDXXXX,pst);
+ CMCHKPKLOG(oduPackPointer,(PTR)cfgCfmInfo,mBuf,EUDXXXX,pst);
break;
}
#endif /* LCUDX */
CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_CFG_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkUdxCfgCfm */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch(pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPKLOG(cmPkPtr,(PTR)newUeInfo,mBuf,EUDXXXX,pst);
- CMCHKPKLOG(cmPkPtr,(PTR)ueInfo,mBuf,EUDXXXX,pst);
+ CMCHKPKLOG(oduPackPointer,(PTR)newUeInfo,mBuf,EUDXXXX,pst);
+ CMCHKPKLOG(oduPackPointer,(PTR)ueInfo,mBuf,EUDXXXX,pst);
break;
}
default:
}
#endif
}
- CMCHKPKLOG(SPkU32, transId, mBuf, EUDXXXX, pst);
+ CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, EUDXXXX, pst);
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_UEIDCHG_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxUeIdChgReq */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPK(cmPkCmStatus, &status, mBuf);
- CMCHKPKLOG(SPkU32, transId, mBuf, EUDXXXX, pst);
+ CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, EUDXXXX, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_UEIDCHG_CFM;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxUeIdChgCfm */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) pStaPdu, mBuf);
- CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) pStaPdu, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
break;
}
}
CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_STA_UPD_CFM;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxStaUpdCfm */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
break;
}
}
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_STA_PHBT_TMR_START;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxStaProhTmrStart */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) pStaPdu, mBuf);
- CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) pStaPdu, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
break;
}
}
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_STA_UPD_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxStaUpdReq */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) pStaPdu, mBuf);
- CMCHKPK(cmPkPtr,(PTR) rlcId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) pStaPdu, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
break;
}
}
CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
pst->event = (Event) UDX_EVT_STA_PDU_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxStaUpdReq */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
}
case UDX_SEL_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) measReqEvt, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) measReqEvt, mBuf);
break;
}
}
pst->event = (Event) UDX_EVT_L2MEAS_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkUdxStaUpdReq */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
case UDX_SEL_LC:
case UDX_SEL_LWLC:
{
- CMCHKPKLOG(SPkU8, measType, mBuf, EUDXXXX, pst);
+ CMCHKPKLOG(oduUnpackUInt8, measType, mBuf, EUDXXXX, pst);
break;
}
}
pst->event = (Event) UDX_EVT_L2MEAS_SEND_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
}
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch (pst->selector)
case UDX_SEL_LC:
case UDX_SEL_LWLC:
{
- CMCHKPKLOG(SPkU8, measType, mBuf, EUDXXXX, pst);
+ CMCHKPKLOG(oduUnpackUInt8, measType, mBuf, EUDXXXX, pst);
break;
}
}
pst->event = (Event) UDX_EVT_L2MEAS_STOP_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
}
#endif
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
} /*end of function cmUnpkUdxBndReq*/
\f
/*
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EUDXXXX, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
} /*end of function cmUnpkUdxUbndReq*/
\f
/*
TRC3(cmUnpkUdxBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
- CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EUDXXXX, pst);
+ CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EUDXXXX, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
} /*end of function cmUnpkUdxBndCfm*/
\f
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(RlcCfgInfo));
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &cfgInfo, mBuf);
break;
}
#endif /* LCUDX */
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, cfgInfo));
+ return ((*func)(pst, spId, cfgInfo));
} /* cmUnpkUdxCfgReq */
\f
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)cfgCfmInfo, sizeof(RlcCfgCfmInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
break;
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgCfmInfo, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &cfgCfmInfo, mBuf);
break;
}
#endif /* LCUDX */
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, cfgCfmInfo));
+ return ((*func)(pst, suId, cfgCfmInfo));
} /* cmUnpkUdxCfgCfm */
/*
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
- CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, EUDXXXX, pst);
+ CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, EUDXXXX, pst);
switch(pst->selector)
{
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &ueInfo, mBuf);
- CMCHKUNPK(cmUnpkPtr,(PTR *) &newUeInfo, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &ueInfo, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &newUeInfo, mBuf);
break;
}
default:
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
+ return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
} /* cmUnpkUdxUeIdChgReq */
cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
CMCHKUNPK(SUnpkS16, &suId, mBuf);
- CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, EUDXXXX, pst);
+ CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, EUDXXXX, pst);
CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, status));
+ return ((*func)(pst, suId, transId, status));
} /* cmUnpkUdxUeIdChgCfm */
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
- CMCHKUNPK(cmUnpkPtr, (PTR *)&pBufLst,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&pBufLst,mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, rlcId, pBufLst));
+ return ((*func)(pst, suId, rlcId, pBufLst));
} /* cmUnpkUdxUeIdChgCfm */
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)pStaPdu, sizeof(KwUdxStaPdu));
ret1 = cmUnpkUdxStruct(mBuf,sizeof(KwUdxStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
- CMCHKUNPK(cmUnpkPtr, (PTR *)&pStaPdu,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&pStaPdu,mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, rlcId, pStaPdu));
+ return ((*func)(pst, spId, rlcId, pStaPdu));
} /* cmUnpkUdxUeIdChgCfm */
(ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmUnpkUdxStruct(mBuf,0, (U8 *)pStaPdu, sizeof(KwUdxDlStaPdu));
ret1 = cmUnpkUdxStruct(mBuf,sizeof(KwUdxDlStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
- CMCHKUNPK(cmUnpkPtr, (PTR *)&pStaPdu,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&pStaPdu,mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, rlcId, pStaPdu));
+ return ((*func)(pst, spId, rlcId, pStaPdu));
} /* cmUnpkUdxUeIdChgCfm */
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr, (PTR *)&rlcId,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, rlcId));
+ return ((*func)(pst, spId, rlcId));
} /* cmUnpkUdxStaProhTmrStart */
}
case UDX_SEL_LWLC:
{
- CMCHKUNPK(cmUnpkPtr, (PTR *)&measReqEvt,mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&measReqEvt,mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measReqEvt));
+ return ((*func)(pst, measReqEvt));
} /* cmUnpkUdxL2MeasReq */
/*
case UDX_SEL_LC:
case UDX_SEL_LWLC:
{
- CMCHKUNPK(SUnpkU8, &measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &measType, mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measType));
+ return ((*func)(pst, measType));
} /* cmUnpkUdxL2MeasReq */
/*
case UDX_SEL_LC:
case UDX_SEL_LWLC:
{
- CMCHKUNPK(SUnpkU8, &measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &measType, mBuf);
break;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measType));
+ return ((*func)(pst, measType));
} /* cmUnpkUdxL2MeasStopReq */
#endif
#endif /* LCUDX */
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
}
}
rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_OK);
- RETVALUE(ROK);
+ return ROK;
}
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
KW_GET_AND_VALIDATE_UDXSAP(tRlcCb,udxSap, EKW208, "KwUiDlUdxndReq");
#endif /* ERRCLASS & ERRCLS_INT_PAR */
udxSap->state = KW_SAP_CFG;
- RETVALUE(ROK);
+ return ROK;
}
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG0(L_FATAL,"Memory Allocation Failed.");
/* kw002.201 Freeing from proper region */
/* RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo)); */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
tRlcCb->u.dlCb->udxDlSap[spId].suId,
cfgCfm);
- RETVALUE(ROK);
+ return ROK;
}
/**
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
transId,
status);
- RETVALUE(ROK);
+ return ROK;
}
/**
pst->pool,
pStaPdu,
sizeof(KwUdxDlStaPdu));
- RETVALUE(RFAILED);
+ return RFAILED;
}
AMDL.cntrlBo = pStaPdu->controlBo;
AMDL.pStaPdu = pStaPdu;
kwAmmSendDStaRsp(tRlcCb, rbCb, &AMDL);
- RETVALUE (ROK);
+ return (ROK);
}
/**
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
rlcId->cellId,rlcId->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
kwAmmDlHndlStatusPdu(tRlcCb, rbCb, pStaPdu);
pStaPdu,
sizeof(KwUdxStaPdu));
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_L2_MEAS
/*stopping Task*/
SStopTask(startTime, PID_RLC_MEAS_START);
- RETVALUE(ROK);
+ return ROK;
} /* rlcDlUdxMeasReq */
/**
/*stopping Task*/
SStopTask(startTime, PID_RLC_MEAS_STOP);
- RETVALUE(ROK);
+ return ROK;
}
/**
@brief
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
{
TRC3(PtDlUdxBndCfm)
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
{
TRC3(PtDlUdxCfgCfm)
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
{
TRC3(PtDlUdxUeIdChgCfm)
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
)
{
TRC3(PtDlUdxStaUpdCfm);
- RETVALUE(ROK);
+ return ROK;
}
PRIVATE S16 PtDlUdxStaProhTmrStart
)
{
TRC3(PtDlUdxStaProhTmrStart);
- RETVALUE(ROK);
+ return ROK;
}
#endif
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxBndCfmMt[pst->selector])(pst, suId, status);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxCfgCfmMt[pst->selector])(pst, suId, cfmInfo);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxUeIdChgCfmMt[pst->selector])(pst, suId,transId,status);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
/* jump to specific primitive depending on configured selector */
(*rlcDlUdxStaProhTmrStartMt[pst->selector])(pst, suId, rlcId);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndCfm */
{
TRC3(PtUlUdxBndReq)
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndReq */
{
TRC3(PtUlUdxUbndReq)
- RETVALUE(ROK);
+ return ROK;
} /* end of PtDlUdxBndReq */
{
TRC3(PtUlUdxCfgReq)
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxCfgReq */
TRC3(PtUlUdxUeIdChgReq)
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxCfgReq */
{
TRC3(PtUlUdxStaPduReq);
- RETVALUE(ROK);
+ return ROK;
}
/**
TRC3(PtUlUdxStaUpdReq);
- RETVALUE(ROK);
+ return ROK;
} /* end of RlcUlmDlmStaUpd*/
#ifdef LTE_L2_MEAS
TRC3(PtUlUdxL2MeasReq);
- RETVALUE(ROK);
+ return ROK;
}
/**
TRC3(PtUlUdxL2MeasSendReq);
- RETVALUE(ROK);
+ return ROK;
}
/**
TRC3(PtUlUdxL2MeasStopReq);
- RETVALUE(ROK);
+ return ROK;
}
#endif
#endif
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxBndReqMt[pst->selector])(pst, suId, spId);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndReq */
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxUbndReqMt[pst->selector])(pst, spId,reason );
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxBndReq */
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxCfgReqMt[pst->selector])(pst, spId, cfmInfo);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxCfgReq */
/* jump to specific primitive depending on configured selector */
(*rlcUlUdxUeIdChgReqMt[pst->selector])(pst, spId,transId,ueInfo,newUeInfo);
- RETVALUE(ROK);
+ return ROK;
} /* end of rlcDlUdxCfgReq */
{
TRC3(rlcUlUdxStaPduReq);
- RETVALUE((*rlcUlUdxStaPduReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
+ return ((*rlcUlUdxStaPduReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
}
/**
TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*rlcUlUdxStaUpdReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
+ return ((*rlcUlUdxStaUpdReqMt[pst->selector])(pst,spId, rlcId, pStaPdu));
} /* end of RlcUlmDlmStaUpd*/
#ifdef LTE_L2_MEAS
TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*rlcUlUdxL2MeasReqMt[pst->selector])(pst,measReqEvt));
+ return ((*rlcUlUdxL2MeasReqMt[pst->selector])(pst,measReqEvt));
} /* end of rlcUlUdxL2MeasReq*/
/**
TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*rlcUlUdxL2MeasSendReqMt[pst->selector])(pst,measType));
+ return ((*rlcUlUdxL2MeasSendReqMt[pst->selector])(pst,measType));
} /* end of rlcUlUdxMesReq*/
/**
TRC3(rlcUlUdxStaUpdReq);
- RETVALUE((*rlcUlUdxL2MeasStopReqMt[pst->selector])(pst,measType));
+ return ((*rlcUlUdxL2MeasStopReqMt[pst->selector])(pst,measType));
} /* end of rlcUlUdxMesReq*/
#endif
/**********************************************************************
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
KW_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (suId < 0)
KW_SEND_SAPID_ALARM(tRlcCb,suId,
LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* Send an alarm with proper event and cause */
KW_SEND_SAPID_ALARM(tRlcCb,suId, event, cause);
- RETVALUE(ROK);
+ return ROK;
}
/**
pst->pool,
cfmInfo,
sizeof(RlcCfgCfmInfo));
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
pst->pool,
cfmInfo,
sizeof(RlcCfgCfmInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
pst->pool,
cfmInfo,
sizeof(RlcCfgCfmInfo));
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if(ROK != kwDbmDelUlTransaction(tRlcCb, cfgTmpData))
pst->pool,
cfmInfo,
sizeof(RlcCfgCfmInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate memory and memset to 0 for cfmInfo */
RLC_ALLOC(tRlcCb,cfgCfm, sizeof(RlcCfgCfmInfo));
pst->pool,
cfmInfo,
sizeof(RlcCfgCfmInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
kwHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->cfgInfo, sizeof(RlcCfgInfo));
RLC_FREE(tRlcCb,cfgTmpData,sizeof(RlcUlCfgTmpData));
- RETVALUE(ROK);
+ return ROK;
}
/**
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
if (suId < 0)
{
RLOG0(L_ERROR, "Invalid suId");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(ROK != kwDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
{
RLOG0(L_ERROR, "Invalid transId");
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if(ROK != kwDbmDelUlTransaction(tRlcCb, cfgTmpData))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(status.status == CKW_CFG_CFM_OK)
interface or by he receipient in case of tight coupling */
RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->newUeInfo, sizeof(CkwUeInfo));
RLC_FREE_WC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
- RETVALUE(ROK);
+ return ROK;
}
/**
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
{
RLOG_ARG2(L_ERROR, DBG_UEID,rlcId->ueId, "CellId [%u]:RbId[%d] not found",
rlcId->cellId,rlcId->rbId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Start staProhTmr */
kwStartTmr(tRlcCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR);
- RETVALUE (ROK);
+ return (ROK);
}
/**
cfgCfm->cellId = cfg->cellId;
cfgCfm->numEnt = cfg->numEnt;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef __cplusplus
}
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG0(L_ERROR, "CKW SAP already Bound");
KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
- RETVALUE(RFAILED);
+ return RFAILED;
break;
}
}
KwUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_OK);
- RETVALUE(ROK);
+ return ROK;
}
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
/* disable upper sap (CKW) */
tRlcCb->u.ulCb->ckwSap.state = KW_SAP_CFG;
- RETVALUE(ROK);
+ return ROK;
}
/**
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
if (cfgTmpData == NULLP)
{
RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfgTmpData->uprLyrTransId = cfg->transId; /*Save User TransId*/
RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rlcUlHdlCfgReq(tRlcCb, cfgTmpData, cfg);
rlcUlUdxCfgReq(&(KW_GET_UDX_SAP(tRlcCb)->pst),KW_GET_UDX_SAP(tRlcCb)->spId,cfg);
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RLC_FREE(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ROK != rlcCfgValidateUeIdChng(tRlcCb,ueInfo,newUeInfo,cfgTmpData))
ueInfo,
newUeInfo);
- RETVALUE(ROK);
+ return ROK;
}
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
{
RLOG0(L_ERROR,"Invalid spId");
KW_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG1(L_ERROR,"RLC Mode [%d] : KWU SAP already Bound",
tRlcCb->genCfg.rlcMode);
KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
LCM_CAUSE_INV_STATE);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_NOK);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
KwUiKwuBndCfm(&(kwuSap->pst), kwuSap->suId, CM_BND_OK);
- RETVALUE(ROK);
+ return ROK;
}
\f
(spId >= (S16) rlcCb[pst->dstInst]->genCfg.maxKwuSaps) ||
(spId < 0))
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
kwuSap->state = KW_SAP_CFG;
- RETVALUE(ROK);
+ return ROK;
}
/**
if(pst->dstInst >= MAX_RLC_INSTANCES)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
datReq->rlcId.cellId,datReq->rlcId.rbId);
RLC_FREE_BUF(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Dispatch according to mode of the rbCb */
sizeof(KwuDatReqInfo));
RLC_FREE_BUF(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
kwTmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
}
- RETVALUE(ret);
+ return (ret);
}
\f
#endif
{
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, discSdu, sizeof(KwuDiscSduInfo));
- RETVALUE(ROK);
+ return ROK;
}
/********************************************************************30**
{
TRC2(rlcUlInitExt);
- RETVALUE(ROK);
+ return ROK;
} /* kwInitExt */
if (inst >= MAX_RLC_INSTANCES)
{
/* intance greater than MAX instances */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rlcCb[inst] != NULLP)
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if (SGetSBuf(region, 0, (Data **)&tRlcCb,
(Size)sizeof (RlcCb)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize rlcCb */
TSL2AllocStatsMem(tRlcCb->init.region, tRlcCb->init.pool);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rlcUlActvInit */
\f
#endif
#endif /* LCLKW */
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_FATAL,"Received Invalid Event[%d] from SM",
#endif /* LCCKW */
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
}
#endif /* LCKWU */
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
}
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
#endif /* LCRGU */
default:
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
case KWU_EVT_TTI_IND:
{
rlcUlBatchProc();
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
}
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
TSL2SendStatsToApp(&(tRlcCb->genCfg.lmPst), 0);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
default:
{
printf("\n ERROR Invalid Event[%d] from CL to PDCPUL\n",
pst->event);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
}
{
RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",pst->event);
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
break;
}
}
- SExitTsk();
+ ODU_EXIT_TASK();
- RETVALUE(ret);
+ return (ret);
} /* kwActvTsk */
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
SRemPreMsg(dst,pdu);
"SRemPreMsgMult Failed for 10 bits SN UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
SRemPreMsgMult(dst,2,pdu);
"SRemPreMsgMult Failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
SRemPreMsgMult(dst,2,pdu);
"Received LI as 0 UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
totalSz += umHdr->li[umHdr->numLi];
if ( pduSz <= totalSz )
pduSz,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED); /* the situation where in the PDU size
+ return RFAILED; /* the situation where in the PDU size
is something that does not match with
the size in LIs*/
}
"SRemPreMsg Failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
SRemPreMsg(dst,pdu);
"Received LI as 0 UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
totalSz += umHdr->li[umHdr->numLi];
pduSz--;
if (pduSz < totalSz)
{
- RETVALUE(RFAILED); /* the situation where in the PDU size is
+ return RFAILED; /* the situation where in the PDU size is
something that does not match with the
size in LIs*/
}
if (e)
{
/* PDU was constructed with LIs that exceeded KW_MAX_LI */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
if ( datReqInfo == NULLP )
{
RLOG0(L_FATAL,"Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
post->pool,
datReqInfo, sizeof(RguDDatReqInfo));
- RETVALUE(ROK);
+ return ROK;
}/* End of KwLiRguDDatReq */
/**
{
RLOG_ARG0(L_FATAL,DBG_CELLID,staIndInfo->cellId,
"Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
for(idx = 0; idx < staIndInfo->nmbOfUeGrantPerTti; idx++)
rguSap = &(gCb->u.dlCb->rguDlSap[suId]);
//Debug
KwLiRguDDatReq(&rguSap->pst,rguSap->spId,datReqInfo);
- RETVALUE(ROK);
+ return ROK;
}
/**
&& (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (AMDL.nxtRetx == NULLP)))
{
rbCb->boUnRprtdCnt++;
- RETVALUE(ROK);
+ return ROK;
}
#endif
RlcMacSendBOStatus(&rguSap->pst,rguSap->spId,&boStatus);
- RETVALUE(ROK);
+ return ROK;
}
/**
{
TRC2(rlcDlUtlSetReestInProgressForRB)
- RETVALUE(rbCb->reestInProgress);
+ return (rbCb->reestInProgress);
}
/**
}
if(*toBeFreed == 0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
#ifndef LTE_TDD
if(*toBeFreed == 0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
if(gCb->u.dlCb->shutdownReceived)
{
(*toBeFreed)--;
}
- RETVALUE(FALSE);;
+ return (FALSE);;
}
/**
gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_UU_LOSS].measCb.measType= LKW_L2MEAS_UU_LOSS;
gCb->u.dlCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_ACT_UE].measCb.measType= LKW_L2MEAS_ACT_UE;
- RETVALUE(ROK);
+ return ROK;
}
/**
*
(Data **)&curL2MeasTb,
(Size)sizeof(KwL2MeasTb)) != ROK)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx] = curL2MeasTb;
/* Initialize the Meas Tb details */
curL2MeasTb->lchInfo[idx].numSdus = 0;
}
}
- RETVALUE(curL2MeasTb);
+ return (curL2MeasTb);
}
ret = ROK;
if(hqStaInd->tbId[tbIdx] >= KW_INVALID_TBID)
{
- RETVALUE(ROK);
+ return ROK;
}
/* Find the L2 measurement tbCb to process DL Ip thruput*/
l2MeasTb = ueCb->l2MeasTbCb[hqStaInd->tbId[tbIdx]];
if(l2MeasTb == NULLP)
{
- RETVALUE(ROK);
+ return ROK;
}
/* For each logical channel in the tbCb, process
* and get the DL IP thruput */
/*stopping Task*/
SStopTask(startTime, PID_RLC_DLIP_TPT_PRCHARQIND);
- RETVALUE(ret);
+ return (ret);
}/* end of kwUtlProcHarqInd */
/**
}
/* Fix Klock warning */
KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndL2MeasCfm */
/**
*
TRC3(kwUtlSndDlL2MeasNCfm)
KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndL2MeasNCfm */
/**
*
txBuf = (KwTx *) node->node;
if(txBuf->sn == sn)
{
- RETVALUE(txBuf);
+ return (txBuf);
}
CM_LLIST_NEXT_NODE(txBufLstCp, node);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* kwUtlStoreTxBuf */
/**
*
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
#endif
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_FREE_BUF(sdu);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
KwUiKwuDatInd(&gCb->genCfg.lmPst, datIndInfo, sdu);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndDatInd */
cmMemset((U8 *)&(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]), 0, sizeof(KwL2MeasEvtCb));
}
gCb->u.ulCb->kwL2Cb.kwL2EvtCb[KW_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
- RETVALUE(ROK);
+ return ROK;
}
/**
*
}
measEvtCb->val.nonIpThMeas.measCb.numSamples--;
kwStartTmr(gCb, (PTR)measEvtCb, KW_EVT_L2_TMR);
- RETVALUE(ROK);
+ return ROK;
}
#endif
kwUtlSndUlL2MeasCfm(gCb, measEvtCb);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlHdlL2TmrExp */
/**
*
measCfmEvt.val.ipThMeas.numUes = cfmIdx;
}
KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndUlL2MeasCfm */
/**
*
TRC3(kwUtlSndUlL2MeasNCfm)
KwMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
- RETVALUE(ROK);
+ return ROK;
} /* kwUtlSndL2MeasNCfm */
#ifdef LTE_L2_MEAS_RLC
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*User can either request for Active UE,*
*Dl delay, Dl discard, Uu Loss OR Dl ip throughput, Ul ip throughput. */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check for total maximum number of Measurement Control Block */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_EXCEED_NUMMEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check that number of samples should be a non-zero value */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_ZERO_NUMSAM;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check that measurement period should be completely divisible *
* number of sample. */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_NUMSAM;
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
numQci = measReqEvt->measReq.val.nonIpThMeas.numQci;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_QCI;
measCfmEvt->measType = measType;
measCfmEvt->transId = measReqEvt->transId;
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
if(measCfmEvt->val.nonIpThMeas.numCfm > 0)
{
measCfmEvt->transId = measReqEvt->transId;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* kwUtlValidateL2Meas */
#endif
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*User can either request for Active UE,*
*Dl delay, Dl discard, Uu Loss OR Dl ip throughput, Ul ip throughput. */
measCfmEvt->measType = measType;
measCfmEvt->status.status = LCM_PRIM_NOK;
measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* kwUtlValidateL2Meas */
/**
recBuf = (KwAmRecBuf *) node->node;
if(recBuf->amHdr.sn == sn)
{
- RETVALUE(recBuf);
+ return (recBuf);
}
CM_LLIST_NEXT_NODE(recBufLstCp, node);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* kwUtlStoreRecBuf */
/**
*
uint8_t rlcDatSn = 0;
uint64_t ulDatNum = 0;
-PUBLIC S16 macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta)
+PUBLIC uint8_t macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta)
{
Pst rspPst;
RlcMacSchedRepInfo *schRep;
}
-PUBLIC S16 macStubSendDlData(Pst *pst, SpId spId, RlcMacData *dlData)
+PUBLIC uint8_t macStubSendDlData(Pst *pst, SpId spId, RlcMacData *dlData)
{
U32 availmem;
DU_LOG("\nMAC_STUB : Received DL data from RLC to be sent to PHY");
- SPutMsg(dlData->pduInfo[0].pduBuf);
+ ODU_PUT_MSG(dlData->pduInfo[0].pduBuf);
dlData->pduInfo[0].pduBuf = NULL;
#if 0
#endif
ulData = dlData;
- SGetMsg(pst->region, pst->pool, &mBuf);
+ ODU_GET_MSG(pst->region, pst->pool, &mBuf);
macStubBuildUlData(mBuf);
ulData->pduInfo[0].pduBuf = mBuf;
int datSize = 30;
U32 availmem;
- SAddPstMsgMult((Data *)data, datSize, mBuf);
+ ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf);
/* filling IPv4 header */
CmIpv4Hdr ipv4Hdr;
revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
/* this function automatically reverses revPkArray */
- ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf);
+ ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
- SAddPreMsgMult((Data *)&rlcDatSn, sizeof(uint8_t), mBuf);
+ ODU_ADD_PRE_MSG_MULT((Data *)&rlcDatSn, sizeof(uint8_t), mBuf);
#if 0
SRegInfoShow(0, &availmem);
SRegInfoShow(1, &availmem);
#define DU_IP_V4_ADDR "192.168.130.81"
#define CU_IP_V4_ADDR "192.168.130.82"
-S16 macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta);
-S16 macStubSendDlData(Pst *post, SpId spId, RlcMacData *dlData);
+uint8_t macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta);
+uint8_t macStubSendDlData(Pst *post, SpId spId, RlcMacData *dlData);
void macStubBuildUlData(Buffer *mBuf);
#endif /* __MAC_STUB_H__ */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Memory Unavailable for Confirmation");
SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt));
- RETVALUE(ROK);
+ return ROK;
} */
cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
RgMiLrgSchCntrlCfm(&cfmPst, &cfm);
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Gen Cfg not done.");
/* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
- RETVALUE(ROK);
+ return ROK;
}
/* General Config done, process the Control request */
break;
}
/* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
- RETVALUE(ret);
+ return (ret);
}/*-- RgMiLrgSchCntrlReq --*/
#ifdef LTE_L2_MEAS
RLOG_ARG2(L_ERROR,DBG_INSTID,inst,
"Meas req Failed.Invalid Cell Id errType(%d) errCause(%d)",
err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate for Meas Types */
if ( (ret = rgSCHUtlValidateMeasReq(cell, measInfo, &err)) != ROK)
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"Meas req Failed.Invalid Measurement Type"
"errCasue(%d) errType(%d)", err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Iterate through all meas requests in l2mList in cellCb */
#if (ERRCLASS & ERRCLS_ADD_RES)
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"Meas req Failed.Dublicate TransId"
"errType(%d) errCause(%d)", err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"Meas req Failed.errType(%d) errCause(%d)",
err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* -- RRgMiLrgSchL2MeasReq-- */
/**
{
RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
"Stop req Failed.Invalid Cell Id ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8 *)&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
node = cell->l2mList.first;
RgMiLrgSchL2MeasStopCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
&measCfm);
}
- RETVALUE(ret);
+ return (ret);
}/*RgMiLrgSchL2MeasStopReq*/
/**
* @brief Layer Manager L2 Measurement request handler.
{
RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
"Send req Failed.Invalid Cell Id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
cell->sndL2Meas = TRUE;
}
- RETVALUE(ret);
+ return (ret);
}/*RgMiLrgSchL2MeasSendReq*/
#endif /* LTE_L2_MEAS */
#endif
ret = RgUiRgrBndCfm(&tmpPst, suId, CM_BND_NOK);
}
- RETVALUE(ret);
+ return (ret);
} /* RgUiRgrBndReq */
/**
(ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState,
"Invalid SAP State: RgUiRgrUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
(ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState,
"Invalid SAP Id:RgUiRgrUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgrUbndReq */
#ifdef RGR_SI_SCH
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer "
"is NULL");
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (spId < rgSchCb[instId].numSaps)
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Handle configuration */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"RgUiRgrSiCfgReq:"
"Configuration Request Handling Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgrSiCfgReq */
\f
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer "
"is NULL");
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, 0, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (spId < rgSchCb[instId].numSaps)
sizeof(RgrWarningSiCfgReqInfo));
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
sizeof(RgrWarningSiCfgReqInfo));
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Handle configuration */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,
"Configuration Request Handling Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
(ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState,
"Invalid SAP State: RgUiRgrWarningSiStopReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
(ErrVal)rgSchCb[instId].rgrSap[spId].sapCfg.spId,
"Invalid SAP Id:RgUiRgrWarningSiStopReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgSCHGomHndlWarningSiStopReq(pst->region, pst->pool,
&rgSchCb[instId], siId, transId, spId);
- RETVALUE(ROK);
+ return ROK;
}
#endif /*RGR_SI_SCH */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer "
"is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (spId < rgSchCb[instId].numSaps)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
(Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#endif
SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
(Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Handle configuration */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,
"Configuration Request Handling Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgrLoadInfReq */
/* LTE_ADV_FLAG_REMOVED_END */
/* Handle Cell fetch failure */
RGSCHLOGERROR(inst, ERRCLS_INT_PAR,ERG009,(ErrVal)boRpt->cellId,
"rgMacSchDedBoUpdtReq(): Invalid cell Id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef LTE_ADV
if (cell != ue->cell)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, boRpt->lcId)) != NULLP)
dlLc->setMaxDlPrio = boRpt->setMaxDlPrio;
/* Update the scheduler */
rgSCHUtlDlDedBoUpd(cell, ue, dlLc);
- RETVALUE(ROK);
+ return ROK;
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of rgMacSchDedBoUpdtReq */
{
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,"RgMacSchCmnBoUpdtReq():"
"Invalid boRpt cell Id:%d",boRpt->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* handle status response on CCCH */
rgSCHUtlHndlBcchPcchBoUpdt(cell, boRpt);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of RgMacSchCmnBoUpdtReq */
/*Fix: start: Inform UE delete to scheduler*/
/**
if (rgSchCb[inst].rgrSap == NULLP || rgSchCb[inst].rgrSap[cellSapId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,ueDelInd->cellId,"rgrSap or cell is not configured");
- RETVALUE(ROK);
+ return ROK;
}
cell = rgSchCb[inst].rgrSap[cellSapId].cell;
#ifndef NO_ERRCLS
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgMacSchUeDelInd(): Invalid ueDelInd cell Id:%d",
ueDelInd->cellId);
- RETVALUE(ROK);
+ return ROK;
}
#endif
"Guard Pool:%ld", ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgMacSchUeDelInd */
/*Fix: end: Inform UE delete to scheduler*/
/**
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Received MSG3 with CRNTI:%d and also CCCH ",
datInd->ceInfo.ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, datInd->ceInfo.ces.cRnti);
if (ue == NULLP)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Received MSG3 "
"with CRNTI:%d unable to find ueCb",
datInd->ceInfo.ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ret = rgSCHUtlProcMsg3 (subfrmInfo, cell, ue,
err.errType = RGSCHERR_TOM_DATIND;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Processing for MSG3 failed for CRNTI:%d",
datInd->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
err.errType = RGSCHERR_TOM_DATIND;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Processing for MSG3 failed for CRNTI:%d",
datInd->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* fix */
CM_LLIST_NEXT_NODE(lnkLst, tmp);
err.errType = RGSCHERR_TOM_DATIND;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the UE CB for CRNTI:%d",
datInd->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
err.errType = RGSCHERR_TOM_DATIND;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to handle Data"
" Indication for UEID:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CM_LLIST_NEXT_NODE(lnkLst, tmp);
/* chk if Sch needs to dealloc datInd after unpk */
RGSCH_FREE_MEM(subfrmInfo);
- RETVALUE(ret);
+ return (ret);
} /* rgMacSchSfRecpInd */
#ifdef LTEMAC_SPS
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"No Ue exists with CRNTI:%d",relInfo->cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((rgSCHUtlSpsRelInd(cell, ue, relInfo->isExplRel)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"RelInd processing for CRNTI:%d failed",relInfo->cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of RgMacSchSpsRelInd */
#endif /* LTEMAC_SPS */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,measCfm->cellId,
"Meas Cfm Failed.Invalid Cell Id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if ( measCb == NULLP )
{
- RETVALUE( RFAILED );
+ return ( RFAILED );
}
schMeasCfm.hdr.transId = measCfm->transId;
schMeasCfm.cellId = measCfm->cellId;
RgMiLrgSchL2MeasCfm(&(instCb->rgSchInit.lmPst), &schMeasCfm);
- RETVALUE(ROK);
+ return ROK;
}
for(idx = 0; idx < measCfm->u.prbCfm.numQci; idx++)
{
measCb->avgPrbQciUl.numQci = measCfm->u.prbCfm.numQci;
measCb->cfmRcvd = TRUE;
cell->sndL2Meas = TRUE;
- RETVALUE(ROK);
+ return ROK;
} /* end of RgMacSchL2MeasCfm */
/**
schMeasCfm.hdr.transId = measCfm->transId;
schMeasCfm.cellId = measCfm->cellId;
RgMiLrgSchL2MeasStopCfm(&(instCb->rgSchInit.lmPst), &schMeasCfm);
- RETVALUE(ROK);
+ return ROK;
}
#endif
if(suId >= rgSchCb[instId].numSaps)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId, "Incorrect SuId");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Lets validate suId first */
tfuSap = &(rgSchCb[instId].tfuSap[suId]);
{
RLOG_ARG2(L_ERROR,DBG_INSTID,instId, "Incorrect SuId. Configured (%d)"
"Recieved (%d)", tfuSap->sapCfg.suId, suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHLmmBndCfm (pst, suId, status);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuSchBndCfm */
/**
RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"SAP Validation failed SuId(%d)", suId);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(raReqInd);
- RETVALUE(ret);
+ return (ret);
}
if(raReqInd == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Invalid input pointer for raReqInd Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,raReqInd->cellId,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomRaReqInd(rgSchCb[inst].tfuSap[suId].cell, raReqInd);
RGSCH_FREE_MEM(raReqInd);
/*SPutSBuf (pst->region, pst->pool, (Data *)raReqInd,
sizeof(TfuRaReqIndInfo)); */
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuRaReqInd */
/**
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(ulCqiInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(ulCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomUlCqiInd (rgSchCb[inst].tfuSap[suId].cell, ulCqiInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(ulCqiInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuUlCqiInd */
/**
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(pucchDeltaPwr);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomPucchDeltaPwrInd (rgSchCb[inst].tfuSap[suId].cell, pucchDeltaPwr);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(pucchDeltaPwr);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuPucchDeltaPwrInd */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
RGSCH_FREE_MEM(harqAckInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
ret = rgSCHTomHarqAckInd (rgSchCb[inst].tfuSap[suId].cell, harqAckInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(harqAckInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuHqInd */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"() SAP Validation failed");
RGSCH_FREE_MEM(srInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"RgLiTfuSrInd()No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Now call the TOM (Tfu ownership module) primitive to process further */
ret = rgSCHTomSrInd (rgSchCb[inst].tfuSap[suId].cell, srInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(srInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuSrInd */
RLOG_ARG0(L_ERROR,DBG_INSTID,inst," SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(dlCqiInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomDlCqiInd (rgSchCb[inst].tfuSap[suId].cell, dlCqiInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(dlCqiInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuDlCqiInd */
#ifdef TFU_UPGRADE
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(rawCqiInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst," No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
ret = rgSCHTomRawCqiInd (rgSchCb[inst].tfuSap[suId].cell, rawCqiInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(rawCqiInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuRawCqiInd */
/**
RLOG_ARG0(L_ERROR,DBG_INSTID,inst," SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(srsInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomSrsInd (rgSchCb[inst].tfuSap[suId].cell, srsInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(srsInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuSrsInd */
#endif
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(doaInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomDoaInd (rgSchCb[inst].tfuSap[suId].cell, doaInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(doaInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuDlCqiInd */
/**
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
RGSCH_FREE_MEM(crcInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef XEON_SPECIFIC_CHANGES
gettimeofday(&end6, NULL);
#endif
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuCrcInd */
/**
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(timingAdvInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Now call the TOM (Tfu ownership module) primitive to process further */
ret = rgSCHTomTimingAdvInd(rgSchCb[inst].tfuSap[suId].cell, timingAdvInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(timingAdvInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuTimingAdvInd */
/************* RGM Interface ****************/
#endif
ret = RgUiRgmBndCfm(&tmpPst, suId, CM_BND_NOK);
}
- RETVALUE(ret);
+ return (ret);
} /* RgUiRgmBndReq */
/**
(ErrVal)rgSchCb[instId].rgmSap[spId].sapSta.sapState,
"Invalid SAP State: RgUiRgmUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
(ErrVal)rgSchCb[instId].rgmSap[spId].sapSta.sapState,
"Invalid SAP Id:RgUiRgmUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgmUbndReq */
/* ccpu00134393 : mem leak fix */
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief ERROR INDICATION from PHY for the i failed unlicensed Scell transmission.
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Now call the TOM (Tfu ownership module) primitive to process further */
ret = rgSCHLaaErrInd(rgSchCb[inst].tfuSap[suId].cell, errInd);
#endif
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuErrInd */
{
RGSCHDBGERR(inst, (rgSchPBuf(inst), "Validation for scheduler related "
"config failed\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG1(L_INFO, "MIMO_DBG:: SCH:: numAntPorts=%d\n",schedEnbCfg->numTxAntPorts);
{
RGSCHDBGERR(inst, (rgSchPBuf(inst),"Invalid number of transmit antenna"
" ports %d\n", schedEnbCfg->numTxAntPorts));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate csg access mode */
(schedEnbCfg->accsMode > RGR_CELL_ACCS_HYBRID))
{
RGSCHDBGERR(inst, (rgSchPBuf(inst), "Invalid CSG Access mode\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR SCHED ENB config validation done:"\n));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrSchedEnbCfg */
/**
if ((U8 *)cell != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell Id already exists");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cellCfg->macInst >= SCH_INST_START)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid MAC Instance %d ",
cellCfg->macInst);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellCfg->macRnti.startRnti < RGSCH_MIN_MAC_RNTI )
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid start RNTI %d for cell ",
cellCfg->macRnti.startRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for scheduler related "
"config failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellCfg->dlHqCfg.maxDlHqTx < RGSCH_MIN_HQ_TX) ||
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid Downlink HARQ configuration:"
" maxDlHqTx %d maxMsg4HqTx %d", cellCfg->dlHqCfg.maxDlHqTx,
cellCfg->dlHqCfg.maxMsg4HqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellCfg->cfiCfg.cfi < RGSCH_MIN_CFI_VAL) ||
(cellCfg->cfiCfg.cfi > RGSCH_MAX_CFI_VAL))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid CFI configuration %d",
cellCfg->cfiCfg.cfi);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (((cellCfg->puschSubBand.subbandStart) +
((cellCfg->puschSubBand.numSubbands -1) * cellCfg->puschSubBand.size))
cellCfg->puschSubBand.subbandStart,
cellCfg->puschSubBand.numSubbands, cellCfg->puschSubBand.size,
cellCfg->bwCfg.ulTotalBw);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (((cellCfg->bwCfg.dlTotalBw < RGSCH_MIN_DL_BW) ||
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid Bandwidth configuration:"
" ul %d dl %d",cellCfg->bwCfg.ulTotalBw,
cellCfg->bwCfg.dlTotalBw);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellCfg->phichCfg.ngEnum > RGR_NG_TWO)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid PHICH Ng configuration %d",
(U8)cellCfg->phichCfg.ngEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validation for extended PHICH Duration */
if ((cellCfg->phichCfg.isDurExtend == TRUE) &&
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid cfi value for"
"Extended PHICH duration cfi:%d dlBw:%d",
(U8)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellCfg->phichCfg.isDurExtend == TRUE) &&
(cellCfg->bwCfg.dlTotalBw > 10) && (cellCfg->cfiCfg.cfi < 3))
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid cfi value for"
"Extended PHICH duration cfi:%d dlBw:%d",
(U8)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG4(L_INFO,"CA_DBG:: PUCCH configuration:"
" N2_RB %d N1_PUCCH %d deltaShift %d cyclicShift %d",
cellCfg->pucchCfg.n1PucchAn,
cellCfg->pucchCfg.deltaShift,
cellCfg->pucchCfg.cyclicShift);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellCfg->srsCfg.isSrsCfgSetup && cellCfg->srsCfg.srsBwEnum > RGR_SRS_BWCFG_7)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid SRS configuration: "
" srsBw %d", (U8)cellCfg->srsCfg.srsBwEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for Random access related"
"config failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((rgSCHCfgVldtRgrCellPwrCfg(inst, cellCfg, errInfo)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for cell power "
"config failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate the common logical channel configuration */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid number(%d) of common logical"
"channels in cell config", cellCfg->numCmnLcs);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((rgSCHCfgVldtRgrCmnLcCfg(inst, cellCfg, errInfo)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for common logical"
"channels failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Added 0 as a valid value for number of TICKs RRM
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for SI"
"configuration failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /*RGR_SI_SCH */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid"
"Subframe configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/*ccpu00116923 - ADD - Srs Present support - End*/
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
"Invalid txPower offset ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* LTE_ADV_FLAG_REMOVED_START */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "DSFR is enbaled"
"Without enabling SFR");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((rgSCHCfgVldtRgrCellLteAdvCfg(inst, &(cellCfg->rgrLteAdvCfg),
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for LTE Adv"
"configuration failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
if ((rgSCHCfgVldtRgrCellLteLAACfg(inst, cellCfg)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Validation for LTE LAA"
"configuration failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* LTE_ADV_FLAG_REMOVED_END */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid"
"msg4pAVal %u", cellCfg->msg4pAVal);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate RgrCellCsgParamCfg */
{
RGSCHDBGERR(inst, (rgSchPBuf(inst), "Validation failed for \n"
"Access CSG parameter failed\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef EMTC_ENABLE
if(ROK != rgSCHCfgVldtRgrEmtcCellCfg(cellCfg))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid EMTC cell Configuration %d for cell" ,cellCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrCellCfg */
/**
{
RGSCHDBGERR(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Invalid \
UL scheduler type %d \n", rgSchedCfg->ulSchdType));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSchedCfg->dlSchdType > (RGSCH_NUM_SCHEDULERS - 1))
{
RGSCHDBGERR(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Invalid \
DL scheduler type %d \n", rgSchedCfg->dlSchdType));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Validates the scheduler related configuration request from RRM to MAC.
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid dlfs scheduler type %d for cell",
cellCfg->dlfsSchdType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Validates the RACH related configuration request from RRM to MAC.
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid numRaPreamble %d sizeRaPreambleGrpA %d",
cellCfg->rachCfg.numRaPreamble,
cellCfg->rachCfg.sizeRaPreambleGrpA);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* RACHO */
/* verify that the ded Preambles cfgd for Pdcch Order
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid RACH Preambleset conf:"
"preambleSet Start %d preambleSet Size %d",
cellCfg->macPreambleSet.start, cellCfg->macPreambleSet.size);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef RGR_V1
if(cellCfg->rachCfg.contResTmr)
Then return fail*/
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
"Contention Resolution timer is configured as '0'");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Cell does not exist %d",
ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* RACHO:
* Check configured preamble id not colliding with non dedicated or PDCCH
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Preamble Id configuration"
"failed ",ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if Ue already configured */
if (rgSCHDbmGetUeCb(*cell, ueCfg->crnti) != NULLP)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d UEID already exists",
ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate Transmission UE modes */
if ((ueCfg->txMode.pres == TRUE) && ((ueCfg->txMode.txModeEnum < RGR_UE_TM_1)
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid transmission mode for"
" UE is %d", ueCfg->cellId,(U8)ueCfg->txMode.txModeEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate UE Category */
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid category for UE %d",
ueCfg->cellId,(U8)ueCfg->ueCatEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate UE Access Stratum Release */
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid Access Stratum Release %u for UE\n",
ueCfg->accessStratumRls));
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst), "Configured Access Stratum Release %u\n", \
ueCfg->accessStratumRls));
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid transmission mode for"
" UE (%d) for the configured Cell Antenna Ports",ueCfg->cellId,
(U8)ueCfg->txMode.txModeEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "CELLID:%d Invalid CQI Mode configuration",
ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate Max Uplink HARQ transmission value */
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid Uplink HARQ config for "
"UE %d",ueCfg->cellId,ueCfg->ueUlHqCfg.maxUlHqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHCfgVldtUePwrCfg(*cell, &ueCfg->ueUlPwrCfg) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid PUSCH Group power"
" configuration",ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHCfgVldtUeMeasGapAckNakRepCfg(*cell, ueCfg) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid MeasGap/AckNackRep"
" configuration",ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid SPS RNTI "
" in DL SPS Config",ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (ueCfg->ueSpsCfg.dlSpsCfg.isDlSpsEnabled)
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid DL SPS configuration"
" for the UE",ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid Periodic CQI/SR/SRS"
"configuration",ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid DRX configuration",
ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ccpu00117452 - MOD - Changed macro name from
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid numColltdCqiRept,"
"MAX supported %d",RGR_CQIRPTS_MAXN,ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* End of RGR_CQI_REPT */
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid EMTC UE configurationfor crnti:%d",
ueCfg->cellId, ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrUeCfg */
((*cell)->cellId != cellRecfg->cellId))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell control block does not exist");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate recieved values */
RLOG_ARG2(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Downlink HARQ configuration:"
" maxDlHqTx %d maxMsg4HqTx %d", cellRecfg->dlHqRecfg.maxDlHqTx,
cellRecfg->dlHqRecfg.maxMsg4HqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellRecfg->recfgTypes & RGR_CELL_CFI_RECFG) &&
((cellRecfg->cfiRecfg.cfi < RGSCH_MIN_CFI_VAL) ||
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid CFI configuration %d",
cellRecfg->cfiRecfg.cfi);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellRecfg->recfgTypes & RGR_CELL_PUCCH_RECFG)
{
cellRecfg->pucchRecfg.n1PucchAn,
cellRecfg->pucchRecfg.deltaShift,
cellRecfg->pucchRecfg.cyclicShift);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cellRecfg->recfgTypes & RGR_CELL_SRS_RECFG)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid SRS configuration: "
"srsBw %d", (U8)cellRecfg->srsRecfg.srsBwEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*ccpu00116923 - ADD - Srs Present support - Start*/
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Subframe configuration ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/*ccpu00116923 - ADD - Srs Present support - End*/
"numRaPreamble %d sizeRaPreambleGrpA %d",
cellRecfg->rachRecfg.numRaPreamble,
cellRecfg->rachRecfg.sizeRaPreambleGrpA);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Validation for SI"
"Re-configuration failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif /*RGR_SI_SCH */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"DSFR is enbaled"
"Without enabling SFR");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if ((rgSCHCfgVldtRgrCellLteAdvCfg(inst, &(cellRecfg->rgrLteAdvCfg),
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Validation for Lte Adv"
"Re-configuration failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* LTE_ADV_FLAG_REMOVED_END */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Configuration "
"of minimum DL resources for NON-CSG");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellRecfg->csgParamCfg.minUlResNonCsg > 100)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Configuration "
"of minimum UL resources for NON-CSG");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrCellRecfg */
#ifdef LTE_ADV
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx :Memomy allocation "
"Failed while Adding SCell Information\n", idx));
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCell doesnt exists"));
rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(TRUE == sCellInfoCfg->txMode.pres)
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx ACQI Cfg"
"failed..n\n", idx));
rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* Configuring PCQI */
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx PCQI Cfg failed..n\n", idx));
rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (ROK != rgSCHLaaInitDlRbAllocCb(secCellCb,
&sCellInfo->dlAllocCb))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Initialize Harq entity */
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UEID:Hq Entity Initialization "
"failed in config\n", ue->ueId));
rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
rgSCHEmtcHqPAlloc(secCellCb, sCellInfo->hqEnt);
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_TDD
"Failed while UE related Ack Nack Information\n",
ue->ueId));
rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* LTE_TDD */
ue->ul.ctrlOnServCellIdx[idx] = 0xFF;
}
/* Trigger SCell addition to primary MAC */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSCellCfgUeCfg */
/*f1b_Sprint */
RLOG1(L_ERROR,"Wrong PUCCH Format:%d configured for CA",ue->uciFrmtTyp);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSCellCfgUePucchReCfg */
/**
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid number of SCELL "
" in SCELL Recfg\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(U8 idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
if(ROK != rgSchUtlVldtCellId(inst, ueSCellDedCfg->sCellId))
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCellId is out of range"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate existence of sec cell */
sCell = rgSchUtlGetCellCb(inst, ueSCellDedCfg->sCellId);
if(NULLP == sCell )
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCell doesnt exists"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate the range of serv cell index */
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Invalid Serv Cell Idx %d\n",
ueSCellDedCfg->sCellIdx));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Is this sec cell alredy confiured */
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Secll with id %d already added\n",
ueSCellDedCfg->sCellIdx));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate CQI config params */
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid CQI Mode "
" configuration for Ue %d\n",ue->ueId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef TFU_UPGRADE
/* 1. Validate UE Aperiodic CQI related parameters */
{
RGSCHDBGERR(sCell->instIdx, (rgSchPBuf(sCell->instIdx),
"rgSCHCfgVldtCqiSrSrsUeCfg: Invalid Aperiodic CQI configuration\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_HDFDD
{
RGSCHDBGERR(sCell->instIdx, (rgSchPBuf(sCell->instIdx),
"rgSCHCfgVldtCqiSrSrsUeCfg: Invalid Periodic CQI configuration\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((ueSCellDedCfg->txMode.txModeEnum < RGR_UE_TM_1) ||
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCELL Invalid transmission mode for"
" UE %d\n", (U8)ueSCellDedCfg->txMode.txModeEnum));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
errInfo->errCause = RGSCHERR_NONE;
RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR Ue SCell Reconfig validation done: "
"cellId %d oldUeId %d\n", ueRecfg->cellId, ue->ueId));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrUeSCellRecfg */
/**
#endif
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_ADV */
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,
"Cell does not exist for OLD CRNTI:%d",ueRecfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Old Ue */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"OLD CRNTI:%d does not exist",
ueRecfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
if ( ret != ROK)
{
RGSCHDBGERR(inst,(rgSchPBuf(inst), "Ue SCell Recfg Validation FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"NEW CRNTI:%d already exists",
ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE ID [%d] invalid CSG Membership reconfig :%d ",
ueRecfg->newCrnti, (U8)ueRecfg->csgMmbrSta);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate values */
if ((ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid transmission mode %d"
"for NEW CRNTI:%d", (U8)ueRecfg->txMode.txModeEnum,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef TFU_UPGRADE
if ((ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Periodic CQI INFO"
"OLD CRNTI:%d NEW CRNTI:%d",(U8)ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((ueRecfg->ueRecfgTypes & RGR_UE_ULHARQ_RECFG) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config %d"
"for NEW CRNTI:%d", ueRecfg->ueUlHqRecfg.maxUlHqTx,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef TFU_UPGRADE
if ((ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid periodic mode config for"
" DL CQI %d NEW CRNTI:%d", (U8)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
if ((ueRecfg->ueRecfgTypes & RGR_UE_PCQI_RECFG) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid periodic mode config for "
"DL CQI %d for NEW CRNTI:%d",(U8)ueRecfg->cqiCfg.cqiSetup.prdModeEnum,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* TFU_UPGRADE */
/* Validate UE Category */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid category %d for NEW CRNTI:%d",
(U8)ueRecfg->ueCatEnum,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate UE Access Stratum Release */
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid Access Stratum Release %u for UE\n",
ueRecfg->accessStratumRls));
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst), "Configured Access Stratum Release %u\n", \
ueRecfg->accessStratumRls));
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid aperiodic mode config for"
" DL CQI %d for NEW CRNTI:%d", (U8)ueRecfg->aprdDlCqiRecfg.aprdModeEnum,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ueRecfg->ueRecfgTypes & RGR_UE_ULPWR_RECFG) &&
(rgSCHCfgVldtUePwrCfg(*cell, &ueRecfg->ueUlPwrRecfg) != ROK))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid PUSCH Group power"
" Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid MeasGap/AckNackRep"
" Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
if(rgSCHCfgVldtSpsReCfg(*cell, *ue, ueRecfg)!= ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid SPS"
" Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef TFU_UPGRADE
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid ACQI, PCQI/SR/SRS "
"Re-configuration for NEW CRNTI:%d",ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((ueRecfg->ueRecfgTypes & RGR_UE_DRX_RECFG) &&
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid drxParams"
" Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ccpu00117452 - MOD - Changed macro name from
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid DL Power Control"
" Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* End of RGR_CQI_REPT */
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrUeRecfg */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Cell does not exist "
"for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue for dedicated channels */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"UEID does not exist"
"dedicated logical channel for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((*dlLc = rgSCHDbmGetDlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Dedicated DL LC does not "
"exist for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrLchRecfg */
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"CELL does not exist for CRNTI:%d",
reset->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
if ((*ue = rgSCHDbmGetUeCb(&(*cell), reset->crnti)) == NULLP)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"UE does not exist for CRNTI:%d",
reset->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrUeReset */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Cell does not exist for"
"CRNTI:%d LCGID:%d",lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue for dedicated channels */
RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"UE does not exist for "
"dedicated logical channel group CRNTI:%d LCGID:%d",
lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (lcgRecfg->ulRecfg.lcgId > (RGSCH_MAX_LCG_PER_UE - 1))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Invalid lcgId for uplink logical"
"channel CRNTI:%d LCGID:%d",
lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((lcgRecfg->ulRecfg.gbr != 0) && (lcgRecfg->ulRecfg.mbr < lcgRecfg->ulRecfg.gbr))
{
RGSCHDBGINFO(inst, (rgSchPBuf(inst), "Dedicated Logical Group %d validation failed"
" for ue %d for cell %d\n", lcgCfg->ulInfo.lcgId, lcgCfg->crnti, lcgCfg->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrLcgRecfg */
/**
(cell->dynCfiCb.numFailSamples * sizeof(U16)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Setting the Invalid value 0xFF to pdcchSfIdx, it will be assigned
RGSCH_CFI_TTI_MON_INTRVL)/100;
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
#endif
errInfo->errCause = RGSCHERR_NONE;
RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR SCH ENBconfig done: \n"));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrSchedEnbCfg */
#ifdef RG_5GTF
printf("\ncell cfg at schd,numUes:%u,uepergrp:%u,uegrppertti:%u,numCC:%u,bwPerc:%u cfi %u\n",
cell->cell5gtfCb.numUes,cell->cell5gtfCb.uePerGrpPerTti,cell->cell5gtfCb.ueGrpPerTti,
cell->cell5gtfCb.numCCs,cell->cell5gtfCb.bwPerCC, cell->cell5gtfCb.cfi);
- RETVALUE(ROK);
+ return ROK;
}
#endif
!= ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
if(cellCfg->emtcEnable)
!= ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for emtc cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if ((U8 *)cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize the lists of the cell */
ret = rgSCHDbmInitCell(cell);
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization FAILED for cell");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* LTE_ADV_FLAG_REMOVED_START */
if(cellCfg->rgrLteAdvCfg.pres & RGR_ABS)
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr cell Config failed at "
"Scheduler for cell");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Updating Auto TM Mode enable/diable flag */
cell->isAutoCfgModeEnb = cellCfg->isAutoCfgModeEnb;
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr cell Config failed at "
"Scheduler for cell ");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Invoke DHM to update DHM specific information */
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr Cell Config failed at"
" RNTI DB init for cell");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the cell with recieved configuration */
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for "
"cell");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update RACH Related information
* XXX: Below function yet to be written in RAM
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for"
"cell");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Associate a pair of upper and lower sapCbs with this cell */
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Drx Memory allocation FAILED for"
" cell");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell->overLoadBackOffEnab = FALSE;/* Disabling RachOverload by default */
/* Updating CSG Parameters */
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr Cell Config failed at"
" Initializing the LAA Cell Control Cb");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell->isPucchFormat3Sptd = cellCfg->isPucchFormat3Sptd;
RLOG_ARG0(L_INFO,DBG_CELLID,cellCfg->cellId,"Format 3 is Enabled");
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"EMTC Config Failed"
" cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
{
RLOG_ARG0(L_ERROR, DBG_CELLID,cellCfg->cellId,"5GTF Rgr Cell Config failed");
rgSCHCfgFreeCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrCellCfg */
/**
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%u]SCellIdx :Memomy allocation "
"Failed while Adding SCell Information\n", idx));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)] = RGSCH_PCELL_INDEX;
if (ROK != rgSCHLaaInitDlRbAllocCb(cell,
&ue->cellInfo[RGSCH_PCELL_INDEX]->dlAllocCb))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef TFU_UPGRADE
rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
}
- RETVALUE(ROK);
+ return ROK;
}while(0);
if (ue)
{
rgSCHCfgFreeUeCb(cell, ue);
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgSCHCfgRgrUeCfg */
/**
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId, "RGR Cell re-configuration failed "
"at Scheduler ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Invoke DHM to update DHM specific information */
RLOG_ARG1(L_ERROR,DBG_CELLID, cellRecfg->cellId,
"Invalid CPU OvrLd Ins %d for cell",
cellRecfg->cntrlCmdCfg.cmdDesc.cpuOvrLd.instruction);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
/*initialise the pools of CC and CE*/
if(rgSchSFRTotalPoolInit(cell, cell->subFrms[i]))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
/*initialise the pools of CC and CE*/
if(rgSchDSFRRntpInfoInit(&cell->subFrms[i]->rntpInfo,cell,cell->bwCfg.dlTotalBw))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/*Calculating the length of RNTP array based on Dl Bandwidth */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,
"Memory allocation FAILED for RNTP Alloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell->rntpAggrInfo.pres = PRSNT_NODEF;
cell->rntpAggrInfo.len = len;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrCellRecfg */
/**
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UEID:No RaCb exists while"
"Reconfig for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* rntiLnk does not exist for a HandIn UE. Hence this check. */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"RAM Handling for UE Reconfig failed"
"for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Delete Ue from the ue list */
rgSCHDbmDelUeCb(cell, ue);
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE DRX re-est failed"
"for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif /* Acc Fix */
rgSCHUtlIndRntiRls2Mac(cell, oldRnti, TRUE, ueRecfg->newCrnti);
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for the UE reconfiguration request from RRC to MAC.
/*FH: SCell config failed for a scell index hence revert all successful
* Scell config and send negative confirmation to APP*/
rgSCHSCellCfgUeCfgRollBack(cell, ue, ueRecfg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (dciChange == TRUE)
if( ret != ROK)
{
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_SCELL_PUCCH_RECFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#else
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
"Scheduler handling while reconfig failed"
"for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update uplink HARQ related information for UE */
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Measurement Gap and"
"AckNack Rep Recfg failed for OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (ueRecfg->ueRecfgTypes & RGR_UE_BSRTMR_RECFG)
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"RNTI change "
"failed for OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef TFU_UPGRADE
if (ret != ROK)
{
errInfo->errCause = RGSCHERR_HDFDD_SPSCFGRD;
- RETVALUE(ret);
+ return (ret);
}
}
#endif /* LTEMAC_HDFDD */
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE DRX reconfig failed"
"failed for OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if(ret != OK)
{
errInfo->errCause = RGSCHERR_CQIREPT;
- RETVALUE(ret);
+ return (ret);
}
}
#endif /* End of RGR_CQI_REPT */
#endif
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrUeRecfg */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Scheduler handling for LC Recfg"
" failed for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrLchRecfg */
/**
* @brief Handler for the logical channel reconfiguration request from
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Scheduler handling for LCG Recfg"
" failed for CRNTI:%d LCGID:%d",lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrLcgRecfg */
/**
#endif
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrUeReset */
/**
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,
"Cell does not exist");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Free the active cell */
rgSCHCfgFreeCellCb(cell);
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrCellDel */
RLOG_ARG1(L_ERROR,DBG_CELLID,ueDelInfo->u.ueDel.cellId,
"Cell does not exist CRNTI:%d",
ueDelInfo->u.ueDel.crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgSCHDbmGetUeCb(cell, ueDelInfo->u.ueDel.crnti)) == NULLP)
{
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueDelInfo->u.ueDel.cellId,
"RaCb does not exist for CRNTI:%d",ueDelInfo->u.ueDel.crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
/* This happens in case of Msg4 rejection */
raCb->toDel = TRUE;
- RETVALUE(ROK);
+ return ROK;
}
}
else
errInfo->errCause = RGSCHERR_NONE;
}
- RETVALUE(ROK);
+ return ROK;
}
} /* rgSCHCfgRgrUeDel */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Cell does not exist %d",
lcDelInfo->u.lchDel.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
"UE does not exist for CRNTI:%d LCID:%d",
lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (lcDelInfo->u.lchDel.lcgId > 3)
{
"[%d]UEID:For LC %d, LCGid %d is invalid",
lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId,
lcDelInfo->u.lchDel.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
== NULLP)
RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
"LC does not exist for CRNTI:%d LCID:%d",
lcDelInfo->u.lchDel.crnti, lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgSCHUtlRgrLcDel(cell, ue, lcDelInfo->u.lchDel.lcId,lcDelInfo->u.lchDel.lcgId);
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrLcDel */
RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
"CELL does not exist for CRNTI:%d LCGID:%d",
lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
"UE does not exist for CRNTI:%d LCGID:%d",
lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set lcgId in UEs lcg cntrl blk to invalid */
#endif
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrLcgDel */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Cell does not existi for "
"CRNTI:%d LCID:%d",lcCfg->crnti, lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"UE does not exist for dedicated"
" logical channel CRNTI:%d LCID:%d", lcCfg->crnti, lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate logical channel Id */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid logical channel Id:%d"
"for CRNTI:%d",lcCfg->lcId,lcCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (lcCfg->lcType != CM_LTE_LCH_DTCH && lcCfg->lcType != CM_LTE_LCH_DCCH)
{
RLOG_ARG3(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid logical channel Type %d"
"CRNTI:%d LCID:%d",lcCfg->lcType,lcCfg->crnti, lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrLcCfg */
/***********************************************************
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcgCfg->cellId,"Cell does not exist for"
"CRNTI:%d LCGID:%d",lcgCfg->crnti,lcgCfg->ulInfo.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcgCfg->cellId,"UE does not exist for "
"dedicated logical channel CRNTI:%d LCGID:%d", lcgCfg->crnti, lcgCfg->ulInfo.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((lcgCfg->ulInfo.gbr != 0) && (lcgCfg->ulInfo.mbr < lcgCfg->ulInfo.gbr))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrLcgCfg */
* subsequent power config validations that may be needed */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrCellPwrCfg */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
"Invalid si config for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,
"Invalid transport channel %d for cell", lcCfg->dlTrchType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,"Invalid UL common lcType %d "
"for cell", lcCfg->lcType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,"Invalid Direction %d",
lcCfg->dir);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (bitMask != RGSCH_CELL_ACTIVE_CFG)
{
RLOG_ARG0(L_ERROR,DBG_CELLID, cellCfg->cellId,
"Invalid Common channel config for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrCmnLcCfg */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Invalid Periodic CQI Info");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Validate UE Aperiodic CQI mode */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Invalid Aperiodic mode config for DL CQI",
ueDlCqiCfg->aprdCqiCfg.aprdModeEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef TFU_UPGRADE
/* Validate UE Periodic CQI mode */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Invalid periodic mode config for DL CQI",
ueDlCqiCfg->prdCqiCfg.prdModeEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate K value in periodic CQI Config */
if(((ueDlCqiCfg->prdCqiCfg.prdModeEnum == RGR_PRD_CQI_MOD20) ||
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Invalid K for Subband CQI reporting");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
if ((ueDlCqiCfg->prdCqiCfg.type == 1) &&
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Invalid periodic mode config for DL CQI",
ueDlCqiCfg->prdCqiCfg.cqiSetup.prdModeEnum);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"TDD ACK NACK Multiplexing Mode"
"is not allowed when Ack/Nack is Enabled: %d CRNTI:%d",
ueCfg->ueAckNackCfg.ackNackRepFactor,ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* LTE_TDD */
/* Validate AckNackRep Factor */
if((ueCfg->ueAckNackCfg.isAckNackEnabled == FALSE) &&
(!ueCfg->ueMesGapCfg.isMesGapEnabled))
{
- RETVALUE(ROK);
+ return ROK;
}
if(ueCfg->ueAckNackCfg.isAckNackEnabled)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId, "Invalid ACK NACK REP Factor:%d CRNTI:%d",
ueCfg->ueAckNackCfg.ackNackRepFactor,ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(ueCfg->ueMesGapCfg.isMesGapEnabled)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Offset:%d CRNTI:%d",
ueCfg->ueMesGapCfg.gapOffst,ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case RG_MEAS_GAPPRD_80:
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Offset:%d CRNTI:%d",
ueCfg->ueMesGapCfg.gapOffst,ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
default:
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Periodicity Settings:%d"
"CRNTI:%d", ueCfg->ueMesGapCfg.gapPrd,ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtUeMeasGapAckNakRepCfg*/
if((ueRecfg->ueAckNackRecfg.isAckNackEnabled == FALSE) &&
(!ueRecfg->ueMeasGapRecfg.isMesGapEnabled))
{
- RETVALUE(ROK);
+ return ROK;
}
if(ueRecfg->ueAckNackRecfg.isAckNackEnabled )
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid ACK NACK REP Factor:%d"
"NEW CRNTI:%d",ueRecfg->ueAckNackRecfg.ackNackRepFactor,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(ueRecfg->ueMeasGapRecfg.isMesGapEnabled)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Offset:%d"
"NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapOffst,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case RG_MEAS_GAPPRD_80:
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Offset:%d"
"NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapOffst,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
default:
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Periodicity Settings:%d"
"NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapPrd,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtUeMeasGapAckNakRepRecfg*/
#ifdef LTEMAC_SPS
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid number of n1Pucch values"
" in DL SPS Config");
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (idx = 0; idx < dlSpsCfg->numPucchVal; ++idx)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid N1Pucch value"
" in DL SPS Config %lu", dlSpsCfg->n1PucchVal[idx]);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* SPS_TODO: check will change for TDD */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid number of SPS HARQ procs"
" in DL SPS Config");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtDlSpsCfg */
#endif /* LTEMAC_SPS */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Accumulation configutation"
" not in sync with group power configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid PUSCH Group power"
" configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHCfgVldtUeGrpPwrCfg(cell, &pwrCfg->uePucchPwr) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid PUSCH Group power"
" configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtUePwrCfg */
/***********************************************************
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Uplink Group power "
"configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtUeGrpPwrCfg */
#ifdef LTEMAC_SPS
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid SPS RNTI "
" in DL SPS Recfg OLD CRNTI:%d NEW CCRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHCfgVldtUeDlSpsCfg(cell, &ueRecfg->ueSpsRecfg.dlSpsCfg) != ROK)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid DL SPS configuration"
" for the OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
" DRX reconfig not supported DL SPS enabled for OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
"DL SPS is not supported for HDFDD enabled for OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(ueRecfg->ueSpsRecfg.ulSpsCfg.isUlSpsEnabled)
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
"UL SPS is not supported for HDFDD enabled for OLD CRNTI:%d NEW CRNTI:%d",
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /*rgSCHCfgVldtSpsReCfg*/
#endif
RLOG_ARG3(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalide numColltdCqiRept,"
"MAX supported %d for OLD CRNTI:%d NEW CRNTI:%d",RGR_CQIRPTS_MAXN,
ueRecfg->oldCrnti,ueRecfg->newCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /*rgSCHCfgVldtCqiReptReCfg*/
#endif
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
"Downlink LCId:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((U8 *)dlLc == NULLP)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
"Downlink LCID:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
dlLc->lcId = lcCfg->lcId;
#ifdef LTE_ADV
RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
"configuration failed at SCH:UEID:%d LCID:%d CRNTI:%d",
ue->ueId, lcCfg->lcId,lcCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
RGSCH_ARRAY_BOUND_CHECK(inst, ue->ul.lcCb, (lcCfg->lcId -1));
"configuration failed at SCH: UL LC CB already existing"
" UEID:%d LCID:%d CRNTI:%d",
ue->ueId, lcCfg->lcId,lcCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create UL LC context to maintain LCG to LC mapping and
}
#endif /* LTE_L2_MEAS */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrLchCfg */
/***********************************************************
/* Roll back lcgCfg */
ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcgId = RGSCH_INVALID_LCG_ID;
rgSCHUtlRgrLcgDel(cell, ue, lcgCfg->ulInfo.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef RG_UNUSED
//#ifdef LTE_L2_MEAS
sizeof(RgSchUlLcCb))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Memory allocation FAILED for ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((U8 *)ulLc == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Memory allocation FAILED for ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create UL LC context to maintain LCG to LC mapping and
LC and QCI mapping, this is for L2 Counters :UL ACTIVE UE
ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].numLch = lcgCfg->ulInfo.numLch;
#endif /* LTE_L2_MEAS */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrLcgCfg */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgRgrCmnLcCfg */
if(siCfg->retxCnt > siCfg->siWinSize)
{
RLOG0(L_ERROR,"retxCnt is greater than siWinSize, validation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if(siCfg->numSi > RGR_MAX_NUM_SI)
{
RLOG0(L_ERROR,"Validation for numSi in SI CFG failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* MinPeriodicity will have the least configured periodicity
default:
RLOG0(L_ERROR,"Validation for SI Periodicity in SI-CFG failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrCellSiCfg */
/* LTE_ADV_FLAG_REMOVED_START */
if(lteAdvCfg->sfrCfg.cellEdgeRbRange.startRb > lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb)
{
RLOG0(L_ERROR,"Invalid configuration of cell edge bandwidth for SFR feature");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb >= dlTotalBw)
{
RLOG0(L_ERROR,"Invalid configuration of cell edge end RB for SFR feature");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef TFU_UPGRADE
if(lteAdvCfg->sfrCfg.pwrThreshold.pLow >= lteAdvCfg->sfrCfg.pwrThreshold.pHigh)
{
RLOG0(L_ERROR,"Invalid configuration of power threshold for SFR feature");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
(RGR_ABS_TRANSMIT != lteAdvCfg->absCfg.absPatternType))
{
RLOG0(L_ERROR,"Invalid configuration of ABS pattern type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemcpy(temp, (U8 *) lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
if((temp[idx] != 1) && (temp[idx] != 0))
{
RLOG0(L_ERROR,"Invalid configuration of ABS pattern type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_END */
{
RLOG0(L_ERROR,"Invalid Configuration of minimum DL resources "
"for NON-CSG");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(csgParam->minUlResNonCsg > 100)
{
RLOG0(L_ERROR,"Invalid Configuration of minimum UL resources "
"for NON-CSG");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid SI Id value"
" specified");
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
break;
case RGR_SI_CFG_TYPE_MIB: /* SI CFG Type MIB */
case RGR_SI_CFG_TYPE_SIB1: /* SI CFG TYPE SIB1 */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid SI Id value"
" specified");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(siCfg->siId > ((cell->siCfg.minPeriodicity * 10)/cell->siCfg.siWinSize))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "SiId can not be scheduled ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case RGR_SI_CFG_EMTC_TYPE_SI_PER:
if(ROK != rgEmtcvalidateSiCfg(siCfg,cell))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
#endif
default:
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid cfgType "
"parameter value");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*Validate the specified pdu */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid NULLP pdu "
"specified");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*Check if PDU is of 0 length*/
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid pdu "
"specified");
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrSiCfg */
#endif /*RGR_SI_SCH*/
(loadInfReq->rgrCcPHighStartRb <= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.endRb))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid rgrCcPHighStartRb received specified");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate if the CC endRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
(loadInfReq->rgrCcPHighEndRb <= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.endRb))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid rgrCcPHighEndRb received specified");
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGSCHERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCfgVldtRgrLoadInf */
/* LTE_ADV_FLAG_REMOVED_END */
puschMode == RGR_APRD_CQI_MOD22 ||
puschMode == RGR_APRD_CQI_MOD31)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (puschMode == RGR_APRD_CQI_MOD20 ||
puschMode == RGR_APRD_CQI_MOD30)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
if (puschMode != RGR_APRD_CQI_MOD31)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef LTE_ADV
* 2-0,3-0 of pmi/ri reporitng isdisabled and csi-rs ports == 1*/
#endif
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtRgrTxmodePuschMode ends*/
/*
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Aperiodic CQI configuration CRNTI:%d",crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
{
if (txMde ==RGR_UE_TM_4 || txMde ==RGR_UE_TM_5 || txMde ==RGR_UE_TM_6)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pucchMode == RGR_PRD_CQI_MOD11 || pucchMode == RGR_PRD_CQI_MOD21)
if (txMde ==RGR_UE_TM_1 || txMde ==RGR_UE_TM_2 || txMde ==RGR_UE_TM_3 \
|| txMde ==RGR_UE_TM_7)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* TODO:: Tm8 and TM9 validation needs to be added */
- RETVALUE(ROK);
+ return ROK;
}
/*
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Tx Mode-PUCCH Mode combination CRNTI:%d",crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Reporting Type-PUCCH Mode combination CRNTI:%d",crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cqiCfg->cqiSetup.cqiRepType==2) &&
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Reporting Type-PUCCH Mode combination CRNTI:%d",crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*3. Validate CQI/PMI and RI Configuration related parameter values */
RLOG_ARG3(L_ERROR,DBG_CELLID,cellCb->cellId,
"Not Supported or Invalid CQI-PUCCH resourceIndex=%d Cfg Val=%d CRNTI:%d",
RG_SCH_PUCCH_RES_MAX_SUPP, cqiCfg->type,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_HDFDD
"Not Supported or Invalid Cfg CQI Min Index Sup =%d"
"Max Index Sup=%d Cfg Val=%d CRNTI:%d", RG_SCH_ICQI_MIN_SUPP,
RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
"Not Supported or Invalid Cfg CQI Min Index Sup =%d "
"Max Index Sup=%d Cfg Val=%d CRNTI:%d", RG_SCH_ICQI_MIN_SUPP,
RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#else
"Not Supported or Invalid Cfg CQI Min Index Sup =%d"
"Max Index Sup=%d Cfg Val=%d CRNTI;%d", RG_SCH_ICQI_MIN_SUPP,
RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Cfg CQI Report"
"ModeCfg Val=%d CRNTI:%d", cqiCfg->type,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cqiCfg->cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid CQI Cfg K Cfg Val=%d CRNTI:%d", cqiCfg->type,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cqiCfg->cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP) &&
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Periodic CQI mode Cfg for dlTotalBw (%d) for CRNTI:%d",
cellCb->bwCfg.dlTotalBw, crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef LTE_TDD
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
"Reserved value Cfg =%d CRNTI:%d",
cqiCfg->cqiSetup.cqiPResIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Transmission Mode =%d CRNTI:%d",
txMde,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Index RI value Cfg =%d CRNTI:%d",
cqiCfg->cqiSetup.riCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Cell specific SRS is not configured CRNTI:%d",crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* 1. Validate SRS Configuration related parameter values */
"SRS Min Index Sup =%d Max Index Sup=%d Cfg Val=%d CRNTI:%d",
RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
srsCfg->srsSetup.srsCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
"SRS Min Index Sup =%d Max Index Sup=%d Cfg Val=%d CRNTI:%d",
RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
srsCfg->srsSetup.srsCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
"SRS Min Index Sup =%d Max Index Sup=%d Cfg Val=%d CRNTI:%d",
RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
srsCfg->srsSetup.srsCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef LTE_TDD
"UE specific SRS is not occuring in Cell specific SRS subframe"
"srs Cfg Idx =%d CRNTI:%d",
srsCfg->srsSetup.srsCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
"Max Freq Domain Position =%d Cfg Val=%d CRNTI:%d",
RG_SCH_SRS_FREQDOM_POS_MIN, RG_SCH_SRS_FREQDOM_POS_MAX,
srsCfg->srsSetup.srsCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( srsCfg->srsSetup.txComb > RG_SCH_SRS_TXCOMB_MAX )
"SRS Min TX Comb =%d Max TX Comb =%d Cfg Val=%d CRNTI:%d",
RG_SCH_SRS_TXCOMB_MIN, RG_SCH_SRS_TXCOMB_MAX,
srsCfg->srsSetup.srsCfgIdx,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
"Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
"Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#else
"Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Aperiodic CQI configuration CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* 1. Validate UE Periodic CQI/PMI, SRS and SR related parameters */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Periodic CQI configuration CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* 2. Validate SRS Configuration related parameter values */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid SRS configuration CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* 3. Validate SR Configuration related parameter values */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid SR configuration CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Aperiodic CQI configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid Periodic CQI configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid SRS configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Invalid SR configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
rgSchCmnSetCqiReqField(RG_SCH_CMN_GET_SCELL_INFO(ue, cellCb),ue,&acqiCb->cqiReqField);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
}
ueCb->nPCqiCb = cqiCb;
ueCb->nPRiCb = cqiCb;
- RETVALUE(ROK);
+ return ROK;
}
/**
cqiCb->riDist = RG_SCH_INVALID_IDX;
}
- RETVALUE(ROK);
+ return ROK;
}
ueCb->srsCb.srsLstEnt.node =(PTR) NULLP;
}
- RETVALUE(ROK);
+ return ROK;
}
ueCb->srCb.srLstEnt.node = (PTR)NULLP;
}
- RETVALUE(ROK);
+ return ROK;
}
/* ccpu00140578:: */
cqiCb->riRecpPrcsd = FALSE;
- RETVALUE(ROK);
+ return ROK;
}
/* ccpu00140578:: */
ueCb->srsCb.srsRecpPrcsd = FALSE;
- RETVALUE(ROK);
+ return ROK;
}
/* @brief Handles SR Re-configuration for a UE.
rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
}
- RETVALUE(ROK);
+ return ROK;
}
/* @brief Handles ACQI Re-configuration for a UE.
{
TRC3(rgSCHCfgAcqiUeReCfg);
- RETVALUE(rgSCHCfgACqiUeCfg(cellCb,ueCb,(RG_SCH_CMN_GET_ACQICB(ueCb,cellCb))
+ return (rgSCHCfgACqiUeCfg(cellCb,ueCb,(RG_SCH_CMN_GET_ACQICB(ueCb,cellCb))
,ueCb->mimoInfo.txMode, acqiCfg, ueCat));
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
}while( min <= max );
- RETVALUE(ROK);
+ return ROK;
}
}
}
- RETVALUE ( table );
+ return ( table );
}
/* #endif */
#endif /* TFU_UPGRADE */
if (ueDrxCfg->isDrxEnabled == FALSE)
{
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTEMAC_R9
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid cqiMask configuration(%ld)",
ueDrxCfg->cqiMask.val);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif /*LTEMAC_R9*/
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d)",
ueDrxCfg->drxOnDurTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d) for EMTC",
ueDrxCfg->drxOnDurTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d) for EMTC",
ueDrxCfg->drxOnDurTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Inactivity configuration(%d)",
ueDrxCfg->drxInactvTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
if(ueDrxCfg->isEmtcUe)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d) for EMTC",
ueDrxCfg->drxRetxTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d)",
ueDrxCfg->drxRetxTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d)",
ueDrxCfg->drxRetxTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef EMTC_ENABLE
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d) for EMTC",
ueDrxCfg->drxRetxTmr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if ( rgSCHCfgVldtDrxLngCycCfg(ueDrxCfg->drxLongCycleOffst) != ROK )
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LongCycle configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( ueDrxCfg->drxLongCycleOffst.longDrxCycle < ueDrxCfg->drxOnDurTmr )
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
" and onDuration timer values");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_TDD
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
" and onDuration timer values");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of short DRX "
"Cycle and onDuration timer values");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( (ueDrxCfg->drxLongCycleOffst.longDrxCycle %
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId," Long DRX cycle is not multiple of "
"short DRX cycle");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( rgSCHCfgVldtDrxShrtCycCfg(ueDrxCfg->drxShortDrx) != ROK )
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Short Cycle configuration");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_TDD
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
" and onDuration timer values");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtDrxUeCfg*/
/***********************************************************
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}/*switch(onDurTmr)*/
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtOnDurCfg*/
/***********************************************************
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}/*switch(InactvTmr)*/
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtDrxInActvCfg*/
/***********************************************************
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}/*switch(drxRetxTmr)*/
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtDrxReTxCfg*/
/***********************************************************
if ( rgSCHCfgVldtDrxLngCyclTmrs(lngCycleOffst.longDrxCycle) != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( lngCycleOffst.drxStartOffst >= lngCycleOffst.longDrxCycle )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtDrxLngCycCfg*/
/***********************************************************
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}/*switch(longDrxCycle)*/
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHCfgVldtDrxLngCyclTmrs*/
/***********************************************************
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}/*switch(shortDrxCycle)*/
(shrtCycCfg.drxShortCycleTmr > RGR_DRX_SHRTCYCLE_MAX)
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Could not allocate memory for sending StaInd OLD CRNTI:%d",ueRecfg->oldCrnti);
- RETVALUE(retVal);
+ return (retVal);
}
/* Fill StaInd for sending collated N CQI rpeort */
ue->cqiReptCfgInfo.numColltdCqiRept =
ueRecfg->ueCqiReptCfg.numColltdCqiRept;
- RETVALUE(ROK);
+ return ROK;
} /* End of rgSCHCfgUeCqiReptReCfg */
#endif /* End of RGR_CQI_REPT */
/*This function Added Ue in ongoing L2 Meas*/
lnk = lnk->next;
}/*End of while loop*/
- RETVALUE(ROK);
+ return ROK;
}
#endif
#ifdef LTE_ADV
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"bw<=bwAssigned for UEID:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rbAllocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
ueDl->proc->reqLnk.node = (PTR)ueDl->proc;
allocInfo->ccchSduAlloc.ccchSduDlSf->schdCcchUe++;
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief This function scheduler for downlink CCCH messages.
}
}
- RETVALUE(inWin);
+ return (inWin);
} /* end of rgSCHCmnChkInWin*/
/*
RGSCH_INCR_SUB_FRAME(end, 1);
pastWin = rgSCHCmnChkInWin(frm, end, refFrm);
- RETVALUE(pastWin);
+ return (pastWin);
} /* end of rgSCHCmnChkPastWin*/
\f
/**
numCce = 16;
break;
default:
- RETVALUE(NULLP);
+ return (NULLP);
}
if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
subFrm->cceCnt += numCce;
pdcch->pdcchSearchSpace = RG_SCH_CMN_SEARCH_SPACE;
- RETVALUE(pdcch);
+ return (pdcch);
}
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u",
aggrLvl);
- RETVALUE(NULLP);
+ return (NULLP);
}
\f
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
"bw<=bwAssigned");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDhmGetMsg4HqProc failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
raCb->rbAllocInfo.dlSf = allocInfo->msg4Alloc.msg4DlSf;
rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnMsg4DedAlloc failed.");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
raCb->dlHqE->msg4Proc->reqLnk.node = (PTR)raCb->dlHqE->msg4Proc;
allocInfo->msg4Alloc.msg4DlSf->schdCcchUe++;
- RETVALUE(ROK);
+ return ROK;
}
\f
// prc_trace_format_string(PRC_TRACE_GROUP_PS, PRC_TRACE_INFO_LOW,"Forcing alloc in CMN search spc size %d fmt %d \n",
// pdcch->dciNumOfBits, dciFrmt);
}
- RETVALUE(pdcch);
+ return (pdcch);
}
#endif
"PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
- RETVALUE(NULLP);
+ return (NULLP);
}
if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
/* MSG4 */
pdcch->dciNumOfBits = cell->dciSize.size[dciFrmt];
}
- RETVALUE(pdcch);
+ return (pdcch);
}
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
- RETVALUE(NULLP);
+ return (NULLP);
}
#ifdef RGR_V1
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rbAllocinfo->rnti = ueCb->ueId;
rbAllocinfo->tbInfo[0].noLyr = 1;
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rbAllocinfo->tbInfo[0].schdlngForTb = TRUE;
rbAllocinfo->tbInfo[0].noLyr = 1;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_TDD
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"bw == bwAssigned RARNTI:%d",rarnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
reqLst = &cell->raInfo.raReqLst[raIndex];
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"reqLst Count=0 RARNTI:%d",rarnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
remNumRapid = reqLst->count;
if (!isAlloc)
{
RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
subFrm->bwAssigned = subFrm->bwAssigned + rb;
allocInfo->raRspAlloc[noRaRnti].tbInfo[0].noLyr = 1;
allocInfo->raRspAlloc[noRaRnti].vrbgReq = RGSCH_CEIL(nPrb,MAX_5GTF_VRBG_SIZE);
schdNumRapid += remNumRapid;
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
if(splfrmIdx == curSubfrmIdx)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/**
*ulDai = anInfo->ulDai;
}
#endif
- RETVALUE(anInfo->dlDai);
+ return (anInfo->dlDai);
}
#endif /* ifdef LTE_TDD */
if(dlsf->phichOffInfo.sfnOffset == RGSCH_INVALID_INFO)
{
- RETVALUE(RGSCH_INVALID_INFO);
+ return (RGSCH_INVALID_INFO);
}
subframe = dlsf->phichOffInfo.subframe;
numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
idx = numUlSf % (cellUl->numUlSubfrms);
- RETVALUE(idx);
+ return (idx);
}
/**
rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->subframe]) - 1;
idx = numUlSf % (cellUl->numUlSubfrms);
- RETVALUE(idx);
+ return (idx);
}
#endif
procId = numUlSf % numUlHarq;
#endif
- RETVALUE(procId);
+ return (procId);
}
//pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, y, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_0, FALSE);
pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_A1, FALSE);
}
- RETVALUE(pdcch);
+ return (pdcch);
}
/***********************************************************
bitMap1 = pmiBitMap[1];
if((bitMap1) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap1>>16) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else if((bitMap0) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_3);
+ return (RG_SCH_CMN_RANK_3);
}
else if((bitMap0>>16) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_4);
+ return (RG_SCH_CMN_RANK_4);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
bitMap0 = pmiBitMap[0];
if((bitMap0>>26)& 0x0F)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap0>>30) & 3)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
bitMap0 = pmiBitMap[0];
if((bitMap0>>28)& 1)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap0>>29) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else if((bitMap0>>30) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_3);
+ return (RG_SCH_CMN_RANK_3);
}
else if((bitMap0>>31) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_4);
+ return (RG_SCH_CMN_RANK_4);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
bitMap0 = pmiBitMap[0];
if((bitMap0>>30)& 1)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap0>>31) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
{
- RETVALUE (rgSCHCmnComp2TxMode3(pmiBitMap));
+ return (rgSCHCmnComp2TxMode3(pmiBitMap));
}
else if (numTxPorts ==4 && txMode == RGR_UE_TM_3)
{
- RETVALUE (rgSCHCmnComp4TxMode3(pmiBitMap));
+ return (rgSCHCmnComp4TxMode3(pmiBitMap));
}
else if (numTxPorts ==2 && txMode == RGR_UE_TM_4)
{
- RETVALUE (rgSCHCmnComp2TxMode4(pmiBitMap));
+ return (rgSCHCmnComp2TxMode4(pmiBitMap));
}
else if (numTxPorts ==4 && txMode == RGR_UE_TM_4)
{
- RETVALUE (rgSCHCmnComp4TxMode4(pmiBitMap));
+ return (rgSCHCmnComp4TxMode4(pmiBitMap));
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
if (rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(hqP->sch), (sizeof(RgSchCmnDlHqProc))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef EMTC_ENABLE
{
if(ROK != cellSchd->apisEmtcDl->rgSCHDlUeHqEntInit(cell, hqEnt))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
if(ROK != cellSchd->apisDl->rgSCHDlUeHqEntInit(cell, hqEnt))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnDlInitHqEnt */
/**
cell->refreshUeCnt[refOffst]++;
ue->refreshOffset = refOffst;
/* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst, cell->refreshUeCnt[refOffst]); */
- RETVALUE(refOffst);
+ return (refOffst);
}
}
cell->refreshUeCnt[refOffst-1]++;
ue->refreshOffset = refOffst-1;
- RETVALUE(refOffst-1);
+ return (refOffst-1);
}
/**
* @brief This function computes initial Refresh Wait Period.
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueSchCmn = RG_SCH_CMN_GET_UE(ue,sCell);
if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* TODO: enhance for DLFS RB Allocation for SCELLs in future dev */
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
"Failed for CRNTI:%d", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueUlPcell = RG_SCH_CMN_GET_UL_UE(ue, ue->cell);
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
"for CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
allRcd->allocTime = sCell->crntTime;
cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
"power config for UE CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ue->ul.isUlCaEnabled = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrSCellUeCfg */
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
(Data**)(&(sCellInfo->sch)), (sizeof(RgSchCmnUe)));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrSCellUeDel */
#endif
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
- RETVALUE(ROK);
+ return ROK;
}
#endif
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
ue->dl.ueDlCqiCfg = ueCfg->ueDlCqiCfg;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
"configured as 0 for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DL ambr */
ue->dl.ambrCfgd = (ueCfg->ueQosCfg.dlAmbr * RG_SCH_CMN_REFRESH_TIME)/100;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
"for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
allRcd->allocTime = cell->crntTime;
cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
}
/* After initialising UL part, do power related init */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
"power config for UE CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
"SPS config for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* LTEMAC_SPS */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
"for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rgSCHCmn5gtfUeCfg(cell, ue, ueCfg);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrUeCfg */
/**
"reporting mode %d for old CRNIT:%d",
(int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->dl.ueDlCqiCfg.prdCqiCfg = ueRecfg->prdDlCqiRecfg;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
"configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->ul.cfgdAmbr = (ueRecfg->ueQosRecfg.ueBr * \
RG_SCH_CMN_REFRESH_TIME)/100;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* DLFS UE Config */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrUeRecfg*/
/***********************************************************
}
if (dlCmnCodeRate->ccchCqi == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
cellDl->dl.ccchCqi = dlCmnCodeRate->ccchCqi;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_TDD
}
if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Intialize the RACH response scheduling related infromation */
if(rgSCHCmnDlRachInfoInit(cell) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate PRACH preamble list */
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (!cfg->maxCcchPerDlSf)
{
}
if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*ccpu00118273 - ADD - start */
ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
ret = rgSCHPwrCellCfg(cell, cfg);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset;
cellSch->dl.rarTxPwrOffset = cfg->rarTxPwrOffset;
cellSch->dl.phichTxPwrOffset = cfg->phichTxPwrOffset;
cellSch->dl.msg4pAVal = cfg->msg4pAVal;
- RETVALUE(ROK);
+ return ROK;
}
#else /* LTE_TDD */
/**
"FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
cellSch->dl.maxUePerDlSf,
cellSch->dl.maxUeNewTxPerTti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (!cfg->maxCcchPerDlSf)
{
if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListInit(&cellSch->dl.msg4RetxLst);
#ifdef RGR_V1
ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
ret = rgSCHPwrCellCfg(cell, cfg);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset;
cellSch->dl.rarTxPwrOffset = cfg->rarTxPwrOffset;
cellSch->dl.phichTxPwrOffset = cfg->phichTxPwrOffset;
RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_TDD */
{
U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
TRC2(rgSCHCmnUlCalcReqRbCeil);
- RETVALUE((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
+ return ((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
}
/***********************************************************
if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(msgSzA, ccchCqi, cellUl), sbSize);
* Refer- TG36.321- section- 5.1.2*/
cellUl->ra.prmblANumSb = numSb;
cellUl->ra.prmblAIMcs = ccchMcs;
- RETVALUE(ROK);
+ return ROK;
}
PUBLIC U32 gPrntPucchDet=0;
if (puschRbStart * 2 >= ulBw)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*rbStartRef = puschRbStart;
cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
}
- RETVALUE(ROK);
+ return ROK;
}
#else
if (puschRbStart*2 >= ulBw)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*rbStartRef = puschRbStart;
cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
"FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
cellUl->maxAllocPerUlSf,
cellUl->maxUeNewTxPerTti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
- RETVALUE(ret);
+ return (ret);
}
}
#endif
if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
- RETVALUE(RFAILED);
+ return RFAILED;
}
//Setting the subband size to 4 which is size of VRBG in 5GTF
#ifdef RG_5GTF
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
"maxUlBwPerUe/sbSize is zero");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl->maxSbPerUe = rgSchCmnMult235Tbl[maxSbPerUe].prvMatch;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
"Invalid cqi");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl->dfltUlCqi = cellCfg->ulCmnCodeRate.ccchCqi;
cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
#endif
cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
cellUl->sbSize = sbSize;
if (ret != ROK)
{
cellUl->numUlSubfrms = 0;
- RETVALUE(ret);
+ return (ret);
}
/* store the DL subframe corresponding to the PUSCH offset
#endif
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
if (cfi == 1)
cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi,
cell->pucchCfg.maxPucchRb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DMRS values */
cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
for (i = 0; i < cellUl->dmrsArrSize; ++i)
{
rgSCHUtlFreeSBuf(cell->instIdx,
(Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
#endif
- RETVALUE(ret);
+ return (ret);
}
}
RG_SCH_RESET_HCSG_UL_PRB_CNTR(cellUl);
- RETVALUE(ROK);
+ return ROK;
}
/**
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
cellSch = (RgSchCmnCell *)(cell->sc.sch);
cellSch->cfiCfg = cellCfg->cfiCfg;
{
/* There is no downlink deinit to be performed */
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
ret = rgSCHCmnDlRgrCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
/* DL scheduler has no initializations to make */
/* As of now DL scheduler always returns ROK */
ret = cellSch->apisEmtcUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
#endif
ret = cellSch->apisUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
#ifdef EMTC_ENABLE
if(TRUE == cellCfg->emtcEnable)
ret = cellSch->apisEmtcDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
#endif
ret = rgSCHCmnSpsCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
#endif
ret = cellSch->apisDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
rgSCHCmnInitVars(cell);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrCellCfg*/
\f
err->errCause = RGSCHERR_SCH_CFG;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
"Invalid cqi");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl->dfltUlCqi = recfg->ulCmnCodeRate.ccchCqi;
ret = rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
cellUl->dfltUlCqi = oldCqi;
rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
- RETVALUE(ret);
+ return (ret);
}
}
if (rgSCHCmnDlCnsdrCmnRt(cell, &recfg->dlCmnCodeRate) != ROK)
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ret = cellSch->apisEmtcUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Invoke DL sched for cell Recfg */
ret = cellSch->apisEmtcDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Invoke DL sched for cell Recfg */
ret = cellSch->apisDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ret = cellSch->apisDlfs->rgSCHDlfsCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellSch->dl.isDlFreqSel = recfg->dlfsRecfg.isDlFreqSel;
}
ret = rgSCHPwrCellRecfg(cell, recfg);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((qci >= RG_SCH_CMN_GBR_QCI_START) &&
{
if ((dlQos->mbr == 0) || (dlQos->mbr < dlQos->gbr))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
"SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
if(lcCfg->lcType != CM_LTE_LCH_DCCH)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
"DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
/* Perform DL service activation in the scheduler */
((RgSchCmnDlSvc *)(dlLc->sch))->qci = lcCfg->dlInfo.dlQos.qci;
ret = cellSch->apisEmtcDl->rgSCHRgrDlLcCfg(cell, ue,dlLc ,lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisDl->rgSCHRgrDlLcCfg(cell, ue, dlLc, lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "rgSchCmnRgrLchCfg(): "
"SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
"not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcRecfg->dlRecfg.dlQos.gbr * \
RG_SCH_CMN_REFRESH_TIME)/100;
ret = cellSch->apisEmtcDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cellSch->apisUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
"supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
/* Indicate MAC that this LCG is GBR LCG */
rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcgCfg->ulInfo.lcgId, TRUE);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
/* In case of RAB modification */
rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, FALSE);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
cellSch->apisUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
}while(idx < RG_SCH_CMN_NUM_BI_VAL-1);
cell->biInfo.prevBiTime = rgSchCmnBiTbl[idx];
/* For 16 Entries in Table 7.2.1 36.321.880 - 3 reserved so total 13 Entries */
- RETVALUE(idx); /* Returning reserved value from table UE treats it has 960 ms */
+ return (idx); /* Returning reserved value from table UE treats it has 960 ms */
} /* rgSCHCmnGetBiIndex */
k = (frm.sfn/2) % 4;
}
rv = RGSCH_CEIL(3*k, 2) % 4;
- RETVALUE(rv);
+ return (rv);
}
/**
if ((nPrb >= maxRb) && (resiTbs <= 10))
{
/* Could not accomodate ACQI */
- RETVALUE(RFAILED);
+ return RFAILED;
}
totREs = nPrb * RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
tbSz = rgTbSzTbl[0][resiTbs][nPrb-1];
*numSb = resNumSb;
*iTbs = resiTbs;
- RETVALUE(ROK);
+ return ROK;
}
#endif
#endif
if (proc == NULLP)
{
//printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
gUl5gtfPdcchSchd++;
#if defined (TENB_STATS) && defined (RG_5GTF)
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
- RETVALUE(RFAILED);
+ return RFAILED;
}
gUl5gtfAllocAllocated++;
#if defined (TENB_STATS) && defined (RG_5GTF)
ueUl->alloc.alloc = alloc;
/*rntiwari-Adding the debug for generating the graph.*/
/* No grant attr recorded now */
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
cellSch->apisUl->rgSCHUlUeRefresh(cell, ue);
cellSch->apisDl->rgSCHDlUeRefresh(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
"timer event CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
UNUSED(tmrEvnt);
rgSCHCmnAddUeToRefreshQ(cell, ue, RG_SCH_CMN_REFRESH_TIME);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
cmPrcTmr(&sched->tmrTqCp, sched->tmrTq, (PFV)rgSCHCmnTmrExpiry);
}
- RETVALUE(ROK);
+ return ROK;
}
if (ue->txModeTransCmplt == FALSE)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell->numTxAntPorts == 2)
{
if (pmi > 3)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (ueDl->mimoInfo.ri == 2)
{
/* PMI 2 and 3 are invalid incase of 2 TxAnt and 2 Layered SM */
if (pmi == 2 || pmi == 3)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDl->mimoInfo.pmi = pmi+1;
}
{
if (pmi > 15)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDl->mimoInfo.pmi = pmi;
}
/* Reset the No PMI Flag in forceTD */
RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
- RETVALUE(ROK);
+ return ROK;
}
/**
{
wideCqi=15;
}
- RETVALUE(wideCqi);
+ return (wideCqi);
}/*rgSCHCmnCalcWcqiFrmSnr*/
#if (ERRCLASS & ERRCLS_DEBUG)
if (curProc->alloc == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
curProc->alloc->hqProc = curProc;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnUpdUlHqProc */
#endif
if(ueCb->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHSrRcvd(ueCb->cell, ueCb);
- RETVALUE(ROK);
+ return ROK;
}
}
else
cellSch->apisUl->rgSCHSrRcvd(ueCb->cell, ueCb);
}
- RETVALUE (ROK);
+ return (ROK);
}
/**
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (lcgCnt=0; lcgCnt<4; lcgCnt++)
{
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
- RETVALUE(ROK);
+ return ROK;
}
}
else
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set all higher prio lcgs bs to 0 and update this lcgs bs and
total bsr= sumofall lcgs bs */
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
- RETVALUE(ROK);
+ return ROK;
}
}
else
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHUpdBsrLong(cell, ue, bsArr);
- RETVALUE(ROK);
+ return ROK;
}
}
else
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnUpdExtPhr */
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnUpdPhr */
/**
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHContResUlGrant(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
}
else
{
cellSch->apisUl->rgSCHContResUlGrant(cell, ue);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHSrRcvd(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
}
else
{
cellSch->apisUl->rgSCHSrRcvd(cell, ue);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
}
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
alloc = NULLP;
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
* @brief Collates DRX enabled UE's scheduled in this SF
}
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
{
alloc = NULLP;
}
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
{
TRC2(rgSCHCmnUlGetITbsFrmIMcs);
- RETVALUE(rgUlIMcsTbl[iMcs].iTbs);
+ return (rgUlIMcsTbl[iMcs].iTbs);
}
/***********************************************************
}
#endif
- RETVALUE(iMcs);
+ return (iMcs);
}
/***********************************************************
RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs);
- RETVALUE(rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
+ return (rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
}
/***********************************************************
}
alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
iTbs = 19;
}
#endif
- RETVALUE(iTbs);
+ return (iTbs);
#endif
#else
if ( (ueCtgy != CM_LTE_UE_CAT_5) && (ueUl->crntUlCqi[0] > ueUl->maxUlCqi ))
cqi = ueUl->crntUlCqi[0];
}
#endif
- RETVALUE(rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
+ return (rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
}
/**
cell->subFrms[sfNum]->dlFdbkInfo.sfnOffset;
cell->subFrms[dlIdx]->dlFdbkInfo.m = cell->subFrms[sfNum]->dlFdbkInfo.m;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
cell->subFrms[dlIdx]->ulAscInfo.sfnOffset =
cell->subFrms[sfNum]->ulAscInfo.sfnOffset;
}
- RETVALUE(ROK);
+ return ROK;
}
cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
(Data **)(&cell->raInfo.raReqLst), (Size)(lstSize * sizeof(CmLListCp)));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
cell->raInfo.lstSize = lstSize;
- RETVALUE(ROK);
+ return ROK;
}
ret = rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
cell->subFrms[dlIdx]->phichOffInfo.sfnOffset =
cell->subFrms[sfNum]->phichOffInfo.sfnOffset;
}
- RETVALUE(ROK);
+ return ROK;
}
{
if(cce < cell->rgSchTddNpValTbl[i])
{
- RETVALUE(i-1);
+ return (i-1);
}
}
- RETVALUE(0);
+ return (0);
}
#endif
if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
- RETVALUE(ROK);
+ return ROK;
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
if (cellSch->rachCfg.remDedPrm == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* The stored prachMskIdx is the index of PRACH Oppurtunities in
* raOccasions.subframes[].
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
*prachMskIdx = 0;
*rapId = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if (ueDl->rachInfo.hoRapId == rapId)
{
- RETVALUE(ue);
+ return (ue);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
#ifdef ANSI
ueDl->rachInfo.rapIdLnk.node = (PTR)NULLP;
if (RGSCH_TIMEINFO_SAME(ueDl->rachInfo.asgnOppr, timingInfo))
{
- RETVALUE(ue);
+ return (ue);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
cqi = ueUl->crntUlCqi[0];
}
#endif
- RETVALUE(cqi);
+ return (cqi);
}/* End of rgSCHCmnUlGetCqi */
/***********************************************************
TRC2(rgSCHCmnUlRbAllocForPoHoUe);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*MS_WORKAROUND for HO ccpu00121116*/
cqi = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
#if (ERRCLASS & ERRCLS_DEBUG)
if (!bits)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
RG_SCH_UL_MCS_TO_MODODR(alloc->grnt.iMcsCrnt,alloc->grnt.modOdr);
rgSCHUhmNewTx(proc, ueUl->hqEnt.maxHqRetx, alloc);
/* No grant attr recorded now */
- RETVALUE(ROK);
+ return ROK;
}
/**
((alloc2->sbStart >= alloc1->sbStart) &&
(alloc2->sbStart <= alloc1->sbStart + alloc1->numSb-1)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/**
* @brief Copy allocation Info from src to dst.
pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
if (pdcch == NULLP)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
/* Fetch UL Alloc for msg3 */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"UL Alloc fail for msg3 retx for rnti: %d\n",
proc->reTxAlloc.rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"Num SB not suffiecient for adap retx for rnti: %d",
proc->reTxAlloc.rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Fix: syed Adaptive Msg3 Retx crash. */
* same */
}
- RETVALUE(numAllocRbgs);
+ return (numAllocRbgs);
}
#ifdef RGSCH_SPS_UNUSED
*allocRbgSubset = bestSubsetIdx;
} /* End of if (bestNumAvailRbs) */
- RETVALUE(numAllocRbs);
+ return (numAllocRbs);
}
#endif
/**
}
}
- RETVALUE(numAllocRbs);
+ return (numAllocRbs);
}
/**
rbg = rbIdx/rbgSize;
rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
- RETVALUE(rbgPosInRbgMask);
+ return (rbgPosInRbgMask);
}
#ifdef RGSCH_SPS_UNUSED
rbPosInSubset = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
*type1Subset = rbgSubset;
- RETVALUE(rbPosInSubset);
+ return (rbPosInSubset);
}
#endif /* RGSCH_SPS_UNUSED */
/**
*maskIdx = rbIdx / 32;
rbPosInType2 = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
- RETVALUE(rbPosInType2);
+ return (rbPosInType2);
}
/**
if ((0 == rbAllocInfo->tbInfo[0].schdlngForTb) &&
(0 == rbAllocInfo->tbInfo[1].schdlngForTb))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Check if the requirement can be accomodated in SPS BW */
if (dlSf->spsAllocdBw == spsRbgInfo->numRbs)
{
/* SPS Bandwidth has been exhausted: no further allocations possible */
- RETVALUE(FALSE);
+ return (FALSE);
}
if (!isPartialAlloc)
{
if((dlSf->spsAllocdBw + rbAllocInfo->rbsReq) > spsRbgInfo->numRbs)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
if (!numAllocRbs)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
if (!(rbAllocInfo->pdcch =
rbAllocInfo->dciFormat, FALSE)))
{
/* Note: Returning TRUE since PDCCH might be available for another UE */
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Update Tb info for each scheduled TB */
}
dlSf->spsAllocdBw += numAllocRbs;
- RETVALUE(TRUE);
+ return (TRUE);
}
/***********************************************************
addtlRbsAvl = (dlSf->bw - dlSf->bwAlloced) - allocInfo->rbsReq;
}
- RETVALUE(addtlRbsAvl);
+ return (addtlRbsAvl);
}
/* Added this function to find num of ovrlapping PBCH rb*/
if(dlSf->bwAlloced == dlSf->bw)
#endif
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef LTE_TDD
if (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced))
if (!spsRbsAlloc)
#endif /* LTEMAC_SPS */
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
if (allocInfo->pdcch == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
if(dlSf->bwAlloced == dlSf->bw)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->tbInfo[0].noLyr = 1;
allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
if (allocInfo->pdcch == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, NULLP, dlSf, 13, TFU_DCI_FORMAT_B1, FALSE);
if (allocInfo->pdcch == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
RgSchSfBeamInfo *beamInfo = &(dlSf->sfBeamInfo[0]);
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
printf("5GTF_ERROR vrbg allocated > 25\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->tbInfo[0].cmnGrnt.vrbgStart = beamInfo->vrbgStart;
printf("\n[%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
__func__,allocInfo->tbInfo[0].bytesAlloc,allocInfo->vrbgReq);
- RETVALUE(ROK);
+ return ROK;
}
/* Check if type0 allocation can cater to this RETX requirement */
if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
else
{
/* cannot allocate same number of required RBs */
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
cell->rbgSize) - dlSf->lstRbgDfct))
{
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
noLyrs = allocInfo->tbInfo[0].noLyr;
allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
continue;
}
- // RETVALUE(FALSE);
+ // return (FALSE);
}
}
else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
cell->rbgSize);
sfrPool->adjCCPool->bw -= addtnlPRBs;
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced))
{
*sfrpoolInfo = sfrCEPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else if(allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
{
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Check if CE and CC boundary has unallocated prbs */
else if ((sfrPool->poolstartRB == sfrPool->type2Start) &&
sfrCEPool->type0End = ((sfrCEPool->poolendRB + 1 - addtnlPRBs) / cell->rbgSize) - 1;
}
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else if ( bwAvlbl <
((sfrCEPool->bw - sfrCEPool->bwAlloced) +
allocInfo->tbInfo[0].bytesReq =
rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
if (allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
{
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
{
dlSf->sfrTotalPoolInfo.ccBwFull = TRUE;
}
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
allocInfo->tbInfo[0].bytesReq =
rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
*sfrpoolInfo = poolWithMaxAvlblBw;
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
if (n == NULLP)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
}
}
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif
#endif /* end of ifndef LTE_TDD*/
{
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
/* Check if type0 allocation can cater to this RETX requirement */
if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
else
{
/* cannot allocate same number of required RBs */
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
if(allocInfo->rbsReq <= (((dlSf->type0End - dlSf->type2End + 1)*\
cell->rbgSize) - dlSf->lstRbgDfct))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
/* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB
* allocation in TDD when requested RBs are more than available RBs*/
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/* Fix: Number of RBs in case of RETX should be same as
* that of initial transmission. */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
allocInfo->rnti);
printf ("RB Alloc failed for LAA TB type 0\n");
- RETVALUE(FALSE);
+ return (FALSE);
}
- RETVALUE(TRUE);
+ return (TRUE);
}
}
else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
{
if (allocInfo->rbsReq <= (dlSf->bw - dlSf->bwAlloced))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
/* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB
* allocation in TDD when requested RBs are more than available RBs*/
{
printf ("RB Alloc failed for LAA TB type 2\n");
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
/* Fix: Number of RBs in case of RETX should be same as
* that of initial transmission. */
- RETVALUE(TRUE);
+ return (TRUE);
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif
/* LTE_ADV_FLAG_REMOVED_START */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
n = cmLListNext(l);
if(n)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
/*MS_FIX for ccpu00123918*/
dlSf->type2Start += numRb;
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnBuildRntpInfo():"
"rntpPtr can't be NULLP (Memory Allocation Failed)");
- RETVALUE(RFAILED);
+ return RFAILED;
}
while(rbPtrStartIdx <= rbPtrEndIdx)
/* dsfr_pal_fixes ** 25-March-2013 ** SKS ** Adding Debug logs to print RNTP */
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
sfrPool->bwAlloced += numRb;
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
{
*isDlBwAvail = FALSE;
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX || dlUe->proc->tbInfo[1].isAckNackDtx)
if (!(allocInfo->pdcch))
{
/* Returning ROK since PDCCH might be available for another UE and further allocations could be done */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
dlSf->bwAlloced += allocInfo->rbsReq;
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif
/* LTE_ADV_FLAG_REMOVED_END */
"5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
ue->ueId);
printf("5GTF_ERROR vrbg allocated > 25\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX
"5GTF_ERROR : PDCCH allocation failed :ue (%u)",
ue->ueId);
printf("5GTF_ERROR PDCCH allocation failed\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef RG_5GTF
//maxPrb = RGSCH_MIN((allocInfo->vrbgReq * MAX_5GTF_VRBG_SIZE), ue5gtfCb->maxPrb);
allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef RGR_V1
(allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
#endif
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Retrieve PDCCH */
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if (!(allocInfo->pdcch))
{
/* Returning RFAILED since PDCCH not available for any CCCH allocations */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update allocation information */
/* ccpu00131941 - bwAlloced is updated from SPS bandwidth */
- RETVALUE(ROK);
+ return ROK;
}
#endif
"5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
raCb->ue->ueId);
printf("5GTF_ERROR vrbg allocated > 25\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef LTEMAC_SPS
#endif
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if (!(allocInfo->pdcch))
{
/* Returning RFAILED since PDCCH not available for any CCCH allocations */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef RG_5GTF
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
{
riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
}
- RETVALUE(riv);
+ return (riv);
} /* rgSCHCmnCalcRiv */
#ifdef LTE_TDD
sizeof(RgSchTddRachRspLst));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
for(sfnIdx=raArrSz-1; sfnIdx>=0; sfnIdx--)
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
/**
ueDl->laCb[cwIdx].deltaiTbs = 0;
}
- RETVALUE(iTbs);
+ return (iTbs);
}
\f
/**
if ((cellSch->dl.isDlFreqSel) && (ue->txModeTransCmplt))
{
*raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciRAType;
- RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
+ return (rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
}
else
{
*raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciRAType;
- RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
+ return (rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
}
}
{
TRC2(rgSCHCmnDlTM3PrecInf2);
- RETVALUE(0);
+ return (0);
}
\f
{
precIdx = (ueDl->mimoInfo.pmi < 2)? 0:1;
}
- RETVALUE(precIdx);
+ return (precIdx);
}
\f
{
precIdx = 1;
}
- RETVALUE(precIdx);
+ return (precIdx);
}
\f
precInfoBaseIdx += 1;
precIdx = precInfoBaseIdx + (numTxLyrs-1)*17;
}
- RETVALUE(precIdx);
+ return (precIdx);
}
\f
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* DwPTS Scheduling Changes Start */
/* Avoid re-transmission on Normal SF when the corresponding TB wss transmitted on SPCL SF */
if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
#endif
#endif
/* Avoid re-transmission on Normal SF when the corresponding TB wss tranmitted on SPCL SF */
if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
#endif
#endif
if (txSfType > curSf->sfType)
{
/* Avoid retx */
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Allow Retx */
- RETVALUE(FALSE);
+ return (FALSE);
}
#else
if ((subFrm->bwAssigned < cell->pbchRbEnd) &&
(((subFrm->bwAssigned + reqRbs) - cell->pbchRbStart) > 0))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif
/* Check for DL BW exhaustion */
if (subFrm->bw <= subFrm->bwAssigned)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Call TM specific RB allocation routine */
(dlAllocRetxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/* Update the subframe Allocated BW field */
subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
- RETVALUE(ROK);
+ return ROK;
}
\f
{
RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHCmnDlAllocRb(): UEs max allocation exceed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
noLyr1 = ueDl->mimoInfo.cwInfo[0].noLyr;
#ifdef LTE_ADV
if (ROK != rgSCHLaaCmn2TBPrbCheck(allocInfo, tb1Sz, tb2Sz, boTmp, effBo, iTbs1, iTbs2, numRb, proc))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*numRbRef = (U8)numRb;
- RETVALUE(ROK);
+ return ROK;
}
\f
if(*numRb <= 3)
{
RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if ((S16)*numRb > availBw)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the subframe Allocated BW field */
subFrm->bwAssigned += *numRb;
*effBo = reTxTb->tbSz + tb2Sz;
- RETVALUE(ROK);
+ return ROK;
}
\f
if(*numRb <= 3)
{
RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the subframe Allocated BW field */
subFrm->bwAssigned += *numRb;
- RETVALUE(ROK);
+ return ROK;
}
\f
*numRb = tbInfo->dlGrnt.numRb;
if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the subframe Allocated BW field */
subFrm->bwAssigned += *numRb;
0, imcs, tbInfo, tbInfo->numLyrs);
*effBo = tbInfo->tbSz;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTEMAC_SPS
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
"allocate memory for sending StaInd CRNTI:%d",ue->ueId);
- RETVALUE(retVal);
+ return (retVal);
}
/* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
#endif
retVal = rgSCHUtlFillSndStaInd(cell, ue, staInfo,
ue->cqiReptCfgInfo.numColltdCqiRept);
- RETVALUE(retVal);
+ return (retVal);
}
- RETVALUE(ROK);
+ return ROK;
} /* End of rgSCHCmnUeDlPwrCtColltCqiRept */
#endif /* End of RGR_CQI_REPT */
{
/* 80 is the minimum SI periodicity in sf. Also
* all other SI periodicities are multiples of 80 */
- RETVALUE (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
+ return (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
}
#ifdef LTE_TDD
/**
}
*rb = numDwPtsRb;
- RETVALUE(tbSz/8);
+ return (tbSz/8);
}
/**
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
if(((cmnDlCell->ncsgPrbCnt * 100) / cmnDlCell->totPrbCnt) < cell->minDlResNonCsg)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
if (((cmnUlCell->ncsgPrbCnt * 100) /cmnUlCell->totPrbCnt) < cell->minUlResNonCsg)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
break;
}
- RETVALUE(pcqiSz);
+ return (pcqiSz);
}
/** @brief DL scheduler for SPS, and all other downlink data
/* Initialize ue list */
if ((ret = rgSCHDbmInitUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#ifdef LTE_TDD
if ((ret = rgSCHDbmInitUeTfuPendLst(cellCb,
RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#endif
#ifdef LTEMAC_SPS
/* Initialize SPS Ue list */
if ((ret = rgSCHDbmInitSpsUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#endif /* LTEMAC_SPS */
/* Initialize BCCH/PCCH logical channels */
cmLListInit(&cellCb->l2mList);
#endif /* LTE_L2_MEAS */
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDbmInitCell */
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
- RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
+ return (cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool));
{
TRC2(rgSCHDbmDeInitUeCbLst)
- RETVALUE(cmHashListDeinit(&cellCb->ueLst));
+ return (cmHashListDeinit(&cellCb->ueLst));
} /* rgSCHDbmDeInitUeCbLst */
RgSchUeCb ue;
TRC2(rgSCHDbmInitSpsUeCbLst)
- RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
+ return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool));
{
TRC2(rgSCHDbmDeInitSpsUeCbLst)
- RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
+ return (cmHashListDeinit(&cellCb->spsUeLst));
} /* rgSCHDbmDeInitSpsUeCbLst */
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
- RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCellInfo,
+ return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCellInfo,
(U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
} /* rgSCHDbmInsUeCb */
{
TRC2(rgSCHDbmInsSpsUeCb)
- RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
+ return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
(U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
} /* end of rgSCHDbmInsSpsUeCb */
cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCellInfo);
- RETVALUE(!ueCellInfo?NULLP:ueCellInfo->ue);
+ return (!ueCellInfo?NULLP:ueCellInfo->ue);
} /* rgSCHDbmGetUeCb */
#ifdef LTEMAC_SPS
cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
- RETVALUE(ueCb);
+ return (ueCb);
} /* rgSCHDbmGetSpsUeCb */
#endif
}
cmHashListGetNext(&cellCb->ueLst, (PTR) ueCellInfo, (PTR *)&nextUeCellInfo);
- RETVALUE(!nextUeCellInfo?NULLP:nextUeCellInfo->ue);
+ return (!nextUeCellInfo?NULLP:nextUeCellInfo->ue);
} /* rgSCHDbmGetNextUeCb */
#ifdef LTEMAC_SPS
TRC2(rgSCHDbmGetNextSpsUeCb)
cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
- RETVALUE(nextUeCb);
+ return (nextUeCb);
} /* end of rgSCHDbmGetNextSpsUeCb */
#endif /* LTEMAC_SPS */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmDelL2MUe */
#endif
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
- RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCellInfo));
+ return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCellInfo));
} /* rgSCHDbmDelUeCb */
#ifdef LTEMAC_SPS
{
TRC2(rgSCHDbmDelSpsUeCb)
- RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
+ return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
} /* end of rgSCHDbmDelSpsUeCb */
#endif /* LTEMAC_SPS */
/* Initialize Dedicated logical channels */
rgSCHDbmInitDedLcLst(ueCb);
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDbmInitUe */
/**
if (idx < RGSCH_DEDLC_MIN_LCID || idx > RGSCH_DEDLC_MAX_LCID)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
- RETVALUE(ueCb->dl.lcCb[idx-1]);
+ return (ueCb->dl.lcCb[idx-1]);
} /* rgSCHDbmGetDlDedLcCb */
{
if(ueCb->dl.lcCb[idx])
{
- RETVALUE(ueCb->dl.lcCb[idx]);
+ return (ueCb->dl.lcCb[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetFirstDlDedLcCb */
/**
* @brief Handler for accessing the existing next dl dedicated lcCb at idx
if (!lcCb)
{
- RETVALUE(rgSCHDbmGetFirstDlDedLcCb(ueCb));
+ return (rgSCHDbmGetFirstDlDedLcCb(ueCb));
}
for(idx = lcCb->lcId; idx < RGSCH_DEDLC_MAX_LCID; idx++)
{
if(ueCb->dl.lcCb[idx])
{
- RETVALUE(ueCb->dl.lcCb[idx]);
+ return (ueCb->dl.lcCb[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetNextDlDedLcCb */
/**
{
if(cellCb->cmnLcCb[idx].lcId == lcId)
{
- RETVALUE(&(cellCb->cmnLcCb[idx]));
+ return (&(cellCb->cmnLcCb[idx]));
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetCmnLcCb */
/**
if(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX]));
+ return (&(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetBcchOnBch */
/**
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1]));
+ return (&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetFirstBcchOnDlsch */
/**
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2]));
+ return (&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetSecondBcchOnDlsch */
/**
if(cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_PCCH_IDX]));
+ return (&(cellCb->cmnLcCb[RGSCH_PCCH_IDX]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetPcch */
/**
{
if(((RgSchRaCb *)tmpNode->node)->tmpCrnti == key)
{
- RETVALUE((RgSchRaCb *)(tmpNode->node));
+ return ((RgSchRaCb *)(tmpNode->node));
}
CM_LLIST_NEXT_NODE(&cellCb->raInfo.raCbLst,tmpNode);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetRaCb */
#ifndef LTE_TDD
if(!cfgElem)
{
- RETVALUE( cellCb->rgCfgInfo.crntRgrCfgLst.first ?
+ return ( cellCb->rgCfgInfo.crntRgrCfgLst.first ?
(RgSchCfgElem *)(cellCb->rgCfgInfo.crntRgrCfgLst.first->node) : NULLP );
}
- RETVALUE( cfgElem->cfgReqLstEnt.next ?
+ return ( cfgElem->cfgReqLstEnt.next ?
(RgSchCfgElem *)(cfgElem->cfgReqLstEnt.next->node) : NULLP );
} /* rgSCHDbmGetNextCrntRgrCfgElem */
if(!cfgElem)
{
- RETVALUE( cellCb->rgCfgInfo.pndngRgrCfgLst.first ?
+ return ( cellCb->rgCfgInfo.pndngRgrCfgLst.first ?
(RgSchCfgElem *)(cellCb->rgCfgInfo.pndngRgrCfgLst.first->node) : NULLP );
}
- RETVALUE( cfgElem->cfgReqLstEnt.next ?
+ return ( cfgElem->cfgReqLstEnt.next ?
(RgSchCfgElem *)(cfgElem->cfgReqLstEnt.next->node) : NULLP );
} /* rgSCHDbmGetNextPndngRgrCfgElem */
if((((RgSchCfgElem *)tmpNode->node)->actvTime.sfn == key.sfn) &&
(((RgSchCfgElem *)tmpNode->node)->actvTime.slot == key.slot))
{
- RETVALUE((RgSchCfgElem *)(tmpNode->node));
+ return ((RgSchCfgElem *)(tmpNode->node));
}
CM_LLIST_NEXT_NODE(&cellCb->rgCfgInfo.pndngRgrCfgLst,tmpNode);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetPndngRgrCfgElemByKey */
/**
if(cmLListDelFrm(&cellCb->rgCfgInfo.crntRgrCfgLst,&cfgElem->cfgReqLstEnt))
{
- RETVALUE((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
+ return ((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmDelCrntRgrCfgElem */
/**
if(cmLListDelFrm(&cellCb->rgCfgInfo.pndngRgrCfgLst,&cfgElem->cfgReqLstEnt))
{
- RETVALUE((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
+ return ((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmDelPndngRgrCfgElem */
/**
if(rgSCHUtlAllocSBuf(cellCb->instIdx,
(Data **)&cellCb->rntiDb.rntiPool,maxRntis*sizeof(RgSchRntiLnk)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellCb->rntiDb.rntiStart = rntiStart;
cellCb->rntiDb.maxRntis = maxRntis;
cellCb->rntiDb.lastRnti = &rntiPool[idx];
}
cellCb->rntiDb.freeRnti = &rntiPool[0];
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmRntiDbInit */
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI exhausted count:%d",
cellCb->rntiDb.count);
- RETVALUE(NULLP);
+ return (NULLP);
}
rntiLnk = cellCb->rntiDb.freeRnti;
cellCb->rntiDb.count--;
printf("rgSCHDbmGetRnti::rntiLnk->rnti %u\n",rntiLnk->rnti);
- RETVALUE(rntiLnk);
+ return (rntiLnk);
} /* rgSCHDbmGetRnti */
/**
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmInitUeTfuPendLst */
cmHashListDeinit(&cellCb->ueTfuPendLst);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmDeInitUeTfuPendLst */
#endif
{
RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHDhmHqEntInit hqE alloc fail");
- RETVALUE(NULLP);
+ return (NULLP);
}
#ifdef LTE_TDD
/* Init the HARQ processes */
{
RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHDhmHqEntInit hqP alloc fail in hqE");
- RETVALUE(NULLP);
+ return (NULLP);
}
#else
hqE->numHqPrcs = RGSCH_NUM_DL_HQ_PROC;
hqE->cell = cell;
/* CA Dev End*/
- RETVALUE(hqE);
+ return (hqE);
} /* rgSCHDhmHqEntInit */
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDhmGetAvlHqProc hqE NULL ue %d"
, ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
"rgSCHDhmGetAvlHqProc free %ld inUse %ld ue %d"
, hqE->free.count, hqE->inUse.count, ue->ueId);
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
tmpHqProc = (RgSchDlHqProcCb *)(tmp->node);
if (!tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
tmpHqProc->itbsAtEstimate[1] = 0;
tmpHqProc->prbAtEstimate = 0;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetAvlHqProc */
* until RACH procedure is completed */
if ((hqE == NULLP) || (hqE->inUse.last == NULLP))
{
- RETVALUE(NULLP);
+ return (NULLP);
}
- RETVALUE((RgSchDlHqProcCb *)hqE->inUse.last->node);
+ return ((RgSchDlHqProcCb *)hqE->inUse.last->node);
} /* rgSCHDhmLastSchedHqProc */
#ifdef RGR_V1
if (NULLP == tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Remove the element from the free Queue and */
//cmLListAdd2Tail(&hqE->inUse, &tmpHqProc->lnk);
rgSCHDhmHqPAdd2InUseLst(tmpHqProc);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetCcchSduHqProc */
#endif
if (NULLP == tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Remove the element from the free Queue and */
tmpHqProc->tbInfo[0].timingInfo = timingInfo;
hqE->msg4Proc = tmpHqProc;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetMsg4HqProc */
/**
/* Pick the proc based on the index provided */
*hqP = &(hqE->procs[idx]);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetHqProcFrmId */
/**
if (NULLP == tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(NULLP);
+ return (NULLP);
}
idx = ((timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + timingInfo.slot)/
if (!tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(NULLP);
+ return (NULLP);
}
hqProc->tbInfo[0].timingInfo = timingInfo;
rgSCHLaaResetDlHqProcCb(hqProc);
#endif
- RETVALUE(hqProc);
+ return (hqProc);
} /* rgSCHDhmSpsDlGetHqProc */
#endif /* LTEMAC_SPS */
tbStrtIdx[*cntHqPrcs] = 0;
numTbs[*cntHqPrcs] = 1;
(*cntHqPrcs)++;
- RETVALUE(ROK);
+ return ROK;
}
}
ascIdx = rgSchTddDlAscSetIdxKTbl[cell->ulDlCfgIdx][timeInfo.slot];
}
- RETVALUE(ROK);
+ return ROK;
}
#else /* LTE_TDD */
/** * @brief Handler for fetching Harq Proc given the timming information.
if (RGSCH_TIMEINFO_SAME(hqE->msg4Proc->tbInfo[0].timingInfo, timeInfo))
{
*isMsg4 = TRUE;
- RETVALUE(hqE->msg4Proc);
+ return (hqE->msg4Proc);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
{
err->errType = RGSCHERR_DHM_FDBK_IND;
err->errCause = RGSCHERR_DHM_FDBK_IND_INVALID_CB;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ccpu00147469 : This code is moved below as here this code always try to
{
RGSCHDBGINFO(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),
"Ack Rcvd. No Ack/Nack feedback available \n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ue->ueId,timeInfo.sfn, timeInfo.slot);
err->errType = RGSCHERR_DHM_FDBK_IND;
err->errCause = RGSCHERR_DHM_FDBK_IND_INVALID_CB;
- RETVALUE(RFAILED);
+ return RFAILED;
}
*/
}/*if(hqCnt==0)*/
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
//#endif /* LTEMAC_SPS */
{
if((rgSCHDhmProcHqFdbkAckNackRep(hqP,sf,tbCnt,&isAck)) != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
else
{
rgSCHDhmFdbkIndHndlTa(hqP, tbCnt, isAck, maxHqRetxReached);
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhmPrcFdbkForTb */
/** * @brief Function to decode the position of HarqFb for eachCell.
*
hqPCount--;
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhm5gtfHqFdbkInd */
/** * @brief Handler for HARQ feedback received for DL transmission.
"CRNTI:%d NO HARQ proc available for feedback: TimingInfo: "
"sfn %d slot %d", ue->ueId, timingInfo.sfn,
timingInfo.slot);
- RETVALUE(RFAILED);
+ return RFAILED;
}
isAck[0] = fdbk->isAck[0];
/* Remove release PDCCH from the subframe */
rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, sf->relPdcch);
sf->relPdcch = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
}
}
node = node->next;
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhmHqFdbkInd */
#endif /* LTE_FDD */
if(tbInfo->numLch >= RGSCH_MAX_NUM_DED_LC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
tbInfo->lchSchdDataArr[tbInfo->numLch] = *lchData;
tbInfo->numLch++;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmAddLcData */
RGSCHDECRFRMCRNTTIME(uciTimingInfo, dlSfTime, ascIdx.subfrmNum[i]);
rgSCHUtlDlRlsSubFrm(cellCb, dlSfTime);
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHDhmTddRlsSubFrm */
#ifdef TFU_TDD
#endif
if(anInfo == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCH_NULL_CHECK(cellCb->instIdx, nxtDlsf);
RGSCH_UPD_HQAN_FDBKTIME(tbCb, nxtDlsf, nxtfrm);
}
}
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHDhmRlsDlsfHqProc */
#else /* ifdef LTE_TDD */
/**
}
/*CA Dev End*/
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmRlsDlsfHqProc */
#endif
#ifdef LTEMAC_SPS
/* Pick the proc based on the index provided */
rgSCHDhmGetHqProcFrmId(ue->cell, ue, idx, &hqP);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmMarkSpsHqProc */
#endif /* RG_UNUSED */
#endif /* LTEMAC_SPS */
/* Update timingInfo for this hqP so that next subframe its picked up */
RG_SCH_ADD_TO_CRNT_TIME(hqP->tbInfo[tbCnt].timingInfo, \
hqP->tbInfo[tbCnt].timingInfo, 1);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Take decision here based on the number
hqP->tbInfo[tbCnt].isAckNackDtx = *isAck;
- RETVALUE(ROK);
+ return ROK;
}
#endif /* ifndef LTE_TDD */
RgSchMacRlsHq(&pst, rlsHqInfo);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef DL_LA
*/
rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
(*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
[ueDl->mimoInfo.cwInfo[tbCnt].iTbs[1]];
- RETVALUE(ROK);
+ return ROK;
}
#endif
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
rgSCHDrxTtiHdlOnDurUl(cell, ulIndex);
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxTtiHdlOnDur*/
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisDl->rgSCHDlInactvtUes(cell,&dlInactvLst);
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxTtiHdlInActv*/
/** @brief This function handles the per TTI processing for DRX short cycle
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
rgSCHDrxMvToNxtOnDurOcc(cell,ue,RG_SCH_DRX_DL_DELTA,TRUE);
}/*while(node)...*/
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxTtiHdlShortCycle*/
#if ( ERRCLASS & ERRCLS_INT_PAR)
if ( cell == (RgSchCellCb *)NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /*ERRCLASS & ERRCLS_INT_PAR*/
rgSCHDrxTtiHdlUlHarqRTT(cell, ulIndex);
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function is called by the common scheduler as part of
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue == (RgSchUeCb* )NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDrxUeCfg():"
"Invalid params.cell or ue or ueCfg is NULL ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED for DRX UECB CRBTI:%d",ue->ueId);
- RETVALUE(ret);
+ return (ret);
}
ueDrxCb = ue->drxCb;
ueDrxCb->shortCycleEnt.node = (PTR)ue;
}
- RETVALUE(ret);
+ return (ret);
} /* end of rgSCHDrxUeCfg */
/** @brief This function gets the next occurance of onDurationTimer from the
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if( (drxCb == (RgSchDrxUeCb* )NULLP)
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDrxGetNxOnDur():Invalid params."
"cell/drxCb/nxtOnDur is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
nxtOnDur->sfn = (U16)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
nxtOnDur->slot = (U16)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHDrxGetNxtOnDur */
/** @brief This function is a utility function to copy the UE configuration from
(drxCfg == (RgrUeDrxCfg* )NULLP)
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
ueCb->shortDrxCycle = drxCfg->drxShortDrx.shortDrxCycle;
ueCb->shortCycleTmrLen = drxCfg->drxShortDrx.drxShortCycleTmr;
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHDrxCpyUeCfg */
#ifdef RGR_V2
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHdrxUeReCfg():""Memory allocation FAILED for DRX UE Cb CRNTI:%d",
ue->ueId);
- RETVALUE(ret);
+ return (ret);
}
ue->isDrxEnabled = TRUE; /* sachin */
}
if( ue->drxCb == NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDrxCb = ue->drxCb;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHDrxUeReCfg */
#endif
ueDrxCb->drxDlInactvMask = DRX_UE_INACTIVE;
ueDrxCb->drxUlInactvMask = DRX_UE_INACTIVE;
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxUeDel*/
/** @brief This function is called at the time of RGR cell configuration.
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDrxCellCfg():Invalid Params. cell/cellCfg is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHDrxCellCfg():"
"Memory allocation FAILED for DRX cell Cb");
- RETVALUE(ret);
+ return (ret);
}
/* delInUlScan determines which index scans the queue last.
cell->drxCb->delInUlScan = TRUE;
}
- RETVALUE(ret);
+ return (ret);
} /* end of rgSchDrxCellCfg */
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
- RETVALUE(ROK);
+ return ROK;
}
if( (ue == (RgSchUeCb* )NULLP))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDrxSrInd():Invalid Params. cell/ue is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* KWork fix - shifted this down */
/* Update UE's inactive mask and if required move UE to ACTIVE state */
RG_SCH_CMN_UL_UPDT_INACTV_MASK( cell, ue, RG_DRX_INACTIVE);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDrxSrInd */
(tmrExpryIdx == (CmLteTimingInfo* )NULLP)
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tmrExpryIdx->sfn = tmrExpryIdx->sfn - (RG_SCH_CMN_MAX_SFN_NUM + 1);
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxGetNxtTmrExpry*/
/** @brief This function calculates the next onDuration Occurence
if(((RGSCH_MAX_SUBFRM_5G + endTimeInSf- startTime) % RGSCH_MAX_SUBFRM_5G) >=
drxCycle)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
startTime = (startTime + drxCycle);
}while((drxCycle % RGSCH_NUM_SUB_FRAMES) &&
(startTime < (drxCycle * RGSCH_NUM_SUB_FRAMES/2)));
- RETVALUE(ROK);
+ return ROK;
}
#endif /*LTE_TDD */
RGSCH_FREE_MSG(mBuf);
break;
}
- SExitTsk();
- RETVALUE(ROK);
+ ODU_EXIT_TASK();
+ return ROK;
}/* end of schActvTsk */
\f
{
ret = rgSCHGomCfgReq (pst->region, pst->pool, instCb,
transId, cfgReqInfo);
- RETVALUE(ret);
+ return (ret);
}
/* Fetch the cell Id for the recieved request */
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Extract the cell and Enquee Config Request */
if(NULLP != instCb->rgrSap[spId].cell)
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell = instCb->rgrSap[spId].cell;
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
(Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}/* rgSCHGomHndlCfg */
printf("\n AT MAC RGR cfg cfm sent\n");
#endif
- RETVALUE(ret);
+ return (ret);
} /* rgSCHGomCfgReq */
ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
if ((ret != ROK) || ((U8 *)rgrCfgElem == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize the configuration element */
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
- RETVALUE(RFAILED);
+ return RFAILED;
}
sfDiff = RGSCH_CALC_SF_DIFF(actvTime, cell->crntTime);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (sfDiff)
rgrCfgElem->actvTime = actvTime;
rgSCHDbmInsPndngRgrCfgElem(cell, rgrCfgElem);
/* Cfm to be sent only after applying request */
- RETVALUE(ROK);
+ return ROK;
}
}
/* Add to current cfgReq list */
rgSCHDbmInsCrntRgrCfgElem(cell, rgrCfgElem);
/* Cfm to be sent only after applying request */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHGomEnqCfgReq */
rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
}
- RETVALUE(ROK);
+ return ROK;
}
{
RLOG1(L_ERROR,"Rgr Cell configuration "
"validation FAILED: Cell %d", cfg->u.cellCfg.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrCellCfg(instCb, spId, &cfg->u.cellCfg, errInfo);
break;
{
RLOG1(L_ERROR,"Ue configuration validation"
" FAILED: CRNTI:%d", cfg->u.ueCfg.crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrUeCfg(cell, &cfg->u.ueCfg, errInfo);
break;
{
RLOG1(L_ERROR,"LC configuration validation "
"FAILED: LCID:%d", cfg->u.lchCfg.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrLchCfg(cell, ue, &cfg->u.lchCfg, errInfo);
break;
{
RLOG1(L_ERROR,"LCG configuration validation "
"FAILED: LCGID:%d", cfg->u.lcgCfg.ulInfo.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrLcgCfg(cell, ue, &cfg->u.lcgCfg, errInfo);
break;
{
RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCH ENB configuration validation "
"FAILED: \n" ));
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrSchedEnbCfg(inst, spId, &cfg->u.schedEnbCfg, errInfo);
break;
RLOG1(L_ERROR,"Should never come here: "
"cfgType %d", cfg->cfgType);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHGomHndlCfgReq */
#ifdef LTE_ADV
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UE: does not exist\n",
sCellActDeactEvnt->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx = 0; idx < sCellActDeactEvnt->numOfSCells; idx++)
RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCell Actication failed"
"for UE [%d] with SCellIdx [%d]\n",
sCellActDeactEvnt->crnti, idx));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RGSCHDBGINFO(inst,(rgSchPBuf(inst), "RGR Reconfiguration processed\n"));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHGomHndlSCellActDeactReq */
#endif /* LTE_ADV */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,recfg->u.cellRecfg.cellId,"Rgr Cell Recfg Validation "
"FAILED");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrCellRecfg(cell, &recfg->u.cellRecfg, errInfo);
break;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.ueRecfg.cellId,"Ue Recfg Validation FAILED"
"OLD CRNTI:%d",recfg->u.ueRecfg.oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrUeRecfg(cell, ue, &recfg->u.ueRecfg, errInfo);
break;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lchRecfg.cellId,"Lc Recfg Validation FAILED"
"LCID:%d",recfg->u.lchRecfg.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrLchRecfg(cell, ue, dlLc, &recfg->u.lchRecfg, errInfo);
break;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lcgRecfg.cellId, "Lcg Recfg Validation FAILED"
"LCGID:%d",recfg->u.lcgRecfg.ulRecfg.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrLcgRecfg(cell, ue, &recfg->u.lcgRecfg, errInfo);
break;
#if(ERRCLASS & ERRCLS_INT_PAR)
RLOG1(L_ERROR,"Should never come here: recfgType %d", recfg->recfgType);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHGomHndlRecfgReq */
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset Validation FAILED"
"CRNTI:%d",reset->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHCfgRgrUeReset(cell, ue, reset, errInfo);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset FAILED"
"CRNTI:%d",reset->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHGomHndlResetReq */
if(instCb->rgrSap[spId].cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Cell doesnt exist");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Process the delete request */
#if(ERRCLASS & ERRCLS_INT_PAR)
RLOG1(L_ERROR,"Should never come here: delType %d", del->delType);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHGomHndlDelReq */
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
} /* End of Switch */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHGomGetCellIdFrmCfgReq */
#ifdef RGR_SI_SCH
SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*Validate the received SI configuration */
SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*ccpu00140789: Stopping SI scheduling*/
if(RGR_SI_STOP == cfgReqInfo->cfgType)
cfgReqInfo = NULLP;
cfmStatus = RGR_CFG_CFM_OK;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
- RETVALUE(ROK);
+ return ROK;
}
else
{
SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8*)padding,(U8)0,nmPadBytes);
padding = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
padding = NULLP;
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
cell->siCb.newSiInfo.sib1Info.sib1,
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Si recfg, where numSi changes */
if (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* No need to wait for Modification period boundary */
cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
cfgReqInfo = NULLP;
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHGomHndlSiCfg */
warningSiCfgReqInfo = NULLP;
rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Search for free index in WarningSi */
warningSiCfgReqInfo = NULLP;
rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId,
siId, transId,cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
warningSiCfgReqInfo = NULLP;
rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
sizeof(RgrWarningSiCfgReqInfo));
warningSiCfgReqInfo = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
\f
{
sfrCCPool->pwrHiCCRange.endRb = loadInfReq->rgrCcPHighEndRb;
sfrCCPool->pwrHiCCRange.startRb = loadInfReq->rgrCcPHighStartRb;
- RETVALUE(ROK);
+ return ROK;
}
else
{
n = cmLListNext(l);
}
}
- RETVALUE(ret);
+ return (ret);
}
/**
* @brief Handler to handle LOAD INF request from RRM to MAC.
RLOG_ARG1(L_ERROR,DBG_CELLID,loadInfReq->cellId,"Cell Control block does not exist"
"for load cellId:%d",loadInfReq->cellId);
SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell->lteAdvCb.dsfrCfg.status == RGR_DISABLE)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHGomHndlLoadInf(): DSFR Feature not enabled");
SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate the received LOAD INF Configuration */
ret = rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, &errInfo);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Rgr LOAD INF Configuration "
"validation FAILED");
SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the RNTP info rcvd in the respective cell centre pool so that Phigh can be
sent for the UEs scheduled in that particular RB range*/
{
if((rgSchUpdtRNTPInfo(cell, cell->subFrms[i], loadInfReq) != ROK))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHGomHndlLoadInf */
/* LTE_ADV_FLAG_REMOVED_END */
\f
* @param[in] RgSchUeCb *ue
* @param[in] Bool *hdFddEnbl
*
- * @RETVALUE S16
+ * @return S16
* -# ROK
* -# RFAILED
*/
"rgSCHHdFddUeCfg(): HD-FDD already enabled for this UE"
"CRNTI:%d",ueCb->ueId);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"rgSCHHdFddUeCfg(): Could'nt do HDFDD cfg, SPS already configured"
"CRNTI:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"rgSCHHdFddUeCfg(): Could not allocate memory for hd-fdd ueCb"
"CRNTI:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHHdFddUeCfg*/
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
*
- * @RETVALUE( S16
+ * @return ( S16
* -# ROK
*
*/
ueCb->hdFddEnbld = FALSE;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHHdFddUeDel */
* instance updates
* for HD FDD UEs
* @param[in] RgSchCellCb *cell
- * @RETVALUE None
+ * @return None
*/
#ifdef ANSI
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
*
- * @RETVALUE None
+ * @return None
*
*/
#ifdef ANSI
*
* @param[in] RgSchUeCb *ue
*
- * @RETVALUE None
+ * @return None
*
*/
* @param[out] U8 *allow -- TRUE is allowed or FALSE if no allowedi.
* Valdity of this pointer is not done in this function.
*
- * @RETVALUE None
+ * @return None
*/
#ifdef ANSI
PUBLIC Void rgSCHCmnHdFddUpdULMark
* @param[out] U8 *allow -- TRUE is allowed or FALSE if no allowed.
* Valdity of this pointer is not done in this function
*
- * @RETVALUE None
+ * @return None
*/
#ifdef ANSI
* @param[in] timeInfo timing information subframe of interest
* @param[in] offsest Offest with w.r.t which SFN has to be determined
*
- * @RETVALUE None
+ * @return None
*/
#ifdef ANSI
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef MS_MBUF_CORRUPTION
if(SAddPstMsgMult((Data *)ueDelInd, sizeof(RgInfUeDelInd), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFUEDELIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if(SRemPreMsgMult((Data *)&ueDelInd, sizeof(RgInfUeDelInd), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &ueDelInd));
+ return ((*func)(pst, &ueDelInd));
}
/*Fix: end: Inform UE delete to scheduler*/
TRC2(cmPkMacSchDedBoUpdtReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef MS_MBUF_CORRUPTION
if(SAddPstMsgMult((Data *)boRpt, sizeof(RgInfDedBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFDEDBOUPDTREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfDedBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &boRpt));
+ return ((*func)(pst, &boRpt));
}
/**
* @brief Request from RLC to MAC for forwarding SDUs on
TRC2(cmPkMacSchCmnBoUpdtReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef MS_MBUF_CORRUPTION
if(SAddPstMsgMult((Data *)boRpt, sizeof(RgInfCmnBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFCMNBOUPDTREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
if(SRemPreMsgMult((Data *)&boRpt, sizeof(RgInfCmnBoRpt), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &boRpt));
+ return ((*func)(pst, &boRpt));
}
/**
* @brief Request from RLC to MAC for forwarding SDUs on
TRC2(cmPkMacSchSfRecpInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)datInd, mBuf) != ROK)
+ if(oduPackPointer((PTR)datInd, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFSFRECPIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
TRC2(cmUnpkMacSchCmnBoUpdtReq)
- if(cmUnpkPtr((PTR *)&datInd, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&datInd, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
/* Call cmFreeMem(datInd) in scheduler */
- RETVALUE((*func)(pst, datInd));
+ return ((*func)(pst, datInd));
}
#ifdef LTEMAC_SPS
TRC2(cmPkMacSchSpsRelInd)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)relInfo, mBuf) != ROK)
+ if(oduPackPointer((PTR)relInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFSPSRELIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkMacSchSpsRelInd */
/**
TRC2(cmUnpkMacSchSpsRelInd)
- if(cmUnpkPtr((PTR *)&relInfo, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&relInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, relInfo));
+ return ((*func)(pst, relInfo));
} /* end of cmUnpkMacSchSpsRelInd */
#endif /* LTEMAC_SPS */
TRC2(cmPkSchMacSfAllocReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)resAllocReq, mBuf) != ROK)
+ if(oduPackPointer((PTR)resAllocReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFSFALLOCREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
TRC2(cmUnpkSchMacSfAllocReq)
- if(cmUnpkPtr((PTR *)&resAllocReq, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&resAllocReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, resAllocReq));
+ return ((*func)(pst, resAllocReq));
}
/**
* @brief Request from SCH To MAC for harq entity reset
TRC2(cmPkSchMacRstHqEntReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)hqEntInfo, mBuf) != ROK)
+ if(oduPackPointer((PTR)hqEntInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFHQENTRESET;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
TRC2(cmUnpkSchMacRstHqEntReq)
- if(cmUnpkPtr((PTR *)&hqEntRstInfo, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&hqEntRstInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, hqEntRstInfo));
+ return ((*func)(pst, hqEntRstInfo));
}
/**
TRC2(cmPkSchMacRlsHqReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)sfHqInfo, mBuf) != ROK)
+ if(oduPackPointer((PTR)sfHqInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFRLSHQREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
TRC2(cmUnpkSchMacRlsHqReq)
- if(cmUnpkPtr((PTR *)&sfHqInfo, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&sfHqInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, sfHqInfo));
+ return ((*func)(pst, sfHqInfo));
}
/**
* @brief Request from RLC to MAC for forwarding SDUs on
TRC2(cmPkSchMacRlsRntiReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef MS_MBUF_CORRUPTION
if(SAddPstMsgMult((Data *)rlsRnti, sizeof(RgInfRlsRnti), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFRLSRNTIREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if(SRemPreMsgMult((Data *)&rlsRnti, sizeof(RgInfRlsRnti), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &rlsRnti));
+ return ((*func)(pst, &rlsRnti));
}
/**
TRC2(cmPkSchMacCellRegReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef MS_MBUF_CORRUPTION
if(SAddPstMsgMult((Data *)regReq, sizeof(RgInfCellReg), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFCELLREGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if(SRemPreMsgMult((Data *)®Req, sizeof(RgInfCellReg), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, ®Req));
+ return ((*func)(pst, ®Req));
}
/**
TRC2(cmPkSchMacLcgRegReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)lcgRegReq, sizeof(RgInfLcgRegReq), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFLCGREG;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacLcgRegReq */
/**
TRC2(cmUnpkSchMacLcgRegReq)
- if(cmUnpkPtr((PTR *)&lcgRegReq, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&lcgRegReq, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, lcgRegReq));
+ return ((*func)(pst, lcgRegReq));
} /* end of cmUnpkSchMacLcgRegReq */
#ifdef LTEMAC_SPS
TRC2(cmPkSchMacSpsLcRegReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)lcInfo, mBuf) != ROK)
+ if(oduPackPointer((PTR)lcInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFSPSLCREG;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacSpsLcRegReq */
/**
TRC2(cmPkSchMacUlSpsResetReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)ulSpsResetInfo, mBuf) != ROK)
+ if(oduPackPointer((PTR)ulSpsResetInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFSPSRESET;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacUlSpsResetReq */
/**
TRC2(cmUnpkSchMacSpsLcRegReq)
- if(cmUnpkPtr((PTR *)&lcInfo, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&lcInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, lcInfo));
+ return ((*func)(pst, lcInfo));
} /* end of cmUnpkSchMacSpsLcRegReq */
TRC2(cmUnpkSchMacUlSpsResetReq)
- if(cmUnpkPtr((PTR *)&ulSpsResetInfo, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&ulSpsResetInfo, mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, ulSpsResetInfo));
+ return ((*func)(pst, ulSpsResetInfo));
} /* end of cmUnpkSchMacUlSpsResetReq */
TRC2(cmPkSchMacSpsLcDeregReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteCellId, cellId, mBuf);
CMCHKPK(cmPkLteRnti, crnti, mBuf);
pst->event = (Event) EVTINFSPSLCDEREG;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacSpsLcDeregReq */
/**
CMCHKUNPK(cmUnpkLteCellId, &cellId, mBuf);
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, cellId, crnti));
+ return ((*func)(pst, cellId, crnti));
} /* end of cmUnpkSchMacSpsLcDeregReq */
#endif /* LTEMAC_SPS */
TRC2(cmPkSchMacL2MeasReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFL2MEASREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacL2MeasReq */
/**
TRC2(cmPkSchMacL2MeasStopReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFL2MEASSTOPREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacL2MeasStopReq */
/**
* @brief Primitive from SCH to MAC for L2 Measurement
TRC2(cmPkSchMacL2MeasSendReq)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFL2MEASSENDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkSchMacL2MeasSendReq */
/**
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasReq), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
} /* end of cmUnpkSchMacL2MeasReq */
/**
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasStopReq), mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
} /* end of cmUnpkSchMacL2MeasReq */
/**
* @brief Primitive from SCH to MAC for L2 Measurement request
if(SRemPreMsgMult((Data *)&measInfo, sizeof(RgInfL2MeasSndReq), mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
} /* end of cmUnpkSchMacL2MeasSendReq*/
/**
TRC2(cmPkMacSchL2MeasCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFL2MEASCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* end of cmPkMacSchL2MeasCfm */
TRC2(cmPkMacSchL2MeasStopCfm)
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SAddPstMsgMult((Data *)measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTINFL2MEASSTOPCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}/*cmPkMacSchL2MeasStopCfm*/
/**
* @brief Primitive from MAC to SCH for L2 Measurement Cfm
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCHINF_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, &measCfm));
+ return ((*func)(pst, &measCfm));
} /* end of cmUnpkMacSchL2MeasCfm */
/**
if(SRemPreMsgMult((Data *)&measCfm, sizeof(RgInfL2MeasCfm), mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measCfm));
+ return ((*func)(pst, &measCfm));
} /* end of cmUnpkMacSchL2MeasStopCfm */
#endif/* LTE_L2_MEAS */
measCb->dlTotalBw = 0;
measCb->ulTotalBw = 0;
- RETVALUE(ROK);
+ return ROK;
} /* rgSchFillL2MeasCfm */
/** @brief This function sends the L2 measurement confirm to LM
cfm.cfm.status = LCM_PRIM_NOK;
cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
RgMiLrgSchL2MeasCfm(pst, &cfm);
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSchL2mSndCfm */
/** @brief This function fills the LM confirmation pst structure
{
cell->l2mList.crnt = lnk;
cmLListInsCrnt(&(cell->l2mList), node);
- RETVALUE(ROK);
+ return ROK;
}
else
{
}
} /* End of While */
cmLListAdd2Tail(&(cell->l2mList), node);
- RETVALUE(ROK);
+ return ROK;
} /* rgSchL2mInsertMeasCb */
/** @brief This function calculates the Down link prb count
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSchL2mAllocMeasCb():"
"Allocation of RgSchL2MeasCb failed");
- RETVALUE(NULLP);
+ return (NULLP);
}
cmMemcpy((U8 *)&measCb->measReq, (U8 *)measInfo, sizeof(LrgSchMeasReqInfo));
RGSCHCPYTIMEINFO(cell->crntTime, measCb->startTime);
measCb->dlTotalBw = 0;
measCb->ulTotalBw = 0;
- RETVALUE(measCb);
+ return (measCb);
} /* rgSchL2mAllocMeasCb */
/**
RGSCHERR_SCH_ALLOC_FAILED);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSchL2mMeasReq():"
"Allocation of RgSchL2MeasCb failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*cmMemcpy((U8 *)&measCb->measReq, (CONSTANT U8 *)measInfo,\
sizeof(LrgSchMeasReqInfo));*/
rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
RgSchMacL2Meas(&pst, &measReq);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSchL2mMeasReq */
/**
}
}
}/* end of while */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHL2MEas */
#endif /* LTE_L2_MEAS */
/**********************************************************************
/* would never reach here */
break;
}
- RETVALUE(ret);
+ return (ret);
}
#endif
\f
arg.wait = tmrVal;
cmPlcCbTq(&arg);
- RETVALUE(ROK);
+ return ROK;
}
\f
}
- RETVALUE(ret);
+ return (ret);
}
\f
ret = RFAILED;
break;
}
- RETVALUE(ret);
+ return (ret);
}
\f
break;
case LRG_BND:
/* SAP is already bound */
- RETVALUE(ROK);
+ return ROK;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
cfmPst = rgSchCb[inst].rgSchInit.lmPst;
ret = RgMiLrgSchCntrlCfm(&cfmPst, &cntrlCfm);
- RETVALUE(ret);
+ return (ret);
}
/**
if(rgSchCb[inst].rgSchInit.usta == FALSE)
{
- RETVALUE(ROK);
+ return ROK;
}
cmMemset((U8 *)&usta, 0, sizeof(RgMngmt));
rgSchCb[inst].genCfg.ustaResp.response.mem.pool;
usta.hdr.transId = rgSchCb[inst].genCfg.ustaResp.transId;
- RETVALUE(RgMiLrgSchStaInd(&rgSchCb[inst].rgSchInit.lmPst, &usta));
+ return (RgMiLrgSchStaInd(&rgSchCb[inst].rgSchInit.lmPst, &usta));
}
\f
cmPrcTmr(&rgSchCb[schInst].tmrTqCp,
rgSchCb[schInst].tmrTq, (PFV) rgSCHLmmTmrExpiry);
- RETVALUE(ROK);
+ return ROK;
} /* end of schActvTmr */
cmInitTimers (&ue->ackNakRepCb.ackNakRepDlInactvTmr, 1);
cmInitTimers (&ue->ackNakRepCb.ackNakRepTmr, 1);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
ackNakRepCb->isAckNackEnabled = FALSE;
} /* repetition disabled in re configuration */
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function is a utility to add the UE to the correct Measurement
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHMeasGapANRepUeRecfg() Incorrect GAP Period"
"CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHMeasGapANRepUtlAddUe */
ue->measGapCb.measQLnk.node = NULLP;
break;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHMeasGapANRepUtlRmvUe */
/**
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of */
queue = &(dlSf->ueLst);
rgSchAckNackRepUtlHdlTti (cell, queue);
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function Marks the UE as ackNakRep so that Reception request
if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][ackNakTime.subframe] !=
RG_SCH_TDD_DL_SUBFRAME)
{
- RETVALUE(ROK);
+ return ROK;
}
dlSf = rgSCHUtlSubFrmGet (cell, ackNakTime);
#ifdef LTE_TDD
if(cell->ulDlCfgIdx == 5)
{
- RETVALUE(ROK);
+ return ROK;
}
rgSCHUtlGetPrevDlSfInfo(cell, ackNakTime, &ackNakTime, &repCntr);
dlSf = rgSCHUtlSubFrmGet (cell, ackNakTime);
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
#ifdef LTE_TDD
if(cell->ulDlCfgIdx == 5)
{
- RETVALUE(ROK);
+ return ROK;
}
RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, ackNakTime, TFU_DELTA);
if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][ackNakTime.subframe] !=
RG_SCH_TDD_DL_SUBFRAME)
{
- RETVALUE(ROK);
+ return ROK;
}
#else
/* Introduced timing delta for DL control in FDD */
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
}
noSubfrms += rem;
- RETVALUE(noSubfrms);
+ return (noSubfrms);
}
/**
TRC3(RgSchMacCellReg);
- RETVALUE((*RgSchMacCellRegReqMt[0])(pst, regReq));
+ return ((*RgSchMacCellRegReqMt[0])(pst, regReq));
}
/**
TRC3(RgMacSchDedBoUpdt);
- RETVALUE((*RgMacSchDedBoUpdtReqMt[0])(pst, boRpt));
+ return ((*RgMacSchDedBoUpdtReqMt[0])(pst, boRpt));
}
/**
TRC3(RgMacSchCmnBoUpdt);
- RETVALUE((*RgMacSchCmnBoUpdtReqMt[0])(pst, boRpt));
+ return ((*RgMacSchCmnBoUpdtReqMt[0])(pst, boRpt));
}
/*Fix: start: Inform UE delete to scheduler*/
TRC3(RgMacSchUeDel);
- RETVALUE((*RgMacSchUeDelIndMt[0])(pst, ueDelInd));
+ return ((*RgMacSchUeDelIndMt[0])(pst, ueDelInd));
}
/*Fix: end: Inform UE delete to scheduler*/
/**
TRC3(RgMacSchSfRecp);
- RETVALUE((*RgMacSchSfRecpIndMt[0])(pst, datInd));
+ return ((*RgMacSchSfRecpIndMt[0])(pst, datInd));
}
/**
TRC3(RgSchMacSfAlloc);
- RETVALUE((*RgSchMacSfAllocReqMt[0])(pst, resAllocReq));
+ return ((*RgSchMacSfAllocReqMt[0])(pst, resAllocReq));
}
/**
TRC3(RgSchMacRstHqEnt)
- RETVALUE((*RgSchMacRstHqEntReqMt[0])(pst, hqEntInfo));
+ return ((*RgSchMacRstHqEntReqMt[0])(pst, hqEntInfo));
}
/**
TRC3(RgSchMacRlsHq);
- RETVALUE((*RgSchMacRlsHqReqMt[0])(pst, sfHqInfo));
+ return ((*RgSchMacRlsHqReqMt[0])(pst, sfHqInfo));
}
/**
TRC3(RgSchMacRlsRnti);
- RETVALUE((*RgSchMacRlsRntiReqMt[0])(pst, rlsRnti));
+ return ((*RgSchMacRlsRntiReqMt[0])(pst, rlsRnti));
}
/**
TRC3(RgSchMacLcgReg);
- RETVALUE((*RgSchMacLcgRegReqMt[0])(pst, lcgRegReq));
+ return ((*RgSchMacLcgRegReqMt[0])(pst, lcgRegReq));
} /* end of RgSchMacLcgReg */
#ifdef LTEMAC_SPS
TRC3(RgMacSchS);
- RETVALUE((*RgMacSchSpsRelIndMt[0])(pst, relInfo));
+ return ((*RgMacSchSpsRelIndMt[0])(pst, relInfo));
} /* end of RgMacSchSpsRel */
/**
TRC3(RgSchMacSpsLcReg);
- RETVALUE((*RgSchMacSpsLcRegReqMt[0])(pst, lcInfo));
+ return ((*RgSchMacSpsLcRegReqMt[0])(pst, lcInfo));
} /* end of RgSchMacSpsLcReg */
TRC3(RgSchMacUlSpsReset);
- RETVALUE((*RgSchMacUlSpsResetMt[0])(pst, ulSpsResetInfo));
+ return ((*RgSchMacUlSpsResetMt[0])(pst, ulSpsResetInfo));
} /* end of RgSchMacUlSpsReset */
TRC3(RgSchMacSpsLcDereg);
- RETVALUE((*RgSchMacSpsLcDeregReqMt[0])(pst, cellId, crnti));
+ return ((*RgSchMacSpsLcDeregReqMt[0])(pst, cellId, crnti));
} /* end of RgSchMacSpsLcDereg */
#endif /* LTEMAC_SPS */
TRC3(RgSchMacL2Meas);
- RETVALUE((*RgSchMacL2MeasReqMt[0])(pst, measInfo));
+ return ((*RgSchMacL2MeasReqMt[0])(pst, measInfo));
} /* end of RgSchMacL2Meas */
/**
TRC3(RgSchMacL2MeasStop);
- RETVALUE((*RgSchMacL2MeasStopReqMt[0])(pst, measInfo));
+ return ((*RgSchMacL2MeasStopReqMt[0])(pst, measInfo));
} /* end of RgSchMacL2Meas */
/**
TRC3(RgSchMacL2MeasSend);
- RETVALUE((*RgSchMacL2MeasSendReqMt[0])(pst, measInfo));
+ return ((*RgSchMacL2MeasSendReqMt[0])(pst, measInfo));
} /* end of RgSchMacL2MeasSend */
/**
TRC3(RgMacSchL2Meas);
- RETVALUE((*RgMacSchL2MeasCfmMt[0])(pst, measInfo));
+ return ((*RgMacSchL2MeasCfmMt[0])(pst, measInfo));
} /* end of RgSchMacL2Meas */
/**
* @brief Request from MAC to SCH for L2 Measurement
TRC3(RgMacSchL2MeasStop);
- RETVALUE((*RgMacSchL2MeasStopCfmMt[0])(pst, measInfo));
+ return ((*RgMacSchL2MeasStopCfmMt[0])(pst, measInfo));
} /* end of RgSchMacL2MeasStop*/
#endif/*LTE_L2_MEAS*/
/**********************************************************************
{
TRC2(rgSCHPwrGetCqiPwr);
- RETVALUE(rgSchPwrCqiToPwrTbl[cqi]);
+ return (rgSchPwrCqiToPwrTbl[cqi]);
} /* rgSCHPwrGetCqiPwr */
/***********************************************************
if (!uePwr->deltaMcsEnbld)
{
- RETVALUE(0);
+ return (0);
}
- RETVALUE(rgSCHPwrGetCqiPwr(cqi));
+ return (rgSCHPwrGetCqiPwr(cqi));
} /* rgSCHPwrGetCqiPwrForUe */
/***********************************************************
TRC2(rgSCHPwrCalcEfficncyPwr);
if (tmp <= 0)
- RETVALUE(0);
- RETVALUE((S8)(10 * cmLog10(tmp)));
+ return (0);
+ return ((S8)(10 * cmLog10(tmp)));
} /* rgSCHPwrCalcEfficncyPwr */
TRC2(rgSCHPwrPuschTpcForUe);
rgSCHPwrOnSchedPuschTpc(cell, ue);
- RETVALUE(uePwr->puschTpc);
+ return (uePwr->puschTpc);
}
/**
rgSCHPwrPuschCntrl(cell, ue); /* This stores tpc, delta and maxRb
* in uePwr */
- RETVALUE(uePwr->maxUlRbs);
+ return (uePwr->maxUlRbs);
}
/**
TRC2(rgSCHPwrPucchTpcForUe);
rgSCHPwrPucchCntrl(cell, ue);
- RETVALUE(uePwr->pucchTpc);
+ return (uePwr->pucchTpc);
}
/***********************************************************
if (uePwr->maxPwrDeltaByPhr < 0 && (trgCqi - crntCqi) *
RG_SCH_UL_CQI_DB_STEP_2 > 0)
{
- RETVALUE(0);
+ return (0);
}
- RETVALUE(RGSCH_MIN(uePwr->maxPwrDeltaByPhr,
+ return (RGSCH_MIN(uePwr->maxPwrDeltaByPhr,
(trgCqi - crntCqi) * RG_SCH_UL_CQI_DB_STEP_2));
} /* rgSCHPwrGetDelta2FrmCqi */
/* Give 4 RBS so that UE can report changed power status*/
/* [ccpu00119916] Mod -return 0th index of rgSchPwrToRbTbl when pwr <=0
* Change the Macros from RGSCH_MAX_DL_BW to RGSCH_MAX_UL_BW*/
- RETVALUE(rgSchPwrToRbTbl[0]);
+ return (rgSchPwrToRbTbl[0]);
}
if (pwr > rgSchPwrRbToPwrTbl[cellUl->maxUlBwPerUe])
{
- RETVALUE(cellUl->maxUlBwPerUe);
+ return (cellUl->maxUlBwPerUe);
}
- RETVALUE(RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(U8)pwr]));
+ return (RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(U8)pwr]));
} /* rgSCHPwrGetMaxRb */
/***********************************************************
numRb = cellUl->maxUlBwPerUe;
}
#endif
- RETVALUE(rgSchPwrRbToPwrTbl[numRb]);
+ return (rgSchPwrRbToPwrTbl[numRb]);
} /* rgSCHPwrRbToPwr */
if (proc == NULLP)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
/*
* Checking for PDCCH would have to be in common proc
* the way things are now.
*/
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
- RETVALUE(FALSE);
+ return (FALSE);
}
} /* rgSCHPwrIsDlUeSched */
#if (ERRCLASS & ERRCLS_DEBUG)
if( proc == NULLP )
{
- RETVALUE (FALSE);
+ return (FALSE);
}
#endif
if (proc->alloc)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
- RETVALUE(FALSE);
+ return (FALSE);
}
} /* rgSCHPwrIsUlUeSched */
|| (cfg->pwrCfg.puschPwrFmt3.size + cfg->pwrCfg.puschPwrFmt3a.size
> RG_SCH_CMN_MAX_NUM_TPC_PUSCH_RNTI))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Now initialise TPC RNTIs */
rgSCHPwrAddRntiToPuschRntiLst(cell, rnti, isFmt3a);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
/* Not doing anything for power reconfig, so such structure
* in RGR */
- RETVALUE(ROK);
+ return ROK;
}
/**
}
uePwr->p0UePusch = sCellInfoCfg->ueSCellUlDedPwrCfg.p0UePusch;
- RETVALUE(ROK);
+ return ROK;
}
#endif
* config happens in the function below */
ret = rgSCHPwrApplyUePwrCfg(cell, ue, &cfg->ueUlPwrCfg);
- RETVALUE(ret);
+ return (ret);
}
/**
}
ret = rgSCHPwrApplyUePwrCfg(cell, ue, &recfg->ueUlPwrRecfg);
- RETVALUE(ret);
+ return (ret);
}
/***********************************************************
rgSCHPwrGetPucchRntiCb(cell, pwrCfg->uePucchPwr.tpcRnti);
if (pucchRntiCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
pucchIdx = pwrCfg->uePucchPwr.idx;
ret = rgSCHPwrChkPucchTpcRntiIdx(pucchRntiCb, pucchIdx);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
rgSCHPwrGetPuschRntiCb(cell, pwrCfg->uePuschPwr.tpcRnti);
if (puschRntiCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
puschIdx = pwrCfg->uePuschPwr.idx;
ret = rgSCHPwrChkPuschTpcRntiIdx(puschRntiCb, puschIdx);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
uePwr->p0UePusch = pwrCfg->p0UePusch;
uePwr->p0UePucch = pwrCfg->p0UePucch;
- RETVALUE(ROK);
+ return ROK;
}
if (!cellPwr->tpcPucchRntiCnt)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
for (idx = 0; idx < cellPwr->tpcPucchRntiCnt; ++idx)
{
if (cellPwr->tpcPucchRntiLst[idx].tpcRnti == tpcRnti)
{
- RETVALUE(&cellPwr->tpcPucchRntiLst[idx]);
+ return (&cellPwr->tpcPucchRntiLst[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
/***********************************************************
if (!cellPwr->tpcPuschRntiCnt)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
for (idx = 0; idx < cellPwr->tpcPuschRntiCnt; ++idx)
{
if (cellPwr->tpcPuschRntiLst[idx].tpcRnti == tpcRnti)
{
- RETVALUE(&cellPwr->tpcPuschRntiLst[idx]);
+ return (&cellPwr->tpcPuschRntiLst[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
if (rgSCHPwrChkTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHPwrChkUniqPucchTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
if (rgSCHPwrChkTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHPwrChkUniqPuschTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
if (uePwr->pucchIdx == idx)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
if (uePwr->puschIdx == idx)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
if (idx >= TFU_MAX_1BIT_TPC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
if (idx >= TFU_MAX_2BIT_TPC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* Warning Fix: Commenting out as not used */
#endif
{
TRC2(rgSCHPwrGetPCMaxValFromPCMax);
- RETVALUE((pCMax & 63) - 30);
+ return ((pCMax & 63) - 30);
}
#endif
{
TRC2(rgSCHPwrGetPhValFromPhr);
- RETVALUE((phr & 63) - 23);
+ return ((phr & 63) - 23);
}
#endif
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed errType(%d) ",
raReqInd->raRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* SR_RACH_STATS : DED PREAMB*/
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHRamProcRaReq(): Allocation"
" of RaReq failed RARNTI:%d",raRnti);
err->errCause = RGSCHERR_RAM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Insert the given raReqInfo */
cmLListAdd2Tail(&cell->raInfo.raReqLst[raIndex], &raReqInfo->raReqLstEnt);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamProcRaReq */
/**
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHRamCreateRaCb(): Allocation of "
"RaCb failed");
err->errCause = RGSCHERR_RAM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
rntiLnk = rgSCHDbmGetRnti(cell);
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst, (Data **)(raCb), sizeof(RgSchRaCb));
err->errCause = RGSCHERR_RAM_RNTI_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate and initialize the DL HARQ portion of the RACB */
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst, (Data **)(raCb), sizeof(RgSchRaCb));
err->errCause = RGSCHERR_RAM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
(*raCb)->isEmtcRaCb = FALSE;
(*raCb)->raCbLnk.node = (PTR)(*raCb);
cmLListAdd2Tail(&cell->raInfo.raCbLst, &(*raCb)->raCbLnk);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamCreateRaCb */
/**
err->errCause = RGSCHERR_RAM_NO_MSG3_RCVD;
*hqEnt = NULLP;
raCb->dlHqE->ue = NULLP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamRgrUeCfg */
/* No need of raCb any more */
rgSCHRamDelRaCb(cell, raCb, TRUE);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamContResCrnti */
"RNTI:%d RaCb in wrong State %d Drop Msg 3",
raCb->rntiLnk->rnti,
raCb->raState);
- RETVALUE(ROK);
+ return ROK;
}
raCb->raState = RGSCH_RA_MSG4_PENDING;
raCb->contResTmrLnk.node = (PTR)(raCb);
cmLListAdd2Tail(&(cell->contResGrdTmrLst), &(raCb->contResTmrLnk));
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamContResCcchsdu */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamProcMsg3 */
rgSCHRamAddToRaInfoSchdLst(cell, raCb);
/* MSG4 Fix End */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamUpdtBo */
/**
/*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
rgSCHUhmProcMsg3DatInd(&(raCb->msg3HqProc));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg3DatInd */
/**
/*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
rgSCHUhmProcMsg3Failure(&(raCb->msg3HqProc));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg3FailureInd */
/**
{
TRC2(rgSCHRamMsg4FdbkInd)
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg4FdbkInd */
rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, TRUE);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg4Done */
#endif
rgSCHUtlFreeSBuf(inst, (Data **)&raCb, sizeof(RgSchRaCb));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamDelRaCb */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamTtiHndlr */
rgSCHRamDelRaCb(cell, raCb, TRUE);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamFreeCell */
#ifdef RGR_V1
#ifdef ANSI
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
cmLListAdd2Tail(&(cell->raInfo.toBeSchdLst), &(raCb->schdLnk));
raCb->contResTmrLnk.node = (PTR)(raCb);
cmLListAdd2Tail(&(cell->contResTmrLst), &(raCb->contResTmrLnk));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamAddToRaInfoSchdLst */
raCb->schdLnk.node = NULLP;
cmLListDelFrm(&(cell->contResTmrLst), &(raCb->contResTmrLnk));
raCb->contResTmrLnk.node = NULLP;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamRmvFrmRaInfoSchdLst */
/*MSG4 Fix End*/
rgSCHCmnHdFddChkDlAllow ( cell, ue, &dlAllowed);
if (dlAllowed == FALSE)
{
- RETVALUE(ROK);
+ return ROK;
}
}
#endif
RGSCH_INCR_SUB_FRAME(schdTime, RG_SCH_CMN_DL_DELTA);
if (RG_SCH_CMN_IS_UE_SPS_SCHDLD(ue, cell, schdTime))
{
- RETVALUE(ROK);
+ return ROK;
}
#endif
if (RG_SCH_CMN_IS_UE_SCHDLD(ue, cell))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d rgSCHSc1DlDedSvcAlloc():"
"Ue retransmitting",ue->ueId);
- RETVALUE(ROK);
+ return ROK;
}
/* UE is scheduled for either other services or TA */
sc1HqDl = RG_GET_SC1_HQP_DL(proc);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "CRNTI:%d rgSCHSc1DlDedSvcAlloc():"
" No HARQ Proc available", ue->ueId);
- RETVALUE(ROK);
+ return ROK;
}
sc1HqDl = RG_GET_SC1_HQP_DL(proc);
cmnHqDl = RG_SCH_CMN_GET_DL_HQP(proc);
/* ccpu00126519: proc should be set to NULLP in UE's DL scratch pad info as well. */
ueDl->proc = NULLP;
}
- RETVALUE(ret);
+ return (ret);
}
svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
svcSc1->hdrEstimate = rlcHdrEstmt;
rgSCHSc1DlAdd2UeSchdSvcs(cell, ue, svc);
/* 3.1 MIMO moving this call to cmn scheduler */
/*rgSCHCmnDlRbInfoAddUeTx(allocInfo, ue); */
- RETVALUE(ROK);
+ return ROK;
}
/**
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_SC1_DL_CFG;
- RETVALUE(ret);
+ return (ret);
}
cellDl = RG_GET_SC1_CELL_DL(cell);
/* Now perform downlink Queues related initializations */
rgSCHSc1DlInitQueues(cellDl);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrDlCellCfg */
/***********************************************************
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Memory allocation FAILED"
"CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_SC1_DL_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDl = (RgSchSc1DlUe *)ueSchCmn->dl.schSpfc;
if (ue->dl.ambrCfgd)
cmLListInit(&ueDl->ambrLst);
cmLListInit(&ueDl->schdSvcs);
cmLListInit(&ueDl->retxHqProcs);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrDlUeCfg */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED CRNTI:%d",hqEnt->ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqSpcSch = (RgSchSc1DlHqProc *)(hqEnt->sch);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
((RgSchCmnDlHqProc *)((hqP)->sch))->schSpfc = \
hqSpcSch++;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief UE reconfiguration for scheduler
RgSchMacRlsHq (&pst, rlsHqBufs);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrDlUeRecfg */
/**
#endif
{
TRC2(rgSCHSc1DlFillFlowCntrlInfo);
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief UE deletion for scheduler
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHSc1CrgLcCfg():"
"SCH struct alloc failed CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_SC1_DL_CFG;
- RETVALUE(ret);
+ return (ret);
}
rgSCHSc1DlSvcAdd(cell, ue, dlLc, &lcCfg->dlInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcCfg */
rgSCHSc1DlSvcMod(cell,ue,dlLc, lcRecfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcRecfg */
\f
#endif
{
TRC2(rgSCHSc1DlUeReset);
- RETVALUE(ROK);
+ return ROK;
}
RgSchErrInfo *err
)
{
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief UE Lc Reconfig for RR
RgSchErrInfo *err
)
{
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief LC deletion for PFS
U8 lcgId;
#endif
{
- RETVALUE (ROK);
+ return (ROK);
}
\f
/**
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_SC1_UL_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrUlUeCfg */
/**
#endif
{
TRC2(rgSCHSc1RgrUlUeRecfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrUeRecfg */
/**
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_SC1_UL_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl = RG_GET_SC1_CELL_UL(cell);
cmLListInit(&cellUl->contResLst);
cmLListInit(&cellUl->ueTxLst[0]);
cmLListInit(&cellUl->ueTxLst[1]);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrUlCellCfg */
\f
#endif
{
TRC2(rgSCHSc1RgrUlCellRecfg);
- RETVALUE(ROK);
+ return ROK;
}
/**
#endif
{
TRC2(rgSCHSc1RgrLcgCfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcgCfg */
/**
#endif
{
TRC2(rgSCHSc1RgrLcgRecfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcgRecfg */
/***********************************************************
TRC2(rgSCHSc1UlLcgUpd);
- RETVALUE(ROK);
+ return ROK;
}
\f
RgSchUeCellInfo *sCellInfo
#endif
{
- RETVALUE(ROK);
+ return ROK;
RgSchCmnCell *cellSch;
Inst inst = sCellInfo->cell->instIdx;
printf("SCELL DEATIVATED sCellInfo->ue->ueId =%d, sCellInfo->sCellId =%d\n", sCellInfo->ue->ueId, sCellInfo->sCellId);
//MSPD_DBG("SCELL DEATIVATED sCellInfo->ue->ueId =%d, sCellInfo->sCellId =%d\n", sCellInfo->ue->ueId, sCellInfo->sCellId);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
if((secCellCb = (RgSchCellCb *)rgSchUtlGetCellCb(inst, secCellId)) == NULLP)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCell doesnt exists"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqEntRstInfo.cellId = secCellId;
RgSchMacRstHqEnt(&pst, &hqEntRstInfo);
- RETVALUE(ROK);
+ return ROK;
}
/*removed endif*/
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Invalid Serv Cell Idx %d\n", \
sCellIdx));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ueCb->cellInfo[sCellIdx] == NULLP)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Serv Cell not added to this Ue Scell Idx %d ueId %d\n", \
sCellIdx,ueCb->ueId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch (action)
break;
}
}
- RETVALUE(ret);
+ return (ret);
}
\f
if((ueCb->cellInfo[(*sCellIdx)] != NULLP) &&
(ueCb->cellInfo[(*sCellIdx)]->sCellState == RG_SCH_SCELL_READY))
{
- RETVALUE(ROK);
+ return ROK;
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/**
rgSCHSCellDelUeSCell(cellCb,ueCb,idx);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef TFU_UPGRADE
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Invalid Serv Cell Idx %d\n",
sCellIdx));
- RETVALUE(RFAILED);
+ return RFAILED;
}
sCellInfo = ueCb->cellInfo[sCellIdx];
cqiCb->riDist = RG_SCH_INVALID_IDX;
cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
- RETVALUE(ROK);
+ return ROK;
}
#endif
}
}
- RETVALUE(retCqiCb->servCellInfo->sCellIdx);
+ return (retCqiCb->servCellInfo->sCellIdx);
}
/**
idx = ((nPCqiServCellIdx)& (CM_LTE_MAX_CELLS -1));
ueCb->nPCqiCb = &ueCb->cellInfo[idx]->cqiCb;
- RETVALUE(ROK);
+ return ROK;
}
/* Set the next expected Cqi into nPCqiCb */
ueCb->nPRiCb = &ueCb->cellInfo[nPRiServCellIdx]->cqiCb;
- RETVALUE(ROK);
+ return ROK;
}
#endif/*TFU_UPGRADE*/
break;
}
}
- RETVALUE(retVal);
+ return (retVal);
}
/**
* outstanding BO */
if(ue->remBoCnt == RG_SCH_ACTIVATION_COUNT)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif/*LTE_ADV*/
* Function: rgSCHDynTDDMrkCrntSfIdx
* Purpose: update the dyn tdd sunframe index
* @param[in] Inst schInst
- * @RETVALUE None
+ * @return None
*/
#ifdef UNUSED_FUNC
#ifdef ANSI
#if (ERRCLASS & ERRCLS_DEBUG)
if(idx >= ueUl->hqEnt.numHqPrcs)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
- RETVALUE(&(ueUl->hqEnt.hqProcCb[idx]));
+ return (&(ueUl->hqEnt.hqProcCb[idx]));
} /* rgSCHUhmGetUlHqProc */
/**
TRC2(rgSCHUhmAppendPhich)
#ifdef RG_5GTF
- RETVALUE(ROK);
+ return ROK;
#endif
if(cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
if (rgSCHUtlGetPhichInfo (ulAlloc->hqProc, &rbStart, &nDmrs) != ROK)
#endif
{
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if(nDmrs != RGSCH_INVALID_NDMRS)
{
ulAlloc = rgSCHUtlNextHqFdbkAlloc (cellCb, ulAlloc, idx);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUhmAppendPhich */
/**
ueUl->hqEnt.numHqPrcs * \
sizeof(RgSchUlHqProcCb)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUhmHqEntInit */
#ifdef RG_5GTF
//printf("5GTF_ERROR rgSCHUhmGetAvlHqProc cellId %d %ld inUse %ld ue %d"
//, cell->cellId, hqE->free.count, hqE->inUse.count, ue->ueId);
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
tmpHqProc = (RgSchUlHqProcCb *)(tmp->node);
*hqP = tmpHqProc;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUhmGetAvlHqProc */
/**
if (RGSCH_TIMEINFO_SAME(proc->schdTime, frm))
{
// printf("Harq timing Matched rgSCHUhmGetUlProcByTime time (%d %d) proc->procId %d \n",proc->schdTime.sfn,proc->schdTime.slot, proc->procId);
- RETVALUE(proc);
+ return (proc);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHUhmGetUlProcByTime */
#endif
{
if( n==0 )
{
- RETVALUE( 1 );
+ return ( 1 );
}
else if ( n>0 )
{
- RETVALUE( x * rgSCHUtlPower( x, n-1 ) );
+ return ( x * rgSCHUtlPower( x, n-1 ) );
}
else
{
- RETVALUE( (1/x) * rgSCHUtlPower( x, n+1 ) );
+ return ( (1/x) * rgSCHUtlPower( x, n+1 ) );
}
} /* end of rgSCHUtlPower*/
}
pointToEnd++;
}
- RETVALUE((U32)result);
+ return ((U32)result);
} /* end of rgSCHUtlParse*/
/*
crntTime += RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
dist+=1;
}
- RETVALUE(dist-1);
+ return (dist-1);
} /* end of rgSCHUtlFindDist*/
#endif
if ((offset >= ((pdcchInfo->nCce + 7) >> 3)) ||
((aggrLvl == CM_LTE_AGGR_LVL16) && (offset > 0)))
{
- RETVALUE(FALSE);
+ return (FALSE);
}
byte = &pdcchInfo->map[offset];
ret = rgSCHUtlAllocSBuf(inst, (Data **)pdcch, sizeof(RgSchPdcch));
if(ROK != ret)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
(*pdcch)->nCce = aggrLvl;
(*pdcch)->ue = NULLP;
}
- RETVALUE(TRUE);
+ return (TRUE);
}
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"CE Pool memory allocation FAILED for cell");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo, cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp->node, sizeof(RgSchSFRPoolInfo));
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"CE Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
l = &sf->sfrTotalPoolInfo.cePool;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp->node, sizeof(RgSchSFRPoolInfo));
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
l = &sf->sfrTotalPoolInfo.ccPool;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp->node, sizeof(RgSchSFRPoolInfo));
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListAdd2Tail(l, temp);
sf->sfrTotalPoolInfo.ccBwFull = FALSE;
sf->sfrTotalPoolInfo.ceBwFull = FALSE;
sf->sfrTotalPoolInfo.isUeCellEdge = FALSE;
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief This function resets temporary variables in RNTP Prepration
(len * sizeof(U8)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for RNTP Alloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
rntpPtr->len = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, " rgSCHUtlAddPhich(): "
"Allocation of RgSchPhich failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_TDD
RGSCH_INITPHICH(phich, hqFeedBack, nDmrs, rbStart, iPhich);
RGSCH_INITPHICH(phich, hqFeedBack, nDmrs, rbStart, isForMsg3); /*SR_RACH_STATS */
#endif
cmLListAdd2Tail(&dlSf->phichInfo.phichs, &phich->lnk);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlAddPhich */
/**
/* CA dev Start */
sf->dlIdx = dlIdx;
/* CA dev End */
- RETVALUE(sf);
+ return (sf);
}
\f
ret |= s[i];
}
}
- RETVALUE(ret);
+ return (ret);
}
#ifdef LTEMAC_SPS
default: /* case 1 */
regs += bw * RGSCH_NUM_REGS_1ST_SYM;
}
- RETVALUE(regs);
+ return (regs);
}
/***********************************************************
{
TRC2(rgSCHUtlCalcPhichRegs);
/* ccpu00115330: Corrected the calculation for number of PHICH groups*/
- RETVALUE(RGSCH_CEIL((bw * ng6) ,(8 * 6)) * RGSCH_NUM_REG_PER_PHICH_GRP);
+ return (RGSCH_CEIL((bw * ng6) ,(8 * 6)) * RGSCH_NUM_REG_PER_PHICH_GRP);
}
#ifdef LTE_TDD
phichRegs = rgSCHUtlCalcPhichRegs(bw, ng6);
cceRegs = totalRegs - mPhich*phichRegs - RGSCH_NUM_PCFICH_REG;
- RETVALUE((U8)(cceRegs/RGSCH_NUM_REG_PER_CCE));
+ return ((U8)(cceRegs/RGSCH_NUM_REG_PER_CCE));
}
#else
phichRegs = rgSCHUtlCalcPhichRegs(bw, ng6);
cceRegs = totalRegs - phichRegs - RGSCH_NUM_PCFICH_REG;
- RETVALUE((U8)(cceRegs/RGSCH_NUM_REG_PER_CCE));
+ return ((U8)(cceRegs/RGSCH_NUM_REG_PER_CCE));
}
#endif
#endif
ret = ROK;
}
- RETVALUE(ret);
+ return (ret);
}
#ifndef TFU_UPGRADE
/**
#if (ERRCLASS & ERRCLS_DEBUG)
if ((alloc == NULLP) || (alloc->hqProc == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
RLOG_ARG2(L_ERROR,DBG_CELLID,alloc->ue->cell->cellId,
"Failed: ue->sch is null RNTI:%d,isRetx=%d",
alloc->rnti, alloc->grnt.isRtx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueCtgy = (RG_SCH_CMN_GET_UE_CTGY(alloc->ue));
}
*ndi = alloc->hqProc->ndi;
*hqPId = alloc->hqProc->procId;
- RETVALUE(ROK);
+ return ROK;
}
#else
/**
#if (ERRCLASS & ERRCLS_DEBUG)
if ((alloc == NULLP) || (alloc->hqProc == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
recpReq->size = alloc->grnt.datSz;
}
#endif
/* ccpu00117050 - DEL - nSrs setting at rgSCHUtlAllocRcptInfo */
- RETVALUE(ROK);
+ return ROK;
}
#endif
(Data **)&cell->subFrms, sizeof(RgSchDlSf *) * maxslots);
if (cell->subFrms == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create memory for each frame. */
rgSCHUtlFreeSBuf(cell->instIdx,
(Data **)(&(cell->subFrms)), sizeof(RgSchDlSf *) * maxslots);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell->sc.apis == NULLP)
/* ccpu00132286- Removed deletion of sf nodes as the deletion will be
* happening during CellDelete. Added return handling to provide negative
* confirm*/
- RETVALUE(ret);
+ return (ret);
}
/* Release the slots and thereby perform the initialization */
rgSCHUtlDlRlsSubFrm(cell, frm);
}
- RETVALUE(ret);
+ return (ret);
}
#else
/*initialize the RNTP Buffer*/
if(rgSchDSFRRntpInfoInit(&sf->rntpInfo, cell, sf->bw))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/*initialise the pools of CC and CE*/
if(rgSchSFRTotalPoolInit(cell, sf))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* LTE_ADV_FLAG_REMOVED_END */
(len * sizeof(U8)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for RNTP Alloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell->rntpAggrInfo.pres = PRSNT_NODEF;
cell->rntpAggrInfo.len = len;
rgSCHLaaDeInitDlSfCb(cell, sf);
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell->sc.apis == NULLP)
if (ret != ROK)
{
errInfo->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
RGSCH_IOT_PUCCH_POOLSZ, RGSCH_IOT_PUCCH_DELTA, RGSCH_IOT_PUCCH_MAXFREQSZ) != ROK)
{
errInfo->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ret);
+ return (ret);
}
#endif
#endif
{
TRC2(rgSCHUtlRgrCellRecfg);
- RETVALUE(cell->sc.apis->rgSCHRgrCellRecfg(cell, recfg, err));
+ return (cell->sc.apis->rgSCHRgrCellRecfg(cell, recfg, err));
}
rgSchDSFRRntpInfoFree(&cell->rntpAggrInfo, cell, cell->bwCfg.dlTotalBw);
/* LTE_ADV_FLAG_REMOVED_END */
- RETVALUE(ROK);
+ return ROK;
}
\f
if (cfg->txMode.txModeEnum == RGR_UE_TM_5)
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->mimoInfo.txMode = cfg->txMode.txModeEnum;
}
(cfg->puschDedCfg.bRIIdx > 15))
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->ul.betaHqOffst = cfg->puschDedCfg.bACKIdx;
ue->ul.betaCqiOffst = cfg->puschDedCfg.bCQIIdx;
cmMemset((U8 *)&ue->pfsStats, 0, sizeof(RgSchPfsStats));
#endif
/* Call the handler of the scheduler based on cell configuration */
- RETVALUE(cell->sc.apis->rgSCHRgrUeCfg(cell, ue, cfg, err));
+ return (cell->sc.apis->rgSCHRgrUeCfg(cell, ue, cfg, err));
}
/* Start : LTEMAC_2.1_DEV_CFG */
\f
#endif
{
TRC2(rgSCHUtlRgrLcCfg);
- RETVALUE(cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
+ return (cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
}
\f
#endif
{
TRC2(rgSCHUtlRgrLcRecfg);
- RETVALUE(cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
+ return (cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
}
/**
TRC2(rgSCHUtlRgrLcDel);
cell->sc.apis->rgSCHRgrLchDel(cell, ue, lcId, lcgId);
- RETVALUE (ROK);
+ return (ROK);
} /* rgSCHUtlRgrLcDel */
/**
#endif
{
TRC2(rgSCHUtlRgrLcgCfg);
- RETVALUE(cell->sc.apis->rgSCHRgrLcgCfg(cell, ue, &(ue->ul.lcgArr[cfg->ulInfo.lcgId]), cfg, errInfo));
+ return (cell->sc.apis->rgSCHRgrLcgCfg(cell, ue, &(ue->ul.lcgArr[cfg->ulInfo.lcgId]), cfg, errInfo));
}
\f
#endif
{
TRC2(rgSCHUtlRgrLcgRecfg);
- RETVALUE(cell->sc.apis->rgSCHRgrLcgRecfg(cell, ue, &(ue->ul.lcgArr[recfg->ulRecfg.lcgId]), recfg, err));
+ return (cell->sc.apis->rgSCHRgrLcgRecfg(cell, ue, &(ue->ul.lcgArr[recfg->ulRecfg.lcgId]), recfg, err));
} /* rgSCHUtlRgrLcRecfg */
/**
strtCellId = rgSchCb[inst].genCfg.startCellId;
cellCb = rgSchCb[inst].cells[cellId - strtCellId];
- RETVALUE(cellCb);
+ return (cellCb);
} /* rgSchUtlGetCellCb */
servCellIdx = ue->cellIdToCellIdxMap[cellId - strtCellId];
- RETVALUE(servCellIdx);
+ return (servCellIdx);
} /* rgSchUtlGetCellCb */
strtCellId = rgSchCb[inst].genCfg.startCellId;
if((cellId >= strtCellId) && ((cellId - strtCellId) < CM_LTE_MAX_CELLS))
{
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgSchUtlVldtCellId */
#endif /* LTE_ADV*/
if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_5)
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
if(ue->mimoInfo.txMode != ueRecfg->txMode.txModeEnum)
/* Commenting here to assign garbage value when it is not set in APP. */
//ue->accessStratumRls = ueRecfg->accessStratumRls;
- RETVALUE(cell->sc.apis->rgSCHRgrUeRecfg(cell, ue, ueRecfg, err));
+ return (cell->sc.apis->rgSCHRgrUeRecfg(cell, ue, ueRecfg, err));
} /* rgSCHUtlRgrUeRecfg */
/**
#endif
{
TRC2(rgSCHUtlUpdUlHqProc);
- RETVALUE(cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
+ return (cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
} /* rgSCHUtlUpdUlHqProc */
#endif
/**
ue->isMsg4PdcchWithCrnti = TRUE;
- RETVALUE(cell->sc.apis->rgSCHContResUlGrant(cell, ue, err));
+ return (cell->sc.apis->rgSCHContResUlGrant(cell, ue, err));
} /* rgSCHUtlContResUlGrant */
/**
#endif
{
TRC2(rgSCHUtlSrRcvd);
- RETVALUE(cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
+ return (cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
} /* rgSCHUtlSrRcvd */
/**
#endif
{
TRC2(rgSCHUtlUpdExtPhr);
- RETVALUE(cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
+ return (cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
} /* rgSCHUtlUpdExtPhr */
#endif
{
TRC2(rgSCHUtlUpdPhr);
- RETVALUE(cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
+ return (cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
} /* rgSCHUtlUpdPhr */
#endif
{
TRC2(rgSCHUtlFirstRcptnReq);
- RETVALUE(cell->sc.apis->rgSCHFirstRcptnReq(cell));
+ return (cell->sc.apis->rgSCHFirstRcptnReq(cell));
}
/**
#endif
{
TRC2(rgSCHUtlNextRcptnReq);
- RETVALUE(cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
+ return (cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
}
/**
#endif
{
TRC2(rgSCHUtlFirstHqFdbkAlloc);
- RETVALUE(cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
+ return (cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
}
\f
#endif
{
TRC2(rgSCHUtlNextHqFdbkAlloc);
- RETVALUE(cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
+ return (cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
}
/***********************************
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlTfuBndReq() Call to RgLiTfuBndReq()"
" failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlTfuBndReq */
/**
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuUBndReq() Call to"
" RgLiTfuUbndReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlTfuUBndReq */
{
sfAlloc->cmnLcInfo.bitMask = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
"UE Alloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
"UE Alloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate memory for "scheduled RAR" Info */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
"RARNTI");
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(indx = 0; indx < RGSCH_MAX_RARNTI_PER_DL_SF; indx++)
{
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
"RNTI");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rgSCHEmtcUtlGetSfAlloc(cell);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef EMTC_ENABLE
rgSCHEmtcUtlPutSfAlloc(cell);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifndef NO_ERRCLS
if (size == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RGSCHLOGERROR(inst, ERRCLS_DEBUG, ERG015, 0, "Unable to Allocate Buffer");
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Unable to Allocate the Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* zero out the allocated memory */
cmMemset((U8 *)*pData, 0x00, size);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlAllocSBuf */
{
warningSiPdu = (RgSchWarningSiPdu *)node->node;
pdu = warningSiPdu->pdu;
- RETVALUE(pdu);
+ return (pdu);
}
else
{
- RETVALUE(NULLP);
+ return (NULLP);
}
} /* rgSCHUtlGetWarningSiPdu */
CM_LLIST_FIRST_NODE(&warningSi->warningSiMsg.segLstCp, node);
if (node == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
warningSiPdu = (RgSchWarningSiPdu *)node->node;
*mcs = warningSiPdu->mcs;
*nPrb = warningSiPdu->nPrb;
*msgLen = warningSiPdu->msgLen;
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlGetMcsAndNPrb */
/*
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "msgLen does "
"not match any valid TB Size");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell->siCb.crntSiInfo.siInfo[siId-1].msgLen = msgLen;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
sfAlloc->cmnLcInfo.pcchInfo.lcId = lcId;
sfAlloc->cmnLcInfo.bitMask |= RGINF_PCCH_INFO;
}
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function fills in the RAR information to be sent to MAC
TODO-Need to add a check for max tx power per symbol */
sfAlloc->rarInfo.txPwrOffset = cellDl->rarTxPwrOffset;
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlFillRgInfRarInfo */
/** @brief This function fills in the pdsch data related allocation Info
ret = rgSCHEmtcUtlFillPdschDciInfo(pdsch, pdcchDci);
if(RFAILED == ret)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
/* LTE_ADV_FLAG_REMOVED_START */
/* PHR present */
RGSCHCPYTIMEINFO(subfrmInfo->timingInfo, ueCb->macCeRptTime);
if ((ret = rgSCHUtlUpdPhr(cellCb, ueCb, pdu->ceInfo.ces.phr, err)) != ROK)
- RETVALUE(ret);
+ return (ret);
}
/* Note: Order of indication to Sch now is
* 1st Indicate the DataInd info for each LCG's
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlUpdSch */
#ifdef RGR_V1
/**
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unexpected CCCH SDU BO",
ueCb->ueId);
- RETVALUE(ROK);
+ return ROK;
}
ueCb->ccchSduLnk.node = (PTR)(ueCb);
cmLListAdd2Tail(&(cell->ccchSduUeLst), &(ueCb->ccchSduLnk));
- RETVALUE(ROK);
+ return ROK;
}
/**
*
{
/* Handle Ue fetch failure */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid UEID:%d",staRsp->u.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update Bo in ueCb */
ueCb->dlCcchInfo.bo = (U32)(staRsp->bo);
rgSCHUtlAddUeToCcchSduLst(cell, ueCb);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlUpdtBo */
#endif
#ifdef RGR_V1
/* CR timer implementation changes*/
/*If no raCb, schedule ueCb, ueCb is extracted in rgSCHUtlUpdtBo*/
- RETVALUE(rgSCHUtlUpdtBo(cell, boRpt));
+ return (rgSCHUtlUpdtBo(cell, boRpt));
#else
/* Handle RaCb fetch failure */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Invalid RNTI:%d to fetch raCb",boRpt->u.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
{
/* Handle Ue fetch failure */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RNTI:%d",boRpt->u.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update Bo in ueCb */
ueCb->dlCcchInfo.bo = (U32)(boRpt->bo);
rgSCHRamUpdtBo(cell, raCb, boRpt);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlHndlCcchBoUpdt */
/**
{
*nPrb = rgSchUtlBcchPcchTbSzTbl[cn].rbIndex;
*mcs = rgSchUtlBcchPcchTbSzTbl[cn].mcs;
- RETVALUE(rgSchUtlBcchPcchTbSzTbl[cn].tbSz);
+ return (rgSchUtlBcchPcchTbSzTbl[cn].tbSz);
}
else if (rgSchUtlBcchPcchTbSzTbl[cn].tbSz < bo)
lt = cn + 1;
}
if (lt == 44)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
*nPrb = rgSchUtlBcchPcchTbSzTbl[lt].rbIndex;
*mcs = rgSchUtlBcchPcchTbSzTbl[lt].mcs;
- RETVALUE(rgSchUtlBcchPcchTbSzTbl[lt].tbSz);
+ return (rgSchUtlBcchPcchTbSzTbl[lt].tbSz);
}
/**
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"No Logical Channel dlLc is NULLP for RNTI:%d LCID:%d",boUpdt->u.rnti,boUpdt->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (boUpdt->lcId != dlLc->lcId)
{
{
RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"[%ld]BO: does not match any "
"valid TB Size RNTI:%d LCID:%d", boUpdt->bo,boUpdt->u.rnti,boUpdt->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}/*end of rgSCHChkBoUpdate*/
else
{
- RETVALUE(ROK);
+ return ROK;
}
}
if ((dlLc = rgSCHDbmGetCmnLcCb(cell, boUpdt->lcId)) == NULLP)
{
RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId, "Allocation of common bo %dreport "
"failed RNTI:%d LCID:%d", boUpdt->bo,boUpdt->u.rnti,boUpdt->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
boRpt->bo = boUpdt->bo;
}
rgSCHDbmInsCmnLcBoRpt(dlLc, boRpt);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlHndlBcchPcchBoUpdt */
/**
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrBndCfm: RgUiRgrBndCfm Failed ");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgrBndCfm*/
/**
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgmBndCfm: RgUiRgrBndCfm Failed ");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgmBndCfm*/
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"schSendCfgCfm: RgUiRgrCfgCfm Failed");
printf("\nschSendCfgCfm: RgUiRgrCfgCfm Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* schSendCfgCfm*/
#ifdef RGR_RRM_TICK
/**
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHUtlRgrTtiInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RgUiRgrTtiInd(&(cell->rgrSap->sapCfg.sapPst),
cell->rgrSap->sapCfg.suId, rgrTti);
mtTmrHdlrPublic();
}
#endif
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgrTtiInd*/
#endif
/** @brief This function is called by rgMacSchSfRecpInd. This function invokes the
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId, "RNTI:%d Received MSG3, unable to "
"find raCb",rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ccpu00130982: Processing CRNTI MAC CE before Short BSR, if any, such that
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Processing failed in the RAM "
"RNTI:%d ",rnti);
- RETVALUE(ret);
+ return (ret);
}
/* if ueCb is present */
if (ueCb != NULLP)
rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTEMAC_SPS
/** @brief This function is called by RgMacSchSpsRelInd. This function invokes the
{
TRC2(rgSCHUtlSpsRelInd);
cellCb->sc.apis->rgSCHUlSpsRelInd(cellCb, ueCb, isExplRel);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlSpsRelInd */
{
TRC2(rgSCHUtlSpsActInd);
cellCb->sc.apis->rgSCHUlSpsActInd(cellCb, ueCb, spsSduSize);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlSpsActInd */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,grpPwrCntrlReq->cellId,
"rgSCHUtlTfuGrpPwrCntrlReq() Lower SAP not bound (%d) ",tfuSap->sapSta.sapState);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuGrpPwrCntrlReq (&pst, tfuSap->sapCfg.spId, grpPwrCntrlReq)) != ROK)
RLOG_ARG0(L_ERROR,DBG_CELLID,grpPwrCntrlReq->cellId,
"rgSCHUtlTfuGrpPwrCntrlReq() Call to RgLiTfuGrpPwrCntrlReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlTfuGrpPwrCntrlReq */
#endif
RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuCntrlReq() Lower SAP not bound (%d) ",
tfuSap->sapSta.sapState);
RGSCH_FREE_MEM(cntrlReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuCntrlReq() Call to RgLiTfuCntrlReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlTfuCntrlReq*/
{
TRC2(rgSCHUtlDlActvtUe);
cell->sc.apis->rgSCHActvtDlUe(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
/**
{
TRC2(rgSCHUtlUlActvtUe);
cell->sc.apis->rgSCHActvtUlUe(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
/**
RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuRecpReq() Lower SAP not bound (%d) ",
tfuSap->sapSta.sapState);
RGSCH_FREE_MEM(recpReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuRecpReq() Call to RgLiTfuRecpReq() failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlTfuRecpReq */
/** @brief This function Validates the SAP information received along with the
if(suId >= rgSchCb[inst].numSaps)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Incorrect SuId");
- RETVALUE(RFAILED);
+ return RFAILED;
}
tfuSap = &(rgSchCb[inst].tfuSap[suId]);
{
RLOG_ARG2(L_ERROR,DBG_INSTID,inst,"Incorrect SuId. Configured (%d) Recieved (%d)",
tfuSap->sapCfg.suId, suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (tfuSap->sapSta.sapState != LRG_BND)
{
RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"Lower SAP not enabled SuId (%d)",
tfuSap->sapCfg.suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlValidateTfuSap */
/*
{
RGSCHLOGERROR(inst, ERRCLS_INT_PAR, ERG022, memSize,
"rgAllocEventMem(): memSize invalid\n");
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
/*starting Task*/
#endif /* */
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"cmAllocEvnt Failed.");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*stoping Task*/
SStopTask(startTime, PID_SCHUTL_CMALLCEVT);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlAllocEventMem*/
/*
#else
ret = cmGetMem(memCp, len, (Ptr *)ptr);
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of rgSCHUtlGetEventMem*/
#ifdef LTE_TDD
(Data **) &(ue->cellInfo[servCellIdx]->anInfo), sizeof(RgSchTddANInfo) * \
ue->cell->ackNackFdbkArrSize) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx=0; idx < ue->cell->ackNackFdbkArrSize; idx++)
/* Set it to the first index */
ue->cellInfo[servCellIdx]->nextFreeANIdx = 0;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlAllocUeANFdbkInfo */
/**
anFdInfo->dlDai = RG_SCH_INVALID_DAI_VAL;
anFdInfo->latestMIdx = RG_SCH_INVALID_M_VAL;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlInitUeANFdbkInfo */
/**
if( (timeInfo->sfn == ueCb->cellInfo[servCellIdx]->anInfo[idx].sfn) &&
(timeInfo->slot == ueCb->cellInfo[servCellIdx]->anInfo[idx].slot))
{
- RETVALUE(&ueCb->cellInfo[servCellIdx]->anInfo[idx]);
+ return (&ueCb->cellInfo[servCellIdx]->anInfo[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHUtlGetUeANFdbkInfo */
/**
rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][timeInfo->slot]) - 1;
idx = idx % cell->numDlSubfrms;
- RETVALUE((U8)idx);
+ return ((U8)idx);
}
/**
sizeof(RgSchUlAllocDb));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
ret = rgSCHUtlUlAllocDbInit(cell, sf->allocDb, maxUePerSf);
if (ret != ROK)
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(sf->allocDb)),
sizeof(RgSchUlAllocDb));
- RETVALUE(ret);
+ return (ret);
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&sf->holeDb,
sizeof(RgSchUlHoleDb));
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(sf->allocDb)),
sizeof(RgSchUlAllocDb));
- RETVALUE(ret);
+ return (ret);
}
/* Initialize the hole with CFI 1 Pusch Bw Info */
ret = rgSCHUtlUlHoleDbInit(cell, sf->holeDb, (U8)(maxUePerSf + 2), \
sizeof(RgSchUlAllocDb));
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(sf->holeDb)),
sizeof(RgSchUlHoleDb));
- RETVALUE(ret);
+ return (ret);
}
cmLListInit(&sf->reTxLst);
}
#endif
- RETVALUE(ret);
+ return (ret);
}
TRC2(rgSCHUtlUlAllocDbInit);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
allocDb->count = 0;
allocDb->first = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
ret = rgSCHUtlUlHoleMemInit(cell, &holeDb->mem, maxHoles, &hole);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
holeDb->count = 1;
holeDb->first = hole;
hole->start = start;
hole->num = num;
hole->prv = hole->nxt = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC2(rgSCHUtlUlAllocGetHole);
if (numSb < hole->num)
{
- RETVALUE(rgSCHUtlUlAllocGetPartHole(sf, numSb, hole));
+ return (rgSCHUtlUlAllocGetPartHole(sf, numSb, hole));
}
else
{
- RETVALUE(rgSCHUtlUlAllocGetCompHole(sf, hole));
+ return (rgSCHUtlUlAllocGetCompHole(sf, hole));
}
}
/* UL_ALLOC_CHANGES*/
alloc->allocDbRef = (void*)sf->allocDb;
alloc->holeDbRef = (void*)sf->holeDb;
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
alloc->allocDbRef = (void*)sf->allocDb;
alloc->holeDbRef = (void*)sf->holeDb;
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
#endif
{
TRC2(rgSCHUtlUlAllocFirst);
- RETVALUE(sf->allocDb->first);
+ return (sf->allocDb->first);
}
/***********************************************************
{
TRC2(rgSCHUtlUlAllocNxt);
UNUSED(sf);
- RETVALUE(alloc->nxt);
+ return (alloc->nxt);
}
/***********************************************************
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
{
- RETVALUE ( NULLP );
+ return ( NULLP );
}
#endif
alloc->prv = prv;
++db->count;
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
{
- RETVALUE ( NULLP );
+ return ( NULLP );
}
#endif
++db->count;
- RETVALUE(alloc);
+ return (alloc);
}
/* UL_ALLOC_ENHANCEMENT */
#endif
{
TRC2(rgSCHUtlUlHoleFirst);
- RETVALUE(sf->holeDb->first);
+ return (sf->holeDb->first);
}
/***********************************************************
{
TRC2(rgSCHUtlUlHoleNxt);
UNUSED(sf);
- RETVALUE(hole->nxt);
+ return (hole->nxt);
}
/***********************************************************
maxAllocs * sizeof(*allocs));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
mem->allocs = allocs;
mem->maxAllocs = maxAllocs;
allocs[i].nxt = NULLP;
}
mem->firstFree = &allocs[0];
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
maxHoles * sizeof(*holes));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
mem->holes = holes;
}
mem->firstFree = &holes[1];
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
#if (ERRCLASS & ERRCLS_DEBUG)
if (mem->firstFree == NULLP)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
alloc->nxt = NULLP; /* probably not needed */
/* alloc->prv might already be NULLP, in case was needed to set it to NULLP */
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
#if (ERRCLASS & ERRCLS_DEBUG)
if (mem->firstFree == NULLP)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
hole->nxt = NULLP; /* probably not needed */
/* hole->prv is might already be NULLP, in case was needed to set it to NULLP */
- RETVALUE(hole);
+ return (hole);
}
/***********************************************************
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
do
{
#if (ERRCLASS & ERRCLS_DEBUG)
if ( newHole == NULLP )
{
- RETVALUE( NULLP );
+ return ( NULLP );
}
#endif
newHole->start = hole->start;
break;
}
} while ((hole = nxtHole) != NULLP);
- RETVALUE(alloc);
+ return (alloc);
}
#ifdef LTE_L2_MEAS
/**
qciVal = qci[qciIdx];
if(qciVal == 0 || qciVal > 9)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(qciVal != cellCb->qciArray[qciVal].qci)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHUtlValidateQci */
/**
* @brief Validates the measurement request parameters.
{
err->errType = RGSCHERR_SCH_INVALID_MEAS_TYPE;
err->errCause = RGSCHERR_SCH_L2MEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((schL2MeasInfo->timePrd !=0) &&
(measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL) &&
{
err->errType = RGSCHERR_SCH_INVALID_PARAM_RANGE;
err->errCause = RGSCHERR_SCH_L2MEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((schL2MeasInfo->timePrd !=0) &&
(measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL) &&
{
err->errType = RGSCHERR_SCH_INVALID_PARAM_RANGE;
err->errCause = RGSCHERR_SCH_L2MEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL) &&
((schL2MeasInfo->nmbActvUeQciDl.numQci > LRG_MAX_QCI_PER_REQ) ||
{
err->errType = RGSCHERR_SCH_INVALID_PARAM_RANGE;
err->errCause = RGSCHERR_SCH_L2MEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL) &&
((schL2MeasInfo->nmbActvUeQciUl.numQci > LRG_MAX_QCI_PER_REQ) ||
{
err->errType = RGSCHERR_SCH_INVALID_PARAM_RANGE;
err->errCause = RGSCHERR_SCH_L2MEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((schL2MeasInfo->timePrd !=0) &&
(measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL))
{
err->errType = RGSCHERR_SCH_INVALID_QCI_VAL;
err->errCause = RGSCHERR_SCH_L2MEAS;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHUtlValidateMeasReq */
#endif /* LTE_L2_MEAS */
/******* </AllocHolesMemMgmnt>: END *****/
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrSiCfgCfm: "
"RgUiRgrSiCfgCfm Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlRgrSiCfgCfm */
\f
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrSiCfgCfm: "
"RgUiRgrSiCfgCfm Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlRgrWarningSiCfgCfm */
/***********************************************************
}
}/*if(isNewTx == TRUE) */
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHUtlGetSchdUes*/
\f
/* ccpu00117452 - MOD - Changed macro name from
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Could not send "
"CQI reports for RNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* End of rgSCHUtlFillSndStaInd */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHUtlRgrStaInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RgUiRgrStaInd(&(cell->rgrSap->sapCfg.sapPst),
cell->rgrSap->sapCfg.suId, rgrSta);
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgrStaInd*/
#endif /* End of RGR_CQI_REPT */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHUtlRgrLoadInfInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RgUiRgrLoadInfInd(&(cell->rgrSap->sapCfg.sapPst),
cell->rgrSap->sapCfg.suId, rgrLoadInf);
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgrLoadInfInd*/
/* LTE_ADV_FLAG_REMOVED_END */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Could not send "
"UE Sta reports CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* End of rgSCHUtlFillSndStaInd */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHUtlRgrUeStaInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RgUiRgrUeStaInd(&(cell->rgrSap->sapCfg.sapPst),
cell->rgrSap->sapCfg.suId, rgrUeSta);
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgrStaInd*/
/* RRM_RBC_X */
cell->rgmSap->sapCfg.sapPst.pool, (Data**)&prbRprtInd,
sizeof(RgmPrbRprtInd)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8 *) &prbRprtInd->stQciPrbRpts[0],
cell->rgmSap->sapCfg.suId, prbRprtInd);
- RETVALUE(ret);
+ return (ret);
}
/* RRM_RBC_Y */
if (distance > RGSCH_PCCHBCCH_WIN)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHChkBoUpdate*/
/* Fetch the corresponding UL slot Idx in UL sf array */
reTxIdx = rgSCHCmnGetUlSfIdx(&phichTime, cell);
}
- RETVALUE(reTxIdx);
+ return (reTxIdx);
}
#endif
break;
}
- RETVALUE(pcqiSz);
+ return (pcqiSz);
}
#endif
#endif
//Currently hardcoding MAX prb for each UE
nPrb = ue->ue5gtfCb.maxPrb;
(*numSbs) = RGSCH_CEIL(nPrb, MAX_5GTF_VRBG_SIZE);
- RETVALUE(ROK);
+ return ROK;
}
/**
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
/* code Coverage portion of the test case */
RgSchMacLcgReg(&pst, &lcgRegReq);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef TFU_UPGRADE
}
break;
}
- RETVALUE(mode);
+ return (mode);
}
#endif /* TFU_TDD */
#endif /* LTE_ADV */
break;
}
- RETVALUE(maxTbCount);
+ return (maxTbCount);
}
/**
schCmnCell->ul.maxUeNewTxPerTti;
}
- RETVALUE(ROK);
+ return ROK;
}
/* Check and Update numUEPer TTI based CPU overload instruction before
* going for TP based CPU OL
rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns);
/* If need to have both TP and numUePerTti instrcution together in
* one command then dont return from here */
- RETVALUE(ROK);
+ return ROK;
}
crntDlCpuOL = (crntCpuOvrLdIns & RGR_CPU_OVRLD_DL_TPT_UP) +\
(crntDlCpuOL != RGR_CPU_OVRLD_DL_TPT_DOWN))
{
/* Cfg validation failed. Invalid Command. Either UP/DOWN is allowed */
- RETVALUE(RFAILED);
+ return RFAILED;
}
crntUlCpuOL = (crntCpuOvrLdIns & RGR_CPU_OVRLD_UL_TPT_UP) +\
(crntCpuOvrLdIns & RGR_CPU_OVRLD_UL_TPT_DOWN);
(crntUlCpuOL != RGR_CPU_OVRLD_UL_TPT_DOWN))
{
/* Cfg validation failed. Invalid Command. Either UP/DOWN is allowed */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((crntDlCpuOL == 0) && (crntUlCpuOL == 0))
{
/* Cfg validation failed. Invalid Command. Either UP/DOWN is allowed */
- RETVALUE(RFAILED);
+ return RFAILED;
}
cell->cpuOvrLdCntrl.cpuOvrLdIns = crntCpuOvrLdIns;
#endif
}
rgSCHUtlCpuOvrLdAdjItbsCap(cell);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef EMTC_ENABLE
PUBLIC S16 rgSCHUtlAddToResLst
{
cmLListAdd2Tail(cp, &iotRes->resLnk);
iotRes->resLnk.node = (PTR)iotRes;
- RETVALUE(ROK);
+ return ROK;
}
PUBLIC S16 rgSCHUtlDelFrmResLst
(
if(cp->count == 0)
{
RLOG0(L_INFO,"****error count*****\n");
- RETVALUE(ROK);
+ return ROK;
}
}
cmLListDelFrm(cp, &iotRes->resLnk);
iotRes->resLnk.node = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
#endif
/**********************************************************************
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
- RETVALUE(NULLP);
+ return (NULLP);
#endif
if(lCp->count == 0)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
if (lCp->count == 1)
{
lCp->first = lCp->crnt = (RgSchRrCList *)NULLP;
lCp->count = 0;
node->next = node->prev = (RgSchRrCList *)NULLP;
- RETVALUE(node);
+ return (node);
}
- RETVALUE(NULLP);
+ return (NULLP);
}
if (lCp->first == node)
/* Adding this check and guarding the decrement of counter when
node is deleted with reshuffling */
lCp->count--;
- RETVALUE(node);
+ return (node);
}
if(node->prev && node->next)
lCp->crnt = node->next;
}
node->next = node->prev = (RgSchRrCList *)NULLP;
- RETVALUE(node);
+ return (node);
} /* end of rgSCHRrCListDelFrm */
/*
Inst inst = (instId - SCH_INST_START);
/* Initialize the MAC TskInit structure to zero */
- cmMemset ((uint8_t *)&schCb[inst], 0, sizeof(schCb));
+ memset ((uint8_t *)&schCb[inst], 0, sizeof(schCb));
/* Initialize the MAC TskInit with received values */
schCb[inst].schInit.ent = entity;
* -# LCM_REASON_INVALID_MSGTYPE
* -# LCM_REASON_MEM_NOAVAIL
**/
-PUBLIC U16 SchInstCfg(RgCfg *cfg, Inst dInst)
+PUBLIC uint8_t SchInstCfg(RgCfg *cfg, Inst dInst)
{
uint16_t ret = LCM_REASON_NOT_APPL;
Inst inst = (dInst - SCH_INST_START);
return LCM_REASON_INVALID_MSGTYPE;
}
/* Update the Pst structure for LM interface */
- cmMemcpy((U8 *)&schCb[inst].schInit.lmPst,
- (U8 *)&cfg->s.schInstCfg.genCfg.lmPst,
+ memcpy((uint8_t *)&schCb[inst].schInit.lmPst,
+ (uint8_t *)&cfg->s.schInstCfg.genCfg.lmPst,
sizeof(Pst));
schCb[inst].schInit.inst = inst;
schCb[inst].genCfg.startCellId = cfg->s.schInstCfg.genCfg.startCellId;
#if 0
/* Initialzie the timer queue */
- cmMemset((U8 *)&schCb[inst].tmrTq, 0, sizeof(CmTqType)*RGSCH_TQ_SIZE);
+ memset((uint8_t *)&schCb[inst].tmrTq, 0, sizeof(CmTqType)*RGSCH_TQ_SIZE);
/* Initialize the timer control point */
- cmMemset((U8 *)&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
+ memset((uint8_t *)&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
schCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE;
/* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */
/* Timer Registration request to SSI */
- if (SRegTmrMt(schCb[inst].schInit.ent, dInst,
- (S16)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK)
+ if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst,
+ (int)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "SchInstCfg(): Failed to "
"register timer.");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ return (LCM_REASON_MEM_NOAVAIL);
}
#endif
/* Set Config done in TskInit */
* @return S16
* -# ROK
**/
-int SchProcGenCfgReq(Pst *pst, RgMngmt *cfg)
+uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg)
{
- uint16_t ret = LCM_PRIM_OK;
+ uint8_t ret = LCM_PRIM_OK;
uint16_t reason = LCM_REASON_NOT_APPL;
RgMngmt cfm;
Pst cfmPst;
memset(&cfmPst, 0 , sizeof(Pst));
SchFillCfmPst(pst, &cfmPst, cfg);
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset((uint8_t *)&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId =
* -# ROK
* -# RFAILED
**/
-int schInitCellCb(Inst inst, SchCellCfg *schCellCfg)
+uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg)
{
SchCellCb *cell;
SCH_ALLOC(cell, sizeof(SchCellCb));
* RFAILED - failure
*
* ****************************************************************/
-int sendDlAllocToMac(DlSchedInfo *dlSchedInfo, Inst inst)
+uint8_t sendDlAllocToMac(DlSchedInfo *dlSchedInfo, Inst inst)
{
Pst pst;
if(ret != ROK)
{
DU_LOG("\nschBroadcastAlloc failed");
- RETVALUE(ret);
+ return (ret);
}
}
if(ret != ROK)
{
DU_LOG("\nSending DL Broadcast allocation from SCH to MAC failed");
- RETVALUE(ret);
+ return (ret);
}
schInitDlSlot(cell->schDlSlotInfo[slot]);
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
{ \
- cmMemset((U8*)_datPtr, 0, _size); \
+ memset((U8*)_datPtr, 0, _size); \
} \
else \
{ \
(ErrVal)ECKW001, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, spId, mBuf, ECKW002, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, ECKW003, pst);
pst->event = (Event) CKW_EVT_BND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /*end of function cmPkCkwBndReq*/
\f
/*
(ErrVal)ECKW004, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, reason, mBuf, ECKW005, pst);
CMCHKPKLOG(SPkS16, spId, mBuf, ECKW006, pst);
pst->event = (Event) CKW_EVT_UBND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /*end of function cmPkCkwUbndReq*/
\f
/*
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
- CMCHKPKLOG(SPkU8, status, mBuf, ECKW008, pst);
+ CMCHKPKLOG(oduUnpackUInt8, status, mBuf, ECKW008, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, ECKW009, pst);
pst->event = (Event) CKW_EVT_BND_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /*end of function cmPkCkwBndCfm*/
\f
{
TRC3(cmPkRlcTmInfo)
- CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dl.buffSize, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcTmInfo */
\f
{
case CKW_CFG_DIR_DL:
{
- CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.dl.snLen, mBuf);
break;
}
case CKW_CFG_DIR_UL:
{
- CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
- CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reOrdTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.snLen, mBuf);
break;
}
/* Patch ckw_c_001.main_3 */
case CKW_CFG_DIR_BOTH:
{
- CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
- CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
- CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.dl.snLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reOrdTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.snLen, mBuf);
break;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcUmInfo */
\f
TRC3(cmPkRlcAmInfo)
/* UP LINK */
- CMCHKPK(SPkU8, param->ul.reOrdTmr, mBuf);
- CMCHKPK(SPkU16, param->ul.staProhTmr, mBuf);
- CMCHKPK(SPkU8, param->ul.snLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ul.reOrdTmr, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ul.staProhTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ul.snLen, mBuf);
/* DOWN LINK */
- CMCHKPK(SPkU8, param->dl.maxRetx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dl.maxRetx, mBuf);
CMCHKPK(SPkS32, param->dl.pollByte, mBuf);
CMCHKPK(SPkS16, param->dl.pollPdu, mBuf);
- CMCHKPK(SPkU16, param->dl.pollRetxTmr, mBuf);
- CMCHKPK(SPkU8, param->dl.snLen, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dl.pollRetxTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dl.snLen, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcAmInfo */
\f
{
TRC3(cmPkCkwLChInfo)
- CMCHKPK(SPkU8, param->type, mBuf);
- CMCHKPK(SPkU8, param->lChId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lChId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCkwLChInfo */
\f
CMCHKPK(SPkS16, param->rguSapId, mBuf);
#endif
CMCHKPK(SPkS16, param->discardTmr, mBuf);
- CMCHKPK(SPkU8, param->dir, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
CMCHKPK(cmPkLteRlcMode, param->entMode, mBuf);
- CMCHKPK(SPkU8, param->qci, mBuf);
- CMCHKPK(SPkU8, param->rbType, mBuf);
- CMCHKPK(SPkU8, param->rbId, mBuf);
- CMCHKPK(SPkU8, param->cfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcEntCfgInfo */
\f
CMCHKPK(cmPkRlcEntCfgInfo, &(param->entCfg[idx]), mBuf);
}
- CMCHKPK(SPkU8, param->numEnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numEnt, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW010, pst);
+ CMCHKPKLOG(oduUnpackUInt32, param->transId, mBuf, ECKW010, pst);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcCfgInfo */
\f
TRC3(cmPkRlcEntCfgCfmInfo)
CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
- CMCHKPK(SPkU8, param->rbType, mBuf);
- CMCHKPK(SPkU8, param->rbId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcEntCfgCfmInfo */
\f
CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
}
- CMCHKPK(SPkU8, param->numEnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numEnt, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
+ CMCHKPKLOG(oduUnpackUInt32, param->transId, mBuf, ECKW014, pst);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRlcCfgCfmInfo */
\f
(ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
switch(pst->selector)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECKW016, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
sizeof(RlcCfgCfmInfo)) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
pst->event = (Event) CKW_EVT_CFG_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkRlcCfgCfm */
/*
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
sizeof(CkwUeInfo)) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
sizeof(CkwUeInfo)) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPKLOG(SPkU32, transId, mBuf, ECKW019, pst);
+ CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, ECKW019, pst);
CMCHKPKLOG(SPkS16, spId, mBuf, ECKW020, pst);
pst->event = (Event) CKW_EVT_UEIDCHG_REQ;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkCkwUeIdChgReq */
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPK(cmPkCmStatus, &status, mBuf);
sizeof(CkwUeInfo)) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPKLOG(SPkU32, transId, mBuf, ECKW022, pst);
+ CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, ECKW022, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, ECKW023, pst);
pst->event = (Event) CKW_EVT_UEIDCHG_CFM;
- RETVALUE(SPstTsk(pst, mBuf));
+ return (SPstTsk(pst, mBuf));
} /* cmPkCkwUeIdChgCfm */
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
} /*end of function cmUnpkCkwBndReq*/
\f
/*
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
} /*end of function cmUnpkCkwUbndReq*/
\f
/*
TRC3(cmUnpkCkwBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
- CMCHKUNPKLOG(SUnpkU8, &status, mBuf, ECKW029, pst);
+ CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, ECKW029, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
} /*end of function cmUnpkCkwBndCfm*/
\f
{
TRC3(cmUnpkRlcTmInfo)
- CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
+ CMCHKUNPK(oduPackUInt32, &(param->dl.buffSize), mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcTmInfo */
\f
{
case CKW_CFG_DIR_DL:
{
- CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.dl.snLen), mBuf);
break;
}
case CKW_CFG_DIR_UL:
{
- CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.snLen), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
break;
}
/* Patch ckw_c_001.main_3 */
case CKW_CFG_DIR_BOTH:
{
- CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.snLen), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.dl.snLen), mBuf);
break;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcUmInfo */
\f
TRC3(cmUnpkRlcAmInfo)
/* DOWN LINK */
- CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
- CMCHKUNPK(SUnpkU16, &(param->dl.pollRetxTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->dl.snLen), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(param->dl.pollRetxTmr), mBuf);
CMCHKUNPK(SUnpkS16, &(param->dl.pollPdu), mBuf);
CMCHKUNPK(SUnpkS32, &(param->dl.pollByte), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->dl.maxRetx), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->dl.maxRetx), mBuf);
/* UP LINK */
- CMCHKUNPK(SUnpkU8, &(param->ul.snLen), mBuf);
- CMCHKUNPK(SUnpkU16, &(param->ul.staProhTmr), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->ul.snLen), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(param->ul.staProhTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->ul.reOrdTmr), mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcAmInfo */
\f
{
TRC3(cmUnpkCkwLChInfo)
- CMCHKUNPK(SUnpkU8, &(param->lChId), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->type), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->lChId), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->type), mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCkwLChInfo */
\f
{
TRC3(cmUnpkRlcEntCfgCfmInfo)
- CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->rbId), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->rbType), mBuf);
CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcEntCfgCfmInfo */
\f
TRC3(cmUnpkRlcCfgCfmInfo)
- CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
+ CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW030, pst);
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->numEnt), mBuf);
for (idx = 0; idx < param->numEnt; idx++)
{
CMCHKUNPK(cmUnpkRlcEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcCfgCfmInfo */
\f
{
TRC3(cmUnpkRlcEntCfgInfo)
- CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->qci), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->cfgType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->rbId), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->rbType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->qci), mBuf);
CMCHKUNPK(cmUnpkLteRlcMode, &(param->entMode), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->dir), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->dir), mBuf);
CMCHKUNPK(SUnpkS16, &(param->discardTmr), mBuf);
#ifdef TENB_MULT_CELL_SUPPRT
CMCHKUNPK(SUnpkS16, &(param->rguSapId), mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcEntCfgInfo */
\f
TRC3(cmUnpkRlcCfgInfo)
- CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
+ CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW031, pst);
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
- CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->numEnt), mBuf);
for (idx = 0; idx < param->numEnt; idx++)
{
CMCHKUNPKLOG(cmUnpkRlcEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRlcCfgInfo */
\f
(ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)cfgCfmInfo, 0, sizeof(RlcCfgCfmInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)ECKW036, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
break;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, cfgCfmInfo));
+ return ((*func)(pst, suId, cfgCfmInfo));
} /* cmUnpkRlcCfgCfm */
/*
CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*
CMCHKUNPK(SUnpkS16, &(spId), mBuf);
- CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW037, pst);
+ CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW037, pst);
if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
sizeof(CkwUeInfo))) != ROK)
(ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)ECKW039, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
(ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)ECKW041, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
+ return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
} /* cmUnpkCkwUeIdChgReq */
cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
CMCHKUNPK(SUnpkS16, &suId, mBuf);
- CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW042, pst);
+ CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, ECKW042, pst);
if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
sizeof(CkwUeInfo))) != ROK)
(ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)ECKW044, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+ return ((*func)(pst, suId, transId, ueInfo, status));
} /* cmUnpkCkwUeIdChgCfm */
/*-- cm_gen_c_001.main_36 - added for micro seconds --*/
#ifdef SS_DATETIME_USEC
- CMCHKPK(SPkU32, dateTime->usec, mBuf);
+ CMCHKPK(oduUnpackUInt32, dateTime->usec, mBuf);
#endif /*-- SS_DATETIME_USEC --*/
- CMCHKPK(SPkU8, dateTime->tenths, mBuf);
- CMCHKPK(SPkU8, dateTime->sec, mBuf);
- CMCHKPK(SPkU8, dateTime->min, mBuf);
- CMCHKPK(SPkU8, dateTime->hour, mBuf);
- CMCHKPK(SPkU8, dateTime->year, mBuf);
- CMCHKPK(SPkU8, dateTime->day, mBuf);
- CMCHKPK(SPkU8, dateTime->month, mBuf);
-
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, dateTime->tenths, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->sec, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->min, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->hour, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->year, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->day, mBuf);
+ CMCHKPK(oduUnpackUInt8, dateTime->month, mBuf);
+
+ return ROK;
} /* end of cmPkDateTime */
\f
{
TRC2(cmPkDuration)
- CMCHKPK(SPkU8, duration->tenths, mBuf);
- CMCHKPK(SPkU8, duration->secs, mBuf);
- CMCHKPK(SPkU8, duration->mins, mBuf);
- CMCHKPK(SPkU8, duration->hours, mBuf);
- CMCHKPK(SPkU8, duration->days, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->tenths, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->secs, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->mins, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->hours, mBuf);
+ CMCHKPK(oduUnpackUInt8, duration->days, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkDuration */
/*
*
-* Fun: cmPkPtr
+* Fun: oduPackPointer
*
* Desc: This function packs the pointer
*
*/
#ifdef ANSI
-PUBLIC S16 cmPkPtr
+PUBLIC S16 oduPackPointer
(
PTR ptr, /* pointer */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmPkPtr(ptr, mBuf)
+PUBLIC S16 oduPackPointer(ptr, mBuf)
PTR ptr; /* pointer */
Buffer *mBuf; /* message buffer */
#endif
U32 tmp32;
#endif
- TRC2(cmPkPtr)
+ TRC2(oduPackPointer)
ret = ROK;
switch (PTRSIZE)
ret = RFAILED;
}
- RETVALUE(ret);
-} /* end of cmPkPtr */
+ return (ret);
+} /* end of oduPackPointer */
\f
/*
CMCHKPK(cmPkInst, entityId->inst, mBuf);
CMCHKPK(cmPkEnt, entityId->ent, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkEntityId */
\f
CMCHKPK(cmPkElmntInst1, elmntId->elmntInst1, mBuf);
CMCHKPK(cmPkElmnt, elmntId->elmnt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkElmntId */
\f
CMCHKPK(cmPkPool, memoryId->pool, mBuf);
CMCHKPK(cmPkRegion, memoryId->region, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkMemoryId */
\f
CMCHKPK(SPkS16, systemId->mRev, mBuf);
CMCHKPK(SPkS16, systemId->mVer, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkSystemId */
TRC3(cmPkProtAddr)
#ifdef CM_ARI2
- CMCHKPK(SPkU32, pAddr->autoSysId, mBuf);
- CMCHKPK(cmPkBool, pAddr->autoSysIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt32, pAddr->autoSysId, mBuf);
+ CMCHKPK(oduPackBool, pAddr->autoSysIdPres, mBuf);
#endif /* CM_ARI2 */
for (j = pAddr->len; j; j--)
- CMCHKPK(SPkU8, pAddr->address[j - 1], mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->address[j - 1], mBuf);
- CMCHKPK(SPkU8, pAddr->preLen, mBuf);
- CMCHKPK(SPkU8, pAddr->len, mBuf);
- CMCHKPK(SPkU16, pAddr->protType, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->preLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, pAddr->protType, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkProtAddr */
TRC3(cmPkProtAddrTbl)
if (protAddr->count > MAX_PROT_ADDRS)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = protAddr->count; i; i--)
{
pAddr = &(protAddr->addr[i - 1]);
#ifdef CM_ARI2
- CMCHKPK(SPkU32, pAddr->autoSysId, mBuf);
- CMCHKPK(cmPkBool, pAddr->autoSysIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt32, pAddr->autoSysId, mBuf);
+ CMCHKPK(oduPackBool, pAddr->autoSysIdPres, mBuf);
#endif /* CM_ARI2 */
for (j = pAddr->len; j; j--)
- CMCHKPK(SPkU8, pAddr->address[j - 1], mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->address[j - 1], mBuf);
- CMCHKPK(SPkU8, pAddr->preLen, mBuf);
- CMCHKPK(SPkU8, pAddr->len, mBuf);
- CMCHKPK(SPkU16, pAddr->protType, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->preLen, mBuf);
+ CMCHKPK(oduUnpackUInt8, pAddr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, pAddr->protType, mBuf);
}
- CMCHKPK(SPkU8, protAddr->count, mBuf);
+ CMCHKPK(oduUnpackUInt8, protAddr->count, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkProtAddrTbl */
TRC2(cmPkAddrs)
if (addrs->length > ADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = addrs->length; i; i--)
{
- CMCHKPK(SPkU8, addrs->strg[i-1], mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->strg[i-1], mBuf);
}
- CMCHKPK(SPkU8, addrs->length, mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->length, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkAddrs */
\f
TRC2(cmPkShrtAddrs)
if (addrs->length > SHRTADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = addrs->length; i; i--)
{
- CMCHKPK(SPkU8, addrs->strg[i-1], mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->strg[i-1], mBuf);
}
- CMCHKPK(SPkU8, addrs->length, mBuf);
+ CMCHKPK(oduUnpackUInt8, addrs->length, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkShrtAddrs */
\f
/* pack address mask */
for (i = (ADRLEN - 1); i >= 0; i--)
{
- CMCHKPK(SPkU8, mask[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, mask[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkAddrMask */
\f
CMCHKPK(cmPkRegion, bndCfg->region, mBuf);
CMCHKPK(cmPkInst, bndCfg->inst, mBuf);
CMCHKPK(cmPkEnt, bndCfg->ent, mBuf);
- CMCHKPK(SPkU8, bndCfg->wdw, mBuf);
- CMCHKPK(SPkU8, bndCfg->flcTyp, mBuf);
- CMCHKPK(SPkU8, bndCfg->bufOwnshp, mBuf);
+ CMCHKPK(oduUnpackUInt8, bndCfg->wdw, mBuf);
+ CMCHKPK(oduUnpackUInt8, bndCfg->flcTyp, mBuf);
+ CMCHKPK(oduUnpackUInt8, bndCfg->bufOwnshp, mBuf);
for (p = bndCfg->usrId; *p; p++);
for (; p != bndCfg->usrId; p--);
CMCHKPK(cmPkTxt, *p, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkBndCfg */
\f
CMCHKPK(cmPkIntfVer, pst->intfVer, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkPst */
/*
TRC2(cmPkElmtHdr)
#if (LCAMT || ATM_BISUP)
- CMCHKPK(SPkU16, m->compInd, mBuf);
+ CMCHKPK(oduUnpackUInt16, m->compInd, mBuf);
#endif /* LCAMT || ATM_BISUP */
#if (LCAMT || ATM_BISUP)
/* Pack action indicator field */
if (m->pres)
{
- CMCHKPK(SPkU8, m->actnInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, m->actnInd, mBuf);
}
#endif
/* Present */
- CMCHKPK(cmPkBool, m->pres, mBuf);
+ CMCHKPK(oduPackBool, m->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkElmtHdr */
\f
if (tknU8->pres)
{
/* Value */
- CMCHKPK(SPkU8, tknU8->val, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknU8->val, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknU8->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknU8->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknU8 */
\f
}
/* Token Header */
- CMCHKPK(SPkU8, tknS8->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknS8->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknS8 */
\f
if (tknU16->pres)
{
/* Value */
- CMCHKPK(SPkU16, tknU16->val, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknU16->val, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknU16->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknU16->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknU16 */
\f
if (tknU32->pres)
{
/* Value */
- CMCHKPK(SPkU32, tknU32->val, mBuf);
+ CMCHKPK(oduUnpackUInt32, tknU32->val, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknU32->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknU32->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknU32 */
\f
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr */
\f
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrM */
\f
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrS */
\f
/* Value */
for (i = 0; i < (S16) tknStr->len; i++)
{
- CMCHKPK(SPkU8, tknStr->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrE */
#ifndef CMFILE_REORG_1
for (i = PN_NODEID_LEN - 1; i >= 0; i--)
{
- CMCHKPK(SPkU8, src->id[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, src->id[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmPkPnNodeId */
#endif /* CMFILE_REORG_1 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr4 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr12 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr32 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr64 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr132 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr256 */
/* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
* with compilation flag TKNOID_U16 */
#ifndef TKNOID_U16
- CMCHKPK(SPkU32, tknOid->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, tknOid->val[i], mBuf);
#else
- CMCHKPK(SPkU16, tknOid->val[i], mBuf);
+ CMCHKPK(oduUnpackUInt16, tknOid->val[i], mBuf);
#endif /* !TKNOID_U16 */
}
/* Pack the length */
- CMCHKPK(SPkU8, tknOid->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknOid->len, mBuf);
}
/* Pack the token header */
- CMCHKPK(SPkU8, tknOid->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknOid->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknOid */
\f
}
/* Token Header */
- CMCHKPK(SPkU8, tknS32->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknS32->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknS32 */
\f
#endif /* LMINT3 */
CMCHKPK(cmPkElmntId, &header->elmId, mBuf);
CMCHKPK(cmPkEntityId, &header->entId, mBuf);
- CMCHKPK(SPkU16, header->seqNmb, mBuf);
- CMCHKPK(SPkU8, header->version, mBuf);
- CMCHKPK(SPkU8, header->msgType, mBuf);
- CMCHKPK(SPkU16, header->msgLen, mBuf);
+ CMCHKPK(oduUnpackUInt16, header->seqNmb, mBuf);
+ CMCHKPK(oduUnpackUInt8, header->version, mBuf);
+ CMCHKPK(oduUnpackUInt8, header->msgType, mBuf);
+ CMCHKPK(oduUnpackUInt16, header->msgLen, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkHeader */
\f
{
TRC2(cmPkCmStatus)
- CMCHKPK(SPkU16, sta->reason, mBuf);
- CMCHKPK(SPkU16, sta->status, mBuf);
+ CMCHKPK(oduUnpackUInt16, sta->reason, mBuf);
+ CMCHKPK(oduUnpackUInt16, sta->status, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmStatus */
\f
{
TRC2(cmPkCmAlarm)
- CMCHKPK(SPkU16, alarm->cause, mBuf);
- CMCHKPK(SPkU16, alarm->event, mBuf);
- CMCHKPK(SPkU16, alarm->category, mBuf);
+ CMCHKPK(oduUnpackUInt16, alarm->cause, mBuf);
+ CMCHKPK(oduUnpackUInt16, alarm->event, mBuf);
+ CMCHKPK(oduUnpackUInt16, alarm->category, mBuf);
CMCHKPK(cmPkDateTime, &alarm->dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmAlarm */
\f
CMCHKPK(cmPkInst, smCfg->inst, mBuf);
CMCHKPK(cmPkEnt, smCfg->ent, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkSmCfg */
\f
{
TRC2(cmPkTmrCfg)
- CMCHKPK(SPkU16, tmrCfg->val, mBuf);
- CMCHKPK(cmPkBool, tmrCfg->enb, mBuf);
+ CMCHKPK(oduUnpackUInt16, tmrCfg->val, mBuf);
+ CMCHKPK(oduPackBool, tmrCfg->enb, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTmrCfg */
\f
SFndLenMsg(tknBuf->val, &msgLen);
if( SCatMsg(mBuf, tknBuf->val, M2M1) != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkMsgLen(msgLen, mBuf);
SPutMsg(tknBuf->val);
}
/* Token Header */
- CMCHKPK(SPkU8, tknBuf->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknBuf->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknBuf */
#ifdef TDS_ROLL_UPGRADE_SUPPORT
CMCHKPK(cmPkIntfId, intf->intfId, mBuf);
CMCHKPK(cmPkIntfVer, intf->intfVer, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkIntf */
#endif /* TDS_ROLL_UPGRADE_SUPPORT */
{
TRC2(cmUnpDateTime)
- CMCHKUNPK(SUnpkU8, &dateTime->month, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->day, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->year, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->hour, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->min, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->sec, mBuf);
- CMCHKUNPK(SUnpkU8, &dateTime->tenths, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->month, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->day, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->year, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->hour, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->min, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->sec, mBuf);
+ CMCHKUNPK(oduPackUInt8, &dateTime->tenths, mBuf);
/*-- added for micro seconds --*/
#ifdef SS_DATETIME_USEC
- CMCHKUNPK(SUnpkU32, &dateTime->usec, mBuf);
+ CMCHKUNPK(oduPackUInt32, &dateTime->usec, mBuf);
#endif /*-- SS_DATETIME_USEC --*/
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkDateTime */
\f
{
TRC2(cmUnpDuration)
- CMCHKUNPK(SUnpkU8, &duration->days, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->hours, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->mins, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->secs, mBuf);
- CMCHKUNPK(SUnpkU8, &duration->tenths, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->days, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->hours, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->mins, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->secs, mBuf);
+ CMCHKUNPK(oduPackUInt8, &duration->tenths, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkDuration */
/*
*
-* Fun: cmUnpkPtr
+* Fun: oduUnpackPointer
*
* Desc: This function is used to Unpack Ptr type
*
*/
#ifdef ANSI
-PUBLIC S16 cmUnpkPtr
+PUBLIC S16 oduUnpackPointer
(
PTR *ptr, /* duration structure */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 cmUnpkPtr(ptr, mBuf)
+PUBLIC S16 oduUnpackPointer(ptr, mBuf)
PTR *ptr; /* duration structure */
Buffer *mBuf; /* message buffer */
#endif
U64 tmp64;
#endif
- TRC2(cmUnpkPtr)
+ TRC2(oduUnpackPointer)
switch (PTRSIZE)
{
case 2:
ret = SRemPreMsgMult(unpkArray, (MsgLen) 2, mBuf);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
tmp16 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
case 4:
ret = SRemPreMsgMult(unpkArray, (MsgLen) 4, mBuf);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
tmp16 = 0;
tmp32 = 0;
#if(defined(ALPHA) || defined(BIT_64))
ret = SRemPreMsgMult(unpkArray, (MsgLen) 8, mBuf);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
tmp16 = 0;
tmp32 = 0;
ret = RFAILED;
}
- RETVALUE(ret);
-} /* end of cmUnpkPtr */
+ return (ret);
+} /* end of oduUnpackPointer */
\f
/*
CMCHKUNPK(cmUnpkEnt, &entityId->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &entityId->inst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkEntityId */
\f
CMCHKUNPK(cmUnpkElmntInst2, &elmntId->elmntInst2, mBuf);
CMCHKUNPK(cmUnpkElmntInst3, &elmntId->elmntInst3, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkElmntId */
\f
CMCHKUNPK(cmUnpkRegion, &memoryId->region, mBuf);
CMCHKUNPK(cmUnpkPool, &memoryId->pool, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkMemoryId */
\f
CMCHKUNPK(cmUnpkTxt, &systemId->ptNmb[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkSystemId */
TRC3(cmUnpkProtAddr)
- CMCHKUNPK(SUnpkU16, &(pAddr->protType), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->len), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->preLen), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(pAddr->protType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->len), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->preLen), mBuf);
for (j =0; j < pAddr->len; j++)
- CMCHKUNPK(SUnpkU8, &pAddr->address[j], mBuf);
+ CMCHKUNPK(oduPackUInt8, &pAddr->address[j], mBuf);
#ifdef CM_ARI2
- CMCHKUNPK(cmUnpkBool, &(pAddr->autoSysIdPres), mBuf);
- CMCHKUNPK(SUnpkU32, &(pAddr->autoSysId), mBuf);
+ CMCHKUNPK(oduUnpackBool, &(pAddr->autoSysIdPres), mBuf);
+ CMCHKUNPK(oduPackUInt32, &(pAddr->autoSysId), mBuf);
#endif /* CM_ARI2 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkProtAddr */
TRC3(cmUnpkProtAddrTbl)
- CMCHKUNPK(SUnpkU8, &protAddr->count, mBuf);
+ CMCHKUNPK(oduPackUInt8, &protAddr->count, mBuf);
for (i = 0; i < protAddr->count; i++)
{
pAddr = &(protAddr->addr[i]);
- CMCHKUNPK(SUnpkU16, &(pAddr->protType), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->len), mBuf);
- CMCHKUNPK(SUnpkU8, &(pAddr->preLen), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(pAddr->protType), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->len), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(pAddr->preLen), mBuf);
for (j =0; j < pAddr->len; j++)
- CMCHKUNPK(SUnpkU8, &pAddr->address[j], mBuf);
+ CMCHKUNPK(oduPackUInt8, &pAddr->address[j], mBuf);
#ifdef CM_ARI2
- CMCHKUNPK(cmUnpkBool, &(pAddr->autoSysIdPres), mBuf);
- CMCHKUNPK(SUnpkU32, &(pAddr->autoSysId), mBuf);
+ CMCHKUNPK(oduUnpackBool, &(pAddr->autoSysIdPres), mBuf);
+ CMCHKUNPK(oduPackUInt32, &(pAddr->autoSysId), mBuf);
#endif /* CM_ARI2 */
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkProtAddrTbl */
TRC2(cmUnpAddrs)
- CMCHKUNPK(SUnpkU8, &addrs->length, mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
if (addrs->length > ADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for(i = 0; i < addrs->length; i++)
{
- CMCHKUNPK(SUnpkU8, &addrs->strg[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->strg[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkAddrs */
/*
TRC2(cmUnpShrtAddrs)
- CMCHKUNPK(SUnpkU8, &addrs->length, mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
if (addrs->length > SHRTADRLEN)
- RETVALUE(RFAILED);
+ return RFAILED;
for(i = 0; i < addrs->length; i++)
{
- CMCHKUNPK(SUnpkU8, &addrs->strg[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &addrs->strg[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkShrtAddrs */
\f
/* unpack address mask */
for (i = 0; i< ADRLEN; i++)
{
- CMCHKUNPK(SUnpkU8, &mask[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &mask[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkAddrMask */
\f
for (i = 0; bndCfg->usrId[i]; i++);
CMCHKUNPK(cmUnpkTxt, bndCfg->usrId+i, mBuf);
- CMCHKUNPK(SUnpkU8, &bndCfg->bufOwnshp, mBuf);
- CMCHKUNPK(SUnpkU8, &bndCfg->flcTyp, mBuf);
- CMCHKUNPK(SUnpkU8, &bndCfg->wdw, mBuf);
+ CMCHKUNPK(oduPackUInt8, &bndCfg->bufOwnshp, mBuf);
+ CMCHKUNPK(oduPackUInt8, &bndCfg->flcTyp, mBuf);
+ CMCHKUNPK(oduPackUInt8, &bndCfg->wdw, mBuf);
CMCHKUNPK(cmUnpkEnt, &bndCfg->ent, mBuf);
CMCHKUNPK(cmUnpkInst, &bndCfg->inst, mBuf);
CMCHKUNPK(cmUnpkRegion, &bndCfg->region, mBuf);
CMCHKUNPK(cmUnpkAddrs, &bndCfg->sapAdr, mBuf);
CMCHKUNPK(cmUnpkSelector, &bndCfg->selector, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkBndCfg */
\f
CMCHKUNPK(cmUnpkInst, &pst->srcInst, mBuf);
CMCHKUNPK(cmUnpkEvent, &pst->event, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkPst */
/*
TRC2(cmUnpElmtHdr)
/* Present */
- CMCHKUNPK(cmUnpkBool, &m->pres , mBuf);
+ CMCHKUNPK(oduUnpackBool, &m->pres , mBuf);
#if (LCAMT || ATM_BISUP)
/* Unpack action indicator field */
if (m->pres)
{
- CMCHKUNPK(SUnpkU8, &m->actnInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, &m->actnInd, mBuf);
}
#endif
#if (LCAMT || ATM_BISUP)
- CMCHKUNPK(SUnpkU16, &m->compInd, mBuf);
+ CMCHKUNPK(oduPackUInt16, &m->compInd, mBuf);
#endif /* LCAMT || ATM_BISUP */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkElmtHdr */
\f
TRC2(cmUnpTknU8)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknU8->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknU8->pres, mBuf);
if (tknU8->pres)
{
/* Value */
- CMCHKUNPK(SUnpkU8, &tknU8->val, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknU8->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknU8 */
\f
TRC2(cmUnpTknS8)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknS8->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknS8->pres, mBuf);
if (tknS8->pres)
{
CMCHKUNPK(SUnpkS8, &tknS8->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknS8 */
\f
TRC2(cmUnpTknU16)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknU16->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknU16->pres, mBuf);
if (tknU16->pres)
{
/* Value */
- CMCHKUNPK(SUnpkU16, &tknU16->val, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknU16->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknU16 */
\f
TRC2(cmUnpTknU32)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknU32->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknU32->pres, mBuf);
if (tknU32->pres)
{
/* Value */
- CMCHKUNPK(SUnpkU32, &tknU32->val, mBuf);
+ CMCHKUNPK(oduPackUInt32, &tknU32->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknU32 */
/*
TRC2(cmUnpTknStr)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr */
/*
TRC2(cmUnpTknStrM)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrM */
\f
TRC2(cmUnpTknStrS)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrS */
\f
TRC2(cmUnpTknStrE)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if (tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (i = (tknStr->len - 1); i >= 0; i--)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[i], mBuf);
}
}
else
tknStr->len = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrE */
#ifndef CMFILE_REORG_1
for (i = 0; i < PN_NODEID_LEN; i++)
{
- CMCHKUNPK(SUnpkU8, &dst->id[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, &dst->id[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkPnNodeId */
#endif /* CMFILE_REORG_1 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr4 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr12 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr32 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr64 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr132 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr256 */
TRC2(cmUnpkTknOid)
/* Unpack the token header */
- CMCHKUNPK(SUnpkU8, &tknOid->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknOid->pres, mBuf);
if (tknOid->pres == TRUE)
{
/* Unpack the length */
- CMCHKUNPK(SUnpkU8, &tknOid->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknOid->len, mBuf);
/* Pack the value */
for (i = 1; i <= (U16)tknOid->len; i++)
/* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
* with compilation flag TKNOID_U16 */
#ifndef TKNOID_U16
- CMCHKUNPK(SUnpkU32, &tknOid->val[tknOid->len - i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &tknOid->val[tknOid->len - i], mBuf);
#else
- CMCHKUNPK(SUnpkU16, &tknOid->val[tknOid->len - i], mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknOid->val[tknOid->len - i], mBuf);
#endif /* !TKNOID_U16 */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknOid */
\f
TRC2(cmUnpTknS32)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknS32->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknS32->pres, mBuf);
if (tknS32->pres)
{
CMCHKUNPK(SUnpkS32, &tknS32->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknS32 */
\f
{
TRC2(cmUnpHeader)
- CMCHKUNPK(SUnpkU16, &header->msgLen, mBuf);
- CMCHKUNPK(SUnpkU8, &header->msgType, mBuf);
- CMCHKUNPK(SUnpkU8, &header->version, mBuf);
- CMCHKUNPK(SUnpkU16, &header->seqNmb, mBuf);
+ CMCHKUNPK(oduPackUInt16, &header->msgLen, mBuf);
+ CMCHKUNPK(oduPackUInt8, &header->msgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &header->version, mBuf);
+ CMCHKUNPK(oduPackUInt16, &header->seqNmb, mBuf);
CMCHKUNPK(cmUnpkEntityId, &header->entId, mBuf);
CMCHKUNPK(cmUnpkElmntId, &header->elmId, mBuf);
#ifdef LMINT3
CMCHKUNPK(cmUnpkMemoryId, &header->response.mem, mBuf);
#endif /* LMINT3 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkHeader */
\f
{
TRC2(cmUnpkCmStatus)
- CMCHKUNPK(SUnpkU16, &sta->status, mBuf);
- CMCHKUNPK(SUnpkU16, &sta->reason, mBuf);
+ CMCHKUNPK(oduPackUInt16, &sta->status, mBuf);
+ CMCHKUNPK(oduPackUInt16, &sta->reason, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmStatus */
\f
TRC2(cmUnpkCmAlarm)
CMCHKUNPK(cmUnpkDateTime, &alarm->dt, mBuf);
- CMCHKUNPK(SUnpkU16, &alarm->category, mBuf);
- CMCHKUNPK(SUnpkU16, &alarm->event, mBuf);
- CMCHKUNPK(SUnpkU16, &alarm->cause, mBuf);
+ CMCHKUNPK(oduPackUInt16, &alarm->category, mBuf);
+ CMCHKUNPK(oduPackUInt16, &alarm->event, mBuf);
+ CMCHKUNPK(oduPackUInt16, &alarm->cause, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmAlarm */
\f
CMCHKUNPK(cmUnpkRoute, &smCfg->route, mBuf);
CMCHKUNPK(cmUnpkSelector, &smCfg->selector, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkSmCfg */
\f
{
TRC2(cmUnpTmrCfg)
- CMCHKUNPK(cmUnpkBool, &tmrCfg->enb, mBuf);
- CMCHKUNPK(SUnpkU16, &tmrCfg->val, mBuf);
+ CMCHKUNPK(oduUnpackBool, &tmrCfg->enb, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tmrCfg->val, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTmrCfg */
/*
mBuf = *tBuf;
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknBuf->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknBuf->pres, mBuf);
if(tknBuf->pres)
{
{
if( SSegMsg(mBuf, msgLen, &tknBuf->val) != ROK )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
*tBuf = mBuf;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknBuf */
#ifdef TDS_ROLL_UPGRADE_SUPPORT
CMCHKUNPK(cmUnpkIntfVer, &intf->intfVer, mBuf);
CMCHKUNPK(cmUnpkIntfId, &intf->intfId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkIntf */
#endif /* TDS_ROLL_UPGRADE_SUPPORT */
/* system services typedefs */
-#define cmPkBool(x, mBuf) SPkU8(x, mBuf) /* pack Bool */
+#define oduPackBool(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Bool */
#define cmPkStatus(x, mBuf) SPkS16(x, mBuf) /* pack Status */
-#define cmPkTicks(x, mBuf) SPkU32(x, mBuf) /* pack Ticks */
+#define cmPkTicks(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Ticks */
#define cmPkQLen(x, mBuf) SPkS16(x, mBuf) /* pack QLen */
#define cmPkOrder(x, mBuf) SPkS16(x, mBuf) /* pack Order */
-#define cmPkData(x, mBuf) SPkU8(x, mBuf) /* pack Data */
-#define cmPkRandom(x, mBuf) SPkU16(x, mBuf) /* pack Random */
+#define cmPkData(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Data */
+#define cmPkRandom(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Random */
#define cmPkSeq(x, mBuf) SPkS16(x, mBuf) /* pack Seq */
#define cmPkReason(x, mBuf) SPkS16(x, mBuf) /* pack Reason */
-#define cmPkProcId(x, mBuf) SPkU16(x, mBuf) /* pack ProcId */
+#define cmPkProcId(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack ProcId */
#define cmPkVectNmb(x, mBuf) SPkS16(x, mBuf) /* pack VectNmb */
-#define cmPkPrior(x, mBuf) SPkU8(x, mBuf) /* pack Prior*/
+#define cmPkPrior(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Prior*/
#define cmPkPriority(x, mBuf) cmPkPrior(x, mBuf) /* pack Priority */
-#define cmPkRoute(x, mBuf) SPkU8(x, mBuf) /* pack Route */
+#define cmPkRoute(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Route */
#define cmPkTtype(x, mBuf) SPkS16(x, mBuf) /* pack Ttype */
#define cmPkSema(x, mBuf) SPkS8(x, mBuf) /* pack Sema */
#define cmPkTxt(x, mBuf) SPkS8(x, mBuf) /* pack Txt */
-#define cmPkEnt(x, mBuf) SPkU8(x, mBuf) /* pack Ent */
-#define cmPkInst(x, mBuf) SPkU8(x, mBuf) /* pack Inst */
+#define cmPkEnt(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Ent */
+#define cmPkInst(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Inst */
#define cmPkElmnt(x, mBuf) SPkS16(x, mBuf) /* pack Elmnt */
#define cmPkElmntInst1(x, mBuf) SPkS16(x, mBuf) /* pack ElmntInst1 */
#define cmPkElmntInst2(x, mBuf) SPkS16(x, mBuf) /* pack ElmntInst2 */
#define cmPkElmntInst3(x, mBuf) SPkS16(x, mBuf) /* pack ElmntInst3 */
-#define cmPkRegion(x, mBuf) SPkU8(x, mBuf) /* pack Region */
-#define cmPkPool(x, mBuf) SPkU8(x, mBuf) /* pack Pool */
+#define cmPkRegion(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Region */
+#define cmPkPool(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Pool */
#ifdef LONG_MSG
#define cmPkMsgLen(x, mBuf) SPkS32(x, mBuf) /* pack MsgLen */
#else
#define cmPkMsgLen(x, mBuf) SPkS16(x, mBuf) /* pack MsgLen */
#endif
#ifdef DOS
-#define cmPkSize(x, mBuf) SPkU16(x, mBuf) /* pack Size */
+#define cmPkSize(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Size */
#else
-#define cmPkSize(x, mBuf) SPkU32(x, mBuf) /* pack Size */
+#define cmPkSize(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Size */
#endif /* DOS */
/* general typedefs */
-#define cmPkSelector(x, mBuf) SPkU8(x, mBuf) /* pack Selector */
-#define cmPkEvent(x, mBuf) SPkU8(x, mBuf) /* pack Event */
+#define cmPkSelector(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Selector */
+#define cmPkEvent(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Event */
#define cmPkCntr(x, mBuf) SPkS32(x, mBuf) /* pack Cntr */
-#define cmPkStsCntr(x, mBuf) SPkU32(x, mBuf) /* pack StsCntr */
+#define cmPkStsCntr(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack StsCntr */
#define cmPkLnkNmb(x, mBuf) SPkS16(x, mBuf) /* pack LnkNmb */
#define cmPkSuId(x, mBuf) SPkS16(x, mBuf) /* pack SuId */
#define cmPkSpId(x, mBuf) SPkS16(x, mBuf) /* pack SpId */
#define cmPkSuInstId(x, mBuf) SPkS16(x, mBuf) /* pack SuInstId */
#define cmPkSpInstInd(x, mBuf) SPkS16(x, mBuf) /* pack SpInstInd */
-#define cmPkSapi(x, mBuf) SPkU8(x, mBuf) /* pack Sapi */
-#define cmPkTei(x, mBuf) SPkU8(x, mBuf) /* pack Tei */
-#define cmPkCes(x, mBuf) SPkU8(x, mBuf) /* pack Ces */
-#define cmPkDlci(x, mBuf) SPkU32(x, mBuf) /* pack Dlci */
-#define cmPkCalRef(x, mBuf) SPkU16(x, mBuf) /* pack CalRef */
+#define cmPkSapi(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Sapi */
+#define cmPkTei(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Tei */
+#define cmPkCes(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Ces */
+#define cmPkDlci(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Dlci */
+#define cmPkCalRef(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack CalRef */
#define cmPkOrigin(x, mBuf) SPkS16(x, mBuf) /* pack Origin */
#define cmPkSwtch(x, mBuf) SPkS16(x, mBuf) /* pack Swtch */
-#define cmPkCause(x, mBuf) SPkU8(x, mBuf) /* pack Cause */
-#define cmPkDgn(x, mBuf) SPkU8(x, mBuf) /* pack Dgn */
+#define cmPkCause(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Cause */
+#define cmPkDgn(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Dgn */
#define cmPkAction(x, mBuf) SPkS16(x, mBuf) /* pack Action */
#define cmPkSeqS16(x, mBuf) SPkS16(x, mBuf) /* pack SeqS16 */
-#define cmPkSeqU16(x, mBuf) SPkU16(x, mBuf) /* pack SeqU16 */
+#define cmPkSeqU16(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack SeqU16 */
#define cmPkSeqS24(x, mBuf) SPkS32(x, mBuf) /* pack SeqS24 */
-#define cmPkSeqU24(x, mBuf) SPkU32(x, mBuf) /* pack SeqU24 */
-#define cmPkSetUpArb(x, mBuf) SPkU8(x, mBuf) /* pack SetUpArb */
-#define cmPkEvntType(x, mBuf) SPkU8(x, mBuf) /* pack EvntType */
-#define cmPkState(x, mBuf) SPkU8(x, mBuf) /* pack State */
-#define cmPkMode(x, mBuf) SPkU8(x, mBuf) /* pack Mode */
+#define cmPkSeqU24(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SeqU24 */
+#define cmPkSetUpArb(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack SetUpArb */
+#define cmPkEvntType(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack EvntType */
+#define cmPkState(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack State */
+#define cmPkMode(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Mode */
#define cmPkConnId(x, mBuf) SPkS32(x, mBuf) /* pack ConnId */
/* scc specific typedefs */
/* tcp/ip specific typedefs */
-#define cmPkIpAddr(x, mBuf) SPkU32(x, mBuf) /* pack IpAddr */
-#define cmPkPort(x, mBuf) SPkU16(x, mBuf) /* pack Port */
-#define cmPkCmd(x, mBuf) SPkU8(x, mBuf) /* pack Cmd */
-#define cmPkFlags(x, mBuf) SPkU8(x, mBuf) /* pack Flags */
-#define cmPkTtl(x, mBuf) SPkU8(x, mBuf) /* pack Ttl */
-#define cmPkPrec(x, mBuf) SPkU8(x, mBuf) /* pack Prec */
-#define cmPkWindow(x, mBuf) SPkU32(x, mBuf) /* pack Window */
+#define cmPkIpAddr(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack IpAddr */
+#define cmPkPort(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Port */
+#define cmPkCmd(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Cmd */
+#define cmPkFlags(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Flags */
+#define cmPkTtl(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Ttl */
+#define cmPkPrec(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Prec */
+#define cmPkWindow(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Window */
/* ISUP specific typedefs */
-#define cmPkCirId(x, mBuf) SPkU16(x, mBuf) /* pack CirId */
-#define cmPkCic(x, mBuf) SPkU16(x, mBuf) /* pack Cic */
-#define cmPkSiInstId(x, mBuf) SPkU32(x, mBuf) /* pack SiInstId */
+#define cmPkCirId(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack CirId */
+#define cmPkCic(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Cic */
+#define cmPkSiInstId(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SiInstId */
/* TUP specific typedefs */
-#define cmPkTpInstId(x, mBuf) SPkU32(x, mBuf) /* pack TpInstId */
+#define cmPkTpInstId(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack TpInstId */
/* PNNI specific typedefs */
-#define cmPkPnPortId(x, mBuf) SPkU32(x, mBuf)
+#define cmPkPnPortId(x, mBuf) oduUnpackUInt32(x, mBuf)
\f
/* unpacking macros */
/* system services typedefs */
-#define cmUnpkBool(x, mBuf) SUnpkU8(x, mBuf) /* unpack Bool */
+#define oduUnpackBool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Bool */
#define cmUnpkStatus(x, mBuf) SUnpkS16(x, mBuf) /* unpack Status */
-#define cmUnpkTicks(x, mBuf) SUnpkU32(x, mBuf) /* unpack Ticks */
+#define cmUnpkTicks(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Ticks */
#define cmUnpkQLen(x, mBuf) SUnpkS16(x, mBuf) /* unpack QLen */
#define cmUnpkOrder(x, mBuf) SUnpkS16(x, mBuf) /* unpack Order */
-#define cmUnpkData(x, mBuf) SUnpkU8(x, mBuf) /* unpack Data */
-#define cmUnpkRandom(x, mBuf) SUnpkU16(x, mBuf) /* unpack Random */
+#define cmUnpkData(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Data */
+#define cmUnpkRandom(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Random */
#define cmUnpkSeq(x, mBuf) SUnpkS16(x, mBuf) /* unpack Seq */
#define cmUnpkReason(x, mBuf) SUnpkS16(x, mBuf) /* unpack Reason */
-#define cmUnpkProcId(x, mBuf) SUnpkU16(x, mBuf) /* unpack ProcId */
+#define cmUnpkProcId(x, mBuf) oduPackUInt16(x, mBuf) /* unpack ProcId */
#define cmUnpkVectNmb(x, mBuf) SUnpkS16(x, mBuf) /* unpack VectNmb */
-#define cmUnpkPrior(x, mBuf) SUnpkU8(x, mBuf) /* unpack Prior */
+#define cmUnpkPrior(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Prior */
#define cmUnpkPriority(x, mBuf) cmUnpkPrior(x, mBuf) /* unpack Priority */
-#define cmUnpkRoute(x, mBuf) SUnpkU8(x, mBuf) /* unpack Route */
+#define cmUnpkRoute(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Route */
#define cmUnpkTtype(x, mBuf) SUnpkS16(x, mBuf) /* unpack Ttype */
#define cmUnpkSema(x, mBuf) SUnpkS8(x, mBuf) /* unpack Sema */
#define cmUnpkTxt(x, mBuf) SUnpkS8(x, mBuf) /* unpack Txt */
-#define cmUnpkEnt(x, mBuf) SUnpkU8(x, mBuf) /* unpack Ent */
-#define cmUnpkInst(x, mBuf) SUnpkU8(x, mBuf) /* unpack Inst */
+#define cmUnpkEnt(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Ent */
+#define cmUnpkInst(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Inst */
#define cmUnpkElmnt(x, mBuf) SUnpkS16(x, mBuf) /* unpack Elmnt */
#define cmUnpkElmntInst1(x, mBuf) SUnpkS16(x, mBuf) /* unpack ElmntInst1 */
#define cmUnpkElmntInst2(x, mBuf) SUnpkS16(x, mBuf) /* unpack ElmntInst2 */
#define cmUnpkElmntInst3(x, mBuf) SUnpkS16(x, mBuf) /* unpack ElmntInst3 */
-#define cmUnpkRegion(x, mBuf) SUnpkU8(x, mBuf) /* unpack Region */
-#define cmUnpkPool(x, mBuf) SUnpkU8(x, mBuf) /* unpack Pool */
+#define cmUnpkRegion(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Region */
+#define cmUnpkPool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Pool */
#ifdef LONG_MSG
#define cmUnpkMsgLen(x, mBuf) SUnpkS32(x, mBuf) /* unpack MsgLen */
#else
#define cmUnpkMsgLen(x, mBuf) SUnpkS16(x, mBuf) /* unpack MsgLen */
#endif
#ifdef DOS
-#define cmUnpkSize(x, mBuf) SUnpkU16(x, mBuf) /* unpack Size */
+#define cmUnpkSize(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Size */
#else
-#define cmUnpkSize(x, mBuf) SUnpkU32(x, mBuf) /* unpack Size */
+#define cmUnpkSize(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Size */
#endif /* DOS */
/* general typedefs */
-#define cmUnpkSelector(x, mBuf) SUnpkU8(x, mBuf) /* unpack Selector */
-#define cmUnpkEvent(x, mBuf) SUnpkU8(x, mBuf) /* unpack Event */
+#define cmUnpkSelector(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Selector */
+#define cmUnpkEvent(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Event */
#define cmUnpkCntr(x, mBuf) SUnpkS32(x, mBuf) /* unpack Cntr */
-#define cmUnpkStsCntr(x, mBuf) SUnpkU32(x, mBuf) /* unpack StsCntr */
+#define cmUnpkStsCntr(x, mBuf) oduPackUInt32(x, mBuf) /* unpack StsCntr */
#define cmUnpkLnkNmb(x, mBuf) SUnpkS16(x, mBuf) /* unpack LnkNmb */
#define cmUnpkSuId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SuId */
#define cmUnpkSpId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SpId */
#define cmUnpkSuInstId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SuInstId */
#define cmUnpkSpInstInd(x, mBuf) SUnpkS16(x, mBuf) /* unpack SpInstInd */
-#define cmUnpkSapi(x, mBuf) SUnpkU8(x, mBuf) /* unpack Sapi */
-#define cmUnpkTei(x, mBuf) SUnpkU8(x, mBuf) /* unpack Tei */
-#define cmUnpkCes(x, mBuf) SUnpkU8(x, mBuf) /* unpack Ces */
-#define cmUnpkDlci(x, mBuf) SUnpkU32(x, mBuf) /* unpack Dlci */
-#define cmUnpkCalRef(x, mBuf) SUnpkU16(x, mBuf) /* unpack CalRef */
+#define cmUnpkSapi(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Sapi */
+#define cmUnpkTei(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Tei */
+#define cmUnpkCes(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Ces */
+#define cmUnpkDlci(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Dlci */
+#define cmUnpkCalRef(x, mBuf) oduPackUInt16(x, mBuf) /* unpack CalRef */
#define cmUnpkOrigin(x, mBuf) SUnpkS16(x, mBuf) /* unpack Origin */
#define cmUnpkSwtch(x, mBuf) SUnpkS16(x, mBuf) /* unpack Swtch */
-#define cmUnpkCause(x, mBuf) SUnpkU8(x, mBuf) /* unpack Cause */
-#define cmUnpkDgn(x, mBuf) SUnpkU8(x, mBuf) /* unpack Dgn */
+#define cmUnpkCause(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Cause */
+#define cmUnpkDgn(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Dgn */
#define cmUnpkAction(x, mBuf) SUnpkS16(x, mBuf) /* unpack Action */
#define cmUnpkSeqS16(x, mBuf) SUnpkS16(x, mBuf) /* unpack SeqS16 */
-#define cmUnpkSeqU16(x, mBuf) SUnpkU16(x, mBuf) /* unpack SeqU16 */
+#define cmUnpkSeqU16(x, mBuf) oduPackUInt16(x, mBuf) /* unpack SeqU16 */
#define cmUnpkSeqS24(x, mBuf) SUnpkS32(x, mBuf) /* unpack SeqS24 */
-#define cmUnpkSeqU24(x, mBuf) SUnpkU32(x, mBuf) /* unpack SeqU24 */
-#define cmUnpkSetUpArb(x, mBuf) SUnpkU8(x, mBuf) /* unpack SetUpArb */
-#define cmUnpkEvntType(x, mBuf) SUnpkU8(x, mBuf) /* unpack EvntType */
-#define cmUnpkState(x, mBuf) SUnpkU8(x, mBuf) /* unpack State */
-#define cmUnpkMode(x, mBuf) SUnpkU8(x, mBuf) /* unpack Mode */
+#define cmUnpkSeqU24(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SeqU24 */
+#define cmUnpkSetUpArb(x, mBuf) oduPackUInt8(x, mBuf) /* unpack SetUpArb */
+#define cmUnpkEvntType(x, mBuf) oduPackUInt8(x, mBuf) /* unpack EvntType */
+#define cmUnpkState(x, mBuf) oduPackUInt8(x, mBuf) /* unpack State */
+#define cmUnpkMode(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Mode */
#define cmUnpkConnId(x, mBuf) SUnpkS32(x, mBuf) /* unpack ConnId */
/* scc specific typedefs */
/* tcp/ip specific typedefs */
-#define cmUnpkIpAddr(x, mBuf) SUnpkU32(x, mBuf) /* unpack IpAddr */
-#define cmUnpkPort(x, mBuf) SUnpkU16(x, mBuf) /* unpack Port */
-#define cmUnpkCmd(x, mBuf) SUnpkU8(x, mBuf) /* unpack Cmd */
-#define cmUnpkFlags(x, mBuf) SUnpkU8(x, mBuf) /* unpack Flags */
-#define cmUnpkTtl(x, mBuf) SUnpkU8(x, mBuf) /* unpack Ttl */
-#define cmUnpkPrec(x, mBuf) SUnpkU8(x, mBuf) /* unpack Prec */
-#define cmUnpkWindow(x, mBuf) SUnpkU32(x, mBuf) /* unpack Window */
+#define cmUnpkIpAddr(x, mBuf) oduPackUInt32(x, mBuf) /* unpack IpAddr */
+#define cmUnpkPort(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Port */
+#define cmUnpkCmd(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Cmd */
+#define cmUnpkFlags(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Flags */
+#define cmUnpkTtl(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Ttl */
+#define cmUnpkPrec(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Prec */
+#define cmUnpkWindow(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Window */
/* ISUP specific typedefs */
-#define cmUnpkCirId(x, mBuf) SUnpkU16(x, mBuf) /* unpack CirId */
-#define cmUnpkCic(x, mBuf) SUnpkU16(x, mBuf) /* unpack Cic */
-#define cmUnpkSiInstId(x, mBuf) SUnpkU32(x, mBuf) /* unpack SiInstId */
+#define cmUnpkCirId(x, mBuf) oduPackUInt16(x, mBuf) /* unpack CirId */
+#define cmUnpkCic(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Cic */
+#define cmUnpkSiInstId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SiInstId */
/* TUP specific typedefs */
-#define cmUnpkTpInstId(x, mBuf) SUnpkU32(x, mBuf) /* unpack TpInstId */
+#define cmUnpkTpInstId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack TpInstId */
/* PNNI specific typedefs */
-#define cmUnpkPnPortId(x, mBuf) SUnpkU32(x, mBuf)
+#define cmUnpkPnPortId(x, mBuf) oduPackUInt32(x, mBuf)
#define cmCmpPnNodeId(nodeId1, nodeId2) \
cmCmpStr(&(nodeId1)->id[0], PN_NODEID_LEN, \
&(nodeId2)->id[0], PN_NODEID_LEN)
/* PLOA - HCC profileId */
-#define cmPkProfileId(x, mBuf) SPkU8(x, mBuf) /* pack ProfileId */
+#define cmPkProfileId(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack ProfileId */
-#define cmUnpkProfileId(x, mBuf) SUnpkU8(x, mBuf) /* unpack ProfileId */
+#define cmUnpkProfileId(x, mBuf) oduPackUInt8(x, mBuf) /* unpack ProfileId */
/* packing and unpacking for token strings */
/* Value */ \
for (i = 0; i < (S16) tknStr->len; i++) \
{ \
- CMCHKPK(SPkU8, tknStr->val[i], mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf); \
} \
\
/* Length */ \
- CMCHKPK(SPkU8, tknStr->len, mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf); \
} \
\
/* Token Header */ \
- CMCHKPK(SPkU8, tknStr->pres, mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf); \
}
#define CMUNPKTKNSTR(tknStr, mBuf) \
Cntr i; \
\
/* Token Header */ \
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf); \
\
if(tknStr->pres) \
{ \
/* Length */ \
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf); \
\
/* Value */ \
for (i = 1; i <= (S16) tknStr->len; i++) \
{ \
- CMCHKUNPK(SUnpkU8, &tknStr->val[tknStr->len - i], mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - i], mBuf); \
} \
} \
\
else
*idx = (U16) (c % hashListCp->nmbBins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncAnyKey */
else
*idx = (U16) (sum % hashListCp->nmbBins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncU32Mod () */
else
*idx = (U16) (sum % hashListCp->nmbBins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncBCD8 () */
/*
else
*idx = (U16) (sum % hashListCp->nmbBins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncString () */
else
*idx = (U16) (sum % hashListCp->nmbBins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncDefault */
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if (hashListCp->binBitMask == CM_HASH_NOBITMASK)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
prod = CM_HASH_MULT24_CONST * *((U32 *)key);
shift = CM_HASH_MULT24_BITPOS - hashListCp->nmbBinBits;
*idx = ((U16) (prod & (hashListCp->binBitMask << shift))) >> shift;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncMult24 */
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncConId */
*idx = *((U16 *) key);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashFuncDirIdx */
\f
/* compare key lengths */
if (keyLen1 != keyLen2)
- RETVALUE(RFAILED);
+ return RFAILED;
/* compare key strings */
- RETVALUE(cmMemcmp(key1, key2, (PTR) keyLen1));
+ return (cmMemcmp(key1, key2, (PTR) keyLen1));
} /* end of cmHashMatchKey */
\f
oldEntry->next = newEntry;
(newEntry->next)->prev = newEntry;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmListInsert */
\f
TRC2(cmListDelete);
if (entry == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
if (entry->prev != NULLP)
(entry->prev)->next = entry->next;
if (entry->next != NULLP)
(entry->next)->prev = entry->prev;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmListDelete */
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if (hashListCp == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* initialize control point fields */
case CM_HASH_KEYTYPE_MULT24:
/* return failure if number of bins is not a power of 2 */
if (((nmbBins) & (nmbBins - 1)) != 0)
- RETVALUE (RFAILED);
+ return (RFAILED);
hashListCp->hashFunc = cmHashFuncMult24;
break;
#ifndef CM_MT_HASH_BIN
if (SGetSBuf(region, pool, (Data **) &hashListCp->hl,
(Size) (nmbBins * sizeof(CmListEnt))) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#else
if (SGetSBuf(region, pool, (Data **) &hashListCp->hl,
(Size) (nmbBins * sizeof(CmListBinEnt))) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* initialize bin pointers */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashListInit */
\f
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if (hashListCp == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* deallocate memory for bins */
hashListCp->keyType = CM_HASH_KEYTYPE_DEF;
hashListCp->hashFunc = NULLP;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashListDeinit */
\f
/* error check on parameters */
if ((hashListCp == NULLP) || (entry == NULLP) ||
(key == NULLP) || (keyLen == 0))
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* check for duplicates */
{
/* no duplicates allowed, check if key already exists */
if (cmHashListFind(hashListCp, key, keyLen, 0, &dupEntry) == ROK)
- RETVALUE(ROKDUP);
+ return (ROKDUP);
}
/* get pointer to hash list entry header */
/* compute index for insertion */
if ((*hashListCp->hashFunc)(hashListCp, key, keyLen, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
hashListEnt->hashVal = idx;
hashListCp->hl[idx].nmbEnt++;
#endif /* #ifndef CM_MT_HASH_BIN */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashListInsert */
\f
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if ((hashListCp == NULLP) || (entry == NULLP))
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* get pointer to hash list entry header */
/* check if entry is already deleted if yes then return OK */
if((hashListEnt->list.next == NULLP) ||
(hashListEnt->list.prev == NULLP))
- RETVALUE(ROK);
+ return ROK;
#ifdef CM_MT_HASH_BIN
/* compute index for insertion */
if ((*hashListCp->hashFunc)(hashListCp, hashListEnt->key,
hashListEnt->keyLen, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif /* #ifdef CM_MT_HASH_BIN */
/* delete entry from list */
hashListCp->hl[idx].nmbEnt--;
#endif /* #ifndef CM_MT_HASH_BIN */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashListDelete */
\f
/* error check on parameters */
if ((hashListCp == NULLP) || (key == NULLP) ||
(keyLen == 0) || (entry == NULLP))
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* compute hash table index */
if ((*hashListCp->hashFunc)(hashListCp, key, keyLen, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
/* search this bin for exact key match */
hashListBin = &hashListCp->hl[idx];
/* check for duplicates */
if (!hashListCp->dupFlg)
- RETVALUE(ROK);
+ return ROK;
/* for duplicate key, check sequence number */
if (i++ == seqNmb)
- RETVALUE(ROK);
+ return ROK;
}
/* go to next entry */
}
/* no matching key found */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHashListFind */
\f
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if ((hashListCp == NULLP) || (entry == NULLP))
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* check if need to get first entry */
/* requested entry is in nxtEnt */
*entry = (PTR) (((U8 *) hashListEnt) - hashListCp->offset);
- RETVALUE(ROK);
+ return ROK;
}
/* no more entries */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* use previous entry to find next entry */
/* found next entry */
*entry = (PTR) (((U8 *) prevListEnt) - hashListCp->offset);
- RETVALUE(ROK);
+ return ROK;
}
/* no more entries in this bin, go to next bin, check if more bins */
}
/* no more entries */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
} /* end of cmHashListGetNext */
#ifdef CM_MT_HASH_BIN
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if ((hashListCp == NULLP) || (entry == NULLP))
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* check if need to get first entry */
/* requested entry is in nxtEnt */
*entry = (PTR) (((U8 *) hashListEnt) - hashListCp->offset);
- RETVALUE(ROK);
+ return ROK;
}
/* no more entries */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* use previous entry to find next entry */
/* found next entry */
*entry = (PTR) (((U8 *) prevListEnt) - hashListCp->offset);
- RETVALUE(ROK);
+ return ROK;
}
/* no more entries */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
} /* end of cmHashListBinGetNextEntry */
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if (result == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* respond depending on query type */
#else
*result = (U16) sizeof(CmListBinEnt);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* deal with queries that do need hashListCp */
#if (ERRCLASS & ERRCLS_DEBUG)
/* error check on parameters */
if (hashListCp == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
/* respond depending on query type */
*result += hashListCp->hl[i].nmbEnt;
}
#endif
- RETVALUE(ROK);
+ return ROK;
case CM_HASH_QUERYTYPE_BINS: /* number of bins */
*result = (U16) hashListCp->nmbBins;
- RETVALUE(ROK);
+ return ROK;
case CM_HASH_QUERYTYPE_OFFSET: /* offset of CmHashListEnt in entries */
*result = (U16) hashListCp->offset;
- RETVALUE(ROK);
+ return ROK;
case CM_HASH_QUERYTYPE_DUPFLG: /* allow duplicate keys */
*result = (U16) hashListCp->dupFlg;
- RETVALUE(ROK);
+ return ROK;
case CM_HASH_QUERYTYPE_KEYTYPE: /* key type for selecting hash functions */
*result = (U16) hashListCp->keyType;
- RETVALUE(ROK);
+ return ROK;
default: /* process other query types */
break;
}
/* illegal query type */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHashListQuery */
#ifdef HASH_OPEN_ADDRESSING
/* error check on parameters */
if ((hashListCp == NULLP) || (entry == NULLP) ||
(key == NULLP) || (keyLen == 0))
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
#ifndef CM_MT_HASH_BIN
#endif
/* check if table is full */
if (hashListCp->nmbBins == nmbEnt)
- RETVALUE(ROUTRES);
+ return (ROUTRES);
/* get pointer to hash list entry header */
hashListEnt = (CmHashListEnt *) (((U8 *) entry) + hashListCp->offset);
/* compute index for insertion */
if ((*hashListCp->hashFunc)(hashListCp, key, keyLen, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
/*
* find an empty bin
/* insert into list */
if (cmListInsert(hashBin->prev, &hashListEnt->list) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
hashListEnt->hashVal = idx;
hashBin->nmbEnt++;
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHashListOAInsert */
#endif
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPoll() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = poll(pollFdArr,numFds,timeout);
if (ret == 0)
{
- RETVALUE(RTIMEOUT);
+ return (RTIMEOUT);
}
if (ret == INET_ERR)
{
switch(INET_ERR_CODE)
{
case ERR_EINTR:
- RETVALUE(ROKDNA);
+ return (ROKDNA);
default:
#ifdef CMINETDBG
error(%d)\n", __FILE__, __LINE__, INET_ERR_CODE);
SPrint(prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of switch */
}
*numRdyFds = (S16)ret;
- RETVALUE(ROK);
+ return ROK;
}
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollSetFd() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /*ALIGN_64BIT */
#endif /* CMINETDBG */
- RETVALUE(ROK);
+ return ROK;
}
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollFdIsSet() : Invalid Index (%d) \n",idx);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollFdIsSet() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = (pollFdArr[idx].revents & eventMask);
- RETVALUE(ret);
+ return (ret);
}
/*
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollClearFdREvent() : Invalid Index (%d) \n",idx);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollClearFdREvent() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /*ALIGN_64BIT */
#endif /* CMINETDBG */
- RETVALUE(ROK);
+ return ROK;
}
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollClearFdEvent() : Invalid Index (%d) \n",idx);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollClearFdEvent() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /*ALIGN_64BIT */
#endif /* CMINETDBG */
- RETVALUE(ROK);
+ return ROK;
}
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollDelFd() : Invalid Index \n Current Index (%d) Delete Index (%d) \n",lastIdx,delIdx);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollDelFd() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
pollFdArr[lastIdx].events = 0;
pollFdArr[lastIdx].revents = 0;
- RETVALUE(ROK);
+ return ROK;
}
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "cmInetPollInitFdArr() : Invalid Parameter (pollFdArr is NULL)");
CMINETLOGERROR(ERRCLS_DEBUG, ECMINETXXX, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
pollFdArr[idx].events = 0;
pollFdArr[idx].revents = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
#if (!(defined(WIN32)) && !(defined(CMINETFLATBUF)))
ret = SGetDBuf(info->region, info->pool, &dBuf[numBuf]);
#endif
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
/* Get the data part */
ret = SGetDataRx(dBuf[numBuf], 0, &dPtr, &dLen);
msg->msg_iov = rxArr;
msg->msg_iovlen = numBuf;
- RETVALUE(ret);
+ return (ret);
cleanup:
/* cleanup */
msg->msg_iovlen = 0;
- RETVALUE(ret);
+ return (ret);
} /* end of buildRecvBuf */
/*
i++;
}
- RETVALUE(ret);
+ return (ret);
} /* end of buildRecvMsg */
\f
ret = SInitNxtDBuf(mBuf);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
iovIdx = 0;
{
ret = SGetNxtDBuf(mBuf, &dBuf);
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
dBufsToSkip --;
}
}
/* cm_inet_c_001.main_50 - Assign the value of dbufs packed in IO-vector */
*ioLen = allocLen;
- RETVALUE(ret);
+ return (ret);
} /* end of buildSendIovec */
#endif /* (defined(WIN32)) && !(defined(CMINETFLATBUF)) */
#endif /* CMINETDBG */
/* Set sockFd->fd to invalid socket */
sockFd->fd = CM_INET_INV_SOCKFD;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set socket type */
if (ret != ROK)
{
ret = cmInetClose(sockFd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_LINUX
if (ret != ROK)
{
ret = cmInetClose(sockFd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* CMINET_BSDCOMPAT */
#endif /* SS_LINUX */
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
ret = cmInetClose(sockFd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif /* WIN2K && WIN32 */
if (ret != ROK)
{
ret = cmInetClose(sockFd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif /* CM_LKSCTP_NONBLOCK ends */
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetSocket */
\f
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(myAddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /*ALIGN_64BIT*/
#endif /* IPV6_SUPPORTED */
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetBind */
/*cm_inet_c_001.main_38 Updated for TUCL 2.1 Release (Kernel SCTP Support) */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(addrLst == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(addrLst->count > CM_INET_NUM_NET_ADDR)
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET005, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET057, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET058, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET006, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (addrLst->count > 1)
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET059, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = sctp_bindx(sockFd->fd, (Void*)tempAddrPtr, addrLst->count - 1, SCTP_BINDX_ADD_ADDR);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET007, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(primAddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_inet_c_001.main_58 : Added check for addrLst to fix klockwork issue */
if (addrLst == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_inet_c_001.main_46: Included check for no of address aginst max */
if( addrLst->count > CM_INET_NUM_NET_ADDR )
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET060, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET008, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET061, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET009, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET062, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef IPV6_SUPPORTED
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* IPV6_SUPPORTED */
{
/* non-blocking: connection is in progress */
case ERR_INPROGRESS:
- RETVALUE(RINPROGRESS);
+ return (RINPROGRESS);
break;
/*
* blocking : connection is already established
*/
case ERR_ISCONN:
- RETVALUE(RISCONN);
+ return (RISCONN);
break;
/* resource temporarily unavailable */
case ERR_WOULDBLOCK:
- RETVALUE(ROKDNA);
+ return (ROKDNA);
break;
/* non-blocking: connection is in progress */
case ERR_ALREADY:
- RETVALUE(RINPROGRESS);
+ return (RINPROGRESS);
break;
case ERR_INVAL:
- RETVALUE(RINPROGRESS);
+ return (RINPROGRESS);
break;
/* Check for connection refused and timeout errors */
case ERR_CONNREFUSED:
case ERR_TIMEDOUT:
- RETVALUE(RCLOSED);
+ return (RCLOSED);
break;
/* it is a real error */
default:
- RETVALUE(RFAILED);
+ return RFAILED;
break;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) || (assocFd == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
*assocFd = ret;
- RETVALUE(ROK);
+ return ROK;
}
/*
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd)
|| (info == NULLP) || (mBuf == NULLP) || (len == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = SFndLenMsg(mBuf, &bufLen);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* max message length is limited to control the memory usage */
/* casting bufLen to avoid warnings */
if ((bufLen > 0) && ((U32)bufLen > CM_INET_MAX_MSG_LEN))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = SGetSBuf(info->region, info->pool, &sendBuf, bufLen);
if (ret != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
ret = SCpyMsgFix(mBuf, 0, bufLen, sendBuf, &msgLen);
if ((ret != ROK) || (msgLen != bufLen))
{
SPutSBuf(info->region, info->pool, sendBuf, bufLen);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( dstAddr != NULLP)
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET012, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addr6.sin6_family = AF_INET6;
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET064, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addr6.sin6_family = AF_INET6;
addr6.sin6_port = CM_INET_HTON_U16(port);
#endif /* CMINETDBG */
if ((INET_ERR_CODE == ERR_AGAIN) || (INET_ERR_CODE == ERR_WOULDBLOCK))
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
else if (INET_ERR_CODE == ERR_PIPE)
- RETVALUE(RCLOSED);
+ return (RCLOSED);
else
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_inet_c_001.main_58 : Fix for klockwork issue */
/* cleanup */
SPutSBuf(info->region, info->pool, sendBuf, bufLen);
- RETVALUE(ROK);
+ return ROK;
}
/*
(srcAddr == NULLP) || (port == NULLP) || (meminfo == NULLP) ||
(mBuf == NULLP) || (len == NULLP) || (sinfo == NULLP) || (flag == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "SGetSBuf failed to allocate memory\n");
CMINETLOGERROR(ERRCLS_ADD_RES, ECMINET065, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
addrlen = sizeof(struct sockaddr_storage);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* save the length of the received message */
if (ret != ROK)
{
SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = SAddPstMsgMult(recvbuf, *len, *mBuf);
{
SPutMsg(*mBuf);
SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* cleanup */
SPutSBuf(meminfo->region, meminfo->pool, recvbuf, buflen);
- RETVALUE(ROK);
+ return ROK;
}
/*
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
byteAddress = (U8*)peerAddrList;
#endif /* CMINETDBG */
sctp_freepaddrs(peerAddrList);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pAddr6 = (struct sockaddr_in6*)byteAddress;
sctp_freepaddrs(peerAddrList);
- RETVALUE(ROK);
+ return ROK;
}
/*
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
default:
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET017, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pAddr6 = (struct sockaddr_in6*)&(addrInfo.spinfo_address);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET066, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pAddr6 = (struct sockaddr_in6*)&(addrParams.spp_address);
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (ret == INET_ERR)
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET067, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* cm_inet_c_001.main_54: Added new function cmInetShutDownSctp()*/
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* cm_inet_c_001.main_61: Added new function cmInetAbortSctpAssoc()*/
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(servAddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
{
/* non-blocking: connection is in progress */
case ERR_INPROGRESS:
- RETVALUE(RINPROGRESS);
+ return (RINPROGRESS);
break;
/*
* blocking : connection is already established
*/
case ERR_ISCONN:
- RETVALUE(RISCONN);
+ return (RISCONN);
break;
/* resource temporarily unavailable */
case ERR_WOULDBLOCK:
- RETVALUE(ROKDNA);
+ return (ROKDNA);
break;
/* non-blocking: connection is in progress */
case ERR_ALREADY:
- RETVALUE(RINPROGRESS);
+ return (RINPROGRESS);
break;
case ERR_INVAL:
- RETVALUE(RINPROGRESS);
+ return (RINPROGRESS);
break;
/* Check for connection refused and timeout errors */
case ERR_CONNREFUSED:
case ERR_TIMEDOUT:
- RETVALUE(RCLOSED);
+ return (RCLOSED);
break;
/* it is a real error */
#endif /*ALIGN_64BIT*/
#endif /* IPV6_SUPPORTED */
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
break;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetConnect */
\f
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(backLog < MIN_BACK_LOG) || (backLog > MAX_BACK_LOG))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET021, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetListen */
\f
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (INET_ERR_CODE == ERR_WOULDBLOCK)
{
/* no connection present to accept */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
else
{
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET022, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET071, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* IPV6_SUPPORTED */
if ( ret != ROK)
{
ret = cmInetClose(newSockFd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef IPV6_SUPPORTED
fromAddr->port = CM_INET_NTOH_U16(peerAddr->sin_port);
fromAddr->address = CM_INET_NTOH_U32(peerAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetAccept */
\f
tempHdr->cmsg_len = len;
*curMsgIdx += len;
- RETVALUE(ROK);
+ return ROK;
}/* end of cmInet4FillTos */
/*
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(info == NULLP) || (len == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = SFndLenMsg(mBuf, &bufLen);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* max message length is limited to control the memory usage */
/* casting bufLen to avoid warnings */
if ((bufLen > 0) && ((U32)bufLen > CM_INET_MAX_MSG_LEN))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = SGetSBuf(info->region, info->pool, &sendBuf, bufLen);
if (ret != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
ret = SCpyMsgFix(mBuf, 0, bufLen, sendBuf, &msgLen);
if ((ret != ROK) || (msgLen != bufLen))
{
/* cleanup */
SPutSBuf(info->region, info->pool, sendBuf, bufLen);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dstAddr == NULLP)
if(INET_ERR_CODE == ERR_AGAIN)
{
*len = 0;
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
/* Check for ERR_WOULDBLOCK */
if(INET_ERR_CODE == ERR_WOULDBLOCK)
{
*len = 0;
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
#ifdef CMINETDBG
/* check if network is reacheble*/
if ((INET_ERR_CODE == ERR_NETUNREACH))
{
- RETVALUE(RNETFAILED);
+ return (RNETFAILED);
}
(INET_ERR_CODE == ERR_CONNRESET))
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
*len = ret;
{
/* cleanup */
SPutSBuf(info->region, info->pool, sendBuf, bufLen);
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
/* cleanup */
ret = SFndLenMsg(mBuf, &msgLen);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* added */
/* Compress the message into a single dBuf */
ret = SCompressMsg(mBuf);
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
strtEndDBufNum = 0;
/* Rebuild the send vector */
ret = buildSendIovec(mBuf, unSentLen, txArr, numDBufs, &i,
&strtEndDBufNum, &ioLen);
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
retVal = ROK;
}
}
else
- RETVALUE(RFAILED);
+ return RFAILED;
}
msg.msg_iov = txArr;
msg.msg_iovlen = i;
{
/* cm_inet_c_001.main_50 - Return without making length 0, if in case the partial
message was sent earlier */
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
#ifdef CMINETDBG
#ifndef ALIGN_64BIT
/* check if network is reacheble or not */
if ((INET_ERR_CODE == ERR_NETUNREACH))
{
- RETVALUE(RNETFAILED);
+ return (RNETFAILED);
}
/* Check if connection was closed by the peer */
(INET_ERR_CODE == ERR_CONNABORTED))
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_inet_c_001.main_50 - Update the length only in successful cases */
* to be sent, then return WOULDBLOCK
*/
if (ret < ioLen)
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
unSentLen -= ret;
} while (*len < msgLen);
#endif /* WIN32 | CMINETFLATBUF */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetSendDscpMsg */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(info == NULLP) || (len == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = SFndLenMsg(mBuf, &bufLen);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* max message length is limited to control the memory usage */
/* casting bufLen to avoid warnings */
if ((bufLen > 0) && ((U32)bufLen > CM_INET_MAX_MSG_LEN))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = SGetSBuf(info->region, info->pool, &sendBuf, bufLen);
if (ret != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
ret = SCpyMsgFix(mBuf, 0, bufLen, sendBuf, &msgLen);
if ((ret != ROK) || (msgLen != bufLen))
{
/* cleanup */
SPutSBuf(info->region, info->pool, sendBuf, bufLen);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dstAddr == NULLP)
if(INET_ERR_CODE == ERR_AGAIN)
{
*len = 0;
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
/* Check for ERR_WOULDBLOCK */
if(INET_ERR_CODE == ERR_WOULDBLOCK)
{
*len = 0;
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
#ifdef CMINETDBG
/* check if network is reacheble*/
if ((INET_ERR_CODE == ERR_NETUNREACH))
{
- RETVALUE(RNETFAILED);
+ return (RNETFAILED);
}
(INET_ERR_CODE == ERR_CONNRESET))
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
*len = ret;
{
/* cleanup */
SPutSBuf(info->region, info->pool, sendBuf, bufLen);
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
/* cleanup */
ret = SFndLenMsg(mBuf, &msgLen);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* added */
/* Compress the message into a single dBuf */
ret = SCompressMsg(mBuf);
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
strtEndDBufNum = 0;
/* Rebuild the send vector */
ret = buildSendIovec(mBuf, unSentLen, txArr, numDBufs, &i,
&strtEndDBufNum, &ioLen);
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
retVal = ROK;
}
}
else
- RETVALUE(RFAILED);
+ return RFAILED;
}
msg.msg_iov = txArr;
msg.msg_iovlen = i;
{
/* cm_inet_c_001.main_50 - Return without making length 0, if in case the partial
message was sent earlier */
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
}
#ifdef CMINETDBG
#ifndef ALIGN_64BIT
/* check if network is reacheble or not */
if ((INET_ERR_CODE == ERR_NETUNREACH))
{
- RETVALUE(RNETFAILED);
+ return (RNETFAILED);
}
/* Check if connection was closed by the peer */
(INET_ERR_CODE == ERR_CONNABORTED))
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_inet_c_001.main_50 - Update the length only in successful cases */
* to be sent, then return WOULDBLOCK
*/
if (ret < ioLen)
- RETVALUE(RWOULDBLOCK);
+ return (RWOULDBLOCK);
unSentLen -= ret;
} while (*len < msgLen);
#endif /* WIN32 | CMINETFLATBUF */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetSendMsg */
tempHdr->cmsg_len = len;
*curMsgIdx += len;
- RETVALUE(ROK);
+ return ROK;
}/* end of cmInet6BuildSendPktinfo */
#endif /* LOCAL_INTF */
tempHdr->cmsg_len = len;
*curMsgIdx += len;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetBuildSendHoplimit */
#endif /* SS_LINUX */
tempHdr->cmsg_len = len;
*curMsgIdx += len;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInet6BuildSendHBHOpts */
\f
}
*curMsgIdx += len;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInet6BuildSendRouteOpts */
\f
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "SGetSBuf failure 1 in cmInet6BuildRecvHopOptsArr\n");
CMINETLOGERROR(ERRCLS_ADD_RES, ECMINET028, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
curDataIdx = 0;
(Data *)hbhOptsArr->hbhOpts, numOpts * sizeof(CmInetIpv6HBHHdr));
hbhOptsArr->numHBHOpts = 0;
hbhOptsArr->hbhOpts = NULLP;
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* copy the value bytes */
cmMemcpy((U8 *)hbhOptsArr->hbhOpts[optsIdx].value,
/* get next option */
optsIdx++;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInet6BuildRecvHopOptsArr() */
\f
snprintf(prntBuf, CMINET_PRNT_BUF_SIZE, "SGetSBuf failure 1 in cmInet6BuildRecvRtHdr\n");
CMINETLOGERROR(ERRCLS_ADD_RES, ECMINET032, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* copy all the ipv6 addresses */
curDataIdx += 16;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInet6BuildRecvRtHdr() */
\f
hopLimitValue = (U32 *)(cmsgData);
ipv6HdrParam->ttl.val = (U8)(*hopLimitValue);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* IPV6_OPTS_SUPPORTED */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(info == NULLP) || (mPtr == NULLP) || (len == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (ret != ROK)
{
/* ret may be RFAILED or ROUTRES */
- RETVALUE(ret);
+ return (ret);
}
}
else
ret = cmInetPeekNew(sockFd, NULLP, info, 0, 1, readBuf);
if (ret == RCLOSED)
{
- RETVALUE(ret);
+ return (ret);
}
/* cm_inet_c_001.main_56:
* Returning ROKDNA even cmInetPeekNew returns ROK. Because currently
* cmInetGetNumRead at this point because of latency between the ioctl
* call and recvfrom call issues on some machines ioctl call may
* return ZERO even their a data to read. */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
}
/* cm_inet_c_001.main_52: Support for partial reception */
ret = SGetSBuf(info->region, info->pool, &recvBuf, bufLen);
if (ret != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
curLen = bufLen;
bufPtr = recvBuf;
(INET_ERR_CODE == ERR_WOULDBLOCK))
{
*len = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
(INET_ERR_CODE == ERR_CONNRESET))
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
#ifdef CMINETDBG
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
curLen -= recvLen;
bufPtr += recvLen;
#endif
{
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* cm_inet_c_001.main_48 : If Received
#endif /*ALIGN_64BIT*/
#endif
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* cm_inet_c_001.main_48 : copy data to a message structure */
{
/* cleanup */
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
- RETVALUE(ret);
+ return (ret);
}
#ifdef CM_INET2
{
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
SPutMsg(mBuf);
- RETVALUE(ret);
+ return (ret);
}
*mPtr = mBuf;
numDBufs*sizeof(Buffer*));
if (ret != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* Allocate dBufs for gather read */
/* allocate flat receive buffer */
ret = SGetSBuf(info->region, info->pool, &recvBuf, bufLen);
if (ret != ROK)
- RETVALUE(ROUTRES);
+ return (ROUTRES);
allocFlatBuf = TRUE;
{
SPutSBuf(info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
- RETVALUE(ret);
+ return (ret);
}
}
* against unexpected WOULDBLOCKS observed in solaris
*/
if (*mPtr != NULLP)
- RETVALUE(ROK);
+ return ROK;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* cm_inet_c_001.main_50 - Free the buffer only when valid, it might be that
if (INET_ERR_CODE == ERR_CONNABORTED)
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
bufLen -= recvLen;
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.hbhOptsArr,
0, info);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.hbhHdrPrsnt =
TRUE;
}
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.destOptsArr,
1, info);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.destOptsPrsnt =
TRUE;
}
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsArr,
info);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsPrsnt =
TRUE;
}
ret = cmInet6GetHopLimitValue((U8 *)CMSG_DATA(cmsgptr),
cmsgptr->cmsg_len, &ipHdrParams->u.ipv6HdrParm);
if (ret != ROK)
- RETVALUE(ret);
+ return (ret);
}
}
} /* for */
{
/* cleanup */
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
- RETVALUE(ret);
+ return (ret);
}
/* cm_inet_c_001.main_48 : A 0 len UDP packet could be received */
{
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
SPutMsg(tempMsg);
- RETVALUE(ret);
+ return (ret);
}
}
SPutMsg(*mPtr);
SPutSBuf(info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
- RETVALUE(ret);
+ return (ret);
}
}
SPutMsg(tempMsg);
SPutSBuf(info->region, info->pool, (Data*)dBufs,
numDBufs*sizeof(Buffer*));
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(tempMsg);
}
{
SPutMsg(*mPtr);
}
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET069, 0, prntBuf);
#endif
#endif
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
else
{
/* not enough data pending yet */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetRecvMsg */
(info == NULLP) || (data == NULLP) ||
(dataPos < 0) || (dataLen < 0))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
(INET_ERR_CODE == ERR_WOULDBLOCK))
{
recvLen = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* cm_inet_c_001.main_61: added host unreachable check */
if ((INET_ERR_CODE == ERR_CONNABORTED) ||
(INET_ERR_CODE == ERR_CONNREFUSED))
{
recvLen = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
#ifdef CMINETDBG
#ifndef ALIGN_64BIT
#endif
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (recvLen == 0)
{
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
/* cm_inet_c_001.main_57 - Fix for validation */
if (recvLen < (S32)dataLen) /* maybe happen */
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* setup return destination Internet address */
#endif /* IPV6_SUPPORTED */
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetPeeknew */
\f
(info == NULLP) || (data == NULLP) ||
(dataPos < 0) || (dataLen < 0))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
* errors just return RFAILED.
*/
if (ret == RCLOSED)
- RETVALUE(RCLOSED);
+ return (RCLOSED);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check if connection got closed */
* considered as connection closed. So return ROKDNA instead of
* RCLOSED even for TCP sockets
*/
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* added check for TCP/UDP socket. Pending data len in the socket
recv buffer is determined by ioctl call in cmInetGetNumRead.
ret = SGetSBuf(info->region, info->pool, &recvBuf, bufLen);
if (ret != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* added different recvfrom calls with
(INET_ERR_CODE == ERR_WOULDBLOCK))
{
recvLen = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* moved up the cleanup */
(INET_ERR_CODE == ERR_CONNRESET))
{
recvLen = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (recvLen < (S32)bufLen) /* maybe happen */
{
/* cleanup */
SPutSBuf(info->region, info->pool, recvBuf, bufLen);
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* copy data */
else
{
/* not enough data pending yet */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
}
else
{
/* no data pending */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetPeek */
\f
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET037, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetClose */
\f
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (INET_ERR_CODE == ERR_NOTCONN)
{
/* socket is not connected */
- RETVALUE(ROK);
+ return ROK;
}
else
{
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET038, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetShutdown */
\f
/* error check on parameters */
if (numFdS == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
/* cm_inet_c_001.main_53 - Return ROKDNA in case select was interrupted */
if ((ret == INET_ERR) && (INET_ERR_CODE == ERR_EINTR))
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* timeout occured */
if (ret == 0)
{
- RETVALUE(RTIMEOUT);
+ return (RTIMEOUT);
}
if (ret == INET_ERR)
switch(errCode = INET_ERR_CODE)
{
case ERR_INVAL:
- RETVALUE(ROK);
+ return ROK;
default:
#ifdef CMINETDBG
INET_ERR_CODE);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET039, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of switch */
}
/* cm_inet_c_001.main_54: Fix for Klockworks issue */
*numFdS = (S16)ret;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetSelect */
\f
/* cm_inet_c_001.main_58 : Added NULL check for value field */
if(value == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
default:
/* wrong value */
- RETVALUE(RFAILED);
+ return RFAILED;
break;
}
break;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
- RETVALUE(RNA);
+ return (RNA);
#else
ret = setsockopt(sockFd->fd, level, IP_HDRINCL,
(char*)&enable, sizeof(enable));
else if (*optVal == CM_INET_OPT_DISABLE)
{
#ifdef WIN32
- RETVALUE(RNA);
+ return (RNA);
#else
ret = setsockopt(sockFd->fd, level, IP_HDRINCL,
(char*)&disable, sizeof(disable));
ret = setsockopt(sockFd->fd, level, IP_ROUTER_ALERT,
(char*)&enable, sizeof(enable));
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (*optVal == CM_INET_OPT_DISABLE)
{
ret = setsockopt(sockFd->fd, level, IP_ROUTER_ALERT,
(char*)&disable, sizeof(disable));
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
#endif /* SS_LINUX */
/* set Router Alert socket option */
case CM_INET_OPT_IP_OPTIONS:
#if (defined (SS_VW) || defined(SS_LINUX))
- RETVALUE(RNA);
+ return (RNA);
#else
tempTknStr64=(TknStr64 *)value;
if (tempTknStr64->pres == TRUE)
(char *)tempTknStr64->val, tempTknStr64->len);
}
else
- RETVALUE(RFAILED); /* Trying to set IPv4 Hdr option
+ return RFAILED; /* Trying to set IPv4 Hdr option
* without giving option values*/
#endif /* SS_VW || SS_LINUX */
break;
(char*)&enable, sizeof(enable));
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (*optVal == CM_INET_OPT_DISABLE)
{
(char*)&disable, sizeof(disable));
if (ret != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
#endif /* LOCAL_INTF */
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET040, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pAddr6 = (struct sockaddr_in6*)&(setPrim.ssp_addr);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pAddr6 = (struct sockaddr_in6*)&(addrParams.spp_address);
default:
/* wrong socket option type */
- RETVALUE(RFAILED);
+ return RFAILED;
break;
}
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET042, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetSetOpt */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(dataLen == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
* select says is ready to read. This should not be considered as
* connection closed.
*/
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
/* removed error check ERR_WOULDBLOCK */
(INET_ERR_CODE == ERR_CONNRESET))
{
*dataLen = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
#ifdef SS_LINUX
/* cm_inet_c_001.main_45: Change 2048 to CM_INET_MAX_UDPRAW_MSGSIZE */
*dataLen = CM_INET_MAX_UDPRAW_MSGSIZE;
- RETVALUE(ROK);
+ return ROK;
#endif /* SS_LINUX */
/* removed error debug printing added for recvfrom call. */
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET043, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetGetNumRead */
\f
/* error check on parameters */
if ((hostName == NULLP) || (addrTbl == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
" hostName(%p)\n", INET_ERR_CODE, hostName);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET044, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (hostid->h_addrtype != AF_INET)
{
INET_ERR_CODE, hostName, hostid->h_addrtype);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET045, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
" hostName(%p)\n", INET_ERR_CODE, hostName);
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET046, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
CM_COPY_VWIPADDR(vwIpAddr, &(addrTbl->netAddr[addrTbl->count]));
addrTbl->count++;
INET_ERR_CODE, hostName, hostid.h_addrtype);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET047, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
#endif /* WIN32 || SS_LINUX || HPOS */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetGetHostByName */
/* error check on parameters */
if ((hostName == NULLP) || (addrArr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
err, hostName, addrArr->type);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET048, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef IPV6_SUPPORTED
err, hostName, addrArr->type, hostid->h_addrtype);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET049, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
err, hostName, hostid->h_addrtype, addrArr->type);
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET050, 0, prntBuf);
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif /* SS_LINUX */
#endif /* SUNOS */
- RETVALUE(ROK);
+ return ROK;
#else
ret = cmInetGetHostByName(hostName, &addrArr->u.ipv4AddrArr);
- RETVALUE(ret);
+ return (ret);
#endif /* IPV6_SUPPORTED */
} /* end of cmInetGetIpNodeByName */
/* error check on parameters */
if (asciiAddr == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (*address == (U32)ERR_INADDRNONE)
{
/* asciiAddr does not contain a valid internet address */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/* error check on parameters */
if (asciiAddr == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
*asciiAddr = inet_ntoa(inetAddr);
if (*asciiAddr == NULL)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
*
/* error check on parameters */
if (asciiAddr == NULLP || address == NULLP || len == 0 )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
}
if(inet_ntop(domain,address,asciiAddr,len) == NULL)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* error check on parameters */
if ((asciiAddr == NULLP) || (address == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = inet_pton(AF_INET, asciiAddr, (void *)address);
if (ret != 1)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetPton */
#endif /* SUNOS */
#endif /* IPV6_SUPPORTED */
/* error check on parameters */
if ((asciiAddr == NULLP) || (address6 == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
ret = inet_pton(AF_INET6, asciiAddr, (void *)address6);
if (ret != 1)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
/* cm_inet_c_001.main_44 : In windows inet_pton is not implemented. so we are using the below function
cmMemcpy((U8*)address6, (U8*)&(((struct sockaddr_in6 *)&ss)->sin6_addr), sizeof(CmInetIpAddr6));
#endif /* WIN32 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetPton6 */
#endif /* IPV6_SUPPORTED */
#endif /* SS_PS */
*size = CM_INET_MAX_MSG_LEN;
#endif
- RETVALUE(ROK);
+ return ROK;
}
err = WSAStartup(version, &data);
if (err != 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
err = WSACleanup();
if (err != 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}/* end of cmInetDeInit() */
\f
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd) ||
(locAddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#else
locAddr->port = CM_INET_NTOH_U16(sockAddr->sin_port);
#endif /* IPV6_SUPPORTED */
- RETVALUE(ROK);
+ return ROK;
default:
#ifdef CMINETDBG
CMINETLOGERROR(ERRCLS_INT_PAR, ECMINET051, 0, prntBuf);
#endif /* ALIGN_64BIT */
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}/* end of switch */
}/* end if */
locAddr->port = CM_INET_NTOH_U16(sockAddr->sin_port);
locAddr->address = CM_INET_NTOH_U32(sockAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
- RETVALUE(ROK);
+ return ROK;
}/* end of cmInetGetSockName() */
/* New functions to peek into the file descriptor
#if (ERRCLASS & ERRCLS_INT_PAR)
if (fdSetInfo == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (fdSetInfo->initDone == TRUE)
- RETVALUE(ROK);
+ return ROK;
#ifdef WIN32
fdSetInfo->numFds = 0;
#endif /* SUNOS || SS_LINUX || SS_VW || HPOS */
fdSetInfo->initDone = TRUE;
- RETVALUE(ROK);
+ return ROK;
}/* end of cmInetFdSetInfoInit() */
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((fdSetInfo == NULLP) || (fdSet == NULLP) || (sockFd == NULLP))
- RETVALUE(RFAILED);
+ return RFAILED;
if (fdSetInfo->initDone != TRUE)
- RETVALUE(RNA);
+ return (RNA);
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#ifdef WIN32
#if (ERRCLASS & ERRCLS_DEBUG)
if (fdSetInfo->numFds > FD_SETSIZE)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif /* ERRCLASS & ERRCLS_DEBUG */
/* cm_inet_c_001.main_32 : Corrected check for number of fd set in
a fdset for WIN32*/
if (fdSetInfo->numFds >= fdSet->fd_count)
- RETVALUE(ROKDNA);
+ return (ROKDNA);
*sockFd = fdSet->fd_array[fdSetInfo->numFds];
fdSetInfo->numFds += 1;
- RETVALUE(ROK);
+ return ROK;
#endif /* WIN32 */
/* cm_inet_c_001.main_59: Protected under if not defined WIN32 */
*sockFd += (curIdx * (sizOfFdSetArElem << 3));
/* Clear the file descriptor */
*tempByte &= ~(1 << bitPos);
- RETVALUE(ROK);
+ return ROK;
}
if (fdSetInfo->bigEndian)
tempByte -= 1;
}
if (!found)
- RETVALUE(ROKDNA);
+ return (ROKDNA);
- RETVALUE(ROK);
+ return ROK;
#endif /* SUNOS || SS_LINUX || SS_VW || HPOS */
} /* end of cmInetGetFd */
((val[idx] < 'A') || (val[idx] > 'F')))
{
/* Not a digit */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
if ((val[idx] != '.') && (val[idx] != ':'))
{
/* Not a digit */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* if, couldn't determine IPV4 or IPV6 */
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
if (compressed == TRUE)
{
/* can't have 2 :: */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* if, 2 :: */
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
an IPV6 address */
if (retVal != ROK)
{
- RETVALUE(retVal);
+ return (retVal);
}
embedIPV4 = TRUE;
break;
((val[idx] < 'A') || (val[idx] > 'F')))
{
/* Not a digit */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
} /* else, IPV6 */
#endif /* IPV6_SUPPORTED */
- RETVALUE(ROK);
+ return ROK;
} /* cmInetConvertStrToIpAddr */
\f
if (val[idx] < '0' || val[idx] > '9')
{
/* Not a digit */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_DEBUG) */
idx++;
}
- RETVALUE(ROK);
+ return ROK;
} /* cmInetAsciiToIpv4 */
/* cm_inet_c_001.main_34:Added wrapper function for getaddrinfo and freeaddrinfo */
/* error check on parameters */
if ((node == NULLP) || (hints == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /* ALIGN_64BIT */
#endif /* CMINETDBG */
}
- RETVALUE(ret);
+ return (ret);
} /* end of cmInetGetAddrInfo */
\f
/* error check on parameters */
if ((sockFd == NULLP) || CM_INET_INV_SOCK_FD(sockFd))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if (ret != ROK)
{
/* ret may be RFAILED or ROUTRES */
- RETVALUE(ret);
+ return (ret);
}
/* check if connection got closed */
* considered as connection closed. So return ROKDNA instead of
* RCLOSED
*/
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
else
/* clear error if there is any, because if there is internal error
CMINETLOGERROR(ERRCLS_DEBUG, ECMINET054, 0, prntBuf);
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
#endif /* defined(SUNOS) || defined(SS_LINUX) */
#endif /* defined(SS_VW) || defined(HPOS) || defined(SS_PS) */
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
}
}/* if (pendLen == 0)*/
(INET_ERR_CODE == ERR_WOULDBLOCK))
{
*len = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
(INET_ERR_CODE == ERR_CONNRESET))
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
#ifdef CMINETDBG
#endif /*ALIGN_64BIT*/
#endif /* CMINETDBG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(recvLen < curLen)
(INET_ERR_CODE == ERR_WOULDBLOCK))
{
*len = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
#ifdef CMINETDBG
if (INET_ERR_CODE == ERR_CONNABORTED)
{
*len = 0;
- RETVALUE(RCLOSED);
+ return (RCLOSED);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}/* if ((recvLen == INET_ERR) || (recvLen > CM_INET_MAX_MSG_LEN))*/
if(recvLen < curLen)
#endif /* WIN32 | CMINETFLATBUF */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmInetFlushRecvBuf */
#endif /* CM_INET_FLUSH_RECV_BUF*/
#endif /* SUNOS || HPOS */
#endif /* IPV6_SUPPORTED */
-#define cmPkCmInetIpAddr(x, mBuf) SPkU32(x, mBuf) /* pack IP Address */
-#define cmUnpkCmInetIpAddr(x, mBuf) SUnpkU32(x, mBuf) /* unpacks IP Address */
+#define cmPkCmInetIpAddr(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack IP Address */
+#define cmUnpkCmInetIpAddr(x, mBuf) oduPackUInt32(x, mBuf) /* unpacks IP Address */
#ifdef SS_VW
#define CM_COPY_VWIPADDR(vwIpAddr, addr) \
}
#endif
#if (MEMCPY_AVAIL) /* memcpy is available */
- RETVALUE((U8 *) memcpy((Void *)tgt, (CONSTANT Void *)src, (size_t)len));
+ return ((U8 *) memcpy((Void *)tgt, (CONSTANT Void *)src, (size_t)len));
#else
while (len--)
*tgt++ = *src++;
- RETVALUE(tgt);
+ return (tgt);
#endif /* MEMCPY_AVAIL */
} /* end of cmMemcpy */
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
TRC2(cmMemcmp)
#if MEMCMP_AVAIL /* memcmp is available */
- RETVALUE((S16) memcmp((CONSTANT Void *)s1, (CONSTANT Void *)s2, (size_t)len));
+ return ((S16) memcmp((CONSTANT Void *)s1, (CONSTANT Void *)s2, (size_t)len));
#else /* MEMCMP_AVAIL: memcmp is not available */
while (len--)
{
if (*s1 ^ *s2)
- RETVALUE((S16) (*s1 - *s2));
+ return ((S16) (*s1 - *s2));
s1++;
s2++;
}
- RETVALUE(0);
+ return (0);
#endif /* MEMCMP_AVAIL */
} /* end of cmMemcmp */
*str++ = val;
#endif /* MEMSET_AVAIL */
- RETVALUE(str);
+ return (str);
} /* end of cmMemset */
\f
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
TRC2(cmStrcmp)
#if (STRCMP_AVAIL)
- RETVALUE(strcmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2));
+ return (strcmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2));
#else /* STRCMP_AVAIL */
while (*s1 && *s2)
{
if (*s1 ^ *s2)
- RETVALUE(*s1 - *s2);
+ return (*s1 - *s2);
s1++;
s2++;
}
- RETVALUE(0);
+ return (0);
#endif /* strcmp is not available */
} /* end of cmStrcmp */
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
TRC2(cmStrncmp)
#if (STRNCMP_AVAIL)
- RETVALUE(strncmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2, (size_t) len));
+ return (strncmp((CONSTANT S8 *)s1, (CONSTANT S8 *)s2, (size_t) len));
#else /* STRNCMP_AVAIL */
while (*s1 && *s2 && len--)
{
if (*s1 ^ *s2)
- RETVALUE(*s1 - *s2);
+ return (*s1 - *s2);
s1++;
s2++;
}
- RETVALUE(0);
+ return (0);
#endif /* strncmp is not available */
} /* end of cmStrncmp */
#if (STRLEN_AVAIL)
/*cm_lib_c_001.main_15 : Fix for warning due to mixed declation*/
TRC2(cmStrlen)
- RETVALUE((MsgLen)strlen((CONSTANT S8 *)s));
+ return ((MsgLen)strlen((CONSTANT S8 *)s));
#else /* STRLEN_AVAIL */
MsgLen i;
TRC2(cmStrlen)
for (i = 0; *s; i++, s++);
- RETVALUE(i);
+ return (i);
#endif /* strlen is not available */
} /* end of cmStrlen */
/* cm_llist_c_001.main_8 : added null check for node */
if (lCp == (CmLListCp *)NULLP || lCp->count == 0 || !node)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
{
lCp->first = lCp->crnt = lCp->last = (CmLList *)NULLP;
lCp->count = 0;
- RETVALUE(node);
+ return (node);
}
lCp->count--;
node->next->prev = (CmLList *)NULLP;
lCp->first = node->next;
node->next = node->prev = (CmLList *)NULLP;
- RETVALUE(node);
+ return (node);
}
if (lCp->last == node)
node->prev->next = (CmLList *)NULLP;
lCp->last = node->prev;
node->next = node->prev = (CmLList *)NULLP;
- RETVALUE(node);
+ return (node);
}
node->prev->next = node->next;
node->next->prev = node->prev;
node->next = node->prev = (CmLList *)NULLP;
- RETVALUE(node);
+ return (node);
} /* end of cmLListDelFrm */
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- CMCHKPK(SPkU8, param->rbType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
CMCHKPK(cmPkLteRbId, param->rbId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkLteRlcId);
CMCHKUNPK(cmUnpkLteRbId, ¶m->rbId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbType, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkLteTimingInfo);
- CMCHKPK(SPkU16, param->slot, mBuf);
- CMCHKPK(SPkU16, param->sfn, mBuf);
- //CMCHKPK(SPkU16, param->hSfn, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->slot, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
+ //CMCHKPK(oduUnpackUInt16, param->hSfn, mBuf);
+ return ROK;
}
TRC3(cmUnpkLteTimingInfo);
- //CMCHKUNPK(SUnpkU16, ¶m->hSfn, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sfn, mBuf);
- CMCHKUNPK(SUnpkU16,¶m->slot, mBuf);
- RETVALUE(ROK);
+ //CMCHKUNPK(oduPackUInt16, ¶m->hSfn, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
+ CMCHKUNPK(oduPackUInt16,¶m->slot, mBuf);
+ return ROK;
}
TRC3(cmPkLtePdcpId);
- CMCHKPK(SPkU8, param->rbType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbType, mBuf);
CMCHKPK(cmPkLteRbId, param->rbId, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(cmUnpkLteRbId, ¶m->rbId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbType, mBuf);
+ return ROK;
}
#ifdef LTE_L2_MEAS
#ifdef ANSI
mInfo->regInfo[idxReg].isGenMemInfoUpdated = TRUE;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
memoryInfo->regInfo[idxReg].poolInfo[idxPool].maxUsed = memInfo->regInfo[idxReg].poolInfo[idxPool].maxUsed;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
memInfo->regInfo[idxReg].poolInfo[idxPool].maxUsed = 0;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
cpuInfo->cpuUtil[idx].numSamples = 0;
}
cpuInfo->numCores = 0;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
cpuMeasInfo->cpuUtil[idx].avgCpuUtil = cpuInfo->cpuUtil[idx].totCpuUtil/cpuInfo->cpuUtil[idx].numSamples;
cpuMeasInfo->cpuUtil[idx].maxCpuUtil = cpuInfo->cpuUtil[idx].maxCpuUtil;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
#include <cm_lte.h>
/* Packing Defines */
-#define cmPkLteRbId SPkU8
-#define cmPkLteRnti SPkU16
-#define cmPkLteCellId SPkU16
-#define cmPkLteRlcMode SPkU8
-#define cmPkLteLcId SPkU8
-#define cmPkLteLcType SPkU8
-#define cmPkLteAggrLvl SPkU32
+#define cmPkLteRbId oduUnpackUInt8
+#define cmPkLteRnti oduUnpackUInt16
+#define cmPkLteCellId oduUnpackUInt16
+#define cmPkLteRlcMode oduUnpackUInt8
+#define cmPkLteLcId oduUnpackUInt8
+#define cmPkLteLcType oduUnpackUInt8
+#define cmPkLteAggrLvl oduUnpackUInt32
/* Unpacking Defines */
-#define cmUnpkLteRbId SUnpkU8
-#define cmUnpkLteRnti SUnpkU16
-#define cmUnpkLteCellId SUnpkU16
-#define cmUnpkLteRlcMode SUnpkU8
-#define cmUnpkLteLcId SUnpkU8
-#define cmUnpkLteLcType SUnpkU8
-#define cmUnpkLteAggrLvl SUnpkU32
+#define cmUnpkLteRbId oduPackUInt8
+#define cmUnpkLteRnti oduPackUInt16
+#define cmUnpkLteCellId oduPackUInt16
+#define cmUnpkLteRlcMode oduPackUInt8
+#define cmUnpkLteLcId oduPackUInt8
+#define cmUnpkLteLcType oduPackUInt8
+#define cmUnpkLteAggrLvl oduPackUInt32
#define MAX_POOL_SIZE 6 /*!< Maximum pool size */
#define MAX_REGION_SIZE 5 /*!< Maximum Region size */
#endif
{
#if (defined(SUNOS)|| defined(WIN32)|| defined(WIN2K)|| defined (SS_LINUX))
- RETVALUE((U32) abs((int) val));/* G++ */
+ return ((U32) abs((int) val));/* G++ */
#endif
} /* end of cmAbs */
#endif /* SS_FLOAT */
#endif
{
#if (defined(SUNOS)|| defined(WIN32)|| defined(WIN2K)|| defined (SS_LINUX))
- RETVALUE((F64) pow((F64)x, (F64)y));
+ return ((F64) pow((F64)x, (F64)y));
#endif
} /* end of cmPow */
#endif /* SS_FLOAT */
#endif
{
#if (defined(SUNOS)|| defined(WIN32)|| defined(WIN2K)|| defined (SS_LINUX))
- RETVALUE((F64) floor((F64)x));
+ return ((F64) floor((F64)x));
#endif
} /* end of cmFloor */
#endif
{
#if (defined(SUNOS)|| defined(WIN32)|| defined(WIN2K)|| defined (SS_LINUX))
- RETVALUE((F64) log((F64)x));
+ return ((F64) log((F64)x));
#endif
} /* end of cmLog */
#endif
{
#if (defined(SUNOS)|| defined(WIN32)|| defined(WIN2K)|| defined (SS_LINUX))
- RETVALUE((F64) log10((F64)x));
+ return ((F64) log10((F64)x));
#endif
} /* end of cmLog10 */
#endif /* SS_FLOAT */
printf("eventSize [%ld] greater than maxBlkSize [%ld]\n",
evntSize, maxBlkSize);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Size)(maxBlkSize + sizeof(CmMemList))) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
- RETVALUE(RFAILED);
+ return RFAILED;
/* Reset the contents */
cmMemset((U8 *)allocPtr, (U8 )0,
*ptr = (Ptr) ((PTR)allocPtr + sizeof(CmMemList));
cb->runPtr = ((PTR)(*ptr) + evntSize);
- RETVALUE(ROK);
+ return ROK;
} /* End of cmAllocEvnt */
*allocPtr = (Ptr) cb->runPtr;
cb->memAllocated += size;
cb->runPtr += size;
- RETVALUE(ROK);
+ return ROK;
}
}
(Data **)&(cb->initPtr),
(Size)(blkSize + sizeof(CmMemList)) ) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
- RETVALUE(RFAILED);
+ return RFAILED;
/* Reset the contents */
/* Initialise above allocated structure */
*allocPtr = (Ptr) ((PTR)cb->initPtr + sizeof(CmMemList));
cb->runPtr = ((PTR)(*allocPtr) + size);
- RETVALUE(ROK);
+ return ROK;
} /* End of cmGetMem */
/* Validation check */
if( evntSize > maxBlkSize)
- RETVALUE(RFAILED);
+ return RFAILED;
/* Allocate memory for the first Memory Chunk */
/* Allocated memory should be maxBlkSize + sizeof(CmMemList) */
(Size)(maxBlkSize + sizeof(CmMemList))) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
- RETVALUE(RFAILED);
+ return RFAILED;
/* Reset the contents */
cmMemset((U8 *)allocPtr, (U8 )0,
*ptr = (Ptr) ((PTR)allocPtr + sizeof(CmMemList));
cb->runPtr = ((PTR)(*ptr) + evntSize);
- RETVALUE(ROK);
+ return ROK;
} /* End of cmAllocEvntNoInit */
// (PTR)(size) );
cb->memAllocated += size;
cb->runPtr += size;
- RETVALUE(ROK);
+ return ROK;
}
}
(Data **)&(cb->initPtr),
(Size)(blkSize + sizeof(CmMemList)) ) != ROK)
#endif /* SS_LOCKLESS_MEMORY */
- RETVALUE(RFAILED);
+ return RFAILED;
/* Reset the contents */
/* Initialise above allocated structure */
*allocPtr = (Ptr) ((PTR)cb->initPtr + sizeof(CmMemList));
cb->runPtr = ((PTR)(*allocPtr) + size);
- RETVALUE(ROK);
+ return ROK;
} /* End of cmGetMemNoInit */
{ \
S16 ret; \
if ((ret = func(val, ptr, mBuf)) != ROK) \
- RETVALUE(ret); \
+ return (ret); \
}
#define CMGETMBLK(ptr, size, pptr) \
ret = cmGetMem( ptr, size, pptr); \
if (ret != ROK) \
{ \
- RETVALUE(RFAILED); \
+ return RFAILED; \
} \
}
/* if(!startMemLeak)
{
- RETVALUE(ROK);
+ return ROK;
}*/
U32 index1 = getT2kMemLeakIndex(address, region);
/* error check on parameters */
if ((regCb == NULLP) || (cfg == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Error check on the configuration fields */
if ((!cfg->size) || (cfg->vAddr == NULLP) ||
(cfg->numBkts > CMM_MAX_BKT_ENT))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the quantum size is power of 2 */
if ((cfg->numBkts) &&
/* cm_mem_c_001.main_20 Addition */
sprintf(errMsg,"\n cmMmRegInit() failed, check if BktQuantum size might not be power of 2 \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*
\n",bktIdx,cfg->bktCfg[bktIdx].size,cfg->bktQnSize);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((bktBlkSize = cfg->bktCfg[bktIdx].size) < lstQnSize)
/* cm_mem_c_001.main_20 Addition */
sprintf(errMsg,"\n cmMmRegInit() failed, Two consecutive buckets are not separated by quantum size \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (((cfg->bktCfg[bktIdx].size) /\
\n should be less than CMM_MAX_MAP_ENT:%d \n",cfg->bktQnSize,CMM_MAX_MAP_ENT);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
sprintf(errMsg,"\n cmMmRegInit() failed, Size of the memory region is less than the required size \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
lstQnSize = ((bktBlkSize / cfg->bktQnSize) + 1) * cfg->bktQnSize;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMmBktInit( &memAddr, regCb, cfg, bktIdx, &lstMapIdx);
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
regCb->heapFlag = TRUE;
/* Call SRegRegion to register the memory region with SSI */
if (SRegRegion(region, ®Cb->regInfo) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_12 - addition for initializing the hash table */
/* Initialize the region level hash table for debug info storage */
if (cmMmHashListInit(®Cb->hashListCp, CMM_STAT_HASH_TBL_LEN, region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
if(cmHashListInit(®Cb->brdcmSsiLstCp, 1000, offset, FALSE,
CM_HASH_KEYTYPE_U32MOD, region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegInit*/
/* error check on parameters */
if (regCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Deinitialize the hash table used for debug info storage at region level */
if (cmMmHashListDeinit(®Cb->hashListCp, regCb->region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* Deinitialize the hash table used for broadcom ssi instrumentation */
if (cmHashListDeinit(®Cb->brdcmSsiLstCp) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegDeInit */
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
#endif /* SSI_DEBUG_LEVEL1 */
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
/* return RFAILED */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else if (flags)
{
#ifdef SS_HISTOGRAM_SUPPORT
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
#else
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
#endif /* SSI_DEBUG_LEVEL1 */
#endif /* SS_HISTOGRAM_SUPPORT */
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAlloc */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
#endif
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
printf("Memory signature is invalid\n");
abort();
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
if (CMM_IS_STATIC(ptrHdr->memFlags))
{
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
#endif
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
TRC2(cmFree);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
#endif /* SSI_DEBUG_LEVEL1 */
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (cmMmBktSanityChk(bkt) == RTRAMPLINGNOK)
{
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
/* return RFAILED */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
}
/* cm_mem_c_008.104 - Addition for memory calculator tool */
- RETVALUE(ROK);
+ return ROK;
}
else if (flags)
{
#ifdef SS_HISTOGRAM_SUPPORT
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size,
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size,
memType, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size,
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size,
line, fileName, entId, hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
#else
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
#endif /* SSI_DEBUG_LEVEL1 */
#endif /* SS_HISTOGRAM_SUPPORT */
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAllocNL */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
else
{
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
if (CMM_IS_STATIC(ptrHdr->memFlags))
{
{
/* do not add to the free list */
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
else
{
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
#endif
}
cmRlsAllocBlk((PTR)ptr);
#endif /* SS_MEM_LEAK_STS */
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
TRC2(cmFreeNL);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmFreeNL */
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Update the size parameter */
*size = bkt->size;
- RETVALUE(ROK);
+ return ROK;
}
}
}
* heap pool.
*/
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAllocWL */
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*/
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#else /* use pure is on */
TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/* error check on parameters */
if ((regCb == NULLP) || (memCtl == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((memCtl->u.vtop.vaddr == NULLP) ||
(memCtl->u.vtop.paddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
offset = memCtl->u.vtop.vaddr - regCb->regInfo.start;
*(memCtl->u.vtop.paddr) = regCb->pAddr + offset;
- RETVALUE(ROK);
+ return ROK;
}
break;
}
if (!(memCtl->u.chkres.size) ||
(memCtl->u.chkres.status == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifndef USE_PURE
(regCb->heapSize/10));
}
- RETVALUE(ROK);
+ return ROK;
#else /* use pure is on */
*(memCtl->u.chkres.status) = ((avail_size) /
(regCb->regInfo.size/10));
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
}
default:
{
/* No other event is supported currently */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* shouldn't reach here */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmCtl */
\f
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
} /* end of cmHeapAlloc */
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
#endif /* SSI_DEBUG_LEVEL1 */
#endif
/* This block is already freed in the heap */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
/* update the flags as it is a new node */
if (CMM_IS_STATIC(p->memFlags))
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
else if (p < curHBlk)
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
/* Release the lock */
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHeapFree */
#endif/*USE_PURE*/
#ifdef SS_LIGHT_MEM_LEAK_STS
if(gmemLkCb.head == gmemLkCb.tail)
{
allocQueueEmptyCnt++;
- RETVALUE(CM_MAX_ALLOC_ENTERIES);
+ return (CM_MAX_ALLOC_ENTERIES);
}
else
{
U32 allocQIndx = gmemLkCb.queue[gmemLkCb.head];
gmemLkCb.head = (gmemLkCb.head +1) % CM_MAX_ALLOC_ENTERIES;
- RETVALUE(allocQIndx);
+ return (allocQIndx);
}
}
if(tmpTail == gmemLkCb.head)
{
allocQueueFullCnt++;
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
gmemLkCb.queue[gmemLkCb.tail] = allocQIndx;
gmemLkCb.tail = tmpTail;
- RETVALUE(ROK);
+ return ROK;
}
}
/*
}
(Void) SUnlock(&(gmemLkCb.memLock));
- RETVALUE(allocQIndx);
+ return (allocQIndx);
} /* cmStorAllocBlk */
/* check if hashListCp is initialised yet */
if ( regCb->brdcmSsiLstCp.nmbBins == 0)
{
- RETVALUE(ROK);
+ return ROK;
}
ptrHdr->reqSz = reqSz;
ptrHdr->allocSz = allocSz;
funNm);
if(memReqIdx >= 0)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
(const S8 *)memUsrMdlStr[mdlFunStrIdx].fPStr);
if(retVal == NULLD)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
}
- RETVALUE(0);
+ return (0);
} /* cmMemGetModuleId */
/*
if(!found)
{
- RETVALUE(-1);
+ return (-1);
}
- RETVALUE(strtIdx);
+ return (strtIdx);
} /* cmMemGetStrMtchIdx */
#ifdef SS_MEM_LEAK_SOL
if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0)
{
- RETVALUE(snprintf(buffer, size, "[0x%p]", pc));
+ return (snprintf(buffer, size, "[0x%p]", pc));
}
if ((info.dli_fname != NULLP && info.dli_sname != NULLP) &&
((uintptr_t)pc - (uintptr_t)info.dli_saddr < sym->st_size))
{
- RETVALUE(snprintf(buffer, size, "%s(%s+0x%x) [0x%p]",
+ return (snprintf(buffer, size, "%s(%s+0x%x) [0x%p]",
info.dli_fname,
info.dli_sname,
(unsigned long)pc - (unsigned long)info.dli_saddr, pc));
}
else
{
- RETVALUE(snprintf(buffer, size, "%s(0x%p [0x%p]",
+ return (snprintf(buffer, size, "%s(0x%p [0x%p]",
info.dli_fname,
(unsigned long)pc - (unsigned long)info.dli_fbase, pc));
}
Backtrace_t *bt = (Backtrace_t *)arg;
if (bt->bt_actcount >= bt->bt_maxcount)
- RETVALUE(-1);
+ return (-1);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
buffer = (S8 *)MxHeapAlloc(SsiHeap, 510);
(void) cmAddrToSymStr((void *)pc, buffer, 505);
bt->bt_buffer[bt->bt_actcount++] = (S8 *)buffer;
- RETVALUE(0);
+ return (0);
} /* cmLeakCallBack */
#endif /* SS_MEM_LEAK_SOL */
{
if (blkPtr->trSignature[sigCnt] != 0xAB)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
{
if (tailPtr->trSignature[sigCnt] != 0xFE)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif
#ifdef SSI_DEBUG_LEVEL1
if (bkt->trampleCount > CMM_TRAMPLING_THRESHOLD)
{
/* Take action to invalidate the entire bucket */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
/* reach next memory block in this bucket manually */
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
if (heapCb->trampleCount > CMM_TRAMPLING_THRESHOLD)
{
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
*
*idx = (U16)(key % hashListCp->numOfbins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashFunc () */
{
if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList,
(Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
/* initialize bin pointers */
hl = hashListCp->hashList;
hashListCp->numOfbins = nmbBins;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
hashListCp->numOfbins = 0;
hashListCp->numOfEntries = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListDeinit */
/*
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
- RETVALUE(ROK);
+ return ROK;
/* compute index for insertion */
if (cmMmHashFunc(hashListCp, key, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
hashListEnt = hashListCp->hashList;
if (i == CMM_STAT_HASH_TBL_LEN)
{
/* there is no free slot for this key */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListInsert */
#endif /* SSI_DEBUG_LEVEL1 */
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
{
entry->freedBytes += blkSz;
entry->bucketFreeReq++;
- RETVALUE(ROK);
+ return ROK;
} /* End of if */
/* If hash list is full then print the error tna continue */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* End of if */
/* Take the address of next free entry in the hash bin */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFreeInsert */
entry->allocBytes += blkSz;
entry->bucketAllocReq++;
entry->wastedBytes += (blkSz - *reqSz);
- RETVALUE(ROK);
+ return ROK;
} /* End of if */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* End of if */
/* Take the address of next free entry in the hash bin */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmAllocInsert */
}/* End of for */
*key += line;
*binIdx = ( *key % CMM_HIST_MAX_MEM_BIN);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
entry->fileName[idx] = fileName[idx];
}
entry->fileName[idx] = '\0';
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
if(tmpBin->entries[numEnt].key == key)
{
*entry = &(tmpBin->entries[numEnt]);
- RETVALUE(ROK);
+ return ROK;
}/* End of if (tmpBin->entries[numEnt].key) */
}/* end of for (numEnt = 0) */
else
{
printf ("Unable to find the entry in hash list\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}/* End of else (numEnt) */
}/* end of for (numBin = 0) */
printf("Unable to find the entry in the hash list\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHstGrmFindEntry */
#endif /* SS_HISTOGRAM_SUPPORT */
/* error check on parameters */
if ((regCb == NULLP) || (cfg == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Error check on the configuration fields */
if ((!cfg->size) || (cfg->vAddr == NULLP) ||
(cfg->numBkts > CMM_MAX_BKT_ENT))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the quantum size is power of 2 */
if ((cfg->numBkts) &&
/* cm_mem_c_001.main_20 Addition */
sprintf(errMsg,"\n cmMmRegInit() failed, check if BktQuantum size might not be power of 2 \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*
\n",bktIdx,cfg->bktCfg[bktIdx].size,cfg->bktQnSize);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((bktBlkSize = cfg->bktCfg[bktIdx].size) < lstQnSize)
/* cm_mem_c_001.main_20 Addition */
sprintf(errMsg,"\n cmMmRegInit() failed, Two consecutive buckets are not separated by quantum size \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (((cfg->bktCfg[bktIdx].size) /\
\n should be less than CMM_MAX_MAP_ENT:%d \n",cfg->bktQnSize,CMM_MAX_MAP_ENT);
#endif
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
sprintf(errMsg,"\n cmMmRegInit() failed, Size of the memory region is less than the required size \n");
SPrint(errMsg);
- RETVALUE(RFAILED);
+ return RFAILED;
}
lstQnSize = ((bktBlkSize / cfg->bktQnSize) + 1) * cfg->bktQnSize;
/* Call SRegRegion to register the memory region with SSI */
if (SRegRegion(region, ®Cb->regInfo) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegInit*/
#ifdef SS_MEM_WL_DEBUG
if (cmInitBtInfo() == RFAILED)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
for ( bktIdx = 0; bktIdx < regCb->numBkts; bktIdx++)
*next = NULLP;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmGlobRegInit*/
#ifdef SS_USE_ICC_MEMORY
if((SLock(&iccAllocFreeLock)) != ROK)
{
printf("cmIccAllocWithLock: Failed to get the ICC lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
memPtr = (Data *)TL_Alloc(regCb->iccHdl, *size);
if((SUnlock(&iccAllocFreeLock)) != ROK)
{
printf("cmIccAllocWithLock: Failed to unlock the ICC lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((memPtr) == NULLP)
#endif
*ptr = memPtr;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmIccAllocWithLock */
if((SLock(&iccAllocFreeLock)) != ROK)
{
printf("cmIccFreeWithLock: Failed to get the ICC lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef T2K_MEM_LEAK_DBG
if((SUnlock(&iccAllocFreeLock)) != ROK)
{
printf("cmIccFreeWithLock: Failed to unlock the ICC lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmIccFree */
/*
*ptr = memPtr; /*TL_VA2TRUEVA(regCb->iccHdl, memPtr); */
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of cmIccAlloc */
/*TL_Free(regCb->iccHdl, ptr);*/
- RETVALUE(ROK);
+ return ROK;
} /* end of cmIccFree */
/*
if (SRegDynRegion(regCb->region, ®Info) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmDynRegInit*/
#else /* SS_USE_ICC_MEMORY */
if (SRegDynRegion(region, ®Info) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmDynRegInit*/
#endif /* SS_USE_ICC_MEMORY */
/* error check on parameters */
if (regCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Deinitialize the hash table used for debug info storage at region level */
if (cmMmHashListDeinit(®Cb->hashListCp, regCb->region, 0) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SSI_DEBUG_LEVEL1 */
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmRegDeInit */
/* Check if the element exits or not */
if((memSetNode == NULLP) || (memSetNode->node == NULLP))
{
- RETVALUE(NULLP);
+ return (NULLP);
}
bkt->crntMemBlkSetElem = (CmMmBlkSetElement *)memSetNode->node;
/* Get the new block set from the gloabl region and return the same */
ssGetDynMemBlkSet(bucketIndex, bkt->crntMemBlkSetElem, 0);
- RETVALUE(bkt->crntMemBlkSetElem);
+ return (bkt->crntMemBlkSetElem);
}
/* If this is not the first time, take the bucket list CB from the
* current index */
/* if next node also empty, return failure */
if(memBlkSetElem->numFreeBlks == 0)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
/* store the new index in the current node which will be
* used in the next time. */
}
/* On successful, return the bucket node to calling function */
- RETVALUE(memBlkSetElem);
+ return (memBlkSetElem);
} /* cmGetMemBlkSetForAlloc */
/* Check if the element exits or not */
if((memSetNode == NULLP) || (memSetNode->node == NULLP))
{
- RETVALUE(NULLP);
+ return (NULLP);
}
bkt->crntMemBlkSetElem = (CmMmBlkSetElement *)memSetNode->node;
- RETVALUE(bkt->crntMemBlkSetElem);
+ return (bkt->crntMemBlkSetElem);
}
/* If this is not the first time, take the bucket list CB from the
* current index */
/* if next node also empty, return failure */
if(memBlkSetElem->numFreeBlks >= bkt->bucketSetSize)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
/* store the new index in the current node which will be
* used in the next time. */
}
/* On successful, return the bucket node to calling function */
- RETVALUE(memBlkSetElem);
+ return (memBlkSetElem);
}
#endif /* SS_USE_ICC_MEMORY */
#endif /* USE_PURE */
printf("Analysis from Array storing BT for freeing and allocation\n");
cmAnalyseBtInfo(ptr, regionCb->region);
SUnlock(&memDoubleFreeLock);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cmHashListDelete(&(memDoubleFree), (PTR)memNode)) != ROK)
{
SUnlock(&memDoubleFreeLock);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SUnlock(&memDoubleFreeLock);
SPutSBuf(regionCb->region, 0, (Data *)memNode, sizeof(CmMemDoubleFree));
- RETVALUE(ROK);
+ return ROK;
}
/*
SGetSBuf(regionCb->region, 0, (Data **)&memNode, sizeof(CmMemDoubleFree));
if(memNode == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
memNode->memBlkPtr = ptr;
sizeof(PTR))) != ROK)
{
SUnlock(&memDoubleFreeLock);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SUnlock(&memDoubleFreeLock);
- RETVALUE(ROK);
+ return ROK;
}
#endif
if((SLock(&dynAllocFreeLock)) != ROK)
{
printf("cmDynAllocWithLock: Failed to get the dyn lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cmDynAlloc (regionCb, size,flags,ptr);
if((SUnlock(&dynAllocFreeLock)) != ROK)
{
printf("cmDynAllocWithLock: Failed to unlock the Dyn lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* end of cmDynAlloc */
/*
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
printf("Failed to get the buffer of size %d\n", *size);
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (idx > 512)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Dequeue the memory block and return it to the user */
bktIdx = regCb->mapTbl[idx].bktIdx;
#else
printf("Failed to get the buffer of size %d\n", *size);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MEM_WL_DEBUG
*ptr = dynMemElem->nextBktPtr;
if (*ptr == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
dynMemElem->nextBktPtr = *((CmMmEntry **)(*ptr));
dynMemElem->numFreeBlks--;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* If the size is not matching, return failure to caller */
#else
printf("Failed to get the buffer of size %d\n", *size);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
*ptr = (Data *)malloc(*size);
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
/* avail_size -= *size; */
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmDynAlloc */
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if ((memType != CMM_STATIC_MEM_FLAG) && (memType != CMM_DYNAMIC_MEM_FLAG))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
#endif /* SSI_DEBUG_LEVEL1 */
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
(Void) SUnlock(&(bkt->bktLock));
#endif
/* return RFAILED */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else if (flags)
{
#ifdef SS_HISTOGRAM_SUPPORT
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
#else
/* cm_mem_c_001.main_12 - addition for passing an extra parameter */
#ifdef SSI_DEBUG_LEVEL1
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size, memType));
#else
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
#endif /* SSI_DEBUG_LEVEL1 */
#endif /* SS_HISTOGRAM_SUPPORT */
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data*) malloc(*size);
#endif
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
avail_size -= *size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAlloc */
if((cmHashListInit(&(memDoubleFree), 1000, offset, 0,
CM_HASH_KEYTYPE_U32MOD, 0, 0)) != ROK);
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
SInitLock(&memDoubleFreeLock, SS_LOCK_MUTEX);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_MEM_WL_DEBUG
regBtInfo = (CmBtInfo *)calloc(1, 8 * sizeof (CmBtInfo));
if (regBtInfo == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocBtInfo = (CmBtInfo *)calloc(1, 8 * sizeof (CmBtInfo));
if(allocBtInfo == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_MEM_WL_DEBUG */
/*
if((SLock(&dynAllocFreeLock)) != ROK)
{
printf("dynAllocWithLock: Failed to get the DYN lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cmDynFree(regionCb, ptr,size);
if((SUnlock(&dynAllocFreeLock)) != ROK)
{
printf("dynAllocWithLock: Failed to unlock the dyn lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* end of cmDynFree */
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Check if the bucket index, if its not valid, return failure */
if(dynMemElem == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MEM_WL_DEBUG
dynMemElem->nextBktPtr = ptr;
dynMemElem->numFreeBlks++;
- RETVALUE(ROK);
+ return ROK;
#else /* use pure is on */
TRC2(cmDynFree);
/* avail_size += size; */
free(ptr);
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* cm_mem_c_001.main_20 Addition */
if (ptr < regCb->regInfo.start)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
{
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
#endif
/* handle RDBLFREE in SFree/SPutSBuf */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
if (CMM_IS_STATIC(ptrHdr->memFlags))
{
#else
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
else
{
#endif
/* handle RTRAMPLINGNOK in SFree/SPutSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
(Void) SUnlock(&(bkt->bktLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size, line, fileName, entId, hstReg));
#else
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#endif /* SS_HISTOGRAM_SUPPORT */
#else /* use pure is on */
TRC2(cmFree);
(Void)free(ptr);
#endif
avail_size += size;
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/* error check on parameters */
if ((regCb == NULLP) || (size == NULLP) || !(*size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* Update the size parameter */
*size = bkt->size;
- RETVALUE(ROK);
+ return ROK;
}
}
}
* heap pool.
*/
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
- RETVALUE(cmHeapAlloc(&(regCb->heapCb), ptr, size));
+ return (cmHeapAlloc(&(regCb->heapCb), ptr, size));
}
/* No memory available */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* use pure is on */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
*ptr = (Data *)malloc(*size);
if ( (*ptr) == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
/* avail_size -= *size; */
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
} /* end of cmAllocWL */
/* error check on parameters */
if ((regCb == NULLP) || (!size) || (ptr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Check if the memory block is from the memory region */
if (ptr >= ((CmMmRegCb *)regCb)->regInfo.start +
((CmMmRegCb *)regCb)->regInfo.size)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (regCb->mapTbl[idx].bktIdx == 0xFF)
{
/* Some fatal error in the map table initialization. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*/
bkt->numAlloc--;
- RETVALUE(ROK);
+ return ROK;
}
/* The memory block was allocated from the heap pool */
- RETVALUE(cmHeapFree (&(regCb->heapCb), ptr, size));
+ return (cmHeapFree (&(regCb->heapCb), ptr, size));
#else /* use pure is on */
TRC2(cmFree);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
/* avail_size += size; */
free(ptr);
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
/* error check on parameters */
if ((regCb == NULLP) || (memCtl == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((memCtl->u.vtop.vaddr == NULLP) ||
(memCtl->u.vtop.paddr == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
offset = memCtl->u.vtop.vaddr - regCb->regInfo.start;
*(memCtl->u.vtop.paddr) = regCb->pAddr + offset;
- RETVALUE(ROK);
+ return ROK;
}
break;
}
if (!(memCtl->u.chkres.size) ||
(memCtl->u.chkres.status == NULLP))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifndef USE_PURE
(regCb->heapSize/10));
}
- RETVALUE(ROK);
+ return ROK;
#else /* use pure is on */
*(memCtl->u.chkres.status) = ((avail_size) /
(regCb->regInfo.size/10));
- RETVALUE(ROK);
+ return ROK;
#endif /* USE_PURE */
}
default:
{
/* No other event is supported currently */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* shouldn't reach here */
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmCtl */
\f
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
#else
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
} /* end of cmHeapAlloc */
(Void) SUnlock (&(heapCb->heapLock));
#endif
/* handle RTRAMPLINGNOK in SAlloc/SGetSBuf */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
else
{
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(ROK);
+ return ROK;
}
}
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
#endif /* SSI_DEBUG_LEVEL1 */
#endif
/* This block is already freed in the heap */
- RETVALUE(RDBLFREE);
+ return (RDBLFREE);
}
/* update the flags as it is a new node */
if (CMM_IS_STATIC(p->memFlags))
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
else if (p < curHBlk)
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
}
}
}/* End of if */
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
/* Release the lock */
(Void) SUnlock (&(heapCb->heapLock));
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHeapFree */
/* cm_mem_c_001.main_15 : Additions */
#endif
funNm);
if(memReqIdx >= 0)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
(const S8 *)memUsrMdlStr[mdlFunStrIdx].fPStr);
if(retVal == NULLD)
{
- RETVALUE(mdlFunStrIdx);
+ return (mdlFunStrIdx);
}
mdlFunStrIdx++;
}
}
- RETVALUE(0);
+ return (0);
} /* cmMemGetModuleId */
/*
if(!found)
{
- RETVALUE(-1);
+ return (-1);
}
- RETVALUE(strtIdx);
+ return (strtIdx);
} /* cmMemGetStrMtchIdx */
if (dladdr1(pc, &info, (Void **)&sym, RTLD_DL_SYMENT) == 0)
{
- RETVALUE(snprintf(buffer, size, "[0x%p]", pc));
+ return (snprintf(buffer, size, "[0x%p]", pc));
}
if ((info.dli_fname != NULLP && info.dli_sname != NULLP) &&
((uintptr_t)pc - (uintptr_t)info.dli_saddr < sym->st_size))
{
- RETVALUE(snprintf(buffer, size, "%s(%s+0x%x) [0x%p]",
+ return (snprintf(buffer, size, "%s(%s+0x%x) [0x%p]",
info.dli_fname,
info.dli_sname,
(unsigned long)pc - (unsigned long)info.dli_saddr, pc));
}
else
{
- RETVALUE(snprintf(buffer, size, "%s(0x%p [0x%p]",
+ return (snprintf(buffer, size, "%s(0x%p [0x%p]",
info.dli_fname,
(unsigned long)pc - (unsigned long)info.dli_fbase, pc));
}
Backtrace_t *bt = (Backtrace_t *)arg;
if (bt->bt_actcount >= bt->bt_maxcount)
- RETVALUE(-1);
+ return (-1);
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
buffer = (S8 *)MxHeapAlloc(SsiHeap, 510);
(void) cmAddrToSymStr((void *)pc, buffer, 505);
bt->bt_buffer[bt->bt_actcount++] = (S8 *)buffer;
- RETVALUE(0);
+ return (0);
} /* cmLeakCallBack */
/*
bt.bt_actcount = 0;
if (getcontext(&u) < 0)
- RETVALUE(0);
+ return (0);
(Void) walkcontext(&u, cmLeakCallBack, &bt);
- RETVALUE(bt.bt_actcount);
+ return (bt.bt_actcount);
} /* backtrace */
if (bkt->trampleCount > CMM_TRAMPLING_THRESHOLD)
{
/* Take action to invalidate the entire bucket */
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
}
/* reach next memory block in this bucket manually */
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
if (heapCb->trampleCount > CMM_TRAMPLING_THRESHOLD)
{
- RETVALUE(RTRAMPLINGNOK);
+ return (RTRAMPLINGNOK);
}
- RETVALUE(RTRAMPLINGOK);
+ return (RTRAMPLINGOK);
}
/*
{
if (blkPtr->trSignature[sigCnt] != 0xAB)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
*idx = (U16)(key % hashListCp->numOfbins);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashFunc () */
{
if (SGetSBuf(region, pool, (Data **) &hashListCp->hashList,
(Size)(nmbBins * sizeof(CmMmHashListEnt))) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
/* initialize bin pointers */
hl = hashListCp->hashList;
hashListCp->numOfbins = nmbBins;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
hashListCp->numOfbins = 0;
hashListCp->numOfEntries = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListDeinit */
/*
/* check if hashListCp is initialised yet */
if ( hashListCp->numOfbins == 0)
- RETVALUE(ROK);
+ return ROK;
/* compute index for insertion */
if (cmMmHashFunc(hashListCp, key, &idx) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
hashListEnt = hashListCp->hashList;
if (i == CMM_STAT_HASH_TBL_LEN)
{
/* there is no free slot for this key */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmMmHashListInsert */
#endif /* SSI_DEBUG_LEVEL1 */
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
SDisplay(0, dbgPrntBuf);
#endif /* DEBUGP */
memset(hashListCp, 0, sizeof(CmHstGrmHashListCp));
- RETVALUE(ROK);
+ return ROK;
}
/*
{
entry->freedBytes += blkSz;
entry->bucketFreeReq++;
- RETVALUE(ROK);
+ return ROK;
} /* End of if */
/* If hash list is full then print the error tna continue */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN \n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* End of if */
/* Take the address of next free entry in the hash bin */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFreeInsert */
entry->allocBytes += blkSz;
entry->bucketAllocReq++;
entry->wastedBytes += (blkSz - *reqSz);
- RETVALUE(ROK);
+ return ROK;
} /* End of if */
if(hashListCp->totalNumEntries == (CMM_HIST_MAX_MEM_BIN * CMM_HIST_MAX_MEM_ENTRY_PER_BIN))
{
printf("No place in the hash list. Increase the value of macro CMM_HIST_MAX_MEM_BIN and CMM_HIST_MAX_MEM_ENTRY_PER_BIN\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* End of if */
/* Take the address of next free entry in the hash bin */
/* Increase the total number of entries in the hash list */
hashListCp->totalNumEntries++;
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmAllocInsert */
}/* End of for */
*key += line;
*binIdx = ( *key % CMM_HIST_MAX_MEM_BIN);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
entry->fileName[idx] = fileName[idx];
}
entry->fileName[idx] = '\0';
- RETVALUE(ROK);
+ return ROK;
} /* end of cmHstGrmFillEntry */
/*
if(tmpBin->entries[numEnt].key == key)
{
*entry = &(tmpBin->entries[numEnt]);
- RETVALUE(ROK);
+ return ROK;
}/* End of if (tmpBin->entries[numEnt].key) */
}/* end of for (numEnt = 0) */
else
{
printf ("Unable to find the entry in hash list\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}/* End of else (numEnt) */
}/* end of for (numBin = 0) */
printf("Unable to find the entry in the hash list\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of cmHstGrmFindEntry */
#endif /* SS_HISTOGRAM_SUPPORT */
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
((poolOneFreeCnt * 100) >
(ICC_MEM_LOWER_THRESHOLD * ICC_POOL_ONE_TOTAL_BLKS)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
((poolThreeFreeCnt * 100) >
(ICC_MEM_LOWER_THRESHOLD * ICC_POOL_THREE_TOTAL_BLKS)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/*
((poolThreeFreeCnt * 100) <
(ICC_MEM_UPPER_THRESHOLD * ICC_POOL_THREE_TOTAL_BLKS)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/* ccpu00142274- Function to check if we have reached the
if(gMemoryAlarm)
{
gMemoryAlarm = !(isMemUsageBelowLowerThreshold(reg));
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
memoryCheckCounter = 0;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
#endif /* SS_LOCKLESS_MEMORY */
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
printf("\n MBuf Allocation failed\n");
}
- RETVALUE(mBuf);
+ return (mBuf);
}
#ifdef ANSI
TRC2(TSInfUtlPackUeInfo)
- CMCHKPK(SPkU32, stats->persistent.numDeactivation, mBuf);
- CMCHKPK(SPkU32, stats->persistent.numActivation, mBuf);
- CMCHKPK(SPkU32, stats->persistent.activatedSCells, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->persistent.numDeactivation, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->persistent.numActivation, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->persistent.activatedSCells, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.rlc.dlMaxWindowSz, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.rlc.dlMaxPktsInSduQ, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.rlc.ulReOdrTmrExpCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.rlc.dlMaxWindowSz, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.rlc.dlMaxPktsInSduQ, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.rlc.ulReOdrTmrExpCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.pdcp.dlFlowCtrlDropCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.pdcp.dlPdcpAckWaitDropCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.pdcp.dlPdcpDropCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.pdcp.dlFlowCtrlDropCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.pdcp.dlPdcpAckWaitDropCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.pdcp.dlPdcpDropCnt, mBuf);
for (k = 0; k < L2_STATS_MAX_CELLS; k++)
{
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulTpt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulNumiTbs, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulSumiTbs, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulNumCqi, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulSumCqi, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulDtxCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulNackCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulAckNackCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulPrbUsg, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulRetxOccns, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].ulTxOccns, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlTpt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlBo, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulTpt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulNumiTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulSumiTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulNumCqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulSumCqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulDtxCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulNackCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulAckNackCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulPrbUsg, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulRetxOccns, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].ulTxOccns, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlTpt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlBo, mBuf);
for (i=0; i<4; i++)
{
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].riCnt[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].riCnt[i], mBuf);
}
for (i=0; i<5; i++)
{
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlPdbLvl[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlPdbLvl[i], mBuf);
}
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].cqiDropCnt, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlNumCw1iTbs, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlSumCw1iTbs, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlNumCw0iTbs, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlSumCw0iTbs, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlNumCw1Cqi, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlSumCw1Cqi, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlNumCw0Cqi, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlSumCw0Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].cqiDropCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlNumCw1iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlSumCw1iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlNumCw0iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlSumCw0iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlNumCw1Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlSumCw1Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlNumCw0Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlSumCw0Cqi, mBuf);
for (i=0; i<2; i++)
{
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlDtxCnt[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlDtxCnt[i], mBuf);
}
for (i=0; i<2; i++)
{
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlAckNackCnt[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlAckNackCnt[i], mBuf);
}
for (i=0; i<2; i++)
{
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlNackCnt[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlNackCnt[i], mBuf);
}
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlPrbUsg, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlRetxOccns, mBuf);
- CMCHKPK(SPkU32, stats->nonPersistent.sch[k].dlTxOccns, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlPrbUsg, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlRetxOccns, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlTxOccns, mBuf);
}
- CMCHKPK(SPkU32, stats->rnti, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->rnti, mBuf);
RETVOID;
}
TRC2(TSInfUtlPackCellInfo)
- CMCHKPK(SPkU32, stats->rlc.reOdrTmrExp, mBuf);
- CMCHKPK(SPkU32, stats->rlc.maxRlcDrbRetxFail, mBuf);
- CMCHKPK(SPkU32, stats->rlc.maxRlcSrbRetxFail, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->rlc.reOdrTmrExp, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->rlc.maxRlcDrbRetxFail, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->rlc.maxRlcSrbRetxFail, mBuf);
- CMCHKPK(SPkU32, stats->sch.ulNumiTbs, mBuf);
- CMCHKPK(SPkU32, stats->sch.ulSumiTbs, mBuf);
- CMCHKPK(SPkU32, stats->sch.ulNumCqi, mBuf);
- CMCHKPK(SPkU32, stats->sch.ulSumCqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulNumiTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulSumiTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulNumCqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulSumCqi, mBuf);
#ifdef RG_5GTF
- CMCHKPK(SPkU32, stats->sch.ul5gtfRbAllocFail, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfPdcchSend, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfUeFnlzReAdd, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfUeRmvFnlzZeroBo, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfUeRbAllocDone, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfAllocAllocated, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfPdcchSchd, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfUeSchPick, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfBsrRecv, mBuf);
- CMCHKPK(SPkU32, stats->sch.ul5gtfSrRecv, mBuf);
-
- CMCHKPK(SPkU32, stats->sch.dl5gtfPdschCons, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfPdcchSend, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfBoUpd, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfFnlzFail, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfFnlzPass, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfRbAllocFail, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfRbAllocPass, mBuf);
- CMCHKPK(SPkU32, stats->sch.dl5gtfUePick, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfRbAllocFail, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfPdcchSend, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfUeFnlzReAdd, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfUeRmvFnlzZeroBo, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfUeRbAllocDone, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfAllocAllocated, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfPdcchSchd, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfUeSchPick, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfBsrRecv, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ul5gtfSrRecv, mBuf);
+
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfPdschCons, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfPdcchSend, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfBoUpd, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfFnlzFail, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfFnlzPass, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfRbAllocFail, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfRbAllocPass, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dl5gtfUePick, mBuf);
#endif
- CMCHKPK(SPkU32, stats->sch.cntTtiProcTime500, mBuf);
- CMCHKPK(SPkU32, stats->sch.cntTtiProcTime600, mBuf);
- CMCHKPK(SPkU32, stats->sch.cntTtiProcTime700, mBuf);
- CMCHKPK(SPkU32, stats->sch.cntTtiProcTime800, mBuf);
- CMCHKPK(SPkU32, stats->sch.cntTtiProcTime900, mBuf);
- CMCHKPK(SPkU32, stats->sch.cntTtiProcTime1000, mBuf);
- CMCHKPK(SPkU32, stats->sch.avgTtiProcTime, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.cntTtiProcTime500, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.cntTtiProcTime600, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.cntTtiProcTime700, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.cntTtiProcTime800, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.cntTtiProcTime900, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.cntTtiProcTime1000, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.avgTtiProcTime, mBuf);
for (i=9; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.dlPdbRatio[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlPdbRatio[i], mBuf);
}
for (i=9; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.ulPrbUsage[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulPrbUsage[i], mBuf);
}
for (i=9; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.dlPrbUsage[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlPrbUsage[i], mBuf);
}
for (i=3; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.ulDtx[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulDtx[i], mBuf);
}
for (i=3; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.ulAckNack[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulAckNack[i], mBuf);
}
for (i=3; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.ulNack[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.ulNack[i], mBuf);
}
for (i=1; i>=0; i--)
{
for (j=3; j>=0; j--)
{
- CMCHKPK(SPkU32, stats->sch.dlDtx[i][j], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlDtx[i][j], mBuf);
}
}
for (i=1; i>=0; i--)
{
for (j=3; j>=0; j--)
{
- CMCHKPK(SPkU32, stats->sch.dlAckNack[i][j], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlAckNack[i][j], mBuf);
}
}
for (i=1; i>=0; i--)
{
for (j=3; j>=0; j--)
{
- CMCHKPK(SPkU32, stats->sch.dlNack[i][j], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlNack[i][j], mBuf);
}
}
for (i=3; i>=0; i--)
{
- CMCHKPK(SPkU32, stats->sch.riCnt[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.riCnt[i], mBuf);
}
- CMCHKPK(SPkU32, stats->sch.dlNumCw1iTbs, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlSumCw1iTbs, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlNumCw0iTbs, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlSumCw0iTbs, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlNumCw1Cqi, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlSumCw1Cqi, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlNumCw0Cqi, mBuf);
- CMCHKPK(SPkU32, stats->sch.dlSumCw0Cqi, mBuf);
- CMCHKPK(SPkU32, stats->sch.msg3Fail, mBuf);
- CMCHKPK(SPkU32, stats->sch.msg4Fail, mBuf);
-
- CMCHKPK(SPkU32, stats->cellId, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlNumCw1iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlSumCw1iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlNumCw0iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlSumCw0iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlNumCw1Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlSumCw1Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlNumCw0Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.dlSumCw0Cqi, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.msg3Fail, mBuf);
+ CMCHKPK(oduUnpackUInt32, stats->sch.msg4Fail, mBuf);
+
+ CMCHKPK(oduUnpackUInt32, stats->cellId, mBuf);
RETVOID;
}
TRC2(TSInfUtlUnpkUeInfo)
- CMCHKUNPK(SUnpkU32, &stats->rnti, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->rnti, mBuf);
for (k = L2_STATS_MAX_CELLS; k > 0; k--)
{
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlTxOccns, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlRetxOccns, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlPrbUsg, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlTxOccns, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlRetxOccns, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlPrbUsg, mBuf);
for (i=1; i>=0; i--)
{
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlNackCnt[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlNackCnt[i], mBuf);
}
for (i=1; i>=0; i--)
{
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlAckNackCnt[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlAckNackCnt[i], mBuf);
}
for (i=1; i>=0; i--)
{
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlDtxCnt[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlDtxCnt[i], mBuf);
}
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlSumCw0Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlNumCw0Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlSumCw1Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlNumCw1Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlSumCw0iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlNumCw0iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlSumCw1iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlNumCw1iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].cqiDropCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlSumCw0Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlNumCw0Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlSumCw1Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlNumCw1Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlSumCw0iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlNumCw0iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlSumCw1iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlNumCw1iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].cqiDropCnt, mBuf);
for (i=4; i>=0; i--)
{
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlPdbLvl[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlPdbLvl[i], mBuf);
}
for (i=3; i>=0; i--)
{
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].riCnt[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].riCnt[i], mBuf);
}
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlBo, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].dlTpt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulTxOccns, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulRetxOccns, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulPrbUsg, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulAckNackCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulNackCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulDtxCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulSumCqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulNumCqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulSumiTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulNumiTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.sch[k-1].ulTpt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlBo, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].dlTpt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulTxOccns, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulRetxOccns, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulPrbUsg, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulAckNackCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulNackCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulDtxCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulSumCqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulNumCqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulSumiTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulNumiTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.sch[k-1].ulTpt, mBuf);
}
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.pdcp.dlPdcpDropCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.pdcp.dlPdcpAckWaitDropCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.pdcp.dlFlowCtrlDropCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.pdcp.dlPdcpDropCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.pdcp.dlPdcpAckWaitDropCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.pdcp.dlFlowCtrlDropCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.rlc.ulReOdrTmrExpCnt, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.rlc.dlMaxPktsInSduQ, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->nonPersistent.rlc.dlMaxWindowSz, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.rlc.ulReOdrTmrExpCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.rlc.dlMaxPktsInSduQ, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->nonPersistent.rlc.dlMaxWindowSz, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->persistent.activatedSCells, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->persistent.numActivation, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->persistent.numDeactivation, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->persistent.activatedSCells, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->persistent.numActivation, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->persistent.numDeactivation, mBuf);
RETVOID;
}
TRC2(TSInfUtlUnpkCellInfo)
- CMCHKUNPK(SUnpkU32, &stats->cellId, mBuf);
-
- CMCHKUNPK(SUnpkU32, &stats->sch.msg4Fail, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.msg3Fail, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlSumCw0Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlNumCw0Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlSumCw1Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlNumCw1Cqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlSumCw0iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlNumCw0iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlSumCw1iTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dlNumCw1iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->cellId, mBuf);
+
+ CMCHKUNPK(oduPackUInt32, &stats->sch.msg4Fail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.msg3Fail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlSumCw0Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlNumCw0Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlSumCw1Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlNumCw1Cqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlSumCw0iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlNumCw0iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlSumCw1iTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlNumCw1iTbs, mBuf);
for (i=0; i<4; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.riCnt[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.riCnt[i], mBuf);
}
for (i=0; i<2; i++)
{
for (j=0; j<4; j++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.dlNack[i][j], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlNack[i][j], mBuf);
}
}
for (i=0; i<2; i++)
{
for (j=0; j<4; j++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.dlAckNack[i][j], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlAckNack[i][j], mBuf);
}
}
for (i=0; i<2; i++)
{
for (j=0; j<4; j++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.dlDtx[i][j], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlDtx[i][j], mBuf);
}
}
for (i=0; i<4; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.ulNack[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulNack[i], mBuf);
}
for (i=0; i<4; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.ulAckNack[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulAckNack[i], mBuf);
}
for (i=0; i<4; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.ulDtx[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulDtx[i], mBuf);
}
for (i=0; i<10; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.dlPrbUsage[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlPrbUsage[i], mBuf);
}
for (i=0; i<10; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.ulPrbUsage[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulPrbUsage[i], mBuf);
}
for (i=0; i<10; i++)
{
- CMCHKUNPK(SUnpkU32, &stats->sch.dlPdbRatio[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dlPdbRatio[i], mBuf);
}
- CMCHKUNPK(SUnpkU32, &stats->sch.avgTtiProcTime, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.cntTtiProcTime1000, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.cntTtiProcTime900, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.cntTtiProcTime800, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.cntTtiProcTime700, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.cntTtiProcTime600, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.cntTtiProcTime500, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.avgTtiProcTime, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.cntTtiProcTime1000, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.cntTtiProcTime900, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.cntTtiProcTime800, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.cntTtiProcTime700, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.cntTtiProcTime600, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.cntTtiProcTime500, mBuf);
#ifdef RG_5GTF
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfUePick, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfRbAllocPass, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfRbAllocFail, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfFnlzPass, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfFnlzFail, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfBoUpd, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfPdcchSend, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.dl5gtfPdschCons, mBuf);
-
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfSrRecv, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfBsrRecv, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfUeSchPick, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfPdcchSchd, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfAllocAllocated, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfUeRbAllocDone, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfUeRmvFnlzZeroBo, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfUeFnlzReAdd, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfPdcchSend, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ul5gtfRbAllocFail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfUePick, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfRbAllocPass, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfRbAllocFail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfFnlzPass, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfFnlzFail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfBoUpd, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfPdcchSend, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.dl5gtfPdschCons, mBuf);
+
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfSrRecv, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfBsrRecv, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfUeSchPick, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfPdcchSchd, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfAllocAllocated, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfUeRbAllocDone, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfUeRmvFnlzZeroBo, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfUeFnlzReAdd, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfPdcchSend, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ul5gtfRbAllocFail, mBuf);
#endif
- CMCHKUNPK(SUnpkU32, &stats->sch.ulSumCqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ulNumCqi, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ulSumiTbs, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->sch.ulNumiTbs, mBuf);
-
- CMCHKUNPK(SUnpkU32, &stats->rlc.maxRlcSrbRetxFail, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->rlc.maxRlcDrbRetxFail, mBuf);
- CMCHKUNPK(SUnpkU32, &stats->rlc.reOdrTmrExp, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulSumCqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulNumCqi, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulSumiTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->sch.ulNumiTbs, mBuf);
+
+ CMCHKUNPK(oduPackUInt32, &stats->rlc.maxRlcSrbRetxFail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->rlc.maxRlcDrbRetxFail, mBuf);
+ CMCHKUNPK(oduPackUInt32, &stats->rlc.reOdrTmrExp, mBuf);
RETVOID;
}
}
/* Token Header */
- CMCHKPK(SPkU8, tknS16->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknS16->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknS16 */
\f
CMPKTKNBSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknBStr32 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr8 */
CMPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStr16 */
/* Value */
for (ndx = 0; ndx < tknStr->len; ndx++)
{
- CMCHKPK(SPkU8, tknStr->val[ndx], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[ndx], mBuf);
}
/* Length */
- CMCHKPK(SPkU16, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrOSXL */
/* Value */
for (ndx = 0; ndx < len; ndx++)
{
- CMCHKPK(SPkU8, tknStr->val[ndx], mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->val[ndx], mBuf);
}
/* Length */
- CMCHKPK(SPkU16, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrBSXL */
/* Value */
for (ndx = 0; ndx < tknStr->len; ndx++)
{
- CMCHKPK(SPkU16, tknStr->val[ndx], mBuf);
+ CMCHKPK(oduUnpackUInt16, tknStr->val[ndx], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrBMP4 */
\f
/* Value */
for (ndx = 0; ndx < tknStr->len; ndx++)
{
- CMCHKPK(SPkU16, tknStr->val[ndx], mBuf);
+ CMCHKPK(oduUnpackUInt16, tknStr->val[ndx], mBuf);
}
/* Length */
- CMCHKPK(SPkU16, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrBMPXL */
\f
/* Value */
for (ndx = 0; ndx < tknStr->len; ndx++)
{
- CMCHKPK(SPkU32, tknStr->val[ndx], mBuf);
+ CMCHKPK(oduUnpackUInt32, tknStr->val[ndx], mBuf);
}
/* Length */
- CMCHKPK(SPkU8, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrUNI4 */
\f
/* Value */
for (ndx = 0; ndx < tknStr->len; ndx++)
{
- CMCHKPK(SPkU32, tknStr->val[ndx], mBuf);
+ CMCHKPK(oduUnpackUInt32, tknStr->val[ndx], mBuf);
}
/* Length */
- CMCHKPK(SPkU16, tknStr->len, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknStr->len, mBuf);
}
/* Token Header */
- CMCHKPK(SPkU8, tknStr->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkTknStrUNIXL */
\f
/*
TRC2(cmUnpkTknS16)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknS16->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknS16->pres, mBuf);
if (tknS16->pres)
{
CMCHKUNPK(SUnpkS16, &tknS16->val, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknS16 */
\f
CMUNPKTKNBSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknBStr32 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr8 */
CMUNPKTKNSTR(tknStr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStr16 */
TRC2(cmUnpkTknStrOSXL)
- 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( cmGetMem(ptr, tknStr->len, (Ptr *)&tknStr->val) != ROK)
{
- 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);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrOSXL */
TRC2(cmUnpkTknStrBSXL)
- 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 (tknStr->len % 8)
len = (tknStr->len/8) + 1;
if( cmGetMem(ptr, len, (Ptr *)&tknStr->val) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Value */
for (ndx = 1; ndx <= len; ndx++)
{
- CMCHKUNPK(SUnpkU8, &tknStr->val[len - ndx], mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[len - ndx], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrBSXL */
TRC2(cmUnpkTknStrBMP4)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if(tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (ndx = 1; ndx <= tknStr->len; ndx++)
{
- CMCHKUNPK(SUnpkU16, &tknStr->val[tknStr->len - ndx], mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknStr->val[tknStr->len - ndx], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrBMP4 */
\f
TRC2(cmUnpkTknStrBMPXL)
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if(tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
/* Each BMP Character is 2 octet long */
if( cmGetMem(ptr, 2*(tknStr->len), (Ptr *)&tknStr->val) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Value */
for (ndx = 1; ndx <= tknStr->len; ndx++)
{
- CMCHKUNPK(SUnpkU16, &tknStr->val[tknStr->len - ndx], mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknStr->val[tknStr->len - ndx], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrBMPXL */
TRC2(cmUnpkTknStrUNI4)
/* Token Header */
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if(tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf);
/* Value */
for (ndx = 1; ndx <= tknStr->len; ndx++)
{
- CMCHKUNPK(SUnpkU32, &tknStr->val[tknStr->len - ndx], mBuf);
+ CMCHKUNPK(oduPackUInt32, &tknStr->val[tknStr->len - ndx], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrUNI4 */
\f
TRC2(cmUnpkTknStrUNIXL)
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
if(tknStr->pres)
{
/* Length */
- CMCHKUNPK(SUnpkU16, &tknStr->len, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
/* Each UNI Character is 4 octets long */
if( cmGetMem(ptr, 4*tknStr->len, (Ptr *)&tknStr->val) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Value */
for (ndx = 1; ndx <= tknStr->len; ndx++)
{
- CMCHKUNPK(SUnpkU32, &tknStr->val[tknStr->len - ndx], mBuf);
+ CMCHKUNPK(oduPackUInt32, &tknStr->val[tknStr->len - ndx], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkTknStrUNIXL */
/* Value */ \
for (i = 0; i < (S16) len; i++) \
{ \
- CMCHKPK(SPkU8, tknStr->val[i], mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf); \
} \
\
/* Length */ \
- CMCHKPK(SPkU8, tknStr->len, mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf); \
} \
\
/* Token Header */ \
- CMCHKPK(SPkU8, tknStr->pres, mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf); \
}
#define CMUNPKTKNBSTR(tknStr, mBuf) \
Cntr len; \
\
/* Token Header */ \
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf); \
\
if(tknStr->pres) \
{ \
/* Length */ \
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf); \
\
if (tknStr->len % 8) \
len = (tknStr->len/8 ) + 1; \
/* Value */ \
for (i = 1; i <= (S16) len; i++) \
{ \
- CMCHKUNPK(SUnpkU8, &tknStr->val[len - i], mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[len - i], mBuf); \
} \
} \
\
TRC2(cmPkCmIpv4TptAddr)
CMCHKPK(cmPkCmIpv4NetAddr, pkParam->address, mBuf);
- CMCHKPK(SPkU16, pkParam->port, mBuf);
+ CMCHKPK(oduUnpackUInt16, pkParam->port, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmIpv4TptAddr */
/*
for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
{
- CMCHKPK(SPkU8, *(ptr+num), mBuf);
+ CMCHKPK(oduUnpackUInt8, *(ptr+num), mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6NetAddr */
\f
TRC3(cmPkCmIpv6TptAddr)
CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6NetAddr, mBuf);
- CMCHKPK(SPkU16, pkParam->port, mBuf);
+ CMCHKPK(oduUnpackUInt16, pkParam->port, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmIpv6TptAddr */
\f
TRC2(cmPkCmNetAddrTbl)
if (pkParam->count > CM_MAX_NET_ADDR)
- RETVALUE(RFAILED);
+ return RFAILED;
/* Pack All the addresses */
for (idx = pkParam->count; idx; idx--)
netAddr = &(pkParam->netAddr[idx - 1]);
if ((cmPkCmNetAddr(netAddr, mBuf)) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Pack the total number of addresses present in the table */
- CMCHKPK(SPkU16, pkParam->count, mBuf);
+ CMCHKPK(oduUnpackUInt16, pkParam->count, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmNetAddrTbl() */
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmNetAddr */
\f
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmTptAddr */
/* added new packing functions */
/* pack the actual interface address */
CMCHKPK(cmPkCmNetAddr, &pkParam->localIfAddr, mBuf);
/* pack the interface index value */
- CMCHKPK(SPkU32, pkParam->localIf, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->localIf, mBuf);
}
/* pack the boll which indicates if valid local intf is present or not */
- CMCHKPK(SPkU8, pkParam->intfPrsnt, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, pkParam->intfPrsnt, mBuf);
+ return ROK;
} /* cmPkCmTptLocalInf */
#endif /* LOCAL_INTF */
TRC3(cmPkCmNetMCastInf6)
CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->mCastAddr, mBuf);
- CMCHKPK(SPkU32, pkParam->localInf, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->localInf, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmNetMCastInf6 */
#endif /* IPV6_SUPPORTED */
break;
case CM_SOCKOPT_OPT_MCAST6_IF:
- CMCHKPK(SPkU32, pkParam->optVal.infId, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->optVal.infId, mBuf);
break;
#endif /* IPV6_SUPPORTED */
default:
- CMCHKPK(SPkU32, pkParam->optVal.value, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->optVal.value, mBuf);
break;
}
- CMCHKPK(SPkU32, pkParam->option, mBuf);
- CMCHKPK(SPkU32, pkParam->level, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->option, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->level, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmSockOpts */
\f
if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(num = 0; num < pkParam->numOpts; num++)
{
CMCHKPK(cmPkCmSockOpts, &pkParam->sockOpts[num], mBuf);
}
- CMCHKPK(SPkU8, pkParam->numOpts, mBuf);
- CMCHKPK(SPkU8, pkParam->listenQSize, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->numOpts, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->listenQSize, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmSockParam */
\f
if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(num = 0; num < pkParam->numOpts; num++)
{
CMCHKPK(cmPkCmSockOpts, &pkParam->sockOpts[num], mBuf);
}
- CMCHKPK(SPkU8, pkParam->numOpts, mBuf);
- CMCHKPK(SPkU8, pkParam->listenQSize, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->numOpts, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->listenQSize, mBuf);
CMCHKPK(SPkS16, pkParam->ctxId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkTlsTptParam */
#endif /* CM_TLS */
#endif
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkCmTptParam */
\f
{
TRC2(cmUnpkCmIpv4TptAddr)
- CMCHKUNPK(SUnpkU16, &unpkParam->port, mBuf);
+ CMCHKUNPK(oduPackUInt16, &unpkParam->port, mBuf);
CMCHKUNPK(cmUnpkCmIpv4NetAddr, &unpkParam->address, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmIpv4TptAddr */
\f
for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
{
- CMCHKUNPK(SUnpkU8, (ptr-num), mBuf);
+ CMCHKUNPK(oduPackUInt8, (ptr-num), mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6NetAddr */
\f
{
TRC3(cmUnpkCmIpv6TptAddr)
- CMCHKUNPK(SUnpkU16, &unpkParam->port, mBuf);
+ CMCHKUNPK(oduPackUInt16, &unpkParam->port, mBuf);
CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6NetAddr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmIpv6TptAddr */
\f
TRC2(cmUnpkCmNetAddrTbl)
/* Unpack the count */
- CMCHKUNPK(SUnpkU16, &(unpkParam->count), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(unpkParam->count), mBuf);
/* Unpack the addresses */
for (idx = 0; idx < unpkParam->count; idx++)
netAddr = &(unpkParam->netAddr[idx]);
if ((cmUnpkCmNetAddr(netAddr, mBuf)) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmNetAddrTbl() */
{
TRC3(cmUnpkCmNetAddr)
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
switch (unpkParam->type)
{
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmNetAddr */
\f
{
TRC3(cmUnpkCmTptAddr)
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
switch (unpkParam->type)
{
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmTptAddr */
/* Moving IPv6 multicast information unpacking functions from cm_inet.c */
{
TRC3(cmUnpkCmNetMCastInf6)
- CMCHKUNPK(SUnpkU32, &unpkParam->localInf, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->localInf, mBuf);
CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->mCastAddr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmNetMCastInf6 */
#endif /* IPV6_SUPPORTED */
{
TRC3(cmUnpkCmSockOpts)
- CMCHKUNPK(SUnpkU32, &unpkParam->level, mBuf);
- CMCHKUNPK(SUnpkU32, &unpkParam->option, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->level, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->option, mBuf);
switch (unpkParam->option)
{
break;
case CM_SOCKOPT_OPT_MCAST6_IF:
- CMCHKUNPK(SUnpkU32, &unpkParam->optVal.infId, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->optVal.infId, mBuf);
break;
#endif /* IPV6_SUPPORTED */
default:
- CMCHKUNPK(SUnpkU32, &unpkParam->optVal.value, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->optVal.value, mBuf);
break;
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmSockOpts */
\f
TRC3(cmUnpkCmSockParam)
- CMCHKUNPK(SUnpkU8, &unpkParam->listenQSize, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->numOpts, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->numOpts, mBuf);
if( unpkParam->numOpts > CM_MAX_SOCK_OPTS)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(num = 0; num < unpkParam->numOpts; num++)
CMCHKUNPK(cmUnpkCmSockOpts, &unpkParam->sockOpts[num], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmSockParam */
\f
TRC3(cmUnpkTlsTptParam)
CMCHKUNPK(SUnpkS16, &unpkParam->ctxId, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->listenQSize, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->numOpts, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->numOpts, mBuf);
if( unpkParam->numOpts > CM_MAX_SOCK_OPTS)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(num = 0; num < unpkParam->numOpts; num++)
CMCHKUNPK(cmUnpkCmSockOpts, &unpkParam->sockOpts[num], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkTlsTptParam */
#endif /* CM_TLS */
{
TRC3(cmUnpkCmTptParam)
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
switch (unpkParam->type)
{
#endif
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmTptParam */
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* End of cmPkCmIpHdrParm */
\f
TRC3(cmUnpkCmTptLocalInf)
/* first unpack the bool intfPrsnt value which is always packed */
- CMCHKUNPK(cmUnpkBool, &unpkParam->intfPrsnt, mBuf);
+ CMCHKUNPK(oduUnpackBool, &unpkParam->intfPrsnt, mBuf);
/* if the above unpacked bool is TRUE then we have to unpack further
* to get the local intf index and intf address */
if (unpkParam->intfPrsnt == TRUE)
{
- CMCHKUNPK(SUnpkU32, &unpkParam->localIf, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->localIf, mBuf);
CMCHKUNPK(cmUnpkCmNetAddr, &unpkParam->localIfAddr, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkCmTptLocalInf */
#endif /* LOCAL_INTF */
/* pack first Route hdr */
if (pkParam->rtOptsPrsnt)
CMCHKPK(cmPkCmIpv6RtHdr, &pkParam->rtOpts, mBuf);
- CMCHKPK(cmPkBool, pkParam->rtOptsPrsnt, mBuf);
+ CMCHKPK(oduPackBool, pkParam->rtOptsPrsnt, mBuf);
/* pack Dest Opt hdr */
if (pkParam->destOptsPrsnt)
CMCHKPK(cmPkCmIpv6DestOptsArr, &pkParam->destOptsArr, mBuf);
- CMCHKPK(cmPkBool, pkParam->destOptsPrsnt, mBuf);
+ CMCHKPK(oduPackBool, pkParam->destOptsPrsnt, mBuf);
/* pack HBH hdr */
if (pkParam->hbhHdrPrsnt)
CMCHKPK(cmPkCmIpv6HBHHdrArr, &pkParam->hbhOptsArr, mBuf);
- CMCHKPK(cmPkBool, pkParam->hbhHdrPrsnt, mBuf);
+ CMCHKPK(oduPackBool, pkParam->hbhHdrPrsnt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6ExtHdr */
\f
CMCHKPK(cmPkCmIpv6NetAddr, &pkParam->ipv6Addrs[idx], mBuf);
}
/* pack reserve byte & strict/loose bit map */
- CMCHKPK(SPkU32, pkParam->slMap, mBuf);
- CMCHKPK(SPkU8, pkParam->numAddrs, mBuf);
+ CMCHKPK(oduUnpackUInt32, pkParam->slMap, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->numAddrs, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6RtHdr */
\f
TRC3(cmUnpkCmIpv6RtHdr);
- CMCHKUNPK(SUnpkU8, &unpkParam->numAddrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->numAddrs, mBuf);
/* unpack reserve byte & strict/loose bit map */
- CMCHKUNPK(SUnpkU32, &unpkParam->slMap, mBuf);
+ CMCHKUNPK(oduPackUInt32, &unpkParam->slMap, mBuf);
retVal = SGetSBuf(memInfo->region,
memInfo->pool,
if (retVal != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* unpack all IPV6 addrs in the route hdr */
CMCHKUNPK(cmUnpkCmIpv6NetAddr, &unpkParam->ipv6Addrs[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6RtHdr */
\f
TRC3(cmUnpkCmIpv6ExtHdr)
/* unpack HBH hdr first */
- CMCHKUNPK(cmUnpkBool, &unpkParam->hbhHdrPrsnt, mBuf);
+ CMCHKUNPK(oduUnpackBool, &unpkParam->hbhHdrPrsnt, mBuf);
if (unpkParam->hbhHdrPrsnt)
cmUnpkCmIpv6HBHHdrArr(&unpkParam->hbhOptsArr, mBuf, memInfo);
/* unpack DEST opt hdr */
- CMCHKUNPK(cmUnpkBool, &unpkParam->destOptsPrsnt, mBuf);
+ CMCHKUNPK(oduUnpackBool, &unpkParam->destOptsPrsnt, mBuf);
if (unpkParam->destOptsPrsnt)
cmUnpkCmIpv6DestOptsArr(&unpkParam->destOptsArr, mBuf, memInfo);
/* unpack Route hdr last */
- CMCHKUNPK(cmUnpkBool, &unpkParam->rtOptsPrsnt, mBuf);
+ CMCHKUNPK(oduUnpackBool, &unpkParam->rtOptsPrsnt, mBuf);
if (unpkParam->rtOptsPrsnt)
cmUnpkCmIpv6RtHdr(&unpkParam->rtOpts, mBuf, memInfo);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6ExtHdr */
\f
/* pack all HBH options */
for(numOptions = 0; numOptions<pkParam->numDestOpts; numOptions++)
CMCHKPK(cmPkCmIpv6DestOptsHdr, &pkParam->destOpts[numOptions], mBuf);
- CMCHKPK(SPkU8, pkParam->numDestOpts, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->numDestOpts, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6DestOptsArr */
\f
for(optLen = 0; optLen < pkParam->length; optLen++)
{
- CMCHKPK(SPkU8, pkParam->value[optLen], mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->value[optLen], mBuf);
}
- CMCHKPK(SPkU8, pkParam->length, mBuf);
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->length, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6DestOptsHdr */
\f
TRC3(cmUnpkCmIpv6DestOptsHdr);
/* unpack type, length */
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->length, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->length, mBuf);
/* allocate static memory to hold the unpacked values */
retVal = SGetSBuf(memInfo->region,
(Data **)&unpkParam->value, (Size)unpkParam->length);
if (retVal != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* unpack value fieldof this option */
for(optLen = 0; optLen<unpkParam->length; optLen++)
{
- CMCHKUNPK(SUnpkU8, &unpkParam->value[optLen], mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->value[optLen], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6DestOptsHdr */
\f
TRC3(cmUnpkCmIpv6DestOptsArr);
- CMCHKUNPK(SUnpkU8, &unpkParam->numDestOpts, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->numDestOpts, mBuf);
if (unpkParam->numDestOpts)
{
/* allocate mem to hold all dest options */
if (retVal != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* unpack all dest options */
for(numOptions = 0; numOptions<unpkParam->numDestOpts; numOptions++)
if ((retVal = cmUnpkCmIpv6DestOptsHdr(&unpkParam->destOpts[numOptions],
mBuf, memInfo)) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6DestOptsArr */
\f
for(numOptions = 0; numOptions<pkParam->numHBHOpts; numOptions++)
CMCHKPK(cmPkCmIpv6HBHHdr, &pkParam->hbhOpts[numOptions], mBuf);
- CMCHKPK(SPkU8, pkParam->numHBHOpts, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->numHBHOpts, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6HBHHdrArr */
\f
/* pack value field */
for(optLen = 0; optLen<pkParam->length; optLen++)
{
- CMCHKPK(SPkU8, pkParam->value[optLen], mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->value[optLen], mBuf);
}
/* pack type, length fields */
- CMCHKPK(SPkU8, pkParam->length, mBuf);
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->length, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCmIpv6HBHHdr */
\f
TRC3(cmUnpkCmIpv6HBHHdr)
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->length, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->length, mBuf);
/* allocate static memory to hold the unpacked values */
if (unpkParam->length)
(Data **)&unpkParam->value, (Size)unpkParam->length);
if (retVal != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
for(optLen = 0; optLen<unpkParam->length; optLen++)
- CMCHKUNPK(SUnpkU8, &unpkParam->value[optLen], mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->value[optLen], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6HBHHdr */
\f
TRC3(cmUnpkCmIpv6HBHHdrArr);
- CMCHKUNPK(SUnpkU8, &unpkParam->numHBHOpts, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->numHBHOpts, mBuf);
if (unpkParam->numHBHOpts)
{
/* allocate space for all HBH options */
if (retVal != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
for(numOptions = 0; numOptions<unpkParam->numHBHOpts; numOptions++)
cmUnpkCmIpv6HBHHdr(&unpkParam->hbhOpts[numOptions], mBuf, memInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCmIpv6HBHHdrArr */
#endif /* IPV6_OPTS_SUPPORTED */
{
TRC3(cmUnpkCmIpHdrParm)
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
switch (unpkParam->type)
{
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* End of cmUnpkCmIpHdrParm */
\f
case CM_ICMPVER4_FILTER:
for(idx = (pkParam->u.icmpv4Filter.num-1); idx >= 0; idx--)
{
- CMCHKPK(SPkU32, pkParam->u.icmpv4Filter.icmpError[idx].errCodeMask,
+ CMCHKPK(oduUnpackUInt32, pkParam->u.icmpv4Filter.icmpError[idx].errCodeMask,
mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpError[idx].errType,
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.icmpError[idx].errType,
mBuf);
}
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.num, mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.protocol, mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.allMsg, mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.num, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.protocol, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.allMsg, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
break;
case CM_ICMPVER6_FILTER:
#ifdef IPV6_SUPPORTED
for(idx = (pkParam->u.icmpv6Filter.num - 1); idx >= 0; idx--)
{
- CMCHKPK(SPkU32, pkParam->u.icmpv6Filter.icmpError[idx].errCodeMask,
+ CMCHKPK(oduUnpackUInt32, pkParam->u.icmpv6Filter.icmpError[idx].errCodeMask,
mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv6Filter.icmpError[idx].errType,
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv6Filter.icmpError[idx].errType,
mBuf);
}
- CMCHKPK(SPkU8, pkParam->u.icmpv6Filter.num, mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.allMsg, mBuf);
- CMCHKPK(SPkU8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv6Filter.num, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.allMsg, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
#endif /* IPV6_SUPPORTED */
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, pkParam->type, mBuf);
+ CMCHKPK(oduUnpackUInt8, pkParam->type, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmUnpkCmIcmpFilter)
- CMCHKUNPK(SUnpkU8, &unpkParam->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
switch (unpkParam->type)
{
break;
case CM_ICMPVER4_FILTER:
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.allMsg, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.protocol, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv4Filter.num, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.icmpMsgFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.allMsg, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.protocol, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv4Filter.num, mBuf);
for(idx = 0; idx < (unpkParam->u.icmpv4Filter.num); idx++)
{
- CMCHKUNPK(SUnpkU8,
+ CMCHKUNPK(oduPackUInt8,
&unpkParam->u.icmpv4Filter.icmpError[idx].errType, mBuf);
- CMCHKUNPK(SUnpkU32,
+ CMCHKUNPK(oduPackUInt32,
&unpkParam->u.icmpv4Filter.icmpError[idx].errCodeMask,
mBuf);
}
case CM_ICMPVER6_FILTER:
#ifdef IPV6_SUPPORTED
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.icmpMsgFlag, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.allMsg, mBuf);
- CMCHKUNPK(SUnpkU8, &unpkParam->u.icmpv6Filter.num, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv6Filter.icmpMsgFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv6Filter.allMsg, mBuf);
+ CMCHKUNPK(oduPackUInt8, &unpkParam->u.icmpv6Filter.num, mBuf);
for(idx = 0; idx < (unpkParam->u.icmpv6Filter.num); idx++)
{
- CMCHKUNPK(SUnpkU8,
+ CMCHKUNPK(oduPackUInt8,
&unpkParam->u.icmpv6Filter.icmpError[idx].errType, mBuf);
- CMCHKUNPK(SUnpkU32,
+ CMCHKUNPK(oduPackUInt32,
&unpkParam->u.icmpv6Filter.icmpError[idx].errCodeMask,
mBuf);
}
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* End of cmUnpkCmIcmpFilter */
#endif /* CM_INET2 */
#endif /* __CMINETH__ */
/* packing/unpacking functions */
-#define cmPkCmIpv4NetAddr(x, mBuf) SPkU32(x, mBuf)
+#define cmPkCmIpv4NetAddr(x, mBuf) oduUnpackUInt32(x, mBuf)
/* Moved all packing functions to cm_tpt from
* cm_inet.c files. Hence no #defines are required */
-#define cmUnpkCmIpv4NetAddr(x, mBuf) SUnpkU32(x, mBuf)
+#define cmUnpkCmIpv4NetAddr(x, mBuf) oduPackUInt32(x, mBuf)
/* added macro to free memory allocated for IPv6
* IPv6 extn hdrs*/
#define ODU_START_CRNTI 100
#define ODU_END_CRNTI 500
+/* Defining macros for common utility functions */
+#define ODU_GET_MSG SGetMsg
+#define ODU_PUT_MSG SPutMsg
+#define ODU_ADD_PRE_MSG_MULT SAddPreMsgMult
+#define ODU_ADD_POST_MSG_MULT SAddPstMsgMult
+#define ODU_START_TASK SStartTask
+#define ODU_STOP_TASK SStopTask
+#define ODU_ATTACH_TTSK SAttachTTsk
+#define ODU_POST_TASK SPstTsk
+#define ODU_COPY_MSG_TO_FIX_BUF SCpyMsgFix
+#define ODU_REG_TTSK SRegTTsk
+#define ODU_SET_PROC_ID SSetProcId
+#define ODU_FIND_MSG_LEN SFndLenMsg
+#define ODU_EXIT_TASK SExitTsk
+#define ODU_PRINT_MSG SPrntMsg
+#define ODU_REM_PRE_MSG SRemPreMsg
+#define ODU_REG_TMR_MT SRegTmrMt
+
#define GET_UE_IDX( _crnti,_ueIdx) \
{ \
_ueIdx = _crnti - ODU_START_CRNTI + 1; \
void schAllocFreqDomRscType0(uint16_t startPrb, uint16_t prbSize, uint8_t *freqDomain);
#endif
+
/**********************************************************************
End of file
***********************************************************************/
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG001, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG002, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG003, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCRGBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG004, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG005, (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)ECRG006, (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)ECRG007, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG008, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCRGBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG009, (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)ECRG010, (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)ECRG011, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG012, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG013, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCRGUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG014, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG015, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
(ErrVal)ECRG016, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* crg_c_001.main_5: MOD - Updating ERR code */
if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG020, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCRGCFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG021, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG022, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CrgCfgReqInfo))) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG023, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG024, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
+ return ((*func)(pst, spId, transId, cfgReqInfo));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG025, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* crg_c_001.main_5 - ADD - Added the packing for status. */
- 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)ECRG026, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG027, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECRG028, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCRGCFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG029, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECRG030, (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)ECRG031, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, status));
+ return ((*func)(pst, suId, transId, status));
}
\f
TRC3(cmPkCrgCfgTransId)
for (i=CRG_CFG_TRANSID_SIZE-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->trans[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkCrgCfgTransId)
for (i=0; i<CRG_CFG_TRANSID_SIZE; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->trans[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCrgBwCfg)
- CMCHKPK(SPkU8, param->ulTotalBw, mBuf);
- CMCHKPK(SPkU8, param->dlTotalBw, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgBwCfg)
- 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(cmPkCrgRachCfg)
- CMCHKPK(SPkU8, param->maxMsg3Tx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgRachCfg)
- CMCHKUNPK(SUnpkU8, ¶m->maxMsg3Tx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxMsg3Tx, mBuf);
+ return ROK;
}
TRC3(cmPkCrgCellCfg)
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8, param->emtcEnable, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
#endif
#ifdef TENB_MULT_CELL_SUPPRT
CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
CMCHKPK(cmPkCrgBwCfg, ¶m->bwCfg, mBuf);
CMCHKPK(cmPkCrgRachCfg, ¶m->rachCfg, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(SUnpkS16, ¶m->rguDlSapId, mBuf);
#endif
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8, ¶m->emtcEnable, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->emtcEnable, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCrgUeUlHqCfg)
- CMCHKPK(SPkU8, param->maxUlHqTx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
+ return ROK;
}
#ifdef LTE_ADV
{
CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
- CMCHKPK(SPkU8, param->macInst, mBuf);
- CMCHKPK(SPkU16, param->sCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->macInst, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
Buffer *mBuf;
#endif
{
- CMCHKUNPK(SUnpkU16, ¶m->sCellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->macInst, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->macInst, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->rguUlSapId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->rguDlSapId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
CMCHKPK(cmPkCrgUeSCellCfg, ¶m->ueSCellCfg[(U8)idx], mBuf);
}
- CMCHKPK(SPkU8, param->numSCells, mBuf);
- CMCHKPK(SPkU8, param->isSCellCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSCellCfgPres, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
U8 idx;
- CMCHKUNPK(SUnpkU8, ¶m->isSCellCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSCellCfgPres, mBuf);
if(TRUE == param->isSCellCfgPres)
{
- CMCHKUNPK(SUnpkU8, ¶m->numSCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
for(idx = 0; idx < param->numSCells; idx++)
{
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_ADV */
TRC3(cmUnpkCrgUeUlHqCfg)
- CMCHKUNPK(SUnpkU8, ¶m->maxUlHqTx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->maxUlHqTx, mBuf);
+ return ROK;
}
CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
#endif
- CMCHKPK(SPkU32, param->txMode.tm, mBuf);
- CMCHKPK(SPkU8, param->txMode.pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->txMode.tm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txMode.pres, mBuf);
CMCHKPK(cmPkCrgUeUlHqCfg, ¶m->ueUlHqCfg, 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(cmUnpkCrgUeUlHqCfg, ¶m->ueUlHqCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txMode.pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txMode.pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->txMode.tm = (CrgTxMode) tmpEnum;
#ifdef TENB_MULT_CELL_SUPPRT
CMCHKUNPK(SUnpkS16, ¶m->rguUlSapId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->rguDlSapId, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCrgDlLchCfg)
- CMCHKPK(SPkU8, param->dlTrchType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgDlLchCfg)
- CMCHKUNPK(SUnpkU8, ¶m->dlTrchType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlTrchType, mBuf);
+ return ROK;
}
TRC3(cmPkCrgUlLchCfg)
- CMCHKPK(SPkU8, param->lcgId, mBuf);
- CMCHKPK(SPkU8, param->ulTrchType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgUlLchCfg)
- CMCHKUNPK(SUnpkU8, ¶m->ulTrchType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->lcgId, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulTrchType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcgId, mBuf);
+ return ROK;
}
TRC3(cmPkCrgLchCfg)
/* crg_c_001.main_5 - ADD - Added the packing for LTE_L2_MEAS. */
#ifdef LTE_L2_MEAS
- CMCHKPK(SPkU8, param->qci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
#endif
CMCHKPK(cmPkCrgUlLchCfg, ¶m->ulInfo, mBuf);
CMCHKPK(cmPkCrgDlLchCfg, ¶m->dlInfo, mBuf);
- CMCHKPK(SPkU8, param->dir, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dir, 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(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dir, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dir, mBuf);
CMCHKUNPK(cmUnpkCrgDlLchCfg, ¶m->dlInfo, mBuf);
CMCHKUNPK(cmUnpkCrgUlLchCfg, ¶m->ulInfo, mBuf);
/* crg_c_001.main_5 - ADD - Added the unpacking for LTE_L2_MEAS. */
#ifdef LTE_L2_MEAS
- CMCHKUNPK(SUnpkU8, ¶m->qci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkCrgCellCfg, ¶m->u.cellCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgCfg)
- CMCHKUNPK(SUnpkU8, ¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
case CRG_CELL_CFG:
CMCHKUNPK(cmUnpkCrgCellCfg, ¶m->u.cellCfg, mBuf);
CMCHKUNPK(cmUnpkCrgLchCfg, ¶m->u.lchCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkCrgRachCfg, ¶m->rachRecfg, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkCrgRachCfg, ¶m->rachRecfg, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
}
else
{
- CMCHKPK(SPkU8, param->crgSCellCfg.isSCellCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->crgSCellCfg.isSCellCfgPres, mBuf);
}
#endif /* LTE_ADV */
- CMCHKPK(SPkU32, param->txMode.tm, mBuf);
- CMCHKPK(SPkU8, param->txMode.pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->txMode.tm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txMode.pres, mBuf);
CMCHKPK(cmPkCrgUeUlHqCfg, ¶m->ueUlHqRecfg, mBuf);
CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->oldCrnti, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->newCrnti, mBuf);
CMCHKUNPK(cmUnpkCrgUeUlHqCfg, ¶m->ueUlHqRecfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txMode.pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->txMode.tm, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txMode.pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->txMode.tm, mBuf);
#ifdef LTE_ADV
CMCHKUNPK(cmUnpkCrgUeSecCellInfo, ¶m->crgSCellCfg, mBuf);
#endif /* LTE_ADV */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCrgLchRecfg)
- CMCHKPK(SPkU8, param->ulRecfg.lcgId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, 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(cmUnpkLteLcId, ¶m->lcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulRecfg.lcgId, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulRecfg.lcgId, mBuf);
+ return ROK;
}
CMCHKPK(cmPkCrgCellRecfg, ¶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(cmUnpkCrgRecfg)
- CMCHKUNPK(SUnpkU8, ¶m->recfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->recfgType, mBuf);
switch(param->recfgType) {
case CRG_CELL_CFG:
CMCHKUNPK(cmUnpkCrgCellRecfg, ¶m->u.cellRecfg, mBuf);
CMCHKUNPK(cmUnpkCrgLchRecfg, ¶m->u.lchRecfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
switch(param->delType) {
case CRG_LCH_CFG:
- CMCHKPK(SPkU8, param->u.lchDel.dir, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.lchDel.dir, mBuf);
CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
CMCHKPK(cmPkLteCellId, param->u.cellDel.cellId, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->delType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->delType, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgDel)
- CMCHKUNPK(SUnpkU8, ¶m->delType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->delType, mBuf);
switch(param->delType) {
case CRG_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.dir, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.lchDel.dir, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
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;
}
CMCHKPK(cmPkCrgCfg, ¶m->u.cfgInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->action, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->action, mBuf);
+ return ROK;
}
TRC3(cmUnpkCrgCfgReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->action, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
switch(param->action) {
case CRG_CONFIG:
CMCHKUNPK(cmUnpkCrgCfg, ¶m->u.cfgInfo, mBuf);
CMCHKUNPK(cmUnpkCrgRst, ¶m->u.rstInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
#include "ctf.x"
#ifdef TENB_AS_SECURITY
-#define cmPkCtfCrnti SPkU16
-#define cmPkCtfCellId SPkU16
-#define cmUnpkCtfCellId SUnpkU16
-#define cmUnpkCtfCrnti SUnpkU16
+#define cmPkCtfCrnti oduUnpackUInt16
+#define cmPkCtfCellId oduUnpackUInt16
+#define cmUnpkCtfCellId oduPackUInt16
+#define cmUnpkCtfCrnti oduPackUInt16
#endif
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF001, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF002, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF003, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF004, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF005, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF006, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ECTF007, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF008, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF009, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF010, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF011, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF012, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF013, (ErrVal)0,(Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF014, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF015, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
- RETVALUE(ROK);
+ return ROK;
}
#ifdef TENB_AS_SECURITY
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- CMCHKPK(SPkU16, param->physCellId, mBuf);
- CMCHKPK(SPkU16, param->dlCarrFreq, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dlCarrFreq, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- CMCHKPK(SPkU16, param->physCellId, mBuf);
- CMCHKPK(SPkU16, param->dlCarrFreq, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dlCarrFreq, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- CMCHKPK(SPkU8, param->ciphAlgoType, mBuf);
- CMCHKPK(SPkU8, param->intgAlgoType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ciphAlgoType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->intgAlgoType, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKPK(cmPkCtfNhKeyInfo , ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->keyDerType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->keyDerType, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfKdfReqInfo(kdfReqInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo)) != ROK) {
(ErrVal)ECTF021, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTCTFKDFREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#endif
{
for(i= param->numOfVendorSpecifcParam-1; i >= 0; i--)
{
- CMCHKPK(SPkU32,(U32)param->vendorSpecifcParam[i], mBuf);
+ CMCHKPK(oduUnpackUInt32,(U32)param->vendorSpecifcParam[i], mBuf);
}
}
- CMCHKPK(SPkU16, param->numOfVendorSpecifcParam, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->numOfVendorSpecifcParam, mBuf);
+ return ROK;
}
#ifdef ANSI
{
TRC3(cmPkCtfCtfCnmCellSyncReq);
- CMCHKPK(SPkU16, param->nbrEarfcn, mBuf);
- CMCHKPK(SPkU16, param->nbrPCellId, mBuf);
- CMCHKPK(SPkU8, param->nbrTxAntCount, mBuf);
- CMCHKPK(SPkU8, param->nbrCellCp, mBuf);
- CMCHKPK(SPkU8, param->nbrCellNRb, mBuf);
- CMCHKPK(SPkU8, param->nbrSpecSfCfg, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nbrEarfcn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nbrPCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrTxAntCount, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrCellCp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrCellNRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nbrSpecSfCfg, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmPkCtfcfgReqInfo);
- CMCHKPK(SPkU8, param->searchType, mBuf);
- CMCHKPK(SPkU8, param->mibRequest, mBuf);
- CMCHKPK(SPkU16, param->earfcn, mBuf);
- CMCHKPK(SPkU8, param->measBandWidth, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->searchType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mibRequest, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->earfcn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->measBandWidth, mBuf);
if(param->numOfPciList <= CTF_CNM_MAX_CELL_SEARCH)
{
for(i= param->numOfPciList-1; i >= 0; i--)
CMCHKPK(cmPkCtfCtfCnmCellSyncReq, ¶m->pciList[i], mBuf);
}
}
- CMCHKPK(SPkU16, param->numOfPciList, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->numOfPciList, mBuf);
+ return ROK;
}
#ifdef ANSI
S32 i;
TRC3(cmUnpkCtfCnmVendorSpecificInfo);
- CMCHKUNPK(SUnpkU16, ¶m->numOfVendorSpecifcParam, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfVendorSpecifcParam, mBuf);
for(i=0; (i<param->numOfVendorSpecifcParam)&&(i < CTF_CNM_MAX_VENDOR_PARAMS); i++)
{
- CMCHKUNPK(SUnpkU32, ¶m->vendorSpecifcParam[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->vendorSpecifcParam[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrSpecSfCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrCellNRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrCellCp, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nbrTxAntCount, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->nbrPCellId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->nbrEarfcn, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrSpecSfCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrCellNRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrCellCp, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nbrTxAntCount, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->nbrPCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->nbrEarfcn, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkCtfsyncReqInfo);
- CMCHKUNPK(SUnpkU16, ¶m->numOfPciList, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfPciList, mBuf);
for(i=0; (i < param->numOfPciList)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
{
CMCHKUNPK(cmUnpkCtfCtfCnmCellSyncReq, ¶m->pciList[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->measBandWidth, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->earfcn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mibRequest, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->searchType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->measBandWidth, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->earfcn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mibRequest, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->searchType, mBuf);
+ return ROK;
}
/**
* @brief Configuration Request from App to CL for
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfCtfCnmCellSyncReq(cfgReqInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
}
pst->event = (Event)EVTCTFCNMSYNCREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&SyncReqMsg, sizeof(CtfCnmCellSyncReq))) != ROK) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&SyncReqMsg, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&SyncReqMsg, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, SyncReqMsg));
+ return ((*func)(pst, spId, &transId, SyncReqMsg));
}
/*-----------------------------------------------------*/
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfcfgReqInfo(cfgReqInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
}
pst->event = (Event)EVTCTFCNMINITSYNCREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*-----------------------------------------------------------------*/
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncReqInfo, sizeof(CtfCnmInitSyncReq))) != ROK) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&syncReqInfo, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&syncReqInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncReqInfo));
+ return ((*func)(pst, spId, &transId, syncReqInfo));
}
/*-----------------------------------------------------------------------------*/
{
TRC3(cmPkCtfctfCnmMibInfo)
- CMCHKPK(SPkU16, param->sfn, mBuf);
- CMCHKPK(SPkU8, param->numTxAntennas, mBuf);
- CMCHKPK(SPkU8, param->phichDuration, mBuf);
- CMCHKPK(SPkU8, param->phichResource, mBuf);
- CMCHKPK(SPkU8, param->dlSystemBandWidht, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numTxAntennas, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phichDuration, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phichResource, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlSystemBandWidht, mBuf);
+ return ROK;
}
{
TRC3(cmPkCtfctfCnmInitSyncInfo)
- CMCHKPK(SPkU16, param->pci, mBuf);
- CMCHKPK(SPkU8, param->rsrp, mBuf);
- CMCHKPK(SPkU8, param->mibValidFlag, mBuf);
- CMCHKPK(SPkU16, param->localSfn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rsrp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mibValidFlag, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->localSfn, mBuf);
CMCHKPK(cmPkCtfctfCnmMibInfo, ¶m->ctfCnmMibInfo, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfcfgRspInfo)
- CMCHKPK(SPkU8, param->status, mBuf);
- CMCHKPK(SPkU16, param->earfcn, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->earfcn, mBuf);
if(param->numOfNeighbourInfo <= CTF_CNM_MAX_CELL_SEARCH)
{
for(i= param->numOfNeighbourInfo-1; i >= 0; i--)
CMCHKPK(cmPkCtfctfCnmInitSyncInfo, ¶m->ctfCnmInitSyncInfo[i], mBuf);
}
}
- CMCHKPK(SPkU8, param->numOfNeighbourInfo, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numOfNeighbourInfo, mBuf);
+ return ROK;
}
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfcfgRspInfo(cfgRspInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgRspInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgRspInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
}
pst->event = (Event)EVTCTFCNMINITSYNCRSP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/*-----------------------------------------------------------------------------*/
TRC3(cmUnpkCtfctfCnmMibInfo);
- CMCHKUNPK(SUnpkU8, ¶m->dlSystemBandWidht, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phichResource, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phichDuration, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numTxAntennas, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sfn, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlSystemBandWidht, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phichResource, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phichDuration, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numTxAntennas, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sfn, mBuf);
+ return ROK;
}
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
CMCHKUNPK(cmUnpkCtfctfCnmMibInfo, ¶m->ctfCnmMibInfo, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->localSfn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mibValidFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rsrp, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pci, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->localSfn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mibValidFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rsrp, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pci, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfCnmInitSyncRspMsg);
- CMCHKUNPK(SUnpkU8, ¶m->numOfNeighbourInfo, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numOfNeighbourInfo, mBuf);
for(i=0; (i < param->numOfNeighbourInfo)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
{
CMCHKUNPK(cmUnpkctfCnmInitSyncInfo, ¶m->ctfCnmInitSyncInfo[i], mBuf);
}
- CMCHKUNPK(SUnpkU16, ¶m->earfcn, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->earfcn, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
+ return ROK;
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspInfo, sizeof(CtfCnmInitSyncRsp))) != ROK) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if(cmUnpkPtr((PTR *)&syncRspInfo, mBuf) != ROK) {
+ if(oduUnpackPointer((PTR *)&syncRspInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncRspInfo));
+ return ((*func)(pst, spId, &transId, syncRspInfo));
}
/*-----------------------------------------------------------------------*/
TRC3(cmPkCtfCellSyncRsp)
- CMCHKPK(SPkU8, param->status, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
+ return ROK;
}
/**
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfCellSyncRsp(cfgRspInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgRspInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgRspInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
}
pst->event = (Event)EVTCTFCNMSYNCRSP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
TRC3(cmUnpkCtfCnmSyncRspMsg);
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
+ return ROK;
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspMsg, sizeof(CtfCnmCellSyncRsp))) != ROK) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&syncRspMsg, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&syncRspMsg, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncRspMsg));
+ return ((*func)(pst, spId, &transId, syncRspMsg));
}
/*---------------------------------------------------------------*/
TRC3(cmPkCtfcfgIndInfo);
- CMCHKPK(SPkU8, param->status, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->status, mBuf);
CMCHKPK(cmPkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
(ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfcfgIndInfo(cfgIndInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgIndInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgIndInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
}
pst->event = (Event)EVTCTFCNMSYNCIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
TRC3(cmUnpkCtfCnmSyncIndMsg);
CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, ¶m->ctfCnmVendorSpecificInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->status, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->status, mBuf);
+ return ROK;
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncIndMsg, sizeof(CtfCnmCellSyncInd))) != ROK) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&syncIndMsg, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&syncIndMsg, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, &transId, syncIndMsg));
+ return ((*func)(pst, spId, &transId, syncIndMsg));
}
(ErrVal)ECTF016, (ErrVal)0, "Packing failed");
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)cfgReqInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
cmRelCtfCfgReq(pst, cfgReqInfo);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
cmRelCtfCfgReq(pst, cfgReqInfo);
}
pst->event = (Event) EVTCTFCFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef TENB_AS_SECURITY
TRC3(cmUnpkCtfNhKeyInfo)
- CMCHKUNPK(SUnpkU16, ¶m->dlCarrFreq, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->physCellId, mBuf);
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkCtfKenbStarInfo)
- CMCHKUNPK(SUnpkU16, ¶m->dlCarrFreq, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->physCellId, mBuf);
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkCtfAskeyInfo)
- CMCHKUNPK(SUnpkU8, ¶m->intgAlgoType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ciphAlgoType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->intgAlgoType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ciphAlgoType, mBuf);
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkCtfKdfReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->keyDerType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->keyDerType, mBuf);
switch (param->keyDerType)
{
case CTF_KDF_TYPE1:
CMCHKUNPK(cmUnpkCtfNhKeyInfo, ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- /*if (cmUnpkPtr((PTR *)&cfgReqInfo, mBuf) != ROK) {
+ /*if (oduUnpackPointer((PTR *)&cfgReqInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}*/
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, kdfReqInfo));
+ return ((*func)(pst, spId, transId, kdfReqInfo));
}
#endif
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CtfCfgReqInfo))) != ROK) {
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&cfgReqInfo, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&cfgReqInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
+ return ((*func)(pst, spId, transId, cfgReqInfo));
}
#ifdef TENB_AS_SECURITY
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
for(idx=31;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->secKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
for(idx=15;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->cpCiphKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->cpCiphKey[idx],mBuf);
}
for(idx=15;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->upCiphKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->upCiphKey[idx],mBuf);
}
for(idx=15;idx>=0;idx--)
{
- CMCHKPK(SPkU8,param->intKey[idx],mBuf);
+ CMCHKPK(oduUnpackUInt8,param->intKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKPK(cmPkCtfNhKeyCfmInfo, ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->keyDerType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->keyDerType, mBuf);
+ return ROK;
}
/**
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfKdfCfmInfo(kdfCfmInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo)) != ROK)
(ErrVal)ECTF021, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFKDFCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#endif
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK) {
+ if (oduUnpackUInt8(status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
(ErrVal)ECTF027, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFCFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTCTFENBSTOPIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef TENB_AS_SECURITY
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
for(idx=0;idx<32;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->secKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->secKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
for(idx=0;idx<16;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->intKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->intKey[idx],mBuf);
}
for(idx=0;idx<16;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->upCiphKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->upCiphKey[idx],mBuf);
}
for(idx=0;idx<16;idx++)
{
- CMCHKUNPK(SUnpkU8,¶m->cpCiphKey[idx],mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->cpCiphKey[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkCtfKdfCfmInfo)
- CMCHKUNPK(SUnpkU8, ¶m->keyDerType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->keyDerType, mBuf);
switch (param->keyDerType)
{
case CTF_KDF_TYPE1:
CMCHKUNPK(cmUnpkCtfNhKeyCfmInfo, ¶m->u.nhKeyInf, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfKdfCfmInfo(&kdfCfmInfo, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF032, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId,&kdfCfmInfo, status));
+ return ((*func)(pst, suId, transId,&kdfCfmInfo, status));
}
#endif
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF032, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, status));
+ return ((*func)(pst, suId, transId, status));
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId));
+ return ((*func)(pst, suId, transId));
}
\f
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfUeInfo(newUeInfo, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)newUeInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)newUeInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LC) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)ueInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)ueInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
(ErrVal)ECTF040, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo)) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ECTF041, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTCTFUEIDCHGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(Txt*)& __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF042, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF043, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
(ErrVal)ECTF044, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&ueInfo, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&ueInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF045, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo, sizeof(CtfUeInfo))) != ROK) {
#endif
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&newUeInfo, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&newUeInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF047, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
+ return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
}
\f
(ErrVal)ECTF048, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkCmStatus(&status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfUeInfo(ueInfo, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)ueInfo, mBuf) != ROK) {
+ if (oduPackPointer((PTR)ueInfo, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
(ErrVal)ECTF054, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTCTFUEIDCHGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF055, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF056, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
(ErrVal)ECTF057, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&ueInfo, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&ueInfo, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF058, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCmStatus(&status, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF059, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, transId, ueInfo, status));
+ return ((*func)(pst, suId, transId, ueInfo, status));
}
\f
TRC3(cmPkCtfCfgTransId)
for (i=CTF_CFG_TRANSID_SIZE-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->trans[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkCtfCfgTransId)
for (i=0; i<CTF_CFG_TRANSID_SIZE; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->trans[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->trans[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfBwCfgInfo)
- CMCHKPK(SPkU8, param->eUtraBand, mBuf);
- CMCHKPK(SPkU32, param->ulBw, mBuf);
- CMCHKPK(SPkU32, param->dlBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->eUtraBand, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ulBw, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dlBw, mBuf);
/* ctf_c_001.main_4: Removed packing of param->pres */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkCtfBwCfgInfo)
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->dlBw = (CtfBandwidth)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ulBw = (CtfBandwidth)tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->eUtraBand, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->eUtraBand, mBuf);
+ return ROK;
}
TRC3(cmPkCtfTxSchemeCfg)
- CMCHKPK(SPkU32, param->cycPfx, mBuf);
- CMCHKPK(SPkU32, param->scSpacing, mBuf);
- CMCHKPK(SPkU32, param->duplexMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->cycPfx, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->scSpacing, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->duplexMode, mBuf);
/* ctf_c_001.main_4: Removed packing of param->pres */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkCtfTxSchemeCfg)
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->duplexMode = (CtfDuplexMode)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->scSpacing = (CtfSCSpacing)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->cycPfx = (CtfCPCfg)tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfAntennaCfgInfo)
- CMCHKPK(SPkU32, param->antPortsCnt, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->antPortsCnt, mBuf);
+ return ROK;
}
U32 tmpEnum;
TRC3(cmUnpkCtfAntennaCfgInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->antPortsCnt = (CtfAntennaPortsCount)tmpEnum;
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->prachFreqOffset, mBuf);
- CMCHKPK(SPkU8, param->highSpeedFlag, mBuf);
- CMCHKPK(SPkU8, param->zeroCorrelationZoneCfg, mBuf);
- CMCHKPK(SPkU8, param->prachCfgIndex, mBuf);
- CMCHKPK(SPkU16, param->rootSequenceIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachFreqOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->highSpeedFlag, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->zeroCorrelationZoneCfg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachCfgIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rootSequenceIndex, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPrachCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU16, ¶m->rootSequenceIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachCfgIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->zeroCorrelationZoneCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->highSpeedFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachFreqOffset, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rootSequenceIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachCfgIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->zeroCorrelationZoneCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->highSpeedFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachFreqOffset, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->p_b, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->p_b, mBuf);
CMCHKPK(SPkS16, param->refSigPwr, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPdschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
CMCHKUNPK(SUnpkS16, ¶m->refSigPwr, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->p_b, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->p_b, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfPuschCfgBasic)
- CMCHKPK(SPkU8, param->enable64QAM, mBuf);
- CMCHKPK(SPkU8, param->hoppingOffset, mBuf);
- CMCHKPK(SPkU32, param->hoppingMode, mBuf);
- CMCHKPK(SPkU8, param->noOfsubBands, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->enable64QAM, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingOffset, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hoppingMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->noOfsubBands, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPuschCfgBasic)
- CMCHKUNPK(SUnpkU8, ¶m->noOfsubBands, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->noOfsubBands, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->hoppingMode = (CtfPuschHoppingMode)tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->hoppingOffset, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->enable64QAM, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingOffset, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->enable64QAM, mBuf);
+ return ROK;
}
TRC3(cmPkCtfPuschUlRS)
- CMCHKPK(SPkU8, param->cycShift, mBuf);
- CMCHKPK(SPkU8, param->grpNum, mBuf);
- CMCHKPK(SPkU8, param->seqHopEnabled, mBuf);
- CMCHKPK(SPkU8, param->grpHopEnabled, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cycShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->seqHopEnabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpHopEnabled, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPuschUlRS)
- CMCHKUNPK(SUnpkU8, ¶m->grpHopEnabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->seqHopEnabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->grpNum, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cycShift, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpHopEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->seqHopEnabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpNum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cycShift, mBuf);
+ return ROK;
}
CMCHKPK(cmPkCtfPuschUlRS, ¶m->puschUlRS, mBuf);
CMCHKPK(cmPkCtfPuschCfgBasic, ¶m->puschBasicCfg, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPuschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
CMCHKUNPK(cmUnpkCtfPuschCfgBasic, ¶m->puschBasicCfg, mBuf);
CMCHKUNPK(cmUnpkCtfPuschUlRS, ¶m->puschUlRS, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU32, param->resource, mBuf);
- CMCHKPK(SPkU32, param->duration, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->resource, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->duration, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPhichCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->duration = (CtfPhichDuration)tmpEnum;
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->resource = (CtfPhichResource)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU32, param->deltaShift, mBuf);
- CMCHKPK(SPkU16, param->n1PUCCH, mBuf);
- CMCHKPK(SPkU8, param->nCS, mBuf);
- CMCHKPK(SPkU8, param->nRB, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->deltaShift, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->n1PUCCH, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nCS, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nRB, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfPucchCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->nRB, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nCS, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->n1PUCCH, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nRB, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nCS, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->n1PUCCH, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->deltaShift = (CtfPucchDeltaShift)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->srsSetup.srsMaxUpPts, mBuf);
- CMCHKPK(SPkU8, param->srsSetup.srsANSimultTx, mBuf);
- CMCHKPK(SPkU8, param->srsSetup.sfCfg, mBuf);
- CMCHKPK(SPkU8, param->srsSetup.srsBw, mBuf);
- CMCHKPK(SPkU8, param->srsCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.srsMaxUpPts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.srsANSimultTx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.sfCfg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsSetup.srsBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfSrsUlCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->srsCfgType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.srsBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.sfCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.srsANSimultTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsSetup.srsMaxUpPts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.sfCfg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.srsANSimultTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsSetup.srsMaxUpPts, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->spclSfPatterns, mBuf);
- CMCHKPK(SPkU8, param->sfAssignment, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->spclSfPatterns, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sfAssignment, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
/* ctf_c_001.main_4: Added support for vendor specific parameters */
if( param->buffLen != 0) {
SAddPreMsgMultInOrder(param->paramBuffer,param->buffLen,mBuf);
}
- CMCHKPK(SPkU16,param->buffLen,mBuf);
+ CMCHKPK(oduUnpackUInt16,param->buffLen,mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
TRC3(cmUnpkCtfVendorSpecParams)
- CMCHKUNPK(SUnpkU16, ¶m->buffLen, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->buffLen, mBuf);
if(param->buffLen != 0) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)¶m->paramBuffer, param->buffLen)) != ROK) {
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF060, (ErrVal)0, (Txt*)&"Unpacking failed");
#endif
- RETVALUE(RFAILED) ;
+ return RFAILED ;
}
SRemPreMsgMult(param->paramBuffer, param->buffLen,mBuf) ;
}
param->paramBuffer = NULLP ;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
TRC3(cmUnpkCtfTddSfCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->sfAssignment, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->spclSfPatterns, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sfAssignment, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->spclSfPatterns, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
TRC3(cmPkCtfUnLicnsdCellParam)
CMCHKPK(SPkS32, param->txPowerLimit, mBuf);
- CMCHKPK(SPkU8, param->coExistMethod, mBuf);
- CMCHKPK(SPkU8, param->lteOnPeriod, mBuf);
- CMCHKPK(SPkU8, param->ccaMethod, mBuf);
- CMCHKPK(SPkU8, param->adaptiveTx, mBuf);
- CMCHKPK(SPkU16, param->transPeriod, mBuf);
- CMCHKPK(SPkU16, param->listenPrd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->coExistMethod, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lteOnPeriod, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ccaMethod, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->adaptiveTx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->transPeriod, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->listenPrd, mBuf);
CMCHKPK(SPkS16, param->energyTh, mBuf);
- CMCHKPK(SPkU16, param->scanTimePrd, mBuf);
- CMCHKPK(SPkU16, param->activityTh, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->scanTimePrd, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->activityTh, mBuf);
for(idx = 0; idx < param->numFreq; idx++)
{
- CMCHKPK(SPkU32, param->earfcn[idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->earfcn[idx], mBuf);
}
- CMCHKPK(SPkU8, param->numFreq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numFreq, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
#ifdef EMTC_ENABLE
for (i = CTF_MAX_CE_LEVEL-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
- CMCHKPK(SPkU8, param->ceLevelInfo[i].lastPreamble, mBuf);
- CMCHKPK(SPkU8, param->ceLevelInfo[i].firstPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].lastPreamble, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].firstPreamble, mBuf);
}
- CMCHKPK(SPkU8, param->mPdcchStart, mBuf);
- CMCHKPK(SPkU8, param->catMenabled, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mPdcchStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->catMenabled, mBuf);
#endif
if(param->unLicnsdCfgPres)
{
printf("pverma param->unLicnsdCfgPres cm/ctf -->%d\n",param->unLicnsdCfgPres);
CMCHKPK(cmPkCtfUnLicnsdCellParam, ¶m->lteUCfg, mBuf);
}
- CMCHKPK(SPkU8, param->unLicnsdCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->unLicnsdCfgPres, mBuf);
/*Added for rgu dynamic delta*/
- CMCHKPK(SPkU8, param->numDlUePerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numDlUePerTti, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
- CMCHKPK(SPkU16, param->ulEarfcn, mBuf);
- CMCHKPK(SPkU16, param->dlEarfcn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ulEarfcn, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dlEarfcn, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
/* Packing PHY configuration parameters */
- CMCHKPK(SPkU32, param->period, mBuf);
- CMCHKPK(SPkU32, param->counter, mBuf);
- CMCHKPK(SPkU16, param->opMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->period, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->counter, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->opMode, mBuf);
/* ctf_c_001.main_3: Added the pack for newly added fileds inside the CFG structure*/
- CMCHKPK(SPkU8, param->rachSrRepModePres, mBuf);
- CMCHKPK(SPkU16, param->rachSrRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rachSrRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rachSrRepMode, mBuf);
- CMCHKPK(SPkU8, param->dataRepModePres, mBuf);
- CMCHKPK(SPkU16, param->dataRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dataRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dataRepMode, mBuf);
- CMCHKPK(SPkU8, param->phySyncModePres, mBuf);
- CMCHKPK(SPkU16, param->phySyncMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phySyncModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->phySyncMode, mBuf);
- CMCHKPK(SPkU8, param->rxAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->rxAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rxAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rxAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->txAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->txAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->pucchProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->pucchProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->puschProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->puschProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->puschProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->srsDopEstFactorPres, mBuf);
- CMCHKPK(SPkU16, param->srsDopEstFactor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsDopEstFactorPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srsDopEstFactor, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio0Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio0Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio0, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio4Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio4, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio4Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio4, mBuf);
- CMCHKPK(SPkU8, param->pucchNoiseGammaPres, mBuf);
- CMCHKPK(SPkU16, param->pucchNoiseGamma, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchNoiseGammaPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchNoiseGamma, mBuf);
- CMCHKPK(SPkU8, param->extWinMarginPres, mBuf);
- CMCHKPK(SPkU16, param->extWinMargin, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->extWinMarginPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->extWinMargin, mBuf);
- CMCHKPK(SPkU8, param->dciPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->dciPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dciPowOs, mBuf);
- CMCHKPK(SPkU8, param->cfiPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->cfiPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfiPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cfiPowOs, mBuf);
- CMCHKPK(SPkU8, param->syncSigPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->syncSigPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->syncSigPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->syncSigPowOs, mBuf);
CMCHKPK(cmPkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
CMCHKPK(cmPkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKPK(cmPkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKPK(cmPkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKPK(cmPkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
- CMCHKPK(SPkU8, param->physCellId, mBuf);
- CMCHKPK(SPkU8, param->physCellIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellIdPres, mBuf);
CMCHKPK(SPkS16, param->macSapId, mBuf);
CMCHKPK(SPkS16, param->schSapId, mBuf);
- CMCHKPK(SPkU8, param->cellIdGrpId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellIdGrpId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
TRC3(cmPkCtfUnLicnsdCellParam)
- CMCHKUNPK(SUnpkU8, ¶m->numFreq, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numFreq, mBuf);
for(idx = 0; idx < param->numFreq; idx++)
{
- CMCHKUNPK(SUnpkU32, ¶m->earfcn[idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->earfcn[idx], mBuf);
}
- CMCHKUNPK(SUnpkU16, ¶m->activityTh, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->scanTimePrd, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->activityTh, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->scanTimePrd, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->energyTh, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->listenPrd, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->transPeriod, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->adaptiveTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ccaMethod, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->lteOnPeriod, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->coExistMethod, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->listenPrd, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->transPeriod, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->adaptiveTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ccaMethod, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lteOnPeriod, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->coExistMethod, mBuf);
CMCHKUNPK(SUnpkS32, ¶m->txPowerLimit, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cellIdGrpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdGrpId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->schSapId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->macSapId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellIdPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellIdPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellId, mBuf);
CMCHKUNPK(cmUnpkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKUNPK(cmUnpkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKUNPK(cmUnpkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->syncSigPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->syncSigPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->syncSigPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->syncSigPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cfiPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cfiPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cfiPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfiPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dciPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dciPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->extWinMargin, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->extWinMarginPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->extWinMargin, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->extWinMarginPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchNoiseGamma, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchNoiseGammaPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchNoiseGamma, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchNoiseGammaPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio4, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio4Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio4, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio4Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio0, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio0Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio0Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->srsDopEstFactor, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsDopEstFactorPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsDopEstFactor, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsDopEstFactorPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->puschProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->puschProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->puschProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->txAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rxAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rxAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rxAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rxAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->phySyncMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phySyncModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->phySyncMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phySyncModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dataRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dataRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dataRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dataRepModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rachSrRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rachSrRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rachSrRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rachSrRepModePres, mBuf);
/* UnPacking PHY configuration parameters */
- CMCHKUNPK(SUnpkU16, ¶m->opMode, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->counter, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->period, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->opMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->counter, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->period, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dlEarfcn, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->ulEarfcn, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dlEarfcn, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->ulEarfcn, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
/* Added for rgu dynamic delta change*/
- CMCHKUNPK(SUnpkU8, ¶m->numDlUePerTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->unLicnsdCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numDlUePerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->unLicnsdCfgPres, mBuf);
if(param->unLicnsdCfgPres)
{
CMCHKUNPK(cmUnpkCtfUnLicnsdCellParam, ¶m->lteUCfg, mBuf);
}
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8, ¶m->catMenabled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mPdcchStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->catMenabled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mPdcchStart, mBuf);
for (i = 0; i < CTF_MAX_CE_LEVEL; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->ceLevelInfo[i].firstPreamble, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ceLevelInfo[i].lastPreamble, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevelInfo[i].firstPreamble, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevelInfo[i].lastPreamble, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfCellRecfgInfo)
#ifdef ENABLE_API_LOG
- CMCHKPK(SPkU8, param->enableAPILog, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->enableAPILog, mBuf);
#endif /* ENABLE_API_LOG */
/* ctf_c_001.main_3: Added the pack for newly added fileds inside the CFG structure*/
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
- CMCHKPK(SPkU8, param->rachSrRepModePres, mBuf);
- CMCHKPK(SPkU16, param->rachSrRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rachSrRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rachSrRepMode, mBuf);
- CMCHKPK(SPkU8, param->dataRepModePres, mBuf);
- CMCHKPK(SPkU16, param->dataRepMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dataRepModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dataRepMode, mBuf);
- CMCHKPK(SPkU8, param->phySyncModePres, mBuf);
- CMCHKPK(SPkU16, param->phySyncMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->phySyncModePres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->phySyncMode, mBuf);
- CMCHKPK(SPkU8, param->rxAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->rxAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rxAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rxAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->txAntennaPortsPres, mBuf);
- CMCHKPK(SPkU16, param->txAntennaPorts, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txAntennaPortsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txAntennaPorts, mBuf);
- CMCHKPK(SPkU8, param->pucchProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->pucchProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->puschProbDtxAckPres, mBuf);
- CMCHKPK(SPkU16, param->puschProbDtxAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschProbDtxAckPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->puschProbDtxAck, mBuf);
- CMCHKPK(SPkU8, param->srsDopEstFactorPres, mBuf);
- CMCHKPK(SPkU16, param->srsDopEstFactor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsDopEstFactorPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srsDopEstFactor, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio0Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio0Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio0, mBuf);
- CMCHKPK(SPkU8, param->prachPkRatio4Pres, mBuf);
- CMCHKPK(SPkU16, param->prachPkRatio4, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachPkRatio4Pres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->prachPkRatio4, mBuf);
- CMCHKPK(SPkU8, param->pucchNoiseGammaPres, mBuf);
- CMCHKPK(SPkU16, param->pucchNoiseGamma, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchNoiseGammaPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchNoiseGamma, mBuf);
- CMCHKPK(SPkU8, param->extWinMarginPres, mBuf);
- CMCHKPK(SPkU16, param->extWinMargin, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->extWinMarginPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->extWinMargin, mBuf);
- CMCHKPK(SPkU8, param->dciPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->dciPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dciPowOs, mBuf);
- CMCHKPK(SPkU8, param->cfiPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->cfiPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfiPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cfiPowOs, mBuf);
- CMCHKPK(SPkU8, param->syncSigPowOsPres, mBuf);
- CMCHKPK(SPkU16, param->syncSigPowOs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->syncSigPowOsPres, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->syncSigPowOs, mBuf);
CMCHKPK(cmPkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
CMCHKPK(cmPkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKPK(cmPkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKPK(cmPkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKPK(cmPkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
- CMCHKPK(SPkU8, param->physCellId, mBuf);
- CMCHKPK(SPkU8, param->physCellIdPres, mBuf);
- CMCHKPK(SPkU8, param->cellIdGrpId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->physCellIdPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellIdGrpId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- CMCHKPK(SPkU32, param->ctfReCfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->ctfReCfgType, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfCellRecfgInfo)
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ctfReCfgType = (CtfReCfgType)tmpEnum;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cellIdGrpId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellIdPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->physCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdGrpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellIdPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->physCellId, mBuf);
CMCHKUNPK(cmUnpkCtfBwCfgInfo, ¶m->bwCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTxSchemeCfg, ¶m->txCfg, mBuf);
CMCHKUNPK(cmUnpkCtfAntennaCfgInfo, ¶m->antennaCfg, mBuf);
CMCHKUNPK(cmUnpkCtfSrsUlCfgInfo, ¶m->srsUlCfg, mBuf);
CMCHKUNPK(cmUnpkCtfTddSfCfgInfo, ¶m->tddSfCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->syncSigPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->syncSigPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->syncSigPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->syncSigPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cfiPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cfiPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cfiPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfiPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dciPowOs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciPowOsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dciPowOs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciPowOsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->extWinMargin, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->extWinMarginPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->extWinMargin, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->extWinMarginPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchNoiseGamma, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchNoiseGammaPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchNoiseGamma, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchNoiseGammaPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio4, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio4Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio4, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio4Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->prachPkRatio0, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachPkRatio0Pres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->prachPkRatio0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachPkRatio0Pres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->srsDopEstFactor, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->srsDopEstFactorPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsDopEstFactor, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsDopEstFactorPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->puschProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->puschProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->puschProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pucchProbDtxAck, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchProbDtxAckPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchProbDtxAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchProbDtxAckPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->txAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rxAntennaPorts, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rxAntennaPortsPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rxAntennaPorts, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rxAntennaPortsPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->phySyncMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->phySyncModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->phySyncMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->phySyncModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dataRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dataRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dataRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dataRepModePres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rachSrRepMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rachSrRepModePres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rachSrRepMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rachSrRepModePres, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
printf("param->pilotSigPwr = %d\nparam->priSigPwr = %d\n param->secSigPwr = %d\n",param->pilotSigPwr,param->priSigPwr,param->secSigPwr);
#ifdef ENABLE_API_LOG
- CMCHKUNPK(SUnpkU8, ¶m->enableAPILog, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->enableAPILog, mBuf);
#endif /* ENABLE_API_LOG */
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKPK(SPkU32, param->pA, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->pA, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
U32 tmpEnum;
TRC3(cmUnpkCtfDedPdschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->pA = (CtfPdschPaParam)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_4:115549: packing tddAckNackFBMode and tddAckNackCfgPres */
if (param->tddAckNackCfgPres != FALSE)
{
- CMCHKPK(SPkU32, param->tddAckNackFBMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tddAckNackFBMode, mBuf);
}
- CMCHKPK(SPkU8, param->tddAckNackCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tddAckNackCfgPres, mBuf);
#endif /* CTF_VER3 */
- CMCHKPK(SPkU16, param->pucchSetup.n1PUCCHRep, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->pucchSetup.n1PUCCHRep, mBuf);
#ifdef CTF_VER3
/*ctf_c_001.main_4:115549: packing pucchSetup.repFactPres */
if (param->pucchSetup.repFactPres)
{
- CMCHKPK(SPkU32, param->pucchSetup.repFact, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pucchSetup.repFact, mBuf);
}
- CMCHKPK(SPkU8, param->pucchSetup.repFactPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchSetup.repFactPres, mBuf);
#else
- CMCHKPK(SPkU32, param->pucchSetup.repFact, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pucchSetup.repFact, mBuf);
#endif /* CTF_VER3 */
- CMCHKPK(SPkU8, param->dedPucchCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedPucchCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfDedPucchCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->dedPucchCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedPucchCfgType, mBuf);
#ifdef CTF_VER3
/* ctf_c_001.main_4:115549: unpacking pucchSetup.repFactPres */
- CMCHKUNPK(SUnpkU8, ¶m->pucchSetup.repFactPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchSetup.repFactPres, mBuf);
if (param->pucchSetup.repFactPres)
{
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->pucchSetup.repFact, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->pucchSetup.repFact, mBuf);
}
#else
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->pucchSetup.repFact, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->pucchSetup.repFact, mBuf);
#endif /*CTF_VER3 */
- CMCHKUNPK(SUnpkU16, ¶m->pucchSetup.n1PUCCHRep, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pucchSetup.n1PUCCHRep, mBuf);
#ifdef CTF_VER3
/*ctf_c_001.main_4:115549: unpacking tddAckNackCfgPres and tddAckNackFBMode */
- CMCHKUNPK(SUnpkU8, ¶m->tddAckNackCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tddAckNackCfgPres, mBuf);
if (param->tddAckNackCfgPres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->tddAckNackFBMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tddAckNackFBMode, mBuf);
}
#endif /* CTF_VER3 */
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->betaOffsetCqiIdx, mBuf);
- CMCHKPK(SPkU8, param->betaOffsetRiIdx, mBuf);
- CMCHKPK(SPkU8, param->betaOffsetAckIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->betaOffsetCqiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->betaOffsetRiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->betaOffsetAckIdx, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfDedPuschCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->betaOffsetAckIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->betaOffsetRiIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->betaOffsetCqiIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->betaOffsetAckIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->betaOffsetRiIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->betaOffsetCqiIdx, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfCqiRptModePeriodic)
/* ctf_c_001.main_2: added packning for cqiMask*/
#ifdef CTF_VER1
- CMCHKPK(SPkU32, (U32 )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.cqiMask.pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32 )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.cqiMask.pres, mBuf);
#endif /* CTF_VER1 */
- CMCHKPK(SPkU8, param->cqiSetup.simultaneousAckNack, mBuf);
- CMCHKPK(SPkU16, param->cqiSetup.riCfgIndx, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.riCfgPres, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.subbandCqi.k, mBuf);
- CMCHKPK(SPkU8, param->cqiSetup.formatIndicator, mBuf);
- CMCHKPK(SPkU16, param->cqiSetup.cqiPmiCfgIndx, mBuf);
- CMCHKPK(SPkU16, param->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
- CMCHKPK(SPkU8, param->cqiPeriodicCfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.simultaneousAckNack, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiSetup.riCfgIndx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.riCfgPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.subbandCqi.k, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiSetup.formatIndicator, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiSetup.cqiPmiCfgIndx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPeriodicCfgType, mBuf);
+ return ROK;
}
#endif
TRC3(cmUnpkCtfCqiRptModePeriodic)
- CMCHKUNPK(SUnpkU8, ¶m->cqiPeriodicCfgType, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiSetup.cqiPmiCfgIndx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.formatIndicator, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.subbandCqi.k, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.riCfgPres, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->cqiSetup.riCfgIndx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.simultaneousAckNack, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPeriodicCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.cqiPmiCfgIndx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.formatIndicator, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.subbandCqi.k, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.riCfgPres, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->cqiSetup.riCfgIndx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.simultaneousAckNack, mBuf);
/* ctf_c_001.main_2: added Unpackning for cqiMask*/
#ifdef CTF_VER1
- CMCHKUNPK(SUnpkU8, ¶m->cqiSetup.cqiMask.pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.cqiMask.pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->cqiSetup.cqiMask.cqiMaskSetup = tmpEnum;
#endif /* CTF_VER1 */
- RETVALUE(ROK);
+ return ROK;
}
*/
if(param->reportMode.aPeriodicRpt.pres != FALSE)
{
- CMCHKPK(SPkU32, param->reportMode.aPeriodicRpt.aPeriodicRptMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->reportMode.aPeriodicRpt.aPeriodicRptMode, mBuf);
}
- CMCHKPK(SPkU8, param->reportMode.aPeriodicRpt.pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportMode.aPeriodicRpt.pres, mBuf);
if(param->reportMode.periodicRpt.pres != FALSE)
{
CMCHKPK(cmPkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
}
- CMCHKPK(SPkU8, param->reportMode.periodicRpt.pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportMode.periodicRpt.pres, mBuf);
#else /* CTF_VER2 */
CMCHKPK(cmPkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
break;
case CTF_CQI_RPTMODE_APRDIOC:
- CMCHKPK(SPkU32, param->reportMode.aPeriodicRpt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->reportMode.aPeriodicRpt, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->reportingMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportingMode, mBuf);
#endif /* CTF_VER2 */
/* ctf_c_001.main_2: added packning for pmiRiRpt*/
#ifdef CTF_VER1
- CMCHKPK(SPkU32, param->pmiRiRpt.pmiRiRptSetup, mBuf);
- CMCHKPK(SPkU8, param->pmiRiRpt.pres, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pmiRiRpt.pmiRiRptSetup, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmiRiRpt.pres, mBuf);
#endif /* CTF_VER1 */
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
#endif
TRC3(cmUnpkCtfCqiReportCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
/* ctf_c_001.main_2: added Unpackning for cqiMask*/
#ifdef CTF_VER1
- CMCHKUNPK(SUnpkU8, ¶m->pmiRiRpt.pres, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmiRiRpt.pres, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->pmiRiRpt.pmiRiRptSetup = tmpEnum;
#endif /* CTF_VER1 */
*ctf_c_001.main_2: Added provision to send Periodic and aPeriodic CQI
*report configuration in the same message
*/
- CMCHKUNPK(SUnpkU8, ¶m->reportMode.periodicRpt.pres, mBuf)
+ CMCHKUNPK(oduPackUInt8, ¶m->reportMode.periodicRpt.pres, mBuf)
if(param->reportMode.periodicRpt.pres != FALSE)
{
CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->reportMode.aPeriodicRpt.pres, mBuf)
+ CMCHKUNPK(oduPackUInt8, ¶m->reportMode.aPeriodicRpt.pres, mBuf)
if(param->reportMode.aPeriodicRpt.pres != FALSE)
{
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->reportMode.aPeriodicRpt.aPeriodicRptMode =
(CtfCqiRptModeAperiodic)tmpEnum;
}
#else /* CTF_VER2 */
- CMCHKUNPK(SUnpkU8, ¶m->reportingMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->reportingMode, mBuf);
switch(param->reportingMode) {
case CTF_CQI_RPTMODE_APRDIOC:
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->reportMode.aPeriodicRpt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->reportMode.aPeriodicRpt, mBuf);
break;
case CTF_CQI_RPTMODE_PRDIOC:
CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* CTF_VER2 */
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->dedSrsSetup.cyclicShift, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.txComb, mBuf);
- CMCHKPK(SPkU16, param->dedSrsSetup.srsCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.duration, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.freqDmnPos, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.srsHopngBw, mBuf);
- CMCHKPK(SPkU8, param->dedSrsSetup.srsBw, mBuf);
- CMCHKPK(SPkU8, param->dedSrsUlCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.cyclicShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.txComb, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dedSrsSetup.srsCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.duration, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.freqDmnPos, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.srsHopngBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsSetup.srsBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrsUlCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfDedSrsUlCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsUlCfgType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.srsBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.srsHopngBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.freqDmnPos, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.duration, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dedSrsSetup.srsCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.txComb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrsSetup.cyclicShift, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsUlCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.srsHopngBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.freqDmnPos, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.duration, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dedSrsSetup.srsCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.txComb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrsSetup.cyclicShift, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU8, param->dedSrSetup.srCfgIdx, mBuf);
- CMCHKPK(SPkU16, param->dedSrSetup.srPUCCHRi, mBuf);
- CMCHKPK(SPkU8, param->dedSRCfgType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSrSetup.srCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dedSrSetup.srPUCCHRi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dedSRCfgType, mBuf);
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfDedSRCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(SUnpkU8, ¶m->dedSRCfgType, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dedSrSetup.srPUCCHRi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dedSrSetup.srCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSRCfgType, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dedSrSetup.srPUCCHRi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dedSrSetup.srCfgIdx, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* TFU_UPGRADE */
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKPK(SPkU32, param->ueTxAntSelection.txAntSelect, mBuf);
- CMCHKPK(SPkU8, param->ueTxAntSelection.cfgType, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->ueTxAntSelection.txAntSelect, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ueTxAntSelection.cfgType, mBuf);
/* ctf_c_001.main_3 txMode is of type enum and is 32bit length */
- CMCHKPK(SPkU32, (U32)param->txMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->txMode, mBuf);
#ifdef CTF_VER2
/*
*ctf_c_001.main_2: Added Packing of CodeBookSubsetRestriction parameter
switch(param->codeBookSubsetRes.ctfCdBkRestType)
{
case N2TX_ANT_TM3:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm3, mBuf);
break;
case N4TX_ANT_TM3:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm3, mBuf);
break;
case N2TX_ANT_TM4:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm4, mBuf);
break;
case N4TX_ANT_TM4:
for(idx = 0; idx < 8; idx++)
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm4[idx], mBuf);
break;
case N2TX_ANT_TM5:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm5, mBuf);
break;
case N4TX_ANT_TM5:
- CMCHKPK(SPkU16, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt16, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm5, mBuf);
break;
case N2TX_ANT_TM6:
- CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt8, param->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm6, mBuf);
break;
case N4TX_ANT_TM6:
- CMCHKPK(SPkU16, param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKPK(oduUnpackUInt16, param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm6, mBuf);
break;
default :
break;
}
- CMCHKPK(SPkU32, param->codeBookSubsetRes.ctfCdBkRestType, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->codeBookSubsetRes.ctfCdBkRestType, mBuf);
#endif /* CTF_VER2 */
}
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfDedAntCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
/*
* Added Unpacking for CodeBookSubsetRestriction parameter
*/
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->codeBookSubsetRes.ctfCdBkRestType = (CtfCdBkSubsetRestnType)tmpEnum;
switch(param->codeBookSubsetRes.ctfCdBkRestType)
{
case N2TX_ANT_TM3:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm3, mBuf);
break;
case N4TX_ANT_TM3:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm3, mBuf);
break;
case N2TX_ANT_TM4:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm4, mBuf);
break;
case N4TX_ANT_TM4:
for(idx = 7; idx >= 0; idx--)
{
- CMCHKUNPK(SUnpkU8, &(param->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, &(param->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm4[idx]), mBuf);
}
break;
case N2TX_ANT_TM5:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm5, mBuf);
break;
case N4TX_ANT_TM5:
- CMCHKUNPK(SUnpkU16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm5, mBuf);
break;
case N2TX_ANT_TM6:
- CMCHKUNPK(SUnpkU8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt8, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n2TxAntTm6, mBuf);
break;
case N4TX_ANT_TM6:
- CMCHKUNPK(SUnpkU16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
+ CMCHKUNPK(oduPackUInt16, ¶m->codeBookSubsetRes.codeBookSubsetRestn.
n4TxAntTm6, mBuf);
break;
default :
}
#endif /* CTF_VER2 */
/* ctf_c_001.main_3 Enum is 32bit length */
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->txMode = (CtfUeTxAntMode)tmpEnum;
- CMCHKUNPK(SUnpkU8, ¶m->ueTxAntSelection.cfgType, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ueTxAntSelection.cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
param->ueTxAntSelection.txAntSelect = (CtfUeTxAntSelectType)tmpEnum;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
Buffer *mBuf;
#endif
{
- 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(cmPkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[(U8)idx], mBuf);
}
- CMCHKPK(SPkU32, param->sCellAction, mBuf);
- CMCHKPK(SPkU8, param->numSCells, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sCellAction, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
Buffer *mBuf;
#endif
{
- CMCHKUNPK(SUnpkU8, ¶m->sCellIdx, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->sCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
{
U8 idx;
- CMCHKUNPK(SUnpkU8, ¶m->numSCells, mBuf);
- CMCHKUNPK(SUnpkU32, (U32*)¶m->sCellAction, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32*)¶m->sCellAction, mBuf);
for(idx = 0 ; idx < param->numSCells; idx++)
{
CMCHKUNPK(cmUnpkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKPK(SPkU32, param->ueCategory, mBuf);
- CMCHKPK(SPkU8, param->pres, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->ueCategory, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfUeCatCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->ueCategory, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->ueCategory, mBuf);
+ return ROK;
}
TRC3(cmPkCtfDedCfgInfo)
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8, param->isEmtcUe, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isEmtcUe, mBuf);
#endif
CMCHKPK(cmPkCtfDedAntCfgInfo, ¶m->antInfo, mBuf);
#ifndef TFU_UPGRADE
CMCHKPK(cmPkCtfUeCatCfgInfo, ¶m->ueCatCfg, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* TFU_UPGRADE */
CMCHKUNPK(cmUnpkCtfDedAntCfgInfo, ¶m->antInfo, mBuf);
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8, ¶m->isEmtcUe, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isEmtcUe, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkCtfCellReleaseInfo)
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkCtfCellReleaseInfo)
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(cmUnpkCtfSecCellCfgInfo, ¶m->sCellInfo,mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkCtfCellCfgInfo, ¶m->u.cellCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgElem, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgElem, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgElem, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
case CTF_CELL_CFG:
CMCHKUNPK(cmUnpkCtfCellCfgInfo, ¶m->u.cellCfg, mBuf);
CMCHKUNPK(cmUnpkCtfDedCfgInfo, ¶m->u.dedCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgElem, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgElem, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfReCfgInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgElem, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
case CTF_CELL_CFG:
CMCHKUNPK(cmUnpkCtfCellRecfgInfo, ¶m->u.cellRecfg, mBuf);
CMCHKUNPK(cmUnpkCtfCellStop, ¶m->u.cellRecfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkCtfCellReleaseInfo, ¶m->u.cellRel, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgElem, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgElem, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfReleaseInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgElem, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgElem, mBuf);
switch(param->cfgElem) {
case CTF_CELL_CFG:
CMCHKUNPK(cmUnpkCtfCellReleaseInfo, ¶m->u.cellRel, mBuf);
CMCHKUNPK(cmUnpkCtfDedReleaseInfo, ¶m->u.dedRel, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkCtfCfgInfo, ¶m->u.cfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->cfgType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
+ return ROK;
}
TRC3(cmUnpkCtfCfgReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfgType, mBuf);
switch(param->cfgType) {
case CTF_CONFIG:
CMCHKUNPK(cmUnpkCtfCfgInfo, ¶m->u.cfg, mBuf);
CMCHKUNPK(cmUnpkCtfReleaseInfo, ¶m->u.release, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef CTF_VER3
if((retVal = cmUnpkCtfVendorSpecParams(pst, ¶m->vendorParams, mBuf)) != ROK)
- RETVALUE(retVal);
+ return (retVal);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/* Starts - Fix for CR ccpu00123185 */
TRC3(cmPkCtfCellPwrcfgInfo)
/* Added the pack for newly added reference signal Power*/
- CMCHKPK(SPkU32, (U32)param->ctfCellStatus, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->ctfCellStatus, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKPK(SPkS16, param->pdschCfg.refSigPwr, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->ctfCellStatus, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->ctfCellStatus, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmPkCtfCellStop)
/* Added the pack for newly added reference signal Power*/
- CMCHKPK(SPkU32, (U32)param->ctfCellStatus, mBuf);
+ CMCHKPK(oduUnpackUInt32, (U32)param->ctfCellStatus, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKPK(SPkS16, param->pdschCfg.refSigPwr, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->ctfCellStatus, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->ctfCellStatus, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* Periodic REM Scan for TPM */
{
TRC3(cmPkPerRemScanCellInfo)
- CMCHKPK(SPkU16,param->pci, mBuf);
- CMCHKPK(SPkU8, param->rsrp, mBuf);
- CMCHKPK(SPkU8, param->dlBw, mBuf);
- CMCHKPK(SPkU8, param->numTx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16,param->pci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rsrp, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numTx, mBuf);
+ return ROK;
}
{
CMCHKPK(cmPkPerRemScanCellInfo, ¶m->cellInfo[idx], mBuf);
}
- CMCHKPK(SPkU8, param->numCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
#endif
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkCtfPeriodicCellSearchRsp(CellCfgRsp, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmPkPtr((PTR)CellCfgRsp, mBuf) != ROK) {
+ if (oduPackPointer((PTR)CellCfgRsp, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
/* ctf_c_001.main_3 Compilation warning fix with g++ */
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
sizeof(CtfPeriodicRemCellSearchRsp));
}
pst->event = (Event)EVTCTFPREMCELLSRCHRSP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
{
TRC3(cmUnpkCtfPerRemScanCellInfo);
- CMCHKUNPK(SUnpkU8, ¶m->numTx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rsrp, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->pci, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->numTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rsrp, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->pci, mBuf);
+ return ROK;
}
#ifdef ANSI
S16 idx;
TRC3(cmUnpkCtfPerRemCellSrch);
- CMCHKUNPK(SUnpkU8, ¶m->numCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCells, mBuf);
for(idx = 0; idx < (param->numCells); idx++)
{
CMCHKUNPK(cmUnpkCtfPerRemScanCellInfo, ¶m->cellInfo[idx], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
SPutMsg(mBuf);
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&CellSrchRsp,
(ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (pst->selector == ODU_SELECTOR_LWLC) {
- if (cmUnpkPtr((PTR *)&CellSrchRsp, mBuf) != ROK) {
+ if (oduUnpackPointer((PTR *)&CellSrchRsp, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LC)
(Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, &transId, CellSrchRsp));
+ return ((*func)(pst, suId, &transId, CellSrchRsp));
}
/* Periodic REM Scan for TPM End */
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)macCellCfg, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)macCellCfg, mBuf);
DU_LOG("\nDU-APP : MAC CELL config sent");
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
return ROK;
}
***************************************************************************/
uint8_t unpackDuMacCellCfg(DuMacCellCfgReq func, Pst *pst, Buffer *mBuf)
{
- U16 ret = ROK;
+ uint16_t ret = ROK;
MacCellCfg *macCellCfg;
if(pst->selector == ODU_SELECTOR_LWLC)
{
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&macCellCfg, mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&macCellCfg, mBuf);
ret = (*func)(pst, macCellCfg);
}
else
if(pst->selector == ODU_SELECTOR_LC)
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
/* pack the transaction ID in CNF structure */
- CMCHKPK(SPkU16, macCellCfgCfm->cellId, mBuf);
- CMCHKPK(SPkU8, macCellCfgCfm->rsp, mBuf);
+ CMCHKPK(oduUnpackUInt16, macCellCfgCfm->cellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, macCellCfgCfm->rsp, mBuf);
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
if(pst->selector == ODU_SELECTOR_LC)
{
/* unpack the transaction ID in CNF structure */
- CMCHKUNPK(SUnpkU8, &(macCellCfgCfm.rsp), mBuf);
- CMCHKUNPK(SUnpkU16, &(macCellCfgCfm.cellId), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(macCellCfgCfm.rsp), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(macCellCfgCfm.cellId), mBuf);
return (*func)(pst, &macCellCfgCfm);
}
else
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nDU APP : Memory allocation failed for cell start req pack");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)cellStartInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)cellStartInfo, mBuf);
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
if(pst->selector == ODU_SELECTOR_LWLC)
{
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&cellStartInfo, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cellStartInfo, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, cellStartInfo);
}
else
{
/* Nothing to do for loose coupling */
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return ROK;
}
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nDU APP : Memory allocation failed for cell stop req pack");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)cellStopInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)cellStopInfo, mBuf);
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
return ROK;
}
if(pst->selector == ODU_SELECTOR_LWLC)
{
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&cellStopInfo, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cellStopInfo, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, cellStopInfo);
}
else
{
/* Nothing to do for loose coupling */
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return ROK;
}
}
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nDU APP : Memory allocation failed for cell start req pack");
return RFAILED;
if(pst->selector == ODU_SELECTOR_LC)
{
- CMCHKPK(SPkU16, slotInfo->cellId, mBuf);
- CMCHKPK(SPkU16, slotInfo->sfn, mBuf);
- CMCHKPK(SPkU16, slotInfo->slot, mBuf);
+ CMCHKPK(oduUnpackUInt16, slotInfo->cellId, mBuf);
+ CMCHKPK(oduUnpackUInt16, slotInfo->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt16, slotInfo->slot, mBuf);
CM_FREE_SHRABL_BUF(pst->region, pst->pool, slotInfo, sizeof(SlotIndInfo));
slotInfo = NULL;
else if(pst->selector == ODU_SELECTOR_LWLC)
{
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)slotInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)slotInfo, mBuf);
}
else
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
SlotIndInfo *slotInfo;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&slotInfo, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&slotInfo, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, slotInfo);
}
else if(pst->selector == ODU_SELECTOR_LC)
{
SlotIndInfo slotInfo;
- CMCHKUNPK(SUnpkU16, &(slotInfo.slot), mBuf);
- CMCHKUNPK(SUnpkU16, &(slotInfo.sfn), mBuf);
- CMCHKUNPK(SUnpkU16, &(slotInfo.cellId), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(slotInfo.slot), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(slotInfo.sfn), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(slotInfo.cellId), mBuf);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, &slotInfo);
}
else
{
/* Nothing to do for loose coupling */
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return ROK;
}
return ROK;
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nDU APP : Memory allocation failed for stop Ind pack");
return RFAILED;
{
/*pack the payload here*/
DU_LOG("\nDU APP : Packed CellId");
- CMCHKPK(SPkU16, cellStopId->cellId, mBuf);
+ CMCHKPK(oduUnpackUInt16, cellStopId->cellId, mBuf);
CM_FREE_SHRABL_BUF(pst->region, pst->pool, cellStopId, sizeof(MacCellStopInfo));
cellStopId = NULL;
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)cellStopId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)cellStopId, mBuf);
}
else
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
{
MacCellStopInfo *cellStopId;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&cellStopId, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cellStopId, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, cellStopId);
}
else if(pst->selector == ODU_SELECTOR_LC)
{
MacCellStopInfo cellStopId;
- CMCHKUNPK(SUnpkU16, &(cellStopId.cellId), mBuf);
+ CMCHKUNPK(oduPackUInt16, &(cellStopId.cellId), mBuf);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, &cellStopId);
}
else
{
/* Nothing to do for loose coupling */
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return ROK;
}
return ROK;
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nMAC : Memory allocation failed at packMacUlCcchInd");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)ulCcchIndInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)ulCcchIndInfo, mBuf);
}
else
{
return RFAILED;
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
UlCcchIndInfo *ulCcchIndInfo;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&ulCcchIndInfo, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&ulCcchIndInfo, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, ulCcchIndInfo);
}
else
{
/* Nothing to do for other selectors */
DU_LOG("\n Only LWLC supported for UL CCCH Ind ");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
return RFAILED;
}
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nMAC : Memory allocation failed at packMacDlCcchInd");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)dlCcchIndInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)dlCcchIndInfo, mBuf);
}
else
{
return RFAILED;
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
DlCcchIndInfo *dlCcchIndInfo;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&dlCcchIndInfo, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&dlCcchIndInfo, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, dlCcchIndInfo);
}
else
{
/* Nothing to do for other selectors */
DU_LOG("\n Only LWLC supported for DL CCCH Ind ");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
return RFAILED;
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nMAC : Memory allocation failed at packDuMacUeCreateReq");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)ueCfg, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf);
}
else
{
return RFAILED;
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
MacUeCfg *ueCfg;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&ueCfg, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&ueCfg, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, ueCfg);
}
else
{
/* Nothing to do for other selectors */
DU_LOG("\n Only LWLC supported for UE Create Request ");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
return RFAILED;
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nMAC : Memory allocation failed at packDuMacUeCfgRsp");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)cfgRsp, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)cfgRsp, mBuf);
}
else
{
return RFAILED;
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
MacUeCfgRsp *cfgRsp;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&cfgRsp, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, cfgRsp);
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
typedef struct carrierCfg
{
- Bool pres;
- U16 bw; /* DL/UL bandwidth */
- U32 freq; /* Absolute frequency of DL/UL point A in KHz */
- U16 k0[NUM_NUMEROLOGY]; /* K0 for DL/UL */
- U16 gridSize[NUM_NUMEROLOGY]; /* DL/UL Grid size for each numerologies */
- U16 numAnt; /* Number of Tx/Rx antennas */
+ bool pres;
+ uint16_t bw; /* DL/UL bandwidth */
+ uint32_t freq; /* Absolute frequency of DL/UL point A in KHz */
+ uint16_t k0[NUM_NUMEROLOGY]; /* K0 for DL/UL */
+ uint16_t gridSize[NUM_NUMEROLOGY]; /* DL/UL Grid size for each numerologies */
+ uint16_t numAnt; /* Number of Tx/Rx antennas */
}CarrierCfg;
typedef struct ssbCfg
uint8_t mibPdu[3]; /* MIB payload */
uint32_t ssbMask[SSB_MASK_SIZE]; /* Bitmap for actually transmitted SSB. */
uint8_t beamId[NUM_SSB];
- Bool multCarrBand; /* Multiple carriers in a band */
- Bool multCellCarr; /* Multiple cells in single carrier */
+ bool multCarrBand; /* Multiple carriers in a band */
+ bool multCellCarr; /* Multiple cells in single carrier */
}SsbCfg;
typedef struct fdmInfo
{
- U16 rootSeqIdx; /* Root sequence index */
- U8 numRootSeq; /* Number of root sequences required for FD */
- U16 k1; /* Frequency Offset for each FD */
- U8 zeroCorrZoneCfg; /* Zero correlation zone cofig */
- U8 numUnusedRootSeq; /* Number of unused root sequence */
- U8 *unsuedRootSeq; /* Unused root sequence per FD */
+ uint16_t rootSeqIdx; /* Root sequence index */
+ uint8_t numRootSeq; /* Number of root sequences required for FD */
+ uint16_t k1; /* Frequency Offset for each FD */
+ uint8_t zeroCorrZoneCfg; /* Zero correlation zone cofig */
+ uint8_t numUnusedRootSeq; /* Number of unused root sequence */
+ uint8_t *unsuedRootSeq; /* Unused root sequence per FD */
}PrachFdmInfo;
typedef struct prachCfg
{
- Bool pres;
+ bool pres;
uint8_t prachCfgIdx; /* PRACH Cfg Index */
PrachSeqLen prachSeqLen; /* RACH Sequence length: Long/short */
uint8_t prachSubcSpacing; /* Subcarrier spacing of RACH */
uint8_t rootSeqLen; /* Root sequence length */
PrachFdmInfo fdm[8]; /* FDM info */
uint8_t ssbPerRach; /* SSB per RACH occassion */
- Bool prachMultCarrBand; /* Multiple carriers in Band */
+ bool prachMultCarrBand; /* Multiple carriers in Band */
uint8_t prachRestrictedSet; /* Support for PRACH restricted set */
uint8_t raContResTmr; /* RA Contention Resoultion Timer */
uint8_t rsrpThreshSsb; /* RSRP Threshold SSB */
typedef struct tddCfg
{
- Bool pres;
+ bool pres;
DlUlTxPeriodicity tddPeriod; /* DL UL Transmission periodicity */
SlotConfig slotCfg[MAXIMUM_TDD_PERIODICITY][MAX_SYMB_PER_SLOT];
}TDDCfg;
typedef struct macCellCfg
{
- U16 cellId; /* Cell Id */
- U8 numTlv; /* Number of configuration TLVs */
- U8 carrierId; /* Carrired Index */
- U16 phyCellId; /* Physical cell id */
+ uint16_t cellId; /* Cell Id */
+ uint8_t numTlv; /* Number of configuration TLVs */
+ uint8_t carrierId; /* Carrired Index */
+ uint16_t phyCellId; /* Physical cell id */
DuplexMode dupType; /* Duplex type: TDD/FDD */
CarrierCfg dlCarrCfg; /* DL Carrier configuration */
CarrierCfg ulCarrCfg; /* UL Carrier configuration */
- Bool freqShft; /* Indicates presence of 7.5kHz frequency shift */
+ bool freqShft; /* Indicates presence of 7.5kHz frequency shift */
SsbCfg ssbCfg; /* SSB configuration */
PrachCfg prachCfg; /* PRACH Configuration */
TDDCfg tddCfg; /* TDD periodicity and slot configuration */
typedef struct macCellCfgCfm
{
- U16 cellId;
+ uint16_t cellId;
uint8_t rsp;
}MacCellCfgCfm;
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nRLC : Memory allocation failed at packDuRlcUeCreateReq");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)ueCfg, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf);
}
else
{
return RFAILED;
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
{
RlcUeCfg *ueCfg;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&ueCfg, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&ueCfg, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, ueCfg);
}
else
{
/* Nothing to do for other selectors */
DU_LOG("\nRLC: Only LWLC supported for UE Create Request ");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
return RFAILED;
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nRLC : Memory allocation failed at packRlcUlDuUeCreateRsp");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)ueCfg, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)ueCfg, mBuf);
}
else
{
return RFAILED;
}
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/*******************************************************************
{
RlcUeCfgRsp *cfgRsp;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&cfgRsp, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, cfgRsp);
}
else
{
/* Nothing to do for other selectors */
DU_LOG("\nRLC: Only LWLC supported for UE Create Response ");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
return RFAILED;
if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
DU_LOG("\nRLC : Memory allocation failed at packRlcUlRrcMsgToDu");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(cmPkPtr,(PTR)ulRrcMsgInfo, mBuf);
- return SPstTsk(pst,mBuf);
+ CMCHKPK(oduPackPointer,(PTR)ulRrcMsgInfo, mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
else
{
{
RlcUlRrcMsgInfo *ulRrcMsgInfo;
/* unpack the address of the structure */
- CMCHKUNPK(cmUnpkPtr, (PTR *)&ulRrcMsgInfo, mBuf);
- SPutMsg(mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&ulRrcMsgInfo, mBuf);
+ ODU_PUT_MSG(mBuf);
return (*func)(pst, ulRrcMsgInfo);
}
else
{
/* Nothing to do for other selectors */
DU_LOG("\nRLC: Only LWLC supported for UL RRC Message transfer ");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
return RFAILED;
/* system services typedefs */
-#define cmPkBool(x, mBuf) SPkU8(x, mBuf) /* pack Bool */
+#define oduPackBool(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Bool */
#define cmPkStatus(x, mBuf) SPkS16(x, mBuf) /* pack Status */
-#define cmPkTicks(x, mBuf) SPkU32(x, mBuf) /* pack Ticks */
+#define cmPkTicks(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Ticks */
#define cmPkQLen(x, mBuf) SPkS16(x, mBuf) /* pack QLen */
#define cmPkOrder(x, mBuf) SPkS16(x, mBuf) /* pack Order */
-#define cmPkData(x, mBuf) SPkU8(x, mBuf) /* pack Data */
-#define cmPkRandom(x, mBuf) SPkU16(x, mBuf) /* pack Random */
+#define cmPkData(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Data */
+#define cmPkRandom(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Random */
#define cmPkSeq(x, mBuf) SPkS16(x, mBuf) /* pack Seq */
#define cmPkReason(x, mBuf) SPkS16(x, mBuf) /* pack Reason */
-#define cmPkProcId(x, mBuf) SPkU16(x, mBuf) /* pack ProcId */
+#define cmPkProcId(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack ProcId */
#define cmPkVectNmb(x, mBuf) SPkS16(x, mBuf) /* pack VectNmb */
-#define cmPkPrior(x, mBuf) SPkU8(x, mBuf) /* pack Prior*/
+#define cmPkPrior(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Prior*/
#define cmPkPriority(x, mBuf) cmPkPrior(x, mBuf) /* pack Priority */
-#define cmPkRoute(x, mBuf) SPkU8(x, mBuf) /* pack Route */
+#define cmPkRoute(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Route */
#define cmPkTtype(x, mBuf) SPkS16(x, mBuf) /* pack Ttype */
#define cmPkSema(x, mBuf) SPkS8(x, mBuf) /* pack Sema */
#define cmPkTxt(x, mBuf) SPkS8(x, mBuf) /* pack Txt */
-#define cmPkEnt(x, mBuf) SPkU8(x, mBuf) /* pack Ent */
-#define cmPkInst(x, mBuf) SPkU8(x, mBuf) /* pack Inst */
+#define cmPkEnt(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Ent */
+#define cmPkInst(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Inst */
#define cmPkElmnt(x, mBuf) SPkS16(x, mBuf) /* pack Elmnt */
#define cmPkElmntInst1(x, mBuf) SPkS16(x, mBuf) /* pack ElmntInst1 */
#define cmPkElmntInst2(x, mBuf) SPkS16(x, mBuf) /* pack ElmntInst2 */
#define cmPkElmntInst3(x, mBuf) SPkS16(x, mBuf) /* pack ElmntInst3 */
-#define cmPkRegion(x, mBuf) SPkU8(x, mBuf) /* pack Region */
-#define cmPkPool(x, mBuf) SPkU8(x, mBuf) /* pack Pool */
+#define cmPkRegion(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Region */
+#define cmPkPool(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Pool */
#ifdef LONG_MSG
#define cmPkMsgLen(x, mBuf) SPkS32(x, mBuf) /* pack MsgLen */
#else
#define cmPkMsgLen(x, mBuf) SPkS16(x, mBuf) /* pack MsgLen */
#endif
#ifdef DOS
-#define cmPkSize(x, mBuf) SPkU16(x, mBuf) /* pack Size */
+#define cmPkSize(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Size */
#else
-#define cmPkSize(x, mBuf) SPkU32(x, mBuf) /* pack Size */
+#define cmPkSize(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Size */
#endif /* DOS */
/* general typedefs */
-#define cmPkSelector(x, mBuf) SPkU8(x, mBuf) /* pack Selector */
-#define cmPkEvent(x, mBuf) SPkU8(x, mBuf) /* pack Event */
+#define cmPkSelector(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Selector */
+#define cmPkEvent(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Event */
#define cmPkCntr(x, mBuf) SPkS32(x, mBuf) /* pack Cntr */
-#define cmPkStsCntr(x, mBuf) SPkU32(x, mBuf) /* pack StsCntr */
+#define cmPkStsCntr(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack StsCntr */
#define cmPkLnkNmb(x, mBuf) SPkS16(x, mBuf) /* pack LnkNmb */
#define cmPkSuId(x, mBuf) SPkS16(x, mBuf) /* pack SuId */
#define cmPkSpId(x, mBuf) SPkS16(x, mBuf) /* pack SpId */
#define cmPkSuInstId(x, mBuf) SPkS16(x, mBuf) /* pack SuInstId */
#define cmPkSpInstId(x, mBuf) SPkS16(x, mBuf) /* pack SpInstId */
-#define cmPkSapi(x, mBuf) SPkU8(x, mBuf) /* pack Sapi */
-#define cmPkTei(x, mBuf) SPkU8(x, mBuf) /* pack Tei */
-#define cmPkchNo(x, mBuf) SPkU8(x, mBuf) /* pack Channel Number */
-#define cmPkCes(x, mBuf) SPkU8(x, mBuf) /* pack Ces */
-#define cmPkDlci(x, mBuf) SPkU32(x, mBuf) /* pack Dlci */
-#define cmPkCalRef(x, mBuf) SPkU16(x, mBuf) /* pack CalRef */
+#define cmPkSapi(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Sapi */
+#define cmPkTei(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Tei */
+#define cmPkchNo(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Channel Number */
+#define cmPkCes(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Ces */
+#define cmPkDlci(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Dlci */
+#define cmPkCalRef(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack CalRef */
#define cmPkOrigin(x, mBuf) SPkS16(x, mBuf) /* pack Origin */
-#define cmPkNwId(x, mBuf) SPkU16(x, mBuf) /* pack NwId */
+#define cmPkNwId(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack NwId */
#define cmPkSwtch(x, mBuf) SPkS16(x, mBuf) /* pack Swtch */
-#define cmPkCause(x, mBuf) SPkU8(x, mBuf) /* pack Cause */
-#define cmPkDgn(x, mBuf) SPkU8(x, mBuf) /* pack Dgn */
+#define cmPkCause(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Cause */
+#define cmPkDgn(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Dgn */
#define cmPkAction(x, mBuf) SPkS16(x, mBuf) /* pack Action */
#define cmPkSeqS16(x, mBuf) SPkS16(x, mBuf) /* pack SeqS16 */
-#define cmPkSeqU16(x, mBuf) SPkU16(x, mBuf) /* pack SeqU16 */
+#define cmPkSeqU16(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack SeqU16 */
#define cmPkSeqS24(x, mBuf) SPkS32(x, mBuf) /* pack SeqS24 */
-#define cmPkSeqU24(x, mBuf) SPkU32(x, mBuf) /* pack SeqU24 */
-#define cmPkSetUpArb(x, mBuf) SPkU8(x, mBuf) /* pack SetUpArb */
-#define cmPkEvntType(x, mBuf) SPkU8(x, mBuf) /* pack EvntType */
-#define cmPkState(x, mBuf) SPkU8(x, mBuf) /* pack State */
-#define cmPkMode(x, mBuf) SPkU8(x, mBuf) /* pack Mode */
+#define cmPkSeqU24(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SeqU24 */
+#define cmPkSetUpArb(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack SetUpArb */
+#define cmPkEvntType(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack EvntType */
+#define cmPkState(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack State */
+#define cmPkMode(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Mode */
#define cmPkConnId(x, mBuf) SPkS32(x, mBuf) /* pack ConnId */
-#define cmPkUConnId(x, mBuf) SPkU32(x, mBuf) /* pack unsigned ConnId */
-#define cmPkMibOpCode(x, mBuf) SPkU16(x, mBuf) /* pack mib opCode*/
-#define cmPkMibStatus(x, mBuf) SPkU16(x, mBuf) /* Pack mib cfm status*/
-#define cmPkMibTblType(x, mBuf) SPkU16(x, mBuf) /* Pack mib table type */
+#define cmPkUConnId(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack unsigned ConnId */
+#define cmPkMibOpCode(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack mib opCode*/
+#define cmPkMibStatus(x, mBuf) oduUnpackUInt16(x, mBuf) /* Pack mib cfm status*/
+#define cmPkMibTblType(x, mBuf) oduUnpackUInt16(x, mBuf) /* Pack mib table type */
#define cmPkMibReqId(x, mBuf) SPkS32(x, mBuf) /* Pack mib request Id */
-#define cmPkProfileId(x, mBuf) SPkU8(x, mBuf) /* Pack HCC Profile Id */
-#define cmPkIntfId(x, mBuf) SPkU16(x, mBuf) /* Pack intf id */
-#define cmPkIntfVer(x, mBuf) SPkU16(x, mBuf) /* Pack intf ver */
-#define cmPkuaType(x, mBuf) SPkU8(x, mBuf) /* Pack uaType */
+#define cmPkProfileId(x, mBuf) oduUnpackUInt8(x, mBuf) /* Pack HCC Profile Id */
+#define cmPkIntfId(x, mBuf) oduUnpackUInt16(x, mBuf) /* Pack intf id */
+#define cmPkIntfVer(x, mBuf) oduUnpackUInt16(x, mBuf) /* Pack intf ver */
+#define cmPkuaType(x, mBuf) oduUnpackUInt8(x, mBuf) /* Pack uaType */
/* scc specific typedefs */
#define cmPkBaud(x, mBuf) SPkS16(x, mBuf) /* pack Baud */
/* tcp/ip specific typedefs */
-#define cmPkIpAddr(x, mBuf) SPkU32(x, mBuf) /* pack IpAddr */
-#define cmPkPort(x, mBuf) SPkU16(x, mBuf) /* pack Port */
-#define cmPkCmd(x, mBuf) SPkU8(x, mBuf) /* pack Cmd */
-#define cmPkFlags(x, mBuf) SPkU8(x, mBuf) /* pack Flags */
-#define cmPkTtl(x, mBuf) SPkU8(x, mBuf) /* pack Ttl */
-#define cmPkPrec(x, mBuf) SPkU8(x, mBuf) /* pack Prec */
-#define cmPkWindow(x, mBuf) SPkU32(x, mBuf) /* pack Window */
+#define cmPkIpAddr(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack IpAddr */
+#define cmPkPort(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Port */
+#define cmPkCmd(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Cmd */
+#define cmPkFlags(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Flags */
+#define cmPkTtl(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Ttl */
+#define cmPkPrec(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Prec */
+#define cmPkWindow(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Window */
/* LLC/SNAP specific defines */
-#define cmPkOui(x, mBuf) SPkU32(x, mBuf) /* pack Oui */
-#define cmPkPid(x, mBuf) SPkU16(x, mBuf) /* pack Pid */
-#define cmPkLlcId(x, mBuf) SPkU32(x, mBuf) /* pack LLcId */
+#define cmPkOui(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Oui */
+#define cmPkPid(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack Pid */
+#define cmPkLlcId(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack LLcId */
\f
/* unpacking macros */
/* system services typedefs */
-#define cmUnpkBool(x, mBuf) SUnpkU8(x, mBuf) /* unpack Bool */
+#define oduUnpackBool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Bool */
#define cmUnpkStatus(x, mBuf) SUnpkS16(x, mBuf) /* unpack Status */
-#define cmUnpkTicks(x, mBuf) SUnpkU32(x, mBuf) /* unpack Ticks */
+#define cmUnpkTicks(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Ticks */
#define cmUnpkQLen(x, mBuf) SUnpkS16(x, mBuf) /* unpack QLen */
#define cmUnpkOrder(x, mBuf) SUnpkS16(x, mBuf) /* unpack Order */
-#define cmUnpkData(x, mBuf) SUnpkU8(x, mBuf) /* unpack Data */
-#define cmUnpkRandom(x, mBuf) SUnpkU16(x, mBuf) /* unpack Random */
+#define cmUnpkData(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Data */
+#define cmUnpkRandom(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Random */
#define cmUnpkSeq(x, mBuf) SUnpkS16(x, mBuf) /* unpack Seq */
#define cmUnpkReason(x, mBuf) SUnpkS16(x, mBuf) /* unpack Reason */
-#define cmUnpkProcId(x, mBuf) SUnpkU16(x, mBuf) /* unpack ProcId */
+#define cmUnpkProcId(x, mBuf) oduPackUInt16(x, mBuf) /* unpack ProcId */
#define cmUnpkVectNmb(x, mBuf) SUnpkS16(x, mBuf) /* unpack VectNmb */
-#define cmUnpkPrior(x, mBuf) SUnpkU8(x, mBuf) /* unpack Prior */
+#define cmUnpkPrior(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Prior */
#define cmUnpkPriority(x, mBuf) cmUnpkPrior(x, mBuf) /* unpack Priority */
-#define cmUnpkRoute(x, mBuf) SUnpkU8(x, mBuf) /* unpack Route */
+#define cmUnpkRoute(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Route */
#define cmUnpkTtype(x, mBuf) SUnpkS16(x, mBuf) /* unpack Ttype */
#define cmUnpkSema(x, mBuf) SUnpkS8(x, mBuf) /* unpack Sema */
#define cmUnpkTxt(x, mBuf) SUnpkS8(x, mBuf) /* unpack Txt */
-#define cmUnpkEnt(x, mBuf) SUnpkU8(x, mBuf) /* unpack Ent */
-#define cmUnpkInst(x, mBuf) SUnpkU8(x, mBuf) /* unpack Inst */
+#define cmUnpkEnt(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Ent */
+#define cmUnpkInst(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Inst */
#define cmUnpkElmnt(x, mBuf) SUnpkS16(x, mBuf) /* unpack Elmnt */
#define cmUnpkElmntInst1(x, mBuf) SUnpkS16(x, mBuf) /* unpack ElmntInst1 */
#define cmUnpkElmntInst2(x, mBuf) SUnpkS16(x, mBuf) /* unpack ElmntInst2 */
#define cmUnpkElmntInst3(x, mBuf) SUnpkS16(x, mBuf) /* unpack ElmntInst3 */
-#define cmUnpkRegion(x, mBuf) SUnpkU8(x, mBuf) /* unpack Region */
-#define cmUnpkPool(x, mBuf) SUnpkU8(x, mBuf) /* unpack Pool */
+#define cmUnpkRegion(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Region */
+#define cmUnpkPool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Pool */
#ifdef LONG_MSG
#define cmUnpkMsgLen(x, mBuf) SUnpkS32(x, mBuf) /* unpack MsgLen */
#else
#define cmUnpkMsgLen(x, mBuf) SUnpkS16(x, mBuf) /* unpack MsgLen */
#endif
#ifdef DOS
-#define cmUnpkSize(x, mBuf) SUnpkU16(x, mBuf) /* unpack Size */
+#define cmUnpkSize(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Size */
#else
-#define cmUnpkSize(x, mBuf) SUnpkU32(x, mBuf) /* unpack Size */
+#define cmUnpkSize(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Size */
#endif /* DOS */
/* general typedefs */
-#define cmUnpkSelector(x, mBuf) SUnpkU8(x, mBuf) /* unpack Selector */
-#define cmUnpkEvent(x, mBuf) SUnpkU8(x, mBuf) /* unpack Event */
+#define cmUnpkSelector(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Selector */
+#define cmUnpkEvent(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Event */
#define cmUnpkCntr(x, mBuf) SUnpkS32(x, mBuf) /* unpack Cntr */
-#define cmUnpkStsCntr(x, mBuf) SUnpkU32(x, mBuf) /* unpack StsCntr */
+#define cmUnpkStsCntr(x, mBuf) oduPackUInt32(x, mBuf) /* unpack StsCntr */
#define cmUnpkLnkNmb(x, mBuf) SUnpkS16(x, mBuf) /* unpack LnkNmb */
#define cmUnpkSuId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SuId */
#define cmUnpkSpId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SpId */
#define cmUnpkSuInstId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SuInstId */
#define cmUnpkSpInstId(x, mBuf) SUnpkS16(x, mBuf) /* unpack SpInstId */
-#define cmUnpkSapi(x, mBuf) SUnpkU8(x, mBuf) /* unpack Sapi */
-#define cmUnpkTei(x, mBuf) SUnpkU8(x, mBuf) /* unpack Tei */
+#define cmUnpkSapi(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Sapi */
+#define cmUnpkTei(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Tei */
#define cmUnpkchNo(x, mBuf) SUnpkS8(x, mBuf) /* unpack Channel Number */
-#define cmUnpkCes(x, mBuf) SUnpkU8(x, mBuf) /* unpack Ces */
-#define cmUnpkDlci(x, mBuf) SUnpkU32(x, mBuf) /* unpack Dlci */
-#define cmUnpkCalRef(x, mBuf) SUnpkU16(x, mBuf) /* unpack CalRef */
+#define cmUnpkCes(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Ces */
+#define cmUnpkDlci(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Dlci */
+#define cmUnpkCalRef(x, mBuf) oduPackUInt16(x, mBuf) /* unpack CalRef */
#define cmUnpkOrigin(x, mBuf) SUnpkS16(x, mBuf) /* unpack Origin */
-#define cmUnpkNwId(x, mBuf) SUnpkU16(x, mBuf) /* unpack NwId */
+#define cmUnpkNwId(x, mBuf) oduPackUInt16(x, mBuf) /* unpack NwId */
#define cmUnpkSwtch(x, mBuf) SUnpkS16(x, mBuf) /* unpack Swtch */
-#define cmUnpkCause(x, mBuf) SUnpkU8(x, mBuf) /* unpack Cause */
-#define cmUnpkDgn(x, mBuf) SUnpkU8(x, mBuf) /* unpack Dgn */
+#define cmUnpkCause(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Cause */
+#define cmUnpkDgn(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Dgn */
#define cmUnpkAction(x, mBuf) SUnpkS16(x, mBuf) /* unpack Action */
#define cmUnpkSeqS16(x, mBuf) SUnpkS16(x, mBuf) /* unpack SeqS16 */
-#define cmUnpkSeqU16(x, mBuf) SUnpkU16(x, mBuf) /* unpack SeqU16 */
+#define cmUnpkSeqU16(x, mBuf) oduPackUInt16(x, mBuf) /* unpack SeqU16 */
#define cmUnpkSeqS24(x, mBuf) SUnpkS32(x, mBuf) /* unpack SeqS24 */
-#define cmUnpkSeqU24(x, mBuf) SUnpkU32(x, mBuf) /* unpack SeqU24 */
-#define cmUnpkSetUpArb(x, mBuf) SUnpkU8(x, mBuf) /* unpack SetUpArb */
-#define cmUnpkEvntType(x, mBuf) SUnpkU8(x, mBuf) /* unpack EvntType */
-#define cmUnpkState(x, mBuf) SUnpkU8(x, mBuf) /* unpack State */
-#define cmUnpkMode(x, mBuf) SUnpkU8(x, mBuf) /* unpack Mode */
+#define cmUnpkSeqU24(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SeqU24 */
+#define cmUnpkSetUpArb(x, mBuf) oduPackUInt8(x, mBuf) /* unpack SetUpArb */
+#define cmUnpkEvntType(x, mBuf) oduPackUInt8(x, mBuf) /* unpack EvntType */
+#define cmUnpkState(x, mBuf) oduPackUInt8(x, mBuf) /* unpack State */
+#define cmUnpkMode(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Mode */
#define cmUnpkConnId(x, mBuf) SUnpkS32(x, mBuf) /* unpack ConnId */
-#define cmUnpkUConnId(x, mBuf) SUnpkU32(x, mBuf) /* unpack uns ConnId */
-#define cmUnpkMibOpCode(x, mBuf) SUnpkU16(x, mBuf) /* unpack mib opCode*/
-#define cmUnpkMibStatus(x, mBuf) SUnpkU16(x, mBuf) /* unpack mib cfm status*/
-#define cmUnpkMibTblType(x, mBuf) SUnpkU16(x, mBuf) /* Pack mib table type */
+#define cmUnpkUConnId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack uns ConnId */
+#define cmUnpkMibOpCode(x, mBuf) oduPackUInt16(x, mBuf) /* unpack mib opCode*/
+#define cmUnpkMibStatus(x, mBuf) oduPackUInt16(x, mBuf) /* unpack mib cfm status*/
+#define cmUnpkMibTblType(x, mBuf) oduPackUInt16(x, mBuf) /* Pack mib table type */
#define cmUnpkMibReqId(x, mBuf) SUnpkS32(x, mBuf) /* Pack mib request Id */
-#define cmUnpkProfileId(x, mBuf) SUnpkU8(x, mBuf) /* Pack HCC Profile Id */
-#define cmUnpkIntfId(x, mBuf) SUnpkU16(x, mBuf) /* unpack intf id */
-#define cmUnpkIntfVer(x, mBuf) SUnpkU16(x, mBuf) /* unpack intf ver */
-#define cmUnpkuaType(x, mBuf) SUnpkU8(x, mBuf) /* Unpack uaType */
+#define cmUnpkProfileId(x, mBuf) oduPackUInt8(x, mBuf) /* Pack HCC Profile Id */
+#define cmUnpkIntfId(x, mBuf) oduPackUInt16(x, mBuf) /* unpack intf id */
+#define cmUnpkIntfVer(x, mBuf) oduPackUInt16(x, mBuf) /* unpack intf ver */
+#define cmUnpkuaType(x, mBuf) oduPackUInt8(x, mBuf) /* Unpack uaType */
/* scc specific typedefs */
#define cmUnpkBaud(x, mBuf) SUnpkS16(x, mBuf) /* unpack Baud */
/* tcp/ip specific typedefs */
-#define cmUnpkIpAddr(x, mBuf) SUnpkU32(x, mBuf) /* unpack IpAddr */
-#define cmUnpkPort(x, mBuf) SUnpkU16(x, mBuf) /* unpack Port */
-#define cmUnpkCmd(x, mBuf) SUnpkU8(x, mBuf) /* unpack Cmd */
-#define cmUnpkFlags(x, mBuf) SUnpkU8(x, mBuf) /* unpack Flags */
-#define cmUnpkTtl(x, mBuf) SUnpkU8(x, mBuf) /* unpack Ttl */
-#define cmUnpkPrec(x, mBuf) SUnpkU8(x, mBuf) /* unpack Prec */
-#define cmUnpkWindow(x, mBuf) SUnpkU32(x, mBuf) /* unpack Window */
+#define cmUnpkIpAddr(x, mBuf) oduPackUInt32(x, mBuf) /* unpack IpAddr */
+#define cmUnpkPort(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Port */
+#define cmUnpkCmd(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Cmd */
+#define cmUnpkFlags(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Flags */
+#define cmUnpkTtl(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Ttl */
+#define cmUnpkPrec(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Prec */
+#define cmUnpkWindow(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Window */
/* LLC/SNAP specific defines */
-#define cmUnpkOui(x, mBuf) SUnpkU32(x, mBuf) /* unpack Oui */
-#define cmUnpkPid(x, mBuf) SUnpkU16(x, mBuf) /* unpack Pid */
-#define cmUnpkLlcId(x, mBuf) SUnpkU32(x, mBuf) /* unpack LLcId */
+#define cmUnpkOui(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Oui */
+#define cmUnpkPid(x, mBuf) oduPackUInt16(x, mBuf) /* unpack Pid */
+#define cmUnpkLlcId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack LLcId */
/* packing and unpacking for token strings */
/* Value */ \
for (i = 0; i < (S16) tknStr->len; i++) \
{ \
- CMCHKPK(SPkU8, tknStr->val[i], mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->val[i], mBuf); \
} \
\
/* Length */ \
- CMCHKPK(SPkU8, tknStr->len, mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->len, mBuf); \
} \
\
/* Token Header */ \
- CMCHKPK(SPkU8, tknStr->pres, mBuf); \
+ CMCHKPK(oduUnpackUInt8, tknStr->pres, mBuf); \
}
#define CMUNPKTKNSTR(tknStr, mBuf) \
Cntr i; \
\
/* Token Header */ \
- CMCHKUNPK(SUnpkU8, &tknStr->pres, mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf); \
\
if(tknStr->pres) \
{ \
/* Length */ \
- CMCHKUNPK(SUnpkU8, &tknStr->len, mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->len, mBuf); \
\
/* Value */ \
for (i = 1; i <= (S16) tknStr->len; i++) \
{ \
- CMCHKUNPK(SUnpkU8, &tknStr->val[tknStr->len - i], mBuf); \
+ CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - i], mBuf); \
} \
} \
\
#endif /* CMFILE_REORG_1 */
-#define cmPkTranId(x, mBuf) SPkU32(x, mBuf) /* Pack transaction Id */
-#define cmUnpkTranId(x, mBuf) SUnpkU32(x, mBuf) /* unpack transaction Id */
+#define cmPkTranId(x, mBuf) oduUnpackUInt32(x, mBuf) /* Pack transaction Id */
+#define cmUnpkTranId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack transaction Id */
#ifdef L2_L3_SPLIT
typedef struct _debugInfo
/* system services structures */
EXTERN S16 cmPkDateTime ARGS((DateTime *dateTime, Buffer *mBuf));
EXTERN S16 cmPkDuration ARGS((Duration *duration, Buffer *mBuf));
-EXTERN S16 cmPkPtr ARGS((PTR ptr, Buffer *mBuf));
+EXTERN S16 oduPackPointer ARGS((PTR ptr, Buffer *mBuf));
EXTERN S16 cmPkEntityId ARGS((EntityId *entityId, Buffer *mBuf));
EXTERN S16 cmPkElmntId ARGS((ElmntId *elmntId, Buffer *mBuf));
EXTERN S16 cmPkMemoryId ARGS((MemoryId *memoryId, Buffer *mBuf));
/* system services structures */
EXTERN S16 cmUnpkDateTime ARGS((DateTime *dateTime, Buffer *mBuf));
EXTERN S16 cmUnpkDuration ARGS((Duration *duration, Buffer *mBuf));
-EXTERN S16 cmUnpkPtr ARGS((PTR *ptr, Buffer *mBuf));
+EXTERN S16 oduUnpackPointer ARGS((PTR *ptr, Buffer *mBuf));
EXTERN S16 cmUnpkEntityId ARGS((EntityId *entityId, Buffer *mBuf));
EXTERN S16 cmUnpkElmntId ARGS((ElmntId *elmntId, Buffer *mBuf));
EXTERN S16 cmUnpkMemoryId ARGS((MemoryId *memoryId, Buffer *mBuf));
(ErrVal)EKWU001, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, spId, mBuf, EKWU002, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU003, pst);
pst->event = (Event) KWU_EVT_BND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)EKWU004, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
- CMCHKPKLOG(SPkU8, status, mBuf, EKWU005, pst);
+ CMCHKPKLOG(oduUnpackUInt8, status, mBuf, EKWU005, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
pst->event = (Event) KWU_EVT_BND_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)EKWU007, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
CMCHKPKLOG(SPkS16, reason, mBuf, EKWU008, pst);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU009, pst);
pst->event = (Event) KWU_EVT_UBND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuUbndReq */
#ifdef ANSI
case CM_LTE_LCH_PCCH:
CMCHKPK(cmPkLteTimingInfo, ¶m->tm.tmg, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8, param->emtcDiReason,mBuf);
- CMCHKPK(SPkU8, param->pnb,mBuf);
+ CMCHKPK(oduUnpackUInt8, param->emtcDiReason,mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pnb,mBuf);
#endif
break;
case CM_LTE_LCH_DTCH:
case CM_LTE_LCH_DCCH:
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
#endif
- CMCHKPK(SPkU32, param->sduId, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkKwuDatReqInfo */
\f
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
- CMCHKPK(cmPkPtr,(PTR)datReqInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datReqInfo, mBuf);
}
else
{
- CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datReq, mBuf);
}
}
break;
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDatReqInfo( (datReq), mBuf);
sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef L2_L3_SPLIT
#else
pst->event = (Event) KWU_EVT_DAT_REQ;
#endif
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
#else
if (pst->srcEnt == ENTPJ)
{
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
}
break;
case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datReq, mBuf);
}
break;
#endif /* LCKWU */
sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ret1);
+ return (ret1);
#endif
} /* cmPkKwuDatReq */
{
TRC3(cmPkKwuDatIndInfo);
- CMCHKPK(SPkU8, param->isOutOfSeq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
#ifdef CCPU_OPT
CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
#endif
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
- CMCHKPK(cmPkPtr,(PTR)datIndInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf);
}
break;
case ODU_SELECTOR_LC:
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU012, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDatIndInfo( (datInd), mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) KWU_EVT_DAT_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDatInd */
\f
TRC3(cmPkKwuDatCfmInfo);
for(iter = 0; iter < param->numSduIds; iter++)
{
- CMCHKPK(SPkU32, param->sduIds[iter], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduIds[iter], mBuf);
}
- CMCHKPK(SPkU32, param->numSduIds, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numSduIds, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkKwuDatCfmInfo */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR)datCfm, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)datCfm, mBuf);
}
break;
case ODU_SELECTOR_LC:
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU014, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDatCfmInfo( (datCfm), mBuf);
sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU015, pst);
pst->event = (Event) KWU_EVT_DAT_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDatCfm */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
- CMCHKPK(cmPkPtr,(PTR)discSduInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf);
}
break;
case ODU_SELECTOR_LC:
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU016, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDiscSduInfo( (discSdu), mBuf);
CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst);
pst->event = (Event) KWU_EVT_DISC_SDU_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDiscSduReq */
\f
for (i = (param->numSdu - 1); i >= 0; i--)
{
- CMCHKPK(SPkU32, param->sduId[(U16)i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduId[(U16)i], mBuf);
}
- CMCHKPK(SPkU32, param->numSdu, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numSdu, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
{
TRC3(cmPkKwuFlowCntrlIndInfo);
- CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkKwuFlowCntrlIndInfo */
#ifdef ANSI
TRC3(cmUnpkKwuFlowCntrlIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->pktAdmitCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkKwuFlowCntrlIndInfo */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) staInd, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) staInd, mBuf);
}
break;
case ODU_SELECTOR_LC:
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuStaIndInfo( (staInd), mBuf);
sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
pst->event = (Event) KWU_EVT_STA_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuStaInd */
\f
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkLteRlcId( &rlcId, mBuf);
CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
pst->event = (Event) KWU_EVT_REEST_CMP_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuReEstCmpInd */
/* kwu_c_001.main_3 added support for L2 Measurement */
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(pst->selector)
{
case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR)discCfmSdu, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)discCfmSdu, mBuf);
}
break;
case ODU_SELECTOR_LC:
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, spId, mBuf, ERRKWU, pst);
pst->event = (Event) KWU_EVT_DISC_SDU_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDiscSduCfm */
\f
#ifdef ANSI
pst->pool,
(Data *)flowCntrlIndInfo,
sizeof(KwuFlowCntrlIndInfo),0);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LCKWU
switch(pst->selector)
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
break;
case ODU_SELECTOR_LWLC:
{
- CMCHKPK(cmPkPtr,(PTR) flowCntrlIndInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) flowCntrlIndInfo, mBuf);
}
break;
}
CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
pst->event = (Event) KWU_EVT_FLOW_CNTRL_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
TRC3(cmPkKwuDatAckIndInfo);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKPK(SPkU32, param->sduId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
+ return ROK;
}
#ifdef ANSI
mBuf = NULLP;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret1 = cmPkKwuDatAckInfo( (datInd), mBuf);
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
pst->event = (Event) KWU_EVT_DAT_ACK_IND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
} /* cmPkKwuDatAckInd */
#endif /* LTE_L2_MEAS */
CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
TRC3(cmUnpkKwuBndCfm)
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
- CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EKWU023, pst);
+ CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EKWU023, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
} /* cmUnpkKwuUbndReq */
\f
TRC3(cmUnpkKwuDatReqInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
#ifdef CCPU_OPT
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
case CM_LTE_LCH_BCCH:
case CM_LTE_LCH_PCCH:
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8,¶m->pnb , mBuf);
- CMCHKUNPK(SUnpkU8,¶m->emtcDiReason , mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->pnb , mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->emtcDiReason , mBuf);
#endif
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->tm.tmg, mBuf);
case CM_LTE_LCH_DCCH:
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
{
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &datReq, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &datReq, mBuf);
}
break;
case ODU_SELECTOR_LC:
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU027, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmUnpkKwuDatReqInfo( (datReq), mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
retVal = (*func)(pst, datReq, mBuf);
retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY);
}
- RETVALUE(retVal);
+ return (retVal);
} /* cmUnpkKwuDatReq */
\f
#ifdef CCPU_OPT
CMCHKUNPK(cmUnpkLteRnti, ¶m->tCrnti, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->isOutOfSeq, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isOutOfSeq, mBuf);
+ return ROK;
}
\f
{
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &datInd, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &datInd, mBuf);
}
break;
case ODU_SELECTOR_LC:
(ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
}
else
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU029, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
retVal = (*func)(pst, datInd, mBuf);
/* If LWLC is configured and the destination entity is PDCP, we need to
retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
}
- RETVALUE(retVal);
+ return (retVal);
} /* cmUnpkKwuDatInd */
\f
TRC3(cmUnpkKwuDatCfmInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numSduIds, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numSduIds, mBuf);
#ifdef L2_L3_SPLIT /*Work Around */
if (param->numSduIds >= KWU_MAX_DAT_CFM)
#endif
for(iter = param->numSduIds -1; iter >= 0 ; iter--)
{
- CMCHKUNPK(SUnpkU32, ¶m->sduIds[iter], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduIds[iter], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
{
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &datCfm, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &datCfm, mBuf);
}
break;
case ODU_SELECTOR_LC:
(ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU031, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, datCfm));
+ return ((*func)(pst, suId, datCfm));
} /* cmUnpkKwuDatCfm */
\f
{
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf);
}
break;
case ODU_SELECTOR_LC:
(ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU033, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
break;
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, discSdu));
+ return ((*func)(pst, spId, discSdu));
} /* cmUnpkKwuDiscSduReq */
\f
TRC3(cmUnpkKwuStaIndInfo);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numSdu, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numSdu, mBuf);
for (i = 0; i < param->numSdu; i++)
{
- CMCHKUNPK(SUnpkU32, ¶m->sduId[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduId[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkKwuStaIndInfo */
\f
{
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *)&staInd, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *)&staInd, mBuf);
}
break;
case ODU_SELECTOR_LC:
(ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, staInd));
+ return ((*func)(pst, suId, staInd));
} /* cmUnpkKwuStaInd */
\f
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#else
cmUnpkLteRlcId( &rlcId, mBuf);
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, rlcId));
+ return ((*func)(pst, suId, rlcId));
} /* cmUnpkKwuReEstCmpInd */
/* kwu_c_001.main_3 added support for L2 Measurement */
{
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf);
}
break;
case ODU_SELECTOR_LC:
(ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, discSdu));
+ return ((*func)(pst, spId, discSdu));
} /* cmUnpkKwuDiscSduCfm */
#ifdef ANSI
PUBLIC S16 cmUnpkKwuFlowCntrlInd
sizeof(KwuFlowCntrlIndInfo),0) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf);
case ODU_SELECTOR_LWLC:
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInfo, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInfo, mBuf);
}
break;
#endif
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, flowCntrlInfo));
+ return ((*func)(pst, suId, flowCntrlInfo));
} /* cmUnpkKwuFlowCntrlInd */
#ifdef LTE_L2_MEAS
\f
{
TRC3(cmUnpkKwuDatAckInfo);
- CMCHKUNPK(SUnpkU32, ¶m->sduId, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->sduId, mBuf);
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
(ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
(ErrVal)ERRKWU, (ErrVal)ret1, "Unpacking failure");
- RETVALUE( ret1 );
+ return ( ret1 );
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE((*func)(pst, suId, datInd));
+ return ((*func)(pst, suId, datInd));
} /* cmUnpkKwuDatAckInd */
#endif /* LTE_L2_MEAS */
#endif /* LCKWU */
* RFAILED - failure
*
******************************************************************/
-S16 packEgtpCfmStatus(CmStatus cfm, Buffer *mBuf)
+uint8_t packEgtpCfmStatus(CmStatus cfm, Buffer *mBuf)
{
- SPkU16(cfm.status, mBuf);
- SPkU16(cfm.reason, mBuf);
+ oduUnpackUInt16(cfm.status, mBuf);
+ oduUnpackUInt16(cfm.reason, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
*
******************************************************************/
-S16 unpackEgtpCfmStatus(CmStatus *cfm, Buffer *mBuf)
+uint8_t unpackEgtpCfmStatus(CmStatus *cfm, Buffer *mBuf)
{
- SUnpkU16(&(cfm->reason), mBuf);
- SUnpkU16(&(cfm->status), mBuf);
+ oduPackUInt16(&(cfm->reason), mBuf);
+ oduPackUInt16(&(cfm->status), mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
******************************************************************/
-S16 packEgtpCfgReq(Pst *pst, EgtpConfig egtpCfg)
+uint8_t packEgtpCfgReq(Pst *pst, EgtpConfig egtpCfg)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(egtpCfg.localIp.ipV4Pres)
{
- SPkU32(egtpCfg.localIp.ipV4Addr, mBuf);
+ oduUnpackUInt32(egtpCfg.localIp.ipV4Addr, mBuf);
}
- cmPkBool(egtpCfg.localIp.ipV4Pres, mBuf);
- SPkU16(egtpCfg.localPort, mBuf);
+ oduPackBool(egtpCfg.localIp.ipV4Pres, mBuf);
+ oduUnpackUInt16(egtpCfg.localPort, mBuf);
if(egtpCfg.destIp.ipV4Pres)
{
- SPkU32(egtpCfg.destIp.ipV4Addr, mBuf);
+ oduUnpackUInt32(egtpCfg.destIp.ipV4Addr, mBuf);
}
- cmPkBool(egtpCfg.destIp.ipV4Pres, mBuf);
- SPkU16(egtpCfg.destPort, mBuf);
+ oduPackBool(egtpCfg.destIp.ipV4Pres, mBuf);
+ oduUnpackUInt16(egtpCfg.destPort, mBuf);
- SPkU32(egtpCfg.minTunnelId, mBuf);
- SPkU32(egtpCfg.maxTunnelId, mBuf);
+ oduUnpackUInt32(egtpCfg.minTunnelId, mBuf);
+ oduUnpackUInt32(egtpCfg.maxTunnelId, mBuf);
- SPstTsk(pst, mBuf);
+ ODU_POST_TASK(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 unpackEgtpCfgReq(EgtpCfgReq func, Pst *pst, Buffer *mBuf)
+uint8_t unpackEgtpCfgReq(EgtpCfgReq func, Pst *pst, Buffer *mBuf)
{
EgtpConfig egtpCfg;
- cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig));
+ memset((uint8_t *)&egtpCfg, 0, sizeof(EgtpConfig));
- SUnpkU32(&(egtpCfg.maxTunnelId), mBuf);
- SUnpkU32(&(egtpCfg.minTunnelId), mBuf);
+ oduPackUInt32(&(egtpCfg.maxTunnelId), mBuf);
+ oduPackUInt32(&(egtpCfg.minTunnelId), mBuf);
- SUnpkU16(&(egtpCfg.destPort), mBuf);
- cmUnpkBool(&(egtpCfg.destIp.ipV4Pres), mBuf);
+ oduPackUInt16(&(egtpCfg.destPort), mBuf);
+ oduUnpackBool(&(egtpCfg.destIp.ipV4Pres), mBuf);
if(egtpCfg.destIp.ipV4Pres)
{
- SUnpkU32(&(egtpCfg.destIp.ipV4Addr), mBuf);
+ oduPackUInt32(&(egtpCfg.destIp.ipV4Addr), mBuf);
}
- SUnpkU16(&(egtpCfg.localPort), mBuf);
- cmUnpkBool(&(egtpCfg.localIp.ipV4Pres), mBuf);
+ oduPackUInt16(&(egtpCfg.localPort), mBuf);
+ oduUnpackBool(&(egtpCfg.localIp.ipV4Pres), mBuf);
if(egtpCfg.localIp.ipV4Pres)
{
- SUnpkU32(&(egtpCfg.localIp.ipV4Addr), mBuf);
+ oduPackUInt32(&(egtpCfg.localIp.ipV4Addr), mBuf);
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
- RETVALUE((*func)(pst, egtpCfg));
+ return ((*func)(pst, egtpCfg));
}
*
******************************************************************/
-S16 packEgtpCfgCfm(Pst *pst, CmStatus cfm)
+uint8_t packEgtpCfgCfm(Pst *pst, CmStatus cfm)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nEGTP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
packEgtpCfmStatus(cfm, mBuf);
- SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ ODU_POST_TASK(pst, mBuf);
+ return ROK;
}
/*******************************************************************
*
******************************************************************/
-S16 unpackEgtpCfgCfm(EgtpCfgCfm func, Buffer *mBuf)
+uint8_t unpackEgtpCfgCfm(EgtpCfgCfm func, Buffer *mBuf)
{
CmStatus cfm;
- cmMemset((U8 *)&cfm, 0, sizeof(CmStatus));
+ memset((uint8_t *)&cfm, 0, sizeof(CmStatus));
unpackEgtpCfmStatus(&cfm, mBuf);
- RETVALUE((*func)(cfm));
+ return ((*func)(cfm));
}
/*******************************************************************
* RFAILED - failure
*
*******************************************************************/
-S16 packEgtpSrvOpenReq(Pst *pst)
+uint8_t packEgtpSrvOpenReq(Pst *pst)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ ODU_POST_TASK(pst, mBuf);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
******************************************************************/
-S16 unpackEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf)
+uint8_t unpackEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf)
{
- RETVALUE((*func)(pst));
+ return ((*func)(pst));
}
* RFAILED - failure
*
*******************************************************************/
-S16 packEgtpSrvOpenCfm(Pst *pst, CmStatus cfm)
+uint8_t packEgtpSrvOpenCfm(Pst *pst, CmStatus cfm)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nEGTP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
packEgtpCfmStatus(cfm, mBuf);
- SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ ODU_POST_TASK(pst, mBuf);
+ return ROK;
}
* RFAILED - failure
*
*******************************************************************/
-S16 unpackEgtpSrvOpenCfm(EgtpSrvOpenCfm func, Buffer *mBuf)
+uint8_t unpackEgtpSrvOpenCfm(EgtpSrvOpenCfm func, Buffer *mBuf)
{
CmStatus cfm;
- cmMemset((U8 *)&cfm, 0, sizeof(CmStatus));
+ memset((uint8_t *)&cfm, 0, sizeof(CmStatus));
unpackEgtpCfmStatus(&cfm, mBuf);
- RETVALUE((*func)(cfm));
+ return ((*func)(cfm));
}
/*******************************************************************
* RFAILED - failure
*
*******************************************************************/
-S16 packEgtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt)
+uint8_t packEgtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- SPkU8(tnlEvt.action, mBuf);
- SPkU32(tnlEvt.lclTeid, mBuf);
- SPkU32(tnlEvt.remTeid, mBuf);
+ oduUnpackUInt8(tnlEvt.action, mBuf);
+ oduUnpackUInt32(tnlEvt.lclTeid, mBuf);
+ oduUnpackUInt32(tnlEvt.remTeid, mBuf);
- SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ ODU_POST_TASK(pst, mBuf);
+ return ROK;
}
* RFAILED - failure
*
* *******************************************************************/
-S16 unpackEgtpTnlMgmtReq(EgtpTnlMgmtReq func, Pst *pst, Buffer *mBuf)
+uint8_t unpackEgtpTnlMgmtReq(EgtpTnlMgmtReq func, Pst *pst, Buffer *mBuf)
{
EgtpTnlEvt tnlEvt;
- cmMemset((U8 *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
+ memset((uint8_t *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
- SUnpkU32(&(tnlEvt.remTeid), mBuf);
- SUnpkU32(&(tnlEvt.lclTeid), mBuf);
- SUnpkU8(&(tnlEvt.action), mBuf);
+ oduPackUInt32(&(tnlEvt.remTeid), mBuf);
+ oduPackUInt32(&(tnlEvt.lclTeid), mBuf);
+ oduPackUInt8(&(tnlEvt.action), mBuf);
- RETVALUE((* func)(pst, tnlEvt));
+ return ((* func)(pst, tnlEvt));
}
*
********************************************************************/
-S16 packEgtpTnlMgmtCfm(Pst *pst, EgtpTnlEvt tnlEvt)
+uint8_t packEgtpTnlMgmtCfm(Pst *pst, EgtpTnlEvt tnlEvt)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nEGTP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- SPkU8(tnlEvt.action, mBuf);
- SPkU32(tnlEvt.lclTeid, mBuf);
- SPkU32(tnlEvt.remTeid, mBuf);
+ oduUnpackUInt8(tnlEvt.action, mBuf);
+ oduUnpackUInt32(tnlEvt.lclTeid, mBuf);
+ oduUnpackUInt32(tnlEvt.remTeid, mBuf);
packEgtpCfmStatus(tnlEvt.cfmStatus, mBuf);
- SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ ODU_POST_TASK(pst, mBuf);
+ return ROK;
}
* RFAILED - failure
*
* *******************************************************************/
-S16 unpackEgtpTnlMgmtCfm(EgtpTnlMgmtCfm func, Buffer *mBuf)
+uint8_t unpackEgtpTnlMgmtCfm(EgtpTnlMgmtCfm func, Buffer *mBuf)
{
EgtpTnlEvt tnlEvt;
- cmMemset((U8 *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
+ memset((uint8_t *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
unpackEgtpCfmStatus(&(tnlEvt.cfmStatus), mBuf);
- SUnpkU32(&(tnlEvt.remTeid), mBuf);
- SUnpkU32(&(tnlEvt.lclTeid), mBuf);
- SUnpkU8(&(tnlEvt.action), mBuf);
+ oduPackUInt32(&(tnlEvt.remTeid), mBuf);
+ oduPackUInt32(&(tnlEvt.lclTeid), mBuf);
+ oduPackUInt8(&(tnlEvt.action), mBuf);
- RETVALUE((* func)(tnlEvt));
+ return ((* func)(tnlEvt));
}
* RFAILED - failure
*
*******************************************************************/
-S16 packEgtpSlotInd(Pst *pst)
+uint8_t packEgtpSlotInd(Pst *pst)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, pst->pool, &mBuf) != ROK)
{
printf("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ ODU_POST_TASK(pst, mBuf);
+ return ROK;
}
* RFAILED - failure
*
******************************************************************/
-S16 unpackEgtpSlotInd(EgtpSlotInd func, Pst *pst, Buffer *mBuf)
+uint8_t unpackEgtpSlotInd(EgtpSlotInd func, Pst *pst, Buffer *mBuf)
{
- RETVALUE((*func)());
+ return ((*func)());
}
typedef struct egtpIpAddr
{
- Bool ipV4Pres;
- U32 ipV4Addr;
+ Bool ipV4Pres;
+ uint32_t ipV4Addr;
}EgtpIpAddr;
typedef struct egtpConfig
{
EgtpIpAddr localIp;
- U16 localPort;
+ uint16_t localPort;
EgtpIpAddr destIp;
- U16 destPort;
- U32 minTunnelId;
- U32 maxTunnelId;
+ uint16_t destPort;
+ uint32_t minTunnelId;
+ uint32_t maxTunnelId;
}EgtpConfig;
typedef struct egtpTnlEvt
{
- U8 action;
- U32 lclTeid;
- U32 remTeid;
+ uint8_t action;
+ uint32_t lclTeid;
+ uint32_t remTeid;
CmStatus cfmStatus;
}EgtpTnlEvt;
TknU8 nPdu; /**< N-PDU Number */
TknU32 seqNum; /**< Sequence Number */
EgtpExtHdr extHdr; /**< Extension headers present flag */
- U32 teId; /**< Tunnel Endpoint Id */
- U8 msgType; /**< eGTP-U Message Type */
+ uint32_t teId; /**< Tunnel Endpoint Id */
+ uint8_t msgType; /**< eGTP-U Message Type */
}EgtpMsgHdr;
typedef struct egtpMsg
Buffer *msg;
}EgtpMsg;
-typedef S16 (*EgtpCfgReq) ARGS((Pst *pst, EgtpConfig egtpCfg));
-typedef S16 (*EgtpCfgCfm) ARGS((CmStatus cfm));
-typedef S16 (*EgtpInitReq) ARGS((Buffer *mBuf));
-typedef S16 (*EgtpSrvOpenReq) ARGS(());
-typedef S16 (*EgtpSrvOpenCfm) ARGS((CmStatus cfm));
-typedef S16 (*EgtpTnlMgmtReq) ARGS((Pst *pst, EgtpTnlEvt tnlEvt));
-typedef S16 (*EgtpTnlMgmtCfm) ARGS((EgtpTnlEvt tnlEvt));
-typedef S16 (*EgtpSlotInd) ARGS(());
+typedef uint8_t (*EgtpCfgReq) ARGS((Pst *pst, EgtpConfig egtpCfg));
+typedef uint8_t (*EgtpCfgCfm) ARGS((CmStatus cfm));
+typedef uint8_t (*EgtpInitReq) ARGS((Buffer *mBuf));
+typedef uint8_t (*EgtpSrvOpenReq) ARGS(());
+typedef uint8_t (*EgtpSrvOpenCfm) ARGS((CmStatus cfm));
+typedef uint8_t (*EgtpTnlMgmtReq) ARGS((Pst *pst, EgtpTnlEvt tnlEvt));
+typedef uint8_t (*EgtpTnlMgmtCfm) ARGS((EgtpTnlEvt tnlEvt));
+typedef uint8_t (*EgtpSlotInd) ARGS(());
-S16 packEgtpCfgReq(Pst *pst, EgtpConfig egtpCfg);
-S16 unpackEgtpCfgReq(EgtpCfgReq func , Pst *pst, Buffer *mBuf);
-S16 packEgtpCfgCfm(Pst *pst, CmStatus cfm);
-S16 unpackEgtpCfgCfm(EgtpCfgCfm func, Buffer *mBuf);
-S16 packEgtpSrvOpenReq(Pst *pst);
-S16 unpackkEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf);
-S16 packEgtpSrvOpenCfm(Pst *pst, CmStatus cfm);
-S16 unpackEgtpSrvOpenCfm(EgtpSrvOpenCfm func, Buffer *mBuf);
-S16 packEgtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt);
-S16 unpackEgtpTnlMgmtReq(EgtpTnlMgmtReq func, Pst *pst, Buffer *mBuf);
-S16 packEgtpTnlMgmtCfm(Pst *pst, EgtpTnlEvt tnlEvt);
-S16 unpackEgtpTnlMgmtCfm(EgtpTnlMgmtCfm func, Buffer *mBuf);
-S16 packEgtpSlotInd(Pst *pst);
-S16 unpackEgtpSlotInd(EgtpSlotInd func, Pst *pst, Buffer *mBuf);
+uint8_t packEgtpCfgReq(Pst *pst, EgtpConfig egtpCfg);
+uint8_t unpackEgtpCfgReq(EgtpCfgReq func , Pst *pst, Buffer *mBuf);
+uint8_t packEgtpCfgCfm(Pst *pst, CmStatus cfm);
+uint8_t unpackEgtpCfgCfm(EgtpCfgCfm func, Buffer *mBuf);
+uint8_t packEgtpSrvOpenReq(Pst *pst);
+uint8_t unpackkEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf);
+uint8_t packEgtpSrvOpenCfm(Pst *pst, CmStatus cfm);
+uint8_t unpackEgtpSrvOpenCfm(EgtpSrvOpenCfm func, Buffer *mBuf);
+uint8_t packEgtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt);
+uint8_t unpackEgtpTnlMgmtReq(EgtpTnlMgmtReq func, Pst *pst, Buffer *mBuf);
+uint8_t packEgtpTnlMgmtCfm(Pst *pst, EgtpTnlEvt tnlEvt);
+uint8_t unpackEgtpTnlMgmtCfm(EgtpTnlMgmtCfm func, Buffer *mBuf);
+uint8_t packEgtpSlotInd(Pst *pst);
+uint8_t unpackEgtpSlotInd(EgtpSlotInd func, Pst *pst, Buffer *mBuf);
#endif
"SGetMsg failed ...!\n");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmPkKwMngmt(cfg, LKW_EVT_CFG_REQ, mBuf);
"cmPkKwMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_CFG_REQ; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of packRlcConfigReq */
"cmUnpkKwMngmt failure ......!");
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
(Void) (*func)(pst, &cfg);
- RETVALUE(ROK);
+ return ROK;
} /* end of unpackRlcConfigReq */
"SGetMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmPkKwMngmt(cntrl, LKW_EVT_CNTRL_REQ, mBuf);
"cmPkKwMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
pst->event = (Event) LKW_EVT_CNTRL_REQ; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwCntrlReq */
"cmUnpkKwMngmt failure ......!");
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
} /* end of cmUnpkLkwCntrlReq */
"SGetMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmPkKwMngmt(cfm, LKW_EVT_CNTRL_CFM, mBuf);
"Packing failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_CNTRL_CFM; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwCntrlCfm */
"cmUnpkKwMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
} /* end of cmUnpkLkwCntrlCfm */
"SPutMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, 0, &cfm));
+ return ((*func)(pst, 0, &cfm));
} /* end of cmUnpkLkwStsCfm */
"SGetMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmPkKwMngmt(cfm, LKW_EVT_CFG_CFM, mBuf);
"SPutMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_CFG_CFM; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of packRlcConfigCfm */
"SPutMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
} /* end of unpackRlcConfigCfm */
"SGetMsg() failed");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
ret1 = cmPkKwMngmt(usta, LKW_EVT_STA_IND, mBuf);
"cmPkKwMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret1);
+ return (ret1);
}
pst->event = (Event) LKW_EVT_STA_IND; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwStaInd */
"cmUnpkKwMngmt failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &usta));
+ return ((*func)(pst, &usta));
} /* end of cmUnpkLsnStaInd */
/**
"SGetMsg failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret1 = cmPkKwMngmt(sta, LKW_EVT_STA_REQ, mBuf);
"SGetMsg() failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_STA_REQ; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwStaReq */
"Unpacking failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
} /* end of function cmUnpkLkwStaCfm */
"Unpacking failure ......!");
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, action, &sts));
+ return ((*func)(pst, action, &sts));
} /* end of function cmUnpkLkwStsReq */
"Unpacking failure ......!");
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &sta));
+ return ((*func)(pst, &sta));
} /* end of function cmUnpkLkwStaReq */
"Unpacking failure ......!");
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
- RETVALUE(RFAILED);
+ return RFAILED;
}
(Void) (*func)(pst, &trc, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkLkwTrcInd */
CMCHKPK(cmPkState, rcSap->state, mBuf);
CMCHKPK(SPkS16, rcSap->spId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCkwSapSta */
CMCHKUNPK(SUnpkS16, &rcSap->spId, mBuf);
CMCHKUNPK(cmUnpkState, &rcSap->state, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of function cmUnpkCkwSapSta */
/**
CMCHKPK(cmPkState, rlSap->state, mBuf);
CMCHKPK(SPkS16, rlSap->spId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkKwuSapSta */
CMCHKUNPK(SUnpkS16, &rlSap->spId, mBuf);
CMCHKUNPK(cmUnpkState, &rlSap->state, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of function cmUnpkKwuSapSta */
CMCHKPK(cmPkState, mkSap->state, mBuf);
CMCHKPK(cmPkSuId, mkSap->suId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkRguSapSta */
CMCHKUNPK(cmUnpkSuId, &mkSap->suId, mBuf);
CMCHKUNPK(cmUnpkState, &mkSap->state, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of function cmUnpkRguSapSta */
"SGetMsg() failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret1 = cmPkKwMngmt(cfm, LKW_EVT_STA_CFM, mBuf);
"packing failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_STA_CFM; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwStaCfm */
"SGetMsg() failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (trcBuf)
"SGetMsg() failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(trcBuf);
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
/* log error */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_TRC_IND; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwTrcInd */
"SGetMsg() failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret1 = cmPkKwMngmt(sts, LKW_EVT_STS_REQ, mBuf);
"Packing failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(SPkS16, action, mBuf);
pst->event = (Event) LKW_EVT_STS_REQ; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwStsReq */
"SGetMsg() failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret1 = cmPkKwMngmt(cfm, LKW_EVT_STS_CFM, mBuf);
"Packing failure ......!");
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_STS_CFM; /* event */
SPstTsk(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkLkwStsCfm */
ret1 = cmPkRlcCfg(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmPkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmPkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmPkKwSsta(param, param->hdr.elmId.elmnt , eventType, mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmPkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case LKW_EVT_TRC_IND:
ret1 = cmPkKwTrc(param, mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case LKW_EVT_CNTRL_CFM:
CMCHKPK(cmPkCmStatus, ¶m->cfm, mBuf);
CMCHKPK(cmPkHeader, ¶m->hdr, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of function cmPkKwMngmt */
{
case STGEN:
{
- CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxRguSaps, mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.gen.rlcMode, mBuf);
- CMCHKPK(SPkU32, cfg->t.cfg.s.gen.timeRes, mBuf);
- CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
- CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
- CMCHKPK(SPkU32, cfg->t.cfg.s.gen.maxUe, mBuf);
+ CMCHKPK(oduUnpackUInt16, cfg->t.cfg.s.gen.maxRguSaps, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.gen.rlcMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, cfg->t.cfg.s.gen.timeRes, mBuf);
+ CMCHKPK(oduUnpackUInt16, cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
+ CMCHKPK(oduUnpackUInt16, cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
+ CMCHKPK(oduUnpackUInt32, cfg->t.cfg.s.gen.maxUe, mBuf);
CMCHKPK(cmPkPst, &cfg->t.cfg.s.gen.lmPst,mBuf);
break;
case STUDXSAP:
case STRGUSAP:
{
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.route,mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.priority,mBuf);
- CMCHKPK(SPkU16, cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.route,mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.priority,mBuf);
+ CMCHKPK(oduUnpackUInt16, cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
CMCHKPK(SPkS16, cfg->t.cfg.s.sap.sapId, mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.inst, mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.ent, mBuf);
- CMCHKPK(SPkU16, cfg->t.cfg.s.sap.procId, mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.mem.pool, mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.mem.region, mBuf);
- CMCHKPK(SPkU8, cfg->t.cfg.s.sap.selector, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.inst, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.ent, mBuf);
+ CMCHKPK(oduUnpackUInt16, cfg->t.cfg.s.sap.procId, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.mem.pool, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.mem.region, mBuf);
+ CMCHKPK(oduUnpackUInt8, cfg->t.cfg.s.sap.selector, mBuf);
break;
}
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /*end of function cmPkRlcCfg*/
break;
case SADBG:
{
- CMCHKPK(SPkU32, cntrl->t.cntrl.s.dbgCntrl.dbgMask,
+ CMCHKPK(oduUnpackUInt32, cntrl->t.cntrl.s.dbgCntrl.dbgMask,
mBuf);
}
break;
{
CMCHKPK(SPkS16, cntrl->t.cntrl.s.trcCntrl.trcLen,
mBuf);
- CMCHKPK(SPkU8, cntrl->t.cntrl.s.trcCntrl.trcMask,
+ CMCHKPK(oduUnpackUInt8, cntrl->t.cntrl.s.trcCntrl.trcMask,
mBuf);
}
break;
#ifdef SS_DIAG
case SALOG:
{
- CMCHKPK(SPkU32, cntrl->t.cntrl.s.logMask, mBuf);
+ CMCHKPK(oduUnpackUInt32, cntrl->t.cntrl.s.logMask, mBuf);
}
break;
#endif
break;
}
- CMCHKPK(SPkU8, cntrl->t.cntrl.action, mBuf);
- CMCHKPK(SPkU8, cntrl->t.cntrl.subAction, mBuf);
+ CMCHKPK(oduUnpackUInt8, cntrl->t.cntrl.action, mBuf);
+ CMCHKPK(oduUnpackUInt8, cntrl->t.cntrl.subAction, mBuf);
CMCHKPK(cmPkDateTime, &cntrl->t.cntrl.dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /*end of function cmPkKwCntrl */
/**
UNUSED(elmnt);
/* lkw_c_001.main_2 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- CMCHKPK(SPkU8, usta->t.usta.qci, mBuf);
+ CMCHKPK(oduUnpackUInt8, usta->t.usta.qci, mBuf);
#endif
- CMCHKPK(SPkU32, usta->t.usta.ueId, mBuf);
+ CMCHKPK(oduUnpackUInt32, usta->t.usta.ueId, mBuf);
CMCHKPK(SPkS16, usta->t.usta.suId, mBuf);
CMCHKPK(cmPkCmAlarm, &usta->t.usta.alarm,mBuf);
CMCHKPK(cmPkDateTime, &usta->t.usta.dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkKwUsta */
if(ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkDateTime, &ssta->t.ssta.dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkKwSsta */
{
TRC3(cmPkKwTrc)
- CMCHKPK(SPkU16, trc->t.trc.event, mBuf);
+ CMCHKPK(oduUnpackUInt16, trc->t.trc.event, mBuf);
CMCHKPK(cmPkDateTime, &trc->t.trc.dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkKwTrc */
if(ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkDateTime, &sts->t.sts.dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkKwSts */
{
TRC3(cmPkGenSts)
- CMCHKPK(SPkU32, gen->numSduDisc, mBuf);
- CMCHKPK(SPkU32, gen->numOfRb, mBuf);
- CMCHKPK(SPkU32, gen->protTimeOut, mBuf);
- CMCHKPK(SPkU32, gen->errorPdusRecv, mBuf);
- CMCHKPK(SPkU32, gen->unexpPdusRecv, mBuf);
- CMCHKPK(SPkU32, gen->bytesSent, mBuf);
- CMCHKPK(SPkU32, gen->bytesRecv, mBuf);
- CMCHKPK(SPkU32, gen->pdusRetx, mBuf);
- CMCHKPK(SPkU32, gen->pdusSent, mBuf);
- CMCHKPK(SPkU32, gen->pdusRecv, mBuf);
- CMCHKPK(SPkU32, gen->numUe, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->numSduDisc, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->numOfRb, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->protTimeOut, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->errorPdusRecv, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->unexpPdusRecv, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->bytesSent, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->bytesRecv, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->pdusRetx, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->pdusSent, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->pdusRecv, mBuf);
+ CMCHKPK(oduUnpackUInt32, gen->numUe, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkGenSts */
{
TRC3(cmPkCkwSapSts)
- CMCHKPK(SPkU32, rcSap->statMsgs, mBuf);
+ CMCHKPK(oduUnpackUInt32, rcSap->statMsgs, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCkwSapSts */
/**
{
TRC3(cmPkCkwSapSts)
- CMCHKPK(SPkU32, ruSap->sduTx, mBuf);
- CMCHKPK(SPkU32, ruSap->sduRx, mBuf);
+ CMCHKPK(oduUnpackUInt32, ruSap->sduTx, mBuf);
+ CMCHKPK(oduUnpackUInt32, ruSap->sduRx, mBuf);
/* lkw_c_001.main_2 changed from suId to spId */
CMCHKPK(cmPkSuId, ruSap->spId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmPkCkwSapSts */
/* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
ret1 = cmUnpkRlcCfg(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case LKW_EVT_CNTRL_REQ:
ret1 = cmUnpkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmUnpkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmUnpkKwSsta(param, param->hdr.elmId.elmnt, eventType,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
ret1 = cmUnpkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
case LKW_EVT_TRC_IND:
ret1 = cmUnpkKwTrc(param, mBuf);
if (ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
default:
break;
}
- RETVALUE(ROK);
+ return ROK;
} /*end of function cmUnpkKwMngmt*/
/**
case STGEN:
{
CMCHKUNPK(cmUnpkPst, &cfg->t.cfg.s.gen.lmPst,mBuf);
- CMCHKUNPK(SUnpkU32, &cfg->t.cfg.s.gen.maxUe, mBuf);
- CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
- CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
- CMCHKUNPK(SUnpkU32, &cfg->t.cfg.s.gen.timeRes, mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.gen.rlcMode, mBuf);
- CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxRguSaps, mBuf);
+ CMCHKUNPK(oduPackUInt32, &cfg->t.cfg.s.gen.maxUe, mBuf);
+ CMCHKUNPK(oduPackUInt16, &cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
+ CMCHKUNPK(oduPackUInt16, &cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
+ CMCHKUNPK(oduPackUInt32, &cfg->t.cfg.s.gen.timeRes, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.gen.rlcMode, mBuf);
+ CMCHKUNPK(oduPackUInt16, &cfg->t.cfg.s.gen.maxRguSaps, mBuf);
}
break;
case STRGUSAP:
case STUDXSAP:
{
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.selector, mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.mem.region, mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.mem.pool, mBuf);
- CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.sap.procId, mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.ent, mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.inst, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.selector, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.mem.region, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.mem.pool, mBuf);
+ CMCHKUNPK(oduPackUInt16, &cfg->t.cfg.s.sap.procId, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.ent, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.inst, mBuf);
CMCHKUNPK(SUnpkS16, &cfg->t.cfg.s.sap.sapId, mBuf);
- CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.priority,mBuf);
- CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.route,mBuf);
+ CMCHKUNPK(oduPackUInt16, &cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.priority,mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfg->t.cfg.s.sap.route,mBuf);
}
break;
default:
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of switch */
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkRlcCfg */
/**
UNUSED(elmnt);
CMCHKUNPK(cmUnpkDateTime, &cfm->t.cntrl.dt, mBuf);
- CMCHKUNPK(SUnpkU8, &cfm->t.cntrl.subAction, mBuf);
- CMCHKUNPK(SUnpkU8, &cfm->t.cntrl.action, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfm->t.cntrl.subAction, mBuf);
+ CMCHKUNPK(oduPackUInt8, &cfm->t.cntrl.action, mBuf);
subAction = cfm->t.cntrl.subAction;
case SADBG:
{
dbgCntrl = &cfm->t.cntrl.s.dbgCntrl;
- CMCHKUNPK(SUnpkU32, &dbgCntrl->dbgMask, mBuf);
+ CMCHKUNPK(oduPackUInt32, &dbgCntrl->dbgMask, mBuf);
}
break;
case SATRC:
{
trcCntrl = &cfm->t.cntrl.s.trcCntrl;
- CMCHKUNPK(SUnpkU8, &trcCntrl->trcMask, mBuf);
+ CMCHKUNPK(oduPackUInt8, &trcCntrl->trcMask, mBuf);
CMCHKUNPK(SUnpkS16,&trcCntrl->trcLen, mBuf);
}
break;
#ifdef SS_DIAG
case SALOG:
{
- CMCHKUNPK(SUnpkU32, &cfm->t.cntrl.s.logMask, mBuf);
+ CMCHKUNPK(oduPackUInt32, &cfm->t.cntrl.s.logMask, mBuf);
}
break;
#endif
break;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkKwCntrl */
CMCHKUNPK(cmUnpkDateTime, &usta->t.usta.dt, mBuf);
CMCHKUNPK(cmUnpkCmAlarm, &usta->t.usta.alarm,mBuf);
CMCHKUNPK(SUnpkS16, &usta->t.usta.suId, mBuf);
- CMCHKUNPK(SUnpkU32, &usta->t.usta.ueId, mBuf);
+ CMCHKUNPK(oduPackUInt32, &usta->t.usta.ueId, mBuf);
/* lkw_c_001.main_2 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- CMCHKUNPK(SUnpkU8, &usta->t.usta.qci, mBuf);
+ CMCHKUNPK(oduPackUInt8, &usta->t.usta.qci, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
if(ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkKwTrc);
CMCHKUNPK(cmUnpkDateTime, &trc->t.trc.dt, mBuf);
- CMCHKUNPK(SUnpkU16, &trc->t.trc.event, mBuf);
+ CMCHKUNPK(oduPackUInt16, &trc->t.trc.event, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkKwTrc */
if(ret1 != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkKwSts */
{
TRC3(cmUnpkGenSts);
- CMCHKUNPK(SUnpkU32, &gen->numUe, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->pdusRecv, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->pdusSent, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->pdusRetx, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->bytesRecv, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->bytesSent, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->unexpPdusRecv, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->errorPdusRecv, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->protTimeOut, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->numOfRb, mBuf);
- CMCHKUNPK(SUnpkU32, &gen->numSduDisc, mBuf);
-
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, &gen->numUe, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->pdusRecv, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->pdusSent, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->pdusRetx, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->bytesRecv, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->bytesSent, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->unexpPdusRecv, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->errorPdusRecv, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->protTimeOut, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->numOfRb, mBuf);
+ CMCHKUNPK(oduPackUInt32, &gen->numSduDisc, mBuf);
+
+ return ROK;
} /* end of cmUnpkGenSts */
/**
TRC3(cmUnpkCkwSapSts);
- CMCHKUNPK(SUnpkU32, &rcSap->statMsgs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &rcSap->statMsgs, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkCkwSapSts */
/* lkw_c_001.main_2 changed from suId to spId */
CMCHKUNPK(cmUnpkSuId, &ruSap->spId, mBuf);
- CMCHKUNPK(SUnpkU32, &ruSap->sduRx, mBuf);
- CMCHKUNPK(SUnpkU32, &ruSap->sduTx, mBuf);
+ CMCHKUNPK(oduPackUInt32, &ruSap->sduRx, mBuf);
+ CMCHKUNPK(oduPackUInt32, &ruSap->sduTx, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* end of cmUnpkKwuSapSts */
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU16(measReqEvt->measPeriod, mBuf) != ROK) {
+ if (oduUnpackUInt16(measReqEvt->measPeriod, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU32(measReqEvt->transId, mBuf) != ROK) {
+ if (oduUnpackUInt32(measReqEvt->transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_L2MEAS_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
CMCHKPK(cmPkLteRnti, param->val.ipThMeas.ueInfoLst[idx1].ueId, mBuf);
for(idx = 0; idx < param->val.ipThMeas.ueInfoLst[idx1].numQci; idx++)
{
- CMCHKPK(SPkU8, param->val.ipThMeas.ueInfoLst[idx1].qci[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->val.ipThMeas.ueInfoLst[idx1].qci[idx], mBuf);
}
- CMCHKPK(SPkU8, param->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
}
- CMCHKPK(SPkU16, param->val.ipThMeas.numUes, mBuf);
- CMCHKPK(SPkU8, param->measType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->val.ipThMeas.numUes, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->measType, mBuf);
+ return ROK;
}
else
{
for(idx = 0; idx < param->val.nonIpThMeas.numQci; idx++)
{
- CMCHKPK(SPkU8, param->val.nonIpThMeas.qci[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->val.nonIpThMeas.qci[idx], mBuf);
}
- CMCHKPK(SPkU8, param->val.nonIpThMeas.numQci, mBuf);
- CMCHKPK(SPkU16, param->val.nonIpThMeas.numSamples, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->val.nonIpThMeas.numQci, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->val.nonIpThMeas.numSamples, mBuf);
}
- CMCHKPK(SPkU8, param->measType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->measType, mBuf);
+ return ROK;
}
#ifdef ANSI
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, measType, mBuf);
+ CMCHKPK(oduUnpackUInt8, measType, mBuf);
pst->event = (Event) LKW_EVT_L2MEAS_STOP_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, measType, mBuf);
+ CMCHKPK(oduUnpackUInt8, measType, mBuf);
pst->event = (Event) LKW_EVT_L2MEAS_SEND_REQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef TENB_SPLIT_ARCH
#ifdef ANSI
TRC3(cmUnpkLkwL2MeasReq)
- if (SUnpkU32(&measReqEvt.transId, mBuf) != ROK) {
+ if (oduPackUInt32(&measReqEvt.transId, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU16(&measReqEvt.measPeriod, mBuf) != ROK) {
+ if (oduPackUInt16(&measReqEvt.measPeriod, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkKwL2MeasReqInfo(&measReqEvt.measReq, mBuf) != ROK)
{
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measReqEvt));
+ return ((*func)(pst, &measReqEvt));
}
#else
#ifdef ANSI
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "SGetMsg() failed");
#endif /* ERRCLASS & ERRCLS_ADD_RES */
- RETVALUE(ret);
+ return (ret);
}
- if (SUnpkU32(&measReqEvt->transId, mBuf) != ROK) {
+ if (oduPackUInt32(&measReqEvt->transId, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU16(&measReqEvt->measPeriod, mBuf) != ROK) {
+ if (oduPackUInt16(&measReqEvt->measPeriod, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK)
{
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measReqEvt));
+ return ((*func)(pst, measReqEvt));
}
#endif
TRC3(cmUnpkKwL2MeasReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->measType, mBuf);
if((param->measType & LKW_L2MEAS_DL_IP) ||
(param->measType & LKW_L2MEAS_UL_IP))
{
- CMCHKUNPK(SUnpkU16, ¶m->val.ipThMeas.numUes, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->val.ipThMeas.numUes, mBuf);
for(idx1 = 0;idx1 < param->val.ipThMeas.numUes;idx1++)
{
- CMCHKUNPK(SUnpkU8, ¶m->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
for(idx = param->val.ipThMeas.ueInfoLst[idx1].numQci; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU8, ¶m->val.ipThMeas.ueInfoLst[idx1].\
+ CMCHKUNPK(oduPackUInt8, ¶m->val.ipThMeas.ueInfoLst[idx1].\
qci[idx - 1], mBuf);
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->val.ipThMeas.ueInfoLst[idx1].\
CMCHKUNPK(cmUnpkLteCellId, ¶m->val.ipThMeas.\
ueInfoLst[idx1].cellId, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
else
{
- CMCHKUNPK(SUnpkU16, ¶m->val.nonIpThMeas.numSamples, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->val.nonIpThMeas.numQci, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->val.nonIpThMeas.numSamples, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->val.nonIpThMeas.numQci, mBuf);
for(idx = param->val.nonIpThMeas.numQci; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU8, ¶m->val.nonIpThMeas.qci[idx - 1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->val.nonIpThMeas.qci[idx - 1], mBuf);
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
U8 measType;
TRC3(cmUnpkLkwL2MeasReq)
- CMCHKUNPK(SUnpkU8, &measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &measType, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measType));
+ return ((*func)(pst, measType));
}
#ifdef ANSI
TRC3(cmUnpkLkwL2MeasSendReq)
- CMCHKUNPK(SUnpkU8, &measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &measType, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measType));
+ return ((*func)(pst, measType));
}
#ifdef ANSI
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)measCfmEvt, sizeof(KwL2MeasCfmEvt));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((measCfmEvt->measType & LKW_L2MEAS_ACT_UE) || \
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (SPkU16(measCfmEvt->val.nonIpThMeas.numCfm, mBuf) != ROK) {
+ if (oduUnpackUInt16(measCfmEvt->val.nonIpThMeas.numCfm, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- if (SPkU16(measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm, mBuf) != ROK) {
+ if (oduUnpackUInt16(measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteCellId, measCfmEvt->val.ipThMeas.ueInfoLst[idx1].cellId, mBuf);
CMCHKPK(cmPkLteRnti, measCfmEvt->val.ipThMeas.ueInfoLst[idx1].ueId, mBuf);
}
- SPkU16(measCfmEvt->val.ipThMeas.numUes, mBuf);
+ oduUnpackUInt16(measCfmEvt->val.ipThMeas.numUes, mBuf);
}
- CMCHKPK(SPkU8, measCfmEvt->measType, mBuf);
+ CMCHKPK(oduUnpackUInt8, measCfmEvt->measType, mBuf);
CMCHKPK(cmPkCmStatus, &measCfmEvt->status, mBuf);
- if (SPkU32(measCfmEvt->transId, mBuf) != ROK) {
+ if (oduUnpackUInt32(measCfmEvt->transId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) LKW_EVT_L2MEAS_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
{
CMCHKPK(SPkF32, param->val.ipThrput.ulIpThPut, mBuf);
CMCHKPK(SPkF32, param->val.ipThrput.dlIpThPut, mBuf);
- CMCHKPK(SPkU8, param->qci, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
+ return ROK;
}
else
{
- CMCHKPK(SPkU32, param->val.nonIpThrput.dlDiscRate, mBuf);
- CMCHKPK(SPkU32, param->val.nonIpThrput.uuLoss, mBuf);
- CMCHKPK(SPkU32, param->val.nonIpThrput.numActUe, mBuf);
- CMCHKPK(SPkU32, param->val.nonIpThrput.dlSduDelay, mBuf);
- CMCHKPK(SPkU8, param->qci, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->val.nonIpThrput.dlDiscRate, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->val.nonIpThrput.uuLoss, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->val.nonIpThrput.numActUe, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->val.nonIpThrput.dlSduDelay, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
cmMemset((U8 *)&measCfmEvt, 0 , sizeof(KwL2MeasCfmEvt));
- if (SUnpkU32(&measCfmEvt.transId, mBuf) != ROK) {
+ if (oduPackUInt32(&measCfmEvt.transId, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKUNPK(cmUnpkCmStatus, &measCfmEvt.status, mBuf);
- CMCHKUNPK(SUnpkU8, &measCfmEvt.measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &measCfmEvt.measType, mBuf);
if(measCfmEvt.measType & LKW_L2MEAS_DL_IP || measCfmEvt.measType & LKW_L2MEAS_UL_IP)
{
- CMCHKUNPK(SUnpkU16, &measCfmEvt.val.ipThMeas.numUes, mBuf);
+ CMCHKUNPK(oduPackUInt16, &measCfmEvt.val.ipThMeas.numUes, mBuf);
for(idx1 = 0;idx1<measCfmEvt.val.ipThMeas.numUes;idx1++)
{
CMCHKUNPK(cmUnpkLteRnti, &measCfmEvt.val.ipThMeas.\
ueInfoLst[idx1].ueId, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &measCfmEvt.val.ipThMeas.\
ueInfoLst[idx1].cellId, mBuf);
- if (SUnpkU16(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
+ if (oduPackUInt16(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
numCfm, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx = measCfmEvt.val.ipThMeas.ueInfoLst[idx1].numCfm; idx > 0; idx--)
{
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
}
else
{
- if (SUnpkU16(&measCfmEvt.val.nonIpThMeas.numCfm, mBuf) != ROK) {
+ if (oduPackUInt16(&measCfmEvt.val.nonIpThMeas.numCfm, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx = measCfmEvt.val.nonIpThMeas.numCfm; idx > 0; idx--)
{
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measCfmEvt));
+ return ((*func)(pst, &measCfmEvt));
}
#ifdef ANSI
if((measType & LKW_L2MEAS_DL_IP) ||
(measType & LKW_L2MEAS_UL_IP))
{
- CMCHKUNPK(SUnpkU8, ¶m->qci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
CMCHKUNPK(SUnpkF32, ¶m->val.ipThrput.dlIpThPut, mBuf);
CMCHKUNPK(SUnpkF32, ¶m->val.ipThrput.ulIpThPut, mBuf);
}
else
{
- CMCHKUNPK(SUnpkU8, ¶m->qci, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->val.nonIpThrput.dlSduDelay, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->val.nonIpThrput.numActUe, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->val.nonIpThrput.uuLoss, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->val.nonIpThrput.dlDiscRate, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->val.nonIpThrput.dlSduDelay, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->val.nonIpThrput.numActUe, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->val.nonIpThrput.uuLoss, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->val.nonIpThrput.dlDiscRate, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, status, mBuf);
- CMCHKPK(SPkU8, measType, mBuf);
+ CMCHKPK(oduUnpackUInt8, status, mBuf);
+ CMCHKPK(oduUnpackUInt8, measType, mBuf);
pst->event = (Event) LKW_EVT_L2MEAS_STOP_CFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
U8 measType;
U8 status;
TRC3(cmUnpkLkwL2MeasCfm)
- CMCHKUNPK(SUnpkU8, &measType, mBuf);
- CMCHKUNPK(SUnpkU8, &status, mBuf);
+ CMCHKUNPK(oduPackUInt8, &measType, mBuf);
+ CMCHKUNPK(oduPackUInt8, &status, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, measType,status));
+ return ((*func)(pst, measType,status));
}
#endif /* LTE_L2_MEAS */
#endif /* LCLKW */
void l1HdlSlotIndicaion(bool);
-S16 buildAndSendSlotIndication();
-S16 duSendEgtpSlotInd();
+uint8_t buildAndSendSlotIndication();
+uint8_t duSendEgtpSlotInd();
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG001, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cfg, EVTLRGCFGREQ, mBuf) != ROK) {
(ErrVal)ELRG002, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGCFGREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG003, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfg));
+ return ((*func)(pst, &cfg));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG004, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
(ErrVal)ELRG005, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG006, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfg));
+ return ((*func)(pst, &cfg));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG007, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cfm, EVTLRGCFGCFM, mBuf) != ROK) {
(ErrVal)ELRG008, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGCFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG009, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG010, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
(ErrVal)ELRG011, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTMACSCHGENCFGCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG012, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfg));
+ return ((*func)(pst, &cfg));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG013, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, sts, EVTLRGSTSREQ, mBuf) != ROK) {
(ErrVal)ELRG014, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGSTSREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG015, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &sts));
+ return ((*func)(pst, &sts));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG016, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cfm, EVTLRGSTSCFM, mBuf) != ROK) {
(ErrVal)ELRG017, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGSTSCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG018, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG019, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgMngmt(pst, sta, EVTLRGSSTAREQ, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ELRG020, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTLRGSSTAREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ELRG021, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &sta));
+ return ((*func)(pst, &sta));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG022, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmPkRgMngmt(pst, cfm, EVTLRGSSTACFM, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ELRG023, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTLRGSSTACFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ELRG024, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG025, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, usta, EVTLRGUSTAIND, mBuf) != ROK) {
(ErrVal)ELRG026, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGUSTAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG027, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &usta));
+ return ((*func)(pst, &usta));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG028, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
(ErrVal)ELRG029, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGSCHSTAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG030, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &sta));
+ return ((*func)(pst, &sta));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG031, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
(ErrVal)ELRG032, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGCNTRLREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG033, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cntrl));
+ return ((*func)(pst, &cntrl));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG034, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
(ErrVal)ELRG035, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGSCHCNTRLREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG036, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cntrl));
+ return ((*func)(pst, &cntrl));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG037, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
(ErrVal)ELRG038, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGCNTRLCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG039, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cfm));
+ return ((*func)(pst, &cfm));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG040, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkRgMngmt(pst, cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
(ErrVal)ELRG041, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTLRGSCHCNTRLCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG042, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &cntrl));
+ return ((*func)(pst, &cntrl));
}
\f
(ErrVal)ELRG043, (ErrVal)0, "Packing failed");
#endif
SPutMsg(trcBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
MsgLen msgLen;
(ErrVal)ELRG044, (ErrVal)0, "Packing failed");
#endif
SPutMsg(trcBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SCatMsg(mBuf, trcBuf, M1M2) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ELRG045, (ErrVal)0, "Packing failed");
#endif
SPutMsg(trcBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(trcBuf);
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
#endif
SPutMsg(trcBuf);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTLRGTRCIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG047, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
MsgLen msgLen, totalMsgLen;
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, &trcBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &trc, trcBuf));
+ return ((*func)(pst, &trc, trcBuf));
}
\f
TRC3(cmPkRgGenCfg)
#ifdef LTE_ADV
- CMCHKPK(SPkU8, param->isSCellActDeactAlgoEnable, mBuf);
- CMCHKPK(SPkU8, param->forceCntrlSrbBoOnPCel, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSCellActDeactAlgoEnable, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->forceCntrlSrbBoOnPCel, mBuf);
#endif
- CMCHKPK(SPkU8, param->startCellId, mBuf);
- CMCHKPK(SPkU8, param->numRguSaps, mBuf);
- CMCHKPK(SPkU8, param->tmrRes, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->startCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRguSaps, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tmrRes, mBuf);
CMCHKPK(cmPkMemoryId, ¶m->mem, mBuf);
CMCHKPK(cmPkPst, ¶m->lmPst, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkPst, ¶m->lmPst, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tmrRes, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRguSaps, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->startCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tmrRes, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRguSaps, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->startCellId, mBuf);
#ifdef LTE_ADV
- CMCHKUNPK(SUnpkU8, ¶m->forceCntrlSrbBoOnPCel, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isSCellActDeactAlgoEnable, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->forceCntrlSrbBoOnPCel, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSCellActDeactAlgoEnable, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(SPkS16, param->suId, mBuf);
CMCHKPK(SPkS16, param->spId, mBuf);
- CMCHKPK(SPkU8, param->route, mBuf);
- CMCHKPK(SPkU8, param->inst, mBuf);
- CMCHKPK(SPkU8, param->ent, mBuf);
- CMCHKPK(SPkU16, param->procId, mBuf);
- CMCHKPK(SPkU8, param->prior, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->route, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->inst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ent, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->procId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prior, mBuf);
CMCHKPK(cmPkMemoryId, ¶m->mem, mBuf);
- CMCHKPK(SPkU8, param->selector, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->selector, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgUpSapCfg)
- CMCHKUNPK(SUnpkU8, ¶m->selector, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->selector, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prior, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->procId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ent, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->inst, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->route, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prior, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->procId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ent, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->inst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->route, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->spId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->suId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTmrCfg, ¶m->bndTmr, mBuf);
CMCHKPK(SPkS16, param->suId, mBuf);
CMCHKPK(SPkS16, param->spId, mBuf);
- CMCHKPK(SPkU8, param->route, mBuf);
- CMCHKPK(SPkU8, param->inst, mBuf);
- CMCHKPK(SPkU8, param->ent, mBuf);
- CMCHKPK(SPkU16, param->procId, mBuf);
- CMCHKPK(SPkU8, param->prior, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->route, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->inst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ent, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->procId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prior, mBuf);
CMCHKPK(cmPkMemoryId, ¶m->mem, mBuf);
- CMCHKPK(SPkU8, param->selector, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->selector, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgLowSapCfg)
- CMCHKUNPK(SUnpkU8, ¶m->selector, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->selector, mBuf);
CMCHKUNPK(cmUnpkMemoryId, ¶m->mem, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prior, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->procId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ent, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->inst, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->route, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prior, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->procId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ent, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->inst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->route, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->spId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->suId, mBuf);
CMCHKUNPK(cmUnpkTmrCfg, ¶m->bndTmr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef MAC_SCH_STATS
TRC3(cmPkRgAckNack)
- CMCHKPK(SPkU16, param->numOfAcks, mBuf);
- CMCHKPK(SPkU16, param->numOfNacks, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfAcks, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfNacks, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRgAckNack */
\f
CMCHKPK(cmPkRgAckNack, ¶m->dlCqiStat[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
{
TRC3(cmPkRgHqNumRetx)
- CMCHKPK(SPkU32, param->totalTx, mBuf);
- CMCHKPK(SPkU16, param->numOfHQ_4, mBuf);
- CMCHKPK(SPkU16, param->numOfHQ_3, mBuf);
- CMCHKPK(SPkU16, param->numOfHQ_2, mBuf);
- CMCHKPK(SPkU16, param->numOfHQ_1, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->totalTx, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfHQ_4, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfHQ_3, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfHQ_2, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfHQ_1, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRgHqNumRetx */
\f
CMCHKPK(cmPkRgHqNumRetx, ¶m->dlCqiStat[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmPkRgSchHqRetxStats */
/* unpcaking functions */
TRC3(cmUnpkRgAckNack)
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfNacks, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfAcks, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfNacks, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfAcks, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnkRgAckNack */
\f
CMCHKUNPK(cmUnpkRgAckNack, ¶m->ulCqiStat[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRgSchNackAckStats */
\f
{
TRC3(cmUnpkRgHqNumRetx)
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfHQ_1, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfHQ_2, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfHQ_3, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfHQ_4, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->totalTx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfHQ_1, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfHQ_2, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfHQ_3, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfHQ_4, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->totalTx, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRgHqNumRetx */
\f
CMCHKUNPK(cmUnpkRgHqNumRetx, ¶m->ulCqiStat[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* cmUnpkRgSchHqRetxStats */
#endif /* MAC_SCH_STATS */
CMCHKPK(cmPkRgSchHqRetxStats, ¶m->hqRetxStats, mBuf);
CMCHKPK(cmPkRgSchNackAckStats, ¶m->nackAckStats, mBuf);
#endif /* MAC_SCH_STATS */
- CMCHKPK(SPkU16, param->numCellCfg, mBuf);
- CMCHKPK(SPkU32, param->numUeCfg, mBuf);
- CMCHKPK(SPkU32, param->numHarqFail, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->numCellCfg, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numUeCfg, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numHarqFail, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgGenSts)
- CMCHKUNPK(SUnpkU32, ¶m->numHarqFail, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numUeCfg, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numCellCfg, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numHarqFail, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numUeCfg, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numCellCfg, mBuf);
#ifdef MAC_SCH_STATS
CMCHKUNPK(cmUnpkRgSchNackAckStats, ¶m->nackAckStats, mBuf);
CMCHKUNPK(cmUnpkRgSchHqRetxStats, ¶m->hqRetxStats, mBuf);
#endif /* MAC_SCH_STATS */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgSapSts)
- CMCHKPK(SPkU32, param->numPduDrop, mBuf);
- CMCHKPK(SPkU32, param->numPduTxmit, mBuf);
- CMCHKPK(SPkU32, param->numPduRcvd, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->numPduDrop, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numPduTxmit, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numPduRcvd, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgSapSts)
- CMCHKUNPK(SUnpkU32, ¶m->numPduRcvd, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numPduTxmit, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numPduDrop, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->numPduRcvd, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numPduTxmit, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numPduDrop, mBuf);
+ return ROK;
}
for (i=param->numSaps-1; i >= 0; i--) {
CMCHKPK(cmPkRgUpSapCfg, ¶m->rgmSap[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSaps, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSaps, mBuf);
CMCHKPK(cmPkRgGenCfg, ¶m->genCfg, mBuf);
- CMCHKPK(SPkU8, param->instId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->instId, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkRgSchInstCfg)
- CMCHKUNPK(SUnpkU8, ¶m->instId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->instId, mBuf);
CMCHKUNPK(cmUnpkRgGenCfg, ¶m->genCfg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSaps, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSaps, mBuf);
for (i=0; i<param->numSaps; i++) {
CMCHKUNPK(cmUnpkRgUpSapCfg, ¶m->rgmSap[i], mBuf);
}
for (i=0; i<param->numSaps; i++) {
CMCHKUNPK(cmUnpkRgLowSapCfg, ¶m->tfuSap[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkRgGenCfg, ¶m->s.genCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkRgSchInstCfg, ¶m->s.schInstCfg, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgSapSta)
- CMCHKPK(SPkU8, param->sapState, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->sapState, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgSapSta)
- CMCHKUNPK(SUnpkU8, ¶m->sapState, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->sapState, mBuf);
+ return ROK;
}
break;
}
CMCHKPK(cmPkAction, param->action, mBuf);
- CMCHKPK(SPkU8, param->sapInst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sapInst, mBuf);
CMCHKPK(cmPkDateTime, ¶m->dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgSts)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sapInst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sapInst, mBuf);
CMCHKUNPK(cmUnpkAction, ¶m->action, mBuf);
switch(elmnt) {
case STGEN:
default :
break;
}
- RETVALUE(ROK);
+ return ROK;
}
default :
break;
}
- CMCHKPK(SPkU8, param->sapInst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sapInst, mBuf);
CMCHKPK(cmPkDateTime, ¶m->dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgSsta)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sapInst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sapInst, mBuf);
switch(elmnt) {
case STGEN:
/*ccpu00118255 - ADD - Check for eventType before Unpack */
(ErrVal)ELRG048, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* KWORK_FIX: Moved the memset under the NULL check */
if (param->s.sysId.ptNmb != NULLP)
default :
break;
}
- RETVALUE(ROK);
+ return ROK;
}
default :
break;
}
- CMCHKPK(SPkU8, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkRgUstaDgn)
- CMCHKUNPK(SUnpkU8, ¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->type, mBuf);
switch(param->type) {
case LRG_USTA_DGNVAL_MEM:
CMCHKUNPK(cmUnpkMemoryId, ¶m->u.mem, mBuf);
default :
break;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkRgUstaDgn, ¶m->dgn, mBuf);
CMCHKPK(cmPkCmAlarm, ¶m->cmAlarm, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkCmAlarm, ¶m->cmAlarm, mBuf);
CMCHKUNPK(cmUnpkRgUstaDgn, ¶m->dgn, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRgTrc)
- CMCHKPK(SPkU8, param->evnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->evnt, mBuf);
CMCHKPK(cmPkDateTime, ¶m->dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgTrc)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->evnt, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->evnt, mBuf);
+ return ROK;
}
TRC3(cmPkRgDbgCntrl)
- CMCHKPK(SPkU32, param->dbgMask, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->dbgMask, mBuf);
+ return ROK;
}
#ifdef PHY_ERROR_LOGING
{
TRC3(cmPkRgSchUlAllocCntrl)
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU16, param->numOfRb, mBuf);
- CMCHKPK(SPkU16, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->testStart, mBuf);
- CMCHKPK(SPkU8, param->enaLog, mBuf);
- CMCHKPK(SPkU16, param->logTime, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->numOfRb, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->testStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->enaLog, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->logTime, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
{
TRC3(cmUnpkRgSchUlAllocCntrl)
- CMCHKUNPK(SUnpkU16, ¶m->logTime, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->enaLog, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->testStart, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->numOfRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->logTime, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->enaLog, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->testStart, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->numOfRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgDbgCntrl)
- CMCHKUNPK(SUnpkU32, ¶m->dbgMask, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->dbgMask, mBuf);
+ return ROK;
}
CMCHKPK(SPkS16, param->spId, mBuf);
CMCHKPK(SPkS16, param->suId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(SUnpkS16, ¶m->suId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->spId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
break;
#ifdef SS_DIAG
case SALOG:
- CMCHKPK(SPkU32, param->s.logMask, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->s.logMask, mBuf);
break;
#endif
#ifdef PHY_ERROR_LOGING
default :
break;
}
- CMCHKPK(SPkU8, param->subAction, mBuf);
- CMCHKPK(SPkU8, param->action, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->subAction, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->action, mBuf);
CMCHKPK(cmPkDateTime, ¶m->dt, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkRgCntrl)
CMCHKUNPK(cmUnpkDateTime, ¶m->dt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->action, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->subAction, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->action, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->subAction, mBuf);
switch(elmnt) {
case STGEN:
switch(param->subAction) {
break;
#ifdef SS_DIAG
case SALOG:
- CMCHKUNPK(SUnpkU32, ¶m->s.logMask, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->s.logMask, mBuf);
break;
#endif
#ifdef PHY_ERROR_LOGING
default :
break;
}
- RETVALUE(ROK);
+ return ROK;
}
case EVTLRGSCHCNTRLREQ:
case EVTLRGSCHCNTRLCFM:
if(cmPkRgCntrl(¶m->t.cntrl, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
case EVTLRGTRCIND:
CMCHKPK(cmPkRgTrc, ¶m->t.trc, mBuf);
#ifdef LRG_V1
if(cmPkRgSsta(pst, ¶m->t.ssta, param->hdr.elmId.elmnt,
eventType, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* LRG_V1 is not defined */
if(cmPkRgSsta(pst, ¶m->t.ssta, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif /* end of LRG_V1*/
break;
case EVTLRGSTSREQ:
case EVTLRGSTSCFM:
if(cmPkRgSts(¶m->t.sts, param->hdr.elmId.elmnt, mBuf)!= ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
case EVTLRGCFGREQ:
case EVTLRGCFGCFM:
if(cmPkRgCfg(¶m->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
case EVTMACSCHGENCFGREQ:
case EVTMACSCHGENCFGCFM:
if(cmPkRgCfg(¶m->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkCmStatus, ¶m->cfm, mBuf);
CMCHKPK(cmPkHeader, ¶m->hdr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
case EVTMACSCHGENCFGREQ:
case EVTMACSCHGENCFGCFM:
if(cmUnpkRgCfg(¶m->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
case EVTLRGSTSREQ:
case EVTLRGSTSCFM:
if(cmUnpkRgSts(¶m->t.sts, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
case EVTLRGSSTAREQ:
case EVTLRGSSTACFM:
if(cmUnpkRgSsta(pst, ¶m->t.ssta, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
case EVTLRGUSTAIND:
case EVTLRGSCHSTAIND:
case EVTLRGSCHCNTRLREQ:
case EVTLRGSCHCNTRLCFM:
if(cmUnpkRgCntrl(¶m->t.cntrl, param->hdr.elmId.elmnt, mBuf) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* lrg_c_001.main_3 - ADD - Added the functions pertaining to LTE_L2_MEAS */
for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
{
- CMCHKPK(SPkU8, nmbActvUeQci->qci[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, nmbActvUeQci->qci[idx], mBuf);
}
- CMCHKPK(SPkU8, nmbActvUeQci->numQci, mBuf);
- CMCHKPK(SPkU8, nmbActvUeQci->sampPrd, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, nmbActvUeQci->numQci, mBuf);
+ CMCHKPK(oduUnpackUInt8, nmbActvUeQci->sampPrd, mBuf);
+ return ROK;
}
\f
/**
for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
{
- CMCHKPK(SPkU8, avgPrbQciReq->qci[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, avgPrbQciReq->qci[idx], mBuf);
}
- CMCHKPK(SPkU8, avgPrbQciReq->numQci, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, avgPrbQciReq->numQci, mBuf);
+ return ROK;
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
{
}
CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
- CMCHKPK(SPkU32, measInfo->timePrd, mBuf);
- CMCHKPK(SPkU16, measInfo->measType, mBuf);
+ CMCHKPK(oduUnpackUInt32, measInfo->timePrd, mBuf);
+ CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
pst->event = (Event) EVTLRGSCHL2MEASREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
* @brief This API is used to stop a
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
- /*CMCHKPK(SPkU16, measInfo->timePrd, mBuf);*/
- CMCHKPK(SPkU16, measInfo->measType, mBuf);
+ /*CMCHKPK(oduUnpackUInt16, measInfo->timePrd, mBuf);*/
+ CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
pst->event = (Event) EVTLRGSCHL2MEASSTOPREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}/*cmPkLrgSchL2MeasStopReq*/
/**
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
- CMCHKPK(SPkU32, measInfo->timePrd, mBuf);
- CMCHKPK(SPkU16, measInfo->measType, mBuf);
+ CMCHKPK(oduUnpackUInt32, measInfo->timePrd, mBuf);
+ CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
pst->event = (Event) EVTLRGSCHL2MEASSENDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}/*cmPkLrgSchL2MeasSendReq*/
\f
/**
TRC3(cmUnpkNmbActvUeQciReq)
- CMCHKUNPK(SUnpkU8, ¶m->sampPrd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sampPrd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU8, ¶m->qci[idx - 1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci[idx - 1], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/**
TRC3(cmUnpkAvgPrbQciReq)
- CMCHKUNPK(SUnpkU8, ¶m->numQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU8, ¶m->qci[idx - 1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->qci[idx - 1], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmUnpkLrgSchL2MeasReq)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
- CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
- CMCHKUNPK(SUnpkU32, &measInfo.timePrd, mBuf);
+ CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
+ CMCHKUNPK(oduPackUInt32, &measInfo.timePrd, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
if(measInfo.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
{
CMCHKUNPK(cmUnpkNmbActvUeQciReq, &measInfo.nmbActvUeQciDl, mBuf);
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
}
/**
TRC3(cmUnpkLrgSchL2MeasStopReq)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
- CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
- /*CMCHKUNPK(SUnpkU16, &measInfo.timePrd, mBuf);*/
+ CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
+ /*CMCHKUNPK(oduPackUInt16, &measInfo.timePrd, mBuf);*/
CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
}/*cmUnpkLrgSchL2MeasStopReq*/
/**
{
LrgSchMeasSndReqInfo measInfo;
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
- CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
- CMCHKUNPK(SUnpkU32, &measInfo.timePrd, mBuf);
+ CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
+ CMCHKUNPK(oduPackUInt32, &measInfo.timePrd, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
}/*cmUnpkLrgSchL2MeasSendReq*/
/**
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG050, (ErrVal)0, "SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
CMCHKPK(cmPkCmStatus, &measInfo->cfm, mBuf);
- CMCHKPK(SPkU16, measInfo->measType, mBuf);
+ CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
pst->event = (Event) EVTLRGSCHL2MEASSTOPCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}/*cmPkLrgSchL2MeasStopCfm*/
/**
* @brief This API is used to Send a
TRC3(cmUnpkLrgSchL2MeasCfm)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
- CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
+ CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
CMCHKUNPK(cmUnpkCmStatus, &measInfo.cfm, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
}/*cmUnpkLrgSchL2MeasStopCfm*/
\f
/**
for(idx = 0; idx < param->numQci; idx++)
{
/*LRG : Review Tag*/
- CMCHKPK(SPkU8, param->numActvUeQci[idx].qciValue, mBuf);
- CMCHKPK(SPkU8, param->numActvUeQci[idx].numActvUeQci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numActvUeQci[idx].qciValue, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numActvUeQci[idx].numActvUeQci, mBuf);
/*LRG : Review Tag*/
}
- CMCHKPK(SPkU8, param->numQci, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numQci, mBuf);
+ return ROK;
}
\f
/**
for(idx = 0; idx < param->numQci; idx++)
{
/*LRG : Review Tag*/
- CMCHKPK(SPkU8, param->prbPercQci[idx].qciValue, mBuf);
- CMCHKPK(SPkU8, param->prbPercQci[idx].prbPercQci, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prbPercQci[idx].qciValue, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prbPercQci[idx].prbPercQci, mBuf);
/*LRG : Review Tag*/
}
- CMCHKPK(SPkU8, param->numQci, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numQci, mBuf);
+ return ROK;
}
\f
/**
{
TRC3(cmPkRaPrmbsCfm)
- CMCHKPK(SPkU16, param->randSelPreHighRange, mBuf);
- CMCHKPK(SPkU16, param->randSelPreLowRange, mBuf);
- CMCHKPK(SPkU16, param->dedPreambles, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->randSelPreHighRange, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->randSelPreLowRange, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dedPreambles, mBuf);
+ return ROK;
}
\f
/**
{
TRC3(cmPkAvgPrbCfm)
- CMCHKPK(SPkU8, param->prbPerc, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->prbPerc, mBuf);
+ return ROK;
}
\f
/**
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ELRG050, (ErrVal)0, "SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
{
}
if(measInfo->measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
{
- CMCHKPK(SPkU32, measInfo->tbTransDlTotalCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, measInfo->tbTransDlTotalCnt, mBuf);
}
if(measInfo->measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
{
- CMCHKPK(SPkU32, measInfo->tbTransDlFaulty, mBuf);
+ CMCHKPK(oduUnpackUInt32, measInfo->tbTransDlFaulty, mBuf);
}
if(measInfo->measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
{
- CMCHKPK(SPkU32, measInfo->tbTransUlTotalCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, measInfo->tbTransUlTotalCnt, mBuf);
}
if(measInfo->measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
{
- CMCHKPK(SPkU32, measInfo->tbTransUlFaulty, mBuf);
+ CMCHKPK(oduUnpackUInt32, measInfo->tbTransUlFaulty, mBuf);
}
CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
CMCHKPK(cmPkCmStatus, &measInfo->cfm, mBuf);
- CMCHKPK(SPkU16, measInfo->measType, mBuf);
+ CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
pst->event = (Event) EVTLRGSCHL2MEASCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
/**
U8 idx;
TRC3(cmUnpkNumUeQciCfm)
- CMCHKUNPK(SUnpkU8, ¶m->numQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
/*LRG : Review Tag*/
- CMCHKUNPK(SUnpkU8, ¶m->numActvUeQci[idx - 1].numActvUeQci, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numActvUeQci[idx - 1].qciValue, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numActvUeQci[idx - 1].numActvUeQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numActvUeQci[idx - 1].qciValue, mBuf);
/*LRG : Review Tag*/
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/**
TRC3(cmUnpkAvgPrbQciCfm)
- CMCHKUNPK(SUnpkU8, ¶m->numQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
{
/*LRG : Review Tag*/
- CMCHKUNPK(SUnpkU8, ¶m->prbPercQci[idx - 1].prbPercQci, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prbPercQci[idx - 1].qciValue, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prbPercQci[idx - 1].prbPercQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prbPercQci[idx - 1].qciValue, mBuf);
/*LRG : Review Tag*/
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/**
TRC3(cmUnpkRaPrmbsCfm)
- CMCHKUNPK(SUnpkU16, ¶m->dedPreambles, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->randSelPreLowRange, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->randSelPreHighRange, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->dedPreambles, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->randSelPreLowRange, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->randSelPreHighRange, mBuf);
+ return ROK;
}
\f
/**
TRC3(cmUnpkAvgPrbCfm)
- CMCHKUNPK(SUnpkU8, ¶m->prbPerc, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->prbPerc, mBuf);
+ return ROK;
}
\f
/**
TRC3(cmUnpkLrgSchL2MeasCfm)
CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
- CMCHKUNPK(SUnpkU16, &measInfo.measType, mBuf);
+ CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
CMCHKUNPK(cmUnpkCmStatus, &measInfo.cfm, mBuf);
CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
if(measInfo.measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
{
- CMCHKPK(SUnpkU32, &measInfo.tbTransUlFaulty, mBuf);
+ CMCHKPK(oduPackUInt32, &measInfo.tbTransUlFaulty, mBuf);
}
if(measInfo.measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
{
- CMCHKPK(SUnpkU32, &measInfo.tbTransUlTotalCnt, mBuf);
+ CMCHKPK(oduPackUInt32, &measInfo.tbTransUlTotalCnt, mBuf);
}
if(measInfo.measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
{
- CMCHKPK(SUnpkU32, &measInfo.tbTransDlFaulty, mBuf);
+ CMCHKPK(oduPackUInt32, &measInfo.tbTransDlFaulty, mBuf);
}
if(measInfo.measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
{
- CMCHKPK(SUnpkU32, &measInfo.tbTransDlTotalCnt, mBuf);
+ CMCHKPK(oduPackUInt32, &measInfo.tbTransDlTotalCnt, mBuf);
}
if(measInfo.measType & LRG_L2MEAS_AVG_PRB_UL)
{
CMCHKUNPK(cmUnpkNumUeQciCfm, &measInfo.numUeQciDlCfm, mBuf);
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, &measInfo));
+ return ((*func)(pst, &measInfo));
}
#endif
#endif
RgMngmt *cfg /* Management Structure */
));
-typedef int (*LrgSchCfgReq) ARGS((
+typedef uint8_t (*LrgSchCfgReq) ARGS((
Pst *pst, /* Post Structure */
RgMngmt *cfg /* Management Structure */
));
* @param cfm pointer to RgMngmt
* @return ROK/RFAILED
*/
-EXTERN int MacSchGenCfgReq ARGS((Pst *pst, RgMngmt *cfg));
+EXTERN uint8_t MacSchGenCfgReq ARGS((Pst *pst, RgMngmt *cfg));
/** @brief This primitive carries the Confirmation for a Configuration Request
* sent from the layer manager to MAC.
* @param cfg pointer to RgMngmt
* @return ROK/RFAILED
*/
-EXTERN int SchProcGenCfgReq ARGS((Pst *pst, RgMngmt *cfg));
+EXTERN uint8_t SchProcGenCfgReq ARGS((Pst *pst, RgMngmt *cfg));
/** @brief This primitive carries the Confirmation for a Configuration Request
* sent from the layer manager to Scheduler.
*
* ****************************************************************/
-S16 cmPkSctpNtfy(Pst *pst, CmInetSctpNotification *ntfy)
+uint8_t cmPkSctpNtfy(Pst *pst, CmInetSctpNotification *ntfy)
{
Buffer *mBuf;
- if(SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if(ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
printf("\nSCTP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ntfy->header.nType == CM_INET_SCTP_ASSOC_CHANGE)
{
- SPkU16(ntfy->u.assocChange.state, mBuf);
- SPkU32(ntfy->u.assocChange.assocId, mBuf);
+ oduUnpackUInt16(ntfy->u.assocChange.state, mBuf);
+ oduUnpackUInt32(ntfy->u.assocChange.assocId, mBuf);
}
- SPkU16(ntfy->header.nType, mBuf);
+ oduUnpackUInt16(ntfy->header.nType, mBuf);
- if (SPstTsk(pst, mBuf) != ROK)
+ if (ODU_POST_TASK(pst, mBuf) != ROK)
{
- printf("\nSCTP : SPstTsk failed while sending SCTP notification");
- RETVALUE(RFAILED);
+ printf("\nSCTP : ODU_POST_TASK failed while sending SCTP notification");
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
*
* ****************************************************************/
-S16 cmUnpkSctpNtfy(SctpNtfy func, Pst *pst, Buffer *mBuf)
+uint8_t cmUnpkSctpNtfy(SctpNtfy func, Pst *pst, Buffer *mBuf)
{
CmInetSctpNotification ntfy;
- cmMemset((U8*)&ntfy, 0, sizeof(CmInetSctpNotification));
+ memset((uint8_t*)&ntfy, 0, sizeof(CmInetSctpNotification));
- SUnpkU16(&(ntfy.header.nType), mBuf);
+ oduPackUInt16(&(ntfy.header.nType), mBuf);
if(ntfy.header.nType == CM_INET_SCTP_ASSOC_CHANGE)
{
- SUnpkU32(&(ntfy.u.assocChange.assocId), mBuf);
- SUnpkU16(&(ntfy.u.assocChange.state), mBuf);
+ oduPackUInt32(&(ntfy.u.assocChange.assocId), mBuf);
+ oduPackUInt16(&(ntfy.u.assocChange.state), mBuf);
}
- RETVALUE((*func)(mBuf, &ntfy));
+ return ((*func)(mBuf, &ntfy));
}
/**********************************************************************
#ifndef __LSCTP_H___
#define __LSCTP_H___
-typedef S16 (*SctpNtfy) ARGS((Buffer *mBuf, CmInetSctpNotification *ntfy));
-extern S16 cmPkSctpNtfy(Pst *pst, CmInetSctpNotification *ntfy);
-extern S16 cmUnpkSctpNtfy(SctpNtfy func, Pst *pst, Buffer *mBuf);
+typedef uint8_t (*SctpNtfy) ARGS((Buffer *mBuf, CmInetSctpNotification *ntfy));
+extern uint8_t cmPkSctpNtfy(Pst *pst, CmInetSctpNotification *ntfy);
+extern uint8_t cmUnpkSctpNtfy(SctpNtfy func, Pst *pst, Buffer *mBuf);
#endif
uint8_t packMacSchSlotInd(Pst *pst, SlotIndInfo *slotInd)
{
Buffer *mBuf = NULLP;
- if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
+ if (ODU_GET_MSG(pst->region, pst->pool, &mBuf) != ROK)
{
return RFAILED;
}
/* pack SFN and slot value */
- CMCHKPK(SPkU16,slotInd->sfn, mBuf);
- CMCHKPK(SPkU16,slotInd->slot, mBuf);
+ CMCHKPK(oduUnpackUInt16,slotInd->sfn, mBuf);
+ CMCHKPK(oduUnpackUInt16,slotInd->slot, mBuf);
- return SPstTsk(pst,mBuf);
+ return ODU_POST_TASK(pst,mBuf);
}
/**
typedef struct schCellCfgCfm
{
- U16 cellId; /* Cell Id */
+ uint16_t cellId; /* Cell Id */
SchMacRsp rsp;
}SchCellCfgCfm;
* 0 : No tranamission
* 1 : SIB1 Transmission
* 2 : SIB1 Repetition */
- U8 sib1Trans;
+ uint8_t sib1Trans;
Sib1AllocInfo sib1Alloc;
}DlBrdcstAlloc;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = ((*func)(pst, suId, spId));
SPutMsg(mBuf);
- RETVALUE(ret);
+ return (ret);
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK)
+ if (oduUnpackUInt8(status, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
TRC3(cmUnpkLwLcRgmBndCfm)
- if (SUnpkU8(&status, mBuf) != ROK)
+ if (oduPackUInt8(&status, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)prbRprtCfg, mBuf) != ROK)
+ if(oduPackPointer((PTR)prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMCFGPRBRPRT;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
if (SUnpkS16(&spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (cmUnpkPtr((PTR *)&prbRprtCfg, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = ((*func)(pst, spId, prbRprtCfg));
SPutMsg(mBuf);
- RETVALUE(ret);
+ return (ret);
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if(cmPkPtr((PTR)prbRprtInd, mBuf) != ROK)
+ if(oduPackPointer((PTR)prbRprtInd, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMCFGPRBRPRT;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (cmUnpkPtr((PTR *)&prbRprtInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&prbRprtInd, mBuf) != ROK)
{
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE(ret);
+ return (ret);
}
#endif
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = ((*func)(pst, suId, spId));
SPutMsg(mBuf);
- RETVALUE(ret);
+ return (ret);
}
/**
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#if 1
if (SUnpkS16(&spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
#endif
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SPkU8(status, mBuf) != ROK)
+ if (oduUnpackUInt8(status, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGMBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
TRC3(cmUnpkRgmBndCfm)
- if (SUnpkU8(&status, mBuf) != ROK)
+ if (oduPackUInt8(&status, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
#endif
{
TRC3(cmPkCfgPrbRprt);
- CMCHKPK(SPkU16, prbRprtCfg->usPrbAvgPeriodicty, mBuf);
- CMCHKPK(SPkU8, prbRprtCfg->bConfigType, mBuf);
- CMCHKPK(SPkU8, prbRprtCfg->bCellId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, prbRprtCfg->usPrbAvgPeriodicty, mBuf);
+ CMCHKPK(oduUnpackUInt8, prbRprtCfg->bConfigType, mBuf);
+ CMCHKPK(oduUnpackUInt8, prbRprtCfg->bCellId, mBuf);
+ return ROK;
}
/**
* @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
#endif
{
TRC3(cmUnPkCfgPrbRprt);
- CMCHKUNPK(SUnpkU8, &prbRprtCfg->bCellId, mBuf);
- CMCHKUNPK(SUnpkU8, &prbRprtCfg->bConfigType, mBuf);
- CMCHKUNPK(SUnpkU16, &prbRprtCfg->usPrbAvgPeriodicty, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, &prbRprtCfg->bCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, &prbRprtCfg->bConfigType, mBuf);
+ CMCHKUNPK(oduPackUInt16, &prbRprtCfg->usPrbAvgPeriodicty, mBuf);
+ return ROK;
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
pst->event = (Event) EVTRGMCFGPRBRPRT;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
if ((SGetSBuf(pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, prbRprtCfg));
+ return ((*func)(pst, spId, prbRprtCfg));
}
/* RRM_SP1_START */
Buffer *mBuf = NULLP;
#endif
{
- CMCHKPK(SPkU8, qciPrbRprt->bQci, mBuf);
- CMCHKPK(SPkU8, qciPrbRprt->bAvgPrbUlUsage, mBuf);
- CMCHKPK(SPkU8, qciPrbRprt->bAvgPrbDlUsage, mBuf);
+ CMCHKPK(oduUnpackUInt8, qciPrbRprt->bQci, mBuf);
+ CMCHKPK(oduUnpackUInt8, qciPrbRprt->bAvgPrbUlUsage, mBuf);
+ CMCHKPK(oduUnpackUInt8, qciPrbRprt->bAvgPrbDlUsage, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/**
Buffer *mBuf = NULLP;
#endif
{
- CMCHKUNPK(SUnpkU8, &qciPrbRprt->bAvgPrbDlUsage, mBuf);
- CMCHKUNPK(SUnpkU8, &qciPrbRprt->bAvgPrbUlUsage, mBuf);
- CMCHKUNPK(SUnpkU8, &qciPrbRprt->bQci, mBuf);
+ CMCHKUNPK(oduPackUInt8, &qciPrbRprt->bAvgPrbDlUsage, mBuf);
+ CMCHKUNPK(oduPackUInt8, &qciPrbRprt->bAvgPrbUlUsage, mBuf);
+ CMCHKUNPK(oduPackUInt8, &qciPrbRprt->bQci, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* RRM_SP1_END */
{
CMCHKPK(cmPkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
}
- CMCHKPK(SPkU8, prbRprtInd->bPrbUsageMask, mBuf);
- CMCHKPK(SPkU8, prbRprtInd->bCellId, mBuf);
+ CMCHKPK(oduUnpackUInt8, prbRprtInd->bPrbUsageMask, mBuf);
+ CMCHKPK(oduUnpackUInt8, prbRprtInd->bCellId, mBuf);
/* RRM_SP1_END */
- RETVALUE(ROK);
+ return ROK;
}
/**
TRC3(cmUnpkPrbRprtInd);
/* RRM_SP1_START */
- CMCHKUNPK(SUnpkU8, &prbRprtInd->bCellId, mBuf);
- CMCHKUNPK(SUnpkU8, &prbRprtInd->bPrbUsageMask, mBuf);
+ CMCHKUNPK(oduPackUInt8, &prbRprtInd->bCellId, mBuf);
+ CMCHKUNPK(oduPackUInt8, &prbRprtInd->bPrbUsageMask, mBuf);
for(idx = 0; idx < RGM_MAX_QCI_REPORTS; idx++)
{
CMCHKUNPK(cmUnpkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
}
/* RRM_SP1_END */
- RETVALUE(ROK);
+ return ROK;
}
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmPkPrbRprtInd(prbRprtInd, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
pst->event = (Event) EVTRGMPRBRPRTIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
* @brief PRB Usage Report Indication from MAC to RRM
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkPrbRprtInd(&prbRprtInd, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, &prbRprtInd));
+ return ((*func)(pst, suId, &prbRprtInd));
}
/**
#endif
{
TRC3(cmPkTransModeInd);
- CMCHKPK(SPkU32, transModeInd->eMode, mBuf);
- CMCHKPK(SPkU16, transModeInd->usCrnti, mBuf);
- CMCHKPK(SPkU8, transModeInd->bCellId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, transModeInd->eMode, mBuf);
+ CMCHKPK(oduUnpackUInt16, transModeInd->usCrnti, mBuf);
+ CMCHKPK(oduUnpackUInt8, transModeInd->bCellId, mBuf);
+ return ROK;
}
/**
{
U32 tmpModeEnum;
TRC3(cmUnpkTransModeInd);
- CMCHKUNPK(SUnpkU8, &transModeInd->bCellId, mBuf);
- CMCHKUNPK(SUnpkU16, &transModeInd->usCrnti, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)&tmpModeEnum, mBuf);
+ CMCHKUNPK(oduPackUInt8, &transModeInd->bCellId, mBuf);
+ CMCHKUNPK(oduPackUInt16, &transModeInd->usCrnti, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)&tmpModeEnum, mBuf);
transModeInd->eMode = (RgmTxnMode)tmpModeEnum;
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Transmission Mode Change Indication from MAC to RRM
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmPkTransModeInd(transModeInd, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK)
{
SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
pst->event = (Event) EVTRGMTRANSMODEIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/**
* @brief Transmission Mode Change Indication from MAC to RRM
if (SUnpkS16(&suId, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkTransModeInd(&transModeInd, mBuf) != ROK)
{
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, &transModeInd));
+ return ((*func)(pst, suId, &transModeInd));
}
/**********************************************************************
__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) */
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU001, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU002, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU003, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ERGU004, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU005, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU006, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU007, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU008, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGUUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ERGU009, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU010, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU011, (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)ERGU012, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ERGU013, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGUBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ERGU014, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU015, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
(ErrVal)ERGU022, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)dlData, sizeof(RlcMacData));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR) dlData, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) dlData, mBuf);
}
else
{
SPutSBuf(pst->region, pst->pool, (Data *)dlData,
sizeof(RlcMacData));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool,
(ErrVal)ERGU025, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
dlData = NULLP;
}
(Data *)dlData, sizeof(RlcMacData));
}
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRLCDLDAT;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
if (SUnpkS16(&spId, mBuf) != ROK) {
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &dlData, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &dlData, mBuf);
}
else
{
(ErrVal)ERGU026, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemset((U8*)dlData, (U8)0, sizeof(RlcMacData));
/*rgu_c_001.main_5 - ADD - L2M Support */
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)dlData,
sizeof(RlcMacData));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
/* TODO : change function call to send RlcMacData as below: */
- RETVALUE((*func)(pst, spId, dlData));
+ return ((*func)(pst, spId, dlData));
- //RETVALUE((*func)(pst, spId, datReq));
+ //return ((*func)(pst, spId, datReq));
}
\f
(ErrVal)ERGU035, (ErrVal)0, "Packing failed");
#endif
SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR)ulData, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)ulData, mBuf);
}
else
{
#endif
SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutStaticBuffer(pst->region, pst->pool,
(ErrVal)ERGU038, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ulData = NULLP;
}
pst->event = (Event) EVTRLCULDAT;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &ulData, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &ulData, mBuf);
}
else
{
(ErrVal)ERGU040, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (unpackRlcMacDataInfo(ulData, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutMsg(mBuf);
SPutStaticBuffer(pst->region, pst->pool,
(Data *)ulData, sizeof(RlcMacData),0);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, ulData));
+ return ((*func)(pst, ulData));
}
S32 loop;
TRC3(cmPkRguL2MUlThrpMeasReqInfo);
- CMCHKPK(SPkU8, param->enbMeas, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->enbMeas, mBuf);
for (loop=param->numLcId-1; loop >= 0; loop--)
{
- CMCHKPK(SPkU8, param->lcId[loop], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->lcId[loop], mBuf);
}
CMCHKPK(cmPkLteLcId, param->numLcId, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcId, ¶m->numLcId, mBuf);
for (loop=0; loop<param->numLcId; loop++)
{
- CMCHKUNPK(SUnpkU8, ¶m->lcId[loop], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->lcId[loop], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->enbMeas, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->enbMeas, mBuf);
+ return ROK;
}
/**
(ErrVal)ERGU049, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)measReq, sizeof(RguL2MUlThrpMeasReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR) measReq, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) measReq, mBuf);
}
else
{
SPutSBuf(pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo)) != ROK) {
(ErrVal)ERGU052, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
measReq = NULLP;
}
sizeof(RguL2MUlThrpMeasReqInfo));
}
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGUL2MULTHRPMEASREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ERGU053, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &measReq, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &measReq, mBuf);
}
else
{
(ErrVal)ERGU054, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRguL2MUlThrpMeasReqInfo(measReq, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)measReq,
sizeof(RguL2MUlThrpMeasReqInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, spId, measReq));
+ return ((*func)(pst, spId, measReq));
}
#endif
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU056, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef ERRCLS_KW
/* boStaInfo cant be NULL here */
if (boStaInfo == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cmMemcpy((U8 *)boStaInfo, (U8 *)boStatus, sizeof(RlcMacBOStatus));
#endif
SPutSBuf(pst->region, pst->pool, (Data *)boStaInfo, sizeof(RlcMacBOStatus));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR) boStaInfo, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) boStaInfo, mBuf);
}
else
{
(ErrVal)ERGU057, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (SPkS16(spId, mBuf) != ROK) {
SPutSBuf(pst->region, pst->pool, (Data *)boStaInfo, sizeof(RlcMacBOStatus));
}
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event)EVTRLCBOSTA;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
SPutMsg(mBuf);
}
(ErrVal)ERGU060, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &boSta, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &boSta, mBuf);
}
else
{
(ErrVal)ERGU061, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (unpackBOStatusInfo(boSta, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)boSta, sizeof(RlcMacBOStatus));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
// (*func)(pst, spId, boSta);
SPutSBuf(pst->region, pst->pool, (Data *)boSta, sizeof(RlcMacBOStatus));
- RETVALUE(ROK);
+ return ROK;
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU070, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmMemcpy((U8 *)harqStaInd, (U8 *)harqStatusInd, sizeof(RguHarqStatusInd));
#else
SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR) harqStaInd, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) harqStaInd, mBuf);
}
else
{
for(idx = 0; idx < harqStaInd->numTbs; idx++)
{
- CMCHKPK(SPkU16, harqStaInd->status[idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, harqStaInd->status[idx], mBuf);
}
for(idx = 0; idx < harqStaInd->numTbs; idx++)
{
- CMCHKPK(SPkU32, harqStaInd->tbId[idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, harqStaInd->tbId[idx], mBuf);
}
- CMCHKPK(SPkU8, harqStaInd->numTbs, mBuf);
+ CMCHKPK(oduUnpackUInt8, harqStaInd->numTbs, mBuf);
CMCHKPK(cmPkLteRnti, harqStaInd->ueId, mBuf);
CMCHKPK(cmPkLteCellId, harqStaInd->cellId, mBuf);
}
SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
if (SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd,
(ErrVal)ERGU072, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef XEON_SPECIFIC_CHANGES
}
#endif
pst->event = (Event) EVTRGUHQSTAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ERGU073, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
if ((SGetSBuf(pst->region, pst->pool, (Data **)&hqStaInd,
#else
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &hqStaInd, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &hqStaInd, mBuf);
}
else
{
(ErrVal)ERGU074, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKUNPK(cmUnpkLteCellId, &hqStaInd->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, &hqStaInd->ueId, mBuf);
- CMCHKUNPK(SUnpkU8, &hqStaInd->numTbs, mBuf);
+ CMCHKUNPK(oduPackUInt8, &hqStaInd->numTbs, mBuf);
for(idx = hqStaInd->numTbs; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU32, &hqStaInd->tbId[idx - 1], mBuf);
+ CMCHKUNPK(oduPackUInt32, &hqStaInd->tbId[idx - 1], mBuf);
}
for(idx = hqStaInd->numTbs; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU16, &hqStaInd->status[idx - 1], mBuf);
+ CMCHKUNPK(oduPackUInt16, &hqStaInd->status[idx - 1], mBuf);
}
#ifndef XEON_SPECIFIC_CHANGES
}
#else
SPutStaticBuffer(pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd), 0);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_L2_MEAS */
(ErrVal)ERGU076, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR) schRep, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) schRep, mBuf);
}
else
{
SPutSBuf(pst->region, pst->pool, (Data *)schRep,
sizeof(RlcMacSchedRepInfo));
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPutSBuf(pst->region, pst->pool, (Data *)schRep,
sizeof(RlcMacSchedRepInfo)) != ROK) {
(ErrVal)ERGU079, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
schRep= NULLP;
}
SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
}
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTSCHREP;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
(ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &schRep, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &schRep, mBuf);
}
else
{
(ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (unpackSchedRepInfo(schRep, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRepInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, schRep));
+ return ((*func)(pst, suId, schRep));
}
#ifdef ANSI
#endif
{
TRC3(cmPkRguLcFlowCntrlInfo);
- CMCHKPK(SPkU32, param->maxBo4FlowCtrl, mBuf);
- CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->maxBo4FlowCtrl, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
{
cmPkRguLcFlowCntrlInfo(¶m->lcInfo[idx],mBuf);
}
- CMCHKPK(SPkU32, param->numLcs, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numLcs, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
{
cmPkRguUeFlowCntrlInfo(¶m->ueFlowCntrlInfo[idx],mBuf);
}
- CMCHKPK(SPkU32, param->numUes, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->numUes, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
/**
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ERGU076, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKPK(cmPkPtr,(PTR) flowCntrlInd, mBuf);
+ CMCHKPK(oduPackPointer,(PTR) flowCntrlInd, mBuf);
}
else
{
(ErrVal)ERGU077, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (SPkS16(suId, mBuf) != ROK) {
(ErrVal)ERGU078, (ErrVal)0, "Packing failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTRGUFLOWCNTRLIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#ifdef ANSI
TRC3(cmUnpkRguLcFlowCntrlInfo);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->pktAdmitCnt, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->maxBo4FlowCtrl, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->pktAdmitCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->maxBo4FlowCtrl, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
PUBLIC S16 cmUnpkRguUeFlowCntrlInfo
U32 idx;
TRC3(cmUnpkRguUeFlowCntrlInfo);
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numLcs, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numLcs, mBuf);
for(idx=0; idx < param->numLcs; idx++)
{
cmUnpkRguLcFlowCntrlInfo(¶m->lcInfo[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
TRC3(cmUnpkRguFlowCntrlInfo);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->numUes, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->numUes, mBuf);
for (idx=0; idx < param->numUes; idx++)
{
cmUnpkRguUeFlowCntrlInfo(¶m->ueFlowCntrlInfo[idx],mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
(ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LWLC)
{
- CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInd, mBuf);
+ CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInd, mBuf);
}
else
{
(ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
#endif
SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cmUnpkRguFlowCntrlInfo(flowCntrlInd, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
#endif
SPutMsg(mBuf);
SPutSBuf(pst->region, pst->pool, (Data *)flowCntrlInd, sizeof(RguFlowCntrlInd));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SPutMsg(mBuf);
- RETVALUE((*func)(pst, suId, flowCntrlInd));
+ return ((*func)(pst, suId, flowCntrlInd));
}
/***********************************************************
/* rgu_c_001.main_3: ccpu00111328: S16 is renamed as MsgLen */
MsgLen msgLen = 0;
if (SFndLenMsg(param->mBuf[i], &msgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SCatMsg(mBuf, param->mBuf[i], M1M2) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
SPutMsg(param->mBuf[i]);
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
}
- CMCHKPK(SPkU8, param->numPdu, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numPdu, mBuf);
+ return ROK;
}
TRC3(cmUnpkRguPduInfo);
- CMCHKUNPK(SUnpkU8, ¶m->numPdu, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numPdu, mBuf);
for (i=0; i<param->numPdu; i++) {
MsgLen msgLen, totalMsgLen;
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, ¶m->mBuf[i]) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRguDBoReport);
- CMCHKPK(SPkU32, param->oldestSduArrTime, mBuf);
- CMCHKPK(SPkU32, param->staPduBo, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->oldestSduArrTime, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->staPduBo, mBuf);
#ifdef CCPU_OPT
- CMCHKPK(SPkU8, param->staPduPrsnt, mBuf);
- CMCHKPK(SPkU16, param->estRlcHdrSz, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->staPduPrsnt, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->estRlcHdrSz, mBuf);
#endif
CMCHKPK(SPkS32, param->bo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(SUnpkS32, ¶m->bo, mBuf);
#ifdef CCPU_OPT
- CMCHKUNPK(SUnpkU16, ¶m->estRlcHdrSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->staPduPrsnt, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->estRlcHdrSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->staPduPrsnt, mBuf);
#endif
- CMCHKUNPK(SUnpkU32, ¶m->staPduBo, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->oldestSduArrTime, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->staPduBo, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->oldestSduArrTime, mBuf);
+ return ROK;
}
\f
if (param->pdu != NULLP)
{
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);
}
case CM_LTE_LCH_PCCH:
CMCHKPK(cmPkLteTimingInfo, ¶m->u.timeToTx, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8,param->pnb,mBuf);
+ CMCHKPK(oduUnpackUInt8,param->pnb,mBuf);
#endif
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->transId, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->transId, mBuf);
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkLteLcType, ¶m->lcType, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->transId, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->transId, mBuf);
switch(param->lcType) {
case CM_LTE_LCH_BCCH:
case CM_LTE_LCH_PCCH:
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8,¶m->pnb, mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->pnb, mBuf);
#endif
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->u.timeToTx, mBuf);
break;
CMCHKUNPK(cmUnpkLteRnti, ¶m->u.rnti, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
SFndLenMsg(mBuf, &msgLen);
if (msgLen > 0)
{
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, ¶m->pdu) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRguLchDatReq);
#ifdef L2_OPTMZ
- CMCHKPK(SPkU8, param->freeBuff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->freeBuff, mBuf);
#endif
- CMCHKPK(SPkU8, param->setMaxUlPrio, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->setMaxUlPrio, mBuf);
CMCHKPK(cmPkRguPduInfo, ¶m->pdu, mBuf);
CMCHKPK(cmPkRguDBoReport, ¶m->boReport, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkRguDBoReport, ¶m->boReport, mBuf);
CMCHKUNPK(cmUnpkRguPduInfo, ¶m->pdu, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->setMaxUlPrio, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->setMaxUlPrio, mBuf);
#ifdef L2_OPTMZ
- CMCHKUNPK(SUnpkU8, ¶m->freeBuff, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->freeBuff, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmPkRguDatReqTb);
/*rgu_c_001.main_5 - ADD - L2M Support */
#ifdef LTE_L2_MEAS
- CMCHKPK(SPkU32, param->tbId, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
#endif
for (i=param->nmbLch-1; i >= 0; i--) {
CMCHKPK(cmPkRguLchDatReq, ¶m->lchData[i], mBuf);
}
- CMCHKPK(SPkU8, param->nmbLch, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
+ return ROK;
}
TRC3(cmUnpkRguDatReqTb);
- CMCHKUNPK(SUnpkU8, ¶m->nmbLch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbLch, mBuf);
for (i=0; i<param->nmbLch; i++) {
CMCHKUNPK(cmUnpkRguLchDatReq, ¶m->lchData[i], mBuf);
}
/*rgu_c_001.main_5 - ADD - L2M Support */
#ifdef LTE_L2_MEAS
- CMCHKUNPK(SUnpkU32, ¶m->tbId, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->tbId, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
{
CMCHKPK(cmPkRguDatReqTb, &datReq->datReqTb[i], mBuf);
}
- CMCHKPK(SPkU8, datReq->nmbOfTbs, mBuf);
- CMCHKPK(SPkU32, datReq->transId, mBuf);
+ CMCHKPK(oduUnpackUInt8, datReq->nmbOfTbs, mBuf);
+ CMCHKPK(oduUnpackUInt32, datReq->transId, mBuf);
CMCHKPK(cmPkLteRnti, datReq->rnti, mBuf);
}
- CMCHKPK(SPkU8, param->nmbOfUeGrantPerTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nmbOfUeGrantPerTti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
retVal = ROK;
#endif
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nmbOfUeGrantPerTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbOfUeGrantPerTti, mBuf);
for(idx = 0; idx < param->nmbOfUeGrantPerTti; idx++)
{
RguDDatReqPerUe *datReq = ¶m->datReq[idx];
CMCHKUNPK(cmUnpkLteRnti, &datReq->rnti, mBuf);
- CMCHKUNPK(SUnpkU32, &datReq->transId, mBuf);
- CMCHKUNPK(SUnpkU8, &datReq->nmbOfTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, &datReq->transId, mBuf);
+ CMCHKUNPK(oduPackUInt8, &datReq->nmbOfTbs, mBuf);
/* rgu_c_001.main_4 - Changes for MIMO feature addition */
for (i=0; i<RGU_MAX_TB; i++)
{
retVal = cmUnpkRguDatReqTb(pst, &datReq->datReqTb[i], mBuf);
if(retVal != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
CMCHKUNPK(cmUnpkRguDatReqTb, &datReq->datReqTb[i], mBuf);
#endif
}
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkRguCDatIndInfo);
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(cmPkLteLcId, param->lcId, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, ¶m->pdu) != ROK)
- RETVALUE(RFAILED);
- RETVALUE(ROK);
+ return RFAILED;
+ return ROK;
}
CMCHKPK(cmPkRguPduInfo, ¶m->pdu, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(cmUnpkRguPduInfo, ¶m->pdu, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
{
msgLen = 0;
//if (SFndLenMsg(param->pduInfo[i].pduBuf, &msgLen) != ROK)
- // RETVALUE(RFAILED);
+ // return RFAILED;
//if (SCatMsg(mBuf, param->pduInfo[i].pduBuf, M1M2) != ROK)
- // RETVALUE(RFAILED);
+ // return RFAILED;
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
CMCHKPK(cmPkLteLcId, param->pduInfo[i].lcId, mBuf);
- CMCHKPK(cmPkBool, param->pduInfo[i].commCh, mBuf);
+ CMCHKPK(oduPackBool, param->pduInfo[i].commCh, mBuf);
}
- CMCHKPK(SPkU8, param->numPdu, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numPdu, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
//CMCHKPK(cmPkLteTimingInfo, ¶m->timeToTx, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
//CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timeToTx, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numPdu, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numPdu, mBuf);
for (i=0; i<param->numPdu; i++)
{
MsgLen totalMsgLen;
- CMCHKUNPK(cmUnpkBool, ¶m->pduInfo[i].commCh, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->pduInfo[i].commCh, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->pduInfo[i].lcId, mBuf);
CMCHKUNPK(cmUnpkMsgLen, ¶m->pduInfo[i].pduLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
//if (SSegMsg(mBuf, totalMsgLen-param->pduInfo[i].pduLen, ¶m->pduInfo[i].pduBuf) != ROK)
- // RETVALUE(RFAILED);
+ // return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
case CM_LTE_LCH_PCCH:
CMCHKPK(cmPkLteTimingInfo, ¶m->u.timeToTx, mBuf);
#ifdef EMTC_ENABLE
- CMCHKPK(SPkU8,param->pnb,mBuf);
- CMCHKPK(SPkU8,param->emtcDiReason,mBuf);
+ CMCHKPK(oduUnpackUInt8,param->pnb,mBuf);
+ CMCHKPK(oduUnpackUInt8,param->emtcDiReason,mBuf);
#endif
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(SPkS32, param->bo, mBuf);
CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
case CM_LTE_LCH_BCCH:
case CM_LTE_LCH_PCCH:
#ifdef EMTC_ENABLE
- CMCHKUNPK(SUnpkU8,¶m->emtcDiReason , mBuf);
- CMCHKUNPK(SUnpkU8,¶m->pnb , mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->emtcDiReason , mBuf);
+ CMCHKUNPK(oduPackUInt8,¶m->pnb , mBuf);
#endif
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->u.timeToTx, mBuf);
break;
CMCHKUNPK(cmUnpkLteRnti, ¶m->u.rnti, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(SPkS32, param->bo, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- CMCHKPK(cmPkBool, param->commCh, mBuf);
+ CMCHKPK(oduPackBool, param->commCh, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* End of packBOStatusInfo */
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(cmUnpkBool, ¶m->commCh, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->commCh, mBuf);
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(SUnpkS32, ¶m->bo, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* End of unpackBOStatusInfo */
\f
CMCHKPK(SPkS16, param->totBufSize, mBuf);
CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteLcId, ¶m->lcId, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->totBufSize, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmPkRguStaIndTb);
#ifdef LTE_L2_MEAS
- CMCHKPK(SPkU16, param->status, mBuf);
- CMCHKPK(SPkU32, param->tbId, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
#endif
for (i=param->nmbLch-1; i >= 0; i--) {
CMCHKPK(cmPkRguLchStaInd, ¶m->lchStaInd[i], mBuf);
}
- CMCHKPK(SPkU8, param->nmbLch, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
+ return ROK;
}
TRC3(cmUnpkRguStaIndTb);
- CMCHKUNPK(SUnpkU8, ¶m->nmbLch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbLch, mBuf);
for (i=0; i<param->nmbLch; i++) {
CMCHKUNPK(cmUnpkRguLchStaInd, ¶m->lchStaInd[i], mBuf);
}
#ifdef LTE_L2_MEAS
- CMCHKUNPK(SUnpkU32, ¶m->tbId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->tbId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->status, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
for(idx = (param->nmbLch-1); idx >= 0; idx--)
{
CMCHKPK(cmPkRguLchStaInd, ¶m->lchSta[idx].lchStaInd, mBuf);
- CMCHKPK(cmPkBool, param->lchSta[idx].commCh, mBuf);
+ CMCHKPK(oduPackBool, param->lchSta[idx].commCh, mBuf);
}
- CMCHKPK(SPkU8, param->nmbLch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timeToTx, mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* End of packSchedRepInfo */
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timeToTx, mBuf);
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nmbLch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbLch, mBuf);
for(idx = 0; idx < param->nmbLch; idx++)
{
- CMCHKUNPK(cmUnpkBool, ¶m->lchSta[idx].commCh, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->lchSta[idx].commCh, mBuf);
CMCHKUNPK(cmUnpkRguLchStaInd, ¶m->lchSta[idx].lchStaInd, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
} /* End of unpackSchedRepInfo */
#endif
{ \
S16 ret; \
if ((ret = func(val, mBuf)) != ROK) \
- RETVALUE(ret); \
+ return (ret); \
}
#define CMCHKPKLOG(func, val, mBuf, errCode, pst) \
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId, __FILE__, \
__LINE__, (ErrCls) ERRCLS_ADD_RES, errCode, (ErrVal)ret, \
"Packing failure"); \
- RETVALUE(ret); \
+ return (ret); \
} \
}
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId, __FILE__, \
__LINE__, (ErrCls) ERRCLS_ADD_RES, errCode, (ErrVal)ret, \
"Packing failure"); \
- RETVALUE(ret); \
+ return (ret); \
} \
}
{ \
S16 ret; \
if ((ret = func(val, mBuf)) != ROK) \
- RETVALUE(ret); \
+ return (ret); \
}
#define CMCHKUNPKLOG(func, val, mBuf, errCode, pst) \
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId, __FILE__, \
__LINE__, (ErrCls) ERRCLS_ADD_RES, (ErrVal)errCode, (ErrVal)ret, \
"Unpacking failure"); \
- RETVALUE(ret); \
+ return (ret); \
} \
}
SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId, __FILE__, \
__LINE__, (ErrCls) ERRCLS_ADD_RES, (ErrVal)errCode, (ErrVal)ret, \
"Unpacking failure"); \
- RETVALUE(ret); \
+ return (ret); \
} \
}
EXTERN Void prntMem ARGS((Data *strtAdr,S16 len));
EXTERN Void prntMsg ARGS((Buffer *mBuf));
EXTERN Void prntMsg1 ARGS((Buffer *mBuf,S16 src,S16 dst));
-EXTERN S16 tst ARGS((void ));
+EXTERN uint8_t tst ARGS((void ));
EXTERN S16 rdConQ ARGS((Data data));
EXTERN S16 SPkS8 ARGS((S8 val,Buffer *mBuf));
-EXTERN S16 SPkU8 ARGS((U8 val,Buffer *mBuf));
+EXTERN S16 oduUnpackUInt8 ARGS((U8 val,Buffer *mBuf));
EXTERN S16 SPkS16 ARGS((S16 val,Buffer *mBuf));
-EXTERN S16 SPkU16 ARGS((U16 val,Buffer *mBuf));
+EXTERN S16 oduUnpackUInt16 ARGS((U16 val,Buffer *mBuf));
EXTERN S16 SPkS32 ARGS((S32 val,Buffer *mBuf));
-EXTERN S16 SPkU32 ARGS((U32 val,Buffer *mBuf));
+EXTERN S16 oduUnpackUInt32 ARGS((U32 val,Buffer *mBuf));
/* ssi_x_001.main_49 : added packing of F32 and F64*/
#ifdef SS_FLOAT
EXTERN S16 SPkF32 ARGS((F32 val,Buffer *mBuf));
EXTERN S16 SPkF64 ARGS((F64 val,Buffer *mBuf));
#endif /* SS_FLOAT */
EXTERN S16 SUnpkS8 ARGS((S8 *val,Buffer *mBuf));
-EXTERN S16 SUnpkU8 ARGS((U8 *val,Buffer *mBuf));
+EXTERN S16 oduPackUInt8 ARGS((U8 *val,Buffer *mBuf));
EXTERN S16 SUnpkS16 ARGS((S16 *val,Buffer *mBuf));
-EXTERN S16 SUnpkU16 ARGS((U16 *val,Buffer *mBuf));
+EXTERN S16 oduPackUInt16 ARGS((U16 *val,Buffer *mBuf));
EXTERN S16 SUnpkS32 ARGS((S32 *val,Buffer *mBuf));
-EXTERN S16 SUnpkU32 ARGS((U32 *val,Buffer *mBuf));
+EXTERN S16 oduPackUInt32 ARGS((U32 *val,Buffer *mBuf));
/* ssi_x_001.main_49 : added unpacking of F32 and F64*/
#ifdef SS_FLOAT
EXTERN S16 SUnpkF32 ARGS((F32 *val,Buffer *mBuf));
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU001, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU002, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU003, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU004, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU005, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU006, (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)ETFU007, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU008, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU009, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU010, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU011, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU012, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU013, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU014, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU015, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU016, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU017, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU018, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUSCHBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU019, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&spId, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU020, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, spId));
+ return ((*func)(pst, suId, spId));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU021, (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)ETFU022, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU023, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUSCHBNDCFM;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU024, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- if (SUnpkU8(&status, mBuf) != ROK) {
+ if (oduPackUInt8(&status, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU025, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, status));
+ return ((*func)(pst, suId, status));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU026, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(reason, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU027, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(spId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU028, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUSCHUBNDREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU029, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SUnpkS16(&reason, mBuf) != ROK) {
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU030, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, reason));
+ return ((*func)(pst, spId, reason));
}
\f
(ErrVal)ETFU031, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(raReqInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuRaReqIndInfo(raReqInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)raReqInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)raReqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(raReqInd);
}
pst->event = (Event) EVTTFURAREQIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU034, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU035, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU036, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&raReqInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&raReqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(raReqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, raReqInd));
+ return ((*func)(pst, suId, raReqInd));
}
\f
(ErrVal)ETFU037, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(recpReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuRecpReqInfo(recpReq, mBuf) != ROK) {
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)recpReq, mBuf) != ROK)
+ if (oduPackPointer((PTR)recpReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(recpReq);
}
pst->event = (Event) EVTTFURECPREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU040, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU041, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&recpReq, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&recpReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU042, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR*)&recpReq, mBuf) != ROK)
+ if (oduUnpackPointer((PTR*)&recpReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(recpReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, recpReq));
+ return ((*func)(pst, spId, recpReq));
}
\f
(ErrVal)ETFU043, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(ulCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuUlCqiIndInfo(ulCqiInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)ulCqiInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)ulCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(ulCqiInd);
}
pst->event = (Event) EVTTFUULCQIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU046, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU047, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU048, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&ulCqiInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&ulCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(ulCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, ulCqiInd));
+ return ((*func)(pst, suId, ulCqiInd));
}
\f
(ErrVal)ETFU049, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(hqInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuHqIndInfo(hqInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)hqInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)hqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(hqInd);
}
pst->event = (Event) EVTTFUHQIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU052, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU053, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU054, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&hqInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&hqInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(hqInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, hqInd));
+ return ((*func)(pst, spId, hqInd));
}
\f
(ErrVal)ETFU055, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(srInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuSrIndInfo(srInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)srInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)srInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(srInd);
}
pst->event = (Event) EVTTFUSRIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU058, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU059, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU060, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&srInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&srInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(srInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, srInd));
+ return ((*func)(pst, spId, srInd));
}
\f
(ErrVal)ETFU061, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(dlCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuDlCqiIndInfo(dlCqiInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)dlCqiInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)dlCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(dlCqiInd);
}
pst->event = (Event) EVTTFUDLCQIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU064, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU065, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU066, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&dlCqiInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&dlCqiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(dlCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, dlCqiInd));
+ return ((*func)(pst, suId, dlCqiInd));
}
(ErrVal)ETFU067, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(rawCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkTfuRawCqiIndInfo(rawCqiInd, mBuf);
if (SPkS16(suId, mBuf) != ROK) {
#endif
TFU_FREE_MEM(rawCqiInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MEM(rawCqiInd);
pst->event = (Event) EVTTFURAWCQIIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU069, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
Mem sMem;
(ErrVal)ETFU070, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cmUnpkTfuRawCqiIndInfo(rawCqiInd, (Ptr)&rawCqiInd->memCp, mBuf);
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, rawCqiInd));
+ return ((*func)(pst, suId, rawCqiInd));
}
\f
(ErrVal)ETFU071, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(srsInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkTfuSrsIndInfo(srsInd, mBuf);
if (SPkS16(suId, mBuf) != ROK) {
#endif
TFU_FREE_MEM(srsInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MEM(srsInd);
pst->event = (Event) EVTTFUSRSIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU073, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
Mem sMem;
(ErrVal)ETFU074, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cmUnpkTfuSrsIndInfo(srsInd, (Ptr)&srsInd->memCp, mBuf);
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, srsInd));
+ return ((*func)(pst, suId, srsInd));
}
#endif
(ErrVal)ETFU075, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(datInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuDatIndInfo(datInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmPkPtr((PTR)datInd, mBuf) != ROK)
+ if(oduPackPointer((PTR)datInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(datInd);
}
pst->event = (Event) EVTTFUDATIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU078, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU079, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU080, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmUnpkPtr((PTR *)&datInd, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&datInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(datInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, datInd));
+ return ((*func)(pst, spId, datInd));
}
\f
(ErrVal)ETFU081, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(crcIndInfo);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuCrcIndInfo(crcIndInfo, mBuf) != ROK) {
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)crcIndInfo, mBuf) != ROK)
+ if (oduPackPointer((PTR)crcIndInfo, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(crcIndInfo);
}
pst->event = (Event) EVTTFUCRCIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU084, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU085, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU086, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&crcIndInfo, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&crcIndInfo, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(crcIndInfo);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, crcIndInfo));
+ return ((*func)(pst, suId, crcIndInfo));
}
\f
(ErrVal)ETFU087, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(timingAdvInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuTimingAdvIndInfo(timingAdvInd, mBuf) != ROK) {
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)timingAdvInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)timingAdvInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(timingAdvInd);
}
pst->event = (Event) EVTTFUTIMINGADVIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU090, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU091, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU092, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&timingAdvInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&timingAdvInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(timingAdvInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, timingAdvInd));
+ return ((*func)(pst, suId, timingAdvInd));
}
\f
(ErrVal)ETFU093, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(datReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuDatReqInfo(datReq, mBuf) != ROK) {
#endif
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmPkPtr((PTR)datReq, mBuf) != ROK)
+ if(oduPackPointer((PTR)datReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(datReq);
}
pst->event = (Event) EVTTFUDATREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU096, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU097, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU098, (ErrVal)0, "Unpacking failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (pst->selector == ODU_SELECTOR_LWLC)
{
- if(cmUnpkPtr((PTR *)&datReq, mBuf) != ROK)
+ if(oduUnpackPointer((PTR *)&datReq, mBuf) != ROK)
{
TFU_FREE_MEM(datReq);
TFU_FREE_MSG(mBuf);
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFUXXX, (ErrVal)0, "LWLC Un-Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, datReq));
+ return ((*func)(pst, spId, datReq));
}
\f
(ErrVal)ETFU099, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MEM(cntrlReq);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuCntrlReqInfo(cntrlReq, mBuf) != ROK) {
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)cntrlReq, mBuf) != ROK)
+ if (oduPackPointer((PTR)cntrlReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(cntrlReq);
}
pst->event = (Event) EVTTFUCNTRLREQ;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU102, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU103, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU104, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&cntrlReq, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&cntrlReq, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(cntrlReq);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, spId, cntrlReq));
+ return ((*func)(pst, spId, cntrlReq));
}
(ErrVal)ETFU105, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuTtiIndInfo(ttiInd, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)ttiInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)ttiInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
/*MS_FIX:71858:Changed to SPutSBuf as being allocated with SGetSBuf*/
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(TfuTtiIndInfo)) != ROK) {
(ErrVal)ETFU108, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
//pst->event = (Event) EVENT_SLOT_IND_TO_MAC;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
#if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU105, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (SPkS16(suId, mBuf) != ROK) {
#if (ERRCLASS & ERRCLS_ADD_RES)
(ErrVal)ETFU107, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pst->event = (Event) EVTTFUNONRTIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
/***********************************************************
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU109, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId));
+ return ((*func)(pst, suId));
}
#endif
(ErrVal)ETFU119, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)pucchDeltaPwr, sizeof(TfuPucchDeltaPwrIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuPucchDeltaPwrIndInfo(pucchDeltaPwr, mBuf) != ROK) {
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)pucchDeltaPwr, mBuf) != ROK)
+ if (oduPackPointer((PTR)pucchDeltaPwr, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(pucchDeltaPwr);
}
pst->event = (Event) EVTTFUPUCCHDELPWR;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU122, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
Mem sMem;
(ErrVal)ETFU123, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU124, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&pucchDeltaPwr, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&pucchDeltaPwr, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
TFU_FREE_MEM(pucchDeltaPwr);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, pucchDeltaPwr));
+ return ((*func)(pst, suId, pucchDeltaPwr));
}
#ifdef TFU_5GTF
TRC3(cmPkTfuRbAssignA1Val324)
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
#ifdef UL_ADPT_DBG
printf("cmPkTfuRbAssignA1Val324 param->ndi %d mcs %d param->hqProcId %d \n",param->ndi,param->mcs,param->hqProcId);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmPkTfuRbAssignB1Val324)
- CMCHKPK(SPkU8, param->bmiHqAckNack, mBuf);
- CMCHKPK(SPkU8, param->RV, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->bmiHqAckNack, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->RV, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
+ return ROK;
}
\f
TRC3(cmPkTfuRbAssignVal326)
- CMCHKPK(SPkU8, param->CyclicShiftInd, mBuf);
- CMCHKPK(SPkU8, param->OCCInd, mBuf);
- CMCHKPK(SPkU8, param->FreqBandIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->CyclicShiftInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->OCCInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->FreqBandIdx, mBuf);
+ return ROK;
}
\f
TRC3(cmUnpkTfuRbAssignA1Val324)
- CMCHKUNPK(SUnpkU8, ¶m->hqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ return ROK;
}
\f
TRC3(cmUnpkTfuRbAssignB1Val324)
- CMCHKUNPK(SUnpkU8, ¶m->hqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->RV, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bmiHqAckNack, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->RV, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bmiHqAckNack, mBuf);
+ return ROK;
}
\f
TRC3(cmUnpkTfuRbAssignVal326)
- CMCHKUNPK(SUnpkU8, ¶m->FreqBandIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->OCCInd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CyclicShiftInd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->FreqBandIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->OCCInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CyclicShiftInd, mBuf);
+ return ROK;
}
TRC3(cmPkTfuDciFormatA1A2Info)
//printf("5GTF_DBG: cmPkTfuDciFormatA1Info() called by eNB\n");
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->UL_PCRS, mBuf);
- CMCHKPK(SPkU8, param->PMI, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
-
- CMCHKPK(SPkU8, param->REMapIdx_DMRS_PCRS_numLayers, mBuf);
- CMCHKPK(SPkU8, param->SRS_Symbol, mBuf);
- CMCHKPK(SPkU8, param->SRS_Config, mBuf);
- CMCHKPK(SPkU8, param->beamSwitch, mBuf);
- CMCHKPK(SPkU8, param->uciOnxPUSCH, mBuf);
-
- CMCHKPK(SPkU8, param->numBSI_Reports, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKPK(SPkU8, param->CSI_BRRS_Indicator, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->CSI_BSI_BRI_Req, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->UL_PCRS, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->PMI, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+
+ CMCHKPK(oduUnpackUInt8, param->REMapIdx_DMRS_PCRS_numLayers, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Symbol, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Config, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamSwitch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->uciOnxPUSCH, mBuf);
+
+ CMCHKPK(oduUnpackUInt8, param->numBSI_Reports, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BRRS_Indicator, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BSI_BRI_Req, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKPK(cmPkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->symbIdx, mBuf);
- CMCHKPK(SPkU8, param->beamIndex, mBuf);
- CMCHKPK(SPkU16, param->RBAssign, mBuf);
- CMCHKPK(SPkU8, param->xPUSCH_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->xPUSCHRange, mBuf);
- CMCHKPK(SPkU8, param->formatType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->symbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->RBAssign, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUSCH_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUSCHRange, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->formatType, mBuf);
+ return ROK;
}
\f
TRC3(cmPkTfuDciFormatB1B2Info)
- CMCHKPK(SPkU8, param->DL_PCRS, mBuf);
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->DL_PCRS, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->AntPorts_numLayers, mBuf);
- CMCHKPK(SPkU8, param->SRS_Symbol, mBuf);
- CMCHKPK(SPkU8, param->SRS_Config, mBuf);
- CMCHKPK(SPkU8, param->beamSwitch, mBuf);
- CMCHKPK(SPkU8, param->freqResIdx_xPUCCH, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->AntPorts_numLayers, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Symbol, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SRS_Config, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamSwitch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->freqResIdx_xPUCCH, mBuf);
- CMCHKPK(SPkU8, param->xPUCCH_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUCCH_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->numBSI_Reports, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKPK(SPkU8, param->CSI_BRRS_Indicator, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKPK(SPkU8, param->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKPK(SPkU8, param->CSI_BSI_BRI_Req, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBSI_Reports, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BRRS_Indicator, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->CSI_BSI_BRI_Req, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKPK(cmPkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKPK(SPkU8, param->symbIdx, mBuf);
- CMCHKPK(SPkU8, param->beamIndex, mBuf);
- CMCHKPK(SPkU16, param->RBAssign, mBuf);
- CMCHKPK(SPkU8, param->xPDSCHRange, mBuf);
- CMCHKPK(SPkU8, param->formatType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->symbIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->RBAssign, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPDSCHRange, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->formatType, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormatA1A2Info)
- CMCHKUNPK(SUnpkU8, ¶m->formatType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUSCHRange, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUSCH_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->RBAssign, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->symbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUSCHRange, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUSCH_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->RBAssign, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->symbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKUNPK(cmUnpkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BSI_BRI_Req, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BRRS_Indicator, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBSI_Reports, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BSI_BRI_Req, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BRRS_Indicator, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBSI_Reports, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->uciOnxPUSCH, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamSwitch, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Config, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Symbol, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->REMapIdx_DMRS_PCRS_numLayers, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->uciOnxPUSCH, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamSwitch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Config, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Symbol, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->REMapIdx_DMRS_PCRS_numLayers, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->PMI, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->UL_PCRS, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->PMI, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->UL_PCRS, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC3(cmUnpkTfuDciFormatB1B2Info)
- CMCHKUNPK(SUnpkU8, ¶m->formatType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPDSCHRange, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->RBAssign, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->symbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->formatType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPDSCHRange, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->RBAssign, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->symbIdx, mBuf);
if(param->RBAssign <= TFU_RIV_324)
{
CMCHKUNPK(cmUnpkTfuRbAssignVal326, ¶m->u.rbAssignVal326, mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BSI_BRI_Req, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSI_BRRS_Indicator, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBSI_Reports, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BSI_BRI_Req, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_SymbIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSI_BRRS_Indicator, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->CSIRS_BRRS_ProcInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBSI_Reports, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUCCH_TxTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->freqResIdx_xPUCCH, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamSwitch, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Config, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SRS_Symbol, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->AntPorts_numLayers, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->DL_PCRS, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUCCH_TxTiming, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->freqResIdx_xPUCCH, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamSwitch, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Config, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SRS_Symbol, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->AntPorts_numLayers, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->DL_PCRS, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuDciFormat0Info)
/* tfu_c_001.main_3: Adding pack for hqProcId */
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
- CMCHKPK(SPkU8, param->txAntenna, mBuf);
- CMCHKPK(SPkU8, param->numCqiBit, mBuf);
- CMCHKPK(SPkU8, param->cqiReq, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txAntenna, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCqiBit, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiReq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
- CMCHKPK(SPkU8, param->ulIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulIdx, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->hoppingBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingBits, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU32, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
#endif
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat0Info)
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
#endif /* TFU_UPGRADE */
- CMCHKUNPK(SUnpkU8, ¶m->hoppingBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->ulIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiReq, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numCqiBit, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txAntenna, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiReq, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numCqiBit, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txAntenna, mBuf);
/* tfu_c_001.main_3: Adding unpack for hqProcId */
- CMCHKUNPK(SUnpkU8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifndef TFU_RESMAP_CHANGE
case TFU_ALLOC_TYPE_MAP:
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->u.resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.resAllocMap[i], mBuf);
}
break;
#endif
case TFU_ALLOC_TYPE_RIV:
- CMCHKPK(SPkU32, param->u.riv, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->u.riv, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuAllocMapOrRiv)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_ALLOC_TYPE_RIV:
- CMCHKUNPK(SUnpkU32, ¶m->u.riv, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->u.riv, mBuf);
break;
/*tfu_c_001.main_7 - ADD - TFU_RESMAP_CHANGE support */
#ifndef TFU_RESMAP_CHANGE
case TFU_ALLOC_TYPE_MAP:
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->u.resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.resAllocMap[i], mBuf);
}
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmPkTfuDciFormat1AllocInfo)
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAllocMap[i], mBuf);
}
- CMCHKPK(SPkU8, param->isAllocType0, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isAllocType0, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuDciFormat1AllocInfo)
- CMCHKUNPK(SUnpkU8, ¶m->isAllocType0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAllocMap[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ return ROK;
}
\f
TRC3(cmPkTfuDciFormat1Info)
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1AllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmPkTfuDciFormat2AAllocInfo)
- CMCHKPK(SPkU8, param->transSwap, mBuf);
- CMCHKPK(SPkU8, param->precoding, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
for (i=1; i >= 0; i--) {
CMCHKPK(cmPkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAllocMap[i], mBuf);
}
- CMCHKPK(SPkU8, param->isAllocType0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAllocType0, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->isAllocType0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAllocMap[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
CMCHKUNPK(cmUnpkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->precoding, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->transSwap, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->precoding, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->transSwap, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
TRC3(cmPkTfuDciFormat6AAllocInfo)
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU32, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat6AAllocInfo)
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
printf("In cmUnpkTfuDciFormat6AAllocInfo :: Passed \n");
- RETVALUE(ROK);
+ return ROK;
}
#endif
TRC3(cmPkTfuDciFormat2AInfo)
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat2AAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTfuDciFormat2AAllocInfo, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
for (i=1; i >= 0; i--) {
CMCHKPK(cmPkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->precoding, mBuf);
- CMCHKPK(SPkU8, param->transSwap, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->precoding, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->transSwap, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
for (i=TFU_MAX_ALLOC_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->resAllocMap[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->resAllocMap[i], mBuf);
}
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKPK(SPkU8, param->isAllocType0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isAllocType0, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->isAllocType0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAllocType0, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
for (i=0; i<TFU_MAX_ALLOC_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->resAllocMap[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->resAllocMap[i], mBuf);
}
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->transSwap, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->precoding, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->transSwap, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->precoding, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
for (i=0; i<=1; i++) {
CMCHKUNPK(cmUnpkTfuDciFormatTbInfo, ¶m->tbInfo[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
CMCHKPK(cmPkTfuDciFormat2AllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmPkTfuDciFormat3Info)
- CMCHKPK(SPkU8, param->isPucch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->tpcCmd[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat3Info)
for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isPucch, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucch, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmPkTfuDciFormat3AInfo)
- CMCHKPK(SPkU8, param->isPucch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPucch, mBuf);
for (i=TFU_MAX_2BIT_TPC-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->tpcCmd[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat3AInfo)
for (i=0; i<TFU_MAX_2BIT_TPC; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isPucch, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucch, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
TRC3(cmPkTfuDciFormat60aInfo)
- CMCHKPK(SPkU8, param->dciRep, mBuf);
- CMCHKPK(SPkU8, param->isSrs, mBuf);
- CMCHKPK(SPkU8, param->cqiReq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiReq, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
- CMCHKPK(SPkU8, param->ulIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulIdx, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->hqProcId, mBuf);
- CMCHKPK(SPkU8, param->rep, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU32, param->riv, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
/***********************************************************
*
TRC3(cmPkTfuPdcchOrderInfoEmtc)
- CMCHKPK(SPkU8, param->ceLevel, mBuf);
- CMCHKPK(SPkU8, param->prachMaskIdx, mBuf);
- CMCHKPK(SPkU8, param->preambleIdx, mBuf);
- CMCHKPK(SPkU32, param->riv, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->ceLevel, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->riv, mBuf);
+ return ROK;
}
/***********************************************************
TRC3(cmPkTfudciformat61aPdsch)
- CMCHKPK(SPkU8, param->isTBMsg4, mBuf);
- CMCHKPK(SPkU8, param->dciRep, mBuf);
- CMCHKPK(SPkU8, param->harqAckOffst, mBuf);
- CMCHKPK(SPkU8, param->pmiCfm, mBuf);
- CMCHKPK(SPkU8, param->tPmi, mBuf);
- CMCHKPK(SPkU8, param->isSrs, mBuf);
- CMCHKPK(SPkU8, param->antPortAndScrId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isTBMsg4, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciRep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqAckOffst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmiCfm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->antPortAndScrId, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->rep, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rep, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
CMCHKPK(cmPkTfuDciFormat6AAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuPdcchOrderInfoEmtc, ¶m->t.pdcchOrder, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isPdcchOrder, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPdcchOrder, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkTfuDciFormat60aInfo)
printf("In cmUnpkTfuDciFormat60aInfo :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rep, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->ulIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->cqiReq, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isSrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciRep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiReq, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciRep, mBuf);
printf("In cmUnpkTfuDciFormat60aInfo :: Exit \n");
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
TRC3(cmUnpkTfuPdcchOrderInfoEmtc)
printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Entry \n");
- CMCHKUNPK(SUnpkU32, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->preambleIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachMaskIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ceLevel, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->preambleIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachMaskIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ceLevel, mBuf);
printf("In cmUnpkTfuPdcchOrderInfoEmtc :: Passed \n");
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkTfuDciFormat61aInfo)
- CMCHKUNPK(SUnpkU8, ¶m->isPdcchOrder, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
printf("1. cmUnpkTfuDciFormat61aInfo :: isPdcchOrder %d \n", param->isPdcchOrder);
switch(param->isPdcchOrder) {
case TRUE:
CMCHKUNPK(cmUnpkTfudciformat61aPdsch, ¶m->t.pdschInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
TRC3(cmPkTfuDciFormat1dAllocInfo)
- CMCHKPK(SPkU8, param->tPmi, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- CMCHKPK(SPkU8, param->isLocal, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat1dAllocInfo)
- CMCHKUNPK(SUnpkU8, ¶m->isLocal, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tPmi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tPmi, mBuf);
+ return ROK;
}
TRC3(cmPkTfuDciFormat1dInfo)
- CMCHKPK(SPkU8, param->dlPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlPwrOffset, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
CMCHKPK(cmPkTfuDciFormat1dAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat1dInfo)
CMCHKUNPK(cmUnpkTfuDciFormat1dAllocInfo, ¶m->allocInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->dlPwrOffset, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlPwrOffset, mBuf);
+ return ROK;
}
TRC3(cmPkTfuDciFormat1cInfo)
- CMCHKPK(SPkU8, param->iTbs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->iTbs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->iTbs, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->iTbs, mBuf);
+ return ROK;
}
TRC3(cmPkTfuDciFormat1bAllocInfo)
- CMCHKPK(SPkU8, param->pmiCfm, mBuf);
- CMCHKPK(SPkU8, param->tPmi, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmiCfm, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- CMCHKPK(SPkU8, param->isLocal, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat1bAllocInfo)
- CMCHKUNPK(SUnpkU8, ¶m->isLocal, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tPmi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pmiCfm, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tPmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmiCfm, mBuf);
+ return ROK;
}
TRC3(cmPkTfuPdcchOrderInfo)
- CMCHKPK(SPkU8, param->prachMaskIdx, mBuf);
- CMCHKPK(SPkU8, param->preambleIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->prachMaskIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->preambleIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuPdcchOrderInfo)
- CMCHKUNPK(SUnpkU8, ¶m->preambleIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->prachMaskIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->preambleIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->prachMaskIdx, mBuf);
+ return ROK;
}
TRC3(cmPkTfuDciFormat1aAllocInfo)
- CMCHKPK(SPkU8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
CMCHKPK(cmPkTknU8, ¶m->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
- CMCHKPK(SPkU8, param->isLocal, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat1aAllocInfo)
- CMCHKUNPK(SUnpkU8, ¶m->isLocal, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ return ROK;
}
TRC3(cmPkTfudciformat1aPdsch)
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
CMCHKPK(cmPkTknU8, ¶m->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTknU8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
#ifdef EMTC_ENABLE
printf("1. cmUnpkTfudciformat61aPdsch :: Entry \n");
CMCHKUNPK(cmUnpkTfuDciFormat6AAllocInfo, ¶m->allocInfo, mBuf);
printf("2. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
printf("3. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->rep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rep, mBuf);
printf("4. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
printf("5. cmUnpkTfudciformat61aPdsch :: Entry \n");
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
printf("6. cmUnpkTfudciformat61aPdsch :: Entry \n");
#endif
- CMCHKUNPK(SUnpkU8, ¶m->antPortAndScrId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->antPortAndScrId, mBuf);
printf("7. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->isSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSrs, mBuf);
printf("8. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->tPmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tPmi, mBuf);
printf("9. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->pmiCfm, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmiCfm, mBuf);
printf("10. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->harqAckOffst, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqAckOffst, mBuf);
printf("11. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->dciRep, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciRep, mBuf);
printf("12. cmUnpkTfudciformat61aPdsch :: Entry \n");
- CMCHKUNPK(SUnpkU8, ¶m->isTBMsg4, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isTBMsg4, mBuf);
printf("1. cmUnpkTfudciformat61aPdsch :: Passed \n");
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
{
TRC3(cmUnpkTfuDirectIndication)
- CMCHKUNPK(SUnpkU8, ¶m->directInd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->directInd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
#endif
{
TRC3(cmUnpkTfuDciFormat62AllocInfo)
- CMCHKUNPK(SUnpkU8, ¶m->riv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->riv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKUNPK(cmUnpkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->repNum, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciSubRepNum, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->repNum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciSubRepNum, mBuf);
+ return ROK;
}
{
TRC3(cmUnpkTfuDciFormat62Info)
- CMCHKUNPK(SUnpkU8, ¶m->isPaging, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPaging, mBuf);
switch(param->isPaging) {
case FALSE:
CMCHKUNPK(cmUnpkTfuDirectIndication, ¶m->t.directIndication, mBuf);
CMCHKUNPK(cmUnpkTfudciformat62Pdsch, ¶m->t.pdschInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmPkTfuDirectIndication)
- CMCHKPK(SPkU8, param->directInd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->directInd, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuDciFormat6AAllocInfo)
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->riv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->riv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmPkTfudciformat62Pdsch)
- CMCHKPK(SPkU8, param->dciSubRepNum, mBuf);
- CMCHKPK(SPkU8, param->repNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciSubRepNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->repNum, mBuf);
CMCHKPK(cmPkTfuDciFormat62AllocInfo, ¶m->format62AllocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuDirectIndication, ¶m->t.directIndication, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isPaging, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPaging, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuPdcchOrderInfo, ¶m->t.pdcchOrder, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isPdcchOrder, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPdcchOrder, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormat1aInfo)
- CMCHKUNPK(SUnpkU8, ¶m->isPdcchOrder, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPdcchOrder, mBuf);
switch(param->isPdcchOrder) {
case TRUE:
CMCHKUNPK(cmUnpkTfuPdcchOrderInfo, ¶m->t.pdcchOrder, mBuf);
CMCHKUNPK(cmUnpkTfudciformat1aPdsch, ¶m->t.pdschInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuDciFormat1bInfo)
- CMCHKPK(SPkU8, param->tpcCmd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->dai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1bAllocInfo, ¶m->allocInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTfuDciFormat1bAllocInfo, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->dai, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dai, mBuf);
#endif
- CMCHKUNPK(SUnpkU8, ¶m->tpcCmd, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
+ return ROK;
}
CMCHKPK(cmPkTfuDciFormat0Info, ¶m->u.format0Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->dciFormat, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->dciFormat, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->dciFormat, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->dciFormat, mBuf);
switch(param->dciFormat) {
case TFU_DCI_FORMAT_0:
CMCHKUNPK(cmUnpkTfuDciFormat0Info, ¶m->u.format0Info, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuSubbandInfo)
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuSubbandInfo)
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ return ROK;
}
TRC3(cmPkTfuSubbandCqiInfo)
- CMCHKPK(SPkU8, param->cqiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subband, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuSubbandCqiInfo)
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subband, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
+ return ROK;
}
TRC3(cmPkTfuPdcchCceInfo)
CMCHKPK(cmPkLteAggrLvl, param->aggrLvl, mBuf);
- CMCHKPK(SPkU8, param->cceIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cceIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuPdcchCceInfo)
- CMCHKUNPK(SUnpkU8, ¶m->cceIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cceIdx, mBuf);
CMCHKUNPK(cmUnpkLteAggrLvl,(U32 *)¶m->aggrLvl, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
switch(param->type) {
case TFU_RPT_CQI:
- CMCHKPK(SPkU8, param->u.cqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiPucchMode10)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
- CMCHKUNPK(SUnpkU8, ¶m->u.cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuCqiMode11Cqi)
CMCHKPK(cmPkTknU8, ¶m->wideDiffCqi, mBuf);
- CMCHKPK(SPkU8, param->pmi, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiMode11Cqi)
- CMCHKUNPK(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->wideDiffCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiMode11Cqi, ¶m->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiPucchMode11)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
CMCHKUNPK(cmUnpkTfuCqiMode11Cqi, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuCqiMode20SubCqi)
- CMCHKPK(SPkU8, param->l, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->l, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiMode20SubCqi)
- CMCHKUNPK(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->l, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiMode20SubCqi, ¶m->u.subCqi, mBuf);
break;
case TRUE:
- CMCHKPK(SPkU8, param->u.wideCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.wideCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isWideband, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isWideband, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiMode20Cqi)
- CMCHKUNPK(SUnpkU8, ¶m->isWideband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
case TRUE:
- CMCHKUNPK(SUnpkU8, ¶m->u.wideCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.wideCqi, mBuf);
break;
case FALSE:
CMCHKUNPK(cmUnpkTfuCqiMode20SubCqi, ¶m->u.subCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiMode20Cqi, ¶m->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiPucchMode20)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
CMCHKUNPK(cmUnpkTfuCqiMode20Cqi, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuCqiMode21SubCqi)
CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
- CMCHKPK(SPkU8, param->l, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->l, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiMode21SubCqi)
- CMCHKUNPK(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->l, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuCqiMode21WideCqi)
CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
- CMCHKPK(SPkU8, param->pmi, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiMode21WideCqi)
- CMCHKUNPK(SUnpkU8, ¶m->cqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiMode21WideCqi, ¶m->u.wideCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU8, param->isWideband, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isWideband, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiMode21Cqi)
- CMCHKUNPK(SUnpkU8, ¶m->isWideband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isWideband, mBuf);
switch(param->isWideband) {
case TRUE:
CMCHKUNPK(cmUnpkTfuCqiMode21WideCqi, ¶m->u.wideCqi, mBuf);
CMCHKUNPK(cmUnpkTfuCqiMode21SubCqi, ¶m->u.subCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiMode21Cqi, ¶m->u.cqi, mBuf);
break;
case TFU_RPT_RI:
- CMCHKPK(SPkU8, param->u.ri, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->u.ri, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuCqiPucchMode21)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
- CMCHKUNPK(SUnpkU8, ¶m->u.ri, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
break;
case TFU_RPT_CQI:
CMCHKUNPK(cmUnpkTfuCqiMode21Cqi, ¶m->u.cqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiPucchMode10, ¶m->u.mode10Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->mode, mBuf);
- CMCHKPK(SPkU8, param->cellIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDlCqiPucch)
- CMCHKUNPK(SUnpkU8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUCCH_CQI_MODE10:
CMCHKUNPK(cmUnpkTfuCqiPucchMode10, ¶m->u.mode10Info, mBuf);
CMCHKUNPK(cmUnpkTfuCqiPucchMode21, ¶m->u.mode21Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuSubbandMode12)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
- CMCHKPK(SPkU8, param->pmi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuSubbandMode12)
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuSubbandMode12, ¶m->subbandArr[i], mBuf);
}
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqiIdx[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuCqiPuschMode12)
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx[i], mBuf);
}
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandMode12, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideBandCqi, mBuf);
- CMCHKPK(SPkU8, param->cqiIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuCqiPuschMode20)
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
\f
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideBandPmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandPmi, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->wideBandCqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi[i], mBuf);
}
- CMCHKPK(SPkU8, param->pmi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuCqiPuschMode22)
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->wideBandPmi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandPmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuSubbandMode30)
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
- CMCHKPK(SPkU8, param->cqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuSubbandMode30)
- CMCHKUNPK(SUnpkU8, ¶m->cqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
for (i=TFU_MAX_DL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuSubbandMode30, ¶m->subbandArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideBandCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuCqiPuschMode30)
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_DL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuSubbandMode30, ¶m->subbandArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subBand, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqi[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuSubbandMode31)
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqi[i], mBuf);
}
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subBand, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuSubbandDlCqiInfo, ¶m->subbandCqiArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->wideBandCqi[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideBandCqi[i], mBuf);
}
- CMCHKPK(SPkU8, param->pmi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuCqiPuschMode31)
- CMCHKUNPK(SUnpkU8, ¶m->pmi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->wideBandCqi[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideBandCqi[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
/* tfu_c_001.main_4 - Changes for MIMO feature addition */
/* tfu_c_001.main_5 - Removed dependency on MIMO compile-time flag */
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
CMCHKPK(cmPkTknU8, ¶m->ri, mBuf);
- CMCHKPK(SPkU32, param->mode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
- CMCHKPK(SPkU8, param->cellIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDlCqiPusch)
- CMCHKUNPK(SUnpkU8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->ri, mBuf);
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_12:
CMCHKUNPK(cmUnpkTfuCqiPuschMode31, ¶m->u.mode31Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
{
CMCHKPK(cmPkTfuDlCqiPusch, ¶m->pusch.puschCqi[idx], mBuf);
}
- CMCHKPK(SPkU8, param->pusch.numOfCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pusch.numOfCells, mBuf);
break;
case TRUE:
CMCHKPK(cmPkTfuDlCqiPucch, ¶m->pucchCqi, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTfuDlCqiPucch, ¶m->pucchCqi, mBuf);
break;
case FALSE:
- CMCHKUNPK(SUnpkU8, ¶m->pusch.numOfCells, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pusch.numOfCells, mBuf);
for (idx = param->pusch.numOfCells; idx > 0; idx--)
{
CMCHKUNPK(cmUnpkTfuDlCqiPusch, ¶m->pusch.puschCqi[idx-1], mBuf);
}
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*ccpu00116923 - ADD - SRS present support*/
/*tfu_c_001.main_7 - ADD - SRS present field inclusion */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU8, param->srsPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->srsPres, mBuf);
#endif
count = param->ueRecpReqLst.count;
node = param->ueRecpReqLst.last;
cmLListDelFrm(¶m->ueRecpReqLst, &tfuUeRecpReqInfo->lnk);
tfuUeRecpReqInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->ueRecpReqLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuUeRecpReqInfo), (Ptr *)&tfuUeRecpReqInfo);
CMCHKUNPK(cmUnpkTfuUeRecpReqInfo, tfuUeRecpReqInfo, mBuf);
/*ccpu00116923 - ADD - SRS present support*/
/*tfu_c_001.main_7 - ADD - SRS present field inclusion */
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU8, ¶m->srsPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->srsPres, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuPdcchInfo)
#ifdef TFU_5GTF
- CMCHKPK(SPkU8, param->grpId, mBuf);
- CMCHKPK(SPkU8, param->sccIdx, mBuf);
- CMCHKPK(SPkU8, param->sectorId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sectorId, mBuf);
#endif /* TFU_5GTF */
CMCHKPK(cmPkTfuDciInfo, ¶m->dci, mBuf);
- CMCHKPK(SPkU8, param->dciNumOfBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dciNumOfBits, mBuf);
CMCHKPK(cmPkLteAggrLvl, param->aggrLvl, mBuf);
- CMCHKPK(SPkU16, param->nCce, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nCce, mBuf);
#ifdef LTEMAC_SPS
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
- CMCHKPK(SPkU8, param->isSpsRnti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isSpsRnti, mBuf);
#endif
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
#ifdef LTEMAC_SPS
- CMCHKUNPK(SUnpkU8, ¶m->isSpsRnti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isSpsRnti, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
- CMCHKUNPK(SUnpkU16, ¶m->nCce, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->nCce, mBuf);
CMCHKUNPK(cmUnpkLteAggrLvl, (U32*)¶m->aggrLvl, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dciNumOfBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dciNumOfBits, mBuf);
CMCHKUNPK(cmUnpkTfuDciInfo, ¶m->dci, mBuf);
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->sectorId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sccIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->grpId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sectorId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sccIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->grpId, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuPhichInfo)
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU16, param->txPower, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txPower, mBuf);
#endif
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->iPhich, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->iPhich, mBuf);
#endif
- CMCHKPK(SPkU8, param->isAck, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->isAck, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuPhichInfo)
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isAck, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isAck, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->iPhich, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->iPhich, mBuf);
#endif
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU16, ¶m->txPower, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txPower, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
cmLListDelFrm(¶m->dlMpdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
count = param->ulMpdcchLst.count;
node = param->ulMpdcchLst.last;
while (node) {
cmLListDelFrm(¶m->ulMpdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
#endif
#ifdef LTEMAC_SPS /* SPS_NEW_CHGS */
- CMCHKPK(cmPkBool, param->isSPSOcc, mBuf);
+ CMCHKPK(oduPackBool, param->isSPSOcc, mBuf);
#endif
count = param->phichLst.count;
node = param->phichLst.last;
cmLListDelFrm(¶m->phichLst, &tfuPhichInfo->lnk);
tfuPhichInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
count = param->dlPdcchLst.count;
node = param->dlPdcchLst.last;
while (node) {
cmLListDelFrm(¶m->dlPdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
count = param->ulPdcchLst.count;
node = param->ulPdcchLst.last;
while (node) {
cmLListDelFrm(¶m->ulPdcchLst, &tfuPdcchInfo->lnk);
tfuPdcchInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
- CMCHKPK(SPkU8, param->cfi, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->dlTiming, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->ulTiming, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->ulTiming, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->dlTiming, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cfi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cfi, mBuf);
cmLListInit(¶m->ulPdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
CMCHKUNPK(cmUnpkTfuPdcchInfo, tfuPdcchInfo, mBuf);
tfuPdcchInfo->lnk.node = (PTR)tfuPdcchInfo;
}
cmLListInit(¶m->dlPdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
CMCHKUNPK(cmUnpkTfuPdcchInfo, tfuPdcchInfo, mBuf);
tfuPdcchInfo->lnk.node = (PTR)tfuPdcchInfo;
}
cmLListInit(¶m->phichLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPhichInfo), (Ptr *)&tfuPhichInfo);
CMCHKUNPK(cmUnpkTfuPhichInfo, tfuPhichInfo, mBuf);
}
#ifdef LTEMAC_SPS /* SPS_NEW_CHGS */
- CMCHKUNPK(cmUnpkBool, ¶m->isSPSOcc, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->isSPSOcc, mBuf);
#endif
#ifdef EMTC_ENABLE
cmLListInit(¶m->ulMpdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
CMCHKUNPK(cmUnpkTfuPdcchInfo, tfuPdcchInfo, mBuf);
tfuPdcchInfo->lnk.node = (PTR)tfuPdcchInfo;
}
cmLListInit(¶m->dlMpdcchLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
printf("4. cmUnpkTfuCntrlReqInfo :: count %ld \n", count);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPdcchInfo), (Ptr *)&tfuPdcchInfo);
printf("5. cmUnpkTfuCntrlReqInfo :: Failed \n");
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuDciFormat1AllocInfo, ¶m->u.format1AllocInfo, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->format, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->format, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuPdschDciInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->format, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->format, mBuf);
switch(param->format) {
case TFU_DCI_FORMAT_1:
CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, ¶m->u.format1AllocInfo, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
for(idx=TFU_MAX_DL_SUBBAND-1;idx>=0; idx--)
{
for (idx2=param->numPhyAnt -1; idx2 >= 0; idx2--) {
- CMCHKPK(SPkU16, param->bfValue[idx2], mBuf);}
- CMCHKPK(SPkU8, param->numPhyAnt, mBuf);
- CMCHKPK(SPkU8, param->sbIndex, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->bfValue[idx2], mBuf);}
+ CMCHKPK(oduUnpackUInt8, param->numPhyAnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sbIndex, mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkTfuBfVectorInfo)
for(idx=0;idx<TFU_MAX_DL_SUBBAND; idx++)
{
- CMCHKUNPK(SUnpkU8, ¶m->sbIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numPhyAnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sbIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numPhyAnt, mBuf);
for (idx2=0; idx2 <param->numPhyAnt; idx2++) {
- CMCHKUNPK(SUnpkU16, ¶m->bfValue[idx2], mBuf);}
+ CMCHKUNPK(oduPackUInt16, ¶m->bfValue[idx2], mBuf);}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
TRC3(cmPkTfuDatReqPduInfo)
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKPK(SPkU8, param->isEnbSFR, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isEnbSFR, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKPK(SPkU16, param->txPwrOffset, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->txPwrOffset, mBuf);
if(param->transMode == TFU_UE_TM_7)
{
CMCHKPK(cmPkTfuBfVectorInfo, param->bfVector, mBuf);
- CMCHKPK(SPkU8, param->numBfVectors, mBuf);
- CMCHKPK(SPkU8, param->numBfPrbPerSb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBfVectors, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBfPrbPerSb, mBuf);
}
- CMCHKPK(SPkU8, param->deltaPowOffIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->deltaPowOffIdx, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKPK(SPkU8, param->pa, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pa, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKPK(SPkU8, param->numLayers, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numLayers, mBuf);
#endif
- CMCHKPK(cmPkBool, param->isTApres, mBuf);
+ CMCHKPK(oduPackBool, param->isTApres, mBuf);
CMCHKPK(cmPkTknU32, ¶m->doa, mBuf);
- CMCHKPK(SPkU32, param->transMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->transMode, mBuf);
CMCHKPK(cmPkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
- CMCHKPK(SPkU8, param->puschRptUsd, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschRptUsd, mBuf);
for (i = 0; i < TFU_MAX_TB; i++)
{
#ifndef L2_OPTMZ
mBuf);
}
- CMCHKPK(SPkU32, param->tbInfo[i].lchInfo[lchIdx].numPdu, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbInfo[i].lchInfo[lchIdx].numPdu, mBuf);
}
- CMCHKPK(SPkU32, param->tbInfo[i].numLch, mBuf);
- CMCHKPK(SPkU32, param->tbInfo[i].padSize, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbInfo[i].numLch, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->tbInfo[i].padSize, mBuf);
CMCHKPK(cmPkBuffer, ¶m->tbInfo[i].macCes, mBuf);
CMCHKPK(cmPkBuffer, ¶m->tbInfo[i].macHdr, mBuf);
CMCHKPK(cmPkMsgLen, param->tbInfo[i].tbSize, mBuf);
- CMCHKPK(cmPkBool, param->tbInfo[i].tbPres, mBuf);
+ CMCHKPK(oduPackBool, param->tbInfo[i].tbPres, mBuf);
#endif
}
- CMCHKPK(SPkU8, tbMask, mBuf);
- CMCHKPK(SPkU8, param->nmbOfTBs, mBuf);
+ CMCHKPK(oduUnpackUInt8, tbMask, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nmbOfTBs, mBuf);
CMCHKPK(cmPkTfuPdschDciInfo, ¶m->dciInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkTfuPdschDciInfo, ¶m->dciInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nmbOfTBs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbOfTBs, mBuf);
- CMCHKUNPK(SUnpkU8, &tbMask, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tbMask, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
#ifndef L2_OPTMZ
if (tbMask & (1<<i))
param->mBuf[i] = NULLP;
}
#else /* L2_OPTMZ*/
- CMCHKUNPK(cmUnpkBool, ¶m->tbInfo[i].tbPres, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->tbInfo[i].tbPres, mBuf);
CMCHKUNPK(cmUnpkMsgLen, ¶m->tbInfo[i].tbSize, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macHdr, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macCes, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->tbInfo[i].padSize, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->tbInfo[i].numLch, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->tbInfo[i].padSize, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tbInfo[i].numLch, mBuf);
for(lchIdx = 0; lchIdx < param->tbInfo[i].numLch; lchIdx++)
{
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->tbInfo[i].lchInfo[lchIdx].numPdu,
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tbInfo[i].lchInfo[lchIdx].numPdu,
mBuf);
for(pduIdx = 0; pduIdx < param->tbInfo[i].lchInfo[lchIdx].numPdu;
pduIdx++)
#endif /* L2_OPTMZ*/
}
- CMCHKUNPK(SUnpkU8, ¶m->puschRptUsd, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschRptUsd, mBuf);
CMCHKUNPK(cmUnpkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->transMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->transMode, mBuf);
CMCHKUNPK(cmUnpkTknU32, ¶m->doa, mBuf);
- CMCHKUNPK(cmUnpkBool, ¶m->isTApres, mBuf);
+ CMCHKUNPK(oduUnpackBool, ¶m->isTApres, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- CMCHKUNPK(SUnpkU8, ¶m->numLayers, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numLayers, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKUNPK(SUnpkU8, ¶m->pa, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pa, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKUNPK(SUnpkU8, ¶m->deltaPowOffIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->deltaPowOffIdx, mBuf);
if(param->transMode == TFU_UE_TM_7)
{
- CMCHKUNPK(SUnpkU8, ¶m->numBfPrbPerSb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBfVectors, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBfPrbPerSb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBfVectors, mBuf);
CMCHKUNPK(cmUnpkTfuBfVectorInfo, param->bfVector, mBuf);
}
- CMCHKUNPK(SUnpkU16, ¶m->txPwrOffset, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->txPwrOffset, mBuf);
#endif
/* LTE_ADV_FLAG_REMOVED_START */
- CMCHKUNPK(SUnpkU8, ¶m->isEnbSFR, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isEnbSFR, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- RETVALUE(ROK);
+ return ROK;
}
cmLListDelFrm(¶m->pdus, &tfuDatReqPduInfo->lnk);
tfuDatReqPduInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkTknBuf, ¶m->bchDat, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKUNPK(cmUnpkTknBuf, ¶m->bchDat, &mBuf);
cmLListInit(¶m->pdus);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDatReqPduInfo), (Ptr *)&tfuDatReqPduInfo);
CMCHKUNPK(cmUnpkTfuDatReqPduInfo, tfuDatReqPduInfo, mBuf);
cmLListAdd2Tail(¶m->pdus, &tfuDatReqPduInfo->lnk);
tfuDatReqPduInfo->lnk.node = (PTR)tfuDatReqPduInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkBuffer, ¶m->mBuf, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->mBuf, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuDatIndInfo)
#ifdef TFU_5GTF
- CMCHKPK(SPkU8, param->sccIdx, mBuf);
- CMCHKPK(SPkU8, param->sectorId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sectorId, mBuf);
#endif /* TFU_5GTF */
count = param->datIndLst.count;
node = param->datIndLst.last;
cmLListDelFrm(¶m->datIndLst, &tfuDatInfo->lnk);
tfuDatInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->datIndLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDatInfo), (Ptr *)&tfuDatInfo);
CMCHKUNPK(cmUnpkTfuDatInfo, tfuDatInfo, mBuf);
tfuDatInfo->lnk.node = (PTR)tfuDatInfo;
}
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->sectorId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sccIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sectorId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sccIdx, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuSrInfo)
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuSrInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
cmLListDelFrm(¶m->srLst, &tfuSrInfo->lnk);
tfuSrInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->srLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuSrInfo), (Ptr *)&tfuSrInfo);
CMCHKUNPK(cmUnpkTfuSrInfo, tfuSrInfo, mBuf);
cmLListAdd2Tail(¶m->srLst, &tfuSrInfo->lnk);
tfuSrInfo->lnk.node = (PTR)tfuSrInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
S32 i;
TRC3(cmPkTfuHqInfo)
- CMCHKPK(SPkU8, param->isPusch, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isPusch, mBuf);
for (i=TFU_MAX_HARQ_FDBKS-1; i >= 0; i--) {
- CMCHKPK(SPkU32, param->isAck[i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->isAck[i], mBuf);
}
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->M, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->M, mBuf);
#endif/*TFU_TDD*/
- CMCHKPK(SPkU8, param->noOfTbs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->noOfTbs, mBuf);
/* ACC-TDD ccpu00130520 */
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
/* ACC-TDD ccpu00130520 */
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->noOfTbs, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->noOfTbs, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->M, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->M, mBuf);
#endif
for (i=0; i<TFU_MAX_HARQ_FDBKS; i++) {
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->isAck[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->isAck[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->isPusch, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPusch, mBuf);
+ return ROK;
}
cmLListDelFrm(¶m->hqIndLst, &tfuHqInfo->lnk);
tfuHqInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->hqIndLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuHqInfo), (Ptr *)&tfuHqInfo);
CMCHKUNPK(cmUnpkTfuHqInfo, tfuHqInfo, mBuf);
cmLListAdd2Tail(¶m->hqIndLst, &tfuHqInfo->lnk);
tfuHqInfo->lnk.node = (PTR)tfuHqInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuUlCqiInfo)
CMCHKPK(cmPkTfuSubbandCqiInfo, ¶m->subbandCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuUlCqiInfo)
CMCHKUNPK(cmUnpkTfuSubbandCqiInfo, ¶m->subbandCqi, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
for (i=TFU_MAX_UL_SUBBAND-1; i >= 0; i--) {
CMCHKPK(cmPkTfuUlCqiInfo, ¶m->ulCqiInfoArr[i], mBuf);
}
- CMCHKPK(SPkU8, param->numSubband, mBuf);
- CMCHKPK(SPkU8, param->wideCqi, mBuf);
- CMCHKPK(SPkU8, param->isTxPort0, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numSubband, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isTxPort0, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuUlCqiRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isTxPort0, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->wideCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numSubband, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isTxPort0, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numSubband, mBuf);
for (i=0; i<TFU_MAX_UL_SUBBAND; i++) {
CMCHKUNPK(cmUnpkTfuUlCqiInfo, ¶m->ulCqiInfoArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
cmLListDelFrm(¶m->ulCqiRpt, &tfuUlCqiRpt->lnk);
tfuUlCqiRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->ulCqiRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuUlCqiRpt), (Ptr *)&tfuUlCqiRpt);
CMCHKUNPK(cmUnpkTfuUlCqiRpt, tfuUlCqiRpt, mBuf);
cmLListAdd2Tail(¶m->ulCqiRpt, &tfuUlCqiRpt->lnk);
tfuUlCqiRpt->lnk.node = (PTR)tfuUlCqiRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuDlCqiRpt)
if (cmPkTfuDlCqiInfo(param->isPucchInfo, ¶m->dlCqiInfo, mBuf) != ROK)
- RETVALUE(RFAILED);
- CMCHKPK(SPkU8, param->isPucchInfo, mBuf);
+ return RFAILED;
+ CMCHKPK(oduUnpackUInt8, param->isPucchInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDlCqiRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isPucchInfo, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isPucchInfo, mBuf);
if (cmUnpkTfuDlCqiInfo (param->isPucchInfo, ¶m->dlCqiInfo, mBuf) != ROK)
- RETVALUE(RFAILED);
- RETVALUE(ROK);
+ return RFAILED;
+ return ROK;
}
cmLListDelFrm(¶m->dlCqiRptsLst, &tfuDlCqiRpt->lnk);
tfuDlCqiRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->dlCqiRptsLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDlCqiRpt), (Ptr *)&tfuDlCqiRpt);
CMCHKUNPK(cmUnpkTfuDlCqiRpt, tfuDlCqiRpt, mBuf);
cmLListAdd2Tail(¶m->dlCqiRptsLst, &tfuDlCqiRpt->lnk);
tfuDlCqiRpt->lnk.node = (PTR)tfuDlCqiRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuCrcInfo)
CMCHKPK(cmPkTknU8, ¶m->rv, mBuf);
- CMCHKPK(SPkU8, param->isFailure, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isFailure, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuCrcInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isFailure, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isFailure, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->rv, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuCrcIndInfo)
#ifdef TFU_5GTF
- CMCHKPK(SPkU8, param->sccIdx, mBuf);
- CMCHKPK(SPkU8, param->sectorId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sccIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->sectorId, mBuf);
#endif /* TFU_5GTF */
count = param->crcLst.count;
node = param->crcLst.last;
cmLListDelFrm(¶m->crcLst, &tfuCrcIndInfo->lnk);
tfuCrcIndInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->crcLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuCrcIndInfo), (Ptr *)&tfuCrcIndInfo);
CMCHKUNPK(cmUnpkTfuCrcInfo, tfuCrcIndInfo, mBuf);
tfuCrcIndInfo->lnk.node = (PTR)tfuCrcIndInfo;
}
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->sectorId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->sccIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sectorId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->sccIdx, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuTimingAdvInfo)
- CMCHKPK(SPkU8, param->timingAdv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->timingAdv, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuTimingAdvInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->timingAdv, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->timingAdv, mBuf);
+ return ROK;
}
cmLListDelFrm(¶m->timingAdvLst, &tfuTimingAdvInfo->lnk);
tfuTimingAdvInfo->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->timingAdvLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuTimingAdvInfo), (Ptr *)&tfuTimingAdvInfo);
CMCHKUNPK(cmUnpkTfuTimingAdvInfo, tfuTimingAdvInfo, mBuf);
cmLListAdd2Tail(¶m->timingAdvLst, &tfuTimingAdvInfo->lnk);
tfuTimingAdvInfo->lnk.node = (PTR)tfuTimingAdvInfo;
}
- RETVALUE(ROK);
+ return ROK;
}
/*CA dev Start*/
TRC3(cmPkTfuTtiCellInfo)
- CMCHKPK(SPkU8, param->ulBlankSf, mBuf);
- CMCHKPK(SPkU8, param->dlBlankSf, mBuf);
- CMCHKPK(SPkU8, param->schTickDelta, mBuf);
- CMCHKPK(cmPkBool, param->isDummyTti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulBlankSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->dlBlankSf, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->schTickDelta, mBuf);
+ CMCHKPK(oduPackBool, param->isDummyTti, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*CA dev End*/
\f
for (i=(param->numCells-1); i >= 0; i--) {
CMCHKPK(cmPkTfuTtiCellInfo, ¶m->cells[i], mBuf);
}
- CMCHKPK(SPkU8, param->numCells, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
/*CA dev End*/
- RETVALUE(ROK);
+ return ROK;
}
/* CA dev Start */
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
- CMCHKUNPK(cmUnpkBool, ¶m->isDummyTti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->schTickDelta, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->dlBlankSf, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulBlankSf, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduUnpackBool, ¶m->isDummyTti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->schTickDelta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->dlBlankSf, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulBlankSf, mBuf);
+ return ROK;
}
/* CA dev End */
TRC3(cmPkTfuRaReqInfo)
- CMCHKPK(SPkU8, param->cqiIdx, mBuf);
- CMCHKPK(SPkU8, param->cqiPres, mBuf);
- CMCHKPK(SPkU8, param->tpc, mBuf);
- CMCHKPK(SPkU16, param->ta, mBuf);
- CMCHKPK(SPkU8, param->rapId, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->tpc, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ta, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rapId, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuRaReqInfo)
- CMCHKUNPK(SUnpkU8, ¶m->rapId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->ta, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->tpc, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->rapId, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->ta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->tpc, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx, mBuf);
+ return ROK;
}
CMCHKPK(cmPkTfuRaReqInfo, &(param->raReqInfoArr[i]), mBuf);
}
#ifdef PRACH_5GTF
- CMCHKPK(SPkU16, param->nPwrFactor, mBuf);
- CMCHKPK(SPkU8, param->nPRACHSymbIndex, mBuf);
- CMCHKPK(SPkU8, param->nf1Value, mBuf);
- CMCHKPK(SPkU8, param->nCyclicShift, mBuf);
- CMCHKPK(SPkU8, param->nRootSeq, mBuf);
- CMCHKPK(SPkU8, param->nPRACHConfiguration, mBuf);
- CMCHKPK(SPkU8, param->nPreambleFormat, mBuf);
-#endif
- CMCHKPK(SPkU8, param->numRaReqInfo, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->nPwrFactor, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nPRACHSymbIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nf1Value, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nCyclicShift, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nRootSeq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nPRACHConfiguration, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nPreambleFormat, mBuf);
+#endif
+ CMCHKPK(oduUnpackUInt8, param->numRaReqInfo, mBuf);
CMCHKPK(cmPkLteRnti, param->raRnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuRachInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->raRnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRaReqInfo, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRaReqInfo, mBuf);
#ifdef PRACH_5GTF
- CMCHKUNPK(SPkU8, param->nPreambleFormat, mBuf);
- CMCHKUNPK(SPkU8, param->nPRACHConfiguration, mBuf);
- CMCHKUNPK(SPkU8, param->nRootSeq, mBuf);
- CMCHKUNPK(SPkU8, param->nCyclicShift, mBuf);
- CMCHKUNPK(SPkU8, param->nf1Value, mBuf);
- CMCHKUNPK(SPkU8, param->nPRACHSymbIndex, mBuf);
- CMCHKUNPK(SPkU16, param->nPwrFactor, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nPreambleFormat, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nPRACHConfiguration, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nRootSeq, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nCyclicShift, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nf1Value, mBuf);
+ CMCHKUNPK(oduUnpackUInt8, param->nPRACHSymbIndex, mBuf);
+ CMCHKUNPK(oduUnpackUInt16, param->nPwrFactor, mBuf);
#endif
if (cmGetMem (&(memCp), (sizeof(TfuRaReqInfo) * param->numRaReqInfo),
(Ptr *)¶m->raReqInfoArr) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i=0; i<param->numRaReqInfo; i++) {
CMCHKUNPK(cmUnpkTfuRaReqInfo, ¶m->raReqInfoArr[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
if (ROK != cmPkTfuRachInfo(param->memCp,
&(param->rachInfoArr[i]), mBuf))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- CMCHKPK(SPkU8, param->nmbOfRaRnti, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nmbOfRaRnti, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nmbOfRaRnti, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nmbOfRaRnti, mBuf);
if (cmGetMem (&(param->memCp), (sizeof(TfuRachInfo) * param->nmbOfRaRnti),
(Ptr *)¶m->rachInfoArr) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i=0; i<param->nmbOfRaRnti; i++)
{
if (ROK != cmUnpkTfuRachInfo(param->memCp, ¶m->rachInfoArr[i], mBuf))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(SPkS8, param->pucchDeltaPwr, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pucchDeltaPwr, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
cmLListDelFrm(¶m->pucchDeltaPwrLst, &tfuPucchDeltaPwr->lnk);
tfuPucchDeltaPwr->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->pucchDeltaPwrLst);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuPucchDeltaPwr), (Ptr *)&tfuPucchDeltaPwr);
CMCHKUNPK(cmUnpkTfuPucchDeltaPwrInfo, tfuPucchDeltaPwr, mBuf);
cmLListAdd2Tail(¶m->pucchDeltaPwrLst, &tfuPucchDeltaPwr->lnk);
tfuPucchDeltaPwr->lnk.node = (PTR)tfuPucchDeltaPwr;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
MsgLen msgLen=0;
TRC3(cmPkBuffer)
if (SFndLenMsg(*param, &msgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SCatMsg(mBuf, *param, M1M2) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
TFU_FREE_MSG(*param);
*param = NULLP;
CMCHKPK(cmPkMsgLen, msgLen, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
PUBLIC S16 cmUnpkBuffer
TRC3(cmUnpkBuffer)
CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (SSegMsg(mBuf, totalMsgLen-msgLen, param) != ROK)
- RETVALUE(RFAILED);
- RETVALUE(ROK);
+ return RFAILED;
+ return ROK;
}
(ErrVal)ETFU125, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)doaInd, sizeof(TfuDoaIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmPkTfuDoaIndInfo(doaInd, mBuf);
if (SPkS16(suId, mBuf) != ROK) {
#endif
TFU_FREE_MEM(doaInd);
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
TFU_FREE_MEM(doaInd);
pst->event = (Event) EVTTFUDOAIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU127, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
Mem sMem;
(ErrVal)ETFU128, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cmUnpkTfuDoaIndInfo(doaInd, (Ptr)&doaInd->memCp, mBuf);
TFU_FREE_MSG(mBuf);
- RETVALUE((*func)(pst, suId, doaInd));
+ return ((*func)(pst, suId, doaInd));
}
TRC3(cmPkTfuDciFormatTbInfo)
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDciFormatTbInfo)
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ return ROK;
}
TRC3(cmPkTfuSubbandDlCqiInfo)
for (i=TFU_MAX_TB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqiIdx[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiIdx[i], mBuf);
}
CMCHKPK(cmPkTfuSubbandInfo, ¶m->subband, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkTfuSubbandInfo, ¶m->subband, mBuf);
for (i=0; i<TFU_MAX_TB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqiIdx[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiIdx[i], mBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CMCHKPK(cmPkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->mode, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuDlCqiPuschInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_12:
CMCHKUNPK(cmUnpkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
CMCHKUNPK(cmUnpkTfuCqiPuschMode31, ¶m->u.mode31Info, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/***********************************************************
TRC3(cmPkTfuDoaRpt)
- CMCHKPK(SPkU32, param->doa, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->doa, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuDoaRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU32, ¶m->doa, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, ¶m->doa, mBuf);
+ return ROK;
}
cmLListDelFrm(¶m->doaRpt, &tfuDoaRpt->lnk);
tfuDoaRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
cmLListInit(¶m->doaRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuDoaRpt), (Ptr *)&tfuDoaRpt);
CMCHKUNPK(cmUnpkTfuDoaRpt, tfuDoaRpt, mBuf);
cmLListAdd2Tail(¶m->doaRpt, &tfuDoaRpt->lnk);
tfuDoaRpt->lnk.node = (PTR)tfuDoaRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmPkTfuSrsRpt)
- CMCHKPK(SPkU8, param->wideCqi, mBuf);
- CMCHKPK(SPkU8, param->wideCqiPres, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->wideCqiPres, mBuf);
for (i=TFU_MAX_UL_RB-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->snr[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->snr[i], mBuf);
}
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->numRbs, mBuf);
- CMCHKPK(SPkU16, param->ta, mBuf);
- CMCHKPK(SPkU16, param->dopEst, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRbs, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->ta, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->dopEst, mBuf);
CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuSrsRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->dopEst, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->ta, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRbs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->dopEst, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->ta, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRbs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
for (i=0; i<TFU_MAX_UL_RB; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->snr[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->snr[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->wideCqiPres, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->wideCqi, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideCqiPres, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->wideCqi, mBuf);
+ return ROK;
}
cmLListDelFrm(¶m->srsRpt, &tfuSrsRpt->lnk);
tfuSrsRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->srsRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuSrsRpt), (Ptr *)&tfuSrsRpt);
CMCHKUNPK(cmUnpkTfuSrsRpt, tfuSrsRpt, mBuf);
cmLListAdd2Tail(¶m->srsRpt, &tfuSrsRpt->lnk);
tfuSrsRpt->lnk.node = (PTR)tfuSrsRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuRawCqiRpt)
#ifdef TFU_5GTF
- CMCHKPK(SPkU32, param->uciPayload, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->uciPayload, mBuf);
#else
S32 i;
for (i=CM_LTE_MAX_CELLS-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->ri[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ri[i], mBuf);
}
for (i=TFU_MAX_CQI_BYTES-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->cqiBits[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiBits[i], mBuf);
}
#endif
- CMCHKPK(SPkU8, param->numBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBits, mBuf);
CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuRawCqiRpt)
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
#ifndef TFU_5GTF
S32 i;
for (i=0; i<TFU_MAX_CQI_BYTES; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->cqiBits[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiBits[i], mBuf);
}
for (i=0; i<CM_LTE_MAX_CELLS; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->ri[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ri[i], mBuf);
}
#else
- CMCHKUNPK(SUnpkU32, ¶m->uciPayload, mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->uciPayload, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
cmLListDelFrm(¶m->rawCqiRpt, &tfuRawCqiRpt->lnk);
tfuRawCqiRpt->lnk.node = (PTR)NULLP;
}
- CMCHKPK(SPkU32, count, mBuf);
+ CMCHKPK(oduUnpackUInt32, count, mBuf);
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
cmLListInit(¶m->rawCqiRpt);
- CMCHKUNPK(SUnpkU32, &count, mBuf);
+ CMCHKUNPK(oduPackUInt32, &count, mBuf);
for (loopCnt=0; loopCnt<count; loopCnt++) {
cmGetMem((Ptr)memCp, sizeof(*tfuRawCqiRpt), (Ptr *)&tfuRawCqiRpt);
CMCHKUNPK(cmUnpkTfuRawCqiRpt, tfuRawCqiRpt, mBuf);
cmLListAdd2Tail(¶m->rawCqiRpt, &tfuRawCqiRpt->lnk);
tfuRawCqiRpt->lnk.node = (PTR)tfuRawCqiRpt;
}
- RETVALUE(ROK);
+ return ROK;
}
S32 i;
TRC3(cmPkTfuUePucchHqRecpInfo)
- CMCHKPK(SPkU8, param->a, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->a, mBuf);
for (i=TFU_MAX_HQ_RES-1; i >= 0; i--) {
- CMCHKPK(SPkU16, param->hqRes[i], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->hqRes[i], mBuf);
}
- CMCHKPK(SPkU8, param->pucchResCnt, mBuf);
- CMCHKPK(SPkU8, param->hqSz, mBuf);
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->pucchResCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqSz, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
+ return ROK;
}
S32 i;
TRC3(cmUnpkTfuUePucchHqRecpInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchResCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
for (i=0; i<TFU_MAX_HQ_RES; i++) {
- CMCHKUNPK(SUnpkU16, ¶m->hqRes[i], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->hqRes[i], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->a, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->a, mBuf);
+ return ROK;
}
#ifdef LTE_ADV
S32 idx;
for (idx=(TFU_MAX_HQ_RES-1); idx >= 0; idx--) {
- CMCHKPK(SPkU16, param->hqRes[idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->hqRes[idx], mBuf);
}
#else
- CMCHKPK(SPkU16, param->hqRes[0], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->hqRes[0], mBuf);
#endif
- CMCHKPK(SPkU8, param->pucchResCnt, mBuf);
- CMCHKPK(SPkU8, param->hqSz, mBuf);
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchResCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqSz, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
{
TRC3(cmUnpkTfuUePucchHqRecpInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchResCnt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
#ifdef LTE_ADV
S32 idx;
for (idx=0; idx<TFU_MAX_HQ_RES; idx++) {
- CMCHKUNPK(SUnpkU16, ¶m->hqRes[idx], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->hqRes[idx], mBuf);
}
#else
- CMCHKUNPK(SUnpkU16, ¶m->hqRes[0], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->hqRes[0], mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuUePucchSrRecpInfo)
- CMCHKPK(SPkU16, param->n1PucchIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt16, param->n1PucchIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUePucchSrRecpInfo)
- CMCHKUNPK(SUnpkU16, ¶m->n1PucchIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->n1PucchIdx, mBuf);
+ return ROK;
}
TRC3(cmPkTfuUePucchCqiRecpInfo)
- CMCHKPK(SPkU8, param->cqiPmiSz, mBuf);
- CMCHKPK(SPkU16, param->n2PucchIdx, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cqiPmiSz, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->n2PucchIdx, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUePucchCqiRecpInfo)
- CMCHKUNPK(SUnpkU16, ¶m->n2PucchIdx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiPmiSz, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt16, ¶m->n2PucchIdx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSz, mBuf);
+ return ROK;
}
TRC3(cmPkTfuUePucchSrsRecpInfo)
- CMCHKPK(SPkU32, param->srsCyclicShft, mBuf);
- CMCHKPK(SPkU16, param->srsCfgIdx, mBuf);
- CMCHKPK(SPkU8, param->transComb, mBuf);
- CMCHKPK(SPkU32, param->srsHopBw, mBuf);
- CMCHKPK(SPkU8, param->nRrc, mBuf);
- CMCHKPK(SPkU32, param->srsBw, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->srsCyclicShft, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->transComb, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsHopBw, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nRrc, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->srsBw, mBuf);
+ return ROK;
}
#ifdef TFU_5GTF
TRC3(cmPkTfuUePucchUciRecpInfo)
- CMCHKPK(SPkU8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->pucchIndex, mBuf);
- CMCHKPK(SPkU8, param->numBits, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numBits, mBuf);
+ return ROK;
}
#endif
TRC3(cmUnpkTfuUePucchSrsRecpInfo)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->srsBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nRrc, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->srsHopBw, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->transComb, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->srsCyclicShft, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nRrc, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsHopBw, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->transComb, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsCyclicShft, mBuf);
+ return ROK;
}
#ifdef TFU_5GTF
TRC3(cmPkTfuUePucchBsiBriRecpInfo)
- CMCHKPK(SPkU8, param->briRpt, mBuf);
- CMCHKPK(SPkU8, param->bsiRpt, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->pucchIndex, mBuf);
- CMCHKPK(SPkU8, param->puschFlag, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->briRpt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->bsiRpt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->pucchIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->puschFlag, mBuf);
+ return ROK;
}
/***********************************************************
TRC3(cmUnpkTfuUePucchBsiBriRecpInfo)
- CMCHKUNPK(SUnpkU8, ¶m->puschFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->bsiRpt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->briRpt, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->puschFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->bsiRpt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->briRpt, mBuf);
+ return ROK;
}
#endif
TRC3(cmUnpkTfuUePucchUciRecpInfo)
- CMCHKUNPK(SUnpkU8, ¶m->numBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->pucchIndex, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->pucchIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif
CMCHKPK(cmPkTfuUePucchHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKPK(cmPkTfuUePucchSrRecpInfo, ¶m->srInfo, mBuf);
CMCHKPK(cmPkTfuUePucchCqiRecpInfo, ¶m->cqiInfo, mBuf);
- CMCHKPK(SPkU32, param->uciInfo, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->uciInfo, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUePucchRecpReq)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->uciInfo, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->uciInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchCqiRecpInfo, ¶m->cqiInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchSrRecpInfo, ¶m->srInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchUciRecpInfo, ¶m->uciPduInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchBsiBriRecpInfo, ¶m->bsiBriInfo, mBuf);
#endif /* TFU_5GTF */
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuUeUlSchRecpInfo)
#ifdef TFU_5GTF
- CMCHKPK(SPkU8, param->beamIndex, mBuf);
- CMCHKPK(SPkU8, param->uciWoTBFlag, mBuf);
- CMCHKPK(SPkU8, param->PMI, mBuf);
- CMCHKPK(SPkU8, param->SCID, mBuf);
- CMCHKPK(SPkU8, param->nAntPortLayer, mBuf);
- CMCHKPK(SPkU8, param->xPUSCHRange, mBuf);
- CMCHKPK(SPkU8, param->numRbg, mBuf);
- CMCHKPK(SPkU8, param->rbgStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->beamIndex, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->uciWoTBFlag, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->PMI, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->SCID, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nAntPortLayer, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->xPUSCHRange, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRbg, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbgStart, mBuf);
#endif
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->nSrs, mBuf);
- CMCHKPK(SPkU8, param->crntTxNb, mBuf);
- CMCHKPK(SPkU8, param->txMode, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->isRtx, mBuf);
- CMCHKPK(SPkU8, param->hoppingBits, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU32, param->modType, mBuf);
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nSrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->crntTxNb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->txMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isRtx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuUeUlSchRecpInfo)
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->modType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hoppingBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isRtx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->txMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->crntTxNb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nSrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isRtx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->txMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->crntTxNb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nSrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->rbgStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRbg, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->xPUSCHRange, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nAntPortLayer, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->SCID, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->PMI, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->uciWoTBFlag, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->beamIndex, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbgStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRbg, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->xPUSCHRange, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nAntPortLayer, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->SCID, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->PMI, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->uciWoTBFlag, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->beamIndex, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
U32 idx = 0;
TRC3(cmPkTfuUePuschCqiRecpInfo)
- CMCHKPK(SPkU8, param->riBetaOff, mBuf);
- CMCHKPK(SPkU8, param->cqiBetaOff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->riBetaOff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiBetaOff, mBuf);
for (idx = 0; idx < param->cCNum; idx++)
{
CMCHKPK(cmPkTknU8, ¶m->riSz[idx], mBuf);
- CMCHKPK(SPkU8, param->cqiPmiSzRn1[idx], mBuf);
- CMCHKPK(SPkU8, param->cqiPmiSzR1[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPmiSzRn1[idx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->cqiPmiSzR1[idx], mBuf);
}
- CMCHKPK(SPkU8, param->cCNum, mBuf);
- CMCHKPK(SPkU8, param->reportType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->cCNum, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->reportType, mBuf);
+ return ROK;
}
U32 idx;
TRC3(cmUnpkTfuUePuschCqiRecpInfo)
- CMCHKUNPK(SUnpkU8, ¶m->reportType, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cCNum, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->reportType, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cCNum, mBuf);
for (idx = param->cCNum; idx > 0; idx--)
{
- CMCHKUNPK(SUnpkU8, ¶m->cqiPmiSzR1[idx-1], mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->cqiPmiSzRn1[idx-1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzR1[idx-1], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzRn1[idx-1], mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->riSz[idx-1], mBuf);
}
- CMCHKUNPK(SUnpkU8, ¶m->cqiBetaOff, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->riBetaOff, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->cqiBetaOff, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->riBetaOff, mBuf);
+ return ROK;
}
#ifdef TFU_TDD
- CMCHKPK(SPkU8, param->ulDai, mBuf);
- CMCHKPK(SPkU8, param->nBundled, mBuf);
- CMCHKPK(SPkU32, param->hqFdbkMode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulDai, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nBundled, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->hqFdbkMode, mBuf);
#endif
- CMCHKPK(SPkU8, param->hqBetaOff, mBuf);
- CMCHKPK(SPkU8, param->hqSz, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->hqBetaOff, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hqSz, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUePuschHqRecpInfo)
- CMCHKUNPK(SUnpkU8, ¶m->hqSz, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hqBetaOff, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hqBetaOff, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqFdbkMode, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nBundled, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulDai, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nBundled, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulDai, mBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuUePuschHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKPK(cmPkTfuUePuschCqiRecpInfo, ¶m->cqiRiInfo, mBuf);
CMCHKPK(cmPkTfuUeUlSchRecpInfo, ¶m->ulSchInfo, mBuf);
- CMCHKPK(SPkU32, param->rcpInfo, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->rcpInfo, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUePuschRecpReq)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->rcpInfo, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->rcpInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUeUlSchRecpInfo, ¶m->ulSchInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschCqiRecpInfo, ¶m->cqiRiInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchSrsRecpInfo, ¶m->srsInfo, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->initialNSrs, mBuf);
CMCHKUNPK(cmUnpkTknU8, ¶m->initialNumRbs, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
#ifdef TFU_5GTF
- CMCHKPK(SPkU8, param->groupId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->groupId, mBuf);
#endif /* TFU_5GTF */
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
#ifdef TFU_5GTF
- CMCHKUNPK(SUnpkU8, ¶m->groupId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->groupId, mBuf);
#endif /* TFU_5GTF */
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_RECP_REQ_PUCCH:
CMCHKUNPK(cmUnpkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschRecpReq, ¶m->t.puschRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* TFU_UPGRADE */
#ifndef TFU_UPGRADE /* TFU_UPGRADE */
#ifdef TFU_TDD
for (i=TFU_MAX_M-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->p[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->p[i], mBuf);
}
for (i=TFU_MAX_M-1; i >= 0; i--) {
- CMCHKPK(SPkU8, param->m[i], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m[i], mBuf);
}
- CMCHKPK(SPkU8, param->M, mBuf);
- CMCHKPK(SPkU8, param->multCnt, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->M, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->multCnt, mBuf);
#endif
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
switch(param->hqType) {
case TFU_HQ_RECP_REQ_N1PUCCH:
- CMCHKPK(SPkU16, param->t.n1Pucch, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t.n1Pucch, mBuf);
break;
#ifdef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
for (i=TFU_MAX_M-1; i >= 0; i--) {
- CMCHKPK(SPkU16, param->t.nCce[i], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t.nCce[i], mBuf);
}
break;
#ifndef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
- CMCHKPK(SPkU16, param->t.nCce, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->t.nCce, mBuf);
break;
#endif
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->hqType, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->hqType, mBuf);
+ return ROK;
}
#endif
TRC3(cmUnpkTfuUePucchRecpReq)
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->hqType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqType, mBuf);
switch(param->hqType) {
#ifndef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
- CMCHKUNPK(SUnpkU16, ¶m->t.nCce, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t.nCce, mBuf);
break;
#endif
#ifdef TFU_TDD
case TFU_HQ_RECP_REQ_NORMAL:
for (i=0; i<TFU_MAX_M; i++) {
- CMCHKUNPK(SUnpkU16, ¶m->t.nCce[i], mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t.nCce[i], mBuf);
}
break;
#endif
case TFU_HQ_RECP_REQ_N1PUCCH:
- CMCHKUNPK(SUnpkU16, ¶m->t.n1Pucch, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->t.n1Pucch, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(SUnpkU8, ¶m->multCnt, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->M, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->multCnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->M, mBuf);
for (i=0; i<TFU_MAX_M; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->m[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->m[i], mBuf);
}
for (i=0; i<TFU_MAX_M; i++) {
- CMCHKUNPK(SUnpkU8, ¶m->p[i], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->p[i], mBuf);
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmPkTfuUeMsg3RecpReq)
- CMCHKPK(SPkU32, param->modType, mBuf);
- CMCHKPK(SPkU16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
/*ccpu00128993 - ADD - fix for msg3 softcombining bug*/
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->isRtx, mBuf);
- CMCHKPK(SPkU8, param->ulDelay, mBuf);
- CMCHKPK(SPkU8, param->expCqi, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isRtx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ulDelay, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->expCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUeMsg3RecpReq)
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->expCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ulDelay, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isRtx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->expCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ulDelay, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isRtx, mBuf);
/*ccpu00128993 - ADD - fix for msg3 softcombining bug*/
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->modType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ return ROK;
}
TRC3(cmPkTfuUePuschRecpReq)
- CMCHKPK(SPkU32, param->modType, mBuf);
- CMCHKPK(SPkU16, param->size, mBuf);
- CMCHKPK(SPkU32, param->mode, mBuf);
- CMCHKPK(SPkU8, param->expHarq, mBuf);
- CMCHKPK(SPkU8, param->expCqi, mBuf);
- CMCHKPK(SPkU8, param->nDmrs, mBuf);
- CMCHKPK(SPkU8, param->rv, mBuf);
- CMCHKPK(SPkU8, param->isRtx, mBuf);
- CMCHKPK(SPkU8, param->ndi, mBuf);
- CMCHKPK(SPkU8, param->harqProcId, mBuf);
- CMCHKPK(SPkU8, param->mcs, mBuf);
- CMCHKPK(SPkU8, param->numRb, mBuf);
- CMCHKPK(SPkU8, param->rbStart, mBuf);
- CMCHKPK(SPkU8, param->hoppingBits, mBuf);
- CMCHKPK(SPkU8, param->hoppingEnbld, mBuf);
- RETVALUE(ROK);
+ CMCHKPK(oduUnpackUInt32, param->modType, mBuf);
+ CMCHKPK(oduUnpackUInt16, param->size, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->expHarq, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->expCqi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->nDmrs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->isRtx, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->harqProcId, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->numRb, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->rbStart, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingBits, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->hoppingEnbld, mBuf);
+ return ROK;
}
TRC3(cmUnpkTfuUePuschRecpReq)
- CMCHKUNPK(SUnpkU8, ¶m->hoppingEnbld, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->hoppingBits, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rbStart, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->numRb, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->mcs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->harqProcId, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->ndi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->isRtx, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->rv, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->nDmrs, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->expCqi, mBuf);
- CMCHKUNPK(SUnpkU8, ¶m->expHarq, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->mode, mBuf);
- CMCHKUNPK(SUnpkU16, ¶m->size, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->modType, mBuf);
- RETVALUE(ROK);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->isRtx, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->expCqi, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->expHarq, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ return ROK;
}
CMCHKPK(cmPkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- CMCHKPK(SPkU32, param->type, mBuf);
+ CMCHKPK(oduUnpackUInt32, param->type, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
TRC3(cmUnpkTfuUeRecpReqInfo)
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(SUnpkU32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
switch(param->type) {
case TFU_RECP_REQ_PUCCH:
CMCHKUNPK(cmUnpkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschRecpReq, ¶m->t.puschRecpReq, mBuf);
break;
default :
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
CMCHKPK(cmPkLteTimingInfo, ¶m->timingInfo, mBuf);
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteTimingInfo, ¶m->timingInfo, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
(ErrVal)ETFU105, (ErrVal)0, "Packing failed");
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector == ODU_SELECTOR_LC) {
if (cmPkTfuErrIndInfo(errInd, mBuf) != ROK) {
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmPkPtr((PTR)errInd, mBuf) != ROK)
+ if (oduPackPointer((PTR)errInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
/*MS_FIX:71858:Changed to SPutSBuf as being allocated with SGetSBuf*/
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if (SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo)) != ROK) {
(ErrVal)ETFU108, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
pst->event = (Event) EVTTFUERRIND;
- RETVALUE(SPstTsk(pst,mBuf));
+ return (SPstTsk(pst,mBuf));
}
\f
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU109, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pst->selector != ODU_SELECTOR_LWLC) {
if ((SGetSBuf(pst->region, pst->pool, (Data **)&errInd, sizeof(TfuErrIndInfo))) != ROK) {
(ErrVal)ETFU110, (ErrVal)0, "Packing failed");
#endif
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
(ErrVal)ETFU111, (ErrVal)0, "Packing failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if(pst->selector == ODU_SELECTOR_LWLC)
{
- if (cmUnpkPtr((PTR *)&errInd, mBuf) != ROK)
+ if (oduUnpackPointer((PTR *)&errInd, mBuf) != ROK)
{
#if (ERRCLASS & ERRCLS_ADD_RES)
SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
#endif
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
TFU_FREE_MSG(mBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
TFU_FREE_MSG(mBuf);
/* [ccpu00141698]-MOD- MAC/SCH does not free the TTI ind anymore */
(*func)(pst, suId, errInd);
SPutSBuf(pst->region, pst->pool, (Data *)errInd, sizeof(TfuErrIndInfo));
- RETVALUE(ROK);
+ return ROK;
}
#endif /* if defined(LCTFU) */
* RFAILED - failure
*
* ****************************************************************/
-S16 buildPlmnId(Plmn plmn, OCTET_STRING_t *octe)
+uint8_t buildPlmnId(Plmn plmn, OCTET_STRING_t *octe)
{
- U8 mncCnt;
+ uint8_t mncCnt;
mncCnt = 2;
octe->buf[0] = ((plmn.mcc[1] << 4) | (plmn.mcc[0]));
if(mncCnt == 2)
octe->buf[1] = ((plmn.mnc[0] << 4) | (plmn.mcc[2]));
octe->buf[2] = ((plmn.mnc[2] << 4) | (plmn.mnc[1]));
}
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* Functionality: Fills the RicId
*
* @params[in] BIT_STRING_t *nbid,
- * U8 unusedBits
- * U8 byteSize
- * U8 val
+ * uint8_t unusedBits
+ * uint8_t byteSize
+ * uint8_t val
*
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-S16 fillBitString(BIT_STRING_t *id, U8 unusedBits, U8 byteSize, U8 val)
+uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint8_t val)
{
- U8 tmp;
+ uint8_t tmp;
if(id->buf == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (tmp = 0 ; tmp < (byteSize-1); tmp++)
}
id->buf[byteSize-1] = val;
id->bits_unused = unusedBits;
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 bitStringToInt(BIT_STRING_t *bitString, U16 *val)
+uint8_t bitStringToInt(BIT_STRING_t *bitString, uint16_t *val)
{
- U16 idx;
+ uint16_t idx;
if(bitString->buf == NULL || bitString->size <= 0)
{
DU_LOG("\nDU_APP : Bit string is empty");
int encBufSize;
int PrepFinalEncBuf(const void *buffer, size_t size, void *encodedBuf);
-S16 buildPlmnId(Plmn plmn, OCTET_STRING_t *octe);
-S16 fillBitString(BIT_STRING_t *id, U8 unusedBits, U8 byteSize, U8 val);
-S16 bitStringToInt(BIT_STRING_t *bitString, U16 *val);
+uint8_t buildPlmnId(Plmn plmn, OCTET_STRING_t *octe);
+uint8_t fillBitString(BIT_STRING_t *id, uint8_t unusedBits, uint8_t byteSize, uint8_t val);
+uint8_t bitStringToInt(BIT_STRING_t *bitString, uint16_t *val);
#endif
{
Buffer *mBuf = NULLP;
- if(SGetMsg(region, pool, &mBuf) == ROK)
+ if(ODU_GET_MSG(region, pool, &mBuf) == ROK)
{
- if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
+ if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
{
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
if(sctpSend(mBuf) != ROK)
{
DU_LOG("\nF1AP : SCTP Send failed");
- SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ ODU_PUT_MSG(mBuf);
+ return RFAILED;
}
}
else
{
- DU_LOG("\nF1AP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG(mBuf);
+ return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
else
{
DU_LOG("\nF1AP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SendF1APMsg */
/*******************************************************************
nrcell->buf[4] = 16;
nrcell->bits_unused = 4;
nrcell->size = 5 * sizeof(uint8_t);
- RETVALUE(ROK);
+ return ROK;
}
/********************************************************************
if(f1apMsg == NULLP)
{
DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
{
DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
DU_LOG("\nF1AP : Memory allocation for F1ResponseIEs failed");
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx=0; idx<elementCnt; idx++)
CU_FREE(f1apMsg->choice.successfulOutcome, \
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
CU_FREE(f1apMsg->choice.successfulOutcome,\
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idy=0; idy<cellCnt; idy++)
{
CU_FREE(f1apMsg->choice.successfulOutcome, \
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cellToActivate->list.array[0]->id = \
CU_FREE(f1apMsg->choice.successfulOutcome, \
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
buildPlmnId(cuCfgParams.plmn , &cellToActivate->list.array[0]->value.choice.\
Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity);
CU_FREE(f1apMsg->choice.successfulOutcome, \
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
BuildNrCellId(&(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity));
/* RRC Version */
elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Need to check RRC Version */
elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rrcVer->iE_Extensions->list.count = 1;
rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
sizeof(struct RRC_Version_ExtIEs));
elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rrcVer->iE_Extensions->list.array[0]->id = \
ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
elementCnt * sizeof(F1SetupResponseIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
Latest_RRC_Version_Enhanced.buf[0] = 0;
{
DU_LOG("\nF1AP : Could not encode F1SetupResponse structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
{
DU_LOG("\nF1AP : Sending F1 Setup Response failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* End of BuildAndSendF1SetupRsp */
/*******************************************************************
if(f1apMsg == NULLP)
{
DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
{
DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
DU_LOG("\nF1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx=0; idx<elementCnt; idx++)
CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(enRetVal.encoded == ENCODE_FAIL)
{
DU_LOG("\nF1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
{
DU_LOG("\nF1AP : Sending GNB-DU Config Update Ack failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* End of BuildAndSendDUUpdateAck*/
{
DU_LOG( "\n F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
if(f1apMsg == NULLP)
{
DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
{
DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
f1apMsg->choice.successfulOutcome->procedureCode = \
CU_FREE(f1apMsg->choice.successfulOutcome,
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx=0; idx<elementCnt; idx++)
CU_FREE(f1apMsg->choice.successfulOutcome,\
sizeof(SuccessfulOutcome_t));
CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL) != ROK)
{
DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/* End of BuildAndSendUESetRsp */
F1AP_PDU_t f1apasnmsg ;
DU_LOG("\nF1AP : Received F1AP message buffer");
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
- SFndLenMsg(mBuf, &recvBufLen);
- if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
+ ODU_FIND_MSG_LEN(mBuf, &recvBufLen);
+ CU_ALLOC(recvBuf, (Size)recvBufLen);
+
+ if(recvBuf == NULLP)
{
DU_LOG("\nF1AP : Memory allocation failed");
return;
}
- if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
+ if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
return;
memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
- SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
+ CU_FREE(recvBuf, (Size)recvBufLen);
+
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
DU_LOG("\nF1AP : ASN decode failed");
*
* ****************************************************************/
-S16 tst()
+uint8_t tst()
{
init_log();
DU_LOG("\nStarting CU_STUB");
sctpCfgReq();
sctpStartReq();
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
DU_LOG("\n\nEGTP : Initializing");
cmMemset ((U8 *)&egtpCb, 0, sizeof(EgtpGlobalCb));
protType = CM_INET_PROTO_UDP;
- RETVALUE(ROK);
+ return ROK;
}
if(ret != ROK)
{
DU_LOG("\nEGTP : Configuration failed");
- RETVALUE(ret);
+ return (ret);
}
ret = cuEgtpSrvOpenReq();
if(ret != ROK)
{
DU_LOG("\nEGTP : Transport server open request failed");
- RETVALUE(ret);
+ return (ret);
}
tnlEvt.action = EGTP_TNL_MGMT_ADD;
if(ret != ROK)
{
DU_LOG("\n EGTP : Tunnel management request failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* egtpInitReq */
if(ret != ROK)
{
DU_LOG("\nEGTP : TeId hash list initialization failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
DU_LOG("\nEGTP : Configuration successful");
}
- RETVALUE(ROK);
+ return ROK;
} /* cuEgtpCfgReq */
/**************************************************************************
if(ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType)) != ROK)
{
DU_LOG("\nEGTP : Failed to open UDP socket");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cmInetBind(&(egtpCb.recvTptSrvr.sockFd), &(egtpCb.recvTptSrvr.addr));
if(ret != ROK)
{
DU_LOG("\nEGTP : Failed to bind socket");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK)
{
DU_LOG("\nEGTP : Failed to open UDP socket");
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr));
if(ret != ROK)
{
DU_LOG("\nEGTP : Failed to bind socket");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* TODO: set socket options */
DU_LOG("\nEGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd, egtpCb.dstCb.sendTptSrvr.sockFd.fd);
- RETVALUE(ROK);
+ return ROK;
} /* cuEgtpSrvOpenReq */
}
}
- RETVALUE(ret);
+ return (ret);
}
/**************************************************************************
DU_LOG("\nEGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- ret = SGetSBuf(CU_APP_MEM_REG, CU_POOL, (Data **)&teidCb, (Size)sizeof(EgtpTeIdCb));
- if(ret != ROK)
+ CU_ALLOC(teidCb, (Size)sizeof(EgtpTeIdCb));
+
+ if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ret != ROK)
{
DU_LOG("\nEGTP : Failed to insert in hash list");
- SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));
- RETVALUE(RFAILED);
+ CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
+ return RFAILED;
}
egtpCb.dstCb.numTunn++;
/* SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));*/
- RETVALUE(ROK);
+ return ROK;
} /* cuEgtpTnlAdd */
/**************************************************************************
if(teidCb == NULLP)
{
printf("\nTunnel id not found");
- RETVALUE(RFAILED);
+ return RFAILED;
}
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**************************************************************************
if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb);
- SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));
+ CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
egtpCb.dstCb.numTunn--;
- RETVALUE(ROK);
+ return ROK;
} /* cuEgtpTnlDel */
/*******************************************************************
}
*hdrIdx = cnt;
- RETVALUE(ROK);
+ return ROK;
} /* egtpEncodeHdr */
cuEgtpDecodeHdr(mBuf);
/* Start Pumping data from CU to DU */
- RETVALUE(cuEgtpDatReq());
+ return (cuEgtpDatReq());
}
U8 extHdrLen = 0; /* Extension hdr length */
Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
- SFndLenMsg(mBuf, &bufLen);
+ ODU_FIND_MSG_LEN(mBuf, &bufLen);
/* Decode version */
- SRemPreMsg(&tmpByte[0], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[0], mBuf);
version = tmpByte[0] >> 5;
/* Decode message type */
- SRemPreMsg((Data*)&(egtpMsg.msgHdr.msgType), mBuf);
+ ODU_REM_PRE_MSG((Data*)&(egtpMsg.msgHdr.msgType), mBuf);
/* Decode message length */
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
msgLen = (tmpByte[1] << 8) | tmpByte[2];
/* Decode tunnel id */
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
- SRemPreMsg(&tmpByte[3], mBuf);
- SRemPreMsg(&tmpByte[4], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[3], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[4], mBuf);
egtpMsg.msgHdr.teId = (tmpByte[1] << 24) | (tmpByte[2] << 16) | (tmpByte[3] << 8) | tmpByte[4];
if((tmpByte[0] & EGTP_MASK_BIT1) || (tmpByte[0] & EGTP_MASK_BIT2)||(tmpByte[0] & EGTP_MASK_BIT3))
if ( tmpByte[0] & EGTP_MASK_BIT2 )
{
egtpMsg.msgHdr.seqNum.pres = TRUE;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
}
else if(extPres)
{
egtpMsg.msgHdr.seqNum.pres = 0;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg.msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
}
if ( tmpByte[0] & EGTP_MASK_BIT1 )
{
egtpMsg.msgHdr.nPdu.pres = TRUE;
- SRemPreMsg(&(egtpMsg.msgHdr.nPdu.val), mBuf);
+ ODU_REM_PRE_MSG(&(egtpMsg.msgHdr.nPdu.val), mBuf);
}
else if(extPres)
{
egtpMsg.msgHdr.nPdu.pres = TRUE;
- SRemPreMsg(&(egtpMsg.msgHdr.nPdu.val), mBuf);
+ ODU_REM_PRE_MSG(&(egtpMsg.msgHdr.nPdu.val), mBuf);
}
if(extPres & EGTP_MASK_BIT1)
{
- SRemPreMsg(&extHdrType, mBuf);
+ ODU_REM_PRE_MSG(&extHdrType, mBuf);
while( 0 != extHdrType)
{
switch (extHdrType)
{
case EGTP_EXT_HDR_UDP_TYPE:
{
- SRemPreMsg(&extHdrLen, mBuf);
+ ODU_REM_PRE_MSG(&extHdrLen, mBuf);
if(extHdrLen == 0x01)
{
egtpMsg.msgHdr.extHdr.udpPort.pres = TRUE;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg.msgHdr.extHdr.udpPort.val = (tmpByte[1] << 8) | tmpByte[2];
}
break;
case EGTP_EXT_HDR_PDCP_TYPE:
{
- SRemPreMsg(&extHdrLen, mBuf);
+ ODU_REM_PRE_MSG(&extHdrLen, mBuf);
if(extHdrLen == 0x01)
{
egtpMsg.msgHdr.extHdr.pdcpNmb.pres = TRUE;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg.msgHdr.extHdr.pdcpNmb.val = (tmpByte[1] << 8) | tmpByte[2];
}
break;
}
} /* End of switch */
- SRemPreMsg(&extHdrType, mBuf);
+ ODU_REM_PRE_MSG(&extHdrType, mBuf);
} /* End of while */
} /* End of if(extPres & EGTP_MASK_BIT1) */
else if(extPres)
{
- SRemPreMsg(&extHdrType, mBuf);
+ ODU_REM_PRE_MSG(&extHdrType, mBuf);
}
DU_LOG("\nEGTP : Message Buffer after decoding header ");
- SPrntMsg(mBuf, 0, 0);
+ ODU_PRINT_MSG(mBuf, 0, 0);
- RETVALUE(ROK);
+ return ROK;
} /* End of cuEgtpDecodeHdr */
cnt++;
}
- SPutMsg(egtpMsg.msg);
+ ODU_PUT_MSG(egtpMsg.msg);
- RETVALUE(ROK);
+ return ROK;
}
Buffer *mBuf;
- if(SGetMsg(CU_APP_MEM_REG, CU_POOL, &mBuf) == ROK)
+ if(ODU_GET_MSG(CU_APP_MEM_REG, CU_POOL, &mBuf) == ROK)
{
- if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK)
+ if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
{
- DU_LOG("\nEGTP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ DU_LOG("\nEGTP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG(mBuf);
+ return RFAILED;
}
}
else
{
DU_LOG("\nEGTP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* filling IPv4 header */
MsgLen mLen;
mLen = 0;
- SFndLenMsg(mBuf, &mLen);
+ ODU_FIND_MSG_LEN(mBuf, &mLen);
cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
/* this function automatically reverses revPkArray */
- ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf);
+ ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
egtpMsg->msgHdr.msgType = EGTPU_MSG_GPDU;
egtpMsg->msgHdr.nPdu.pres = FALSE;
egtpMsg->msgHdr.teId = 10;
egtpMsg->msg = mBuf;
- RETVALUE(ROK);
+ return ROK;
}
if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
- RETVALUE(LCM_REASON_INVALID_PAR_VAL);
+ return (LCM_REASON_INVALID_PAR_VAL);
}
msgHdr = &(egtpMsg->msgHdr);
teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT3);
}
- SFndLenMsg(egtpMsg->msg, &tPduSize);
+ ODU_FIND_MSG_LEN(egtpMsg->msg, &tPduSize);
/*Adjust the header to fill the correct length*/
msgLen = tPduSize + (EGTP_MAX_HDR_LEN - hdrLen) - 0x08;
teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT2);
}
- SAddPreMsgMult(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg->msg);
+ ODU_ADD_PRE_MSG_MULT(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg->msg);
DU_LOG("\nEGTP : Sending message buffer");
- SPrntMsg(egtpMsg->msg, 0, 0);
+ ODU_PRINT_MSG(egtpMsg->msg, 0, 0);
- RETVALUE(ROK);
+ return ROK;
}
S16 cuEgtpSendMsg(Buffer *mBuf)
if(ret != ROK && ret != RWOULDBLOCK)
{
DU_LOG("\nEGTP : Message send failure");
- RETVALUE(RFAILED);
+ return RFAILED;
}
DU_LOG("\nEGTP : Message Sent");
- RETVALUE(ROK);
+ return ROK;
}
memset(&f1Params.lstnSockFd, -1, sizeof(CmInetFd));
fillDestNetAddr(&f1Params.destIpNetAddr, &sctpCfg.duIpAddr);
- RETVALUE(ROK);
+ return ROK;
}
addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE;
addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_U32(ipAddr->ipV4Addr);
- RETVALUE(ROK);
+ return ROK;
}
/******************************************************************************
/* Filling destination address */
destAddrPtr->type = CM_INET_IPV4ADDR_TYPE;
destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_U32(dstIpPtr->ipV4Addr);
- RETVALUE(ROK);
+ return ROK;
}
/******************************************************************************
{
DU_LOG("\nSCTP: Polling failed to start at CU");
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
*
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
{
DU_LOG("\nSCTP : Listening on socket failed");
cmInetClose(lstnSock_Fd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
DU_LOG("\nSCTP : Connecting");
else if(ret != ROK)
{
DU_LOG("\nSCTP : Failed to accept connection");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
}
DU_LOG("\nSCTP : Connection established");
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
}
sctpNtfyInd(ntfy);
- RETVALUE(ROK);
+ return ROK;
}/* End of sctpNtfyHdlr */
/*******************************************************************
if(ret == ROK && egtpBuf != NULLP)
{
DU_LOG("\nEGTP : Received message \n");
- SPrntMsg(egtpBuf, 0 ,0);
+ ODU_PRINT_MSG(egtpBuf, 0 ,0);
cuEgtpHdlRecvMsg(egtpBuf);
}
};
- RETVALUE(ret);
+ return (ret);
}/* End of sctpSockPoll() */
/*******************************************************************
else if(connUp & (pollParams->port == f1Params.destPort))
{
F1APMsgHdlr(pollParams->mBuf);
- SPutMsg(pollParams->mBuf);
+ ODU_PUT_MSG(pollParams->mBuf);
}
else
{
- SPutMsg(pollParams->mBuf);
+ ODU_PUT_MSG(pollParams->mBuf);
}
}
}
- RETVALUE(ROK);
+ return ROK;
}/* End of sctpSockPoll() */
/*******************************************************************
if(ret != ROK && ret != RWOULDBLOCK)
{
DU_LOG("\nSCTP : Send message failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* End of sctpSend */
/**********************************************************************
#include "du_f1ap_msg_hdl.h"
extern DuCfgParams duCfgParam;
-extern S16 duBuildAndSendMacCellCfg();
+extern uint8_t duBuildAndSendMacCellCfg();
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-S16 procCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
+uint8_t procCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
{
- U16 idx = 0;
- S16 ret = ROK;
+ uint16_t idx = 0;
+ uint8_t ret = ROK;
for(idx=0; idx<cellsToActivate.list.count; idx++)
{
- U16 nci = 0;
- U16 pci = 0;
+ uint16_t nci = 0;
+ uint16_t pci = 0;
DuCellCb *cellCb = NULLP;
Cells_to_be_Activated_List_Item_t cell = cellsToActivate.list.array[idx]->\
F1SetupRsp f1SetRspDb;
GNB_CU_Name_t *cuName;
RRC_Version_t *rrc_Ver;
- U16 idx;
+ uint16_t idx;
DU_LOG("\nDU_APP : F1 Setup Response received");
printf("\nDU_APP : F1 Setup Response received");
/* TODO :Check the deallocation */
#if 0
- SPutSBuf(DU_APP_MEM_REGION, DU_POOL,(Data *)&(f1SetupRsp->protocolIEs.list.array),\
- (Size)elementCnt * sizeof(F1SetupResponseIEs_t *));
- SPutSBuf(DU_APP_MEM_REGION, DU_POOL,(Data *)&(f1apMsg->choice.successfulOutcome),\
- (Size)sizeof(SuccessfulOutcome_t));
- SPutSBuf(DU_APP_MEM_REGION, DU_POOL,(Data *)&f1apMsg,(Size)sizeof(F1AP_PDU_t));
+ DU_FREE(f1SetupRsp->protocolIEs.list.array,(Size)elementCnt * sizeof(F1SetupResponseIEs_t *));
+ DU_FREE(f1apMsg->choice.successfulOutcome,(Size)sizeof(SuccessfulOutcome_t));
+ DU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
#endif
return ret;
* RFAILED - failure
*
* ****************************************************************/
-S16 procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
+uint8_t procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
{
DU_LOG("\nF1AP : GNB-DU config update acknowledgment received");
/* TODO :Check the deallocation */
#if 0
- SPutSBuf(DU_APP_MEM_REGION,DU_POOL,(Data*)&(gNBDuCfgAck->protocolIEs.list.array),\
- (Size)elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t
-));
- SPutSBuf(DU_APP_MEM_REGION,DU_POOL,(Data*)&(f1apMsg->choice.successfulOutcome),\
- (Size)sizeof(SuccessfulOutcome_t));
- SPutSBuf(DU_APP_MEM_REGION,DU_POOL,(Data*)&f1apMsg,(Size)sizeof(F1AP_PDU_t));
+ DU_FREE(gNBDuCfgAck->protocolIEs.list.array,(Size)elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
+ DU_FREE(f1apMsg->choice.successfulOutcome,(Size)sizeof(SuccessfulOutcome_t));
+ DU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
#endif
return ROK;
}
#ifndef __DU_CELL_MGR_H__
#define __DU_CELL_MGR_H__
-S16 duSendSchGnbCfg();
-S16 duSendSchGnbCfgToMac(RgrCfgReqInfo *cfgReq, U32 trans_id);
+uint8_t duSendSchGnbCfg();
+uint8_t duSendSchGnbCfgToMac(RgrCfgReqInfo *cfgReq, uint32_t trans_id);
#endif
/**********************************************************************
End of file
* ****************************************************************/
void FillSlotConfig()
{
- U8 slot;
- U8 symbol;
+ uint8_t slot;
+ uint8_t symbol;
for(slot = 0; slot <= 3; slot++)
{
/* This function is used to fill up the cell configuration for CL */
-S16 readMacCfg()
+uint8_t readMacCfg()
{
duCfgParam.macCellCfg.carrierId = CARRIER_IDX;
if(duCfgParam.macCellCfg.prachCfg.fdm[0].unsuedRootSeq == NULLP)
{
DU_LOG("\nDU_APP : Memory allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*(duCfgParam.macCellCfg.prachCfg.fdm[0].unsuedRootSeq) = UNUSED_ROOT_SEQ;
}
(number of mandatory parameters) + (number of otional parameters being filled) */
duCfgParam.macCellCfg.numTlv = 40;
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 fillDuPort(U16 *duPort)
+uint8_t fillDuPort(uint16_t *duPort)
{
duPort[F1_INTERFACE] = DU_PORT; /* DU Port idx 0 38472 */
duPort[E2_INTERFACE] = RIC_PORT; /* RIC Port idx 1 38482 */
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
** ****************************************************************/
-S16 fillServCellCfgCommSib(SrvCellCfgCommSib *srvCellCfgComm)
+uint8_t fillServCellCfgCommSib(SrvCellCfgCommSib *srvCellCfgComm)
{
PdcchCfgCommon pdcchCfg;
PdschCfgCommon pdschCfg;
*
* ****************************************************************/
-S16 readCfg()
+uint8_t readCfg()
{
- U8 i,j,k;
- U32 ipv4_du, ipv4_cu, ipv4_ric;
+ uint8_t i,j,k;
+ uint32_t ipv4_du, ipv4_cu, ipv4_ric;
MibParams mib;
Sib1Params sib1;
if(readMacCfg() != ROK)
{
DU_LOG("\nDU_APP : Failed while reading MAC config");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 duReadCfg()
+uint8_t duReadCfg()
{
Pst pst;
Buffer *mBuf;
- cmMemset((U8 *)&duCfgParam, 0, sizeof(DuCfgParams));
+ memset((uint8_t *)&duCfgParam, 0, sizeof(DuCfgParams));
//Read configs into duCfgParams
if(readCfg() != ROK)
{
DU_LOG("\nDU_APP : Reading configuration failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
//Fill pst structure
- cmMemset((U8 *)&(pst), 0, sizeof(Pst));
+ memset((uint8_t *)&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTDUAPP;
pst.srcInst = (Inst)DU_INST;
pst.srcProcId = DU_PROC;
pst.pool= DU_POOL;
- if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, DU_POOL, &mBuf) != ROK)
{
DU_LOG("\nDU_APP : Memory allocation failed in duReadCfg");
return RFAILED;
}
- if (SPstTsk(&pst, mBuf) != ROK)
+ if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nDU_APP : SPstTsk failed in duReadCfg");
+ DU_LOG("\nDU_APP : ODU_POST_TASK failed in duReadCfg");
return RFAILED;
}
typedef struct sctpParams
{
F1IpAddr duIpAddr;
- U16 duPort[MAX_DU_PORT];
+ uint16_t duPort[MAX_DU_PORT];
F1IpAddr cuIpAddr;
- U16 cuPort;
+ uint16_t cuPort;
F1IpAddr ricIpAddr;
- U16 ricPort;
+ uint16_t ricPort;
}SctpParams;
typedef struct f1EgtpParams
/*function declarations */
void FillSlotConfig();
-S16 readClCfg();
-S16 readCfg();
-S16 duReadCfg();
+uint8_t readClCfg();
+uint8_t readCfg();
+uint8_t duReadCfg();
uint16_t calcSliv(uint8_t startSymbol, uint8_t lengthSymbol);
#endif /* __DU_CONFIG_H__ */
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
encBuf);
}
break;
- }while(1);
+ }while(true);
deAllocateE2SetupReqMsg(e2apMsg, e2SetupReq, idx);
return ret;
uint8_t ret = RFAILED;
uint8_t FillRicricSubscriptionRspret;
- while(1)
+ while(true)
{
DU_LOG("\nE2AP : Building RIC Subscription Response\n");
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apRicMsg);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apRicMsg, PrepFinalEncBuf,\
encBuf);
uint8_t ret = RFAILED;
uint8_t FillRicIndicationret = ROK;
- while(1)
+ while(true)
{
DU_LOG("\nE2AP : Building Ric Indication Message\n");
}
/* Prints the Msg formed */
xer_fprint(stdout, &asn_DEF_E2AP_PDU, e2apMsg);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_E2AP_PDU, 0, e2apMsg, PrepFinalEncBuf,\
encBuf);
{
Buffer *mBuf=NULLP;
- if(SGetMsg(region, pool, &mBuf) == ROK)
+ if(ODU_GET_MSG(region, pool, &mBuf) == ROK)
{
- if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
+ if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
{
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
if(sctpSend(mBuf, E2_INTERFACE) != ROK)
{
DU_LOG("\nE2AP : SCTP Send for E2 failed");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nE2AP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
+ DU_LOG("\nE2AP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
else
{
E2AP_PDU_t e2apasnmsg ;
DU_LOG("\nE2AP : Received E2AP message buffer");
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
- SFndLenMsg(mBuf, &recvBufLen);
- if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
+ ODU_FIND_MSG_LEN(mBuf, &recvBufLen);
+ DU_ALLOC(recvBuf, (Size)recvBufLen);
+
+ if(recvBuf == NULLP)
{
DU_LOG("\nE2AP : Memory allocation failed");
return;
}
- if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
+ if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
DU_LOG("\nE2AP : Failed while copying %d", copyCnt);
return;
memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
- SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
+ DU_FREE(recvBuf, (Size)recvBufLen);
+
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
DU_LOG("\nE2AP : ASN decode failed");
#define ENCODE_FAIL -1
-S16 sctpSend(Buffer *mBuf, U8 itfType);
+uint8_t sctpSend(Buffer *mBuf, uint8_t itfType);
typedef struct e2apDb
{
- U16 ricId;
- uint8_t *plmn;
- U32 ricReqId;
- U32 ricInstanceId;
- U32 ranFuncId;
- uint8_t *ricEventTrigger;
- U32 ricActionId;
- U32 ricActionType;
+ uint16_t ricId;
+ uint8_t *plmn;
+ uint32_t ricReqId;
+ uint32_t ricInstanceId;
+ uint32_t ranFuncId;
+ uint8_t *ricEventTrigger;
+ uint32_t ricActionId;
+ uint32_t ricActionType;
}E2apMsgDb;
E2apMsgDb e2apMsgDb;
void E2APMsgHdlr(Buffer *mBuf);
uint8_t deAllocateE2SetupReqMsg(E2AP_PDU_t *e2apMsg, E2setupRequest_t *e2SetupReq, uint8_t idx);
/**********************************************************************
- End of file
-**********************************************************************/
+ End of file
+ **********************************************************************/
* @return ROK - success
* RFAILED - failure
***************************************************************************/
-S16 egtpActvInit(Ent entity, Inst inst, Region region, Reason reason)
+uint8_t egtpActvInit(Ent entity, Inst inst, Region region, Reason reason)
{
DU_LOG("\n\nEGTP : Initializing");
- cmMemset ((U8 *)&egtpCb, 0, sizeof(EgtpGlobalCb));
+ memset ((uint8_t *)&egtpCb, 0, sizeof(EgtpGlobalCb));
protType = CM_INET_PROTO_UDP;
return ROK;
* RFAILED - failure
*
***************************************************************************/
-S16 egtpActvTsk(Pst *pst, Buffer *mBuf)
+uint8_t egtpActvTsk(Pst *pst, Buffer *mBuf)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
switch(pst->srcEnt)
{
case EVTSLOTIND:
{
ret = unpackEgtpSlotInd(egtpSlotInd, pst, mBuf);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
default:
{
DU_LOG("\nEGTP : Invalid event %d", pst->event);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
}
ret = RFAILED;
}
}
- SExitTsk();
+ ODU_EXIT_TASK();
return ret;
}
* RFAILED - failure
*
* ***********************************************************************/
-S16 egtpCfgReq(Pst *pst, EgtpConfig egtpCfg)
+uint8_t egtpCfgReq(Pst *pst, EgtpConfig egtpCfg)
{
- U8 ret; /* Return value */
+ uint8_t ret; /* Return value */
Pst rspPst; /* Response Pst structure */
CmStatus cfgCfm; /* Configuration Confirm */
- cmMemcpy((U8 *)&egtpCb.egtpCfg, (U8 *)&egtpCfg, (PTR)sizeof(EgtpConfig));
+ memcpy((uint8_t *)&egtpCb.egtpCfg, (uint8_t *)&egtpCfg, (PTR)sizeof(EgtpConfig));
egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
*
*
* ***********************************************************************/
-S16 egtpFillRspPst(Pst *pst, Pst *rspPst)
+uint8_t egtpFillRspPst(Pst *pst, Pst *rspPst)
{
- cmMemset((U8 *)rspPst, 0, sizeof(Pst));
+ memset((uint8_t *)rspPst, 0, sizeof(Pst));
rspPst->srcEnt = pst->dstEnt;
rspPst->srcInst = pst->dstInst;
rspPst->srcProcId = pst->dstProcId;
*
***************************************************************************/
-S16 egtpSrvOpenReq(Pst *pst)
+uint8_t egtpSrvOpenReq(Pst *pst)
{
- U8 ret; /* Return value */
+ uint8_t ret; /* Return value */
Pst rspPst; /* Response Pst structure */
CmStatus cfm; /* Confirmation status */
- U8 sockType; /* Socket type */
+ uint8_t sockType; /* Socket type */
DU_LOG("\nEGTP : Received EGTP open server request");
*
* ****************************************************************/
-S16 egtpSrvOpenPrc(U8 sockType, EgtpTptSrvr *server)
+uint8_t egtpSrvOpenPrc(uint8_t sockType, EgtpTptSrvr *server)
{
S8 ret=ROK;
ret = cmInetSocket(sockType, &(server->sockFd), protType);
*
* ***************************************************************************/
-S16 egtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt)
+uint8_t egtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt)
{
S8 ret;
Pst rspPst;
* RFAILED - failure
*
* ***************************************************************************/
-S16 egtpTnlAdd(EgtpTnlEvt tnlEvt)
+uint8_t egtpTnlAdd(EgtpTnlEvt tnlEvt)
{
- S16 ret;
+ uint8_t ret;
EgtpTeIdCb *teidCb; /* Tunnel endpoint control block */
EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
return LCM_REASON_MEM_NOAVAIL;
}
- cmMemset((U8 *)teidCb, 0, sizeof(EgtpTeIdCb));
+ memset((uint8_t *)teidCb, 0, sizeof(EgtpTeIdCb));
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
- ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (U8 *)&(teidCb->teId), sizeof(U32));
+ ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
if(ret != ROK)
{
DU_LOG("\nEGTP : Failed to insert in hash list");
egtpCb.dstCb.numTunn++;
/* Encoding pre-defined header */
- cmMemset((U8*)&preDefHdr, 0, sizeof(EgtpMsgHdr));
+ memset((uint8_t*)&preDefHdr, 0, sizeof(EgtpMsgHdr));
preDefHdr.msgType = EGTPU_MSG_GPDU;
preDefHdr.teId = teidCb->remTeId;
preDefHdr.extHdr.pdcpNmb.pres = FALSE;
preDefHdr.extHdr.udpPort.pres = FALSE;
preDefHdr.nPdu.pres = FALSE;
- egtpEncodeHdr((U8 *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt));
+ egtpEncodeHdr((uint8_t *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt));
return ROK;
} /* egtpTnlAdd */
* RFAILED - failure
*
* ***************************************************************************/
-S16 egtpTnlMod(EgtpTnlEvt tnlEvt)
+uint8_t egtpTnlMod(EgtpTnlEvt tnlEvt)
{
#if 0
- S16 ret;
+ uint8_t ret;
EgtpTeIdCb *teidCb = NULLP;
printf("\nTunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.teId), sizeof(U32), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
printf("\nTunnel id not found");
- RETVALUE(RFAILED);
+ return RFAILED;
}
teidCb->teId = tnlEvt.lclTeid;
* RFAILED - failure
*
* ***************************************************************************/
-S16 egtpTnlDel(EgtpTnlEvt tnlEvt)
+uint8_t egtpTnlDel(EgtpTnlEvt tnlEvt)
{
EgtpTeIdCb *teidCb = NULLP;
DU_LOG("\nEGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.lclTeid), sizeof(U32), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
* RFAILED - failure
*
* ****************************************************************/
-S16 egtpHdlDatInd(EgtpMsg egtpMsg)
+uint8_t egtpHdlDatInd(EgtpMsg egtpMsg)
{
EgtpTeIdCb *teidCb = NULLP;
- MsgLen tPduSize;
- U8 hdrLen;
- U32 msgLen;
+ uint16_t tPduSize;
+ uint8_t hdrLen;
+ uint32_t msgLen;
EgtpMsgHdr *msgHdr;
DU_LOG("\nEGTP : Received Data Indication");
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(egtpMsg.msgHdr.teId), sizeof(U32), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg.msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg.msgHdr.teId);
teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] &= ~(EGTP_MASK_BIT3);
}
- SFndLenMsg(egtpMsg.msg, &tPduSize);
+ ODU_FIND_MSG_LEN(egtpMsg.msg, &tPduSize);
/*Adjust the header to fill the correct length*/
msgLen = tPduSize + (EGTP_MAX_HDR_LEN - hdrLen) - 0x08;
/***********************************************
* Fill the length field of the message header *
***********************************************/
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (U8)GetHiByte(msgLen);
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (U8)GetLoByte(msgLen);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (uint8_t)GetHiByte(msgLen);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (uint8_t)GetLoByte(msgLen);
/*Update the sequence number*/
if(egtpMsg.msgHdr.seqNum.pres)
{
teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= (EGTP_MASK_BIT2);
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (U8)GetHiByte(egtpMsg.msgHdr.seqNum.val);
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (U8)GetLoByte(egtpMsg.msgHdr.seqNum.val);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (uint8_t)GetHiByte(egtpMsg.msgHdr.seqNum.val);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (uint8_t)GetLoByte(egtpMsg.msgHdr.seqNum.val);
}
else
{
}
DU_LOG("\nEGTP : UL Data buffer before encoding header");
- SPrntMsg(egtpMsg.msg, 0, 0);
+ ODU_PRINT_MSG(egtpMsg.msg, 0, 0);
- SAddPreMsgMult(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg.msg);
+ ODU_ADD_PRE_MSG_MULT(&teidCb->preEncodedHdr.hdr[hdrLen], (EGTP_MAX_HDR_LEN - hdrLen), egtpMsg.msg);
DU_LOG("\nEGTP : UL Data buffer after encoding header");
- SPrntMsg(egtpMsg.msg, 0, 0);
+ ODU_PRINT_MSG(egtpMsg.msg, 0, 0);
/* Send over UDP */
egtpSendMsg(egtpMsg.msg);
- SPutMsg(egtpMsg.msg);
+ ODU_PUT_MSG(egtpMsg.msg);
return ROK;
}/* EgtpHdlDatInd */
* RFAILED - failure
*
* ****************************************************************/
-S16 egtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx)
+uint8_t egtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx)
{
- U8 tmpByte = 0; /* Stores one byte of data for enc */
- U8 cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
- Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
- U16 nwWord = 0;
+ uint8_t tmpByte = 0; /* Stores one byte of data for enc */
+ uint8_t cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
+ bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
+ uint16_t nwWord = 0;
/* Encoding header */
tmpByte |= EGTP_MASK_BIT6; /* Setting 6th LSB of 1st byte as version */
/* Encode Tunnel endpoint */
preEncodedHdr[--cnt] = 0;
preEncodedHdr[--cnt] = 0;
- nwWord = (U16)(GetHiWord(preDefHdr->teId));
- preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
- preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
- nwWord = (U16)(GetLoWord(preDefHdr->teId));
- preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
- preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
+ nwWord = (uint16_t)(GetHiWord(preDefHdr->teId));
+ preEncodedHdr[--cnt] = (uint8_t)(GetHiByte(nwWord));
+ preEncodedHdr[--cnt] = (uint8_t)(GetLoByte(nwWord));
+ nwWord = (uint16_t)(GetLoWord(preDefHdr->teId));
+ preEncodedHdr[--cnt] = (uint8_t)(GetHiByte(nwWord));
+ preEncodedHdr[--cnt] = (uint8_t)(GetLoByte(nwWord));
/* Encode sequence number */
if(preDefHdr->seqNum.pres)
* RFAILED - failure
*
* ****************************************************************/
-S16 egtpSendMsg(Buffer *mBuf)
+uint8_t egtpSendMsg(Buffer *mBuf)
{
- S16 ret;
- MsgLen txLen;
+ uint8_t ret;
+ uint16_t txLen;
CmInetMemInfo info;
CmInetAddr dstAddr;
* RFAILED - failure
*
* ****************************************************************/
-S16 egtpSlotInd()
+uint8_t egtpSlotInd()
{
egtpRecvMsg();
return ROK;
*
* ****************************************************************/
-S16 egtpRecvMsg()
+uint8_t egtpRecvMsg()
{
- U8 ret; /* Return value */
- U8 nMsg; /* Number of messages to read from UDP socked */
- MsgLen bufLen; /* Length of received buffer */
+ uint8_t ret; /* Return value */
+ uint8_t nMsg; /* Number of messages to read from UDP socked */
+ uint16_t bufLen; /* Length of received buffer */
Buffer *recvBuf; /* Received buffer */
CmInetAddr fromAddr; /* Egtp data sender address */
CmInetMemInfo memInfo; /* Buffer allocation info */
if(ret == ROK && recvBuf != NULLP)
{
DU_LOG("\nEGTP : Received DL Message[%d]\n", nMsg+1);
- SPrntMsg(recvBuf, 0 ,0);
+ ODU_PRINT_MSG(recvBuf, 0 ,0);
egtpHdlRecvData(recvBuf);
}
nMsg++;
return ROK;
}
-S16 egtpHdlRecvData(Buffer *mBuf)
+uint8_t egtpHdlRecvData(Buffer *mBuf)
{
EgtpMsg egtpMsg;
return ROK;
}
-S16 egtpDecodeHdr(Buffer *mBuf, EgtpMsg *egtpMsg)
+uint8_t egtpDecodeHdr(Buffer *mBuf, EgtpMsg *egtpMsg)
{
- U8 tmpByte[5]; /* Holds 5 byte of data after Decoding */
- U8 version = 0; /* Holds the version type, decoded */
- MsgLen msgLen = 0; /* Holds the msgLen from the Hdr */
- MsgLen bufLen = 0; /* Holds the total buffer length */
- U8 extHdrType = 0; /* Holds the Extension hdr type */
- U8 extHdrLen = 0; /* Extension hdr length */
- Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
+ uint8_t tmpByte[5]; /* Holds 5 byte of data after Decoding */
+ uint8_t version = 0; /* Holds the version type, decoded */
+ uint16_t msgLen = 0; /* Holds the msgLen from the Hdr */
+ uint16_t bufLen = 0; /* Holds the total buffer length */
+ uint8_t extHdrType = 0; /* Holds the Extension hdr type */
+ uint8_t extHdrLen = 0; /* Extension hdr length */
+ bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
- SFndLenMsg(mBuf, &bufLen);
+ ODU_FIND_MSG_LEN(mBuf, &bufLen);
/* Decode first byte and storing in temporary variable */
- SRemPreMsg(&tmpByte[0], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[0], mBuf);
/* Extracting version fro 1st byte */
version = tmpByte[0] >> 5;
DU_LOG("\nEGTP : Version %d", version);
/* Decode message type */
- SRemPreMsg((Data*)&(egtpMsg->msgHdr.msgType), mBuf);
+ ODU_REM_PRE_MSG((Data*)&(egtpMsg->msgHdr.msgType), mBuf);
DU_LOG("\nEGTP : msgType %d", egtpMsg->msgHdr.msgType);
/****************************************************************************
* Message length param is 2 bytes. So decode next 2 bytes from msg hdr and
* performing OR operation on these two bytes to calculate message length
***************************************************************************/
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
msgLen = (tmpByte[1] << 8) | tmpByte[2];
DU_LOG("\nEGTP : msgLen %d", msgLen);
* Tunnel id param is 4 bytes. So decode next 4 bytes from msg hdr and
* perform OR operation on these 4 bytes to calculate tunnel id
***************************************************************************/
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
- SRemPreMsg(&tmpByte[3], mBuf);
- SRemPreMsg(&tmpByte[4], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[3], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[4], mBuf);
egtpMsg->msgHdr.teId = (tmpByte[1] << 24) | (tmpByte[2] << 16) | (tmpByte[3] << 8) | tmpByte[4];
DU_LOG("\nEGTP : teId %d",egtpMsg->msgHdr.teId);
* perform OR operation on them
************************************************************************/
egtpMsg->msgHdr.seqNum.pres = TRUE;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg->msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
}
/****************************************************************************
* perform OR operation on them
************************************************************************/
egtpMsg->msgHdr.seqNum.pres = 0;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg->msgHdr.seqNum.val = (tmpByte[1] << 8) | tmpByte[2];
}
if (tmpByte[0] & EGTP_MASK_BIT1)
{
egtpMsg->msgHdr.nPdu.pres = TRUE;
- SRemPreMsg(&(egtpMsg->msgHdr.nPdu.val), mBuf);
+ ODU_REM_PRE_MSG(&(egtpMsg->msgHdr.nPdu.val), mBuf);
}
/****************************************************************************
* If extPres is true, but PN bit is not set, implies, either of S or E bit
else if(extPres)
{
egtpMsg->msgHdr.nPdu.pres = TRUE;
- SRemPreMsg(&(egtpMsg->msgHdr.nPdu.val), mBuf);
+ ODU_REM_PRE_MSG(&(egtpMsg->msgHdr.nPdu.val), mBuf);
}
/* If E flag is set in first byte, decode extension header */
if(tmpByte[0] & EGTP_MASK_BIT3)
{
- SRemPreMsg(&extHdrType, mBuf);
+ ODU_REM_PRE_MSG(&extHdrType, mBuf);
while( 0 != extHdrType)
{
switch (extHdrType)
{
case EGTP_EXT_HDR_UDP_TYPE:
{
- SRemPreMsg(&extHdrLen, mBuf);
+ ODU_REM_PRE_MSG(&extHdrLen, mBuf);
if(extHdrLen == 0x01)
{
/************************************************************
* and perform OR operation on them
*************************************************************/
egtpMsg->msgHdr.extHdr.udpPort.pres = TRUE;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg->msgHdr.extHdr.udpPort.val = (tmpByte[1] << 8) | tmpByte[2];
}
break;
case EGTP_EXT_HDR_PDCP_TYPE:
{
- SRemPreMsg(&extHdrLen, mBuf);
+ ODU_REM_PRE_MSG(&extHdrLen, mBuf);
if(extHdrLen == 0x01)
{
/*************************************************************
* and perform OR operation on them
************************************************************/
egtpMsg->msgHdr.extHdr.pdcpNmb.pres = TRUE;
- SRemPreMsg(&tmpByte[1], mBuf);
- SRemPreMsg(&tmpByte[2], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[1], mBuf);
+ ODU_REM_PRE_MSG(&tmpByte[2], mBuf);
egtpMsg->msgHdr.extHdr.pdcpNmb.val = (tmpByte[1] << 8) | tmpByte[2];
}
break;
}
} /* End of switch */
- SRemPreMsg(&extHdrType, mBuf);
+ ODU_REM_PRE_MSG(&extHdrType, mBuf);
} /* End of while */
}
***************************************************************************/
else if(extPres)
{
- SRemPreMsg(&extHdrType, mBuf);
+ ODU_REM_PRE_MSG(&extHdrType, mBuf);
}
egtpMsg->msg = mBuf;
DU_LOG("\nEGTP : DL Data Buffer after decoding header ");
- SPrntMsg(mBuf, 0, 0);
+ ODU_PRINT_MSG(mBuf, 0, 0);
/* Forward the data to duApp/RLC */
#define EGTP_MASK_BIT7 0x40
#define EGTP_MASK_BIT8 0x80
-S16 unpackEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf);
-U8 protType;
+uint8_t unpackEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf);
+uint8_t protType;
typedef struct egtpTptSrvr
{
typedef struct EgtpTeIdCb
{
- U32 teId; /* Local tunnel id */
- U32 remTeId; /* Remote tunnel id */
+ uint32_t teId; /* Local tunnel id */
+ uint32_t remTeId; /* Remote tunnel id */
struct
{
- U8 hdr[EGTP_MAX_HDR_LEN];
- U8 cnt;
+ uint8_t hdr[EGTP_MAX_HDR_LEN];
+ uint8_t cnt;
}preEncodedHdr; /* Pre-encoded header for PDUs on this tunnel */
}EgtpTeIdCb;
typedef struct egtpDstCb
{
CmInetIpAddr dstIp; /* destination IP */
- U16 dstPort; /* destination port that sends data */
+ uint16_t dstPort; /* destination port that sends data */
EgtpTptSrvr sendTptSrvr; /* Transport server for sending UDP msg to */
- U32 numTunn; /* Number of tunnels */
+ uint32_t numTunn; /* Number of tunnels */
CmHashListCp teIdLst; /* Tunnel Id list for this destination */
}EgtpDstCb;
extern EgtpGlobalCb egtpCb; /* EGTP global control block */
uint8_t duHdlEgtpDlData(EgtpMsg *egtpMsg);
-S16 egtpActvInit(Ent entity, Inst inst, Region region, Reason reason);
-S16 egtpActvTsk(Pst *pst, Buffer *mBuf);
-S16 egtpFillRspPst(Pst *pst, Pst *rspPst);
-S16 egtpCfgReq(Pst *pst, EgtpConfig egtpCfg);
-S16 egtpSrvOpenReq(Pst *pst);
-S16 egtpSrvOpenPrc(U8 sockType, EgtpTptSrvr *server);
-S16 egtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt);
-S16 egtpTnlAdd(EgtpTnlEvt tnlEvt);
-S16 egtpTnlMod(EgtpTnlEvt tnlEvt);
-S16 egtpTnlDel(EgtpTnlEvt tnlEvt);
-S16 egtpHdlDatInd(EgtpMsg msg);
-S16 egtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx);
-S16 egtpSendMsg(Buffer *mBuf);
-S16 egtpSlotInd();
-S16 egtpRecvMsg();
-S16 egtpHdlRecvData(Buffer *mBuf);
-S16 egtpDecodeHdr(Buffer *mBuf, EgtpMsg *egtpMsg);
+uint8_t egtpActvInit(Ent entity, Inst inst, Region region, Reason reason);
+uint8_t egtpActvTsk(Pst *pst, Buffer *mBuf);
+uint8_t egtpFillRspPst(Pst *pst, Pst *rspPst);
+uint8_t egtpCfgReq(Pst *pst, EgtpConfig egtpCfg);
+uint8_t egtpSrvOpenReq(Pst *pst);
+uint8_t egtpSrvOpenPrc(uint8_t sockType, EgtpTptSrvr *server);
+uint8_t egtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt);
+uint8_t egtpTnlAdd(EgtpTnlEvt tnlEvt);
+uint8_t egtpTnlMod(EgtpTnlEvt tnlEvt);
+uint8_t egtpTnlDel(EgtpTnlEvt tnlEvt);
+uint8_t egtpHdlDatInd(EgtpMsg msg);
+uint8_t egtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx);
+uint8_t egtpSendMsg(Buffer *mBuf);
+uint8_t egtpSlotInd();
+uint8_t egtpRecvMsg();
+uint8_t egtpHdlRecvData(Buffer *mBuf);
+uint8_t egtpDecodeHdr(Buffer *mBuf, EgtpMsg *egtpMsg);
#endif
#include "du_mgr.h"
#include "du_f1ap_msg_hdl.h"
-S16 procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg);
+uint8_t procGNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg);
uint8_t procDlRrcMsgTrans(F1AP_PDU_t *f1apMsg);
void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg);
extern char encBuf[ENC_BUF_MAX_LEN];
extern DuCfgParams duCfgParam;
uint8_t BuildULTnlInforet=RFAILED;
uint8_t ServedCellListreturn=RFAILED;
-S16 sctpSend(Buffer *mBuf, U8 itfType);
+uint8_t sctpSend(Buffer *mBuf, U8 itfType);
uint8_t Nrcgiret=RFAILED;
uint8_t SplCellListret=RFAILED;
uint8_t SRBSetupret=RFAILED;
{
Buffer *mBuf;
- if(SGetMsg(region, pool, &mBuf) == ROK)
+ if(ODU_GET_MSG(region, pool, &mBuf) == ROK)
{
- if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
+ if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
{
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
if(sctpSend(mBuf, F1_INTERFACE) != ROK)
{
DU_LOG("\nF1AP : SCTP Send failed");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nF1AP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
+ DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
else
{
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
/* Encode the DU Config Update type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
/* encode cellGrpCfg into duToCuRrcContainer */
xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
/* Encode results */
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
/* Encode results */
xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
encBuf);
F1AP_PDU_t f1apasnmsg ;
DU_LOG("\nF1AP : Received F1AP message buffer");
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
- SFndLenMsg(mBuf, &recvBufLen);
- if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
+ ODU_FIND_MSG_LEN(mBuf, &recvBufLen);
+ DU_ALLOC(recvBuf, (Size)recvBufLen);
+
+ if(recvBuf == NULLP)
{
DU_LOG("\nF1AP : Memory allocation failed");
return;
}
- if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
+ if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
return;
memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
- SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
+ DU_FREE(recvBuf, (Size)recvBufLen);
+
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
DU_LOG("\nF1AP : ASN decode failed");
#define MAC_CONFIGURED (MAC_GEN_CFG | MAC_SAP_CFG)
#define DU_SET_ZERO(_buf, _size) \
- cmMemset((U8 *)(_buf), 0, _size);
+ memset((uint8_t *)(_buf), 0, _size);
typedef enum
{
typedef struct cellCfgParams
{
NrEcgi nrEcgi; /* ECGI */
- U16 nrPci; /* PCI */
- U16 fiveGsTac; /* 5gSTac */
+ uint16_t nrPci; /* PCI */
+ uint16_t fiveGsTac; /* 5gSTac */
Plmn plmn[MAX_PLMN]; /* List of serving PLMN IDs */
- U32 maxUe; /* max UE per slot */
+ uint32_t maxUe; /* max UE per slot */
}CellCfgParams;
typedef struct duUeCb
{
uint16_t cellId; /* Internal cell Id */
CellCfgParams cellInfo; /* Cell info */
- Bool firstSlotIndRcvd;
+ bool firstSlotIndRcvd;
CellStatus cellStatus; /* Cell status */
uint32_t numActvUes; /* Total Active UEs */
DuUeCb ueCb[MAX_NUM_UE]; /* UE CONTEXT */
State sapState;
Mem mem;
CmTimer timer;
- U8 bndRetryCnt;
- U8 maxBndRetry;
+ uint8_t bndRetryCnt;
+ uint8_t maxBndRetry;
TmrCfg bndTmr;
}DuLSapCb;
Mem mem; /* Memory configs */
TskInit init; /* DU Init */
//DuLSapCb **macSap; /* MAC SAP */
- Bool f1Status; /* Status of F1 connection */
- Bool e2Status; /* Status of E2 connection */
+ bool f1Status; /* Status of F1 connection */
+ bool e2Status; /* Status of E2 connection */
uint8_t numCfgCells;
DuCellCb* cfgCellLst[MAX_NUM_CELL]; /* List of cells at DU APP of type DuCellCb */
uint8_t numActvCells;
Route dstRoute;
Selector dstSel;
Mem mem;
- U8 maxBndRetry;
+ uint8_t maxBndRetry;
TmrCfg bndTmr;
TmrCfg connTmr;
}DuLSapCfg;
//DuCfgParams duCfgParam;
/* DU Cell Functions */
-S16 duActvInit(Ent entity, Inst inst, Region region, Reason reason);
-S16 duActvTsk(Pst *pst, Buffer *mBuf);
-S16 duSendRlcUlCfg();
-S16 duSendRlcDlCfg();
-S16 duBuildRlcCfg(Inst inst);
-S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst);
-S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst);
-S16 DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm);
-S16 duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cfm);
-S16 duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm);
-S16 duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm);
-S16 duSendMacCfg();
-S16 duBuildMacGenCfg();
-S16 duBuildMacUsapCfg(SpId sapId);
-S16 duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm);
-S16 duBindUnbindRlcToMacSap(U8 inst, U8 action);
-S16 duProcCfgComplete();
-S16 duSendSchCfg();
-S16 duSctpStartReq();
-S16 duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy);
-
-S16 duBuildEgtpCfgReq();
-S16 duHdlEgtpCfgComplete(CmStatus cfm);
-S16 duSendEgtpSrvOpenReq();
-S16 duHdlEgtpSrvOpenComplete(CmStatus cfm);
-S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid);
-S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm);
-S16 duSendEgtpTestData();
-S16 duSendEgtpDatInd(Buffer *mBuf);
-S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm);
+uint8_t duActvInit(Ent entity, Inst inst, Region region, Reason reason);
+uint8_t duActvTsk(Pst *pst, Buffer *mBuf);
+uint8_t duSendRlcUlCfg();
+uint8_t duSendRlcDlCfg();
+uint8_t duBuildRlcCfg(Inst inst);
+uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst);
+uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst);
+uint8_t DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm);
+uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cfm);
+uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm);
+uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm);
+uint8_t duSendMacCfg();
+uint8_t duBuildMacGenCfg();
+uint8_t duBuildMacUsapCfg(SpId sapId);
+uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm);
+uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action);
+uint8_t duProcCfgComplete();
+uint8_t duSendSchCfg();
+uint8_t duSctpStartReq();
+uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy);
+
+uint8_t duBuildEgtpCfgReq();
+uint8_t duHdlEgtpCfgComplete(CmStatus cfm);
+uint8_t duSendEgtpSrvOpenReq();
+uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm);
+uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid);
+uint8_t duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm);
+uint8_t duSendEgtpTestData();
+uint8_t duSendEgtpDatInd(Buffer *mBuf);
+uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm);
uint8_t duBuildAndSendMacCellStartReq();
uint8_t duBuildAndSendMacCellStopReq();
#endif
#include "du_ue_mgr.h"
#include "du_utils.h"
-extern S16 unpackRlcConfigCfm(RlcConfigCfm func,Pst *pst, Buffer *mBuf);
-extern S16 cmUnpkLkwCntrlCfm(LkwCntrlCfm func,Pst *pst, Buffer *mBuf);
-extern S16 cmUnpkLrgCfgCfm(LrgCfgCfm func,Pst *pst, Buffer *mBuf);
+extern uint8_t unpackRlcConfigCfm(RlcConfigCfm func,Pst *pst, Buffer *mBuf);
+extern uint8_t cmUnpkLkwCntrlCfm(LkwCntrlCfm func,Pst *pst, Buffer *mBuf);
+extern uint8_t cmUnpkLrgCfgCfm(LrgCfgCfm func,Pst *pst, Buffer *mBuf);
extern uint8_t cmUnpkKwuDatInd(KwuDatInd func,Pst *pst, Buffer *mBuf);
-extern S16 cmUnpkLrgSchCfgCfm(LrgSchCfgCfm func,Pst *pst,Buffer *mBuf);
+extern uint8_t cmUnpkLrgSchCfgCfm(LrgSchCfgCfm func,Pst *pst,Buffer *mBuf);
/**************************************************************************
* @brief Task Initiation callback function.
*
* @return ROK - success
* RFAILED - failure
***************************************************************************/
-S16 duActvInit(Ent entity, Inst inst, Region region, Reason reason)
+uint8_t duActvInit(Ent entity, Inst inst, Region region, Reason reason)
{
uint8_t id;
duCb.numCfgCells = 0;
duCb.numActvCells = 0;
- SSetProcId(DU_PROC);
+ ODU_SET_PROC_ID(DU_PROC);
return ROK;
* RFAILED - failure
*
***************************************************************************/
-S16 duActvTsk(Pst *pst, Buffer *mBuf)
+uint8_t duActvTsk(Pst *pst, Buffer *mBuf)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
switch(pst->srcEnt)
{
{
DU_LOG("\n****** Received initial configs at DU APP ******\n");
duProcCfgComplete();
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
default:
{
DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTDUAPP");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
}
{
DU_LOG("\nDU_APP : Invalid event %d received at duActvTsk from ENTKW", \
pst->event);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
}
//Config complete
case EVTCFG:
{
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
case EVTLRGCFGCFM:
default:
{
DU_LOG("\nDU_APP : Invalid event received at duActvTsk from ENTRG");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
}
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
case ENTEGTP:
ret = RFAILED;
}
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
break;
}
default:
{
DU_LOG("\nDU_APP : DU APP can not process message from Entity %d", pst->srcEnt);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
ret = RFAILED;
}
}
- SExitTsk();
+ ODU_EXIT_TASK();
return ret;
}
#include "du_sctp.h"
#include "du_egtp.h"
-extern S16 rlcUlActvTsk (Pst *, Buffer *);
-extern S16 rlcUlActvInit (Ent, Inst, Region, Reason);
-extern S16 rlcDlActvTsk (Pst *, Buffer *);
-extern S16 rlcDlActvInit (Ent, Inst, Region, Reason);
-extern S16 rgActvTsk (Pst *, Buffer *);
-extern S16 rgActvInit (Ent, Inst, Region, Reason);
+extern uint8_t rlcUlActvTsk (Pst *, Buffer *);
+extern uint8_t rlcUlActvInit (Ent, Inst, Region, Reason);
+extern uint8_t rlcDlActvTsk (Pst *, Buffer *);
+extern uint8_t rlcDlActvInit (Ent, Inst, Region, Reason);
+extern uint8_t rgActvTsk (Pst *, Buffer *);
+extern uint8_t rgActvInit (Ent, Inst, Region, Reason);
/* Global variable */
DuCfgParams duCfgParam;
* RFAILED - failure
*
* ****************************************************************/
-S16 duAppInit(SSTskId sysTskId)
+uint8_t duAppInit(SSTskId sysTskId)
{
/* Register DU APP TAPA Task for DU */
- if(SRegTTsk((Ent)ENTDUAPP, (Inst)DU_INST, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTDUAPP, (Inst)DU_INST, (Ttype)TTNORM, (Prior)PRIOR0,
duActvInit, (ActvTsk)duActvTsk) != ROK)
{
return RFAILED;
}
/* Attach DU APP TAPA Task for DU */
- if (SAttachTTsk((Ent)ENTDUAPP, (Inst)0, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTDUAPP, (Inst)0, sysTskId)!= ROK)
{
return RFAILED;
}
* RFAILED - failure
*
* ****************************************************************/
-S16 egtpInit(SSTskId sysTskId)
+uint8_t egtpInit(SSTskId sysTskId)
{
/* Register DU APP TAPA Task for DU */
- if(SRegTTsk((Ent)ENTEGTP, (Inst)EGTP_INST, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTEGTP, (Inst)EGTP_INST, (Ttype)TTNORM, (Prior)PRIOR0,
egtpActvInit, (ActvTsk)egtpActvTsk) != ROK)
{
return RFAILED;
}
/* Attach DU APP TAPA Task for DU */
- if (SAttachTTsk((Ent)ENTEGTP, (Inst)0, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTEGTP, (Inst)0, sysTskId)!= ROK)
{
return RFAILED;
}
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpInit(SSTskId sysTskId)
+uint8_t sctpInit(SSTskId sysTskId)
{
/* Register SCTP TAPA Task */
- if(SRegTTsk((Ent)ENTSCTP, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTSCTP, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
sctpActvInit, (ActvTsk)sctpActvTsk) != ROK)
{
return RFAILED;
}
/* Attach SCTP TAPA Task */
- if (SAttachTTsk((Ent)ENTSCTP, (Inst)SCTP_INST, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTSCTP, (Inst)SCTP_INST, sysTskId)!= ROK)
{
return RFAILED;
}
* RFAILED - failure
*
* ****************************************************************/
-S16 rlcDlInit(SSTskId sysTskId)
+uint8_t rlcDlInit(SSTskId sysTskId)
{
/* Register RLC DL TAPA Task */
- if(SRegTTsk((Ent)ENTKW, (Inst)1, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTKW, (Inst)1, (Ttype)TTNORM, (Prior)PRIOR0,
rlcDlActvInit, (ActvTsk)rlcDlActvTsk) != ROK)
{
return RFAILED;
}
/* Attach RLC DL Task */
- if (SAttachTTsk((Ent)ENTKW, (Inst)1, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTKW, (Inst)1, sysTskId)!= ROK)
{
return RFAILED;
}
/* Register MAC TAPA Task */
- if(SRegTTsk((Ent)ENTRG, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTRG, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
rgActvInit, (ActvTsk)rgActvTsk) != ROK)
{
return RFAILED;
}
/* Attach MAC Task */
- if (SAttachTTsk((Ent)ENTRG, (Inst)0, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTRG, (Inst)0, sysTskId)!= ROK)
{
return RFAILED;
}
* RFAILED - failure
*
* ****************************************************************/
-S16 rlcUlInit(SSTskId sysTskId)
+uint8_t rlcUlInit(SSTskId sysTskId)
{
/* Register RLC UL TAPA Task */
- if(SRegTTsk((Ent)ENTKW, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
+ if(ODU_REG_TTSK((Ent)ENTKW, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
rlcUlActvInit, (ActvTsk)rlcUlActvTsk) != ROK)
{
return RFAILED;
}
/* Attach RLC DL Task */
- if (SAttachTTsk((Ent)ENTKW, (Inst)0, sysTskId)!= ROK)
+ if (ODU_ATTACH_TTSK((Ent)ENTKW, (Inst)0, sysTskId)!= ROK)
{
return RFAILED;
}
* RFAILED - failure
*
* ****************************************************************/
-S16 commonInit()
+uint8_t commonInit()
{
/* Declare system task Ids */
SSTskId du_app_stsk, sctp_stsk, rlc_ul_stsk, rlc_mac_cl_stsk;
pthread_attr_t attr;
- SSetProcId(DU_PROC);
+ ODU_SET_PROC_ID(DU_PROC);
/* system task for DU APP */
SCreateSTsk(PRIOR0, &du_app_stsk);
* RFAILED - failure
*
* ****************************************************************/
-S16 duInit()
+uint8_t duInit()
{
int ret = ROK;
if(commonInit() != ROK)
* RFAILED - failure
*
* ****************************************************************/
-S16 tst(void)
+uint8_t tst(void)
{
init_log();
#define __DU_MGR_MAIN_H__
/* Function declarations */
-S16 duAppInit(SSTskId sysTskId);
-S16 sctpInit(SSTskId sysTskId);
-S16 rlcDlInit(SSTskId sysTskId);
-S16 rlcUlInit(SSTskId sysTskId);
-S16 commonInit();
-S16 duInit();
-S16 tst(void);
+uint8_t duAppInit(SSTskId sysTskId);
+uint8_t sctpInit(SSTskId sysTskId);
+uint8_t rlcDlInit(SSTskId sysTskId);
+uint8_t rlcUlInit(SSTskId sysTskId);
+uint8_t commonInit();
+uint8_t duInit();
+uint8_t tst(void);
#endif
#include "lphy_stub.h"
#include "du_utils.h"
-U8 rlcDlCfg = 0;
-U8 numRlcDlSaps = 0;
-U8 rlcUlCfg = 0;
-U8 numRlcMacSaps = 0;
-U8 macCfg = 0;
-U8 macCfgInst = 0;
+uint8_t rlcDlCfg = 0;
+uint8_t numRlcDlSaps = 0;
+uint8_t rlcUlCfg = 0;
+uint8_t numRlcMacSaps = 0;
+uint8_t macCfg = 0;
+uint8_t macCfgInst = 0;
extern DuCfgParams duCfgParam;
-extern S16 packRlcConfigReq(Pst *pst, KwMngmt *cfg);
-extern S16 cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg);
-extern S16 cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg);
-extern S16 BuildAndSendE2SetupReq();
-extern S16 egtpHdlDatInd(EgtpMsg egtpMsg);
+extern uint8_t packRlcConfigReq(Pst *pst, KwMngmt *cfg);
+extern uint8_t cmPkLkwCntrlReq(Pst *pst, KwMngmt *cfg);
+extern uint8_t cmPkLrgCfgReq(Pst *pst, RgMngmt *cfg);
+extern uint8_t BuildAndSendE2SetupReq();
+extern uint8_t egtpHdlDatInd(EgtpMsg egtpMsg);
extern uint8_t BuildAndSendDUConfigUpdate();
-extern U16 getTransId();
-extern S16 cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg);
+extern uint16_t getTransId();
+extern uint8_t cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg);
packMacCellCfgReq packMacCellCfgOpts[] =
{
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildRlcCfg(Inst inst)
+uint8_t duBuildRlcCfg(Inst inst)
{
KwMngmt kwMngmt;
KwGenCfg *genCfg = NULLP;
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildRlcLsapCfg(Ent ent, Inst inst, U8 lsapInst)
+uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst)
{
KwMngmt kwMngmt;
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildRlcUsapCfg(U8 elemId, Ent ent, Inst inst)
+uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst)
{
KwMngmt kwMngmt;
KwSapCfg *uSap = NULLP;
* RFAILED - failure
*
***************************************************************************/
-S16 duProcCfgComplete()
+uint8_t duProcCfgComplete()
{
- S16 ret = ROK;
- static U16 cellId = 0;
- U16 idx;
+ uint8_t ret = ROK;
+ static uint16_t cellId = 0;
+ uint16_t idx;
for(idx=0; idx< DEFAULT_CELLS; idx++)
{
DuCellCb *cell = NULLP;
}
else
{
- U32 nci;
- U8 idx1;
+ uint32_t nci;
+ uint8_t idx1;
memset(cell, 0, sizeof(DuCellCb));
cell->cellId = ++cellId;
cell->cellInfo.nrEcgi.plmn.mcc[0] = PLMN_MCC0;
}
cell->cellInfo.maxUe = duCfgParam.maxUe;
cell->cellStatus = CELL_OUT_OF_SERVICE;
- nci = (U16)cell->cellInfo.nrEcgi.cellId;
+ nci = (uint16_t)cell->cellInfo.nrEcgi.cellId;
duCb.cfgCellLst[nci-1] = cell;
duCb.numCfgCells++;
* RFAILED - failure
*
***************************************************************************/
-S16 duSendRlcUlCfg()
+uint8_t duSendRlcUlCfg()
{
- U8 cellIdx;
+ uint8_t cellIdx;
duBuildRlcCfg((Inst)RLC_UL_INST);
for(cellIdx = 0; cellIdx < DEFAULT_CELLS; cellIdx++)
* RFAILED - failure
*
***************************************************************************/
-S16 duSendRlcDlCfg()
+uint8_t duSendRlcDlCfg()
{
- U8 cellIdx;
+ uint8_t cellIdx;
duBuildRlcCfg((Inst)RLC_DL_INST);
duBuildRlcUsapCfg(STUDXSAP, ENTKW, (Inst)RLC_DL_INST);
* RFAILED - failure
*
***************************************************************************/
-S16 DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm)
+uint8_t DuHdlRlcCfgComplete(Pst *pst, KwMngmt *cfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if (pst->srcInst == RLC_UL_INST)
{
ret = duProcRlcUlCfgComplete(pst, cfm);
* RFAILED - failure
*
***************************************************************************/
-S16 duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl)
+uint8_t duHdlRlcCntrlCfgComplete(Pst *pst, KwMngmt *cntrl)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if (cntrl->cfm.status == LCM_PRIM_OK)
{
* RFAILED - failure
*
***************************************************************************/
-S16 duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm)
+uint8_t duProcRlcUlCfgComplete(Pst *pst, KwMngmt *cfm)
{
- S16 ret;
+ uint8_t ret;
DU_LOG("\nDU_APP : RLC UL Cfg Status %d", cfm->cfm.status);
if (cfm->cfm.status == LCM_PRIM_OK)
* RFAILED - failure
*
***************************************************************************/
-S16 duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm)
+uint8_t duProcRlcDlCfgComplete(Pst *pst, KwMngmt *cfm)
{
DU_LOG("\nDU_APP : RLC DL Cfg Status %d", cfm->cfm.status);
if (cfm->cfm.status == LCM_PRIM_OK)
* RFAILED - failure
*
***************************************************************************/
-S16 duSendMacCfg()
+uint8_t duSendMacCfg()
{
duBuildMacGenCfg();
duBuildMacUsapCfg(RLC_UL_INST);
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildMacGenCfg()
+uint8_t duBuildMacGenCfg()
{
RgMngmt rgMngmt;
RgGenCfg *genCfg=NULLP;
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildMacUsapCfg(SpId sapId)
+uint8_t duBuildMacUsapCfg(SpId sapId)
{
RgMngmt rgMngmt;
RgUpSapCfg *uSap = NULLP;
* RFAILED - failure
*
***************************************************************************/
-S16 duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm)
+uint8_t duHdlMacCfgComplete(Pst *pst, RgMngmt *cfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if (cfm->cfm.status == LCM_PRIM_OK)
{
* RFAILED - failure
*
***************************************************************************/
-S16 duBindUnbindRlcToMacSap(U8 inst, U8 action)
+uint8_t duBindUnbindRlcToMacSap(uint8_t inst, uint8_t action)
{
KwCntrl *cntrl = NULLP;
KwMngmt kwMngmt;
*
* ****************************************************************/
-S16 duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy)
+uint8_t duSctpNtfyHdl(Buffer *mBuf, CmInetSctpNotification *ntfy)
{
if(f1Params.assocId == ntfy->u.assocChange.assocId)
{
* RFAILED - failure
*
* ****************************************************************/
-S16 duFillEgtpPst(Pst *pst, Event event)
+uint8_t duFillEgtpPst(Pst *pst, Event event)
{
- cmMemset((U8 *)pst, 0, sizeof(Pst));
+ memset((uint8_t *)pst, 0, sizeof(Pst));
pst->srcEnt = (Ent)ENTDUAPP;
pst->srcInst = (Inst)DU_INST;
pst->srcProcId = DU_PROC;
pst->selector = ODU_SELECTOR_LC;
pst->pool= DU_POOL;
- RETVALUE(ROK);
+ return ROK;
}
*
* ****************************************************************/
-S16 duBuildEgtpCfgReq()
+uint8_t duBuildEgtpCfgReq()
{
Pst pst;
EgtpConfig egtpCfg;
DU_LOG("\nDU_APP : Sending EGTP config request");
- cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig));
- cmMemcpy((U8 *)&egtpCfg, (U8 *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig));
+ memset((uint8_t *)&egtpCfg, 0, sizeof(EgtpConfig));
+ memcpy((uint8_t *)&egtpCfg, (uint8_t *)&duCfgParam.egtpParams, (PTR)sizeof(EgtpConfig));
duFillEgtpPst(&pst, EVTCFGREQ);
packEgtpCfgReq(&pst, egtpCfg);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 duHdlEgtpCfgComplete(CmStatus cfm)
+uint8_t duHdlEgtpCfgComplete(CmStatus cfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if(cfm.status == LCM_PRIM_OK)
{
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
*
* ****************************************************************/
-S16 duSendEgtpSrvOpenReq()
+uint8_t duSendEgtpSrvOpenReq()
{
Pst pst;
duFillEgtpPst(&pst, EVTSRVOPENREQ);
packEgtpSrvOpenReq(&pst);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
*
*****************************************************************/
-S16 duHdlEgtpSrvOpenComplete(CmStatus cfm)
+uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if(cfm.status == LCM_PRIM_OK)
{
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
*
* ****************************************************************/
-S16 duSendEgtpTnlMgmtReq(U8 action, U32 lclTeid, U32 remTeid)
+uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid)
{
Pst pst;
EgtpTnlEvt tnlEvt;
duFillEgtpPst(&pst, EVTTNLMGMTREQ);
packEgtpTnlMgmtReq(&pst, tnlEvt);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm)
+uint8_t duHdlEgtpTnlMgmtCfm(EgtpTnlEvt tnlEvtCfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK)
{
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
-S16 duSendEgtpDatInd(Buffer *mBuf)
+uint8_t duSendEgtpDatInd(Buffer *mBuf)
{
EgtpMsg egtpMsg;
* RFAILED - failure
*
* ****************************************************************/
-S16 duSendEgtpTestData()
+uint8_t duSendEgtpTestData()
{
char data[30] = "This is EGTP data from DU";
int datSize = 30;
Buffer *mBuf;
- if(SGetMsg(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
+ if(ODU_GET_MSG(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
{
- if(SAddPstMsgMult((Data *)data, datSize, mBuf) != ROK)
+ if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
{
- DU_LOG("\nDU_APP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
- RETVALUE(RFAILED);
+ DU_LOG("\nDU_APP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG(mBuf);
+ return RFAILED;
}
}
else
{
DU_LOG("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* filling IPv4 header */
MsgLen mLen;
mLen = 0;
- SFndLenMsg(mBuf, &mLen);
+ ODU_FIND_MSG_LEN(mBuf, &mLen);
- cmMemset((U8 *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
+ memset((uint8_t *)&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
ipv4Hdr.destAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.destIp.ipV4Addr);
/* Packing IPv4 header into buffer */
- S16 ret, cnt, idx;
+ uint8_t ret, cnt, idx;
Data revPkArray[CM_IPV4_HDRLEN];
Data pkArray[CM_IPV4_HDRLEN];
/* initialize locals */
cnt = 0;
- cmMemset(revPkArray, 0, CM_IPV4_HDRLEN);
- cmMemset(pkArray, 0, CM_IPV4_HDRLEN);
+ memset(revPkArray, 0, CM_IPV4_HDRLEN);
+ memset(pkArray, 0, CM_IPV4_HDRLEN);
/* Pack Header Version */
pkArray[cnt++] = ipv4Hdr.hdrVer;
revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
/* this function automatically reverses revPkArray */
- ret = SAddPreMsgMult(revPkArray, (MsgLen)cnt, mBuf);
+ ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
duSendEgtpDatInd(mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* EGTP_TEST */
* RFAILED - failure
*
***************************************************************************/
-S16 duSendSchCfg()
+uint8_t duSendSchCfg()
{
RgMngmt rgMngmt;
RgSchInstCfg *cfg = NULLP;
* RFAILED - failure
*
***************************************************************************/
-S16 duLayerConfigComplete()
+uint8_t duLayerConfigComplete()
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
DU_LOG("\nDU_APP : Configuring all Layer is complete");
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/**************************************************************************
* RFAILED - failure
*
***************************************************************************/
-S16 duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm)
+uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm)
{
if (cfm->cfm.status == LCM_PRIM_OK)
{
* RFAILED - failure
*
* ****************************************************************/
-S16 duSendEgtpSlotInd()
+uint8_t duSendEgtpSlotInd()
{
Pst pst;
duFillEgtpPst(&pst, EVTSLOTIND);
packEgtpSlotInd(&pst);
- RETVALUE(ROK);
+ return ROK;
}
* RFAILED - failure
*
***************************************************************************/
-S16 duBuildAndSendMacCellCfg()
+uint8_t duBuildAndSendMacCellCfg()
{
Pst pst;
DU_SET_ZERO(&pst, sizeof(Pst));
* @return ROK - success
* RFAILED - failure
***************************************************************************/
-S16 sctpActvInit(Ent entity, Inst inst, Region region, Reason reason)
+uint8_t sctpActvInit(Ent entity, Inst inst, Region region, Reason reason)
{
DU_LOG("\n\nSCTP : Initializing");
- SSetProcId(DU_PROC);
+ ODU_SET_PROC_ID(DU_PROC);
connUp = FALSE;
f1Params.assocId = -1;
ricParams.assocId = -1;
* RFAILED - failure
*
***************************************************************************/
-S16 sctpActvTsk(Pst *pst, Buffer *mBuf)
+uint8_t sctpActvTsk(Pst *pst, Buffer *mBuf)
{
switch(pst->srcEnt)
{
break;
}
}
- SExitTsk();
+ ODU_EXIT_TASK();
return ROK;
}
/*******************************************************************
* RFAILED - failure
*
******************************************************************/
-S16 duCheckReqStatus(CmStatus *cfm)
+uint8_t duCheckReqStatus(CmStatus *cfm)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
if(cfm->status != LCM_PRIM_OK)
{
DU_LOG("\nDU_APP : Failed to process the request successfully");
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/**************************************************************************
*
***************************************************************************/
-S16 duSctpCfgReq(SctpParams sctpCfg)
+uint8_t duSctpCfgReq(SctpParams sctpCfg)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
CmStatus cfm;
/* Fill F1 Params */
f1Params.itfState = DU_SCTP_DOWN;
f1Params.srcPort = sctpCfg.duPort[F1_INTERFACE];
f1Params.recvMsgSet = ROK;
- cmMemset ((U8 *)&f1Params.sockFd, -1, sizeof(CmInetFd));
+ memset ((uint8_t *)&f1Params.sockFd, -1, sizeof(CmInetFd));
fillDestNetAddr(&f1Params.destIpNetAddr, &f1Params.destIpAddr);
fillAddrLst(&f1Params.destAddrLst, &f1Params.destIpAddr);
ricParams.itfState = DU_SCTP_DOWN;
ricParams.srcPort = sctpCfg.duPort[E2_INTERFACE];
ricParams.recvMsgSet = ROK;
- cmMemset ((U8 *)&ricParams.sockFd, -1, sizeof(CmInetFd));
+ memset ((uint8_t *)&ricParams.sockFd, -1, sizeof(CmInetFd));
fillDestNetAddr(&ricParams.destIpNetAddr, &ricParams.destIpAddr);
fillAddrLst(&ricParams.destAddrLst, &ricParams.destIpAddr);
ret = duCheckReqStatus(&cfm);
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
*
******************************************************************/
-S16 fillAddrLst(CmInetNetAddrLst *addrLstPtr, F1IpAddr *ipAddr)
+uint8_t fillAddrLst(CmInetNetAddrLst *addrLstPtr, F1IpAddr *ipAddr)
{
addrLstPtr->count++;
addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE;
addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_U32(ipAddr->ipV4Addr);
- RETVALUE(ROK);
+ return ROK;
}
/******************************************************************************
* RFAILED - failure
*
*******************************************************************************/
-S16 fillDestNetAddr(CmInetNetAddr *destAddrPtr, F1IpAddr *dstIpPtr)
+uint8_t fillDestNetAddr(CmInetNetAddr *destAddrPtr, F1IpAddr *dstIpPtr)
{
/* Filling destination address */
destAddrPtr->type = CM_INET_IPV4ADDR_TYPE;
destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_U32(dstIpPtr->ipV4Addr);
- RETVALUE(ROK);
+ return ROK;
}
/******************************************************************************
*
*******************************************************************************/
-S16 establishReq(DuSctpDestCb *paramPtr)
+uint8_t establishReq(DuSctpDestCb *paramPtr)
{
Pst pst;
- S16 ret = ROK;
+ uint8_t ret = ROK;
socket_type = CM_INET_STREAM;
if((ret = cmInetSocket(socket_type, ¶mPtr->sockFd, IPPROTO_SCTP)) != ROK)
duFillSctpPst(&pst, EVTSTARTPOLL);
}
- RETVALUE(ret);
+ return (ret);
}
/******************************************************************************
*
*******************************************************************************/
-S16 duSctpAssocReq(U8 itfType)
+uint8_t duSctpAssocReq(uint8_t itfType)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
CmStatus cfm;
DuSctpDestCb *paramPtr = NULLP;
if(paramPtr == NULLP)
{
printf("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
switch(itfType)
{
}
ret = duCheckReqStatus(&cfm);
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-S16 duFillSctpPst(Pst *pst, Event event)
+uint8_t duFillSctpPst(Pst *pst, Event event)
{
Buffer *mBuf;
- if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
+ if(ODU_GET_MSG(DFLT_REGION, DU_POOL, &mBuf) != ROK)
{
printf("\nDU_APP : Failed to allocate memory");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- cmMemset((U8 *)pst, 0, sizeof(Pst));
+ memset((uint8_t *)pst, 0, sizeof(Pst));
pst->srcEnt = (Ent)ENTDUAPP;
pst->srcInst = (Inst)DU_INST;
pst->srcProcId = DU_PROC;
pst->event = event;
pst->selector = ODU_SELECTOR_LC;
pst->pool= DU_POOL;
- SPstTsk(pst, mBuf);
+ ODU_POST_TASK(pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpSetSockOpts(CmInetFd *sock_Fd)
+uint8_t sctpSetSockOpts(CmInetFd *sock_Fd)
{
- S16 ret = ROK;
+ uint8_t ret = ROK;
CmSctpEvent sctpEvent;
sctpEvent.dataIoEvent = TRUE;
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
{
Pst pst;
DU_LOG("\nSCTP : Forwarding received message to duApp");
- SPrntMsg(mBuf, 0, 0);
+ ODU_PRINT_MSG(mBuf, 0, 0);
- cmMemset((U8 *)&(pst), 0, sizeof(Pst));
+ memset((uint8_t *)&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
pst.srcInst = (Inst)SCTP_INST;
pst.srcProcId = DU_PROC;
pst.pool= DU_POOL;
pst.region = DFLT_REGION;
- if (SPstTsk(&pst, mBuf) != ROK)
+ if (ODU_POST_TASK(&pst, mBuf) != ROK)
{
- DU_LOG("\nSCTP : SPstTsk failed in duReadCfg");
+ DU_LOG("\nSCTP : ODU_POST_TASK failed in duReadCfg");
}
}
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpNtfyHdlr(CmInetSctpNotification *ntfy, U8 *itfState)
+uint8_t sctpNtfyHdlr(CmInetSctpNotification *ntfy, uint8_t *itfState)
{
Pst pst;
/* Pack notification and send to APP */
DU_LOG("\nSCTP : Forwarding received message to duApp");
- cmMemset((U8 *)&(pst), 0, sizeof(Pst));
+ memset((uint8_t *)&(pst), 0, sizeof(Pst));
pst.srcEnt = (Ent)ENTSCTP;
pst.srcInst = (Inst)SCTP_INST;
pst.srcProcId = DU_PROC;
if(cmPkSctpNtfy(&pst, ntfy) != ROK)
{
DU_LOG("\nSCTP : Failed to pack SCTP notification");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
*
* ****************************************************************/
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo, Bool recvMsgSet)
+uint8_t processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo, bool recvMsgSet)
{
- U16 ret = ROK;
+ uint8_t ret = ROK;
CM_INET_FD_SET(sockFd, &pollParams->readFd);
ret = cmInetSelect(&pollParams->readFd, NULLP, timeoutPtr, &pollParams->numFd);
if(CM_INET_FD_ISSET(sockFd, &pollParams->readFd))
else
{
DU_LOG("\nSCTP : Failed to fill AssocId\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ret != ROK)
{
else
{
- SPutMsg(pollParams->mBuf);
+ ODU_PUT_MSG(pollParams->mBuf);
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpSockPoll()
+uint8_t sctpSockPoll()
{
- U16 ret = ROK;
- U32 timeout;
- U32 *timeout_Ptr;
+ uint8_t ret = ROK;
+ uint32_t timeout;
+ uint32_t *timeout_Ptr;
CmInetMemInfo memInfo;
sctpSockPollParams f1PollParams, e2PollParams;
CM_INET_FD_ZERO(&e2PollParams.readFd);
DU_LOG("\nSCTP : Polling started at DU\n");
- while(1)
+ while(true)
{
if(f1Params.itfState)
{
}
}
};
- RETVALUE(ret);
+ return (ret);
}/* End of sctpSockPoll() */
/*******************************************************************
* RFAILED - failure
*
* ****************************************************************/
-S16 sctpSend(Buffer *mBuf, U8 itfType)
+uint8_t sctpSend(Buffer *mBuf, uint8_t itfType)
{
- U8 ret;
+ uint8_t ret;
MsgLen len; /* number of actually sent octets */
CmInetMemInfo memInfo;
if(ret != ROK && ret != RWOULDBLOCK)
{
DU_LOG("\nSCTP : Failed sending the message");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* End of sctpSend */
/**********************************************************************
#define MAX_RETRY 5
/* Global variable declaration */
-U8 socket_type; /* Socket type */
-Bool nonblocking; /* Blocking/Non-blocking socket */
-Bool connUp; /* Is connection up */
-Bool pollingState;
+uint8_t socket_type; /* Socket type */
+bool nonblocking; /* Blocking/Non-blocking socket */
+bool connUp; /* Is connection up */
+bool pollingState;
CmInetNetAddrLst localAddrLst;
CmInetNetAddrLst remoteAddrLst;
typedef struct
{
- S16 numFd; /* Total count number of receivers socket Fd */
- U16 port; /* Filled by the InetSctpRecvMsg during polling */
- U32 flag; /* Refers to the notifyHandler Flag during successful InetSctpRecvMsg*/
+ uint8_t numFd; /* Total count number of receivers socket Fd */
+ uint16_t port; /* Filled by the InetSctpRecvMsg during polling */
+ uint32_t flag; /* Refers to the notifyHandler Flag during successful InetSctpRecvMsg*/
Buffer *mBuf; /* Buffer filled during Socket polling*/
MsgLen bufLen; /* Determines the length of the Buffer filled during socket polling */
CmInetNetAddr addr; /* Determines the destination port filled during socket polling */
typedef struct
{
- U8 itfState; /* determines the interface State*/
- U16 destPort; /* Refers to the destination port of F1/E2 */
- U16 srcPort; /* Refers to respective src port of DU */
- U32 assocId;
- Bool recvMsgSet;
+ uint8_t itfState; /* determines the interface State*/
+ uint16_t destPort; /* Refers to the destination port of F1/E2 */
+ uint16_t srcPort; /* Refers to respective src port of DU */
+ uint32_t assocId;
+ bool recvMsgSet;
F1IpAddr destIpAddr; /* Refers to te destination Ip Address */
CmInetFd sockFd; /* Socket file descriptor */
CmInetNetAddrLst destAddrLst; /* Refers to the destinaiton Addr Lst in CmInetNetAddrLst format */
DuSctpDestCb ricParams; /* SCTP configurations at DU */
-S16 sctpActvInit(Ent entity, Inst inst, Region region, Reason reason);
-S16 sctpActvTsk(Pst *pst, Buffer *mBuf);
+uint8_t sctpActvInit(Ent entity, Inst inst, Region region, Reason reason);
+uint8_t sctpActvTsk(Pst *pst, Buffer *mBuf);
void sctpAssocReq();
void sendToDuApp(Buffer *mBuf, Event event);
-S16 sctpSend(Buffer *mBuf, U8 itfType);
-S16 duSctpCfgReq(SctpParams sctpCfg);
-S16 fillAddrLst(CmInetNetAddrLst *addrLstPtr, F1IpAddr *ipAddr);
-S16 fillDestNetAddr(CmInetNetAddr *destAddrPtr, F1IpAddr *dstIpPtr);
-S16 establishReq(DuSctpDestCb *paramPtr);
-S16 duSctpAssocReq(U8 itfType);
-S16 duFillSctpPst(Pst *pst, Event event);
-S16 sctpSetSockOpts(CmInetFd *sock_Fd);
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo, Bool recvMsgSet);
-S16 sctpSockPoll();
+uint8_t sctpSend(Buffer *mBuf, uint8_t itfType);
+uint8_t duSctpCfgReq(SctpParams sctpCfg);
+uint8_t fillAddrLst(CmInetNetAddrLst *addrLstPtr, F1IpAddr *ipAddr);
+uint8_t fillDestNetAddr(CmInetNetAddr *destAddrPtr, F1IpAddr *dstIpPtr);
+uint8_t establishReq(DuSctpDestCb *paramPtr);
+uint8_t duSctpAssocReq(uint8_t itfType);
+uint8_t duFillSctpPst(Pst *pst, Event event);
+uint8_t sctpSetSockOpts(CmInetFd *sock_Fd);
+uint8_t processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo, bool recvMsgSet);
+uint8_t sctpSockPoll();
#endif
uint8_t ret = RFAILED;
BCCH_BCH_Message_t *bcchMsg;
asn_enc_rval_t encRetVal; /* Encoder return value */
- while(1)
+ while(true)
{
DU_ALLOC(bcchMsg, sizeof(BCCH_BCH_Message_t));
if(!bcchMsg)
break;
}
xer_fprint(stdout, &asn_DEF_BCCH_BCH_Message, bcchMsg);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_BCCH_BCH_Message, 0,
bcchMsg, PrepFinalEncBuf, encBuf);
asn_enc_rval_t encRetVal; /* Encoder return value */
uint8_t ret = RFAILED;
uint8_t BuildMibret;
- while(1)
+ while(true)
{
DU_ALLOC(mibMsg, sizeof(MIB_t));
if(!mibMsg)
break;
}
xer_fprint(stdout, &asn_DEF_MIB, mibMsg);
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_MIB, 0,
mibMsg, PrepFinalEncBuf, encBuf);
xer_fprint(stdout, &asn_DEF_SIB1, sib1Msg);
/* Encode the F1SetupRequest type as APER */
- cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_SIB1, 0, sib1Msg, PrepFinalEncBuf,\
encBuf);
ret = ROK;
break;
- }while(1);
+ }while(true);
FreeSib1Msg(sib1Msg);
/* Send UL data to CU via EGTP */
duSendEgtpDatInd(mBuf);
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return ROK;
}
_ret = SGetSBuf(DU_APP_MEM_REGION, DU_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
- cmMemset((U8*)_datPtr, 0, _size); \
+ memset((uint8_t*)_datPtr, 0, _size); \
else \
_datPtr = NULLP; \
}
if(SGetStaticBuffer(DU_APP_MEM_REGION, DU_POOL, \
(Data **)&_buf, (Size) _size, 0) == ROK) \
{ \
- cmMemset((U8 *)(_buf), 0, _size); \
+ memset((uint8_t *)(_buf), 0, _size); \
} \
else \
{ \
void * mtGetWlsHdl()
{
- RETVALUE(osCp.wls.intf);
+ return (osCp.wls.intf);
}
#ifdef XEON_MULTIPLE_CELL_CHANGES
if(!osCp.wls.intf)
{
printf("Could not open WLS Interface \n");
- RETVALUE(0);
+ return (0);
}
- RETVALUE(1);
+ return (1);
}
#endif
if(smWrReadWlsConfigParams() != ROK)
{
fprintf(stderr, "Failed to read WLS params from file wr_cfg.txt");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of if statement */
#endif
#ifdef INTEL_WLS
if(!SOpenWlsIntf())
- RETVALUE(0);
+ return (0);
#endif /* INTEL_WLS */
msArgc = argc;
printf("\n SInit failed, SSI could not start \n");
/* pthread_exit(NULLP);*/ /* Commented to Come out of Main thread*/
- RETVALUE(0);
+ return (0);
}
/*mt010.301 cleanup part exposed to user*/
SFini();
- RETVALUE(0);
+ return (0);
}
#else
SInit();
- RETVALUE(0);
+ return (0);
}
#endif
if(fileBasedMemCfg == TRUE && memConfigured == FALSE)
{
printf("\n File Based Memory configuration failed \n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* initialize the started semaphore */
if (sem_init(&osCp.dep.ssStarted, 0, 0) != 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* mt028.201 added compile time flag to allow not to mask signals */
if(sigaction(SIGILL, &sa, NULL) != 0)
{
printf("Failed to process sigaction for the SIGILL\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(sigaction(SIGSEGV, &sa, NULL) != 0)
{
printf("Failed to process sigaction for the SIGSEGV\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(sigaction(SIGABRT, &sa, NULL) != 0)
{
printf("Failed to process sigaction for the SIGABRT\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(sigaction(SIGTERM, &sa, NULL) != 0)
{
printf("Failed to process sigaction for the SIGTERM\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(sigaction(SIGHUP, &sa, NULL) != 0)
{
printf("Failed to process sigaction for the SIGHUP\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#else
act.sa_flags = 0;
if (sigaction(SIGINT, &act, NULLP) != 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* mt040.201 initialise random seed */
osCp.dep.randSeed = time(NULLP);
- RETVALUE(ROK);
+ return ROK;
}
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
if(bktIdx >= globReg->numBkts)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
dynMemSetElem->nextBktPtr = NULLP;
dynMemSetElem->numFreeBlks = 0;
- RETVALUE(ROK);
+ return ROK;
}
/*
#if (ERRCLASS & ERRCLS_INT_PAR)
if(bktIdx >= globReg->numBkts)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
dynMemSetElem->numFreeBlks = bktCb->bucketSetSize;
- RETVALUE(ROK);
+ return ROK;
} /* ssGetDynMemBlkSet */
#if (ERRCLASS & ERRCLS_INT_PAR)
if(bktIdx >= globReg->numBkts)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(lstNode == NULLP)
{
SUnlock(&(bktCb->bucketLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListDelFrm(&(bktCb->listFreeBktSet), lstNode);
SUnlock(&(bktCb->bucketLock));
}
- RETVALUE(ROK);
+ return ROK;
}
/*
#if (ERRCLASS & ERRCLS_INT_PAR)
if(bktIdx >= globReg->numBkts)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
if(lstNode == NULLP)
{
SUnlock(&(bktCb->bucketLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Delete the node from the valid linked list and copy the values of the
SUnlock(&(bktCb->bucketLock));
}
- RETVALUE(ROK);
+ return ROK;
} /* ssGetDynMemBlkSet */
#if (ERRCLASS & ERRCLS_INT_PAR)
if(bktIdx >= globReg->numBkts)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
// printf ("recoverd bktCb->listValidBktSet.count %d bktIdx %d\n",bktCb->listValidBktSet.count ,bktIdx);
}
SUnlock(&(bktCb->bucketLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
SUnlock(&(bktCb->bucketLock));
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* USE_MALLOC */
/* Klock work fix ccpu00148484 */
if(!(region < SS_MAX_REGS))
{
- RETVALUE(NULLP);
+ return (NULLP);
}
dynRegCb = (CmMmDynRegCb *)osCp.dynRegionTbl[region].regCb;
- RETVALUE(dynRegCb->iccHdl);
+ return (dynRegCb->iccHdl);
}
#endif /* SS_USE_ICC_MEMORY */
}
//Store last region addr for validation
mtRegMemSz[i].startAddr = regMemStrtAddr;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_MEM_WL_DEBUG
}
#endif /* T2K_MEM_LEAK_DBG */
}
- RETVALUE(ROK);
+ return ROK;
}
PUBLIC S16 SAllocateWlsMem()
{
printf("\n ************* \n WLS memory: %lx, %d\n ****** \n", (PTR)osCp.wls.allocAddr, reqdMemSz);
#endif
SPartitionWlsMemory();
- RETVALUE(ROK);
+ return ROK;
}
PUBLIC S16 SAllocateStaticMem()
{
printf("\n ************* \n Static memory: %lx, %d\n ****** \n", (PTR)startAddr, reqdMemSz);
#endif
SPartitionStaticMemory(startAddr);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* INTEL_WLS */
dynRegCb = (CmMmDynRegCb *)calloc(1, sizeof(CmMmDynRegCb));
if(dynRegCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(k = 0; k < mtDynMemoCfg.region[i].numBkts; k++)
{
if(osCp.globRegCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
globReg = (CmMmGlobRegCb *)osCp.globRegCb;
#endif
if(globReg->bktTbl[i].startAddr == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
globReg->bktTbl[i].poolId = i;
globReg->bktTbl[i].size = mtGlobMemoCfg.bkt[i].blkSize;
dynRegCb = (CmMmDynRegCb *)calloc(1, sizeof(CmMmDynRegCb));
if(dynRegCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(k = 0; k < mtDynMemoCfg.region[i].numBkts; k++)
{
#ifdef XEON_SPECIFIC_CHANGES
free(dynRegCb);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
dynRegCb->bktTbl[k].size = mtGlobMemoCfg.bkt[k].blkSize;
dynRegCb->bktTbl[k].blkSetRelThreshold = mtDynMemoCfg.region[i].bkt[k].blkSetRelThreshold;
if (pthread_mutex_init(&(regMemLeakInfo.memLock[reg]), NULL) != 0)
{
printf("\n mutex init failed\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
free(mtCMMRegCb[k]);
free(mtCMMRegCfg[k]);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
mtCMMRegCfg[i] = (CmMmRegCfg *)calloc(1, sizeof(CmMmRegCfg));
free(mtCMMRegCfg[k]);
}
free(mtCMMRegCb[i]);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
free(mtCMMRegCb[i]);
free(mtCMMRegCfg[i]);
- RETVALUE(RFAILED);
+ return RFAILED;
}
free(mtCMMRegCfg[i]->vAddr);
free(mtCMMRegCb[i]);
free(mtCMMRegCfg[i]);
- RETVALUE(RFAILED);
+ return RFAILED;
}
free(mtCMMRegCfg[i]->vAddr);
free(mtCMMRegCb[i]);
free(mtCMMRegCfg[i]);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#endif /* SS_MEM_LEAK_STS */
- RETVALUE(ROK);
+ return ROK;
}
\f
osCp.sTskTbl[tskInd].dep.lwpId = 0;
}
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
}
\f
*/
if (pipe(osCp.dep.isFildes) != 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef L2_L3_SPLIT
/* mt020.201 - Addition for destroying thread attribute object attr */
pthread_attr_destroy(&attr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
pthread_attr_destroy(&attr);
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
sTsk = ssdAddTmrSTsk();
if(!sTsk)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTICORE_SUPPORT */
/* create the timer handler thread */
/* mt020.201 - Addition for destroying thread attribute object attr */
pthread_attr_destroy(&attr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_THR_REG_MAP
pthread_attr_destroy(&attr);
- RETVALUE(ROK);
+ return ROK;
}
\f
if ((tcgetattr(fd, &tio)) != 0)
{
printf("Error: disable canonical input processing\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
tio.c_lflag &= ~ICANON;
if ((tcsetattr(fd, TCSANOW, &tio)) != 0)
{
printf("Error: while tcsetattr() processing\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* CONSTDIO */
if (fcntl(fd, F_SETFL, flags) == -1)
{
printf("Error: while fcntl processing\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
pthread_attr_destroy(&attr);
printf("Error: Logging Thread creation failed \n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* mt020.201 - Addition for destroying thread attribute object attr */
#endif /* CONAVL */
- RETVALUE(ROK);
+ return ROK;
}
\f
ProcId procId = SS_WD_WDPROC;
if (SAddProcIdLst(1, &procId) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
if (SGetMsg(SS_DFLT_REGION, SS_DFLT_POOL, &mBuf) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef SS_MULTIPLE_PROCS
pst.srcProcId = SFndProcId();
ssdInitWatchDgPst(&pst);
SPstTsk(&pst, mBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
pst->srcEnt = ENTDW; /* source entity */
pst->srcInst = 0;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_MULTIPLE_PROCS
cmPrcTmr(&osCp.wdCp.watchDgTqCp, osCp.wdCp.watchDgTs, (PFV)ssdWatchDgTmrEvt);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
}
SUnlock(&osCp.wdCp.wdLock);
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_WATCHDOG */
UNUSED(argv);
UNUSED(opts);
- RETVALUE(EOF);
+ return (EOF);
#else
sp = 1;
/*mt013.301 : Changes as per coding standards*/
if (msOptInd >= (S16) argc || argv[msOptInd][0] == '\0')
{
- RETVALUE(EOF);
+ return (EOF);
}
else
{
if (!strcmp(argv[msOptInd], "--"))
{
msOptInd++;
- RETVALUE(EOF);
+ return (EOF);
}
else if (argv[msOptInd][0] != '-')
{
msOptInd++;
- RETVALUE('?');
+ return ('?');
}
}
}
sp = 1;
}
- RETVALUE('?');
+ return ('?');
}
if (*++cp == ':')
if (++msOptInd >= (S16) argc)
{
sp = 1;
- RETVALUE('?');
+ return ('?');
}
else msOptArg = argv[msOptInd++];
}
- RETVALUE(c);
+ return (c);
#endif /* NOCMDLINE */
}
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT001, ret, "SGetMsg() failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
mInfo = (SsMsgInfo *)mBuf->b_rptr;
MTLOGERROR(ERRCLS_DEBUG, EMT002, ret,
"Could not write to demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC0(ssdDetachTTsk);
- RETVALUE(ROK);
+ return ROK;
}
\f
#endif /* SS_MULTICORE_SUPPORT */
#endif /* SS_WATCHDOG */
{
- RETVALUE(ROK);
+ return ROK;
}
#endif
MTLOGERROR(ERRCLS_DEBUG, EMT004, ERRZERO, "Could not create thread");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_THR_REG_MAP
threadCreated = ssCheckAndAddMemoryRegionMap(sTsk->dep.tId,
MTLOGERROR(ERRCLS_DEBUG, EMT004, ERRZERO, "Could not create thread");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_THR_REG_MAP
threadCreated = ssCheckAndAddMemoryRegionMap(sTsk->dep.tId,
/* mt020.201 - Addition for destroying thread attribute object attr */
pthread_attr_destroy(&attr);
- RETVALUE(ROK);
+ return ROK;
}
/* Klock work fix ccpu00148484 */
if(threadArg == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
threadArg->argument = arg;
threadArg->start_routine = start_routine;
if (((retVal = pthread_create(tid, attr, pthreadCreateHdlr, threadArg))) != 0)
{
- RETVALUE(retVal);
+ return (retVal);
}
#ifdef SS_THR_REG_MAP
threadCreated = ssCheckAndAddMemoryRegionMap(*tid, SS_MAX_REGS - 1);
#endif
}
- RETVALUE(retVal);
+ return (retVal);
}
#endif
pthread_attr_setschedparam(attr, ¶m);
- RETVALUE (ROK);
+ return (ROK);
} /* ssdSetPthreadAttr */
if (tskInd == SS_MAX_STSKS)
{
MTLOGERROR(ERRCLS_DEBUG, EMT036, ERRZERO, "Invalid system task Id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT037, ERRZERO, "Could not get thread affinity\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if pthread_setaffinity fails */
for (cpuInd = 0; cpuInd <CPU_SETSIZE; cpuInd++)
if (tskInd == SS_MAX_STSKS)
{
MTLOGERROR(ERRCLS_DEBUG, EMT036, ERRZERO, "Invalid system task Id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set thread affinity for Solaris */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT037, ERRZERO, "Could not get thread affinity\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if processor_bind fails */
#endif /* SUNOS */
#endif /* SS_LINUX */
- RETVALUE(ROK);
+ return ROK;
} /* ssdGetAffinity */
if (tskInd == SS_MAX_STSKS)
{
MTLOGERROR(ERRCLS_DEBUG, EMT036, ERRZERO, "Invalid system task Id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* initialize the cpu mask */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT038, ERRZERO, "Could not set thread affinity\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if pthread_setaffinity fails */
#else
if (tskInd == SS_MAX_STSKS)
{
MTLOGERROR(ERRCLS_DEBUG, EMT036, ERRZERO, "Invalid system task Id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set thread affinity for Solaris */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT038, ERRZERO, "Could not set thread affinity\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if processor_bind fails */
#endif /* SUNOS */
#endif /* SS_LINUX */
- RETVALUE(ROK);
+ return ROK;
} /* ssdSetAffinity */
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
MTLOGERROR(ERRCLS_DEBUG, EMT005, ERRZERO, "Could not get a message");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
mInfo = (SsMsgInfo *)mBuf->b_rptr;
"Could not write to demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/* mt023.201 - Added SThreadYield function to yield CPU
tw.tv_sec=0;
tw.tv_usec=0;
- RETVALUE(select(0,0,0,0,&tw) == 0 ? ROK : RFAILED);
+ return (select(0,0,0,0,&tw) == 0 ? ROK : RFAILED);
}
#else /* other UNICes */
- RETVALUE(sleep(0) == 0 ? ROK : RFAILED);
+ return (sleep(0) == 0 ? ROK : RFAILED);
#endif /* SS_LINUX */
cmPlcCbTq(&arg);
- RETVALUE(ROK);
+ return ROK;
}
\f
cmRmvCbTq(&arg);
- RETVALUE(ROK);
+ return ROK;
}
\f
/* won't reach here */
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC0(ssdRegDrvrTsk);
- RETVALUE(ROK);
+ return ROK;
}
/* mt001.30 : Additions */
/*
TRC0(ssdDeregDrvrTsk);
- RETVALUE(ROK);
+ return ROK;
}
#endif
if (ret != ROK)
{
MTLOGERROR(ERRCLS_DEBUG, EMTXXX, ERRZERO, "Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
if (ret != ROK)
{
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMTXXX, ERRZERO, "Could not Unlock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MULTIPLE_PROCS
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMTXXX, ERRZERO, "Could not Unlock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
//#ifndef SPLIT_RLC_DL_TASK
* (processes L1 msgs) */
}
- RETVALUE(NULLP);
+ return (NULLP);
}
#else
EXTERN Void ysMtTskHdlr(Void);
#endif
}
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif /* TENB_T2K3K_SPECIFIC_CHANGES */
#endif
continue;
pthreadCreateArg->start_routine(pthreadCreateArg->argument);
- RETVALUE(ROK);
+ return ROK;
}
\f
/*
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
\f
if (ret != ROK)
{
/* nothing to receive */
- RETVALUE(ROK);
+ return ROK;
}
/* if we can't lock this system task entry, return the message */
"Could not lock system task entry");
#endif
SPutMsg(mBuf);
- RETVALUE(ROK);
+ return ROK;
}
/* mt034.201 */
"Could not lock system task table");
#endif
/* what to do here? */
- RETVALUE(ROK);
+ return ROK;
}
/* clean up the system task entry */
/* unlock the system task table */
SUnlock(&osCp.sTskTblLock);
- RETVALUE(RFAILED);
+ return RFAILED;
/* this is a data message or a permanent task keep-alive message */
SThreadYield();
#endif
- RETVALUE(ROK);
+ return ROK;
}
Bool g_usettitmr;
}
/* mt009.21: addition */
- RETVALUE( (Void *) NULLP);
+ return ( (Void *) NULLP);
/* will not reach here */
}
if (osCp.dep.conInFp == NULLP)
{
/* die */
- RETVALUE(NULLP);
+ return (NULLP);
}
fd = fileno(osCp.dep.conInFp);
}
}
/* mt009.21: addition */
- RETVALUE( (Void *) NULLP);
+ return ( (Void *) NULLP);
/* not reached */
}
if (buf == NULLP)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT022, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifndef XEON_SPECIFIC_CHANGES
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
ssMemlog(buf, strlen(buf));
- RETVALUE(ROK);
+ return ROK;
#endif
#endif
#endif
#endif
- RETVALUE(ROK);
+ return ROK;
}
/*mt010.301 */
#endif
pthread_exit(NULLP);
- RETVALUE(0);
+ return (0);
}
\f
/*
UNUSED(dt);
- RETVALUE(ROK);
+ return ROK;
}
\f
if (dt == NULLP)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT023, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#endif
#endif /*-- SS_DATETIME_USEC --*/
- RETVALUE(ROK);
+ return ROK;
}
/*
#if (ERRCLASS & ERRCLS_INT_PAR)
if (et == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*et = now;
- RETVALUE(ROK);
+ return ROK;
}
if (sysTime == NULLP)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT024, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*sysTime = osCp.dep.sysTicks;
- RETVALUE(ROK);
+ return ROK;
}
/* mt021.201 - Addition of SGetRefTime function */
if (sec == NULLP || usec == NULLP)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT025, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* mt022.201 - Modification to fix compile warning */
if (refTime > (U32)(ptime.tv_sec))
{
MTLOGERROR(ERRCLS_INT_PAR, EMT026, ERRZERO, "Reference time exceeds present time");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*usec = ptime.tv_usec;
#endif
- RETVALUE(ROK);
+ return ROK;
}
{
/* mt011.21: addition */
MTLOGERROR(ERRCLS_INT_PAR, EMT028, (ErrVal)0 , "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*value = (Random) rand_r(&osCp.dep.randSeed);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC1(SExitTsk);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC1(SExitInt);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC1(SHoldInt);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC1(SRelInt);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC1(SEnbInt);
- RETVALUE(ROK);
+ return ROK;
}
\f
TRC1(SDisInt);
- RETVALUE(ROK);
+ return ROK;
}
\f
UNUSED(vectFnct);
- RETVALUE(ROK);
+ return ROK;
}
\f
UNUSED(vectFnct);
- RETVALUE(ROK);
+ return ROK;
}
/* mt028.201: modification: multiple procs support related changes */
if (ent == NULLP || inst == NULLP)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT029, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
ret = SLock(&osCp.sTskTblLock);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i = 0; i < SS_MAX_STSKS; i++)
{
SUnlock(&osCp.sTskTblLock);
- RETVALUE(ret == ROK ? ROK : RFAILED);
+ return (ret == ROK ? ROK : RFAILED);
}
\f
if (ent >= ENTNC || inst >= INSTNC)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT030, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
ret = SLock(&osCp.sTskTblLock);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i = 0; i < SS_MAX_STSKS; i++)
{
SUnlock(&osCp.sTskTblLock);
- RETVALUE(ret == ROK ? ROK : RFAILED);
+ return (ret == ROK ? ROK : RFAILED);
}
#endif /* SS_MULTIPLE_PROCS */
if (id >= SS_MAX_DRVRTSKS || osCp.drvrTskTbl[id].used == FALSE)
{
MTLOGERROR(ERRCLS_INT_PAR, EMT031, id, "Invalid instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (write(osCp.dep.isFildes[1], &isFlag, sizeof(isFlag)) != sizeof(isFlag))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_DRVR_SUPPORT */
sprintf(prntBuf, "--------------------------------------------------------------\n");
SDisplay(0, prntBuf);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_LOCKLESS_MEMORY */
pool,
mtCMMRegCb[reg]->bktTbl[pool].numAlloc,
mtCMMRegCb[reg]->bktTbl[pool].numBlks);
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
*/
if (region > (SS_MAX_REGS-1) )
{
MTLOGERROR(ERRCLS_INT_PAR, EMT032, ERRZERO, "Invalid Region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SDisplay(0, prntBuf);
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef XEON_SPECIFIC_CHANGES
#define SSI_MAX_BKT_THRESHOLD 6
memStatus = 2;
}
}
- RETVALUE(memStatus);
+ return (memStatus);
}
#endif
/* mt033.201 - addition of API to return the memory statistical data */
if (region >= mtMemoCfg.numRegions )
{
MTLOGERROR(ERRCLS_INT_PAR, EMT033, ERRZERO, "Invalid Region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
dbgInfo->numFragBlk = mtCMMRegCb[region]->heapCb.numFragBlk;
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
/* Send number of Pools available */
*numPool = cfgRegInfo[0].numPools;
- RETVALUE(ROK);
+ return ROK;
}
/* mt033.201 - addition of APIs to print the memory statistical data
if (region >= mtMemoCfg.numRegions )
{
MTLOGERROR(ERRCLS_INT_PAR, EMT034, ERRZERO, "Invalid Region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
else if (typeFlag == SS_MEM_BLK_SIZE_PROFILE)
{
/* Bucket Memory allocation Statistics */
- RETVALUE(SPrintRegMemStats(region));
+ return (SPrintRegMemStats(region));
}
else
{
SDisplay(0, prntBuf);
}
- RETVALUE(ROK);
+ return ROK;
}
/*
sprintf(prntBuf, "\n");
SDisplay(0, prntBuf);
- RETVALUE(ROK);
+ return ROK;
}
/*
if (region >= mtMemoCfg.numRegions )
{
MTLOGERROR(ERRCLS_INT_PAR, EMT035, ERRZERO, "Invalid Region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
* we cannot rely on this size. So it is better to stop here unless there
* exists any other mechanism(?) to know the offset to next block.
*/
- RETVALUE(ROK);
+ return ROK;
}
/*mt009.301 Fixed 64BIT compilation warnings*/
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SSI_DEBUG_LEVEL1 */
sprintf(ts, "%s.%03ld", time_string, microseconds);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/*-- mt037.201 : Added new API for SGetSystemTsk --*/
{
TRC1(SGetSystemTskS);
- RETVALUE(pthread_self());
+ return (pthread_self());
} /* end of SGetSystemTsk */
"Could not lock system task table");
#endif
- RETVALUE(sTsk);
+ return (sTsk);
}
/* check count of system tasks */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT040, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(sTsk);
+ return (sTsk);
#endif
}
MTLOGERROR(ERRCLS_ADD_RES, EMT041, ERRZERO, "Too many system tasks");
#endif
- RETVALUE(sTsk);
+ return (sTsk);
}
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT042, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
"Could not initialize demand queue");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
/* initialize the system task entry lock */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT044, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
"Could not initialize system task entry lock");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT046, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
- RETVALUE(sTsk);
+ return (sTsk);
}
#endif /* SS_MULTICORE_SUPPORT */
/* mt003.301 Readwrite lock and recursive mutex additions */
{
sprintf(prntBuf, "\n\n ssdInitLockNew(): Initialization of read write lock failed,Error# retVal %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf,"\n ssdInitLockNew(): mutexattr init failed,Error# %d \n",retVal);
SPrint(prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_LINUX
retVal = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
sprintf(prntBuf,"\n ssdInitLockNew(): mutexattr settype failed,Error# %d \n",retVal);
pthread_mutexattr_destroy(&attr);
SPrint(prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
retVal = pthread_mutex_init((pthread_mutex_t *)&(lockId->l.recurLock), &attr);
if(retVal != 0)
sprintf(prntBuf,"\n ssdInitLockNew(): mutex init failed,Error# %d \n",retVal);
pthread_mutexattr_destroy(&attr);
SPrint(prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdInitLockNew(): Invalid lock type %d\n", lockType);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
*
{
sprintf(prntBuf, "\n\n ssdLockNew(): Failed to aquire the read lock,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdLockNew(): Failed to aquire the write lock,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdLockNew(): Failed to aquire the read lock,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdLockNew(): Failed to aquire the read lock,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdLockNew(): Failed to aquire the recursive mutex,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdLockNew(): Invalid lock type %d\n", lockType);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
{
sprintf(prntBuf, "\n\n ssdUnLockNew(): Failed to unlock the lock,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdUnLockNew(): Failed to aquire the recursive mutex,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdUnlockNew(): Invalid lock type %d\n", lockType);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/*
{
sprintf(prntBuf, "\n\n ssdDestroyLockNew(): Failed to destroy the lock,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdDestroyLockNew(): Failed to destroy the mutex,Error# %d\n", retVal);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
break;
}
{
sprintf(prntBuf, "\n\n ssdDestroyLockNew(): Invalid lock type %d\n", lockType);
SDisplay(0, prntBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_LOCK_SUPPORT */
{
pthread_attr_destroy(&attr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
pthread_attr_destroy(&attr);
- RETVALUE(ROK);
+ return ROK;
}/* ssInitRcvWork */
exit(1);
}
createdThreadIds[createdThreads++] = threadId;
- RETVALUE(FALSE);
+ return (FALSE);
}
/* If we found free mapping table entry, place the region and send pthread_cancel
* for all the thread Ids which are created before this
}
createdThreads = 0;
- RETVALUE(TRUE);
+ return (TRUE);
} /* ssCheckAndAddMemoryRegionMap */
#else
printf("Invalid Thread ID (%d)\n", (U32)threadId);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* If we found free mapping table entry, place the region and send pthread_cancel
* for all the thread Ids which are created before this
*/
osCp.threadMemoryRegionMap[((threadId >> SS_MEM_THREAD_ID_SHIFT) % SS_MAX_THREAD_REGION_MAP)] = SS_INVALID_THREAD_REG_MAP;
- RETVALUE(ROK);
+ return ROK;
} /* ssCheckAndAddMemoryRegionMap */
#ifdef MSPD_MLOG_NEW
*startTime = GetTIMETICK();
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
/*
#endif
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#else
#ifdef ANSI
#endif
{
*startTime = 0;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
U32 taskId;
#endif
{
- RETVALUE(ROK);
+ return ROK;
}
#endif /*#ifdef SS_TSKLOG_ENABLE */
"Could not lock system task table");
#endif
- RETVALUE(sTsk);
+ return (sTsk);
}
/* initialize the system task entry with the information we have */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT042, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
"Could not initialize demand queue");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
/* initialize the system task entry lock */
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT044, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
"Could not initialize system task entry lock");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
#if (ERRCLASS & ERRCLS_DEBUG)
MTLOGERROR(ERRCLS_DEBUG, EMT046, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
- RETVALUE(sTsk);
+ return (sTsk);
}
#endif /* SS_MULTICORE_SUPPORT */
MTLOGERROR(ERRCLS_DEBUG, EMT046, ERRZERO,
"Could not give the Semaphore");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
sTsk = ssdReAddTmrSTsk(0);
if(!sTsk)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTICORE_SUPPORT */
/* create the timer handler thread */
/* mt020.201 - Addition for destroying thread attribute object attr */
pthread_attr_destroy(&attr);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_THR_REG_MAP
/* mt020.201 - Addition for destroying thread attribute object attr */
pthread_attr_destroy(&attr);
sem_post(&osCp.dep.ssStarted);
- RETVALUE(ROK);
+ return ROK;
}
/**********************************************************************
if (SGetProcIdLst(&count, procIdLst) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS001, ERRZERO, "Null procId list");
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (i = 0; i < count; i++)
if (procIdLst[i] >= low && procIdLst[i] <= high)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS002, ERRZERO, "Invalid procId range");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#else /* SS_MULTIPLE_PROCS */
if (thisProcId >= low && thisProcId <= high)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS003, ERRZERO, "Invalid procId range");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
if (channel >= SS_MAX_DRVRTSKS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS004, channel, "Invalid channel");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check activation functions */
if (actvTsk == NULLP || isTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS005, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check if already registered */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS006, ERRZERO,
"Driver task already registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (osCp.numDrvrTsks == SS_MAX_DRVRTSKS)
{
SSLOGERROR(ERRCLS_DEBUG, ESS007, ERRZERO, "Too many tasks");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS008, ERRZERO, "Could not initialize lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
osCp.drvrTskTbl[channel].channel = channel;
}
- RETVALUE(ret);
+ return (ret);
}
/* ss001.301: Additions */
if (channel >= SS_MAX_DRVRTSKS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, channel, "Invalid channel");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check if already registered */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS477, ERRZERO,
"Driver task is not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS477, ERRZERO,
"Could not lock driver task lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
ssdDeregDrvrTsk(&osCp.drvrTskTbl[channel]);
SSLOGERROR(ERRCLS_DEBUG, ESS477, ERRZERO,
"Could not unlock driver task lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SDestroyLock(&osCp.drvrTskTbl[channel].lock);
/* ss002.301 Modifications */
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_DRVR_SUPPORT */
/**********************************************************************
sprintf(prntBufLoc,"\n SInit(): ssdInitGen failed to initialize\
implementation specific general information \n");
SDisplay(1,prntBufLoc);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
ssdStart();
- RETVALUE(ROK);
+ return ROK;
/* clean up code */
ssdDeinitGen();
- RETVALUE(RFAILED);
+ return RFAILED;
}
\f
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS014, ERRZERO,
"Could not destroy the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS015, ERRZERO,
"Could not destroy the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SDestroyLock(&(osCp.logger.bufLock));
#endif /* SS_LOGGER_SUPPORT */
ssdDeinitLog();
- RETVALUE(ROK);
+ return ROK;
}
/* ss001.301: additions */
if(osCp.logger.started == FALSE)
{
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
}
/*
* Append the buffer to the global buffer
osCp.logger.curBufSiz += bufSz;
}
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_LOGGER_SUPPORT */
/*
SWrtLogBuf(buf);
#endif /* SS_LOGGER_SUPPORT */
- RETVALUE(ROK);
+ return ROK;
} /* end of SPrint */
ret = ssdError(seq, reason);
- RETVALUE(ret);
+ return (ret);
}
\f
{
TRC1(SFndProcId);
- RETVALUE(osCp.procId);
+ return (osCp.procId);
} /* end of SFndProcId */
\f
if (osCp.procLst.procId[i] == proc)
return i;
- RETVALUE(SS_INV_PROCID_IDX);
+ return (SS_INV_PROCID_IDX);
} /* SGetProcIdIdx */
\f
{
osCp.procLst.procId[i] = proc;
osCp.procLst.free--;
- RETVALUE(ROK);
+ return ROK;
}
/* search for free entry upto idx */
{
osCp.procLst.procId[i] = proc;
osCp.procLst.free--;
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* SInsProcId */
\f
{
osCp.procLst.procId[i] = SS_INV_PROCID;
osCp.procLst.free++;
- RETVALUE(ROK);
+ return ROK;
}
/* search upto idx */
{
osCp.procLst.procId[i] = SS_INV_PROCID;
osCp.procLst.free++;
- RETVALUE(ROK);
+ return ROK;
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* SRemProcId */
\f
{
SSLOGERROR(ERRCLS_DEBUG, ESS016, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS018, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SLockOsCp */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS019, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SULockOsCp */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS020, ERRZERO, "number of proc Ids exceeds\
limit");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* find if the entry exist in the table */
if (pIdLst[i] == SS_INV_PROCID)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS021, ERRZERO, "Invalid proc Ids");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if (SLockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
#if (ERRCLASS & ERRCLS_INT_PAR)
for (i = 0; i < numPIds; i++)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS022, ERRZERO, "Duplicate proc id");
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (numPIds > osCp.procLst.free)
SSLOGERROR(ERRCLS_INT_PAR, ESS023, ERRZERO, "Total number of proc id \
exceeds");
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not insert the proc id");
#endif
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* unlock the table */
if (SULockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ret);
+ return (ret);
} /* SAddProcIdLst */
\f
#if (ERRCLASS & ERRCLS_INT_PAR)
/* range check */
if (numPIds > SS_MAX_PROCS)
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
if (SLockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (numPIds > (SS_MAX_PROCS - osCp.procLst.free))
{
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* find if the entry exist in the table */
if (SGetProcIdIdx(pIdLst[i]) == SS_INV_PROCID_IDX)
{
(Void) SULockOsCp();
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SRemProcId(pIdLst[i]);
if (SULockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
} /* SRemProcIdLst */
\f
if ((numPIds == NULLP) || (pIdLst == NULLP))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS025, ERRZERO, "Invalid numPIds/pIdLst");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (SLockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
for (i = 0; i < SS_MAX_PROCS; i++)
{
*numPIds = count;
if (SULockOsCp() != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
if (count == 0)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
} /* SGetProcIdLst */
\f
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS026, ERRZERO, "Invalid proc/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
SSLOGERROR(ERRCLS_INT_PAR, ESS027, ERRZERO, "Could not get proc table idx");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = osCp.tTskIds[procIdIdx][ent][inst];
if (idx == SS_TSKNC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* update the CB */
*xxCb = osCp.tTskTbl[idx].xxCb;
/*ss032.103 added a check for NULLP */
if (*xxCb == NULLP)
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
} /* SGetXxCb */
#endif /* SS_MULTIPLE_PROCS */
TRC2(SFillEntIds)
memcpy((U8*)osCp.entId, (U8*)entInfo, sizeof(entInfo));
- RETVALUE(ROK);
+ return ROK;
} /* SFillEntIds */
if (letter[1] == 'g' && letter[2] == 'u')
{
*entId = ENTGT;
- RETVALUE(ROK);
+ return ROK;
}
default:
break;
if(letter[count] < 'a' || letter[count] > 'z')
{
*entId = ENTNC;
- RETVALUE(ROK);
+ return ROK;
}
else
{
/* First two letter of file name are alphabets the get the
* entity id from the static data base which is loaded in sFillEntIds() */
*entId = osCp.entId[firstIdx][secondIdx];
- RETVALUE(ROK);
+ return ROK;
} /* SGetEntInd */
#endif /* SS_HISTOGRAM_SUPPORT */
if((retVal = ssdLockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SLockNew(): Failed to aquire the lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if((retVal = ssdInitLockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SInitLockNew(): Initialization of lock Failed\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if((retVal = ssdUnlockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SUnlockNew(): Failed to release the lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if((retVal = ssdDestroyLockNew(lockId, lockType)) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SDestroyLockNew(): Failed to destroy the lock\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_LOCK_SUPPORT */
{
/*ss012.301 : Fix log related issue to suite MT and NS implementations*/
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SReInitTmr(): Failed to Restart the Tmr\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
{\
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ERRZERO,\
"Could not unlock the Semaphore");\
- RETVALUE(RFAILED);\
+ return RFAILED;\
}\
}\
}
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS028, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate region info pointer */
if (regInfo == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS029, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
SSLOGERROR(ERRCLS_INT_PAR, ESS031, ERRZERO, "Region ID used");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
- RETVALUE(ROK);
+ return ROK;
}
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS028, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate region info pointer */
if (regInfo == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS029, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
SSLOGERROR(ERRCLS_INT_PAR, ESS031, ERRZERO, "Region ID used");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
- RETVALUE(ROK);
+ return ROK;
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS032, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
{
SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
SSLOGERROR(ERRCLS_INT_PAR, ESS034, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SS_RELEASE_ALL_SEMA(&osCp.regionTblSem);
- RETVALUE(ROK);
+ return ROK;
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS035, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifndef XEON_SPECIFIC_CHANGES
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS037, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS038, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss001.301: Additions */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS039, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
}
#endif /* SSI_DEBUG_LEVEL1 */
- RETVALUE(ret);
+ return (ret);
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS040, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to validate size and ptr */
if (size <= NULLD)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS041, region, "Invalid size");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate ptr */
if (ptr == (Data *)NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS042, region, "Invalid ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS044, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS045, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS046, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
}
#endif /* SSI_DEBUG_LEVEL1 */
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_FAP */
}/* End of for. Region Count */
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_HISTOGRAM_SUPPORT */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS047, ERRZERO, "ssGetDBufOfSize : Null\
Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS048, ERRZERO, "ssGetDBufOfSize : Invalid\
region id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (size <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS049, ERRZERO, "ssGetDBufOfSize : Invalid\
size");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (SAlloc(region, &mdsize, 0, (Data **) dBuf) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
data = (Data *) (*dBuf) + MDBSIZE;
size = mdsize - MDBSIZE;
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* ssGetDBufOfSize */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS050, ERRZERO, "SGetMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS051, ERRZERO, "SGetMsg : Invalid region\
id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS052, ERRZERO, "SGetMsg : Invalid pool id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss037.103 Removed the semaphore operation for performance enhancement */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS054, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS055, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss037.103 Removed the semaphore operation for performance enhancement */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS056, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
#endif /* SS_HISTOGRAM_SUPPORT */
{
SSLOGERROR(ERRCLS_DEBUG, ESS058, ERRZERO, "SGetMsg:Failed in SAlloc");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#else /* SS_M_PROTO_REGION */
/* ss001.301: additions */
#endif /* SS_HISTOGRAM_SUPPORT */
{
SSLOGERROR(ERRCLS_DEBUG, ESS059, ERRZERO, "SGetMsg:Failed in SAlloc");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#endif /* SS_M_PROTO_REGION */
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef RGL_SPECIFIC_CHANGES
minfo = (SsMsgInfo*) mBuf->b_rptr;
minfo->pool = pool;
- RETVALUE(ROK);
+ return ROK;
}
#endif
}
if (mBuf->refCnt > 0)
{
- RETVALUE(ROK);
+ return ROK;
}
}
#endif
{
if(ROK == mtAddBufToRing(SS_RNG_BUF_MAC_FREE_RING,(Void *)mBuf,0))
{
- RETVALUE(ROK);
+ return ROK;
}
}
#endif
{
if(ROK == mtAddBufToRing(SS_RNG_BUF_RLC_FREE_RING,(Void *)mBuf,0))
{
- RETVALUE(ROK);
+ return ROK;
}
}
#endif
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS060, ERRZERO, "SPutMsg: Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS061, ERRZERO, "SPutMsg: Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if(tmpThrReg == 0xFF)
{
printf("\n Not able to get region \n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (SFree(minfo->region, (Data *) mBuf, MSGSIZE) == RFAILED)
#endif
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(RFAILED);
+ return RFAILED;
#else /* SS_M_PROTO_REGION */
/* ss021.103 - Addition to check return value of SFree */
#ifdef SS_HISTOGRAM_SUPPORT
#else
if (SFree(minfo->region, (Data *) mBuf, MSGSIZE) == RFAILED)
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(RFAILED);
+ return RFAILED;
#endif /* SS_M_PROTO_REGION */
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_LOCKLESS_MEMORY
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS220, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate pool ID */
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS221, pool, "Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate data pointer */
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS223, (ErrVal)0, "NULL data pointe");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate size */
if (size <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS224, size, "Invalid size");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
{
if(ROK == mtAddBufToRing(SS_RNG_BUF_MAC_FREE_RING,(Void *)ptr,1))
{
- RETVALUE(ROK);
+ return ROK;
}
}
#endif
{
if(ROK == mtAddBufToRing(SS_RNG_BUF_RLC_FREE_RING,(Void *)ptr,1))
{
- RETVALUE(ROK);
+ return ROK;
}
}
}
(osCp.dynRegionTbl[region].used == FALSE)))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS218, region, "Region not registered");
- RETVALUE(ret);
+ return (ret);
}
#endif
}
#endif
- RETVALUE(ret);
+ return (ret);
}
/*
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS211, region, "Invalid region");
- RETVALUE(ret);
+ return (ret);
}
/* validate pool ID */
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS212, pool, "Invalid pool");
- RETVALUE(ret);
+ return (ret);
}
/* validate data pointer */
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS214, (ErrVal)0 , "NULL data pointer");
- RETVALUE(ret);
+ return (ret);
}
/* validate size */
if (size <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS215, size, "Invalid size");
- RETVALUE(ret);
+ return (ret);
}
#endif
(osCp.dynRegionTbl[region].used == FALSE)))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS218, region, "Region not registered");
- RETVALUE(ret);
+ return (ret);
}
#endif
}
#endif
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_LOCKLESS_MEMORY */
ret = SGetSBuf(region, pool, ptr, size);
- RETVALUE(ret);
+ return (ret);
}
ret = SPutSBuf(region, pool, ptr, size);
- RETVALUE(ret);
+ return (ret);
}
#endif
#endif
#endif
- RETVALUE(ret);
+ return (ret);
}
#ifdef T2K_MEM_LEAK_DBG
#endif
#endif
- RETVALUE(ret);
+ return (ret);
}
#endif /* INTEL_WLS */
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS211, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate pool ID */
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS212, pool, "Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss008.13: addition */
/* validate data pointer */
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS214, (ErrVal)0 , "NULL data pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate size */
if (size <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS215, size, "Invalid size");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss037.103 Removed the semaphore operation for performance enhancement */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS217, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS218, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS219, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
}
#endif /* SSI_DEBUG_LEVEL1 */
- RETVALUE(ret);
+ return (ret);
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS220, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate pool ID */
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS221, pool, "Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss008.13: addition */
/* validate data pointer */
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS223, (ErrVal)0, "NULL data pointe");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate size */
if (size <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS224, size, "Invalid size");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss037.103 Removed the semaphore operation for performance enhancement */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS226, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS227, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS228, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
}
#endif /* SSI_DEBUG_LEVEL1 */
- RETVALUE(ret);
+ return (ret);
}
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS062, ERRZERO, "SInitMsg: Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS063, ERRZERO, "SInitMsg: Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
CM_MEM_GET_REGION(tmpRegId);
if(tmpRegId == 0xFF)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
minfo = (SsMsgInfo*) mBuf->b_rptr;
minfo->endptr = NULLP;
minfo->next = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/* ss016.301 - Added a new API - SAddPreMsgMultInOrder. This preserves the
{
SSLOGERROR(ERRCLS_INT_PAR, ESS070, ERRZERO, "SAddPreMsgMultInOrder:\
Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check source */
if (src == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS071, ERRZERO, "SAddPreMsgMultInOrder:\
Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check count */
if (cnt <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS072, ERRZERO, "SAddPreMsgMultInOrder:\
Invalid count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS073, ERRZERO, "SAddPreMsgMultInOrder:\
Incorrect buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (!cnt)
{
minfo->len += len;
- RETVALUE(ROK);
+ return ROK;
}
}
newblk = prevblk = NULLP;
tmp->b_rptr = tmp->b_datap->db_base + offset;
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* attach curblk in the newblk chain */
if (prevblk)
/* update length of message */
minfo->len += len;
- RETVALUE(ROK);
+ return ROK;
}
/*
*
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS064, ERRZERO, "SAddPreMsg: Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS065, ERRZERO, "SAddPreMsg: Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (minfo->len == 0x7FFF)
#endif
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/*
{
SSLOGERROR(ERRCLS_DEBUG, ESS066, ERRZERO, "SAddPreMsg:Failed in\
SGetDBuf");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* set the read and write pointers to end of data buffer */
/* subsequent prepends have all the buffer to insert data into */
*--tmp->b_rptr = data;
minfo->len++;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS067, ERRZERO, "SAddPstMsg: Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS068, ERRZERO, "SAddPstMsg: Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS069, ERRZERO, "SAddPstMsg: Failed in\
SGetDBuf()");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* append newb to the end of the mBuf chain */
*tmp->b_wptr++ = data;
minfo->len++;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS070, ERRZERO, "SAddPreMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check source */
if (src == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS071, ERRZERO, "SAddPreMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check count */
if (cnt <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS072, ERRZERO, "SAddPreMsgMult: Invalid\
count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS073, ERRZERO, "SAddPreMsgMult: Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (!cnt)
{
minfo->len += len;
- RETVALUE(ROK);
+ return ROK;
}
}
newblk = prevblk = NULLP;
tmp->b_rptr = tmp->b_datap->db_base + offset;
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* attach curblk in the newblk chain */
if (prevblk)
/* update length of message */
minfo->len += len;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS074, ERRZERO, "SAddPstMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check source */
if (src == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS075, ERRZERO, "SAddPstMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check count */
if (cnt <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS076, ERRZERO, "SAddPstMsgMult:Invalid\
count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS077, ERRZERO, "SAddPstMsgMult: Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (!cnt)
{
minfo->len += len;
- RETVALUE(ROK);
+ return ROK;
}
}
tmp->b_wptr = tmp->b_datap->db_lim - offset;
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* insert curblk in the newblk chain */
/* update length */
minfo->len += len;
- RETVALUE(ROK);
+ return ROK;
}
/* #ifdef SS_LOCKLESS_MEMORY */
if (!dataPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS078, ERRZERO, "SRemPreMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS079, ERRZERO, "SRemPreMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS080, ERRZERO, "SRemPreMsg : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (!(tmp = mBuf->b_cont))
- RETVALUE(ROKDNA);
+ return (ROKDNA);
/* get SsMsgInfo of mBuf */
minfo = (SsMsgInfo *) mBuf->b_rptr;
if (!--minfo->len)
minfo->endptr = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (dataPtr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS081, ERRZERO, "SRemPstMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer */
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS082, ERRZERO, "SRemPstMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS083, ERRZERO, "SRemPstMsg : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
minfo = (SsMsgInfo*) mBuf->b_rptr;
if (!(last = minfo->endptr))
- RETVALUE(ROKDNA);
+ return (ROKDNA);
/* read databyte into dataPtr and decrement write ptr */
*dataPtr = *--last->b_wptr;
/* update SsMsgInfo */
minfo->len--;
- RETVALUE(ROK);
+ return ROK;
}
{
SSLOGERROR(ERRCLS_INT_PAR, ESS084, ERRZERO, "SRemPreMsgMult:Invalid\
count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS085, ERRZERO, "SRemPreMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to check for NULL pointer */
/* check data pointer */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS086, ERRZERO, "SRemPreMsgMult : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* check if data present */
if (minfo->len < cnt)
- RETVALUE(ROKDNA);
+ return (ROKDNA);
else
minfo->len -= cnt;
if (!minfo->len)
minfo->endptr = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/*
{
SSLOGERROR(ERRCLS_INT_PAR, ESS087, ERRZERO, "SRemPstMsgMult:Invalid\
count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer */
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS088, ERRZERO, "SRemPstMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS089, ERRZERO, "SRemPstMsgMult : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to check dst data pointer */
/* check data pointer */
/* check if data present */
if (minfo->len < cnt)
- RETVALUE(ROKDNA);
+ return (ROKDNA);
else
{
minfo->len -= cnt;
else
minfo->endptr = prev;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!dataPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS090, ERRZERO, "SExamMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS091, ERRZERO, "SExamMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check index */
if (idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS092, ERRZERO, "SExamMsg : Invalid Index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS093, ERRZERO, "SExamMsg : Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (minfo->len <= idx)
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* get the first SS_M_DATA blk */
*dataPtr = *(tmp->b_rptr + idx);
- RETVALUE(ROK);
+ return ROK;
}
if (!dataPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS090, ERRZERO, "SGetDataFrmMsg: Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS091, ERRZERO, "SGetDataFrmMsg: Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check index */
if (idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS092, ERRZERO, "SGetDataFrmMsg: Invalid Index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS093, ERRZERO, "SGetDataFrmMsg: Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (minfo->len <= (idx + dataLen) )
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* get the first SS_M_DATA blk */
/* determine offset */
if(tmp == NULLP)
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
else
{
}
if( tmp == NULLP )
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
SMemCpy((Void *)tmpDataPtr, (Void *)(tmp->b_rptr + idx), (size_t)dataLen);
}
- RETVALUE(ROK);
+ return ROK;
} /* End of SGetDataFrmMsg() */
/*
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS094, ERRZERO, "SFndLenMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check length pointer */
if (lngPtr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS095, ERRZERO, "SFndLenMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS096, ERRZERO, "SFndLenMsg : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* read length */
*lngPtr = minfo->len;
- RETVALUE(ROK);
+ return ROK;
}
if (mBuf1 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS097, ERRZERO, "SSegMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer 2 */
if (mBuf2 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS098, ERRZERO, "SSegMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS099, ERRZERO, "SSegMsg : Invalid index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf1->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS100, ERRZERO, "SSegMsg : Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (idx >= minfo1->len)
{
*mBuf2 = NULLP;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* allocate message buffer */
if (SGetMsg(minfo1->region, minfo1->pool, mBuf2) != ROK)
{
SSLOGERROR(ERRCLS_DEBUG, ESS101, ERRZERO, "SSegMsg : SGetMsg failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* get the SsMsgInfo of mBuf2 */
minfo1->endptr = NULLP;
mBuf1->b_cont = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/* get the first SS_M_DATA blk */
/* reset length */
minfo1->len += minfo2->len;
(Void) SPutMsg(*mBuf2);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(*mBuf2)->b_cont = next;
/* reset length */
minfo1->len += minfo2->len;
(Void) SPutMsg(*mBuf2);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(*mBuf2)->b_cont = next;
tmp->b_wptr = tmp->b_rptr + idx;
#endif /*SS_MULTICORE_SUPPORT*/
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if (srcBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS102, ERRZERO, "SCpyFixMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check destination message buffer */
if (dstMbuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS103, ERRZERO, "SCpyFixMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check copied count buffer */
if (cCnt == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS104, ERRZERO, "SCpyFixMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check copy count */
if (cnt <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS105, ERRZERO, "SCpyFixMsg : Invalid count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dstMbuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS106, ERRZERO, "SCpyFixMsg : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS107, ERRZERO, "SCpyFixMsg : Invalid Index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition test if message length will exceed max msg length */
*cCnt = 0;
SSLOGERROR(ERRCLS_INT_PAR, ESS108, ERRZERO, "SCpyFixMsg : msgLen + cnt > maxS16");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS109, ERRZERO, "SCpyFixMsg : Failed in\
SAddPreMsgMult");
#endif
- RETVALUE(ret);
+ return (ret);
}
*cCnt = cnt;
- RETVALUE(ROK);
+ return ROK;
}
/* add data at the end of the dst buffer */
{
if ((ret = SAddPstMsgMult(srcBuf, cnt, dstMbuf)) != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
*cCnt = cnt;
- RETVALUE(ROK);
+ return ROK;
}
/* segment the message into dstMbuf and right */
if ((ret = SSegMsg(dstMbuf, dstIdx, &right)) != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
/* append data at the end of dstMbuf */
{
/* ss020.103 - Addition for cleanup */
(Void) SPutMsg(right);
- RETVALUE(ret);
+ return (ret);
}
/* cancatenate dstMbuf and right */
{
/* ss020.103 - Addition for cleanup */
(Void) SPutMsg(right);
- RETVALUE(ret);
+ return (ret);
}
*cCnt = cnt;
(Void) SPutMsg(right);
- RETVALUE(ROK);
+ return ROK;
}
/*
if (srcMbuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS110, ERRZERO, "SCpyMsgFix : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check destination message buffer */
if (dstBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS111, ERRZERO, "SCpyMsgFix : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cnt <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS112, ERRZERO, "SCpyMsgFix : Invalid Index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (srcIdx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS113, ERRZERO, "SCpyMsgFix : Invalid Index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!cCnt)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS114, ERRZERO, "SCpyMsgFix : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (srcMbuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS115, ERRZERO, "SCpyMsgFix : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((srcIdx + cnt) > minfo->len)
{
*cCnt = 0;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* get the first SS_M_DATA blk */
break;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!srcBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS116, ERRZERO, "SCpyMsgMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (srcBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS117, ERRZERO, "SCpyMsgMsg : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to validate region and pool */
if (dstRegion >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS118, ERRZERO,
"SCpyMsgMsg : Invalid region id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dstPool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS119, ERRZERO,
"SCpyMsgMsg : Invalid pool id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss037.103 Removed the semaphore operation for performance enhancement */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS121, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS122, dstRegion, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss037.103 Removed the semaphore operation for performance enhancement */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS123, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS124, ERRZERO, "SCpyMsgMsg : SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* get the SsMsgInfo from srcBuf */
minfo1 = (SsMsgInfo*) srcBuf->b_rptr;
}
printf("Failed to get the buffer of size %s %d\n", __FILE__, __LINE__);
(Void) SPutMsg(*dstBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
if (!prevblk)
minfo2->endptr = curblk;
(*dstBuf)->b_cont = newblk;
- RETVALUE(ROK);
+ return ROK;
}
if (!srcBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS126, ERRZERO, "SAddMsgRef : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (srcBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS127, ERRZERO, "SAddMsgRef : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef XEON_SPECIFIC_CHANGES
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS128, ERRZERO, "SAddMsgRef : SGetMsg failed");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* get the SsMsgInfo from srcBuf */
minfo1 = (SsMsgInfo*) srcBuf->b_rptr;
newblk = curblk;
}
(Void) SPutMsg(*dstBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
if (!prevblk)
minfo2->endptr = curblk;
(*dstBuf)->b_cont = newblk;
- RETVALUE(ROK);
+ return ROK;
}
/* allocate a data buffer */
(Void) SPutMsg(*dstBuf);
SSLOGERROR(ERRCLS_DEBUG, ESS129, ERRZERO, "SAddMsgRef : ssGetDBufOfSize\
failed");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
dBuf->b_datap->db_type = SS_M_DATA;
minfo2->endptr = dBuf;
(*dstBuf)->b_cont = dBuf;
- RETVALUE(ROK);
+ return ROK;
}
/* ss012.13: Addition */
#ifdef SS_M_PROTO_REGION
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS130, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS131, ERRZERO, "DupMsg : Invalid region\
id");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
SSLOGERROR(ERRCLS_ADD_RES, ESS132, (ErrVal) r, "SAlloc() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
/* generic set-up-message function */
#if 1
{
SSLOGERROR(ERRCLS_DEBUG, ESS335, ERRZERO,
"Could not lock the mBuf Ref Lock");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
/* increment the reference count of the dblock */
{
SSLOGERROR(ERRCLS_DEBUG, ESS335, ERRZERO,
"Could not lock the mBuf Ref Lock");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
- RETVALUE(bp);
+ return (bp);
} /* DupMsg */
#endif /* SS_M_PROTO_REGION */
if (!bufPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS133, ERRZERO, "SGetDBuf : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS134, ERRZERO, "SGetDBuf : Invalid region\
id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS135, ERRZERO, "SGetDBuf : Invalid pool id");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss037.103 Removed the semaphore operation for performance enhancement */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS137, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS138, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss037.103 Removed the semaphore operation for performance enhancement */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS139, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
if (SAlloc(region, &mdsize, 0, (Data **) bufPtr) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
data = (Data *) (*bufPtr) + MDBSIZE;
size = mdsize - MDBSIZE;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/*
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS141, ERRZERO, "SPutDBuf:Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS142, ERRZERO, "SPutDBuf:Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (buf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS143, ERRZERO, "SPutDBuf:Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( (buf->b_datap->db_type != SS_M_DATA) && (buf->b_datap->db_type != SS_M_PROTO))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS144, ERRZERO, "SPutDBuf:Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss016.13: Addition */
if(dptr->db_type == SS_MEM_TYPE_SSI_ZBC)
{
ret = SPutZbcDBuf(region, buf);
- RETVALUE(ret);
+ return (ret);
}
#ifdef TENB_DPDK_BUF
SDetachDpdkPtrFrmDBuf(buf, &dpdkBuf);
SPutSBufDpdk(dpdkBuf);
ret = SFree(region, (Data *) buf, MDBSIZE);
- RETVALUE(ret);
+ return (ret);
}
#endif /* TENB_DPDK_BUF */
#endif /* SS_USE_ZBC_MEMORY */
{
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ERRZERO,
"Could not lock the mBuf Ref Lock");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
--dptr->db_ref;
#else
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base);
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ret);
+ return (ret);
}
#ifndef SS_DBUF_REFLOCK_DISABLE
ret = SUnlock(&(dptr->dBufLock));
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base);
#endif /* SS_HISTOGRAM_SUPPORT */
#endif /* SS_MULTICORE_SUPPORT */
- RETVALUE(ret);
+ return (ret);
}
if (mBuf1 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS148, ERRZERO, "SCatMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer 2 */
if (mBuf2 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS149, ERRZERO, "SCatMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to test if same buffer */
/* check message buffer 1 and 2 not same buffer */
if (mBuf1 == mBuf2)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS150, ERRZERO, "SCatMsg : mBuf1 == mBuf2");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((order != M1M2) && (order != M2M1))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS151, ERRZERO, "SCatMsg : Invalid Order");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((mBuf1->b_datap->db_type != SS_M_PROTO) ||
(mBuf2->b_datap->db_type != SS_M_PROTO))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS152, ERRZERO,
"SCatMsg : Incorrect buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* no data to append or prepend */
if (!mBuf2->b_cont)
- RETVALUE(ROK);
+ return ROK;
minfo1 = (SsMsgInfo*) mBuf1->b_rptr;
minfo2 = (SsMsgInfo*) mBuf2->b_rptr;
#endif
{
SSLOGERROR(ERRCLS_INT_PAR, ESS153, ERRZERO, "SCpyFixMsg : messages too big");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#endif
/* duplicate mBuf2 from the region/pool of mBuf1, initialise mBuf2 */
/*ss015.13: addition */
if (SCpyMsgMsg(mBuf2, minfo1->region, minfo1->pool, &newb) != ROK)
- RETVALUE(RFAILED);
+ return RFAILED;
minfo2 = (SsMsgInfo*) newb->b_rptr;
}
#endif
if (newb && (newb != mBuf2))
(Void) SPutMsg(newb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
(Void) SInitMsg(mBuf2);
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS155, ERRZERO, "SRepMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS156, ERRZERO, "SRepMsg : Invalid index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS157, ERRZERO, "SRepMsg : Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* if index > length of the buffer */
if (minfo->len <= idx)
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
tmp = mBuf->b_cont; /* get the first SS_M_DATA blk */
{
SSLOGERROR(ERRCLS_DEBUG, ESS158, ERRZERO, "SRepMsg : ssGetDBufOfSize\
failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
while (numBytes--)
*newb->b_wptr++ = *tmp->b_rptr++;
}
*(tmp->b_rptr + idx) = data;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS159, ERRZERO, "SUpdMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!dBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS160, ERRZERO, "SUpdMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dLen < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS161, ERRZERO, "SUpdMsg : Invalid length");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((mBuf->b_datap->db_type != SS_M_PROTO) ||
(dBuf->b_datap->db_type != SS_M_DATA))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS162, ERRZERO, "SUpdMsg : Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((dBuf->b_rptr + dLen) > dBuf->b_datap->db_lim)
{
SSLOGERROR(ERRCLS_DEBUG, ESS163, ERRZERO, "SUpdMsg:Offset out of bounds");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* offset write ptr from read ptr by dLen */
minfo->len += dLen;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf || !dBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS164, ERRZERO, "SAddDBufPst : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((mBuf->b_datap->db_type != SS_M_PROTO) ||
(dBuf->b_datap->db_type != SS_M_DATA))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS165, ERRZERO, "SAddDBufPst : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* no data, return */
if (dBuf->b_wptr == dBuf->b_rptr)
- RETVALUE(ROK);
+ return ROK;
minfo = (SsMsgInfo*) (mBuf)->b_rptr;
minfo->len += dBuf->b_wptr - dBuf->b_rptr;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf || !dBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS166, ERRZERO, "SAddDBufPre : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((mBuf->b_datap->db_type != SS_M_PROTO) ||
(dBuf->b_datap->db_type != SS_M_DATA))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS167, ERRZERO, "SAddDBufPre : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* no data, return */
if (dBuf->b_wptr == dBuf->b_rptr)
- RETVALUE(ROK);
+ return ROK;
minfo = (SsMsgInfo*) (mBuf)->b_rptr;
if (!tmp)
minfo->endptr = dBuf;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (dBufPtr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS168, ERRZERO, "SRemDBufPre : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check queue */
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS169, ERRZERO, "SRemDBufPre : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS170, ERRZERO, "SRemDBufPre : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (!(minfo->len -= (*dBufPtr)->b_wptr - (*dBufPtr)->b_rptr))
minfo->endptr = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!dBufPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS171, ERRZERO, "SRemDBufPst : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS172, ERRZERO, "SRemDBufPst : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS173, ERRZERO, "SRemDBufPst : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
else
minfo->endptr = tmp;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS174, ERRZERO, "SInitNxtDBuf : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS175, ERRZERO, "SInitNxtDBuf : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* set the next ptr of mBuf to point to the first SS_M_DATA blk */
minfo->next = mBuf->b_cont;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS176, ERRZERO, "SGetNxtDBuf : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!dBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS177, ERRZERO, "SGetNxtDBuf : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS178, ERRZERO, "SGetNxtDBuf : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* if next ptr of mBuf is NULLP, return */
if ((*dBuf = minfo->next) == NULLP)
- RETVALUE(ROKDNA);
+ return (ROKDNA);
/* update next */
minfo->next = (*dBuf)->b_cont;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS179, ERRZERO, "SChkNxtDBuf : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS180, ERRZERO, "SChkNxtDBuf : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS */
/* if next is valid, return ROK */
if (minfo->next)
- RETVALUE(ROK);
+ return ROK;
else
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/*
if (!dBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS181, ERRZERO, "SGetDataRx : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!retDatLen || (pad < 0))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS182, ERRZERO, "SGetDataRx : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!retDatPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS183, ERRZERO, "SGetDataRx : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dBuf->b_datap->db_type != SS_M_DATA)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS184, ERRZERO, "SGetDataRx : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS */
SSLOGERROR(ERRCLS_DEBUG, ESS185, ERRZERO, "SGetDataRx : Reference\
count > 1");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* return the write ptr loc(with padding) if there is data to write to */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS186, ERRZERO, "SGetDataRx:No data available");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!retDatPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS187, ERRZERO, "SGetDataTx : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!dBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS188, ERRZERO, "SGetDataTx : Null Buffer");
*retDatPtr = (Data *)NULLP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (!retDatLen)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS189, ERRZERO, "SGetDataTx : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dBuf->b_datap->db_type != SS_M_DATA)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS190, ERRZERO, "SGetDataTx : Incorrect\
buffer type");
*retDatPtr = (Data *)NULLP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS191, ERRZERO, "SGetDataTx : Buffer empty");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifndef SS_ENABLE_MACROS
{
SSLOGERROR(ERRCLS_INT_PAR, ESS192, ERRZERO,
"SGetBufRegionPool : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((region == NULLP) && (pool == NULLP))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS193, ERRZERO,
"SGetBufRegionPool : Null region and pool pointers");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS194, ERRZERO,
"SUpdMsg : Incorrect buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR */
SSLOGERROR(ERRCLS_DEBUG, ESS195, ERRZERO,
"SGetBufRegionPool : mBuf's control data is null");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (region != NULLP)
if (pool != NULLP)
*pool = mInfo->pool;
- RETVALUE(ROK);
+ return ROK;
} /* end of SGetBufRegionPool */
#endif /* SS_ENABLE_MACROS */
if (!mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS196, ERRZERO, "SCompressMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS197, ERRZERO, "SCompressMsg : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((tmp = mBuf->b_cont) == minfo->endptr)
{
- RETVALUE(ROK);
+ return ROK;
}
/* allocate a data buffer of size bytes*/
{
SSLOGERROR(ERRCLS_DEBUG, ESS198, ERRZERO, "SAddMsgRef : ssGetDBufOfSize\
failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
dBuf->b_datap->db_type = SS_M_DATA;
mBuf->b_cont = dBuf;
minfo->endptr = dBuf;
- RETVALUE(ROK);
+ return ROK;
}
/*
sprintf(prntBuf,"\nmsg: empty\n");
SPrint(prntBuf);
SPrint( (S8*)"\n\n");
- RETVALUE(ROK);
+ return ROK;
}
for (qlen = 0, tmp = mBuf->b_cont; tmp; qlen++)
sprintf(prntBuf," empty\n");
SPrint(prntBuf);
SPrint( (S8*)"\n\n");
- RETVALUE(ROK);
+ return ROK;
}
tmp = mBuf->b_cont;
cptr = tmp->b_rptr;
printf("%s\n", prntBuf);
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* end of SPrntMsg */
/* check message buffer */
if (mBuf == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check count */
if (cnt <= 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* get the message info */
tmp->b_wptr += numBytes;
if (!cnt)
- RETVALUE(ROK);
+ return ROK;
}
if (ssGetDBufOfSize(minfo->region, cnt, &newb) != ROK)
{
if ((avail) && (tmp))
tmp->b_wptr = tmp->b_datap->db_lim - avail;
minfo->len -= avail;
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
minfo->len += cnt;
minfo->endptr = newb;
- RETVALUE(ROK);
+ return ROK;
}
/*
/* check message buffer */
if (mBuf == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* get the message info */
minfo = (SsMsgInfo *) (mBuf->b_rptr);
if (minfo->len < 2)
- RETVALUE(RFAILED);
+ return RFAILED;
/* get the first M_DATA blk*/
tmp = mBuf->b_cont;
if (((tmp->b_rptr + 2) <= tmp->b_wptr) || (SCompressMsg(mBuf) == ROK))
- RETVALUE(ROK);
+ return ROK;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*
{
SSLOGERROR(ERRCLS_INT_PAR, ESS199, ERRZERO, "SAlignDBufEven : Null\
Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dBuf->b_datap->db_type != SS_M_DATA)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS200, ERRZERO, "SAlignDBufEven : Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
src = dBuf->b_rptr;
/* ss008.13: addition */
if (!((PTR)src % (PTR)2))
- RETVALUE(ROK);
+ return ROK;
if (dBuf->b_datap->db_ref > 1)
- RETVALUE(RFAILED);
+ return RFAILED;
len = dBuf->b_wptr - dBuf->b_rptr;
*--dBuf->b_rptr = *src--;
}
else
- RETVALUE(RFAILED);
+ return RFAILED;
- RETVALUE(ROK);
+ return ROK;
}
/* ss004.13: addition */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS201, ERRZERO, "SAlignDBuf: Null\
Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dBuf->b_datap->db_type != SS_M_DATA)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS202, ERRZERO, "SAlignDBuf: Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
* the read and write pointers */
if (!upShift)
- RETVALUE(ROK);
+ return ROK;
if (dBuf->b_datap->db_ref > 1)
- RETVALUE(RFAILED);
+ return RFAILED;
downShift = align - upShift; /* no of bytes by which to shift down
* the read and write pointers */
*--dBuf->b_rptr = *src--;
}
else
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS203, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate pointer to pool ID */
if (pool == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS204, region, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*pool = 0;
- RETVALUE(ROK);
+ return ROK;
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS205, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate pool ID */
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS206, region, "Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to check if region is registered */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS208, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS209, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS210, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
\f
if (region >= SS_MAX_REGS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS229, region, "Invalid region");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate pool ID */
if (pool >= SS_MAX_POOLS_PER_REG)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS230, region, "Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* validate status pointer */
if (status == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS231, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* ss037.103 Removed the semaphore operation for performance enhancement */
"Could not lock region table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS233, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS234, region, "Region not registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* verify that this is a valid pool */
if (osCp.regionTbl[region].poolTbl[pool].type != SS_POOL_DYNAMIC)
{
SSLOGERROR(ERRCLS_DEBUG, ESS235, ERRZERO, "Invalid pool");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS236, ERRZERO,
"Could not release semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE(ret);
+ return (ret);
}
/*
if (mBuf1 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS237, ERRZERO, "SSwapMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check message buffer 2 */
if (mBuf2 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS238, ERRZERO, "SSwapMsg : Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf1->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS239, ERRZERO, "SSwapMsg: Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf2->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS240, ERRZERO, "SSwapMsg: Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
minfo1 = (SsMsgInfo*) mBuf1->b_rptr;
minfo2 = (SsMsgInfo*) mBuf2->b_rptr;
{
SSLOGERROR(ERRCLS_INT_PAR, ESS241, ERRZERO, "SSwapMsg: differnt regions\
for messages");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SMemCpy((Void *) (mBuf1->b_datap->db_base), (Void *) (mBuf2->b_datap->db_base), (size_t)(sizeof(SsMsgInfo)));
SMemCpy((Void *) (mBuf2->b_datap->db_base), (Void *) minfop, (size_t)(sizeof(SsMsgInfo)));
- RETVALUE(ROK);
+ return ROK;
}
/* ss004.301 : Cavium changes */
#ifdef SS_SEUM_CAVIUM
/* check mBuf for NULLP */
if ( (mBuf == NULLP) || (*mBuf == NULLP ) )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* first block in Buffer is head */
*mBuf = (Buffer*)cvmx_ptr_to_phys (*mBuf);
- RETVALUE(ROK);
+ return ROK;
} /* SConvPtrPhy */
/* check workPtr for NULLP */
if ( (workPtr == NULLP) || (*workPtr == NULLP) )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Convert the buffer address to pointer */
/* Place the converted buffer */
*workPtr = mBuf;
- RETVALUE(ROK);
+ return ROK;
} /* SConvPhyPtr */
if ( srcBuf == (Buffer*)NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((dstRegion >= SS_MAX_REGS) || (dstPool >= SS_MAX_POOLS_PER_REG))
{
/* Free the source buffer and return failure */
SPutFpaMsg(srcBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate memory for destination buffer */
{
/* Free the source buffer and return failure */
SPutFpaMsg(srcBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* get the minfo of dest and src buffers */
(Void) SPutMsg(*dstBuf);
/* Free the source buffer and return failure */
SPutFpaMsg(srcBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
dat = (Data *)tmpblk + MDBSIZE;
/* Free the source buffer after copying it */
SPutFpaMsg(srcBuf);
- RETVALUE(ROK);
+ return ROK;
} /* SCpyFpaMsg */
if (srcBuf == (Buffer*)NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
*dstBuf = (Buffer*)cvmx_fpa_alloc(SS_CVMX_POOL_0);
{
/* Free the source buffer before returning */
SPutMsg(srcBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
dat = (Data *)(*dstBuf) + MDBSIZE;
SPutFpaMsg(*dstBuf);
/* Free the source buffer before returning */
SPutMsg(srcBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate for mBuf and copy both the header and contents */
SPutFpaMsg(*dstBuf);
/* Free the source buffer before returning */
SPutMsg(srcBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
dat = (Data *)tmpblk + MDBSIZE;
/* Free the source buffer after copying it */
SPutMsg(srcBuf);
- RETVALUE(ROK);
+ return ROK;
} /* SCpyMsgFpa */
if( fpaBuf == NULLP )
{
- RETVALUE(ROK);
+ return ROK;
}
curBlk = fpaBuf->b_cont;
cvmx_fpa_free(fpaBuf, SS_CVMX_POOL_0, 0);
- RETVALUE(ROK);
+ return ROK;
} /* SPutFpaMsg */
if (!srcBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SCpyPartMsg : Null src Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (srcBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SCpyPartMsg : Incorrect\
src buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(!dstBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SCpyPartMsg : Null dst Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dstBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SCpyPartMsg : Incorrect\
dst buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SCpyPartMsg : Incorrect\
idx value ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
sBuf = srcBuf->b_cont;
{
SSLOGERROR(ERRCLS_DEBUG, ESS125, ERRZERO, "SCpyPartMsg : SGetDBuf\
failed");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
dCnt = MIN(cnt, (dBuf->b_datap->db_lim - dBuf->b_datap->db_base));
dPrev->b_cont = dBuf;
dMinfo->len += numCpd;
dMinfo->endptr = dBuf;
- RETVALUE(ROK);
+ return ROK;
}
/*
if (!dstBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRepPartMsg : Null dstBuf");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dstBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRepPartMsg : Incorrect\
dstBuf buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(!srcBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRepPartMsg : Null Src Buffer ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (srcBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRepPartMsg : Incorrect\
sBuf buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* (ERRCLASS & ERRCLS_INT_PAR) */
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRepPartMsg : Incorrect\
cnt value ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
dBuf = dstBuf->b_cont;
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRepPartMsg : unable to replace\
some bytes ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if ((!srcBuf) || (!dstBuf ))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS097, ERRZERO, "SMovPartMsg : Null Buffer (src or Dst)");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS099, ERRZERO, "SMovPartMsg : Invalid index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((srcBuf->b_datap->db_type != SS_M_PROTO) || (dstBuf->b_datap->db_type != SS_M_PROTO))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS100, ERRZERO, "SMovPartMsg : Incorrect buffer\
type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/*-- ss008.301 */
if (idx > sMinfo->len)
{
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
/* one block might not sufficient - Check for generic implementation */
{
SSLOGERROR(ERRCLS_DEBUG, ESS125, ERRZERO, "SCpyMsgPartMsg : SGetDBuf\
failed");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
dCnt = MIN(idx, (dBuf->b_datap->db_lim - dBuf->b_datap->db_base));
dPrev->b_cont = dBuf;
dMinfo->len -= idx;
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SMovPartMsg : unable to copy\
some bytes ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS070, ERRZERO, "SPkMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check source */
if (src == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS071, ERRZERO, "SPkMsgMult:Null Buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check count */
if (cnt <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS072, ERRZERO, "SPkMsgMult: Invalid\
count");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS073, ERRZERO, "SPkMsgMult: Incorrect\
buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
minfo->len += numBytes;
if (!cnt)
{
- RETVALUE(ROK);
+ return ROK;
}
}
newblk = NULLP;
if (ssGetDBufOfSize(minfo->region, cnt, &newblk) != ROK)
{
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
newblk->b_datap->db_type = SS_M_DATA;
newblk->b_rptr = newblk->b_datap->db_lim - cnt;
minfo->len += cnt;
minfo->endptr = newblk;
- RETVALUE(ROK);
+ return ROK;
}
/* ss006.301 : new buffer management APIs, end */
/*
*len = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_USE_ZBC_MEMORY
/*
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: Null PTR");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if(SGetMsg(region, pool, mBuf) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: SGetMsg Failed");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
mdsize = MDBSIZE;
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: SAlloc Failed");
SPutMsg(*mBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(*mBuf)->b_cont = newblk;
minfo->len = totalLen;
minfo->endptr = newblk;
- RETVALUE(ROK);
+ return ROK;
}
/*
{
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ERRZERO,
"Could not lock the mBuf Ref Lock");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
--dptr->db_ref;
#else
ret = SFree(region, (Data *) buf, MDBSIZE);
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(ret);
+ return (ret);
}
#ifndef SS_DBUF_REFLOCK_DISABLE
ret = SUnlock(&(dptr->dBufLock));
#endif
}
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_USE_ZBC_MEMORY */
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: Null PTR");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if(SGetMsg(region, pool, mBuf) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: SGetMsg Failed");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
region = 0;
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: SAlloc Failed");
SPutMsg(*mBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(*mBuf)->b_cont = newblk;
minfo->endptr = newblk;
//printf("Mbuf PTR = %x, DBlk PTR = %x, PTR = %x\n", *mBuf, newblk, ptr);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* INTEL_WLS */
PUBLIC S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf)
{
#ifndef L2_OPTMZ
- RETVALUE(SAddMsgRef(srcBuf,dstRegion, dstPool,dstBuf));
+ return (SAddMsgRef(srcBuf,dstRegion, dstPool,dstBuf));
#else
*dstBuf = srcBuf;
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef L2_OPTMZ
PUBLIC Void SResetMBuf(Buffer *mbuf)
if (ptr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: Null PTR");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if(SGetMsg(region, pool, mBuf) != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: SGetMsg Failed");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
mdsize = MDBSIZE;
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SAttachPtrToBuf: SAlloc Failed");
SPutMsg(*mBuf);
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
(*mBuf)->b_cont = newblk;
minfo->endptr = newblk;
//printf("Mbuf PTR = %x, DBlk PTR = %x, PTR = %x\n", *mBuf, newblk, ptr);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef TENB_DPDK_BUF
*ptr = ntl_alloc(mtGetNtlHdl(), size);
- RETVALUE(ret);
+ return (ret);
}
PUBLIC S16 SPutSBufDpdk
ntl_free(mtGetNtlHdl(), ptr);
- RETVALUE(ret);
+ return (ret);
}
PUBLIC S16 SDetachDpdkPtrFrmDBuf
//minfo->len = 0;
- RETVALUE(ROK);
+ return ROK;
}
if(msgBlk == NULLP)
{
*ptr = NULLP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
dptr = msgBlk->b_datap;
if(dptr->db_type != SS_MEM_TYPE_DPDK_ZBC)
{
*ptr = NULLP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
*ptr = msgBlk->b_rptr;;
minfo = (SsMsgInfo*) mBuf->b_rptr;
minfo->len = 0;
- RETVALUE(ROK);
+ return ROK;
}
SsDblk *dptr;
if(0 == msgLen)
- RETVALUE(RFAILED);
+ return RFAILED;
SAttachWlsPtrToMBuf(region, pool, ptr, readPtr, msgLen, totalLen, mBuf);
dptr = (SsDblk*) (((Data *) ((*mBuf)->b_cont)) + MBSIZE);
dptr->db_type = SS_MEM_TYPE_DPDK_ZBC;
- RETVALUE(ROK);
+ return ROK;
}
#endif /* TENB_DPDK_BUF */
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS242, (ErrVal)ret, "SAddPreMsg() failed");
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SPkS8 */
\f
/*
*
-* Fun: SPkU8
+* Fun: oduUnpackUInt8
*
* Desc: This function packs an unsigned 8 bit value into a message.
*
*/
#ifdef ANSI
-PUBLIC S16 SPkU8
+PUBLIC S16 oduUnpackUInt8
(
U8 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkU8(val, mBuf)
+PUBLIC S16 oduUnpackUInt8(val, mBuf)
U8 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
{
S16 ret; /* return code */
- TRC1(SPkU8)
+ TRC1(oduUnpackUInt8)
ret = SAddPreMsg((Data) val, mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS243, (ErrVal)ret, "SAddPreMsg() failed");
#endif
- RETVALUE(ret);
-} /* end of SPkU8 */
+ return (ret);
+} /* end of oduUnpackUInt8 */
\f
/*
*
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS244, (ErrVal)ret, "SAddPreMsgMult() failed");
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SPkS16 */
\f
/*
*
-* Fun: SPkU16
+* Fun: oduUnpackUInt16
*
* Desc: This function packs an unsigned 16 bit value into a message.
*
*/
#ifdef ANSI
-PUBLIC S16 SPkU16
+PUBLIC S16 oduUnpackUInt16
(
U16 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkU16(val, mBuf)
+PUBLIC S16 oduUnpackUInt16(val, mBuf)
U16 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
Data pkArray[2]; /* array for packing */
S16 ret; /* return code */
- TRC1(SPkU16)
+ TRC1(oduUnpackUInt16)
#ifndef FCSPKINT /* backward compatibility, packing order */
pkArray[0] = (Data) GetHiByte(val);
pkArray[1] = (Data) GetLoByte(val);
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS245, (ErrVal)ret, "SAddPreMsgMult() failed");
#endif
- RETVALUE(ret);
-} /* end of SPkU16 */
+ return (ret);
+} /* end of oduUnpackUInt16 */
\f
/*
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS246, (ErrVal)ret, "SAddPreMsgMult() failed");
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SPkS32 */
\f
/*
*
-* Fun: SPkU32
+* Fun: oduUnpackUInt32
*
* Desc: This function packs an unsigned 32 bit value into a message.
*
*/
#ifdef ANSI
-PUBLIC S16 SPkU32
+PUBLIC S16 oduUnpackUInt32
(
U32 val, /* value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SPkU32(val, mBuf)
+PUBLIC S16 oduUnpackUInt32(val, mBuf)
U32 val; /* value */
Buffer *mBuf; /* message buffer */
#endif
Data pkArray[4]; /* packing array */
S16 ret; /* return code */
- TRC1(SPkU32)
+ TRC1(oduUnpackUInt32)
#ifndef FCSPKINT /* backward compatibility, packing order */
tmp = (U16) GetHiWord(val);
pkArray[0] = (Data) GetHiByte(tmp);
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS247, (ErrVal)ret, "SAddPreMsgMult() failed");
#endif
- RETVALUE(ret);
-} /* end of SPkU32 */
+ return (ret);
+} /* end of oduUnpackUInt32 */
/*ss038.103 1. Added Floating point support*/
#ifdef SS_FLOAT
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS248, (ErrVal)ret, "SAddPreMsgMult() failed");
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SPkF32 */
/*
if (ret != ROK)
SSLOGERROR(ERRCLS_ADD_RES, ESS249, (ErrVal)ret, "SAddPreMsgMult() failed");
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SPkF64 */
#endif /* SS_FLOAT */
if (!val)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS250, ERRZERO, "SUnpkS8 : Null value");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
SSLOGERROR(ERRCLS_DEBUG, ESS251, (ErrVal)ret, "SRemPreMsg() failed");
#endif
*val = (S8) tmp;
- RETVALUE(ret);
+ return (ret);
} /* end of SUnpkS8 */
\f
/*
*
-* Fun: SUnpkU8
+* Fun: oduPackUInt8
*
* Desc: This function unpacks an unsigned 8 bit value from a message.
*
*/
#ifdef ANSI
-PUBLIC S16 SUnpkU8
+PUBLIC S16 oduPackUInt8
(
U8 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkU8(val, mBuf)
+PUBLIC S16 oduPackUInt8(val, mBuf)
U8 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
{
Data tmp; /* temporary value */
S16 ret; /* return code */
- TRC1(SUnpkU8)
+ TRC1(oduPackUInt8)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!val)
{
- SSLOGERROR(ERRCLS_INT_PAR, ESS252, ERRZERO, "SUnpkU8 : Null value");
- RETVALUE(RFAILED);
+ SSLOGERROR(ERRCLS_INT_PAR, ESS252, ERRZERO, "oduPackUInt8 : Null value");
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
SSLOGERROR(ERRCLS_DEBUG, ESS253, (ErrVal)ret, "SRemPreMsg() failed");
#endif
*val = (U8) tmp;
- RETVALUE(ret);
-} /* end of SUnpkU8 */
+ return (ret);
+} /* end of oduPackUInt8 */
\f
/*
*
if (!val)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS254, ERRZERO, "SUnpkS16 : Null value");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
#endif
*val = (S16) tmp16;
- RETVALUE(ret);
+ return (ret);
} /* end of SUnpkS16 */
\f
/*
*
-* Fun: SUnpkU16
+* Fun: oduPackUInt16
*
* Desc: This function unpacks an unsigned 16 bit value from a message.
*
*/
#ifdef ANSI
-PUBLIC S16 SUnpkU16
+PUBLIC S16 oduPackUInt16
(
U16 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkU16(val, mBuf)
+PUBLIC S16 oduPackUInt16(val, mBuf)
U16 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
U16 tmp16; /* temporary value */
Data unpkArray[2]; /* unpacking array */
S16 ret; /* return code */
- TRC1(SUnpkU16)
+ TRC1(oduPackUInt16)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!val)
{
- SSLOGERROR(ERRCLS_INT_PAR, ESS256, ERRZERO, "SUnpkU16 : Null value");
- RETVALUE(RFAILED);
+ SSLOGERROR(ERRCLS_INT_PAR, ESS256, ERRZERO, "oduPackUInt16 : Null value");
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
#endif
*val = tmp16;
- RETVALUE(ret);
-} /* end of SUnpkU16 */
+ return (ret);
+} /* end of oduPackUInt16 */
\f
/*
if (!val)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS258, ERRZERO, "SUnpkS32 : Null value");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
#endif
*val = (S32) tmp32;
- RETVALUE(ret);
+ return (ret);
} /* end of SUnpkS32 */
\f
/*
*
-* Fun: SUnpkU32
+* Fun: oduPackUInt32
*
* Desc: This function unpacks an unsigned 32 bit value from a message.
*
*/
#ifdef ANSI
-PUBLIC S16 SUnpkU32
+PUBLIC S16 oduPackUInt32
(
U32 *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
-PUBLIC S16 SUnpkU32(val, mBuf)
+PUBLIC S16 oduPackUInt32(val, mBuf)
U32 *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
#ifdef ERRCLASS
S16 ret; /* return code */
#endif /* ERRCLASS */
- TRC1(SUnpkU32)
+ TRC1(oduPackUInt32)
/* ss021.103 - Addition of data pointer check */
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check data pointer */
if (!val)
{
- SSLOGERROR(ERRCLS_INT_PAR, ESS260, ERRZERO, "SUnpkU32 : Null value");
- RETVALUE(RFAILED);
+ SSLOGERROR(ERRCLS_INT_PAR, ESS260, ERRZERO, "oduPackUInt32 : Null value");
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
#endif
*val = tmp32;
- RETVALUE(ret);
-} /* end of SUnpkU32 */
+ return (ret);
+} /* end of oduPackUInt32 */
/*ss038.103 1. Added Floating point support*/
#ifdef SS_FLOAT
if (!val)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS262, ERRZERO, "SUnpkF32 : Null value");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
sscanf(tmpArray, "%f", val);
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SUnpkF32 */
if (!val)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS264, ERRZERO, "SUnpkF64 : Null value");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_INT_PAR */
sscanf(tmpArray, "%lf", val);
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of SUnpkF64 */
#endif /* SS_FLOAT */
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS266, ERRZERO, "Null Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
q->head = NULLP;
q->tail = NULLP;
q->crntSize = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of SInitQueue */
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS267, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
q->head = NULLP;
q->tail = NULLP;
- RETVALUE(ROK);
+ return ROK;
} /* end of SFlushQueue */
if (q1 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS268, ERRZERO, "Null Q1 Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (q2 == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS269, ERRZERO, "Null Q2 Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((order != Q1Q2) && (order != Q2Q1))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS270, ERRZERO, "Invalid queue order");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition if Q1 is Q2 */
if (q2 == q1)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS271, ERRZERO, "Q1 == Q2");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS */
q2->tail = NULLP;
q2->crntSize = 0;
- RETVALUE(ROK);
+ return ROK;
}
if (q2->crntSize == 0)
{
- RETVALUE(ROK);
+ return ROK;
}
switch (order)
break;
}
default:
- RETVALUE(RFAILED);
+ return RFAILED;
}
q1->crntSize += q2->crntSize;
q2->tail = NULLP;
q2->crntSize = 0;
- RETVALUE(ROK);
+ return ROK;
} /* end of SCatQueue */
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS272, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check length */
if (lngPtr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS273, ERRZERO, "Null Q Len Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*lngPtr = q->crntSize;
- RETVALUE(ROK);
+ return ROK;
} /* end of SFndLenQueue */
if (bufPtr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS274, ERRZERO, "Null Buf Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check index */
if ((S32)idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS275, ERRZERO, "-ve index ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check queue */
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS276, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS */
if (idx >= q->crntSize)
{
*bufPtr = NULLP;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
if (idx == 0)
*bufPtr = tmpBuf;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of SExamQueue */
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS277, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS278, ERRZERO, "Null Buf Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((S32)idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS279, ERRZERO, "-ve index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to check buffer type and if duplicate message */
if (mBuf->b_datap->db_type != SS_M_PROTO)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS280, ERRZERO,
"Incorrect buffer type");
- RETVALUE(RFAILED);
+ return RFAILED;
}
tBuf = q->head;
while (tBuf != (Buffer *)NULLP)
if (tBuf == mBuf)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS281, ERRZERO, "Duplicate queued mBuf");
- RETVALUE(RFAILED);
+ return RFAILED;
}
tBuf = tBuf->b_next;
}
if (idx > q->crntSize)
{
SSLOGERROR(ERRCLS_DEBUG, ESS282, ERRZERO, "Invalid index");
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
else if (q->crntSize == 0)
{
tBuf->b_prev = mBuf;
}
q->crntSize++;
- RETVALUE(ROK);
+ return ROK;
} /* end of SAddQueue */
if (bufPtr == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS283, ERRZERO, "Null Buf Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check queue */
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS284, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((S32)idx < 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS285, ERRZERO, "-ve Index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* ERRCLASS */
if (idx >= q->crntSize)
{
*bufPtr = NULLP;
- RETVALUE(ROKDNA);
+ return (ROKDNA);
}
if (idx == 0)
{
}
q->crntSize--;
- RETVALUE(ROK);
+ return ROK;
} /* end of SRemQueue */
{
TRC1(SQueueFirst)
- RETVALUE(SAddQueue(buf, q, 0));
+ return (SAddQueue(buf, q, 0));
} /* end of SQueueFirst */
\f
{
TRC2(SDequeueFirst)
- RETVALUE(SRemQueue(bufPtr, q, 0));
+ return (SRemQueue(bufPtr, q, 0));
} /* end of SDequeueFirst */
\f
if (q == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS286, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check queue */
if (buf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS287, ERRZERO, "Null Buf Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(SAddQueue(buf, (q), ((q)->crntSize)));
+ return (SAddQueue(buf, (q), ((q)->crntSize)));
}
if (!bufPtr)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS288, ERRZERO, "Null Buf Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check queue */
if (!q)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS289, ERRZERO, "Null Q Ptr");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if(q->crntSize > 0)
else
ret = SRemQueue(bufPtr, q, q->crntSize);
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_ENABLE_MACROS */
if (dQueue == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS290, ERRZERO, "NULL DQ Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS291, (ErrVal)ret,
"Failed to initialize lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
SSLOGERROR(ERRCLS_DEBUG, ESS292, (ErrVal)ret,
"Failed to init semaphore");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE (ROK);
+ return (ROK);
} /* End of ssInitDmndQ */
if (dQueue == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS293, ERRZERO, "NULL DQ Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS294, (ErrVal)ret, "Failed to destroy lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
for (i = 0; i < SS_MAX_NUM_DQ; i++)
{
SSLOGERROR(ERRCLS_DEBUG, ESS295, ERRZERO,
"Could not delete the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE (ROK);
+ return (ROK);
} /* end of ssDestroyDmndQ */
if (dQueue == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS296, ERRZERO, "NULL DQ Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS297, ERRZERO, "NULL mBuf Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((priority == PRIORNC) || (priority > SS_MAX_DQ_PRIOR))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS298, ERRZERO, "invalid priority ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((order != SS_DQ_FIRST) && (order != SS_DQ_LAST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS299, ERRZERO, "invalid order ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS300, (ErrVal)ret, "Failed to get lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
if (queue->crntSize == 0)
{
SDequeueFirst(&mBuf, queue);
}
- RETVALUE (RFAILED);
+ return (RFAILED);
}
/* increment the counting semaphore */
{
sem_getvalue(&dQueue->dmndQSema, &value);
if (value > 0)
- RETVALUE(ROK);
+ return ROK;
}
#endif
if (ssPostSema(&dQueue->dmndQSema) != ROK)
{
SDequeueFirst(&mBuf, queue);
}
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* End of ssDmndQPut */
if (dQueue == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS303, ERRZERO, "NULL DQ Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS306, (ErrVal)ret, "Failed to get semaphore");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
- RETVALUE (ROK);
+ return (ROK);
} /* End of ssDmndQWait */
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS304, ERRZERO, "NULL mBuf Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((order != SS_DQ_FIRST) && (order != SS_DQ_LAST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS305, ERRZERO, "invalid order ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS307, (ErrVal)ret, "Failed to get lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
bitPosition = osCp.dmndQLookupTbl[dQueue->bitMask[i]];
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS308, ret, "Failed to release lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
}
if (i >= SS_DQ_BIT_MASK_LEN)
{
/* Demand Queue is empty */
*mBuf = NULLP;
- RETVALUE (ROKDNA);
+ return (ROKDNA);
}
qIndex = (i * 8) + (7 - bitPosition);
{
/* Demand Queue is empty */
*mBuf = NULLP;
- RETVALUE (ROKDNA);
+ return (ROKDNA);
}
/* ss039.103 : Replaced SLock with WTLock */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS307, (ErrVal)ret, "Failed to get lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS309, (ErrVal)ret, "Failed to release lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
- RETVALUE (ROK);
+ return (ROK);
} /* End of ssDmndQGet */
if ((dQueue == NULLP) || (len == NULLP))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS310, ERRZERO, "NULL Pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS311, (ErrVal)ret, "Failed to get lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
*len = dQueue->queue[priority].crntSize;
SSLOGERROR(ERRCLS_DEBUG, ESS312, (ErrVal)ret, \
"Failed to release lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
}
else
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS314, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
i--;
}
- RETVALUE (RFAILED);
+ return (RFAILED);
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS315, (ErrVal)ret, "Failed to get lock");
#endif
- RETVALUE (RFAILED);
+ return (RFAILED);
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* End of ssFndLenDmndQ */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id, "Invalid RBUF ID");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SsRngInfoTbl[id].r_addr != 0)
{
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id,
"Failed to Create Ring Buffer Id Ring already exist");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Get Element Size */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "Allocating Ring Failed!!!")
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ring,
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "Allocating Ring Failed!!!")
#endif
free(ring);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update Buffer Id Table */
SsRngInfoTbl[id].r_addr = ring;
#else
printf("Ring Buffer Created with id =%d rSize:%d eSize:%d %lx\n",id,ring->size,ring->type,(PTR)ring);
#endif
- RETVALUE(ROK);
+ return ROK;
}
/*
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id, "Invalid RBUF ID");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(SsRngInfoTbl[id].rngState < SS_RNG_CREATED)
{
printf("Attach Request in Invalid Ring State %d id%d \n",
SsRngInfoTbl[id].rngState,id);
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(txRx == SS_RNG_TX)
{
SsRngInfoTbl[id].rxEnt = ent;
SsRngInfoTbl[id].rngState = SS_RNG_RX_ATTACHED;
}
- RETVALUE(ROK);
+ return ROK;
}
/*
Func: SConnectSRngBuf
#endif
{
/* Send to Reciever ENT*/
- RETVALUE(ROK);
+ return ROK;
}
/*
if (IsFull(ring))
{
SsRngInfoTbl[id].nWriteFail++;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* TBD Avoid multiplication for optimisation */
w_ptr = (U8*)ring->elem + (ring->write * ring->type);
ring->write = (wrIndex == ring->size)?0: wrIndex;
/* Update Statistics */
SsRngInfoTbl[id].n_write++;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
S16 freeDist = (SsRngInfoTbl[id].n_write- SsRngInfoTbl[id].n_read);
- RETVALUE(freeDist);
+ return (freeDist);
}
/*
Func: SDeqSRngBuf
if(IsEmpty(ring))
{
SsRngInfoTbl[id].nReadFail++;
- RETVALUE(RFAILED);
+ return RFAILED;
}
r_ptr = (U8*)ring->elem + (ring->read * ring->type);
for(i=0; i<ring->type; i++)
rdIndex= ring->read + 1;
ring->read = (rdIndex == ring->size)?0:rdIndex;
SsRngInfoTbl[id].n_read++;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
SsRngInfoTbl[id].rngState = SS_RNG_DESTROYED;
SsRngInfoTbl[id].r_addr = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
Txt prntBuf[100];
#ifdef RGL_SPECIFIC_CHANGES
- RETVALUE(ROK);
+ return ROK;
#endif
for(i=0; i< SS_RNG_BUF_MAX;i++)
{
#endif
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
if (IsFull(ring))
{
SsRngInfoTbl[rngId].nWriteFail++;
- RETVALUE(NULLP);
+ return (NULLP);
}
else
{
- RETVALUE(((U8 *)ring->elem) + (ring->type * ring->write));
+ return (((U8 *)ring->elem) + (ring->type * ring->write));
}
}
if(IsEmpty(ring))
{
SsRngInfoTbl[rngId].nReadFail++;
- RETVALUE(NULLP);
+ return (NULLP);
}
else
{
- RETVALUE(((U8 *)ring->elem) + (ring->type * ring->read));
+ return (((U8 *)ring->elem) + (ring->type * ring->read));
}
}
SsRngInfoTbl[ringId].pktDrop++;
ret1 = RFAILED;
}
- RETVALUE(ret1);
+ return (ret1);
}
#endif
#endif
strmCfg.datRegion = datRegId;
- RETVALUE(ROK);
+ return ROK;
}
\f
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS325, ERRZERO, "Null pointer");
- RETVALUE(0);
+ return (0);
}
#endif
if (len == 0) /* nothing to do */
{
- RETVALUE(1);
+ return (1);
}
/* if we can't trim len bytes, fail */
if (len > size)
{
- RETVALUE(0);
+ return (0);
}
size += len;
if (size < 0)
{
- RETVALUE(0);
+ return (0);
}
}
- RETVALUE(1);
+ return (1);
} /* ssAdjMsg */
\f
SSLOGERROR(ERRCLS_ADD_RES, ESS326, (ErrVal) r, "SAlloc() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
#else
SFree(strmCfg.mdRegion, (Data *)bp, m);
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVALUE(NULLP);
+ return (NULLP);
}
}
/* we _can_ allocate a message with an empty data block */
SS_STRM_INITB(bp, (SsDblk *)(((U8 *)bp) + sizeof(SsMblk)), dat, size, NULLP);
- RETVALUE(bp);
+ return (bp);
} /* ssAllocB */
\f
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS328, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
SSLOGERROR(ERRCLS_ADD_RES, ESS329, ERRZERO, "ssAllocB() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
}
- RETVALUE(bp);
+ return (bp);
} /* ssCopyB */
\f
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS330, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
SSLOGERROR(ERRCLS_ADD_RES, ESS331, ERRZERO, "ssCopyB() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
ssFreeMsg(first);
- RETVALUE(NULLP);
+ return (NULLP);
}
bp = bp->b_cont;
}
- RETVALUE(first);
+ return (first);
} /* ssCopyMsg */
\f
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS333, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
SSLOGERROR(ERRCLS_ADD_RES, ESS334, ERRZERO, "ssAllocB() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
{
SSLOGERROR(ERRCLS_DEBUG, ESS335, ERRZERO,
"Could not lock the mBuf Ref Lock");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS336, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(NULLP);
+ return (NULLP);
#endif
}
#endif
- RETVALUE(bp);
+ return (bp);
} /* ssDupB */
\f
SSLOGERROR(ERRCLS_ADD_RES, ESS337, ERRZERO, "ssDupB() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
ssFreeMsg(first);
- RETVALUE(NULLP);
+ return (NULLP);
}
bp = bp->b_cont;
}
- RETVALUE(first);
+ return (first);
} /* ssDupMsg */
\f
if (base == NULLP || fr_rtn == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS339, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
SSLOGERROR(ERRCLS_ADD_RES, ESS340, (ErrVal) r, "SAlloc() failed");
#endif
- RETVALUE(NULLP);
+ return (NULLP);
}
base, size, fr_rtn);
- RETVALUE(bp);
+ return (bp);
} /* ssESBAlloc */
\f
}
- RETVALUE(size);
+ return (size);
} /* ssMsgDSize */
\f
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS346, ERRZERO, "Null pointer");
- RETVALUE(0);
+ return (0);
}
if (len < -1)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS347, len, "Invalid length");
- RETVALUE(0);
+ return (0);
}
#endif
if (len == 0)
{
- RETVALUE(1);
+ return (1);
}
/* do we have enough bytes to pull up? */
if (len < 0 || len > mLen)
{
- RETVALUE(0);
+ return (0);
}
newbp = ssAllocB(len, 0);
if (newbp == NULLP)
{
- RETVALUE(0);
+ return (0);
}
newbp->b_datap->db_type = mp->b_datap->db_type;
ssFreeB(newbp);
- RETVALUE(1);
+ return (1);
} /* ssPullupMsg */
\f
if (mp == NULLP || bp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS348, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
{
if (mp == NULLP)
{
- RETVALUE((SsMblk *)-1);
+ return ((SsMblk *)-1);
}
else if (mp->b_cont == bp)
{
bp->b_cont = NULLP;
- RETVALUE(rp);
+ return (rp);
} /* ssRmvB */
\f
if (bp)
{
ssFreeB(bp);
- RETVALUE(1);
+ return (1);
}
- RETVALUE(0);
+ return (0);
} /* ssTestB */
\f
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS349, ERRZERO, "Null pointer");
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
mp->b_cont = NULLP;
- RETVALUE(bp);
+ return (bp);
} /* ssUnlinkB */
/**********************************************************************
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS350, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check initialization function */
if (initFnct == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS351, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS352, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS355, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* check if entity and instance already registered */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS357, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS358, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SRegInit */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS359, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check activation function */
if (actvTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS360, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task type */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS361, ERRZERO, "Invalid task type");
/* ss021.103 - Addition of return fail for invalid task type */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task priority */
if (prior > PRIOR3)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS362, ERRZERO, "Invalid task priority");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS363, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* lock TAPA task table */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS364, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS365, ERRZERO,
"Could not lock TAPA task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Modification for SRegInit not called yet */
/* check if entity and instance already registered */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS366, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS367, ERRZERO, "Too many tasks");
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS368, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS369, ERRZERO,
"ActvTask already registered");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS370, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SDeregTTsk(ent, inst);
- RETVALUE(ret);
+ return (ret);
}
}
- RETVALUE(ret);
+ return (ret);
} /* SRegActvTsk */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS373, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
SSLOGERROR(ERRCLS_DEBUG, ESS374, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* lock the TAPA task table */
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS377, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS378, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
/* deregister the TAPA task */
if (SDeregTTsk(ent, inst) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = (SsIdx) sTskId;
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS380, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
/* check if the system task is dying already */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS381, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS382, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not destroy system task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* SDeregInitTskTmr */
#endif /* SS_MULTIPLE_PROCS */
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS384, ERRZERO, "Invalid proc/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS385, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
if (actvTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS386, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task type */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS387, ERRZERO, "Invalid task type");
/* ss021.103 - Addition of return fail for invalid task type */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check task priority */
if (prior > PRIOR3)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS388, ERRZERO, "Invalid task priority");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not find proc table index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
{
SSLOGERROR(ERRCLS_DEBUG, ESS390, ERRZERO,
"Could not lock system task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
SS_ACQUIRE_ALL_SEMA(&osCp.tTskTblSem, ret);
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS392, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS394, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
/* check if entity and instance already registered */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS396, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS397, ERRZERO,
"Could not give the Semaphore");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SRegTTsk */
/* ss002.301 Additions */
/*
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRegCbTsk() : Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cbTsk == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, " SRegCbTsk() : Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
" SRegCbTsk() : Could not find proc table index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ERRZERO,
"SRegCbTsk() : Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MULTIPLE_PROCS
{
SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "SRegCbTsk() : Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tTsk = &osCp.tTskTbl[idx];
/* unlock the table */
SS_RELEASE_ALL_SEMA(&osCp.tTskTblSem);
- RETVALUE(ROK);
+ return ROK;
}
\f
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS398, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS399, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
SSLOGERROR(ERRCLS_DEBUG, ESS400, ERRZERO,
"Could not find proc id index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
SSLOGERROR(ERRCLS_DEBUG, ESS401, ERRZERO,
"Could not lock timer table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (idx = 0; idx < SS_MAX_TMRS; idx++)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS402, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS403, ERRZERO,
"Could not deregister task's timer(s)");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS404, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
/* ss002.301 Additions */
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
SSLOGERROR(ERRCLS_INT_PAR, ESS412, ERRZERO, "Unknown task");
/* ss002.301 Additions */
- RETVALUE(RFAILED);
+ return RFAILED;
}
tTsk = &osCp.tTskTbl[idx];
SSLOGERROR(ERRCLS_DEBUG, ESS415, ERRZERO, "Could not get a message");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update message*/
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_INT_PAR, ESS416, ERRZERO, "Could not write to demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* SDeregTTsk */
\f
if (tskId == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS417, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check system task priority */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS418, ERRZERO,
"Invalid system task priority");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS420, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_SINGLE_THREADED */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS421, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_ADD_RES, ESS422, ERRZERO, "Too many system tasks");
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS423, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not initialize demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* initialize the system task entry lock */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS425, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not initialize system task entry lock");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS427, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not create system task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* success, update the table */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS429, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SCreateSTsk */
/* Initialize the lock, return on failure */
if( SInitLock(&(osCp.logger.bufLock),SS_LOCK_MUTEX) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
} /* if */
SLock(&osCp.logger.bufLock);
if( osCp.logger.started == TRUE)
{
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set the mode of the logging */
{
SDisplay(0,"Error Opening Log File \n");
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
strcpy(osCp.logger.filePath,path);
}
{
SDisplay(0, "Error at WSAStartup!\n");
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
osCp.logger.socketdes = socket(AF_INET, SOCK_DGRAM, 0);
WSACleanup();
#endif
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* bind to local address */
localAddr.sin_family = AF_INET;
close(osCp.logger.socketdes);
#endif
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* remote address */
remoteAddr.sin_family = AF_INET;
close(osCp.logger.socketdes);
#endif
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(RFAILED);
+ return RFAILED;
}
remoteAddr.sin_addr.s_addr = inet_addr(IPA);
osCp.logger.remoteAddr = remoteAddr;
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
} /* SRegLogCfg */
/*
{
writeNum = sendto(osCp.logger.socketdes, buffer, cmStrlen((U8 *)buffer), 0, (struct sockaddr*)&osCp.logger.remoteAddr, sizeof(osCp.logger.remoteAddr));
/*ss013.301 : Returned after sending to socket*/
- RETVALUE(ROK);
+ return ROK;
}
osCp.logger.curNumFlush++;
if(osCp.logger.curNumFlush == osCp.logger.maxNumFlush)
/*SPutSBuf(DFLT_REGION,DFLT_POOL,
(Data *)buffer, (Size)(osCp.logger.maxBufSiz * sizeof(S8)));*/
- RETVALUE(ROK);
+ return ROK;
} /* SFlushBufToLog */
/*
if(osCp.logger.started == FALSE)
{
(Void)SUnlock(&(osCp.logger.bufLock));
- RETVALUE(ROK);
+ return ROK;
}
if(osCp.logger.curBufSiz)
{
signal(SIGINT, App_SigExitCallBack);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of SCleanUp */
SCleanUp();
- RETVALUE(ROK);
+ return ROK;
} /* SDeregLogCfg */
cpuInfo->numCores < 1 || cpuInfo->threadsPerCore < 1 )
{
SSLOGERROR(ERRCLS_INT_PAR, ESS430, ERRZERO, "Invalid number of cores\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* lock mCInfo */
/* unlock mCInfo */
SUnlock(&osCp.mCILock);
- RETVALUE(ROK);
+ return ROK;
} /* SRegCpuInfo */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS431, ERRZERO, "Failed to get affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
- RETVALUE(ROK);
+ return ROK;
} /* SGetAffinity */
mode > SS_AFFINITY_MODE_EXCL)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS432, ERRZERO, "Invalid mode for setting core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* check the value of core id */
(coreId > osCp.mCInfo.cpuInfo.numCores || coreId < 0))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS433, ERRZERO, "Invalid core id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* set affinity according to the mode supplied */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS434, ERRZERO, \
"Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS436, ERRZERO,\
"Can not set core affinity, core is exclusively used for other task\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* call the implementation specific affinity function with the core id supplied by caller */
ret = ssdSetAffinity(tskId, coreId);
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS437, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS439, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS441, ERRZERO,
"Can not set core affinity, core is exclusively used for other task\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end else */
tskNotFound = FALSE;
break;
if (coreIndex == SS_MAX_CORES)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS442, ERRZERO, "Invalid core id\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* if */
break;
} /* end case SS_AFFINITY_MODE_ASSOC */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS443, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
if (ret != ROK)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS444, ERRZERO, "Failed to set core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if */
/* lock mCInfo */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS445, ERRZERO,
"Failed to set core affinity, no threads on cores available\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end if no thrs on cores available */
} /* else if */
else
{
SSLOGERROR(ERRCLS_INT_PAR, ESS446, ERRZERO, "Can not set exclusive affinity for the core\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end else */
break;
} /* end case SS_AFFINITY_MODE_EXCL */
default:
{
SSLOGERROR(ERRCLS_INT_PAR, ESS447, ERRZERO, "Invalid mode for setting core affinity\n");
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end default case */
} /* end of switch */
- RETVALUE(ROK);
+ return ROK;
} /* SSetAffinity */
if (tskId >= SS_MAX_STSKS)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS448, (ErrVal) tskId, "Invalid task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS450, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS451, (ErrVal) idx,
"Invalid system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (sTsk->termPend != FALSE)
{
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS452, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS453, (ErrVal) idx,
"Invalid system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS454, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock system task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS456, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS457, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS459, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS460, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not destroy system task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* multi-core support */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS462, ERRZERO,
"Could not unlock the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* SDestroySTsk */
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS463, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
/* check entity and instance range */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS464, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
{
SSLOGERROR(ERRCLS_INT_PAR, ESS465, (ErrVal) sTskId,
"Invalid system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS466, ERRZERO,
"Could not find proc id index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS468, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS469, (ErrVal) sTskId,
"Unknown system task ID");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS470, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock system task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS472, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS473, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS474, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS475, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS477, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS478, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS479, ERRZERO, "Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS480, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS481, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS482, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS483, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
"Could not find proc table index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
(Void)(tTsk->initTsk)(tTsk->proc, tTsk->ent, tTsk->inst, sTsk->region, PWR_UP, &xxCb);
/*
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS484, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS485, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#else /* SS_MULTIPLE_PROCS */
SDetachTTsk(ent, inst);
#endif /* SS_MULTIPLE_PROCS */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SAttachTTsk */
\f
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS486, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
/* check entity and instance ranges */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS487, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS488, ERRZERO,
"Could not find proc id index");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
"Could not lock system task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS490, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS492, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS493, ERRZERO, "Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS494, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS495, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock system task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS497, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
if ( SUnlock(&osCp.sTskTblLock) != ROK)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS498, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS500, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS501, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
*/
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* SDetachTTsk */
\f
if (mBuf == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS502, ERRZERO, "Invalid message buffer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check the pst structure */
{
SPutMsg(mBuf);
SSLOGERROR(ERRCLS_INT_PAR, ESS503, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ss021.103 - Addition to check for valid route */
/* ss023.103 - Modification to fix bug in route validation */
{
SPutMsg(mBuf);
SSLOGERROR(ERRCLS_INT_PAR, ESS504, ERRZERO, "No route defined");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS506, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_INT_PAR, ESS507, ERRZERO,
"Invalid source/destination entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS508, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not lock router task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* call the router activation function */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS510, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS511, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE((r == RFAILED) ? RFAILED : ROK);
+ return ((r == RFAILED) ? RFAILED : ROK);
}
}
#endif /* SS_RTR_SUPPORT */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS512, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS513, ERRZERO, "Unknown task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS514, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
SSLOGERROR(ERRCLS_DEBUG, ESS515, ERRZERO, "Unknown task");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS516, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not lock driver task entry");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef L2_L3_SPLIT
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS519, ERRZERO,
"Could not give the Semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#ifdef L2_L3_SPLIT
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS520, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS521, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not find a driver task to handle this proc ID");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_DRVR_SUPPORT */
/* ss002.301 Modifications */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS512, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS513, ERRZERO, "call back function failed\n");
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef SS_MULTIPLE_PROCS
dstIdx = osCp.tTskIds[dstProcIdIdx][tempPst.dstEnt][tempPst.dstInst];
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS527, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
if( ret != ROK )
{
/* No need to free the buffer, its already done in called fun */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate for the mBuf */
if( workPtr == NULLP )
{
SPutFpaMsg(wqBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Convert the pointers to physical address */
if( ret != ROK )
{
SPutFpaMsg(wqBuf);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Assign the values for work ptr */
cvmx_pow_work_submit(workPtr, workPtr->tag, workPtr->tag_type, \
workPtr->qos, workPtr->grp);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_SEUM_CAVIUM */
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS523, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Destination TAPA task is not attached");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_LOCKLESS_MEMORY
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS525, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
"Could not write to demand queue");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS527, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
#endif
*/
ssdPstTsk(tempPst, mBuf, tTsk);
- RETVALUE(ROK);
+ return ROK;
} /* SPstTsk */
/* ss001.301: additions */
ent[tskCnt] = osCp.tTskTbl[tskCnt].ent;
}
- RETVALUE(ROK);
+ return ROK;
} /* SGetTapaTskEntIds */
/*
"Could not lock TAPA task table");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(tskCnt = 0; tskCnt < osCp.numTTsks; tskCnt++)
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS639, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ROK);
+ return ROK;
} /* SGetTapaTskEntIds */
/*
*hstReg = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* SGetTapaTskEntIds */
#endif /* SS_HISTOGRAM_SUPPORT */
#endif
SPrint(prntBuf);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
/* Implicit watchdog stop during dereg */
SStopHrtBt();
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
ssdStartWatchDgTmr(NULLP, SS_TMR_HRTBT, timeInterval);
ssdSndHrtBtMsg(TRUE, SS_WD_HB_REQ);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
osCp.wdCp.globWd.watchdogStop = 1;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
);
SPrint(prntBuf);
#endif /* DEBUGP */
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
#endif /* DEBUGP */
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_WATCHDOG */
if ((procId == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS463, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
/* check entity and instance range */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS464, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
#endif
ret = SLock(&osCp.sTskTblLock);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (procIdIdx == SS_INV_PROCID_IDX)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
idx = osCp.tTskIds[procIdIdx][ent][inst];
if(tTsk == NULLP )
{
SUnlock(&osCp.sTskTblLock);
- RETVALUE(RFAILED);
+ return RFAILED;
}
*curEvent = osCp.tTskTbl[idx].curEvent;
*curEvtTime = osCp.tTskTbl[idx].curEvtTime;
*sTskId = osCp.tTskTbl[idx].sTsk->tskId;
SUnlock(&osCp.sTskTblLock);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* SS_THREAD_PROFILE */
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrRegHndlr(ent, inst, period, units, ssTmrActvFn);
- RETVALUE(ret);
+ return (ret);
}
#else /* SS_MULTIPLE_PROCS */
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrRegHndlr(proc, ent, inst, period, units, ssTmrActvFn);
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_MULTIPLE_PROCS */
ssTmrActvFn.mtFlag = TRUE;
ret = STmrRegHndlr(ent, inst, period, units, ssTmrActvFn);
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_MT_TMR */
#endif /* not SS_MULTIPLE_PROCS */
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS528, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS529, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
if (period <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS530, ERRZERO, "Invalid period");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check period units*/
if ((units < 1) || (units > SS_TICKS_SEC))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS531, ERRZERO, "Invalid period units");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(ssTmrActvFn.mtFlag == TRUE)
if (ssTmrActvFn.actvFnc.tmrActvFnMt == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS532, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
#else
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
else
if (ssTmrActvFn.actvFnc.tmrActvFn == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS532, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
SSLOGERROR(ERRCLS_INT_PAR, ESS533, ERRZERO,
"Could not find proc id index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
{
SSLOGERROR(ERRCLS_DEBUG, ESS534, ERRZERO,
"Could not lock TAPA task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MULTIPLE_PROCS
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS535, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS536, ERRZERO, "Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( SS_RELEASE_SEMA(&osCp.tTskTblSem) != ROK)
{
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS537, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS538, (ErrVal) ret,
"Could not lock timer table");
#endif
- RETVALUE(ret);
+ return (ret);
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS539, ERRZERO,
"Could not unlock the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS540, ERRZERO, "Too many timers");
#endif
- RETVALUE(ROUTRES);
+ return (ROUTRES);
}
#if (ERRCLASS & ERRCLS_INT_PAR)
{
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS541, ERRZERO, "Could not unlock the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS542, ERRZERO,
"Could not unlock the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ret);
+ return (ret);
}
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrDeregHndlr(ent, inst, period, units, ssTmrActvFn);
- RETVALUE(ret);
+ return (ret);
}
#else /* SS_MULTIPLE_PROCS */
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
ret = STmrDeregHndlr(proc, ent, inst, period, units, ssTmrActvFn);
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_MULTIPLE_PROCS */
ret = STmrDeregHndlr(ent, inst, period, units, ssTmrActvFn);
- RETVALUE(ret);
+ return (ret);
}
#endif /* SS_MT_TMR */
#endif /* not SS_MULTIPLE_PROCS */
if ((proc == SS_INV_PROCID) || (ent >= SS_MAX_ENT) || (inst >= SS_MAX_INST))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS543, ERRZERO, "Invalid processor/entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else /* SS_MULTIPLE_PROCS */
if (ent >= SS_MAX_ENT || inst >= SS_MAX_INST)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS544, ERRZERO, "Invalid entity/instance");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
/* check period */
if (period <= 0)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS545, ERRZERO, "Invalid period");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check period units */
if ((units < 1) || (units > SS_TICKS_SEC))
{
SSLOGERROR(ERRCLS_INT_PAR, ESS546, ERRZERO, "Invalid period units");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* check timer function */
if (ssTmrActvFn.actvFnc.tmrActvFnMt == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS547, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
#else
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
if (ssTmrActvFn.actvFnc.tmrActvFn == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS547, ERRZERO, "Null pointer");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
SSLOGERROR(ERRCLS_INT_PAR, ESS548, ERRZERO,
"Could not find proc id index");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* SS_MULTIPLE_PROCS */
{
SSLOGERROR(ERRCLS_DEBUG, ESS549, ERRZERO,
"Could not lock TAPA task table");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef SS_MULTIPLE_PROCS
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS550, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_INT_PAR, ESS551, ERRZERO, "Unknown task");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ( SS_RELEASE_SEMA(&osCp.tTskTblSem) != ROK)
{
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS552, ERRZERO,
"Could not release the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS553, (ErrVal) ret,
"Could not lock timer table");
#endif
- RETVALUE(ret);
+ return (ret);
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS554, ERRZERO,
"Could not unlock the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
SSLOGERROR(ERRCLS_DEBUG, ESS555, ERRZERO, "Could not locate timer");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS556, ERRZERO,
"Could not unlock the semaphore");
- RETVALUE(RFAILED);
+ return RFAILED;
#endif
}
- RETVALUE(ret);
+ return (ret);
}
/**********************************************************************
{
Buffer *mBuf;
- if(SGetMsg(region, pool, &mBuf) == ROK)
+ if(ODU_GET_MSG(region, pool, &mBuf) == ROK)
{
- if(SAddPstMsgMult((Data *)encBuf, encBufSize, mBuf) == ROK)
+ if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
{
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
if(sctpSend(mBuf) != ROK)
{
DU_LOG("\nE2AP : SCTP Send for E2 failed");
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
}
else
{
- DU_LOG("\nE2AP : SAddPstMsgMult failed");
- SPutMsg(mBuf);
+ DU_LOG("\nE2AP : ODU_ADD_POST_MSG_MULT failed");
+ ODU_PUT_MSG(mBuf);
return RFAILED;
}
- SPutMsg(mBuf);
+ ODU_PUT_MSG(mBuf);
}
else
{
setupItems->ricActionType = RICactionType_report;
}
- RETVALUE(setupItems);
+ return (setupItems);
}
/*******************************************************************
E2AP_PDU_t e2apasnmsg ;
DU_LOG("\nE2AP : Received E2AP message buffer");
- SPrntMsg(mBuf, 0,0);
+ ODU_PRINT_MSG(mBuf, 0,0);
/* Copy mBuf into char array to decode it */
- SFndLenMsg(mBuf, &recvBufLen);
- if(SGetSBuf(DFLT_REGION, DFLT_POOL, (Data **)&recvBuf, (Size)recvBufLen) != ROK)
+ ODU_FIND_MSG_LEN(mBuf, &recvBufLen);
+ RIC_ALLOC(recvBuf, (Size)recvBufLen);
+
+ if(recvBuf == NULLP)
{
DU_LOG("\nE2AP : Memory allocation failed");
return;
}
- if(SCpyMsgFix(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
+ if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, ©Cnt) != ROK)
{
DU_LOG("\nE2AP : Failed while copying %d", copyCnt);
return;
memset(e2apMsg, 0, sizeof(E2AP_PDU_t));
rval = aper_decode(0, &asn_DEF_E2AP_PDU, (void **)&e2apMsg, recvBuf, recvBufLen, 0, 0);
- SPutSBuf(DFLT_REGION, DFLT_POOL, (Data *)recvBuf, (Size)recvBufLen);
+ RIC_FREE(recvBuf, (Size)recvBufLen);
+
if(rval.code == RC_FAIL || rval.code == RC_WMORE)
{
DU_LOG("\nE2AP : ASN decode failed");
*
* ****************************************************************/
-S16 tst()
+uint8_t tst()
{
init_log();
{
DU_LOG("\nSCTP: Polling failed to start at RIC");
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
*
ret = RFAILED;
}
- RETVALUE(ret);
+ return (ret);
}
/*******************************************************************
DU_LOG("\nSCTP : Failed to RecvMsg for E2 at RIC \n");
}
};
- RETVALUE(ret);
+ return (ret);
}/* End of sctpSockPoll() */
/*******************************************************************
else if(connUp & (pollParams->port == ricParams.destPort))
{
E2APMsgHdlr(pollParams->mBuf);
- SPutMsg(pollParams->mBuf);
+ ODU_PUT_MSG(pollParams->mBuf);
}
else
{
- SPutMsg(pollParams->mBuf);
+ ODU_PUT_MSG(pollParams->mBuf);
}
}
}
Code Review / o-du / l2.git / commitdiff