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