static int RLOG_FILE_ID=177;
/* header include files -- defines (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system service interface */
-#include "cm_hash.h" /* common hash list */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
+#include "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "tfu.h"
#include "rl_common.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
#include "tfu.x" /* TFU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "rgr.x" /* layer management typedefs for MAC */
RgSchCellCb *cell,
RgInfCmnBoRpt *boUpdt
));
+#ifdef UNUSE_FUN
#ifdef TFU_UPGRADE
PRIVATE U8 rgSCHUtlFetchPcqiBitSz ARGS((
RgSchCellCb *cell,
U8 numTxAnt
));
#endif
+#endif
/* sorted in ascending order of tbSz */
CONSTANT struct rgSchUtlBcchPcchTbSz
{
{
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);
}
{
U8 *byte;
U8 offset;
- U8 mask;
+ uint16_t mask;
TRC2(rgSCHUtlPdcchPut);
*
* Function: rgSCHUtlPdcchInit
* Purpose: This function initializes PDCCH information for
- * a subframe. It removes the list of PDCCHs allocated
- * in the prior use of this subframe structure.
+ * a slot. It removes the list of PDCCHs allocated
+ * in the prior use of this slot structure.
*
* Invoked by: rgSCHUtlSubFrmPut
*
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;
}
/**
- * @brief This function release RNTP pattern from subFrame and Cell
+ * @brief This function release RNTP pattern from slot and Cell
* @details
*
* Function: rgSchDSFRRntpInfoFree
rntpPtr->len = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @details
*
* Function: rgSCHSFRUtlTotalPooReset
- * Purpose: Update the dynamic variables in each pool as they will be modified in each subframe.
+ * Purpose: Update the dynamic variables in each pool as they will be modified in each slot.
* Dont modify the static variables like startRB, endRB, BW
* Invoked by: rgSCHUtlSubFrmPut
*
*
* Function: rgSCHUtlAddPhich
* Purpose: This function appends PHICH information for
- * a subframe.
+ * a slot.
*
* Invoked by: TOM
*
{
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 */
/**
*
* Function: rgSCHUtlPhichReset
* Purpose: This function initializes PHICH information for
- * a subframe. It removes the list of PHICHs allocated
- * in the prior use of this subframe structure.
+ * a slot. It removes the list of PHICHs allocated
+ * in the prior use of this slot structure.
*
* Invoked by: rgSCHUtlSubFrmPut
*
\f
/**
- * @brief This function returns subframe data structure for a cell
+ * @brief This function returns slot data structure for a cell
*
* @details
*
* Function: rgSCHUtlSubFrmGet
- * Purpose: This function resets the subframe data structure
- * when the subframe is released
+ * Purpose: This function resets the slot data structure
+ * when the slot is released
*
* Invoked by: scheduler
*
sf = cell->subFrms[dlIdx];
#else
/* Changing the idexing
- so that proper subframe is selected */
- dlIdx = (((frm.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (frm.subframe % RGSCH_NUM_SUB_FRAMES));
+ so that proper slot is selected */
+ dlIdx = (((frm.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (frm.slot % RGSCH_NUM_SUB_FRAMES));
RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
sf = cell->subFrms[dlIdx];
#endif
/* CA dev Start */
sf->dlIdx = dlIdx;
/* CA dev End */
- RETVALUE(sf);
+ return (sf);
}
\f
/**
- * @brief This function returns subframe data structure for a cell
+ * @brief This function returns slot data structure for a cell
*
* @details
*
* Function: rgSCHUtlSubFrmPut
- * Purpose: This function resets the subframe data structure
- * when the subframe is released
+ * Purpose: This function resets the slot data structure
+ * when the slot is released
*
* Invoked by: scheduler
*
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
#ifdef LTE_TDD
/**
- * @brief This function initialises the PRACH subframe occasions
+ * @brief This function initialises the PRACH slot occasions
*
* @details
*
* Function: rgSCHUtlUpdPrachOcc
- * Purpose: This function updates the PRACH subframes based on
+ * Purpose: This function updates the PRACH slots based on
* RGR configuration.
*
* Invoked by: Scheduler
for(idx = startIdx; idx < endIdx; idx++)
{
if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][idx]
- == RG_SCH_TDD_UL_SUBFRAME)
+ == RG_SCH_TDD_UL_slot)
{
if(cellCfg->ulStartSfIdx == count)
{
size = cell->rachCfg.raOccasion.size;
- cell->rachCfg.raOccasion.subFrameNum[size] = idx;
+ cell->rachCfg.raOccasion.slotNum[size] = idx;
cell->rachCfg.raOccasion.size++;
break;
}
cell->rachCfg.raOccasion.size = 0;
- /* Update subframe occasions */
+ /* Update slot occasions */
for(idx = 0; idx < cellCfg->prachRscInfo.numRsc; idx++)
{
if(cellCfg->prachRscInfo.prachInfo[idx].freqIdx == 0)
RGR_TDD_SPL_UL_IDX)
{
subfrmIdx = cell->rachCfg.raOccasion.size;
- cell->rachCfg.raOccasion.subFrameNum[subfrmIdx] = splFrm;
+ cell->rachCfg.raOccasion.slotNum[subfrmIdx] = splFrm;
cell->rachCfg.raOccasion.size++;
}
else
*
* Function: rgSCHUtlRgrCellCfg
* Purpose: This function initialises the cell with RGR configuration
- * and subframe related initialization.
+ * and slot related initialization.
*
* Invoked by: Scheduler
*
RgSchDlSf *sf;
CmLteTimingInfo frm;
U8 ulDlCfgIdx = cellCfg->ulDlCfgIdx;
- U8 maxSubframes ;
- U8 maxDlSubframes;
+ U8 maxslots ;
+ U8 maxDlslots;
S16 ret = ROK;
U16 bw; /*!< Number of RBs in the cell */
cmMemset((U8 *)&frm,0,sizeof(CmLteTimingInfo));
/* ccpu00132657-MOD- Determining DLSF array size independent of DELTAS */
- maxDlSubframes = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
- maxSubframes = 2 * maxDlSubframes;
- cell->numDlSubfrms = maxSubframes;
+ maxDlslots = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
+ maxslots = 2 * maxDlslots;
+ cell->numDlSubfrms = maxslots;
/* ACC-TDD <ccpu00130639> */
cell->tddHqSfnCycle = -1;
cell->ulDlCfgIdx = ulDlCfgIdx;
bw = cell->bwCfg.dlTotalBw;
rgSCHUtlAllocSBuf(cell->instIdx,
- (Data **)&cell->subFrms, sizeof(RgSchDlSf *) * maxSubframes);
+ (Data **)&cell->subFrms, sizeof(RgSchDlSf *) * maxslots);
if (cell->subFrms == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Create memory for each frame. */
- for(i = 0; i < maxSubframes; i++)
+ for(i = 0; i < maxslots; i++)
{
while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] ==
- RG_SCH_TDD_UL_SUBFRAME)
+ RG_SCH_TDD_UL_slot)
{
sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
}
cell->subFrms[i] = sf;
sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
}
- if (i != maxSubframes)
+ if (i != maxslots)
{
for (; i > 0; i--)
{
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
- (Data **)(&(cell->subFrms)), sizeof(RgSchDlSf *) * maxSubframes);
+ (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 subframes and thereby perform the initialization */
- for (i = 0; i < maxSubframes; i++)
+ /* Release the slots and thereby perform the initialization */
+ for (i = 0; i < maxslots; i++)
{
- if((i > 0) && (i%maxDlSubframes == 0))
+ if((i > 0) && (i%maxDlslots == 0))
{
sfn++;
}
frm.sfn = sfn;
- frm.subframe = cell->subFrms[i]->sfNum;
+ frm.slot = cell->subFrms[i]->sfNum;
rgSCHUtlDlRlsSubFrm(cell, frm);
}
- RETVALUE(ret);
+ return (ret);
}
#else
* @details
*
* Function: rgSCHUtlRgrCellCfg
- * Purpose: This function creates the subframes needed for the
+ * Purpose: This function creates the slots needed for the
* cell. It then peforms init of the scheduler by calling
* scheduler specific cell init function.
*
cell->noOfRbgs = RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize);
/* Create memory for each frame. */
/* Changing loop limit from
- RGSCH_NUM_SUB_FRAMES to RGSCH_NUM_DL_SUBFRAMES */
- for(i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
+ RGSCH_NUM_SUB_FRAMES to RGSCH_NUM_DL_slotS */
+ for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
{
rgSCHUtlAllocSBuf(inst, (Data **)&sf, sizeof(RgSchDlSf));
if (sf == NULLP)
/*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;
/* LTE_ADV_FLAG_REMOVED_END */
/* Changing loop limit from
- RGSCH_NUM_SUB_FRAMES to RGSCH_NUM_DL_SUBFRAMES */
- if (i != RGSCH_NUM_DL_SUBFRAMES)
+ RGSCH_NUM_SUB_FRAMES to RGSCH_NUM_DL_slotS */
+ if (i != RGSCH_NUM_DL_slotS)
{
for (; i > 0; i--)
{
rgSCHLaaDeInitDlSfCb(cell, sf);
#endif
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell->sc.apis == NULLP)
cell->sc.apis = &rgSchCmnApis;
}
- /* Release the subframes and thereby perform the initialization */
- for (i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
+ /* Release the slots and thereby perform the initialization */
+ for (i = 0; i < RGSCH_NUM_DL_slotS; i++)
{
if (i >= RGSCH_NUM_SUB_FRAMES)
{
it to one */
frm.sfn = 1;
}
- frm.subframe = i % RGSCH_NUM_SUB_FRAMES;
+ frm.slot = i % RGSCH_NUM_SUB_FRAMES;
rgSCHUtlDlRlsSubFrm(cell, frm);
}
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));
}
* Function: rgSCHUtlFreeCell
* Purpose: This function updates the value of Y stored in the
* UE control block. It uses the previously computed
- * value for computing for this subframe.
+ * value for computing for this slot.
*
* Invoked by: Scheduler
*
RgSchPhichInfo *phichInfo;
RgSchPhich *phich;
Inst inst = cell->instIdx;
- U8 maxSubframes;
+ U8 maxslots;
#ifdef LTE_TDD
RgSchRaReqInfo *raReqInfo;
U8 idx;
TRC2(rgSCHUtlFreeCell);
#ifdef LTE_TDD
- maxSubframes = cell->numDlSubfrms;
+ maxslots = cell->numDlSubfrms;
#else
- maxSubframes = RGSCH_NUM_DL_SUBFRAMES;
+ maxslots = RGSCH_NUM_DL_slotS;
#endif
/* Invoke the index for scheduler, cell deletion */
cell->sc.apis->rgSCHFreeCell(cell);
- /* Release the subframes allocated */
- for (i = 0; i < maxSubframes; i++)
+ /* Release the slots allocated */
+ for (i = 0; i < maxslots; i++)
{
#ifdef LTE_ADV
rgSCHLaaDeInitDlSfCb(cell, cell->subFrms[i]);
rgSCHUtlFreeSBuf(inst, (Data **)(&(cell->subFrms[i])), sizeof(RgSchDlSf));
}
#ifdef LTE_TDD
- /* Release the subframe pointers */
+ /* Release the slot pointers */
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst,
- (Data **) (&(cell->subFrms)), sizeof(RgSchDlSf *) * maxSubframes);
+ (Data **) (&(cell->subFrms)), sizeof(RgSchDlSf *) * maxslots);
for(idx=0; idx < cell->raInfo.lstSize; idx++)
{
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 */
/**
* @details
*
* Function: rgSCHUtlDlHqPTbAddToTx
- * Purpose: This function a HarqProcess TB to the subframe
+ * Purpose: This function a HarqProcess TB to the slot
* list.
*
* Invoked by: Scheduler
* @details
*
* Function: rgSCHUtlDlHqPTbRmvFrmTx
- * Purpose: This function removes a HarqProcess TB to the subframe
+ * Purpose: This function removes a HarqProcess TB to the slot
* list.
*
* Invoked by: Scheduler
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 */
*
* Function: rgSCHUtlUlHqProcForUe
* Purpose: This function returns the harq process for
- * which data is expected in the current subframe.
+ * which data is expected in the current slot.
* It does not validate if the HARQ process
* has an allocation.
*
*
* Function: rgSCHUtlFirstRcptnReq(cell)
* Purpose: This function returns the first uplink allocation
- * (or NULLP if there is none) in the subframe
+ * (or NULLP if there is none) in the slot
* in which is expected to prepare and send reception
* request to PHY.
*
#endif
{
TRC2(rgSCHUtlFirstRcptnReq);
- RETVALUE(cell->sc.apis->rgSCHFirstRcptnReq(cell));
+ return (cell->sc.apis->rgSCHFirstRcptnReq(cell));
}
/**
*
* Function: rgSCHUtlNextRcptnReq(cell)
* Purpose: This function returns the next uplink allocation
- * (or NULLP if there is none) in the subframe
+ * (or NULLP if there is none) in the slot
* in which is expected to prepare and send reception
* request to PHY.
*
#endif
{
TRC2(rgSCHUtlNextRcptnReq);
- RETVALUE(cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
+ return (cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
}
/**
*
* Function: rgSCHUtlFirstHqFdbkAlloc
* Purpose: This function returns the first uplink allocation
- * (or NULLP if there is none) in the subframe
+ * (or NULLP if there is none) in the slot
* in which it is expected to prepare and send HARQ
* feedback to PHY.
*
#endif
{
TRC2(rgSCHUtlFirstHqFdbkAlloc);
- RETVALUE(cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
+ return (cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
}
\f
*
* Function: rgSCHUtlNextHqFdbkAlloc(cell)
* Purpose: This function returns the next uplink allocation
- * (or NULLP if there is none) in the subframe
+ * (or NULLP if there is none) in the slot
* for which HARQ feedback needs to be sent.
*
* Invoked by: TOM
#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 */
*
* Func : rgSCHUtlResetSfAlloc
*
- * Desc : Utility Function to Reset subframe allocation information.
+ * Desc : Utility Function to Reset slot allocation information.
*
*
* Ret : ROK
{
sfAlloc->cmnLcInfo.bitMask = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
* Func : rgSCHUtlGetRlsHqAlloc
*
- * Desc : Utility Function to Allocate subframe allocation information.
+ * Desc : Utility Function to Allocate slot allocation information.
*
*
* Ret : ROK
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
"UE Alloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
*
* Func : rgSCHUtlPutRlsHqAlloc
*
- * Desc : Utility Function to deallocate subframe allocation information.
+ * Desc : Utility Function to deallocate slot allocation information.
*
*
* Ret : ROK
}
}
- RETVALUE(ROK);
+ return ROK;
}
*
* Func : rgSCHUtlGetSfAlloc
*
- * Desc : Utility Function to Allocate subframe allocation information.
+ * Desc : Utility Function to Allocate slot allocation information.
*
*
* Ret : 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;
}
*
* Func : rgSCHUtlPutSfAlloc
*
- * Desc : Utility Function to deallocate subframe allocation information.
+ * Desc : Utility Function to deallocate slot allocation information.
*
*
* Ret : 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
* from the pdcch DCI info.
- * subframe
+ * slot
*
* @details
*
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 */
CmLteTimingInfo frm;
- /* Get Downlink Subframe */
+ /* Get Downlink slot */
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
/* 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)
{
/* Added for dropping paging Message*/
/*suman*/
- if ((rgSCHChkBoUpdate(cell,boUpdt))== ROK) /* Checking if received BO falls within the window of 5120 subframes*/
+ if ((rgSCHChkBoUpdate(cell,boUpdt))== ROK) /* Checking if received BO falls within the window of 5120 slots*/
{
if (rgSCHUtlGetAllwdCchTbSz(boUpdt->bo*8, &nPrb, &mcs)
!= (boUpdt->bo*8))
{
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*/
#endif
{
Pst cfmPst;
- Inst inst;
+ Inst inst = 0;
TRC2(schSendCfgCfm)
cmMemset((U8 *)(&cfmPst), 0, sizeof(Pst));
cfmPst.dstEnt = (Ent)ENTRG;
cfmPst.dstInst = (Inst) 0;
cfmPst.dstProcId = SFndProcId();
- cfmPst.selector = RGR_SEL_LC;
+ cfmPst.selector = ODU_SELECTOR_LC;
cfmPst.region = reg;
cfmPst.pool = pool;
if(RgUiRgrCfgCfm(&cfmPst,transId, status) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"schSendCfgCfm: RgUiRgrCfgCfm Failed ");
+ 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 */
/**
TRC2(rgSCHUtlInitUeANFdbkInfo);
anFdInfo->sfn = RGSCH_MAX_SFN+1; /* defensively setting invalid sfn */
- anFdInfo->subframe = 0;
+ anFdInfo->slot = 0;
anFdInfo->ulDai = RG_SCH_INVALID_DAI_VAL;
anFdInfo->dlDai = RG_SCH_INVALID_DAI_VAL;
anFdInfo->latestMIdx = RG_SCH_INVALID_M_VAL;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlInitUeANFdbkInfo */
/**
* Function : rgSCHUtlGetUeANFdbkInfo
*
* It gets the UE related ACK NACK information based on
- * SFN and subframe number.
+ * SFN and slot number.
*
* @param[in] RgSchUeCb *ueCb
* @param[in] CmLteTimingInfo *time
for (idx = 0; idx < ueCb->cell->ackNackFdbkArrSize; ++idx)
{
if( (timeInfo->sfn == ueCb->cellInfo[servCellIdx]->anInfo[idx].sfn) &&
- (timeInfo->subframe == ueCb->cellInfo[servCellIdx]->anInfo[idx].subframe))
+ (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 */
/**
- * @brief To get downlink subframe index
+ * @brief To get downlink slot index
*
* @details
*
* Function: rgSCHUtlGetDlSfIdx
- * Purpose: Gets downlink subframe index based on SFN and subframe no
+ * Purpose: Gets downlink slot index based on SFN and slot no
*
* @param[in] CmLteTimingInfo *timeInfo
* @param[in] RgSchCellCb *cell
idx = RGSCH_NUM_SUB_FRAMES - \
rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
idx = ((idx * timeInfo->sfn) + \
- rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][timeInfo->subframe]) - 1;
+ rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][timeInfo->slot]) - 1;
idx = idx % cell->numDlSubfrms;
- RETVALUE((U8)idx);
+ return ((U8)idx);
}
/**
- * @brief To get the next downlink subframe
+ * @brief To get the next downlink slot
*
* @details
*
* Function: rgSCHUtlGetNxtDlSfInfo
- * Purpose: Gets next downlink subframe based on current DL subframe
+ * Purpose: Gets next downlink slot based on current DL slot
*
* @param[in] CmLteTimingInfo curDlTime
* @param[in] RgSchCellCb *cell
CmLteTimingInfo *nxtDlTime;
#endif
{
- U16 idx = curDlTime.subframe;
+ U16 idx = curDlTime.slot;
U8 count = 0;
TRC2(rgSCHUtlGetNxtDlSfInfo);
idx = (idx + 1) % RGSCH_NUM_SUB_FRAMES;
count++;
}while(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][idx]
- != RG_SCH_TDD_DL_SUBFRAME);
+ != RG_SCH_TDD_DL_slot);
RG_SCH_ADD_TO_CRNT_TIME(curDlTime, (*nxtDlTime), count);
*nxtDlsf = rgSCHUtlSubFrmGet(cell, *nxtDlTime);
- if(dlSf->dlFdbkInfo.subframe != (*nxtDlsf)->dlFdbkInfo.subframe)
+ if(dlSf->dlFdbkInfo.slot != (*nxtDlsf)->dlFdbkInfo.slot)
{
break;
}
}
/**
- * @brief To get the previous downlink subframe
+ * @brief To get the previous downlink slot
*
* @details
*
* Function: rgSCHUtlGetPrevDlSfInfo
- * Purpose: Gets previous downlink subframe based on current DL subframe
+ * Purpose: Gets previous downlink slot based on current DL slot
*
* @param[in] RgSchCellCb *cell
* @param[in] CmLteTimingInfo curDlTime
U8 *numSubfrm;
#endif
{
- S16 idx = curDlTime.subframe;
+ S16 idx = curDlTime.slot;
U8 count = 0;
TRC2(rgSCHUtlGetPrevDlSfInfo);
}
count++;
}while(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][idx]
- != RG_SCH_TDD_DL_SUBFRAME);
+ != RG_SCH_TDD_DL_slot);
*numSubfrm = count;
RGSCHDECRFRMCRNTTIME(curDlTime, (*prevDlTime), count);
RETVOID;
*
* Func : rgSCHUtlUlSfInit
*
- * Desc : UL subframe init.
+ * Desc : UL slot init.
*
* Ret : S16
*
#ifdef LTE_TDD
if(cell->ulDlCfgIdx == 0)
{
- /* Store the Uplink subframe number corresponding to the idx */
+ /* Store the Uplink slot number corresponding to the idx */
sf->ulSfIdx = rgSchTddCfg0UlSfTbl[idx%6];
}
#endif
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);
}
*
* Func : rgSCHUtlUlSfDeinit
*
- * Desc : Deinitialises a subframe
+ * Desc : Deinitialises a slot
*
* Ret : Void
*
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);
}
/***********************************************************
*
* Func : rgSCHUtlUlAllocFirst
*
- * Desc : Get first alloc in subframe
+ * Desc : Get first alloc in slot
*
* Ret : RgSchUlAlloc *
*
#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 */
/***********************************************************
{
/*Stop the DRX retransmission timer as UE scheduled for retx. Here
* we stop the timer and inactivate the UE for both UL and DL.
- * This may result in loss of one subframe for UL but this trade
+ * This may result in loss of one slot for UL but this trade
* off is taken to avoid the overhead of maintaining a list of UEs
- * to be inactivated in the next subframe.*/
+ * to be inactivated in the next slot.*/
drxHq = RG_SCH_DRX_GET_DL_HQ(dlHq);
drxUe = RG_SCH_DRX_GET_UE(ueCb);
if(drxHq->reTxIndx != DRX_INVALID)
}
}/*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 */
if(cell->prbUsage.rprtPeriod >= RGSCH_NUM_SUB_FRAMES)
{
- /* Get the total number of DL and UL subframes within the reporting period*/
+ /* Get the total number of DL and UL slots within the reporting period*/
numDlSf = (cell->prbUsage.rprtPeriod *
rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1])
/ RGSCH_NUM_SUB_FRAMES;
}
else
{
- /* Get the total number of DL and UL subframes < 10 ms interval */
- numDlSf = rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][frm.subframe];
- numUlSf = rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][frm.subframe];
+ /* Get the total number of DL and UL slots < 10 ms interval */
+ numDlSf = rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][frm.slot];
+ numUlSf = rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][frm.slot];
}
#else
numDlSf = cell->prbUsage.rprtPeriod;
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 */
U32 distance = 0;
TRC2(rgSCHChkBoUpdate);
- crntTimeInSubFrms = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.subframe +
+ crntTimeInSubFrms = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.slot +
RG_SCH_CMN_DL_DELTA + 2; /* As bo received will scheduled in next TTI
so incrementing with +1 more */
- boUpdTimeInSubFrms = (boUpdt->u.timeToTx.sfn * RGSCH_NUM_SUB_FRAMES_5G)+ boUpdt->u.timeToTx.subframe;
+ boUpdTimeInSubFrms = (boUpdt->u.timeToTx.sfn * RGSCH_NUM_SUB_FRAMES_5G)+ boUpdt->u.timeToTx.slot;
distance = boUpdTimeInSubFrms > crntTimeInSubFrms ? \
if (distance > RGSCH_PCCHBCCH_WIN)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHChkBoUpdate*/
{
iPhich = 1;
}
- if(phichTime.subframe == 0 || phichTime.subframe == 5)
+ if(phichTime.slot == 0 || phichTime.slot == 5)
{
if(iPhich == 0)
{
{
/* Retx will happen at n+7 */
RGSCHCMNADDTOCRNTTIME(phichTime, phichTime, 7);
- /* Fetch the corresponding UL subframe Idx in UL sf array */
+ /* Fetch the corresponding UL slot Idx in UL sf array */
reTxIdx = rgSCHCmnGetUlSfIdx(&phichTime, cell);
}
}
- else if(phichTime.subframe == 1 || phichTime.subframe == 6)
+ else if(phichTime.slot == 1 || phichTime.slot == 6)
{
/* Retx will happen at n+7 */
RGSCHCMNADDTOCRNTTIME(phichTime, phichTime, 7);
- /* Fetch the corresponding UL subframe Idx in UL sf array */
+ /* Fetch the corresponding UL slot Idx in UL sf array */
reTxIdx = rgSCHCmnGetUlSfIdx(&phichTime, cell);
}
- RETVALUE(reTxIdx);
+ return (reTxIdx);
}
#endif
RETVOID;
} /* rgSchUtlCalcTotalPrbReq */
+#ifdef UNUSE_FUN
#ifdef TFU_UPGRADE
/***********************************************************
*
break;
}
- RETVALUE(pcqiSz);
+ return (pcqiSz);
}
#endif
+#endif
/**
* @brief Utility function to returns the number of subbands based on the
* requested bytes.
//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);
}
/**
RgSchCmnCell *cellSch;
U8 maxUeNewDlTxPerTti;
U8 maxUeNewUlTxPerTti;
- U8 tmpSubFrame = 0;
+ U8 tmpslot = 0;
#ifdef CPU_OL_DBG_PRINTS
U8 idx = 0;
#endif
/* Decrement till 90% of maxUeNewDlTxPerTti */
if ( cpuInstr->dlNxtIndxDecNumUeTti < maxDlDecCnt )
{
- tmpSubFrame = (cpuInstr->dlNxtIndxDecNumUeTti) % 10;
+ tmpslot = (cpuInstr->dlNxtIndxDecNumUeTti) % 10;
cpuInstr->dlNxtIndxDecNumUeTti++;
- if ( cpuInstr->maxUeNewTxPerTti[tmpSubFrame] > 1 )
+ if ( cpuInstr->maxUeNewTxPerTti[tmpslot] > 1 )
{
- cpuInstr->maxUeNewTxPerTti[tmpSubFrame]--;
+ cpuInstr->maxUeNewTxPerTti[tmpslot]--;
}
else
{
if ( cpuInstr->dlNxtIndxDecNumUeTti > 0)
{
cpuInstr->dlNxtIndxDecNumUeTti--;
- tmpSubFrame = (cpuInstr->dlNxtIndxDecNumUeTti) % 10;
- if ( cpuInstr->maxUeNewTxPerTti[tmpSubFrame] < maxUeNewDlTxPerTti )
+ tmpslot = (cpuInstr->dlNxtIndxDecNumUeTti) % 10;
+ if ( cpuInstr->maxUeNewTxPerTti[tmpslot] < maxUeNewDlTxPerTti )
{
- cpuInstr->maxUeNewTxPerTti[tmpSubFrame]++;
+ cpuInstr->maxUeNewTxPerTti[tmpslot]++;
}
else
{
/* Decrement till 90% of maxUeNewDlTxPerTti */
if ( cpuInstr->ulNxtIndxDecNumUeTti < maxUlDecCnt )
{
- tmpSubFrame = (cpuInstr->ulNxtIndxDecNumUeTti) % 10;
+ tmpslot = (cpuInstr->ulNxtIndxDecNumUeTti) % 10;
cpuInstr->ulNxtIndxDecNumUeTti++;
- if ( cpuInstr->maxUeNewRxPerTti[tmpSubFrame] > 1 )
+ if ( cpuInstr->maxUeNewRxPerTti[tmpslot] > 1 )
{
- cpuInstr->maxUeNewRxPerTti[tmpSubFrame]--;
+ cpuInstr->maxUeNewRxPerTti[tmpslot]--;
}
else
{
if ( cpuInstr->ulNxtIndxDecNumUeTti > 0)
{
cpuInstr->ulNxtIndxDecNumUeTti--;
- tmpSubFrame = (cpuInstr->ulNxtIndxDecNumUeTti) % 10;
- if ( cpuInstr->maxUeNewRxPerTti[tmpSubFrame] < maxUeNewUlTxPerTti )
+ tmpslot = (cpuInstr->ulNxtIndxDecNumUeTti) % 10;
+ if ( cpuInstr->maxUeNewRxPerTti[tmpslot] < maxUeNewUlTxPerTti )
{
- cpuInstr->maxUeNewRxPerTti[tmpSubFrame]++;
+ cpuInstr->maxUeNewRxPerTti[tmpslot]++;
}
else
{
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
/**********************************************************************