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 */
EXTERN U32 rgSchCmnBetaCqiOffstTbl[16];
EXTERN U32 rgSchCmnBetaRiOffstTbl[16];
EXTERN RgSchdApis rgSchCmnApis;
-EXTERN PUBLIC S16 RgUiRgmSendPrbRprtInd ARGS((
+EXTERN S16 RgUiRgmSendPrbRprtInd ARGS((
Pst* pst,
SuId suId,
RgmPrbRprtInd *prbRprtInd
));
-EXTERN PUBLIC S16 RgUiRgmSendTmModeChangeInd ARGS((
+EXTERN S16 RgUiRgmSendTmModeChangeInd ARGS((
Pst* pst,
SuId suId,
RgmTransModeInd *txModeChngInd
));
#ifdef EMTC_ENABLE
-EXTERN PUBLIC S16 rgSCHEmtcUtlGetSfAlloc ARGS((
+EXTERN S16 rgSCHEmtcUtlGetSfAlloc ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC S16 rgSCHEmtcUtlPutSfAlloc ARGS((
+EXTERN S16 rgSCHEmtcUtlPutSfAlloc ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHEmtcUtlUpdUeDciSize ARGS((
+EXTERN Void rgSCHEmtcUtlUpdUeDciSize ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb
));
-EXTERN PUBLIC Void rgSCHEmtcGetDciFrmt61ASize ARGS((
+EXTERN Void rgSCHEmtcGetDciFrmt61ASize ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHEmtcGetDciFrmt60ASize ARGS((
+EXTERN Void rgSCHEmtcGetDciFrmt60ASize ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC S16 rgSCHEmtcUtlFillPdschDciInfo ARGS((
+EXTERN S16 rgSCHEmtcUtlFillPdschDciInfo ARGS((
TfuPdschDciInfo *pdsch,
TfuDciInfo *pdcchDci
));
-EXTERN PUBLIC Void rgSCHEmtcUtlRlsRnti ARGS((
+EXTERN Void rgSCHEmtcUtlRlsRnti ARGS((
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
U8 *isLegacy
));
-EXTERN PUBLIC S16 rgSCHEmtcPdcchAlloc ARGS((
+EXTERN S16 rgSCHEmtcPdcchAlloc ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch
));
-EXTERN PUBLIC Void rgSCHEmtcPdcchFree ARGS((
+EXTERN Void rgSCHEmtcPdcchFree ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch
));
#endif
/* Functions specific to TM1/TM2/TM6/TM7 for PRB calculation*/
-PUBLIC Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
+Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
/* Functions specific to TM3/TM4 for PRB calculation*/
-PUBLIC Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
+Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
#ifdef LTE_ADV
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
+RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
U16 cellId
));
#endif
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
{
*
*/
#ifdef ANSI
-PUBLIC F64 rgSCHUtlPower
+F64 rgSCHUtlPower
(
F64 x,
F64 n
)
#else
-PUBLIC F64 rgSCHUtlPower(x, n)
+F64 rgSCHUtlPower(x, n)
F64 x;
F64 n;
#endif
{
if( n==0 )
{
- RETVALUE( 1 );
+ return ( 1 );
}
else if ( n>0 )
{
- RETVALUE( x * rgSCHUtlPower( x, n-1 ) );
+ return ( x * rgSCHUtlPower( x, n-1 ) );
}
else
{
- RETVALUE( (1/x) * rgSCHUtlPower( x, n+1 ) );
+ return ( (1/x) * rgSCHUtlPower( x, n+1 ) );
}
} /* end of rgSCHUtlPower*/
*
*/
#ifdef ANSI
-PUBLIC U32 rgSCHUtlParse
+U32 rgSCHUtlParse
(
U8 *buff,
U8 startPos,
U8 buffSize
)
#else
-PUBLIC U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
+U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
U8 *buff;
U8 startPos;
U8 endPos;
}
pointToEnd++;
}
- RETVALUE((U32)result);
+ return ((U32)result);
} /* end of rgSCHUtlParse*/
/*
*
*/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlFindDist
+U8 rgSCHUtlFindDist
(
U16 crntTime,
U16 tempIdx
)
#else
-PUBLIC U8 rgSCHUtlFindDist(crntTime, tempIdx)
+U8 rgSCHUtlFindDist(crntTime, tempIdx)
U16 crntTime;
U16 tempIdx;
#endif
crntTime += RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
dist+=1;
}
- RETVALUE(dist-1);
+ return (dist-1);
} /* end of rgSCHUtlFindDist*/
#endif
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHUtlPdcchAvail
+Bool rgSCHUtlPdcchAvail
(
RgSchCellCb *cell,
RgSchPdcchInfo *pdcchInfo,
RgSchPdcch **pdcch
)
#else
-PUBLIC Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
+Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
RgSchCellCb *cell;
RgSchPdcchInfo *pdcchInfo;
CmLteAggrLvl aggrLvl;
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);
}
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPdcchPut
+Void rgSCHUtlPdcchPut
(
RgSchCellCb *cell,
RgSchPdcchInfo *pdcchInfo,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
+Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
RgSchCellCb *cell;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
{
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
*
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPdcchInit
+Void rgSCHUtlPdcchInit
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
U16 nCce
)
#else
-PUBLIC Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
+Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
U16 nCce;
*
**/
#ifdef ANSI
-PUBLIC Void rgSchSFRTotalPoolFree
+Void rgSchSFRTotalPoolFree
(
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo,
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
+Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo;
RgSchCellCb *cell;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchSFRTotalPoolInit
+S16 rgSchSFRTotalPoolInit
(
RgSchCellCb *cell,
RgSchDlSf *sf
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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchDSFRRntpInfoInit
+S16 rgSchDSFRRntpInfoInit
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
(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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchDSFRRntpInfoFree
+S16 rgSchDSFRRntpInfoFree
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
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
*
**/
#ifdef LTE_TDD
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddPhich
+S16 rgSCHUtlAddPhich
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
U8 iPhich
)
#else
-PUBLIC S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
+S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
RgSchCellCb *cell;
CmLteTimingInfo frm;
U8 hqFeedBack;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddPhich
+S16 rgSCHUtlAddPhich
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
Bool isForMsg3
)
#else
-PUBLIC S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
+S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
RgSchCellCb *cell;
CmLteTimingInfo frm;
U8 hqFeedBack;
{
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
*
*
**/
#ifdef ANSI
-PUBLIC RgSchDlSf* rgSCHUtlSubFrmGet
+RgSchDlSf* rgSCHUtlSubFrmGet
(
RgSchCellCb *cell,
CmLteTimingInfo frm
)
#else
-PUBLIC RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
+RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
RgSchCellCb *cell;
CmLteTimingInfo frm;
#endif
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
*
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSubFrmPut
+Void rgSCHUtlSubFrmPut
(
RgSchCellCb *cell,
RgSchDlSf *sf
)
#else
-PUBLIC Void rgSCHUtlSubFrmPut(cell, sf)
+Void rgSCHUtlSubFrmPut(cell, sf)
RgSchCellCb *cell;
RgSchDlSf *sf;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlLog32bitNbase2
+U8 rgSCHUtlLog32bitNbase2
(
U32 n
)
#else
-PUBLIC U8 rgSCHUtlLog32bitNbase2(n)
+U8 rgSCHUtlLog32bitNbase2(n)
U32 n;
#endif
{
ret |= s[i];
}
}
- RETVALUE(ret);
+ return (ret);
}
#ifdef LTEMAC_SPS
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlRelPdcchFbk
+Void rgSCHUtlDlRelPdcchFbk
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 isAck
)
#else
-PUBLIC Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
+Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 isAck;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlProcAck
+Void rgSCHUtlDlProcAck
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHUtlDlProcAck(cell, hqP)
+Void rgSCHUtlDlProcAck(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrntiCE
+Void rgSCHUtlHdlCrntiCE
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlHdlCrntiCE(cell, ue)
+Void rgSCHUtlHdlCrntiCE(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
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
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlCalcNCce
+U8 rgSCHUtlCalcNCce
(
U8 bw,
RgrPhichNg ng,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
+U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
U8 bw;
RgrPhichNg ng;
U8 cfi;
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
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlCalcNCce
+U8 rgSCHUtlCalcNCce
(
U8 bw,
RgrPhichNg ng,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
+U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
U8 bw;
RgrPhichNg ng;
U8 cfi;
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
**/
#ifdef LTE_TDD
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetPhichInfo
+S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
U8 *rbStartRef,
U8 *iPhich
)
#else
-PUBLIC S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
+S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
RgSchUlHqProcCb *hqProc;
U8 *rbStartRef;
U8 *nDmrsRef;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetPhichInfo
+S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
U8 *rbStartRef,
U8 *nDmrsRef
)
#else
-PUBLIC S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
+S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
RgSchUlHqProcCb *hqProc;
U8 *rbStartRef;
U8 *nDmrsRef;
#endif
ret = ROK;
}
- RETVALUE(ret);
+ return (ret);
}
#ifndef TFU_UPGRADE
/**
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocRcptInfo
+S16 rgSCHUtlAllocRcptInfo
(
RgSchUlAlloc *alloc,
CmLteRnti *rnti,
U8 *hqPId
)
#else
-PUBLIC S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
+S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
rvRef, size, modType, isRtx, nDmrs, ndi,
hqPId)
RgSchUlAlloc *alloc;
#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
/**
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocRcptInfo
+S16 rgSCHUtlAllocRcptInfo
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
TfuUeUlSchRecpInfo *recpReq
)
#else
-PUBLIC S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
+S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
CmLteTimingInfo *timeInfo;
#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;
}
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPrachCfgInit
+Void rgSCHUtlPrachCfgInit
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC Void rgSCHUtlPrachCfgInit(cell, cellCfg)
+Void rgSCHUtlPrachCfgInit(cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
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
*
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellCfg
+S16 rgSCHUtlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
+S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *errInfo;
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.
*
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellCfg
+S16 rgSCHUtlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
+S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *errInfo;
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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellRecfg
+S16 rgSCHUtlRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
+S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
#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
*
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFreeCell
+S16 rgSCHUtlFreeCell
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlFreeCell(cell)
+S16 rgSCHUtlFreeCell(cell)
RgSchCellCb *cell;
#endif
{
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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeCfg
+S16 rgSCHUtlRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
+S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcCfg
+S16 rgSCHUtlRgrLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
+S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
#endif
{
TRC2(rgSCHUtlRgrLcCfg);
- RETVALUE(cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
+ return (cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
}
\f
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcRecfg
+S16 rgSCHUtlRgrLcRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
+S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
#endif
{
TRC2(rgSCHUtlRgrLcRecfg);
- RETVALUE(cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
+ return (cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
}
/**
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcDel
+S16 rgSCHUtlRgrLcDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
+S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
TRC2(rgSCHUtlRgrLcDel);
cell->sc.apis->rgSCHRgrLchDel(cell, ue, lcId, lcgId);
- RETVALUE (ROK);
+ return (ROK);
} /* rgSCHUtlRgrLcDel */
/**
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcgCfg
+S16 rgSCHUtlRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
+S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgCfg *cfg;
#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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcgRecfg
+S16 rgSCHUtlRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
+S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgRecfg *recfg;
#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 */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRgrLcgDel
+Void rgSCHUtlRgrLcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
+Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDoaInd
+Void rgSCHUtlDoaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDoaRpt *doaRpt
)
#else
-PUBLIC Void rgSCHUtlDoaInd(cell, ue, doaRpt)
+Void rgSCHUtlDoaInd(cell, ue, doaRpt)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDoaRpt *doaRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlCqiInd
+Void rgSCHUtlDlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
+Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiRpt *dlCqiRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSrsInd
+Void rgSCHUtlSrsInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
+Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuSrsRpt *srsRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlTARpt
+Void rgSCHUtlDlTARpt
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlDlTARpt(cell, ue)
+Void rgSCHUtlDlTARpt(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlRlsSubFrm
+Void rgSCHUtlDlRlsSubFrm
(
RgSchCellCb *cell,
CmLteTimingInfo subFrm
)
#else
-PUBLIC Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
+Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
RgSchCellCb *cell;
CmLteTimingInfo subFrm;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdACqiTrigWt
+Void rgSCHUtlUpdACqiTrigWt
(
RgSchUeCb *ue,
RgSchUeCellInfo *cellInfo,
U8 isAck
)
#else
-PUBLIC Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
+Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
RgSchUeCb *ue;
RgSchUeCellInfo *cellInfo;
U8 isAck;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlUlTransInd
+Void rgSCHUtlHdlUlTransInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrcInd
+Void rgSCHUtlHdlCrcInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrcFailInd
+Void rgSCHUtlHdlCrcFailInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlProcAddToRetx
+Void rgSCHUtlDlProcAddToRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHUtlDlProcAddToRetx(cell, hqP)
+Void rgSCHUtlDlProcAddToRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
* @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
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlHqPTbAddToTx
+Void rgSCHUtlDlHqPTbAddToTx
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
U8 tbIdx
)
#else
-PUBLIC Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
+Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
U8 tbIdx;
* @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
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlHqPTbRmvFrmTx
+Void rgSCHUtlDlHqPTbRmvFrmTx
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
Bool isRepeting
)
#else
-PUBLIC Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
+Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
U8 tbIdx;
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb
+RgSchCellCb* rgSchUtlGetCellCb
(
Inst inst,
U16 cellId
)
#else
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
+RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
Inst inst;
U16 cellId;
#endif
strtCellId = rgSchCb[inst].genCfg.startCellId;
cellCb = rgSchCb[inst].cells[cellId - strtCellId];
- RETVALUE(cellCb);
+ return (cellCb);
} /* rgSchUtlGetCellCb */
* @return U8 servCellIdx
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlGetServCellIdx
+U8 rgSchUtlGetServCellIdx
(
Inst inst,
U16 cellId,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
+U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
Inst inst;
U16 cellId;
RgSchUeCb *ue;
servCellIdx = ue->cellIdToCellIdxMap[cellId - strtCellId];
- RETVALUE(servCellIdx);
+ return (servCellIdx);
} /* rgSchUtlGetCellCb */
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC S16 rgSchUtlVldtCellId
+S16 rgSchUtlVldtCellId
(
Inst inst,
U16 cellId
)
#else
-PUBLIC S16 rgSchUtlVldtCellId(inst, cellId)
+S16 rgSchUtlVldtCellId(inst, cellId)
Inst inst;
U16 cellId;
#endif
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*/
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeRecfg
+S16 rgSCHUtlRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
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 */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeDlLc
+Void rgSCHUtlFreeDlLc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHUtlFreeDlLc(cell, ue, svc)
+Void rgSCHUtlFreeDlLc(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeUe
+Void rgSCHUtlFreeUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlFreeUe(cell, ue)
+Void rgSCHUtlFreeUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlDedBoUpd
+Void rgSCHUtlDlDedBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *lc
)
#else
-PUBLIC Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
+Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *lc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRecMsg3Alloc
+Void rgSCHUtlRecMsg3Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
+Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdUlHqProc
+S16 rgSCHUtlUpdUlHqProc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *curProc,
RgSchUlHqProcCb *oldProc
)
#else
-PUBLIC S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
+S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
RgSchCellCb *cell;
RgSchUlHqProcCb *curProc;
RgSchUlHqProcCb *oldProc;
#endif
{
TRC2(rgSCHUtlUpdUlHqProc);
- RETVALUE(cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
+ return (cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
} /* rgSCHUtlUpdUlHqProc */
#endif
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlContResUlGrant
+S16 rgSCHUtlContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlContResUlGrant(cell, ue, err)
+S16 rgSCHUtlContResUlGrant(cell, ue, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchErrInfo *err;
ue->isMsg4PdcchWithCrnti = TRUE;
- RETVALUE(cell->sc.apis->rgSCHContResUlGrant(cell, ue, err));
+ return (cell->sc.apis->rgSCHContResUlGrant(cell, ue, err));
} /* rgSCHUtlContResUlGrant */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSrRcvd
+S16 rgSCHUtlSrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
+S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
#endif
{
TRC2(rgSCHUtlSrRcvd);
- RETVALUE(cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
+ return (cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
} /* rgSCHUtlSrRcvd */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrShort
+Void rgSCHUtlUpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
+Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrTrunc
+Void rgSCHUtlUpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
+Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrLong
+Void rgSCHUtlUpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
+Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 bsr0;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdExtPhr
+S16 rgSCHUtlUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
+S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo * extPhr;
#endif
{
TRC2(rgSCHUtlUpdExtPhr);
- RETVALUE(cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
+ return (cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
} /* rgSCHUtlUpdExtPhr */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdPhr
+S16 rgSCHUtlUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
+S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
#endif
{
TRC2(rgSCHUtlUpdPhr);
- RETVALUE(cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
+ return (cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
} /* rgSCHUtlUpdPhr */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlCqiInd
+Void rgSCHUtlUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPucchDeltaPwrInd
+Void rgSCHUtlPucchDeltaPwrInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 delta
)
#else
-PUBLIC Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
+Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
RgSchCellCb *cell;
RgSchUeCb *ue;
S8 delta;
* @return S16
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUeReset
+Void rgSCHUtlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlUeReset(cell, ue)
+Void rgSCHUtlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
* 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.
*
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHqProcForUe
+Void rgSCHUtlUlHqProcForUe
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
RgSchUlHqProcCb **procRef
)
#else
-PUBLIC Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
+Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
RgSchCellCb *cell;
CmLteTimingInfo frm;
RgSchUeCb *ue;
*
* 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.
*
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstRcptnReq
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
RgSchCellCb *cell;
#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.
*
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlNextRcptnReq
+RgSchUlAlloc *rgSCHUtlNextRcptnReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
+RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#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.
*
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
U8 idx;
#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
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
U8 idx;
#endif
{
TRC2(rgSCHUtlNextHqFdbkAlloc);
- RETVALUE(cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
+ return (cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
}
/***********************************
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuBndReq
+S16 rgSCHUtlTfuBndReq
(
Inst instId,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 rgSCHUtlTfuBndReq(instId, suId, spId)
+S16 rgSCHUtlTfuBndReq(instId, suId, spId)
Inst instId;
SuId suId;
SpId spId;
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlTfuBndReq() Call to RgLiTfuBndReq()"
" failed");
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlTfuBndReq */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuUBndReq
+S16 rgSCHUtlTfuUBndReq
(
Inst inst,
RgSchLowSapCfgInfo sapCfg,
Reason reason
)
#else
-PUBLIC S16 rgSCHUtlTfuUBndReq(inst, sapCfg, reason)
+S16 rgSCHUtlTfuUBndReq(inst, sapCfg, reason)
Inst inst;
RgSchLowSapCfgInfo sapCfg;
Reason reason;
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
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlResetSfAlloc
+S16 rgSCHUtlResetSfAlloc
(
RgInfSfAlloc *sfAlloc,
Bool resetCmnLcInfo,
Bool restAlloc
)
#else
-PUBLIC S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
+S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
RgInfSfAlloc *sfAlloc;
Bool resetCmnLcInfo;
Bool restAlloc;
{
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
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetRlsHqAlloc
+S16 rgSCHUtlGetRlsHqAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlGetRlsHqAlloc(cell)
+S16 rgSCHUtlGetRlsHqAlloc(cell)
RgSchCellCb *cell;
#endif
{
{
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
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlPutRlsHqAlloc
+S16 rgSCHUtlPutRlsHqAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlPutRlsHqAlloc(cell)
+S16 rgSCHUtlPutRlsHqAlloc(cell)
RgSchCellCb *cell;
#endif
{
}
}
- RETVALUE(ROK);
+ return ROK;
}
*
* Func : rgSCHUtlGetSfAlloc
*
- * Desc : Utility Function to Allocate subframe allocation information.
+ * Desc : Utility Function to Allocate slot allocation information.
*
*
* Ret : ROK
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetSfAlloc
+S16 rgSCHUtlGetSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlGetSfAlloc(cell)
+S16 rgSCHUtlGetSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
{
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 ANSI
-PUBLIC S16 rgSCHUtlPutSfAlloc
+S16 rgSCHUtlPutSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlPutSfAlloc(cell)
+S16 rgSCHUtlPutSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
#ifdef EMTC_ENABLE
rgSCHEmtcUtlPutSfAlloc(cell);
#endif
- RETVALUE(ROK);
+ return ROK;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocSBuf
+S16 rgSCHUtlAllocSBuf
(
Inst inst, /* Instance of the invoking scheduler */
Data **pData, /* Pointer of the data to be returned */
Size size /* size */
)
#else
-PUBLIC S16 rgSCHUtlAllocSBuf(inst, pData, size)
+S16 rgSCHUtlAllocSBuf(inst, pData, size)
Inst inst; /* Instance of the invoking scheduler */
Data **pData; /* Pointer of the data to be returned */
Size size; /* size */
#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 */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeSBuf
+Void rgSCHUtlFreeSBuf
(
Inst inst, /* Instance of the invoking scheduler */
Data **data, /* pointer to data */
Size size /* size */
)
#else
-PUBLIC Void rgSCHUtlFreeSBuf(inst, data, size)
+Void rgSCHUtlFreeSBuf(inst, data, size)
Inst inst; /* Instance of the invoking scheduler */
Data **data; /* pointer to data */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeWarningSiSeg
+Void rgSCHUtlFreeWarningSiSeg
(
Region reg,
Pool pool,
CmLListCp *siPduLst
)
#else
-PUBLIC Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
+Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
Region reg;
Pool pool;
CmLListCp *siPduLst;
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeWarningSiPdu
+Void rgSCHUtlFreeWarningSiPdu
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlFreeWarningSiPdu(cell)
+Void rgSCHUtlFreeWarningSiPdu(cell)
RgSchCellCb *cell;
#endif
{
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Buffer *rgSCHUtlGetWarningSiPdu
+Buffer *rgSCHUtlGetWarningSiPdu
(
RgSchCellCb *cell
)
#else
-PUBLIC Buffer *rgSCHUtlGetWarningSiPdu(cell)
+Buffer *rgSCHUtlGetWarningSiPdu(cell)
RgSchCellCb *cell;
#endif
{
{
warningSiPdu = (RgSchWarningSiPdu *)node->node;
pdu = warningSiPdu->pdu;
- RETVALUE(pdu);
+ return (pdu);
}
else
{
- RETVALUE(NULLP);
+ return (NULLP);
}
} /* rgSCHUtlGetWarningSiPdu */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetMcsAndNPrb
+S16 rgSCHUtlGetMcsAndNPrb
(
RgSchCellCb *cell,
U8 *nPrb,
MsgLen *msgLen
)
#else
-PUBLIC S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
+S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
U8 *nPrb;
U8 *mcs;
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 */
/*
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlCalMcsAndNPrb
+S16 rgSCHUtlCalMcsAndNPrb
(
RgSchCellCb *cell,
U8 cfgType,
U8 siId
)
#else
-PUBLIC S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
+S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
U8 cfgType;
MsgLen msgLen;
{
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
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFillDgnParams
+Void rgSCHUtlFillDgnParams
(
Inst inst,
RgUstaDgn *dgn,
U8 dgnType
)
#else
-PUBLIC Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
+Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
Inst inst;
RgUstaDgn *dgn;
U8 dgnType;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetPstToLyr
+Void rgSCHUtlGetPstToLyr
(
Pst *pst,
RgSchCb *schCb,
Inst macInst
)
#else
-PUBLIC Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
+Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
Pst *pst;
RgSchCb *schCb;
Inst macInst;
pst->dstProcId = schCb->rgSchInit.procId;
pst->dstInst = macInst;
- pst->dstEnt = ENTRG;
- pst->srcEnt = ENTRG;
+ pst->dstEnt = ENTMAC;
+ pst->srcEnt = ENTMAC;
pst->selector = 0;
pst->prior = PRIOR0;
pst->intfVer = 0;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillRgInfCmnLcInfo
+S16 rgSCHUtlFillRgInfCmnLcInfo
(
RgSchDlSf *sf,
RgInfSfAlloc *sfAlloc,
Bool sendInd
)
#else
-PUBLIC S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
+S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
RgSchDlSf *sf;
RgInfSfAlloc *sfAlloc;
CmLteLcId lcId;
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
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillRgInfRarInfo
+S16 rgSCHUtlFillRgInfRarInfo
(
RgSchDlSf *sf,
RgInfSfAlloc *sfAlloc,
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
+S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
RgSchDlSf *sf;
RgInfSfAlloc *sfAlloc;
RgSchCellCb *cell;
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
*
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillPdschDciInfo
+S16 rgSCHUtlFillPdschDciInfo
(
TfuPdschDciInfo *pdsch,
TfuDciInfo *pdcchDci
)
#else
-PUBLIC S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
+S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
TfuPdschDciInfo *pdsch;
TfuDciInfo *pdcchDci;
#endif
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 */
*
**/
#ifdef ANSI
-PUBLIC Void rgSchDSFRPwrCheck
+Void rgSchDSFRPwrCheck
(
RgSchDlSf *sf,
Bool *isAllUePwrHigh
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);
**********************************************************/
/* CA dev Start */
#ifdef ANSI
-PUBLIC Void rgSCHUtlFillRgInfUeInfo
+Void rgSCHUtlFillRgInfUeInfo
(
RgSchDlSf *sf,
RgSchCellCb *cell,
CmLListCp *ulInActvLst
)
#else
-PUBLIC Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
+Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
{
RgSchDlSf *sf;
RgSchCellCb *cell;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdSch
+S16 rgSCHUtlUpdSch
(
RgInfSfDatInd *subfrmInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
+S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
RgInfSfDatInd *subfrmInfo;
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
/* 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
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddUeToCcchSduLst
+S16 rgSCHUtlAddUeToCcchSduLst
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
+S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
#endif
{
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;
}
/**
*
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdtBo
+S16 rgSCHUtlUpdtBo
(
RgSchCellCb *cell,
RgInfCmnBoRpt *staRsp
)
#else
-PUBLIC S16 rgSCHUtlUpdtBo(cell, staRsp)
+S16 rgSCHUtlUpdtBo(cell, staRsp)
RgSchCellCb *cell;
RgInfCmnBoRpt *staRsp;
#endif
{
/* 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
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlHndlCcchBoUpdt
+S16 rgSCHUtlHndlCcchBoUpdt
(
RgSchCellCb *cell,
RgInfCmnBoRpt *boRpt
)
#else
-PUBLIC S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
+S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
RgSchCellCb *cell;
RgInfCmnBoRpt *boRpt;
#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 */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S32 rgSCHUtlGetAllwdCchTbSz
+S32 rgSCHUtlGetAllwdCchTbSz
(
U32 bo,
U8 *nPrb,
U8 *mcs
)
#else
-PUBLIC S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
+S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
U32 bo;
U8 *nPrb;
U8 *mcs;
{
*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);
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlHndlBcchPcchBoUpdt
+S16 rgSCHUtlHndlBcchPcchBoUpdt
(
RgSchCellCb *cell,
RgInfCmnBoRpt *boUpdt
)
#else
-PUBLIC S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
+S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
RgSchCellCb *cell;
RgInfCmnBoRpt *boUpdt;
#endif
{
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 */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrBndCfm
+S16 rgSCHUtlRgrBndCfm
(
Inst instId,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrBndCfm(instId, suId, status)
+S16 rgSCHUtlRgrBndCfm(instId, suId, status)
Inst instId;
SuId suId;
U8 status;
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrBndCfm: RgUiRgrBndCfm Failed ");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgrBndCfm*/
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgmBndCfm
+S16 rgSCHUtlRgmBndCfm
(
Inst instId,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgmBndCfm(instId, suId, status)
+S16 rgSCHUtlRgmBndCfm(instId, suId, status)
Inst instId;
SuId suId;
U8 status;
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgmBndCfm: RgUiRgrBndCfm Failed ");
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHUtlRgmBndCfm*/
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 schSendCfgCfm
+S16 schSendCfgCfm
(
Region reg,
Pool pool,
U8 status
)
#else
-PUBLIC S16 schSendCfgCfm(reg, pool, transId, status)
+S16 schSendCfgCfm(reg, pool, transId, status)
Region reg;
Pool pool;
RgrCfgTransId transId;
#endif
{
Pst cfmPst;
- Inst inst;
+ Inst inst = 0;
TRC2(schSendCfgCfm)
cmMemset((U8 *)(&cfmPst), 0, sizeof(Pst));
cfmPst.srcEnt = (Ent)ENTDUAPP;
cfmPst.srcInst = (Inst) 0;
cfmPst.srcProcId = SFndProcId();
- cfmPst.dstEnt = (Ent)ENTRG;
+ cfmPst.dstEnt = (Ent)ENTMAC;
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
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrTtiInd
+S16 rgSCHUtlRgrTtiInd
(
RgSchCellCb *cell,
RgrTtiIndInfo *rgrTti
)
#else
-PUBLIC S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
+S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
RgSchCellCb *cell;
RgrTtiIndInfo *rgrTti;
#endif
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
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlProcMsg3
+S16 rgSCHUtlProcMsg3
(
RgInfSfDatInd *subfrmInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
+S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
RgInfSfDatInd *subfrmInfo;
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
{
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
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSpsRelInd
+S16 rgSCHUtlSpsRelInd
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
Bool isExplRel
)
#else
-PUBLIC S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
+S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
Bool isExplRel;
{
TRC2(rgSCHUtlSpsRelInd);
cellCb->sc.apis->rgSCHUlSpsRelInd(cellCb, ueCb, isExplRel);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlSpsRelInd */
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSpsActInd
+S16 rgSCHUtlSpsActInd
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
U16 spsSduSize
)
#else
-PUBLIC S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
+S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
U16 spsSduSize;
{
TRC2(rgSCHUtlSpsActInd);
cellCb->sc.apis->rgSCHUlSpsActInd(cellCb, ueCb, spsSduSize);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHUtlSpsActInd */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuGrpPwrCntrlReq
+S16 rgSCHUtlTfuGrpPwrCntrlReq
(
Inst inst,
S16 sapId,
TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq
)
#else
-PUBLIC S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
+S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
Inst inst;
S16 sapId;
TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq;
{
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
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuCntrlReq
+S16 rgSCHUtlTfuCntrlReq
(
Inst inst,
S16 sapId,
TfuCntrlReqInfo *cntrlReq
)
#else
-PUBLIC S16 rgSCHUtlTfuCntrlReq(inst, sapId, cntrlReq)
+S16 rgSCHUtlTfuCntrlReq(inst, sapId, cntrlReq)
Inst inst;
S16 sapId;
TfuCntrlReqInfo *cntrlReq;
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*/
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlDlActvtUe
+S16 rgSCHUtlDlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHUtlDlActvtUe(cell, ue)
+S16 rgSCHUtlDlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
TRC2(rgSCHUtlDlActvtUe);
cell->sc.apis->rgSCHActvtDlUe(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlActvtUe
+S16 rgSCHUtlUlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHUtlUlActvtUe(cell, ue)
+S16 rgSCHUtlUlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
TRC2(rgSCHUtlUlActvtUe);
cell->sc.apis->rgSCHActvtUlUe(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuRecpReq
+S16 rgSCHUtlTfuRecpReq
(
Inst inst,
S16 sapId,
TfuRecpReqInfo *recpReq
)
#else
-PUBLIC S16 rgSCHUtlTfuRecpReq(inst, sapId, recpReq)
+S16 rgSCHUtlTfuRecpReq(inst, sapId, recpReq)
Inst inst;
S16 sapId;
TfuRecpReqInfo *recpReq;
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
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlValidateTfuSap
+S16 rgSCHUtlValidateTfuSap
(
Inst inst,
SuId suId
)
#else
-PUBLIC S16 rgSCHUtlValidateTfuSap(inst, suId)
+S16 rgSCHUtlValidateTfuSap(inst, suId)
Inst inst;
SuId suId;
#endif
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 */
/*
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocEventMem
+S16 rgSCHUtlAllocEventMem
(
Inst inst,
Ptr *memPtr,
Size memSize
)
#else
-PUBLIC S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
+S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
Inst inst;
Ptr *memPtr;
Size memSize;
{
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*/
/*
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetEventMem
+S16 rgSCHUtlGetEventMem
(
Ptr *ptr,
Size len,
Ptr memCp
)
#else
-PUBLIC S16 rgSCHUtlGetEventMem(ptr, len, memCp)
+S16 rgSCHUtlGetEventMem(ptr, len, memCp)
Ptr *ptr;
Size len;
Ptr memCp;
#else
ret = cmGetMem(memCp, len, (Ptr *)ptr);
#endif
- RETVALUE(ret);
+ return (ret);
} /* end of rgSCHUtlGetEventMem*/
#ifdef LTE_TDD
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocUeANFdbkInfo
+S16 rgSCHUtlAllocUeANFdbkInfo
(
RgSchUeCb *ue,
U8 servCellIdx
)
#else
-PUBLIC S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
+S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
U8 servCellIdx;
#endif
(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 */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDelUeANFdbkInfo
+Void rgSCHUtlDelUeANFdbkInfo
(
RgSchUeCb *ue,
U8 servCellIdx
)
#else
-PUBLIC Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
+Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
U8 servCellIdx;
#endif
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlInitUeANFdbkInfo
+S16 rgSCHUtlInitUeANFdbkInfo
(
RgSchTddANInfo *anFdInfo
)
#else
-PUBLIC S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
+S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
RgSchTddANInfo *anFdInfo;
#endif
{
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
* @return RgSchTddANInfo*
**/
#ifdef ANSI
-PUBLIC RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
(
RgSchUeCb *ueCb,
CmLteTimingInfo *timeInfo,
U8 servCellIdx
)
#else
-PUBLIC RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
RgSchUeCb *ueCb;
CmLteTimingInfo *timeInfo;
U8 servCellIdx;
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
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlGetDlSfIdx
+U8 rgSCHUtlGetDlSfIdx
(
RgSchCellCb *cell,
CmLteTimingInfo *timeInfo
)
#else
-PUBLIC U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
+U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
RgSchCellCb *cell;
CmLteTimingInfo *timeInfo;
#endif
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
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetNxtDlSfInfo
+Void rgSCHUtlGetNxtDlSfInfo
(
CmLteTimingInfo curDlTime,
RgSchCellCb *cell,
CmLteTimingInfo *nxtDlTime
)
#else
-PUBLIC Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
+Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
CmLteTimingInfo curDlTime;
RgSchCellCb *cell;
RgSchDlSf *dlSf;
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
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetPrevDlSfInfo
+Void rgSCHUtlGetPrevDlSfInfo
(
RgSchCellCb *cell,
CmLteTimingInfo curDlTime,
U8 *numSubfrm
)
#else
-PUBLIC Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
+Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
RgSchCellCb *cell;
CmLteTimingInfo curDlTime;
CmLteTimingInfo *prevDlTime;
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 ANSI
-PUBLIC S16 rgSCHUtlUlSfInit
+S16 rgSCHUtlUlSfInit
(
RgSchCellCb *cell,
RgSchUlSf *sf,
U8 maxUePerSf
)
#else
-PUBLIC S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
+S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
RgSchCellCb *cell;
RgSchUlSf *sf;
U8 idx;
#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
*
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlSfDeinit
+Void rgSCHUtlUlSfDeinit
(
RgSchCellCb *cell,
RgSchUlSf *sf
)
#else
-PUBLIC Void rgSCHUtlUlSfDeinit(cell, sf)
+Void rgSCHUtlUlSfDeinit(cell, sf)
RgSchCellCb *cell;
RgSchUlSf *sf;
#endif
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;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
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));
}
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
(
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
RgSchUlSf *sf;
RgSchUlHole *hole;
#endif
/* UL_ALLOC_CHANGES*/
alloc->allocDbRef = (void*)sf->allocDb;
alloc->holeDbRef = (void*)sf->holeDb;
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
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 *
*
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocFirst
+RgSchUlAlloc *rgSCHUtlUlAllocFirst
(
RgSchUlSf *sf
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
+RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
RgSchUlSf *sf;
#endif
{
TRC2(rgSCHUtlUlAllocFirst);
- RETVALUE(sf->allocDb->first);
+ return (sf->allocDb->first);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocNxt
+RgSchUlAlloc *rgSCHUtlUlAllocNxt
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
+RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
{
TRC2(rgSCHUtlUlAllocNxt);
UNUSED(sf);
- RETVALUE(alloc->nxt);
+ return (alloc->nxt);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
(
RgSchUlAllocDb *db,
RgSchUlAlloc *prv
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
RgSchUlAllocDb *db;
RgSchUlAlloc *prv;
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
{
- RETVALUE ( NULLP );
+ return ( NULLP );
}
#endif
alloc->prv = prv;
++db->count;
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
(
RgSchUlAllocDb *db
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
RgSchUlAllocDb *db;
#endif
{
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
{
- RETVALUE ( NULLP );
+ return ( NULLP );
}
#endif
++db->count;
- RETVALUE(alloc);
+ return (alloc);
}
/* UL_ALLOC_ENHANCEMENT */
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleAddAllocation
+Void rgSCHUtlUlHoleAddAllocation
(
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleAddAllocation(alloc)
+Void rgSCHUtlUlHoleAddAllocation(alloc)
RgSchUlAlloc *alloc;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocRelease
+Void rgSCHUtlUlAllocRelease
(
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocRelease(alloc)
+Void rgSCHUtlUlAllocRelease(alloc)
RgSchUlAlloc *alloc;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocRls
+Void rgSCHUtlUlAllocRls
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocRls(sf, alloc)
+Void rgSCHUtlUlAllocRls(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleFirst
+RgSchUlHole *rgSCHUtlUlHoleFirst
(
RgSchUlSf *sf
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
+RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
RgSchUlSf *sf;
#endif
{
TRC2(rgSCHUtlUlHoleFirst);
- RETVALUE(sf->holeDb->first);
+ return (sf->holeDb->first);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleNxt
+RgSchUlHole *rgSCHUtlUlHoleNxt
(
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
+RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
RgSchUlSf *sf;
RgSchUlHole *hole;
#endif
{
TRC2(rgSCHUtlUlHoleNxt);
UNUSED(sf);
- RETVALUE(hole->nxt);
+ return (hole->nxt);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleAddAlloc
+Void rgSCHUtlUlHoleAddAlloc
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
+Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleJoin
+Void rgSCHUtlUlHoleJoin
(
RgSchUlHoleDb *db,
RgSchUlHole *prv,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
+Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *prv;
RgSchUlHole *nxt;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleExtndRight
+Void rgSCHUtlUlHoleExtndRight
(
RgSchUlHoleDb *db,
RgSchUlHole *prv,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
+Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *prv;
RgSchUlAlloc *alloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleExtndLeft
+Void rgSCHUtlUlHoleExtndLeft
(
RgSchUlHoleDb *db,
RgSchUlHole *nxt,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
+Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *nxt;
RgSchUlAlloc *alloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleNew
+Void rgSCHUtlUlHoleNew
(
RgSchUlHoleDb *db,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleNew(db, alloc)
+Void rgSCHUtlUlHoleNew(db, alloc)
RgSchUlHoleDb *db;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleUpdAllocLnks
+Void rgSCHUtlUlHoleUpdAllocLnks
(
RgSchUlHole *hole,
RgSchUlAlloc *prvAlloc,
RgSchUlAlloc *nxtAlloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
+Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
RgSchUlHole *hole;
RgSchUlAlloc *prvAlloc;
RgSchUlAlloc *nxtAlloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleIns
+Void rgSCHUtlUlHoleIns
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleIns(db, hole)
+Void rgSCHUtlUlHoleIns(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleIncr
+Void rgSCHUtlUlHoleIncr
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleIncr(db, hole)
+Void rgSCHUtlUlHoleIncr(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleDecr
+Void rgSCHUtlUlHoleDecr
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleDecr(db, hole)
+Void rgSCHUtlUlHoleDecr(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleRls
+Void rgSCHUtlUlHoleRls
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleRls(db, hole)
+Void rgSCHUtlUlHoleRls(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlAllocMemInit
+S16 rgSCHUtlUlAllocMemInit
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem,
U8 maxAllocs
)
#else
-PUBLIC S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
+S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
U8 maxAllocs;
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;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocMemDeinit
+Void rgSCHUtlUlAllocMemDeinit
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem
)
#else
-PUBLIC Void rgSCHUtlUlAllocMemDeinit(cell, mem)
+Void rgSCHUtlUlAllocMemDeinit(cell, mem)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlHoleMemInit
+S16 rgSCHUtlUlHoleMemInit
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem,
RgSchUlHole **holeRef
)
#else
-PUBLIC S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
+S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
U8 maxHoles;
maxHoles * sizeof(*holes));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
mem->holes = holes;
}
mem->firstFree = &holes[1];
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleMemDeinit
+Void rgSCHUtlUlHoleMemDeinit
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem
)
#else
-PUBLIC Void rgSCHUtlUlHoleMemDeinit(cell, mem)
+Void rgSCHUtlUlHoleMemDeinit(cell, mem)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocMemGet
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet
(
RgSchUlAllocMem *mem
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
RgSchUlAllocMem *mem;
#endif
{
#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);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocMemRls
+Void rgSCHUtlUlAllocMemRls
(
RgSchUlAllocMem *mem,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocMemRls(mem, alloc)
+Void rgSCHUtlUlAllocMemRls(mem, alloc)
RgSchUlAllocMem *mem;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleMemGet
+RgSchUlHole *rgSCHUtlUlHoleMemGet
(
RgSchUlHoleMem *mem
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
+RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
RgSchUlHoleMem *mem;
#endif
{
#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);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleMemRls
+Void rgSCHUtlUlHoleMemRls
(
RgSchUlHoleMem *mem,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleMemRls(mem, hole)
+Void rgSCHUtlUlHoleMemRls(mem, hole)
RgSchUlHoleMem *mem;
RgSchUlHole *hole;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
(
RgSchUlSf *sf,
U8 startSb,
U8 numSb
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
RgSchUlSf *sf;
U8 startSb;
U8 numSb;
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.
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlValidateMeasReq
+S16 rgSCHUtlValidateMeasReq
(
RgSchCellCb *cellCb,
LrgSchMeasReqInfo *schL2MeasInfo,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
+S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
RgSchCellCb *cellCb;
LrgSchMeasReqInfo *schL2MeasInfo;
RgSchErrInfo *err;
{
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 *****/
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrSiCfgCfm
+S16 rgSCHUtlRgrSiCfgCfm
(
Inst instId,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
+S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
Inst instId;
SpId spId;
RgrCfgTransId transId;
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrSiCfgCfm: "
"RgUiRgrSiCfgCfm Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlRgrSiCfgCfm */
\f
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrWarningSiCfgCfm
+S16 rgSCHUtlRgrWarningSiCfgCfm
(
Inst instId,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
+S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
Inst instId;
SpId spId;
U8 siId;
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrSiCfgCfm: "
"RgUiRgrSiCfgCfm Failed ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHUtlRgrWarningSiCfgCfm */
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPutSiInfo
+Void rgSCHUtlPutSiInfo
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlPutSiInfo(cell)
+Void rgSCHUtlPutSiInfo(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetDrxSchdUesInDl
+S16 rgSCHUtlGetDrxSchdUesInDl
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLListCp *ulInActvLst
)
#else
-PUBLIC S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
+S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgSchDlHqProcCb *dlHq;
{
/*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
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillSndStaInd
+S16 rgSCHUtlFillSndStaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 numCqiRept
)
#else
-PUBLIC S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
+S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrStaIndInfo *staInfo;
{
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 */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrStaInd
+S16 rgSCHUtlRgrStaInd
(
RgSchCellCb *cell,
RgrStaIndInfo *rgrSta
)
#else
-PUBLIC S16 rgSCHUtlRgrStaInd(cell, rgrSta)
+S16 rgSCHUtlRgrStaInd(cell, rgrSta)
RgSchCellCb *cell;
RgrStaIndInfo *rgrSta;
#endif
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 */
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlIndRntiRls2Mac
+Void rgSCHUtlIndRntiRls2Mac
(
RgSchCellCb *cell,
CmLteRnti rnti,
CmLteRnti newRnti
)
#else
-PUBLIC Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
+Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
RgSchCellCb *cell;
CmLteRnti rnti;
Bool ueIdChng;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLoadInfInd
+S16 rgSCHUtlRgrLoadInfInd
(
RgSchCellCb *cell,
RgrLoadInfIndInfo *rgrLoadInf
)
#else
-PUBLIC S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
+S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
RgSchCellCb *cell;
RgrLoadInfIndInfo *rgrLoadInf;
#endif
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 */
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRlsRnti
+Void rgSCHUtlRlsRnti
(
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
CmLteRnti newRnti
)
#else
-PUBLIC Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
+Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
RgSchCellCb *cell;
RgSchRntiLnk *rntiLnk;
Bool ueIdChngd;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillSndUeStaInd
+S16 rgSCHUtlFillSndUeStaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeStaIndInfo *ueStaInfo
)
#else
-PUBLIC S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
+S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeStaIndInfo *ueStaInfo;
{
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 */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeStaInd
+S16 rgSCHUtlRgrUeStaInd
(
RgSchCellCb *cell,
RgrUeStaIndInfo *rgrUeSta
)
#else
-PUBLIC S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
+S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
RgSchCellCb *cell;
RgrUeStaIndInfo *rgrUeSta;
#endif
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 */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage
+S16 rgSCHUtlUpdAvgPrbUsage
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage(cell)
+S16 rgSCHUtlUpdAvgPrbUsage(cell)
RgSchCellCb *cell;
#endif
{
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 */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlReTxTa
+Void rgSCHUtlReTxTa
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHUtlReTxTa(cellCb, ueCb)
+Void rgSCHUtlReTxTa(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
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*/
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlCfg0ReTxIdx
+U8 rgSchUtlCfg0ReTxIdx
(
RgSchCellCb *cell,
CmLteTimingInfo phichTime,
U8 hqFdbkIdx
)
#else
-PUBLIC U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
+U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
RgSchCellCb *cell;
CmLteTimingInfo phichTime;
U8 hqFdbkIdx;
{
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
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlDlCalc1CwPrb
+Void rgSchUtlDlCalc1CwPrb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
+Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlDlCalc2CwPrb
+Void rgSchUtlDlCalc2CwPrb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
+Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlCalcTotalPrbReq
+Void rgSchUtlCalcTotalPrbReq
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
+Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
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.
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlGetNumSbs
+U8 rgSchUtlGetNumSbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *numSbs
)
#else
-PUBLIC U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
+U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 *numSbs;
//Currently hardcoding MAX prb for each UE
nPrb = ue->ue5gtfCb.maxPrb;
(*numSbs) = RGSCH_CEIL(nPrb, MAX_5GTF_VRBG_SIZE);
- RETVALUE(ROK);
+ return ROK;
}
/**
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlSortInsUeLst
+U8 rgSchUtlSortInsUeLst
(
RgSchCellCb *cell,
CmLListCp *ueLst,
U8 vrbgRequired
)
#else
-PUBLIC U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
+U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
RgSchCellCb *cell;
CmLListCp *ueLst;
CmLList *node;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlBuildNSendLcgReg
+S16 rgSCHUtlBuildNSendLcgReg
(
RgSchCellCb *cell,
CmLteRnti crnti,
Bool isGbr
)
#else
-PUBLIC S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
+S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
RgSchCellCb *cell;
CmLteRnti crnti;
U8 lcgId;
/* code Coverage portion of the test case */
RgSchMacLcgReg(&pst, &lcgRegReq);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef TFU_UPGRADE
* -# ROK
**/
#ifdef ANSI
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode
+TfuAckNackMode rgSchUtlGetFdbkMode
(
RgrSchFrmt1b3TypEnum fdbkType
)
#else
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
+TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
RgrSchFrmt1b3TypEnum fdbkType;
#endif
{
}
break;
}
- RETVALUE(mode);
+ return (mode);
}
#endif /* TFU_TDD */
#endif /* LTE_ADV */
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSndUeSCellDel2Mac
+Void rgSCHUtlSndUeSCellDel2Mac
(
RgSchCellCb *cell,
CmLteRnti rnti
)
#else
-PUBLIC Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
+Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
RgSchCellCb *cell;
CmLteRnti rnti;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlGetMaxTbSupp
+U8 rgSCHUtlGetMaxTbSupp
(
RgrTxMode txMode
)
#else
-PUBLIC U8 rgSCHUtlGetMaxTbSupp(txMode)
+U8 rgSCHUtlGetMaxTbSupp(txMode)
RgrTxMode txMode
#endif
{
break;
}
- RETVALUE(maxTbCount);
+ return (maxTbCount);
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHTomUtlGetTrigSet
+Void rgSCHTomUtlGetTrigSet
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdUeDciSize
+Void rgSCHUtlUpdUeDciSize
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
Bool isCsi2Bit
)
#else
-PUBLIC Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
+Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
Bool isCsi2Bit;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlCalcDciSizes
+Void rgSCHUtlCalcDciSizes
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlCalcDciSizes(cell)
+Void rgSCHUtlCalcDciSizes(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlCpuOvrLdAdjItbsCap
+Void rgSCHUtlCpuOvrLdAdjItbsCap
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
+Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
RgSchCellCb *cell
#endif
{
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
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlResetCpuOvrLdState
+S16 rgSCHUtlResetCpuOvrLdState
(
RgSchCellCb *cell,
U8 crntCpuOvrLdIns
)
#else
-PUBLIC S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
+S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
RgSchCellCb *cell;
U8 crntCpuOvrLdIns;
#endif
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
+S16 rgSCHUtlAddToResLst
(
CmLListCp *cp,
RgSchIotRes *iotRes
{
cmLListAdd2Tail(cp, &iotRes->resLnk);
iotRes->resLnk.node = (PTR)iotRes;
- RETVALUE(ROK);
+ return ROK;
}
-PUBLIC S16 rgSCHUtlDelFrmResLst
+S16 rgSCHUtlDelFrmResLst
(
RgSchUeCb *ue,
RgSchIotRes *iotRes
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
/**********************************************************************