static int RLOG_FILE_ID=163;
/* 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 "rgm.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 */
* in TDD config 2 where no DwPTS exits.
*/
-PRIVATE U8 rgSchDrxDlSfTddCfg[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG] =
+static uint8_t rgSchDrxDlSfTddCfg[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG] =
{
{2,4,6,6,7,8,3},
{4,6,8,7,8,9,5}
*
*/
-PRIVATE U8 rgSchDrxDLSfTillNxtSFN[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
+static uint8_t rgSchDrxDLSfTillNxtSFN[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
[RGSCH_NUM_SUB_FRAMES]=
{
{
*
*/
-PRIVATE U8 rgSchDrxDLSftoDLSfIdx[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
+static uint8_t rgSchDrxDLSftoDLSfIdx[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
[RGSCH_NUM_SUB_FRAMES]=
{
{
/* The k+4 th subframe in TDD at which HARQ RTT expires may be an Uplink SF.
In such case, the drx retx timer may start at the next pdcch sf instead
of at k+4 itself */
-U8 rgSchDrxHarqRetxFirstPsf[RGSCH_MAX_TDD_CFG][RGSCH_NUM_SUB_FRAMES] = {
+uint8_t rgSchDrxHarqRetxFirstPsf[RGSCH_MAX_TDD_CFG][RGSCH_NUM_SUB_FRAMES] = {
{0, 0, 4, 0, 6, 0, 0, 4, 0, 6},
{0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
{0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
/******************************************************************************
* Start of Function declarations *
******************************************************************************/
-PRIVATE Void rgSCHDrxTtiHdlOnDurUl ARGS((
+static Void rgSCHDrxTtiHdlOnDurUl ARGS((
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
));
-PRIVATE Void rgSCHDrxTtiHdlOnDurDl ARGS((
+static Void rgSCHDrxTtiHdlOnDurDl ARGS((
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
));
-PRIVATE Void rgSCHDrxTtiHdlDlHarqRTT ARGS((
+static Void rgSCHDrxTtiHdlDlHarqRTT ARGS((
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
));
-PRIVATE Void rgSCHDrxTtiHdlUlHarqRTT ARGS((
+static Void rgSCHDrxTtiHdlUlHarqRTT ARGS((
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
));
- PRIVATE S16 rgSCHDrxTtiHdlOnDur ARGS((RgSchCellCb *cellCb, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxTtiHdlInActv ARGS((RgSchCellCb *cellCb, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxTtiHdlShortCycle ARGS((RgSchCellCb *cell, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxTtiHdlDlHarq ARGS((RgSchCellCb *cellCb, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxCpyUeCfg ARGS((RgSchDrxUeCb *drxCb,
+static S16 rgSCHDrxTtiHdlOnDur ARGS((RgSchCellCb *cellCb, uint16_t dlIndex,
+ uint16_t ulIndex));
+static S16 rgSCHDrxTtiHdlInActv ARGS((RgSchCellCb *cellCb, uint16_t dlIndex,
+ uint16_t ulIndex));
+static S16 rgSCHDrxTtiHdlShortCycle ARGS((RgSchCellCb *cell, uint16_t dlIndex,
+ uint16_t ulIndex));
+static S16 rgSCHDrxTtiHdlDlHarq ARGS((RgSchCellCb *cellCb, uint16_t dlIndex,
+ uint16_t ulIndex));
+static S16 rgSCHDrxCpyUeCfg ARGS((RgSchDrxUeCb *drxCb,
RgrUeDrxCfg* ueDrxCfg));
- PRIVATE S16 rgSCHDrxGetNxtOnDur ARGS((RgSchCellCb* cell,RgSchDrxUeCb* drxCb,
+static S16 rgSCHDrxGetNxtOnDur ARGS((RgSchCellCb* cell,RgSchDrxUeCb* drxCb,
CmLteTimingInfo* nxtOnDur,
- U8 delta));
+ uint8_t delta));
-PRIVATE Void rgSCHDrxMvToNxtOnDurOcc ARGS((RgSchCellCb* cell,
+static Void rgSCHDrxMvToNxtOnDurOcc ARGS((RgSchCellCb* cell,
RgSchUeCb* ue,
- U16 idx,
+ uint16_t idx,
Bool calcFrmOffst));
#ifdef LTE_TDD
-PRIVATE Void rgSCHDrxCalcNxtTmrExpry ARGS((RgSchCellCb *cell,
+static Void rgSCHDrxCalcNxtTmrExpry ARGS((RgSchCellCb *cell,
RgSchUeCb *ue,
- U16 delta,
- U32 tmrLen,
+ uint16_t delta,
+ uint32_t tmrLen,
S16 *distance,
- U16 *idx
+ uint16_t *idx
));
-PRIVATE S16 rgSCHDrxGetNxtTmrExpry ARGS((RgSchCellCb *cell,U16 curTime,
- U32 duration,
+static S16 rgSCHDrxGetNxtTmrExpry ARGS((RgSchCellCb *cell,uint16_t curTime,
+ uint32_t duration,
CmLteTimingInfo* tmrExpryIdx));
#endif /* LTE_TDD */
#ifdef EMTC_ENABLE
-EXTERN S16 rgSCHEmtcDrxCpyUeCfg
+S16 rgSCHEmtcDrxCpyUeCfg
(
RgSchUeCb *ueCb,
RgrUeDrxCfg *drxCfg
);
-EXTERN S16 rgSCHDrxTtiHdlUlHarq
+S16 rgSCHDrxTtiHdlUlHarq
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
);
-EXTERN Void rgSCHDrxUeUlHqReset
+Void rgSCHDrxUeUlHqReset
(
RgSchCellCb *cell,
RgSchUeCb *ue,
* - Processing is divided into respective timer handling.
* - Calculate the DL and UL indices as follows
* @code
- * dlIndex = (cell->crntTime.sfn * 10 + cell->crntTime.subframe +
+ * dlIndex = (cell->crntTime.sfn * 10 + cell->crntTime.slot +
* RG_SCH_DRX_DL_DELTA) % RG_SCH_MAX_DRXQ_SIZE;
*
- * ulIndex = (cell->crntTime.sfn * 10 + cell->crntTime.subframe +
+ * ulIndex = (cell->crntTime.sfn * 10 + cell->crntTime.slot +
* RG_SCH_DRX_UL_DELTA) % RG_SCH_MAX_DRXQ_SIZE;
* @endcode
* - Call rgSCHDrxTtiHdlOnDur to handle onDurationTimer handling
* @return
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxTtiInd
+Void rgSCHDrxTtiInd
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHDrxTtiInd (cell)
+Void rgSCHDrxTtiInd (cell)
RgSchCellCb *cell;
#endif
{
- U16 dlIndex;
- U16 ulIndex;
+ uint16_t dlIndex;
+ uint16_t ulIndex;
- TRC2(rgSCHDrxTtiInd );
-
-
- dlIndex = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.subframe +
+ dlIndex = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot +
RG_SCH_DRX_DL_DELTA) % RG_SCH_MAX_DRXQ_SIZE;
- ulIndex = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.subframe +
+ ulIndex = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot +
RG_SCH_DRX_UL_DELTA) % RG_SCH_MAX_DRXQ_SIZE;
#ifdef LTEMAC_R9
#endif /*LTEMAC_R9*/
- RETVOID;
+ return;
}/*rgSCHDrxTtiInd*/
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
#ifdef ANSI
-PRIVATE S16 rgSCHDrxTtiHdlOnDur
+static S16 rgSCHDrxTtiHdlOnDur
(
RgSchCellCb* cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else
-PRIVATE S16 rgSCHDrxTtiHdlOnDur(cell, dlIndex, ulIndex)
+static S16 rgSCHDrxTtiHdlOnDur(cell, dlIndex, ulIndex)
RgSchCellCb* cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif
{
- TRC2(rgSCHDrxTtiHdlOnDur);
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
rgSCHDrxTtiHdlOnDurUl(cell, ulIndex);
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxTtiHdlOnDur*/
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxTtiHdlInActv
+S16 rgSCHDrxTtiHdlInActv
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else
-PUBLIC S16 rgSCHDrxTtiHdlInActv(cell, dlIndex, ulIndex)
+S16 rgSCHDrxTtiHdlInActv(cell, dlIndex, ulIndex)
RgSchCellCb *cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif
{
CmLList *node;
RgSchDRXCellCb *drxCell=NULLP;
RgSchUeCb *ue=NULLP;
RgSchDrxUeCb *drxUe=NULLP;
- U16 shrtCycleExpIndx;
+ uint16_t shrtCycleExpIndx;
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
CmLListCp ulInactvLst; /* list of UE's becoming UL-inactive */
RgSchCmnCell *cellSch = NULLP;
Bool delInUlScan = FALSE;
- TRC2(rgSCHDrxTtiHdlInActv);
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisDl->rgSCHDlInactvtUes(cell,&dlInactvLst);
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxTtiHdlInActv*/
/** @brief This function handles the per TTI processing for DRX short cycle
*
*
* @param RgSchCellCb *cell
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxTtiHdlShortCycle
+S16 rgSCHDrxTtiHdlShortCycle
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else
-PUBLIC S16 rgSCHDrxTtiHdlShortCycle (cell, dlIndex, ulIndex)
+S16 rgSCHDrxTtiHdlShortCycle (cell, dlIndex, ulIndex)
RgSchCellCb *cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif
{
CmLList *node;
RgSchUeCb *ue=NULLP;
RgSchDrxUeCb *drxUe=NULLP;
- TRC2(rgSCHDrxTtiHdlShortCycle );
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
rgSCHDrxMvToNxtOnDurOcc(cell,ue,RG_SCH_DRX_DL_DELTA,TRUE);
}/*while(node)...*/
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxTtiHdlShortCycle*/
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
#ifdef ANSI
-PRIVATE S16 rgSCHDrxTtiHdlDlHarq
+static S16 rgSCHDrxTtiHdlDlHarq
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else /* ANSI */
-PRIVATE S16 rgSCHDrxTtiHdlDlHarq (cell, dlIndex, ulIndex)
+static S16 rgSCHDrxTtiHdlDlHarq (cell, dlIndex, ulIndex)
RgSchCellCb *cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif /* ANSI */
{
#if ( ERRCLASS & ERRCLS_INT_PAR)
if ( cell == (RgSchCellCb *)NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /*ERRCLASS & ERRCLS_INT_PAR*/
- TRC2(rgSCHDrxTtiHdlDlHarq );
-
rgSCHDrxTtiHdlDlHarqRTT(cell, dlIndex);
rgSCHDrxTtiHdlUlHarqRTT(cell, ulIndex);
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function is called by the common scheduler as part of
*
* @param RgSchCellCb *cell
* @param CmLListCp *ueUlLst
- * @param U8 direction
+ * @param uint8_t direction
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxStrtInActvTmr
+Void rgSCHDrxStrtInActvTmr
(
RgSchCellCb *cell,
CmLListCp *ueLst,
-U8 direction
+uint8_t direction
)
#else
-PUBLIC Void rgSCHDrxStrtInActvTmr(cell, ueLst, direction)
+Void rgSCHDrxStrtInActvTmr(cell, ueLst, direction)
RgSchCellCb *cell;
CmLListCp *ueLst;
-U8 direction;
+uint8_t direction;
#endif
{
CmLList *node;
RgSchUeCb *ueCb;
RgSchDrxUeCb *ueDrxCb;
#ifndef LTE_TDD
- U16 index1;
+ uint16_t index1;
#endif
- U16 inActvTmrExpIndx;
+ uint16_t inActvTmrExpIndx;
#ifndef LTE_TDD
- U16 curTimeInSf; /* current time in number of subframes */
+ uint16_t curTimeInSf; /* current time in number of subframes */
#endif
#ifdef LTE_TDD
- U16 delta;
+ uint16_t delta;
#endif /*LTE_TDD*/
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
CmLListCp ulInactvLst; /* list of UE's becoming UL-inactive */
RgSchCmnCell *cellSch = NULLP;
Bool delInUlScan = FALSE;
-
- TRC2(rgSCHDrxStrtInActvTmr);
-
-
if ( direction == RG_SCH_DRX_UL)
{
#ifndef LTE_TDD
curTimeInSf = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- (cell->crntTime.subframe) +RG_SCH_DRX_UL_DELTA;
+ (cell->crntTime.slot) +RG_SCH_DRX_UL_DELTA;
#endif
#ifdef LTE_TDD
{
#ifndef LTE_TDD
curTimeInSf = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- (cell->crntTime.subframe) + RG_SCH_DRX_DL_DELTA;
+ (cell->crntTime.slot) + RG_SCH_DRX_DL_DELTA;
#endif
#ifdef LTE_TDD
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisDl->rgSCHDlInactvtUes(cell,&dlInactvLst);
- RETVOID;
+ return;
}/*rgSCHDrxStrtInActvTmr*/
/** @brief This function is called by the downlink HARQ module on receiving a
*
* @param RgSchCellCb *cell
* @param RgSchDlHqProcCb *dlHq
- * @param U8 tbCnt
+ * @param uint8_t tbCnt
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxStartHarqRTTTmr
+Void rgSCHDrxStartHarqRTTTmr
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
-U8 tbCnt
+uint8_t tbCnt
)
#else
-PUBLIC Void rgSCHDrxStartHarqRTTTmr(cell, hqP, tbCnt)
+Void rgSCHDrxStartHarqRTTTmr(cell, hqP, tbCnt)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
-U8 tbCnt;
+uint8_t tbCnt;
#endif
{
RgSchDRXCellCb *drxCell =NULLP;
RgSchDrxDlHqProcCb *drxHq =NULLP;
- U16 harqRTTExpIndx;
- U8 fdbkDelta;
+ uint16_t harqRTTExpIndx;
+ uint8_t fdbkDelta;
#ifdef LTE_TDD
- U8 firstDlTxOcassion;
- U8 drxRetxTmrStartSf;
+ uint8_t firstDlTxOcassion;
+ uint8_t drxRetxTmrStartSf;
#endif
- TRC2(rgSCHDrxStartHarqRTTTmr);
-
drxCell = RG_SCH_DRX_GET_CELL(cell);
drxHq = RG_SCH_DRX_GET_DL_HQ(hqP);
* so that UE is scheduled for retransmission in the next subframe*/
/* ccpu00134196-[Add]-DRX retx timer changes */
harqRTTExpIndx = ((hqP->tbInfo[tbCnt].timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- hqP->tbInfo[tbCnt].timingInfo.subframe + RG_SCH_MIN_HARQ_RTT)
+ hqP->tbInfo[tbCnt].timingInfo.slot + RG_SCH_MIN_HARQ_RTT)
% RG_SCH_MAX_DRXQ_SIZE;
fdbkDelta = RGSCH_CALC_SF_DIFF(cell->crntTime, hqP->tbInfo[tbCnt].timingInfo);
may not be possible */
drxRetxTmrStartSf = (hqP->tbInfo[tbCnt].fdbkTime.subframe +
firstDlTxOcassion) % RGSCH_NUM_SUB_FRAMES;
- U8 i;
+ uint8_t i;
/* We are here because the Retx Timer start is moved by atleast one
position. Hence the timer will be reduced by minimum one */
drxHq->retxTmrReduction = 1;
drxHq->harqRTTEnt.node = (PTR)hqP;
drxHq->rttIndx = harqRTTExpIndx;
- RETVOID;
+ return;
}/*rgSCHDrxStartHarqRTTTmr*/
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxUeCfg
+S16 rgSCHDrxUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *ueCfg
)
#else
-PUBLIC S16 rgSCHDrxUeCfg (cell, ue, ueCfg)
+S16 rgSCHDrxUeCfg (cell, ue, ueCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
S16 ret = ROK;
RgSchDrxUeCb *ueDrxCb;
CmLteTimingInfo nxtOnDur;
- U16 onDurIndx;
- U16 nxtOnDurTime;
- U16 curTime;
- U8 cellIdx;
-
-
- TRC2(rgSCHDrxUeCfg);
+ uint16_t onDurIndx;
+ uint16_t nxtOnDurTime;
+ uint16_t curTime;
+ uint8_t cellIdx;
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue == (RgSchUeCb* )NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDrxUeCfg():"
"Invalid params.cell or ue or ueCfg is NULL ");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED for DRX UECB CRBTI:%d",ue->ueId);
- RETVALUE(ret);
+ return (ret);
}
ueDrxCb = ue->drxCb;
rgSCHDrxGetNxtOnDur (cell, ueDrxCb, &nxtOnDur,RG_SCH_NO_DELTA);
- nxtOnDurTime = ((nxtOnDur.sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur.subframe);
+ nxtOnDurTime = ((nxtOnDur.sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur.slot);
curTime = ((cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- cell->crntTime.subframe);
+ cell->crntTime.slot);
onDurIndx = nxtOnDurTime % RG_SCH_MAX_DRXQ_SIZE;
ueDrxCb->shortCycleEnt.node = (PTR)ue;
}
- RETVALUE(ret);
+ return (ret);
} /* end of rgSCHDrxUeCfg */
/** @brief This function gets the next occurance of onDurationTimer from the
* @param RgSchCellCb *cell
* @param RgSchDrxUeCb *drxCb
* @param CmLteTimingInfo *nxtOnDur
- * @param U8 delta
+ * @param uint8_t delta
* @return ROK/RFAILED
*/
#ifdef ANSI
-PRIVATE S16 rgSCHDrxGetNxtOnDur
+static S16 rgSCHDrxGetNxtOnDur
(
RgSchCellCb *cell,
RgSchDrxUeCb *drxCb,
CmLteTimingInfo *nxtOnDur,
- U8 delta
+ uint8_t delta
)
#else
-PRIVATE S16 rgSCHDrxGetNxtOnDur (cell, drxCb, nxtOnDur, delta)
+static S16 rgSCHDrxGetNxtOnDur (cell, drxCb, nxtOnDur, delta)
RgSchCellCb *cell;
RgSchDrxUeCb *drxCb;
CmLteTimingInfo *nxtOnDur;
- U8 delta;
+ uint8_t delta;
#endif
{
- U16 curTime;
- U16 curDist;
- U16 cycleLen;
- U32 numOfCycles;
- U32 nxtDist;
+ uint16_t curTime;
+ uint16_t curDist;
+ uint16_t cycleLen;
+ uint32_t numOfCycles;
+ uint32_t nxtDist;
- TRC3(rgSCHDrxGetNxtOnDur);
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if( (drxCb == (RgSchDrxUeCb* )NULLP)
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDrxGetNxOnDur():Invalid params."
"cell/drxCb/nxtOnDur is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cycleLen = drxCb->shortDrxCycle;
}
- curTime = ((cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.subframe);
+ curTime = ((cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.slot);
curTime += delta; /*TODO: see if we need to take care of wrap arounds */
{
/* offset is the nextOnDur */
nxtOnDur->sfn = drxCb->drxStartOffset / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->subframe = (U8)(drxCb->drxStartOffset % RGSCH_NUM_SUB_FRAMES_5G);
- nxtDist = ((nxtOnDur->sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur->subframe);
+ nxtOnDur->slot = (uint8_t)(drxCb->drxStartOffset % RGSCH_NUM_SUB_FRAMES_5G);
+ nxtDist = ((nxtOnDur->sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur->slot);
}
else
{
{
/* Perfect match pick up the current time */
/*nxtOnDur should be set to equal to currentTime + DELTA */
- nxtOnDur->sfn = (U16)curTime / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->subframe = (U16)curTime % RGSCH_NUM_SUB_FRAMES_5G;
- nxtDist = ((nxtOnDur->sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur->subframe);
+ nxtOnDur->sfn = (uint16_t)curTime / RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->slot = (uint16_t)curTime % RGSCH_NUM_SUB_FRAMES_5G;
+ nxtDist = ((nxtOnDur->sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur->slot);
}
else
{
nxtDist = drxCb->drxStartOffset + (numOfCycles + 1) *
cycleLen;
- nxtOnDur->sfn = (U16)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->subframe = (U16)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->sfn = (uint16_t)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->slot = (uint16_t)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
}
}
if((nxtDist - (curTime - delta)) <= RG_SCH_DRX_MAX_DELTA)
{
nxtDist = nxtDist + cycleLen;
- nxtOnDur->sfn = (U16)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->subframe = (U16)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->sfn = (uint16_t)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->slot = (uint16_t)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHDrxGetNxtOnDur */
/** @brief This function is a utility function to copy the UE configuration from
* @return ROK/RFAILED
*/
#ifdef ANSI
-PRIVATE S16 rgSCHDrxCpyUeCfg
+static S16 rgSCHDrxCpyUeCfg
(
RgSchDrxUeCb *ueCb,
RgrUeDrxCfg *drxCfg
)
#else
-PRIVATE S16 rgSCHDrxCpyUeCfg (ueCb, drxCfg)
+static S16 rgSCHDrxCpyUeCfg (ueCb, drxCfg)
RgSchDrxUeCb *ueCb;
RgrUeDrxCfg *drxCfg;
#endif
{
- TRC3(rgSCHDrxCpyUeCfg);
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( (ueCb == (RgSchDrxUeCb* )NULLP )
(drxCfg == (RgrUeDrxCfg* )NULLP)
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
ueCb->shortDrxCycle = drxCfg->drxShortDrx.shortDrxCycle;
ueCb->shortCycleTmrLen = drxCfg->drxShortDrx.drxShortCycleTmr;
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHDrxCpyUeCfg */
#ifdef RGR_V2
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxUeReCfg
+S16 rgSCHDrxUeReCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueReCfg
)
#else
-PUBLIC S16 rgSCHDrxUeReCfg (cell, ue, ueReCfg)
+S16 rgSCHDrxUeReCfg (cell, ue, ueReCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueReCfg;
Inst instIdx = cell->instIdx;
RgSchDrxUeCb *ueDrxCb;
CmLteTimingInfo nxtOnDur;
- U16 nxtOnDurTime;
- U16 onDurIndx;
- U16 curTime;
- U16 shrtCycleExpIndx;
- U16 onDurExpTime;
- U16 cycleLen;
- U16 curIndx;
- U8 cellIdx;
-
- TRC2(rgSCHDrxUeReCfg);
+ uint16_t nxtOnDurTime;
+ uint16_t onDurIndx;
+ uint16_t curTime;
+ uint16_t shrtCycleExpIndx;
+ uint16_t onDurExpTime;
+ uint16_t cycleLen;
+ uint16_t curIndx;
+ uint8_t cellIdx;
/* drx was disabled but now enabled for this ue */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHdrxUeReCfg():""Memory allocation FAILED for DRX UE Cb CRNTI:%d",
ue->ueId);
- RETVALUE(ret);
+ return (ret);
}
ue->isDrxEnabled = TRUE; /* sachin */
}
if( ue->drxCb == NULLP )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDrxCb = ue->drxCb;
}
- nxtOnDurTime = (nxtOnDur.sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur.subframe;
+ nxtOnDurTime = (nxtOnDur.sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur.slot;
curTime = ((cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- cell->crntTime.subframe);
+ cell->crntTime.slot);
/* If Onduration timer of old configuration is already running then waiting till it expires */
if((ueDrxCb->onDurExpIndx != DRX_INVALID) && (ueDrxCb->onDurExpDistance != DRX_TMR_EXPRD))
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHDrxUeReCfg */
#endif
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxUeHqReset
+Void rgSCHDrxUeHqReset
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqEnt *hqE,
- U8 cellIdx
+ uint8_t cellIdx
)
#else
-PUBLIC Void rgSCHDrxUeHqReset(cell, ue, hqE, cellIdx)
+Void rgSCHDrxUeHqReset(cell, ue, hqE, cellIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqEnt *hqE;
- U8 cellIdx;
+ uint8_t cellIdx;
#endif
{
RgSchDlHqProcCb *hqP;
RgSchDrxDlHqProcCb *drxHq =NULLP;
- U8 i;
-
- TRC2(rgSCHDrxUeHqReset);
+ uint8_t i;
for(i=0; i < hqE->numHqPrcs; i++)
{
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxUeDel
+S16 rgSCHDrxUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHDrxUeDel (cell, ue)
+S16 rgSCHDrxUeDel (cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchDrxUeCb *ueDrxCb;
RgSchDlHqEnt *hqE = NULLP;
- U8 cellIdx;
+ uint8_t cellIdx;
RgSchUeCellInfo *cellInfo = NULLP;
#ifdef EMTC_ENABLE
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
#endif
- TRC2(rgSCHDrxUeDel);
/* ccpu00129899: Moved the drx-enabled check to the caller */
ueDrxCb->drxDlInactvMask = DRX_UE_INACTIVE;
ueDrxCb->drxUlInactvMask = DRX_UE_INACTIVE;
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxUeDel*/
/** @brief This function is called at the time of RGR cell configuration.
* Function: rgSCHDrxCellCfg
*
* Processing steps:
- * - Initializes the following drxQ (cmMemset would do).
+ * - Initializes the following drxQ (memset would do).
*
*
* @param RgSchCellCb *cell
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxCellCfg
+S16 rgSCHDrxCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCHDrxCellCfg (cell, cellCfg)
+S16 rgSCHDrxCellCfg (cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
S16 ret = ROK;
Inst instIdx = cell->instIdx;
- TRC2(rgSCHDrxCellCfg);
-
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
/*KWORK_FIX :Removed check for cell being NULL*/
if( (cellCfg == (RgrCellCfg* )NULLP))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDrxCellCfg():Invalid Params. cell/cellCfg is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHDrxCellCfg():"
"Memory allocation FAILED for DRX cell Cb");
- RETVALUE(ret);
+ return (ret);
}
/* delInUlScan determines which index scans the queue last.
cell->drxCb->delInUlScan = TRUE;
}
- RETVALUE(ret);
+ return (ret);
} /* end of rgSchDrxCellCfg */
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxCellDel
+Void rgSCHDrxCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHDrxCellDel (cell)
+Void rgSCHDrxCellDel (cell)
RgSchCellCb *cell;
#endif
{
Inst instIdx = cell->instIdx;
- TRC2(rgSCHCfgRgrCellDel);
-
-
if (cell->drxCb)
{
/* ccpu00117052 - MOD - Passing double pointer
rgSCHUtlFreeSBuf(instIdx, (Data **)(&(cell->drxCb)),
sizeof(RgSchDRXCellCb));
}
- RETVOID;
+ return;
} /* end of rgSchDrxCellDel */
/** @brief This function is called when an SR is received from the UE. In this
* @return ROK/RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHDrxSrInd
+S16 rgSCHDrxSrInd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHDrxSrInd (cell, ue)
+S16 rgSCHDrxSrInd (cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchDrxUeCb *drxCb;
- TRC2(rgSCHDrxSrInd);
-
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( cell == (RgSchCellCb* )NULLP)
{
- RETVALUE(ROK);
+ return ROK;
}
if( (ue == (RgSchUeCb* )NULLP))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDrxSrInd():Invalid Params. cell/ue is NULL");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
/* KWork fix - shifted this down */
/* Update UE's inactive mask and if required move UE to ACTIVE state */
RG_SCH_CMN_UL_UPDT_INACTV_MASK( cell, ue, RG_DRX_INACTIVE);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDrxSrInd */
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rgSCHDrxDedRa
+Void rgSCHDrxDedRa
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDrxDedRa (cellCb, ueCb)
+Void rgSCHDrxDedRa (cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
RgSchDrxUeCb *drxCb;
- TRC2(rgSCHDrxDedRa);
-
-
drxCb = RG_SCH_DRX_GET_UE(ueCb);
/* Mark the UE as active for UL & DL */
drxCb->raRcvd = TRUE;
- RETVOID;
+ return;
} /* end of rgSCHDrxDedRa */
*
* @param RgSchCellCb *cell
* @param RgSchUeCb *ueCb
- * @param U16 idx - if calcFrmOffst is TRUE,
+ * @param uint16_t idx - if calcFrmOffst is TRUE,
* idx is delta to be added
* @param Bool calcFrmOffst
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rgSCHDrxMvToNxtOnDurOcc
+static Void rgSCHDrxMvToNxtOnDurOcc
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U16 idx,
+uint16_t idx,
Bool calcFrmOffst
)
#else
-PRIVATE Void rgSCHDrxMvToNxtOnDurOcc (cell, ueCb, idx, calcFrmOffst)
+static Void rgSCHDrxMvToNxtOnDurOcc (cell, ueCb, idx, calcFrmOffst)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U16 idx;
+uint16_t idx;
Bool calcFrmOffst;
#endif
{
- U16 nxtOnDurIndex;
- U16 curTime;
+ uint16_t nxtOnDurIndex;
+ uint16_t curTime;
RgSchDrxUeCb *drxUe;
RgSchDRXCellCb *drxCell;
CmLteTimingInfo nxtOnDur; /* to be used when calcFrmOffset is set */
- U16 nxtOnDurInSf; /* next On Duration in no of subframes */
+ uint16_t nxtOnDurInSf; /* next On Duration in no of subframes */
drxCell = cell->drxCb;
drxUe = ueCb->drxCb;
- TRC2(rgSCHDrxMvToNxtOnDurOcc)
if(calcFrmOffst == FALSE)
{
}
else
{
- rgSCHDrxGetNxtOnDur(cell,drxUe,&nxtOnDur,(U8)idx);
+ rgSCHDrxGetNxtOnDur(cell,drxUe,&nxtOnDur,(uint8_t)idx);
nxtOnDurInSf = ((nxtOnDur.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- nxtOnDur.subframe);
+ nxtOnDur.slot);
curTime = ((cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
- cell->crntTime.subframe);
+ cell->crntTime.slot);
nxtOnDurIndex = nxtOnDurInSf % RG_SCH_MAX_DRXQ_SIZE;
drxUe->distance = (nxtOnDurInSf-curTime) / RG_SCH_MAX_DRXQ_SIZE;
drxUe->onDurationEnt.node = (PTR)ueCb;
drxUe->onDurIndx = nxtOnDurIndex;
- RETVOID;
+ return;
}/*rgSCHDrxMvToNxtOnDurOcc*/
#ifdef LTE_TDD
* and will expire on (15,1)
*
* @param RgSchUeCb *ue Ue control block.
- * @param U16 curTime current Time
- * @param U32 duration Timer duration
+ * @param uint16_t curTime current Time
+ * @param uint32_t duration Timer duration
* @param CmLteTimingInfo *tmrExpryIdx Timer expry (SFN,sf)
* @return ROK/RFAILED
*/
#ifdef ANSI
-PRIVATE S16 rgSCHDrxGetNxtTmrExpry
+static S16 rgSCHDrxGetNxtTmrExpry
(
RgSchCellCb *cell,
- U16 curTime,
- U32 duration,
+ uint16_t curTime,
+ uint32_t duration,
CmLteTimingInfo *tmrExpryIdx
)
#else
-PRIVATE S16 rgSCHDrxGetNxtTmrExpry (cell,curTime,duration,tmrExpryIdx)
+static S16 rgSCHDrxGetNxtTmrExpry (cell,curTime,duration,tmrExpryIdx)
RgSchCellCb *cell;
- U16 curTime;
- U32 duration;
+ uint16_t curTime;
+ uint32_t duration;
CmLteTimingInfo *tmrExpryIdx;
#endif
{
- U32 dlSfTillNxtSFN; /*!< DL subframes till next SFN */
- U8 tddCfgMode; /*!< tdd config mode */
+ uint32_t dlSfTillNxtSFN; /*!< DL subframes till next SFN */
+ uint8_t tddCfgMode; /*!< tdd config mode */
Bool isDwPtsCnted; /*!< is DwPts counted as PDCCH sf */
CmLteTimingInfo crntTime; /*!< current SFN & sf */
- TRC2(rgSCHDrxGetNxtTmrExpry);
-
#if ( ERRCLASS & ERRCLS_INT_PAR )
if ( (cell == (RgSchCellCb* )NULLP)
||
(tmrExpryIdx == (CmLteTimingInfo* )NULLP)
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
tddCfgMode = cell->ulDlCfgIdx;
crntTime.sfn = curTime / RGSCH_NUM_SUB_FRAMES_5G;
- crntTime.subframe = curTime % RGSCH_NUM_SUB_FRAMES_5G;
+ crntTime.slot = curTime % RGSCH_NUM_SUB_FRAMES_5G;
/* First calculate the number of DL subframes till next SFN */
dlSfTillNxtSFN = rgSchDrxDLSfTillNxtSFN[isDwPtsCnted][tddCfgMode]
- [(crntTime.subframe % RGSCH_NUM_SUB_FRAMES)];
+ [(crntTime.slot % RGSCH_NUM_SUB_FRAMES)];
if ( dlSfTillNxtSFN >= duration )
{
/* the timer would expire on the same RF */
- U32 diff = dlSfTillNxtSFN - duration;
+ uint32_t diff = dlSfTillNxtSFN - duration;
tmrExpryIdx->sfn = crntTime.sfn;
}
else
{
- U8 arrayIdx;
+ uint8_t arrayIdx;
/* to know the DL sf index based on diff */
arrayIdx = rgSchDrxDlSfTddCfg[isDwPtsCnted][tddCfgMode];
}/* if ( dlSfTillNxtSFN >= duration...*/
else
{
- U32 remSf; /*!< remaining subframes */
- U32 numRf; /*!< num of complete radio frames */
- U32 numRemSfs; /*!< num of remaining subframes */
+ uint32_t remSf; /*!< remaining subframes */
+ uint32_t numRf; /*!< num of complete radio frames */
+ uint32_t numRemSfs; /*!< num of remaining subframes */
remSf = duration - dlSfTillNxtSFN;
/* move to (currSFN,9) having consued dlSfTillNxtSFN DL subframes */
tmrExpryIdx->sfn = crntTime.sfn;
- tmrExpryIdx->subframe = (U8)9;
+ tmrExpryIdx->subframe = (uint8_t)9;
numRf = (1 * remSf)/rgSchDrxDlSfTddCfg[isDwPtsCnted][tddCfgMode];
numRemSfs = (1 * remSf)%rgSchDrxDlSfTddCfg[isDwPtsCnted][tddCfgMode];
tmrExpryIdx->sfn = tmrExpryIdx->sfn - (RG_SCH_CMN_MAX_SFN_NUM + 1);
}
- RETVALUE(ROK);
+ return ROK;
}/*rgSCHDrxGetNxtTmrExpry*/
/** @brief This function calculates the next onDuration Occurence
*
* @param RgSchCellCb *cell
* @param RgSchUeCb *ue
- * @param U16 delta
- * @param U32 tmrLen
- * @param U16 *distance
+ * @param uint16_t delta
+ * @param uint32_t tmrLen
+ * @param uint16_t *distance
* @param S16 *idx
* @return ROK/RFAILED
*/
#ifdef ANSI
-PRIVATE Void rgSCHDrxCalcNxtTmrExpry
+static Void rgSCHDrxCalcNxtTmrExpry
(
RgSchCellCb *cell,
RgSchUeCb *ue,
- U16 delta,
- U32 tmrLen,
+ uint16_t delta,
+ uint32_t tmrLen,
S16 *distance,
- U16 *idx
+ uint16_t *idx
)
#else
-PRIVATE Void rgSCHDrxCalcNxtTmrExpry (cell,ue,delta,tmrLen,distance,idx)
+static Void rgSCHDrxCalcNxtTmrExpry (cell,ue,delta,tmrLen,distance,idx)
RgSchCellCb *cell;
RgSchUeCb *ue;
- U16 delta;
- U32 tmrLen;
+ uint16_t delta;
+ uint32_t tmrLen;
S16 *distance;
- U16 *idx;
+ uint16_t *idx;
#endif
{
- U16 curTimeInSf; /*current time in no of subframes*/
+ uint16_t curTimeInSf; /*current time in no of subframes*/
CmLteTimingInfo tmrExpry;
- U16 tmrExpryInSf; /*timer expry in no of subframes*/
+ uint16_t tmrExpryInSf; /*timer expry in no of subframes*/
- TRC2(rgSCHDrxCalcNxtTmrExpry)
-
curTimeInSf = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G +
- cell->crntTime.subframe;
+ cell->crntTime.slot;
/* add delta to curTime */
curTimeInSf += delta;
}
}
- RETVOID;
+ return;
}/*rgSCHDrxCalcNxtTmrExpry*/
/* ccpu00134670- Validating onduration timer versus DRX cycle*/
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtTddDrxCycCfg
+S16 rgSCHCfgVldtTddDrxCycCfg
(
RgSchCellCb *cell,
-U16 drxCycle,
-U8 onDurTmr,
-U16 offSet
+uint16_t drxCycle,
+uint8_t onDurTmr,
+uint16_t offSet
)
#else
-PUBLIC S16 rgSCHCfgVldtTddDrxCycCfg(cell, drxCycle, onDurTmr, offSet)
+S16 rgSCHCfgVldtTddDrxCycCfg(cell, drxCycle, onDurTmr, offSet)
RgSchCellCb *cell;
-U16 drxCycle;
-U8 onDurTmr;
-U16 offSet;
+uint16_t drxCycle;
+uint8_t onDurTmr;
+uint16_t offSet;
#endif
{
- U16 startTime;
- U16 endTimeInSf;
+ uint16_t startTime;
+ uint16_t endTimeInSf;
CmLteTimingInfo endTime;
- TRC2(rgSCHCfgVldtTddDrxCycCfg)
startTime = offSet;
do
if(((RGSCH_MAX_SUBFRM_5G + endTimeInSf- startTime) % RGSCH_MAX_SUBFRM_5G) >=
drxCycle)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
startTime = (startTime + drxCycle);
}while((drxCycle % RGSCH_NUM_SUB_FRAMES) &&
(startTime < (drxCycle * RGSCH_NUM_SUB_FRAMES/2)));
- RETVALUE(ROK);
+ return ROK;
}
#endif /*LTE_TDD */
*
*
* @param RgSchCellCb *cellCb
- * @param U16 ulIndex
+ * @param uint16_t ulIndex
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rgSCHDrxTtiHdlOnDurUl
+static Void rgSCHDrxTtiHdlOnDurUl
(
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
)
#else
-PRIVATE Void rgSCHDrxTtiHdlOnDurUl(cell, ulIndex)
+static Void rgSCHDrxTtiHdlOnDurUl(cell, ulIndex)
RgSchCellCb *cell;
-U16 ulIndex;
+uint16_t ulIndex;
#endif
{
CmLList *node;
RgSchCmnCell *cellSch = NULLP;
Bool delInUlScan = FALSE;
- TRC2(rgSCHDrxTtiHdlOnDurUl)
-
drxCell = (cell->drxCb);
delInUlScan = drxCell->delInUlScan;
/***********************************************************
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
- RETVOID;
+ return;
}
/** @brief This function is called to handle onDurationTimer per TTI processing.
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
+ * @param uint16_t dlIndex
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rgSCHDrxTtiHdlOnDurDl
+static Void rgSCHDrxTtiHdlOnDurDl
(
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
)
#else
-PRIVATE Void rgSCHDrxTtiHdlOnDurDl(cell, dlIndex)
+static Void rgSCHDrxTtiHdlOnDurDl(cell, dlIndex)
RgSchCellCb *cell;
-U16 dlIndex;
+uint16_t dlIndex;
#endif
{
CmLList *node;
RgSchUeCb *ue = NULLP;
RgSchDrxUeCb *drxUe = NULLP;
RgSchCmnCell *cellSch = NULLP;
- U16 expiryIndex;
+ uint16_t expiryIndex;
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
Bool delInUlScan = FALSE;
* in the onDurationTmrExprQ. If !delInUlScan, then calculate the next
* OnDuration occurence, q it there and remove it from the current location.
*/
- TRC2(rgSCHDrxTtiHdlOnDurDl)
/***********************************************************
* Scanning OnDurationQ in DL
***********************************************************/
drxCell = (cell->drxCb);
delInUlScan = drxCell->delInUlScan;
- //printf("CELL Timer [SFN : %d],[SF : %d]\n",cell->crntTime.sfn,cell->crntTime.subframe);
+ //printf("CELL Timer [SFN : %d],[SF : %d]\n",cell->crntTime.sfn,cell->crntTime.slot);
node = drxCell->drxQ[dlIndex].onDurationQ.first;
cmLListAdd2Tail(&(drxCell->drxQ[expiryIndex].onDurationExpQ),
&(drxUe->onDurationExpEnt));
- //printf("DRXOnDuration Timer Started at [SFN : %d],[SF : %d]\n",cell->crntTime.sfn,cell->crntTime.subframe);
+ //printf("DRXOnDuration Timer Started at [SFN : %d],[SF : %d]\n",cell->crntTime.sfn,cell->crntTime.slot);
drxUe->onDurationExpEnt.node = (PTR)ue;
drxUe->onDurExpIndx = expiryIndex;
- //printf("DRxOnDuration will Expire = [%d]\n",(cell->crntTime.sfn*10+cell->crntTime.subframe+drxUe->onDurTmrLen));
+ //printf("DRxOnDuration will Expire = [%d]\n",(cell->crntTime.sfn*10+cell->crntTime.slot+drxUe->onDurTmrLen));
if ( delInUlScan == FALSE )
{
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
- RETVOID;
+ return;
}/*rgSCHDrxTtiHdlOnDurDl*/
/** @brief This function handles the Dl HARQ timer's processing per TTI.
* process accordingly.
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
+ * @param uint16_t dlIndex
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rgSCHDrxTtiHdlDlHarqRTT
+static Void rgSCHDrxTtiHdlDlHarqRTT
(
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
)
#else /* ANSI */
-PRIVATE Void rgSCHDrxTtiHdlDlHarqRTT(cell, dlIndex)
+static Void rgSCHDrxTtiHdlDlHarqRTT(cell, dlIndex)
RgSchCellCb *cell;
-U16 dlIndex;
+uint16_t dlIndex;
#endif /* ANSI */
{
CmLList *node;
RgSchDlHqProcCb *dlHq;
RgSchDRXCellCb *drxCell;
RgSchDrxUeCb *drxUe;
- U16 reTxExpIndx;
+ uint16_t reTxExpIndx;
Bool delInUlScan;
RgSchUeCb *ue;
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cellIdx;
- U32 dlInactvMask;
-
- TRC2(rgSCHDrxTtiHdlDlHarqRTT);
+ uint8_t cellIdx;
+ uint32_t dlInactvMask;
drxCell = cell->drxCb;
delInUlScan = drxCell->delInUlScan;
/*Call schedulers to inactivate ue*/
cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
- RETVOID;
+ return;
}
/** @brief This function handles the Ul HARQ timer's processing per TTI.
*
*
* @param RgSchCellCb *cellCb
- * @param U16 ulIndex
+ * @param uint16_t ulIndex
* @return Void
*/
#ifdef ANSI
-PRIVATE Void rgSCHDrxTtiHdlUlHarqRTT
+static Void rgSCHDrxTtiHdlUlHarqRTT
(
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
)
#else /* ANSI */
-PRIVATE Void rgSCHDrxTtiHdlUlHarqRTT(cell, ulIndex)
+static Void rgSCHDrxTtiHdlUlHarqRTT(cell, ulIndex)
RgSchCellCb *cell;
-U16 ulIndex;
+uint16_t ulIndex;
#endif /* ANSI */
{
CmLList *node;
RgSchUeCb *ue;
CmLListCp ulInactvLst; /* list of UE's becoming DL-inactive */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cellIdx;
- U32 ulInactvMask;
+ uint8_t cellIdx;
+ uint32_t ulInactvMask;
- TRC2(rgSCHDrxTtiHdlUlHarqRTT);
-
drxCell = cell->drxCb;
delInUlScan = drxCell->delInUlScan;
}
cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
- RETVOID;
+ return;
}
Code Review / o-du / l2.git / blobdiff