{
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
/**********************************************************************
Code Review / o-du / l2.git / blobdiff