#endif /* __cplusplus */
#ifdef EMTC_ENABLE
-EXTERN U32 emtcStatsUlTomSrInd;
-EXTERN U32 emtcStatsUlBsrTmrTxp;
+uint32_t emtcStatsUlTomSrInd;
+uint32_t emtcStatsUlBsrTmrTxp;
#endif
#define RG_ITBS_DIFF(_x, _y) ((_x) > (_y) ? (_x) - (_y) : (_y) - (_x))
-EXTERN Void rgSCHSc1UlInit ARGS((RgUlSchdApis *apis));
+Void rgSCHSc1UlInit ARGS((RgUlSchdApis *apis));
#ifdef RG_PHASE2_SCHED
-EXTERN Void rgSCHRrUlInit ARGS((RgUlSchdApis *apis));
+Void rgSCHRrUlInit ARGS((RgUlSchdApis *apis));
#ifdef EMTC_ENABLE
-EXTERN Void rgSCHEmtcHqInfoFree ARGS((RgSchCellCb *cell, RgSchDlHqProcCb *hqP));
-EXTERN Void rgSCHEmtcRrUlInit ARGS((RgUlSchdApis *apis));
-EXTERN Void rgSCHEmtcCmnDlInit ARGS((Void));
-EXTERN Void rgSCHEmtcCmnUlInit ARGS((Void));
-EXTERN Void rgSCHEmtcCmnUeNbReset ARGS((RgSchUeCb *ueCb));
-EXTERN RgSchCmnCqiToTbs *rgSchEmtcCmnCqiToTbs[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_CFI];
+Void rgSCHEmtcHqInfoFree ARGS((RgSchCellCb *cell, RgSchDlHqProcCb *hqP));
+Void rgSCHEmtcRrUlInit ARGS((RgUlSchdApis *apis));
+Void rgSCHEmtcCmnDlInit ARGS((Void));
+Void rgSCHEmtcCmnUlInit ARGS((Void));
+Void rgSCHEmtcCmnUeNbReset ARGS((RgSchUeCb *ueCb));
+RgSchCmnCqiToTbs *rgSchEmtcCmnCqiToTbs[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_CFI];
#endif
-EXTERN Void rgSCHMaxciUlInit ARGS((RgUlSchdApis *apis));
-EXTERN Void rgSCHPfsUlInit ARGS((RgUlSchdApis *apis));
+Void rgSCHMaxciUlInit ARGS((RgUlSchdApis *apis));
+Void rgSCHPfsUlInit ARGS((RgUlSchdApis *apis));
#endif
-EXTERN Void rgSCHSc1DlInit ARGS((RgDlSchdApis *apis));
+Void rgSCHSc1DlInit ARGS((RgDlSchdApis *apis));
#ifdef RG_PHASE2_SCHED
-EXTERN Void rgSCHRrDlInit ARGS((RgDlSchdApis *apis));
+Void rgSCHRrDlInit ARGS((RgDlSchdApis *apis));
#ifdef EMTC_ENABLE
-EXTERN Void rgSCHEmtcRrDlInit ARGS((RgDlEmtcSchdApis *apis));
+Void rgSCHEmtcRrDlInit ARGS((RgDlEmtcSchdApis *apis));
#endif
-EXTERN Void rgSCHMaxciDlInit ARGS((RgDlSchdApis *apis));
-EXTERN Void rgSCHPfsDlInit ARGS((RgDlSchdApis *apis));
+Void rgSCHMaxciDlInit ARGS((RgDlSchdApis *apis));
+Void rgSCHPfsDlInit ARGS((RgDlSchdApis *apis));
#ifdef TFU_UPGRADE
-EXTERN Void rgSCHDlfsInit ARGS((RgDlfsSchdApis *apis));
+Void rgSCHDlfsInit ARGS((RgDlfsSchdApis *apis));
#endif
#endif
#ifdef EMTC_ENABLE
-EXTERN Void rgSCHCmnGetCqiEmtcDciFrmt2AggrLvl ARGS((RgSchCellCb *cell));
-EXTERN Void rgSCHCmnGetEmtcDciFrmtSizes ARGS((RgSchCellCb *cell));
-EXTERN Void rgSCHEmtcRrUlProcRmvFrmRetx ARGS((RgSchCellCb *cell, RgSchUlHqProcCb *proc));
-EXTERN S16 rgSCHCmnPrecompEmtcMsg3Vars
+Void rgSCHCmnGetCqiEmtcDciFrmt2AggrLvl ARGS((RgSchCellCb *cell));
+Void rgSCHCmnGetEmtcDciFrmtSizes ARGS((RgSchCellCb *cell));
+Void rgSCHEmtcRrUlProcRmvFrmRetx ARGS((RgSchCellCb *cell, RgSchUlHqProcCb *proc));
+S16 rgSCHCmnPrecompEmtcMsg3Vars
ARGS((
RgSchCmnUlCell *cellUl,
-U8 ccchCqi,
-U16 msgSzA,
-U8 sbSize,
+uint8_t ccchCqi,
+uint16_t msgSzA,
+uint8_t sbSize,
Bool isEcp
));
Void rgSCHEmtcCmnUeCcchSduDel
RgSchCellCb *cell,
RgSchUeCb *ueCb
);
-EXTERN Void rgSCHEmtcRmvFrmTaLst
+Void rgSCHEmtcRmvFrmTaLst
(
RgSchCmnDlCell *cellDl,
RgSchUeCb *ue
);
-EXTERN Void rgSCHEmtcInitTaLst
+Void rgSCHEmtcInitTaLst
(
RgSchCmnDlCell *cellDl
);
-EXTERN Void rgSCHEmtcAddToTaLst
+Void rgSCHEmtcAddToTaLst
(
RgSchCmnDlCell *cellDl,
RgSchUeCb *ue
#endif
#ifdef RGR_SI_SCH
-PRIVATE Void rgSCHDlSiSched ARGS((RgSchCellCb *cell,
+static Void rgSCHDlSiSched ARGS((RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc));
-PRIVATE Void rgSCHChkNUpdSiCfg ARGS((RgSchCellCb *cell));
-PRIVATE Void rgSCHSelectSi ARGS((RgSchCellCb *cell));
+static Void rgSCHChkNUpdSiCfg ARGS((RgSchCellCb *cell));
+static Void rgSCHSelectSi ARGS((RgSchCellCb *cell));
#endif /*RGR_SI_SCH*/
/* LTE_ADV_FLAG_REMOVED_START */
#ifdef UNUSED_FUNC
#ifndef LTE_TDD
-PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
+static S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
);
-PRIVATE S16 rgSCHCmnBuildRntpInfo (
+static S16 rgSCHCmnBuildRntpInfo (
RgSchCellCb *cell,
-U8 *rntpPtr,
-U8 startRb,
-U8 nmbRb,
-U16 bw
+uint8_t *rntpPtr,
+uint8_t startRb,
+uint8_t nmbRb,
+uint16_t bw
);
#endif
-PRIVATE Void rgSCHCmnNonDlfsType0Alloc
+static Void rgSCHCmnNonDlfsType0Alloc
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
RgSchUeCb *ue
);
-PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
-PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
+static uint8_t rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
+static Void rgSCHCmnUlNonadapRetx ARGS((
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
));
-PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
+static Void rgSCHCmnUlSfRlsRetxProcs ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf
));
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
+static S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 maxRb,
-U32 *numSb,
-U8 *iTbs,
-U32 hqSz,
-U32 stepDownItbs,
-U32 effTgt
+uint32_t maxRb,
+uint32_t *numSb,
+uint8_t *iTbs,
+uint32_t hqSz,
+uint32_t stepDownItbs,
+uint32_t effTgt
));
#endif
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
+static Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
+static Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
+static Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
+static Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
+static Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
#endif
);
/* LTE_ADV_FLAG_REMOVED_END */
-PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc ARGS((
+static Void rgSCHCmnNonDlfsBcchPcchRbAlloc ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHBcchPcchDlRbAlloc ARGS((
+static Void rgSCHBcchPcchDlRbAlloc ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnDlBcchPcchAlloc ARGS((
+static Void rgSCHCmnDlBcchPcchAlloc ARGS((
RgSchCellCb *cell
));
#ifdef RGR_CQI_REPT
-PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
+static Void rgSCHCmnDlCqiOnPucchInd ARGS ((
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi,
Bool *isCqiAvail,
Bool *is2ndCwCqiAvail
));
-PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
+static Void rgSCHCmnDlCqiOnPuschInd ARGS ((
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPusch *puschCqi,
Bool *is2ndCwCqiAvail
));
#else
-PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
+static Void rgSCHCmnDlCqiOnPucchInd ARGS ((
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi
));
-PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
+static Void rgSCHCmnDlCqiOnPuschInd ARGS ((
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPusch *puschCqi
/* ccpu00117452 - MOD - Changed macro name from
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
#ifdef RGR_CQI_REPT
-PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept ARGS((
+static S16 rgSCHCmnUeDlPwrCtColltCqiRept ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCqiRept *ueCqiRept));
#endif /* End of RGR_CQI_REPT */
/* Fix: syed align multiple UEs to refresh at same time */
-PRIVATE Void rgSCHCmnGetRefreshPer ARGS((
+static Void rgSCHCmnGetRefreshPer ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U32 *waitPer));
-PRIVATE S16 rgSCHCmnApplyUeRefresh ARGS((
+ uint32_t *waitPer));
+static S16 rgSCHCmnApplyUeRefresh ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue));
#ifdef DL_LA
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE Void rgSCHCheckAndSetTxScheme ARGS
+static Void rgSCHCheckAndSetTxScheme ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue
#endif
#ifdef LTE_TDD
-PRIVATE U32 rgSCHCmnCalcDwPtsTbSz ARGS
+static uint32_t rgSCHCmnCalcDwPtsTbSz ARGS
((
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 *iTbs,
-U8 lyr,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t *iTbs,
+uint8_t lyr,
+uint8_t cfi
));
-PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw ARGS
+static Void rgSCHCmnCalcDwPtsTbSz2Cw ARGS
((
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 maxRb,
-U8 *iTbs1,
-U8 *iTbs2,
-U8 lyr1,
-U8 lyr2,
-U32 *tb1Sz,
-U32 *tb2Sz,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t maxRb,
+uint8_t *iTbs1,
+uint8_t *iTbs2,
+uint8_t lyr1,
+uint8_t lyr2,
+uint32_t *tb1Sz,
+uint32_t *tb2Sz,
+uint8_t cfi
));
#endif
-PRIVATE Void rgSCHCmnInitRbAlloc ARGS
+static Void rgSCHCmnInitRbAlloc ARGS
((
RgSchCellCb *cell
));
/* local defines */
RgSchdApis rgSchCmnApis;
-PRIVATE RgUlSchdApis rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
-PRIVATE RgDlSchdApis rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
+static RgUlSchdApis rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
+static RgDlSchdApis rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
#ifdef EMTC_ENABLE
-PRIVATE RgUlSchdApis rgSchEmtcUlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
-PRIVATE RgDlEmtcSchdApis rgSchEmtcDlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
+static RgUlSchdApis rgSchEmtcUlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
+static RgDlEmtcSchdApis rgSchEmtcDlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
#endif
#ifdef RG_PHASE2_SCHED
-PRIVATE RgDlfsSchdApis rgSchDlfsSchdTbl[RGSCH_NUM_DLFS_SCHEDULERS];
+static RgDlfsSchdApis rgSchDlfsSchdTbl[RGSCH_NUM_DLFS_SCHEDULERS];
#endif
-PRIVATE RgUlSchdInits rgSchUlSchdInits = RGSCH_ULSCHED_INITS;
-PRIVATE RgDlSchdInits rgSchDlSchdInits = RGSCH_DLSCHED_INITS;
+RgUlSchdInits rgSchUlSchdInits = RGSCH_ULSCHED_INITS;
+RgDlSchdInits rgSchDlSchdInits = RGSCH_DLSCHED_INITS;
#ifdef EMTC_ENABLE
-PRIVATE RgEmtcUlSchdInits rgSchEmtcUlSchdInits = RGSCH_EMTC_ULSCHED_INITS;
-PRIVATE RgEmtcDlSchdInits rgSchEmtcDlSchdInits = RGSCH_EMTC_DLSCHED_INITS;
+static RgEmtcUlSchdInits rgSchEmtcUlSchdInits = RGSCH_EMTC_ULSCHED_INITS;
+static RgEmtcDlSchdInits rgSchEmtcDlSchdInits = RGSCH_EMTC_DLSCHED_INITS;
#endif
#if (defined (RG_PHASE2_SCHED) && defined (TFU_UPGRADE))
-PRIVATE RgDlfsSchdInits rgSchDlfsSchdInits = RGSCH_DLFSSCHED_INITS;
+static RgDlfsSchdInits rgSchDlfsSchdInits = RGSCH_DLFSSCHED_INITS;
#endif
typedef Void (*RgSchCmnDlAllocRbFunc) ARGS((RgSchCellCb *cell, RgSchDlSf *subFrm,
-RgSchUeCb *ue, U32 bo, U32 *effBo, RgSchDlHqProcCb *proc,
+RgSchUeCb *ue, uint32_t bo, uint32_t *effBo, RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo));
-typedef U8 (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- U8 numLyrs, Bool bothCwEnbld));
-PRIVATE Void rgSCHCmnDlAllocTxRbTM1 ARGS((
+typedef uint8_t (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
+ uint8_t numLyrs, Bool bothCwEnbld));
+static Void rgSCHCmnDlAllocTxRbTM1 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocTxRbTM2 ARGS((
+static Void rgSCHCmnDlAllocTxRbTM2 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocTxRbTM3 ARGS((
+static Void rgSCHCmnDlAllocTxRbTM3 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocTxRbTM4 ARGS((
+static Void rgSCHCmnDlAllocTxRbTM4 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#ifdef RG_UNUSED
-PRIVATE Void rgSCHCmnDlAllocTxRbTM5 ARGS((
+static Void rgSCHCmnDlAllocTxRbTM5 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#endif
-PRIVATE Void rgSCHCmnDlAllocTxRbTM6 ARGS((
+static Void rgSCHCmnDlAllocTxRbTM6 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocTxRbTM7 ARGS((
+static Void rgSCHCmnDlAllocTxRbTM7 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM1 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM1 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM2 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM2 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM3 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM3 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM4 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM4 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#ifdef RG_UNUSED
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM5 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM5 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#endif
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM6 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM6 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM7 ARGS((
+static Void rgSCHCmnDlAllocRetxRbTM7 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#ifdef LTE_ADV
-PRIVATE U8 rgSchGetN1ResCount ARGS ((
+static uint8_t rgSchGetN1ResCount ARGS ((
RgSchUeCb *ue,
- U16 servCellId
+ uint16_t servCellId
));
Bool rgSchCmnChkDataOnlyOnPcell
(
RgSchDlSf *dlSf
);
#endif /*LTE_ADV */
-U8 rgSCHCmnCalcPcqiBitSz
+uint8_t rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
- U8 numTxAnt
+ uint8_t numTxAnt
);
#ifndef LTE_ADV
#endif
-PRIVATE U8 rgSCHCmnDlTM3PrecInf2 ARGS((
+static uint8_t rgSCHCmnDlTM3PrecInf2 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
-PRIVATE U8 rgSCHCmnDlTM3PrecInf4 ARGS((
+static uint8_t rgSCHCmnDlTM3PrecInf4 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
-PRIVATE U8 rgSCHCmnDlTM4PrecInf2 ARGS((
+static uint8_t rgSCHCmnDlTM4PrecInf2 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
-PRIVATE U8 rgSCHCmnDlTM4PrecInf4 ARGS((
+static uint8_t rgSCHCmnDlTM4PrecInf4 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
/* Functions specific to each transmission mode for DL RB Allocation*/
{rgSCHCmnDlTM4PrecInf2, rgSCHCmnDlTM4PrecInf4}
};
-PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb ARGS((
+static S16 rgSCHCmnDlAlloc1CwRetxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U8 noLyr,
-U8 *numRb,
-U32 *effBo
+uint8_t noLyr,
+uint8_t *numRb,
+uint32_t *effBo
));
-PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb ARGS((
+static S16 rgSCHCmnDlAlloc2CwRetxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numRb,
+uint8_t *numRb,
Bool *swpFlg,
-U32 *effBo
+uint32_t *effBo
));
-PRIVATE Void rgSCHCmnDlTM3TxTx ARGS((
+static Void rgSCHCmnDlTM3TxTx ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlTM3TxRetx ARGS((
+static Void rgSCHCmnDlTM3TxRetx ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnDlTM3RetxRetx ARGS((
+static Void rgSCHCmnDlTM3RetxRetx ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
-PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc ARGS((
+static Void rgSCHCmnNonDlfsUpdTyp2Alloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
));
/* LTE_ADV_FLAG_REMOVED_START */
#ifndef LTE_TDD
-PRIVATE Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc ARGS((
+static Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
));
#endif
/* LTE_ADV_FLAG_REMOVED_END */
-PRIVATE Void rgSCHCmnDlRbInfoAddUeTx ARGS((
+static Void rgSCHCmnDlRbInfoAddUeTx ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc
));
-PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx ARGS((
+static Void rgSCHCmnDlRbInfoAddUeRetx ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
));
-PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst ARGS((
+static Void rgSCHCmnDlAdd2NonSchdRetxLst ARGS((
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc
));
-PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb ARGS((
+static S16 rgSCHCmnDlAlloc2CwTxRetxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *reTxTb,
RgSchDlHqTbCb *txTb,
-U8 *numRb,
-U32 *effBo
+uint8_t *numRb,
+uint32_t *effBo
));
-PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb ARGS((
+static S16 rgSCHCmnDlAlloc2CwTxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U32 bo,
-U8 *numRb,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
));
-PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb ARGS((
+static S16 rgSCHCmnDlAlloc1CwTxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 bo,
-U8 *numRb,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
));
#ifndef LTEMAC_SPS
-PRIVATE Void rgSCHCmnFillHqPTb ARGS((
+static Void rgSCHCmnFillHqPTb ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
));
#endif
#ifdef LTEMAC_SPS
-PRIVATE Void rgSCHCmnDlGetBestFitHole ARGS((
-U32 *allocMask,
-U8 numMaskRbs,
-U32 *crntAllocMask,
-U8 rbsReq,
-U8 *allocStart,
-U8 *allocNumRbs,
+static Void rgSCHCmnDlGetBestFitHole ARGS((
+uint32_t *allocMask,
+uint8_t numMaskRbs,
+uint32_t *crntAllocMask,
+uint8_t rbsReq,
+uint8_t *allocStart,
+uint8_t *allocNumRbs,
Bool isPartialAlloc
));
#ifdef RGSCH_SPS_UNUSED
-PRIVATE U32 rgSCHCmnGetRaType1Mask ARGS((
-U8 rbIdx,
-U8 rbgSize,
-U8 *type1Subset
+static uint32_t rgSCHCmnGetRaType1Mask ARGS((
+uint8_t rbIdx,
+uint8_t rbgSize,
+uint8_t *type1Subset
));
#endif
-PRIVATE U32 rgSCHCmnGetRaType0Mask ARGS((
-U8 rbIdx,
-U8 rbgSize
+static uint32_t rgSCHCmnGetRaType0Mask ARGS((
+uint8_t rbIdx,
+uint8_t rbgSize
));
-PRIVATE U32 rgSCHCmnGetRaType2Mask ARGS((
-U8 rbIdx,
-U8 *maskIdx
+static uint32_t rgSCHCmnGetRaType2Mask ARGS((
+uint8_t rbIdx,
+uint8_t *maskIdx
));
#endif
RgSchDlHqProcCb *proc
));
-U16 rgSCHCmnGetSiSetId ARGS((
-U16 sfn,
-U8 sf,
-U16 minPeriodicity
+uint16_t rgSCHCmnGetSiSetId ARGS((
+uint16_t sfn,
+uint8_t sf,
+uint16_t minPeriodicity
));
#ifdef RG_5GTF
//TODO_SID: Currenly table is only for 100 Prbs. Need to modify wrt VRBG table 8.1.5.2.1-1 V5G_213
-U32 rgSch5gtfTbSzTbl[MAX_5GTF_MCS] =
+uint32_t rgSch5gtfTbSzTbl[MAX_5GTF_MCS] =
{1864, 5256, 8776, 13176, 17576, 21976, 26376, 31656, 35176, 39576, 43976, 47496, 52776, 59376, 66392};
-U32 g5gtfTtiCnt = 0;
-U32 gUl5gtfSrRecv = 0;
-U32 gUl5gtfBsrRecv = 0;
-U32 gUl5gtfUeSchPick = 0;
-U32 gUl5gtfPdcchSchd = 0;
-U32 gUl5gtfAllocAllocated = 0;
-U32 gUl5gtfUeRbAllocDone = 0;
-U32 gUl5gtfUeRmvFnlzZeroBo = 0;
-U32 gUl5gtfUeFnlzReAdd = 0;
-U32 gUl5gtfPdcchSend = 0;
-U32 gUl5gtfRbAllocFail = 0;
-U32 ul5gtfsidUlMarkUl = 0;
-U32 ul5gtfsidDlSchdPass = 0;
-U32 ul5gtfsidDlAlreadyMarkUl = 0;
-U32 ul5gtfTotSchdCnt = 0;
+uint32_t g5gtfTtiCnt = 0;
+uint32_t gUl5gtfSrRecv = 0;
+uint32_t gUl5gtfBsrRecv = 0;
+uint32_t gUl5gtfUeSchPick = 0;
+uint32_t gUl5gtfPdcchSchd = 0;
+uint32_t gUl5gtfAllocAllocated = 0;
+uint32_t gUl5gtfUeRbAllocDone = 0;
+uint32_t gUl5gtfUeRmvFnlzZeroBo = 0;
+uint32_t gUl5gtfUeFnlzReAdd = 0;
+uint32_t gUl5gtfPdcchSend = 0;
+uint32_t gUl5gtfRbAllocFail = 0;
+uint32_t ul5gtfsidUlMarkUl = 0;
+uint32_t ul5gtfsidDlSchdPass = 0;
+uint32_t ul5gtfsidDlAlreadyMarkUl = 0;
+uint32_t ul5gtfTotSchdCnt = 0;
#endif
/* CQI Offset Index to Beta CQI Offset value mapping,
* stored as parts per 1000. Reserved is set to 0.
* Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
-U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
+uint32_t rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
3125, 3500, 4000, 5000, 6250};
-U32 rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
+uint32_t rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
4000, 5000, 6250, 8000,10000, 12625, 15875, 20000,
31000, 50000,80000,126000,0};
-U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
+uint32_t rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
15875,20000,0,0,0};
S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
/* Include CRS REs while calculating Efficiency */
-CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
-CONSTANT PRIVATE U8 rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
-U32 cfiSwitchCnt ;
-U32 cfiIncr ;
-U32 cfiDecr ;
+const static uint8_t rgSchCmnAntIdx[5] = {0,0,1,0,2};
+const static uint8_t rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
+uint32_t cfiSwitchCnt ;
+uint32_t cfiIncr ;
+uint32_t cfiDecr ;
#ifdef TFU_UPGRADE
{
TfuDciFormat spfcDciFrmt; /* TM(Transmission Mode) specific DCI format.
* Search space : UE Specific by C-RNTI only. */
- U8 spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
+ uint8_t spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
TfuDciFormat prfrdDciFrmt; /* Preferred DCI format among the available
* options for TD (Transmit Diversity) */
- U8 prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
+ uint8_t prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
}RgSchCmnDlUeDciFrmtOptns;
#ifndef LTE_ADV
typedef struct rgSchCmnDlImcsTbl
{
- U8 modOdr; /* Modulation Order */
- U8 iTbs; /* ITBS */
+ uint8_t modOdr; /* Modulation Order */
+ uint8_t iTbs; /* ITBS */
}RgSchCmnDlImcsTbl[29];
-CONSTANT struct rgSchCmnMult235Info
+const struct rgSchCmnMult235Info
{
- U8 match; /* Closest number satisfying 2^a.3^b.5^c, with a bias
+ uint8_t match; /* Closest number satisfying 2^a.3^b.5^c, with a bias
* towards the smaller number */
- U8 prvMatch; /* Closest number not greater than array index
+ uint8_t prvMatch; /* Closest number not greater than array index
* satisfying 2^a.3^b.5^c */
} rgSchCmnMult235Tbl[110+1] = {
{0, 0}, /* dummy */
/* R8 Upgrade */
/* BI table from 36.321 Table 7.2.1 */
-CONSTANT PRIVATE S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
+const static S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
0, 10, 20, 30,40,60,80,120,160,240,320,480,960};
RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
{ 0, 0 },
/* This table maps a (delta_offset * 2 + 2) to a (beta * 8)
* where beta is 10^-(delta_offset/10) rounded off to nearest 1/8
*/
-PRIVATE U16 rgSchCmnUlBeta8Tbl[29] = {
+static uint16_t rgSchCmnUlBeta8Tbl[29] = {
6, RG_SCH_CMN_UL_INVALID_BETA8, 8, 9, 10, 11, 13, 14, 16, 18, 20, 23,
25, 28, 32, RG_SCH_CMN_UL_INVALID_BETA8, 40, RG_SCH_CMN_UL_INVALID_BETA8,
50, RG_SCH_CMN_UL_INVALID_BETA8, 64, RG_SCH_CMN_UL_INVALID_BETA8, 80,
#endif
/* QCI to SVC priority mapping. Index specifies the Qci*/
-PRIVATE U8 rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
+static uint8_t rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
/* The configuration is efficiency measured per 1024 REs. */
/* The first element stands for when CQI is not known */
/* ADD CQI to MCS mapping correction
* single dimensional array is replaced by 2 dimensions for different CFI*/
-PRIVATE U16 rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
+static uint16_t rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI2,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI3};
-PRIVATE U16 rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
+static uint16_t rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI2, RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI3};
/* This configuration determines the transalation of a UEs CQI to its */
/* PDCCH coding efficiency. This may be edited based on the installation */
-PRIVATE U8 rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
+static uint8_t rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
/* Indexed by [DciFrmt].
* Considering the following definition in determining the dciFrmt index.
TFU_DCI_FORMAT_3A
} TfuDciFormat;
*/
-PRIVATE U16 rgSchCmnDciFrmtSizes[10];
+static uint16_t rgSchCmnDciFrmtSizes[10];
-
-PRIVATE U16 rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
+static uint16_t rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
#ifdef LTE_TDD
/* SPS_INTG_FIX */
#ifdef LTEMAC_SPS
-U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
+uint8_t rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
/* 0 */ 6,
/* 1 */ 7,
/* 2 */ 8,
/* PDSCH to PUCCH Table for DL Harq Feed back. Based on the
Downlink association set index 'K' table */
-U8 rgSchTddPucchTxTbl[7][10] = {
+uint8_t rgSchTddPucchTxTbl[7][10] = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{7, 6, 0, 0, 4, 7, 6, 0, 0, 4},
{7, 6, 0, 4, 8, 7, 6, 0, 4, 8},
So at sf4 the new CFI can be applied. To arrive at sf4 from
sf0, the sfIdx has to be increased by 3 */
-U8 rgSchTddPdcchSfIncTbl[7][10] = {
+uint8_t rgSchTddPdcchSfIncTbl[7][10] = {
/* A/N Bundl: 0,1,5,6*/ {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
/* A/N Bundl: 0,4,5,9*/ {2, 2, 0, 0, 3, 2, 2, 0, 0, 3},
/* A/N Bundl: 4,9*/ {3, 6, 0, 5, 4, 3, 6, 0, 5, 4},
#endif /* (LTEMAC_SPS ) */
/* Number of Uplink subframes Table */
-PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
+static uint8_t rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
/* Downlink HARQ processes Table */
RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
/* DwPTS Scheduling Changes Start */
/* Provides the number of Cell Reference Signals in DwPTS
* region per RB */
-PRIVATE U8 rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
+static uint8_t rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
{4, 8, 16}, /* Spl Sf cfg 1,2,3,6,7,8 */
{6, 12, 20}, /* Spl Sf cfg 4 */
};
-PRIVATE S8 rgSchCmnSplSfDeltaItbs[9] = RG_SCH_DWPTS_ITBS_ADJ;
+static S8 rgSchCmnSplSfDeltaItbs[9] = RG_SCH_DWPTS_ITBS_ADJ;
/* DwPTS Scheduling Changes End */
#endif
-PRIVATE U32 rgSchCmnBsrTbl[64] = {
+static uint32_t rgSchCmnBsrTbl[64] = {
0, 10, 12, 14, 17, 19, 22, 26,
31, 36, 42, 49, 57, 67, 78, 91,
107, 125, 146, 171, 200, 234, 274, 321,
58255, 68201, 79846, 93479, 109439, 128125, 150000, 220000
};
-PRIVATE U32 rgSchCmnExtBsrTbl[64] = {
+static uint32_t rgSchCmnExtBsrTbl[64] = {
0, 10, 13, 16, 19, 23, 29, 35,
43, 53, 65, 80, 98, 120, 147, 181,
223, 274, 337, 414, 509, 625, 769, 945,
867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
};
-U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
+uint8_t rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
RgSchTbSzTbl rgTbSzTbl = {
{
/* [ccpu00138532]-ADD-The below table stores the min HARQ RTT time
in Downlink for TDD and FDD. Indices 0 to 6 map to tdd UL DL config 0-6.
Index 7 map to FDD */
-U8 rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
+uint8_t rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
/* Number of CFI Switchover Index is equals to 7 TDD Indexes + 1 FDD index */
-U8 rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
+uint8_t rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
/* EffTbl is calculated for single layer and two layers.
* CqiToTbs is calculated for single layer and two layers */
RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3};
#endif
-EXTERN RgUlSchdInits rgSchUlSchdInits;
-EXTERN RgDlSchdInits rgSchDlSchdInits;
-EXTERN RgDlfsSchdInits rgSchDlfsSchdInits;
+ RgUlSchdInits rgSchUlSchdInits;
+ RgDlSchdInits rgSchDlSchdInits;
+ RgDlfsSchdInits rgSchDlfsSchdInits;
#ifdef EMTC_ENABLE
-EXTERN RgEmtcUlSchdInits rgSchEmtcUlSchdInits;
-EXTERN RgEmtcDlSchdInits rgSchEmtcDlSchdInits;
+ RgEmtcUlSchdInits rgSchEmtcUlSchdInits;
+ RgEmtcDlSchdInits rgSchEmtcDlSchdInits;
#endif
/* RACHO : start */
-PRIVATE S16 rgSCHCmnUeIdleExdThrsld ARGS((
+static S16 rgSCHCmnUeIdleExdThrsld ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
RgSchUeCb* rgSCHCmnGetHoUe ARGS((
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
));
-PRIVATE Void rgSCHCmnDelDedPreamble ARGS((
+static Void rgSCHCmnDelDedPreamble ARGS((
RgSchCellCb *cell,
-U8 preambleId
+uint8_t preambleId
));
RgSchUeCb* rgSCHCmnGetPoUe ARGS((
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo
));
-PRIVATE Void rgSCHCmnDelRachInfo ARGS((
+static Void rgSCHCmnDelRachInfo ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe ARGS((
+static S16 rgSCHCmnUlRbAllocForPoHoUe ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
-U8 maxRb
+uint8_t maxRb
));
-PRIVATE Void rgSCHCmnHdlHoPo ARGS((
+static Void rgSCHCmnHdlHoPo ARGS((
RgSchCellCb *cell,
CmLListCp *raRspLst,
RgSchRaReqInfo *raReq
));
-PRIVATE Void rgSCHCmnAllocPoHoGrnt ARGS((
+static Void rgSCHCmnAllocPoHoGrnt ARGS((
RgSchCellCb *cell,
CmLListCp *raRspLst,
RgSchUeCb *ue,
RgSchRaReqInfo *raReq
));
-PRIVATE Void rgSCHCmnFillPdcchOdr2Sf ARGS((
+static Void rgSCHCmnFillPdcchOdr2Sf ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchPdcch *pdcc,
-U8 rapId,
-U8 prachMskIdx
+uint8_t rapId,
+uint8_t prachMskIdx
));
-PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ ARGS((
+static Void rgSCHCmnDlAdd2PdcchOdrQ ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ ARGS((
+static Void rgSCHCmnDlRmvFrmPdcchOdrQ ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx ARGS((
+static Void rgSCHCmnUpdNxtPrchMskIdx ARGS((
RgSchCellCb *cell
));
-PRIVATE Void rgSCHCmnUpdRachParam ARGS((
+static Void rgSCHCmnUpdRachParam ARGS((
RgSchCellCb *cell
));
-PRIVATE S16 rgSCHCmnAllocPOParam ARGS((
+static S16 rgSCHCmnAllocPOParam ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUeCb *ue,
RgSchPdcch **pdcch,
-U8 *rapId,
-U8 *prachMskIdx
+uint8_t *rapId,
+uint8_t *prachMskIdx
));
-PRIVATE Void rgSCHCmnGenPdcchOrder ARGS((
+static Void rgSCHCmnGenPdcchOrder ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf
));
-PRIVATE Void rgSCHCmnCfgRachDedPrm ARGS((
+static Void rgSCHCmnCfgRachDedPrm ARGS((
RgSchCellCb *cell
));
/* RACHO : end */
-PRIVATE Void rgSCHCmnHdlUlInactUes ARGS((
+static Void rgSCHCmnHdlUlInactUes ARGS((
RgSchCellCb *cell
));
-PRIVATE Void rgSCHCmnHdlDlInactUes ARGS((
+static Void rgSCHCmnHdlDlInactUes ARGS((
RgSchCellCb *cell
));
-PRIVATE Void rgSCHCmnUlInit ARGS((Void
+static Void rgSCHCmnUlInit ARGS((Void
));
-PRIVATE Void rgSCHCmnDlInit ARGS((Void
+static Void rgSCHCmnDlInit ARGS((Void
));
-PRIVATE Void rgSCHCmnInitDlRbAllocInfo ARGS((
+static Void rgSCHCmnInitDlRbAllocInfo ARGS((
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnUpdUlCompEffBsr ARGS((
+static Void rgSCHCmnUpdUlCompEffBsr ARGS((
RgSchUeCb *ue
));
#if RG_UNUSED
-PRIVATE Void rgSCHCmnUlSetAllUnSched ARGS((
+static Void rgSCHCmnUlSetAllUnSched ARGS((
RgSchCmnUlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnUlUpdSf ARGS((
+static Void rgSCHCmnUlUpdSf ARGS((
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUlSf *sf
));
-PRIVATE Void rgSCHCmnUlHndlAllocRetx ARGS((
+static Void rgSCHCmnUlHndlAllocRetx ARGS((
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUlSf *sf,
RgSchUlAlloc *alloc
));
#endif
-PRIVATE Void rgSCHCmnGrpPwrCntrlPucch ARGS((
+static Void rgSCHCmnGrpPwrCntrlPucch ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf
));
-PRIVATE Void rgSCHCmnGrpPwrCntrlPusch ARGS((
+static Void rgSCHCmnGrpPwrCntrlPusch ARGS((
RgSchCellCb *cell,
RgSchUlSf *ulSf
));
-PRIVATE Void rgSCHCmnDelUeFrmRefreshQ ARGS((
+static Void rgSCHCmnDelUeFrmRefreshQ ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE S16 rgSCHCmnTmrExpiry ARGS((
+static S16 rgSCHCmnTmrExpiry ARGS((
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
));
-PRIVATE S16 rgSCHCmnTmrProc ARGS((
+static S16 rgSCHCmnTmrProc ARGS((
RgSchCellCb *cell
));
-PRIVATE Void rgSCHCmnAddUeToRefreshQ ARGS((
+static Void rgSCHCmnAddUeToRefreshQ ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 wait
+uint32_t wait
));
-PRIVATE Void rgSCHCmnDlCcchRetx ARGS((
+static Void rgSCHCmnDlCcchRetx ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnUpdUeMimoInfo ARGS((
+static Void rgSCHCmnUpdUeMimoInfo ARGS((
RgrUeCfg *ueCfg,
RgSchCmnDlUe *ueDl,
RgSchCellCb *cell,
RgSchCmnCell *cellSchd
));
-PRIVATE Void rgSCHCmnUpdUeUlCqiInfo ARGS((
+static Void rgSCHCmnUpdUeUlCqiInfo ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchCmnUlUe *ueUl,
Bool isEcp
));
#ifdef RGR_V1
-PRIVATE Void rgSCHCmnDlCcchSduRetx ARGS((
+static Void rgSCHCmnDlCcchSduRetx ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnDlCcchSduTx ARGS((
+static Void rgSCHCmnDlCcchSduTx ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE S16 rgSCHCmnCcchSduAlloc ARGS((
+static S16 rgSCHCmnCcchSduAlloc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE S16 rgSCHCmnCcchSduDedAlloc ARGS((
+static S16 rgSCHCmnCcchSduDedAlloc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb
));
-PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc ARGS((
+static S16 rgSCHCmnNonDlfsCcchSduRbAlloc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchDlSf *dlSf
));
#endif
-PRIVATE Void rgSCHCmnInitVars ARGS((
+static Void rgSCHCmnInitVars ARGS((
RgSchCellCb *cell
));
/*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now */
-PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
+static Void rgSCHCmnUlRbAllocForLst ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
- U32 count,
+ uint32_t count,
CmLListCp *reqLst,
CmLListCp *schdLst,
CmLListCp *nonSchdLst,
Bool isNewTx
));
-PRIVATE S16 rgSCHCmnUlRbAllocForUe ARGS((
+static S16 rgSCHCmnUlRbAllocForUe ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
- U8 maxRb,
+ uint8_t maxRb,
RgSchUlHole *hole
));
-PRIVATE Void rgSCHCmnMsg3GrntReq ARGS((
+static Void rgSCHCmnMsg3GrntReq ARGS((
RgSchCellCb *cell,
CmLteRnti rnti,
Bool preamGrpA,
RgSchUlHqProcCb *hqProc,
RgSchUlAlloc **ulAllocRef,
- U8 *hqProcIdRef
+ uint8_t *hqProcIdRef
));
-PRIVATE Void rgSCHCmnDlCcchRarAlloc ARGS((
+static Void rgSCHCmnDlCcchRarAlloc ARGS((
RgSchCellCb *cell
));
-PRIVATE Void rgSCHCmnDlCcchTx ARGS((
+static Void rgSCHCmnDlCcchTx ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnDlBcchPcch ARGS((
+static Void rgSCHCmnDlBcchPcch ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc
CmLteTimingInfo frm,
CmLteTimingInfo end
));
-PRIVATE Void rgSCHCmnClcAlloc ARGS((
+static Void rgSCHCmnClcAlloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *sf,
RgSchClcDlLcCb *lch,
-U16 rnti,
+uint16_t rnti,
RgSchCmnDlRbAllocInfo *allocInfo
));
#ifndef LTEMAC_SPS
-PRIVATE Void rgSCHCmnClcRbAlloc ARGS((
+static Void rgSCHCmnClcRbAlloc ARGS((
RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
RgSchDlSf *sf
));
#endif
-PRIVATE S16 rgSCHCmnMsg4Alloc ARGS((
+static S16 rgSCHCmnMsg4Alloc ARGS((
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE S16 rgSCHCmnMsg4DedAlloc ARGS((
+static S16 rgSCHCmnMsg4DedAlloc ARGS((
RgSchCellCb *cell,
RgSchRaCb *raCb
));
-PRIVATE Void rgSCHCmnDlRaRsp ARGS((
+static Void rgSCHCmnDlRaRsp ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE S16 rgSCHCmnRaRspAlloc ARGS((
+static S16 rgSCHCmnRaRspAlloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
-U16 rntiIdx,
-U16 rarnti,
-U8 noRaRnti,
+uint16_t rntiIdx,
+uint16_t rarnti,
+uint8_t noRaRnti,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnUlUeDelAllocs ARGS((
+static Void rgSCHCmnUlUeDelAllocs ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE Void rgSCHCmnDlSetUeAllocLmt ARGS((
+static Void rgSCHCmnDlSetUeAllocLmt ARGS((
RgSchCellCb *cell,
RgSchCmnDlUe *ueDl,
Bool isEmtcUe
));
-PRIVATE S16 rgSCHCmnDlRgrCellCfg ARGS((
+static S16 rgSCHCmnDlRgrCellCfg ARGS((
RgSchCellCb *cell,
RgrCellCfg *cfg,
RgSchErrInfo *err
));
-PRIVATE Void rgSCHCmnUlAdapRetx ARGS((
+static Void rgSCHCmnUlAdapRetx ARGS((
RgSchUlAlloc *alloc,
RgSchUlHqProcCb *proc
));
-PRIVATE Void rgSCHCmnUlUpdAllocRetx ARGS((
+static Void rgSCHCmnUlUpdAllocRetx ARGS((
RgSchCellCb *cell,
RgSchUlAlloc *alloc
));
-PRIVATE Void rgSCHCmnUlSfReTxAllocs ARGS((
+static Void rgSCHCmnUlSfReTxAllocs ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf
));
/* Fix: syed Adaptive Msg3 Retx crash. */
#ifdef TFU_UPGRADE
-PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
+static Void rgSCHCmnDlHdlTxModeRecfg ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
-U8 numTxPorts
+uint8_t numTxPorts
));
#else
-PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
+static Void rgSCHCmnDlHdlTxModeRecfg ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
* DL RB allocation specific functions
*/
-PRIVATE Void rgSCHCmnDlRbAlloc ARGS((
+static Void rgSCHCmnDlRbAlloc ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE Void rgSCHCmnNonDlfsRbAlloc ARGS((
+static Void rgSCHCmnNonDlfsRbAlloc ARGS((
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
));
-PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc ARGS((
+static S16 rgSCHCmnNonDlfsCmnRbAlloc ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *cmnAllocInfo));
#ifndef LTE_TDD
-PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj ARGS((
+static Void rgSCHCmnNonDlfsPbchRbAllocAdj ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *cmnAllocInfo,
-U8 pbchSsRsSym,
+uint8_t pbchSsRsSym,
Bool isBcchPcch
));
/* Added function to adjust TBSize*/
-PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj ARGS((
+static Void rgSCHCmnNonDlfsPbchTbSizeAdj ARGS((
RgSchDlRbAlloc *allocInfo,
-U8 numOvrlapgPbchRb,
-U8 pbchSsRsSym,
-U8 idx,
-U32 bytesReq
+uint8_t numOvrlapgPbchRb,
+uint8_t pbchSsRsSym,
+uint8_t idx,
+uint32_t bytesReq
));
/* Added function to find num of overlapping PBCH rb*/
-PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs ARGS((
+static Void rgSCHCmnFindNumPbchOvrlapRbs ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 *numOvrlapgPbchRb
+uint8_t *numOvrlapgPbchRb
));
-PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl ARGS((
+static uint8_t rgSCHCmnFindNumAddtlRbsAvl ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo
));
#ifdef DEBUGP
#ifdef UNUSED_FUNC
-PRIVATE Void rgSCHCmnFindCodeRate ARGS((
+static Void rgSCHCmnFindCodeRate ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 idx
+uint8_t idx
));
#endif
#endif
#endif
-PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
+static Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
RgSchCellCb *cell,
RgSchCmnMsg4RbAlloc *msg4AllocInfo,
-U8 isRetx
+uint8_t isRetx
));
-PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc ARGS((
+static S16 rgSCHCmnNonDlfsMsg4RbAlloc ARGS((
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgSchDlSf *dlSf
));
-PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc ARGS((
+static S16 rgSCHCmnNonDlfsUeRbAlloc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 *isDlBwAvail
+uint8_t *isDlBwAvail
));
#ifndef LTEMAC_SPS
-PRIVATE U32 rgSCHCmnCalcRiv ARGS(( U8 bw,
- U8 rbStart,
- U8 numRb));
+static uint32_t rgSCHCmnCalcRiv ARGS(( uint8_t bw,
+ uint8_t rbStart,
+ uint8_t numRb));
#endif
#ifdef LTE_TDD
-PRIVATE Void rgSCHCmnUpdHqAndDai ARGS((
+static Void rgSCHCmnUpdHqAndDai ARGS((
RgSchDlHqProcCb *hqP,
RgSchDlSf *subFrm,
RgSchDlHqTbCb *tbCb,
-U8 tbAllocIdx
+uint8_t tbAllocIdx
));
-PRIVATE S16 rgSCHCmnUlCalcAvailBw ARGS((
+static S16 rgSCHCmnUlCalcAvailBw ARGS((
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
-U8 cfi,
-U8 *rbStartRef,
-U8 *bwAvailRef
+uint8_t cfi,
+uint8_t *rbStartRef,
+uint8_t *bwAvailRef
));
-PRIVATE S16 rgSCHCmnDlKdashUlAscInit ARGS((
+static S16 rgSCHCmnDlKdashUlAscInit ARGS((
RgSchCellCb *cell
));
-PRIVATE S16 rgSCHCmnDlANFdbkInit ARGS((
+static S16 rgSCHCmnDlANFdbkInit ARGS((
RgSchCellCb *cell
));
-PRIVATE S16 rgSCHCmnDlNpValInit ARGS((
+static S16 rgSCHCmnDlNpValInit ARGS((
RgSchCellCb *cell
));
-PRIVATE S16 rgSCHCmnDlCreateRachPrmLst ARGS((
+static S16 rgSCHCmnDlCreateRachPrmLst ARGS((
RgSchCellCb *cell
));
-PRIVATE S16 rgSCHCmnDlCpyRachInfo ARGS((
+static S16 rgSCHCmnDlCpyRachInfo ARGS((
RgSchCellCb *cell,
RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
-U8 raArrSz
+uint8_t raArrSz
));
-PRIVATE S16 rgSCHCmnDlRachInfoInit ARGS((
+static S16 rgSCHCmnDlRachInfoInit ARGS((
RgSchCellCb *cell
));
-PRIVATE S16 rgSCHCmnDlPhichOffsetInit ARGS((
+static S16 rgSCHCmnDlPhichOffsetInit ARGS((
RgSchCellCb *cell
));
#endif
#ifdef TFU_UPGRADE
-PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt ARGS
+static Void rgSCHCmnFindUlCqiUlTxAnt ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U8 wideCqi
+ uint8_t wideCqi
));
- PRIVATE RgSchCmnRank rgSCHCmnComputeRank ARGS
+ static RgSchCmnRank rgSCHCmnComputeRank ARGS
((
RgrTxMode txMode,
- U32 *pmiBitMap,
- U8 numTxPorts
+ uint32_t *pmiBitMap,
+ uint8_t numTxPorts
));
- PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3 ARGS
+ static RgSchCmnRank rgSCHCmnComp2TxMode3 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
- PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3 ARGS
+ static RgSchCmnRank rgSCHCmnComp4TxMode3 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
- PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4 ARGS
+ static RgSchCmnRank rgSCHCmnComp2TxMode4 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
- PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4 ARGS
+ static RgSchCmnRank rgSCHCmnComp4TxMode4 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
- PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr ARGS
+ static uint8_t rgSCHCmnCalcWcqiFrmSnr ARGS
((
RgSchCellCb *cell,
TfuSrsRpt *srsRpt
*
* Invoked by: Scheduler
*
- * @param[in] U8 noPdcchSym
- * @param[in] U8 cpType
- * @param[in] U8 txAntIdx
+ * @param[in] uint8_t noPdcchSym
+ * @param[in] uint8_t cpType
+ * @param[in] uint8_t txAntIdx
* @param[in] RgSchCmnTbSzEff* effTbl
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnCompEff
+static Void rgSCHCmnCompEff
(
-U8 noPdcchSym,
-U8 cpType,
-U8 txAntIdx,
-RgSchCmnTbSzEff *effTbl
+uint8_t noPdcchSym,
+uint8_t cpType,
+uint8_t txAntIdx,
+RgSchCmnTbSzEff *effTbl
)
#else
-PRIVATE Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
-U8 noPdcchSym;
-U8 cpType;
-U8 txAntIdx;
-RgSchCmnTbSzEff *effTbl;
+static Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
+uint8_t noPdcchSym;
+uint8_t cpType;
+uint8_t txAntIdx;
+RgSchCmnTbSzEff *effTbl;
#endif
{
- U8 noResPerRb;
- U8 noSymPerRb;
- U8 resOfCrs; /* Effective REs occupied by CRS */
- U8 i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t resOfCrs; /* Effective REs occupied by CRS */
+ uint8_t i, j;
- TRC2(rgSCHCmnCompEff);
switch (cpType)
{
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
/* Depending on the Tx Antenna Index, deduct the
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
}
(*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
}
- RETVOID;
+ return;
}
/**
* @brief This function computes efficiency and stores in a table.
*
* Invoked by: Scheduler
*
- * @param[in] U8 noUlRsSym
- * @param[in] U8 cpType
- * @param[in] U8 txAntIdx
+ * @param[in] uint8_t noUlRsSym
+ * @param[in] uint8_t cpType
+ * @param[in] uint8_t txAntIdx
* @param[in] RgSchCmnTbSzEff* effTbl
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnCompUlEff
+static Void rgSCHCmnCompUlEff
(
-U8 noUlRsSym,
-U8 cpType,
-RgSchCmnTbSzEff *effTbl
+uint8_t noUlRsSym,
+uint8_t cpType,
+RgSchCmnTbSzEff *effTbl
)
#else
-PRIVATE Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
-U8 noUlRsSym;
-U8 cpType;
-RgSchCmnTbSzEff *effTbl;
+static Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
+uint8_t noUlRsSym;
+uint8_t cpType;
+RgSchCmnTbSzEff *effTbl;
#endif
{
- U8 noResPerRb;
- U8 noSymPerRb;
- U8 i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t i, j;
- TRC2(rgSCHCmnCompUlEff);
switch (cpType)
{
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
noResPerRb = ((noSymPerRb - noUlRsSym) * RB_SCH_CMN_NUM_SCS_PER_RB);
}
(*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
}
- RETVOID;
+ return;
}
/**
*
* Invoked by: Scheduler
*
- * @param[in] U8 noPdcchSym
- * @param[in] U8 cpType
- * @param[in] U8 txAntIdx
+ * @param[in] uint8_t noPdcchSym
+ * @param[in] uint8_t cpType
+ * @param[in] uint8_t txAntIdx
* @param[in] RgSchCmnTbSzEff* effTbl2Lyr
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmn2LyrCompEff
+static Void rgSCHCmn2LyrCompEff
(
-U8 noPdcchSym,
-U8 cpType,
-U8 txAntIdx,
+uint8_t noPdcchSym,
+uint8_t cpType,
+uint8_t txAntIdx,
RgSchCmnTbSzEff *effTbl2Lyr
)
#else
-PRIVATE Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
-U8 noPdcchSym;
-U8 cpType;
-U8 txAntIdx;
+static Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
+uint8_t noPdcchSym;
+uint8_t cpType;
+uint8_t txAntIdx;
RgSchCmnTbSzEff *effTbl2Lyr;
#endif
{
- U8 noResPerRb;
- U8 noSymPerRb;
- U8 resOfCrs; /* Effective REs occupied by CRS */
- U8 i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t resOfCrs; /* Effective REs occupied by CRS */
+ uint8_t i, j;
- TRC2(rgSCHCmn2LyrCompEff);
switch (cpType)
{
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
/* Depending on the Tx Antenna Index, deduct the
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
}
(*effTbl2Lyr)[i] /= RG_SCH_CMN_NUM_RBS;
}
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnGetDciFrmtSizes
+static Void rgSCHCmnGetDciFrmtSizes
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnGetDciFrmtSizes(cell)
+static Void rgSCHCmnGetDciFrmtSizes(cell)
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHCmnGetDciFrmtSizes);
/* DCI Format 0 size determination */
rgSchCmnDciFrmtSizes[0] = 1 +
/* DCI Format 3A size determination */
rgSchCmnDciFrmtSizes[9] = rgSchCmnDciFrmtSizes[0];
- RETVOID;
+ return;
}
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl
+static Void rgSCHCmnGetCqiDciFrmt2AggrLvl
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl(cell)
+static Void rgSCHCmnGetCqiDciFrmt2AggrLvl(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 i;
- U8 j;
+ uint8_t i;
+ uint8_t j;
- TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
{
for (j = 0; j < 10; j++)
{
- U32 pdcchBits; /* Actual number of phy bits needed for a given DCI Format
+ uint32_t pdcchBits; /* Actual number of phy bits needed for a given DCI Format
* for a given CQI Level */
pdcchBits = (rgSchCmnDciFrmtSizes[j] * 1024)/rgSchCmnCqiPdcchEff[i];
/* V5G_211 : 6.6 */
cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL16;
}
}
- RETVOID;
+ return;
}
\f
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlInit
+static Void rgSCHCmnDlInit
(
)
#else
-PRIVATE Void rgSCHCmnDlInit()
+static Void rgSCHCmnDlInit()
#endif
{
- U8 i;
+ uint8_t i;
S16 j;
S16 k;
- U8 idx;
+ uint8_t idx;
RgSchCmnTbSzEff *effTbl;
RgSchCmnCqiToTbs *tbsTbl;
- TRC2(rgSCHCmnDlInit);
/* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
/* Init Efficiency table for normal cyclic prefix */
for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
{
/* EfficiencyTbl calculation incase of 2 layers for normal CP */
- rgSCHCmnCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
+ rgSCHCmnCompEff((uint8_t)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i]);
- rgSCHCmn2LyrCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
+ rgSCHCmn2LyrCompEff((uint8_t)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i]);
}
}
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
{
/* EfficiencyTbl calculation incase of 2 layers for extendedl CP */
- rgSCHCmnCompEff( (U8)(i + 1 ), (U8)RG_SCH_CMN_EXT_CP, idx,\
+ rgSCHCmnCompEff( (uint8_t)(i + 1 ), (uint8_t)RG_SCH_CMN_EXT_CP, idx,\
rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i]);
- rgSCHCmn2LyrCompEff((U8)(i + 1), (U8) RG_SCH_CMN_EXT_CP,idx, \
+ rgSCHCmn2LyrCompEff((uint8_t)(i + 1), (uint8_t) RG_SCH_CMN_EXT_CP,idx, \
rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i]);
}
}
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
}
}
}
- RETVOID;
+ return;
}
\f
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlInit
+static Void rgSCHCmnUlInit
(
)
#else
-PRIVATE Void rgSCHCmnUlInit()
+static Void rgSCHCmnUlInit()
#endif
{
- U8 *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
+ uint8_t *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
RgSchCmnTbSzEff *effTbl = &rgSchCmnNorUlEff[0];
- CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
+ const RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
S16 i;
S16 j;
- TRC2(rgSCHCmnUlInit);
/* Initaializing new variable added for UL eff */
rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
{
if ((*effTbl)[i] <= cqiTbl[j].eff)
{
- mapTbl[j--] = (U8)i;
+ mapTbl[j--] = (uint8_t)i;
}
}
for (; j > 0; --j)
{
if ((*effTbl)[i] <= cqiTbl[j].eff)
{
- mapTbl[j--] = (U8)i;
+ mapTbl[j--] = (uint8_t)i;
}
}
for (; j > 0; --j)
mapTbl[j] = 0;
}
rgSCHPwrInit();
- RETVOID;
+ return;
}
/**
Void rgSCHCmnInit()
#endif
{
- U8 idx;
- TRC2(rgSCHCmnInit);
+ uint8_t idx;
rgSCHCmnDlInit();
rgSCHCmnUlInit();
rgSchCmnApis.rgSCHRgrSCellUeCfg = rgSCHCmnRgrSCellUeCfg;
rgSchCmnApis.rgSCHRgrSCellUeDel = rgSCHCmnRgrSCellUeDel;
#endif
- RETVOID;
+ return;
}
\f
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *sf;
- TRC2(rgSCHCmnDlRlsSubFrm);
/* Get the pointer to the subframe */
sf = rgSCHUtlSubFrmGet(cell, frm);
/* Re-initialize DLFS specific information for the sub-frame */
cellSch->apisDlfs->rgSCHDlfsReinitSf(cell, sf);
}
- RETVOID;
+ return;
}
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchRarAlloc
+static Void rgSCHCmnDlCcchRarAlloc
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnDlCcchRarAlloc(cell)
+static Void rgSCHCmnDlCcchRarAlloc(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCcchRarAlloc);
rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
/* LTE_ADV_FLAG_REMOVED_START */
/* LTE_ADV_FLAG_REMOVED_END */
#endif
- RETVOID;
+ return;
}
#ifdef RGR_V1
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnCcchSduAlloc
+static S16 rgSCHCmnCcchSduAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE S16 rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)
+static S16 rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
RgSchCmnDlRbAllocInfo *allocInfo;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnCcchSduAlloc);
/* Return if subframe BW exhausted */
if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchSduTx
+static Void rgSCHCmnDlCcchSduTx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchSduTx(cell, allocInfo)
+static Void rgSCHCmnDlCcchSduTx(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduTx);
node = cell->ccchSduUeLst.first;
while(node)
}
}
}
- RETVOID;
+ return;
}
#endif
\f
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchTx
+static Void rgSCHCmnDlCcchTx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchTx(cell, allocInfo)
+static Void rgSCHCmnDlCcchTx(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchTx);
node = cell->raInfo.toBeSchdLst.first;
while(node)
}
}
}
- RETVOID;
+ return;
}
#ifdef RGR_V1
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchSduRetx
+static Void rgSCHCmnDlCcchSduRetx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchSduRetx(cell, allocInfo)
+static Void rgSCHCmnDlCcchSduRetx(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchUeCb *ueCb;
RgSchDlHqProcCb *hqP;
- U8 retxBw = 0;
+ uint8_t retxBw = 0;
RgSchCmnDlUe *ueDl;
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduRetx);
node = cellSch->dl.ccchSduRetxLst.first;
while(node)
}
}
dlSf->bwAssigned += retxBw;
- RETVOID;
+ return;
}
#endif
\f
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchRetx
+static Void rgSCHCmnDlCcchRetx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchRetx(cell, allocInfo)
+static Void rgSCHCmnDlCcchRetx(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchRaCb *raCb;
RgSchDlHqProcCb *hqP;
- U8 retxBw = 0;
+ uint8_t retxBw = 0;
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchRetx);
node = cellSch->dl.msg4RetxLst.first;
while(node)
}
}
dlSf->bwAssigned += retxBw;
- RETVOID;
+ return;
}
\f
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlBcchPcch
+static Void rgSCHCmnDlBcchPcch
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc
)
#else
-PRIVATE Void rgSCHCmnDlBcchPcch(cell, allocInfo, subfrmAlloc)
+static Void rgSCHCmnDlBcchPcch(cell, allocInfo, subfrmAlloc)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
RgInfSfAlloc *subfrmAlloc;
#endif/*RGR_SI_SCH*/
- TRC2(rgSCHCmnDlBcchPcch);
frm = cell->crntTime;
#ifdef LTEMAC_HDFDD
if (bch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
- RETVOID;
+ return;
}
#endif
if (bch->boLst.first != NULLP)
if (bcch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
- RETVOID;
+ return;
}
#endif
if (bcch->boLst.first != NULLP)
if (bcch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
- RETVOID;
+ return;
}
#endif
lnk = bcch->boLst.first;
if (pcch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
- RETVOID;
+ return;
}
#endif
if (pcch->boLst.first != NULLP)
rgSCHCmnClcAlloc(cell, sf, pcch, RGSCH_P_RNTI, allocInfo);
}
}
- RETVOID;
+ return;
}
/*
{
Bool inWin = FALSE;
- TRC2(rgSCHCmnChkInWin);
if (end.sfn > start.sfn)
{
CmLteTimingInfo refFrm = end;
Bool pastWin;
- TRC2(rgSCHCmnChkPastWin);
RGSCH_INCR_FRAME(refFrm.sfn);
RGSCH_INCR_SUB_FRAME(end, 1);
* @param[in] RgSchCellCb *cell,
* @param[in] RgSchDlSf *sf,
* @param[in] RgSchClcDlLcCb *lch,
- * @param[in] U16 rnti,
+ * @param[in] uint16_t rnti,
* @param[out] RgSchCmnDlRbAllocInfo *allocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnClcAlloc
+static Void rgSCHCmnClcAlloc
(
RgSchCellCb *cell,
RgSchDlSf *sf,
RgSchClcDlLcCb *lch,
-U16 rnti,
+uint16_t rnti,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnClcAlloc(cell, sf, lch, rnti, allocInfo)
+static Void rgSCHCmnClcAlloc(cell, sf, lch, rnti, allocInfo)
RgSchCellCb *cell;
RgSchDlSf *sf;
RgSchClcDlLcCb *lch;
-U16 rnti;
+uint16_t rnti;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchClcBoRpt *bo;
- U32 rb=0;
- U8 mcs;
- U32 tbs;
+ uint32_t rb=0;
+ uint8_t mcs;
+ uint32_t tbs;
#ifdef LTE_TDD
- U8 lostRe;
- U8 cfi = cellDl->currCfi;
+ uint8_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnClcAlloc);
bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
"failed for CRNTI:%d",rnti);
- RETVOID;
+ return;
}
/* Update the subframe Allocated BW field */
allocInfo->pcchAlloc.tbInfo[0].noLyr = 1;
allocInfo->pcchAlloc.nPrb = bo->nPrb;
}
- RETVOID;
+ return;
}
\f
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 numCce; /*store num CCEs based on
+ uint8_t numCce; /*store num CCEs based on
aggregation level */
- TRC2(rgSCHCmnCmnPdcchAlloc);
aggrLvl = cellSch->dl.cmnChAggrLvl;
* Invoked by: Scheduler
*
* @param[in] RgSchCellCb* cell
- * @param[in] U32 bo
- * @param[in] U8 cqi
- * @param[in] U8 *rb
- * @param[in] U32 *tbs
- * @param[in] U8 *mcs
+ * @param[in] uint32_t bo
+ * @param[in] uint8_t cqi
+ * @param[in] uint8_t *rb
+ * @param[in] uint32_t *tbs
+ * @param[in] uint8_t *mcs
* @param[in] RgSchDlSf *sf
* @return Void
*
#ifdef ANSI
Void rgSCHCmnClcRbAlloc
(
-RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
-U8 *iTbs,
-Bool isSpsBo,
-RgSchDlSf *sf
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+uint8_t *iTbs,
+Bool isSpsBo,
+RgSchDlSf *sf
)
#else
Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
-RgSchCellCb *cell;
-U32 bo;
-U8 cqi;
-U8 *rb;
-U32 *tbs;
-U8 *mcs;
-U8 *iTbs;
-Bool isSpsBo;
-RgSchDlSf *sf;
-#endif
-#else
-#ifdef ANSI
-PRIVATE Void rgSCHCmnClcRbAlloc
-(
-RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
-RgSchDlSf *sf
-)
-#else
-PRIVATE Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
-RgSchCellCb *cell;
-U32 bo;
-U8 cqi;
-U8 *rb;
-U32 *tbs;
-U8 *mcs;
-RgSchDlSf *sf;
+RgSchCellCb *cell;
+uint32_t bo;
+uint8_t cqi;
+uint8_t *rb;
+uint32_t *tbs;
+uint8_t *mcs;
+uint8_t *iTbs;
+Bool isSpsBo;
+RgSchDlSf *sf;
+#endif
+#else
+#ifdef ANSI
+static Void rgSCHCmnClcRbAlloc
+(
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+RgSchDlSf *sf
+)
+#else
+static Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
+RgSchCellCb *cell;
+uint32_t bo;
+uint8_t cqi;
+uint8_t *rb;
+uint32_t *tbs;
+uint8_t *mcs;
+RgSchDlSf *sf;
#endif
#endif /* LTEMAC_SPS */
{
- U8 iTbsVal;
- RgSchCmnTbSzEff *effTbl;
- U32 eff;
- U32 noRes;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
- U32 tmpRb=0;
- TRC2(rgSCHCmnClcRbAlloc);
+ uint8_t iTbsVal;
+ RgSchCmnTbSzEff *effTbl;
+ uint32_t eff;
+ uint32_t noRes;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint32_t tmpRb=0;
/* first get the CQI to MCS table and determine the number of RBs */
effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
}
*tbs = rgTbSzTbl[0][iTbsVal][tmpRb-1]/8;
- *rb = (U8)tmpRb;
+ *rb = (uint8_t)tmpRb;
RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnMsg4Alloc
+static S16 rgSCHCmnMsg4Alloc
(
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE S16 rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)
+static S16 rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)
RgSchCellCb *cell;
RgSchRaCb *raCb;
RgSchCmnDlRbAllocInfo *allocInfo;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnMsg4Alloc);
/* SR_RACH_STATS : MSG4 TO BE TXED */
rgNumMsg4ToBeTx++;
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *subFrm,
-U8 cqi,
+uint8_t cqi,
TfuDciFormat dciFrmt,
Bool isDtx
)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *subFrm;
-U8 cqi;
+uint8_t cqi;
TfuDciFormat dciFrmt;
Bool isDtx;
#endif
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
- TRC2(rgSCHCmnPdcchAlloc);
/* 3.1 consider the selected DCI format size in determining the
* aggregation level */
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnCcchSduDedAlloc
+static S16 rgSCHCmnCcchSduDedAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
)
#else
-PRIVATE S16 rgSCHCmnCcchSduDedAlloc(cell, ueCb)
+static S16 rgSCHCmnCcchSduDedAlloc(cell, ueCb)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
#endif
{
RgSchDlHqEnt *hqE = NULLP;
- U32 effBo;
+ uint32_t effBo;
RgSchDlRbAlloc *rbAllocinfo = NULLP;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 iTbs;
- U8 numRb;
+ uint8_t iTbs;
+ uint8_t numRb;
#ifdef LTE_TDD
- U8 cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnCcchSduDedAlloc);
rbAllocinfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnMsg4DedAlloc
+static S16 rgSCHCmnMsg4DedAlloc
(
RgSchCellCb *cell,
RgSchRaCb *raCb
)
#else
-PRIVATE S16 rgSCHCmnMsg4DedAlloc(cell, raCb)
+static S16 rgSCHCmnMsg4DedAlloc(cell, raCb)
RgSchCellCb *cell;
RgSchRaCb *raCb;
#endif
{
- U32 effBo;
+ uint32_t effBo;
RgSchDlRbAlloc *rbAllocinfo = &raCb->rbAllocInfo;
- U8 iTbs;
- U8 numRb;
+ uint8_t iTbs;
+ uint8_t numRb;
#ifdef LTE_TDD
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnMsg4DedAlloc);
effBo = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRaRsp
+static Void rgSCHCmnDlRaRsp
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
+static Void rgSCHCmnDlRaRsp(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
CmLteTimingInfo frm;
CmLteTimingInfo schFrm;
RgSchDlSf *subFrm;
- U16 rarnti;
- U8 i;
- U8 noRaRnti=0;
- U8 raIdx;
+ uint16_t rarnti;
+ uint8_t i;
+ uint8_t noRaRnti=0;
+ uint8_t raIdx;
RgSchTddRachRspLst *rachRsp;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 sfnIdx;
- U8 subfrmIdx;
- U16 rntiIdx=0;
- TRC2(rgSCHCmnDlRaRsp);
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfnIdx;
+ uint8_t subfrmIdx;
+ uint16_t rntiIdx=0;
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
}
}
- RETVOID;
+ return;
}
#else
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRaRsp //FDD
+static Void rgSCHCmnDlRaRsp //FDD
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
+static Void rgSCHCmnDlRaRsp(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
CmLteTimingInfo frm;
CmLteTimingInfo winStartFrm;
RgSchDlSf *subFrm;
- U8 winStartIdx;
- U8 winGap;
- U8 rarnti;
- U8 raIdx;
+ uint8_t winStartIdx;
+ uint8_t winGap;
+ uint8_t rarnti;
+ uint8_t raIdx;
RgSchCmnCell *sched;
- U8 i,noRaRnti=0;
- TRC2(rgSCHCmnDlRaRsp);
+ uint8_t i,noRaRnti=0;
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
for response allocation */
}
}
- RETVOID;
+ return;
}
#endif
*
* @param[in] RgSchCellCb *cell,
* @param[in] RgSchDlSf *subFrm,
- * @param[in] U16 rarnti,
- * @param[in] U8 noRaRnti
+ * @param[in] uint16_t rarnti,
+ * @param[in] uint8_t noRaRnti
* @param[out] RgSchCmnDlRbAllocInfo *allocInfo
* @return S16
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnRaRspAlloc
+static S16 rgSCHCmnRaRspAlloc
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
-U16 raIndex,
-U16 rarnti,
-U8 noRaRnti,
+uint16_t raIndex,
+uint16_t rarnti,
+uint8_t noRaRnti,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
+static S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
-U16 raIndex;
-U16 rarnti;
-U8 noRaRnti;
+uint16_t raIndex;
+uint16_t rarnti;
+uint8_t noRaRnti;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U16 noBytes;
- U32 rb = 0;
- U32 tbs;
+ uint16_t noBytes;
+ uint32_t rb = 0;
+ uint32_t tbs;
/*ccpu00116700,ccpu00116708- Corrected the wrong type for mcs*/
- U8 mcs;
+ uint8_t mcs;
CmLListCp *reqLst;
/* RACH handling related changes */
Bool isAlloc = FALSE;
- static U8 schdNumRapid = 0;
- U8 remNumRapid = 0;
- U8 nPrb = 0;
+ static uint8_t schdNumRapid = 0;
+ uint8_t remNumRapid = 0;
+ uint8_t nPrb = 0;
S32 allwdTbSz = 0;
#ifdef LTE_TDD
- U16 lostRe;
- U8 cfi = cellDl->currCfi;
+ uint16_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnRaRspAlloc);
#ifndef RGR_V1
UNUSED(cellUl);
#endif
/* rgSCHCmnClcRbAllocForFxdTb(cell, allwdTbSz/8, cellDl->ccchCqi, &rb);*/
if(cellDl->bitsPerRb==0)
{
- while ((rgTbSzTbl[0][0][rb]) <(U32) allwdTbSz)
+ while ((rgTbSzTbl[0][0][rb]) <(uint32_t) allwdTbSz)
{
rb++;
}
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
- TRC2(rgSCHCmnUlAllocFillRbInfo);
alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) +
cell->dynCfiCb.bwInfo[cfi].startRb;
/* Num RBs = numSbAllocated * sbSize - less RBs in the last SB */
alloc->grnt.numRb = (alloc->numSb * cellUl->sbSize);
- RETVOID;
+ return;
}
/**
* @param[in] Bool preamGrpA
* @param[in] RgSchUlHqProcCb *hqProc
* @param[out] RgSchUlAlloc **ulAllocRef
- * @param[out] U8 *hqProcIdRef
+ * @param[out] uint8_t *hqProcIdRef
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnMsg3GrntReq
+static Void rgSCHCmnMsg3GrntReq
(
RgSchCellCb *cell,
CmLteRnti rnti,
Bool preamGrpA,
RgSchUlHqProcCb *hqProc,
RgSchUlAlloc **ulAllocRef,
-U8 *hqProcIdRef
+uint8_t *hqProcIdRef
)
#else
-PRIVATE Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
+static Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
ulAllocRef, hqProcIdRef)
RgSchCellCb *cell;
CmLteRnti rnti;
Bool preamGrpA;
RgSchUlHqProcCb *hqProc;
RgSchUlAlloc **ulAllocRef;
-U8 *hqProcIdRef;
+uint8_t *hqProcIdRef;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
RgSchUlHole *hole;
RgSchUlAlloc *alloc;
- U8 iMcs;
- U8 numSb;
+ uint8_t iMcs;
+ uint8_t numSb;
- TRC2(rgSCHCmnMsg3GrntReq);
*ulAllocRef = NULLP;
/* Fix: ccpu00120610 Use remAllocs from subframe during msg3 allocation */
if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
{
- RETVOID;
+ return;
}
if (preamGrpA == FALSE)
{
}
if (numSb <= hole->num)
{
- U8 iTbs;
+ uint8_t iTbs;
alloc = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
alloc->grnt.iMcs = iMcs;
alloc->pdcch = FALSE;
alloc->forMsg3 = TRUE;
alloc->hqProc = hqProc;
- rgSCHUhmNewTx(hqProc, (U8)(cell->rachCfg.maxMsg3Tx - 1), alloc);
+ rgSCHUhmNewTx(hqProc, (uint8_t)(cell->rachCfg.maxMsg3Tx - 1), alloc);
//RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
printf(
"\nRNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
}
}
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlSetUeAllocLmt
+static Void rgSCHCmnDlSetUeAllocLmt
(
RgSchCellCb *cell,
RgSchCmnDlUe *ueDl,
Bool isEmtcUe
)
#else
-PRIVATE Void rgSCHCmnDlSetUeAllocLmt(cell, ueDl, isEmtcUe)
+static Void rgSCHCmnDlSetUeAllocLmt(cell, ueDl, isEmtcUe)
RgSchCellCb *cell;
RgSchCmnDlUe *ueDl;
Bool isEmtcUe;
#endif
{
- U8 modOrder;
- U32 maxRb;
+ uint8_t modOrder;
+ uint32_t maxRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
+ uint8_t cfi = cellSch->dl.currCfi;
- TRC2(rgSCHCmnDlSetUeAllocLmt);
#ifdef EMTC_ENABLE
if(TRUE == isEmtcUe)
}
}
- RETVOID;
+ return;
}
#ifdef DL_LA
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCheckAndSetTxScheme
+static Void rgSCHCheckAndSetTxScheme
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCheckAndSetTxScheme(cell, ue)
+static Void rgSCHCheckAndSetTxScheme(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue ,cell);
- U8 cfi = cellSch->dl.currCfi;
- U8 maxiTbs;
- U8 cqiBasediTbs;
- U8 actualiTbs;
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs;
+ uint8_t cqiBasediTbs;
+ uint8_t actualiTbs;
- TRC2(rgSCHCheckAndSetTxScheme);
maxiTbs = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
[RG_SCH_CMN_MAX_CQI - 1];
RG_SCH_CMN_UNSET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
}
- RETVOID;
+ return;
}
/**
RgSchUeCb *ue;
#endif
{
- U8 modOrder;
- U32 maxRb;
- U8 reportediTbs;
+ uint8_t modOrder;
+ uint32_t maxRb;
+ uint8_t reportediTbs;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 cfi = cellSch->dl.currCfi;
- U8 maxiTbs;
- U8 cwIdx = 0;
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs;
+ uint8_t cwIdx = 0;
- TRC2(rgSCHCmnDlSetUeAllocLmtLa);
maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
if(ueDl->cqiFlag == TRUE)
}
- RETVOID;
+ return;
}
#endif
/***********************************************************
#endif
{
- TRC2(rgSCHCmnDlHqPResetTemp);
/* Fix: syed having a hqP added to Lists for RB assignment rather than
* a UE, as adding UE was limiting handling some scenarios */
hqP->reqLnk.node = (PTR)NULLP;
hqP->schdLstLnk.node = (PTR)NULLP;
- RETVOID;
+ return;
} /* rgSCHCmnDlHqPResetTemp */
/***********************************************************
Void *tmpCb;
#endif
- TRC2(rgSCHCmnDlUeResetTemp);
/* Fix : syed check for UE's existence was useless.
* Instead we need to check that reset is done only for the
#ifdef LTE_ADV
tmpCb = allocInfo->laaCb;
#endif
- cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo, 0, sizeof(RgSchDlRbAlloc));
allocInfo->rnti = ue->ueId;
#ifdef LTE_ADV
allocInfo->laaCb = tmpCb;
}
rgSCHCmnDlHqPResetTemp(hqP);
- RETVOID;
+ return;
} /* rgSCHCmnDlUeResetTemp */
/***********************************************************
{
RgSchCmnUlUe *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlUeResetTemp);
- cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
+ memset(&cmnUlUe->alloc, 0, sizeof(cmnUlUe->alloc));
- RETVOID;
+ return;
} /* rgSCHCmnUlUeResetTemp */
#endif
{
- TRC2(rgSCHCmnFillPdcch);
/* common channel pdcch filling,
* only 1A and Local is supported */
"dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
break;
}
- RETVOID;
+ return;
}
#ifdef LTE_TDD
*
* Invoked by: Scheduler
*
- * @param[in] U8 splfrmCnt
- * @param[in] U8 curSubfrmIdx
- * @param[in] U8 periodicity
+ * @param[in] uint8_t splfrmCnt
+ * @param[in] uint8_t curSubfrmIdx
+ * @param[in] uint8_t periodicity
* @param[in] RgSchTddSubfrmInfo *subfrmInfo
* @return Bool
*
**/
#ifdef ANSI
-PRIVATE Bool rgSCHCmnIsSplSubfrm
+static Bool rgSCHCmnIsSplSubfrm
(
-U8 splfrmCnt,
-U8 curSubfrmIdx,
-U8 periodicity,
+uint8_t splfrmCnt,
+uint8_t curSubfrmIdx,
+uint8_t periodicity,
RgSchTddSubfrmInfo *subfrmInfo
)
#else
-PRIVATE Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
-U8 splfrmCnt;
-U8 curSubfrmIdx;
-U8 periodicity;
+static Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
+uint8_t splfrmCnt;
+uint8_t curSubfrmIdx;
+uint8_t periodicity;
RgSchTddSubfrmInfo *subfrmInfo;
#endif
{
- U8 dlSfCnt = 0;
- U8 splfrmIdx = 0;
+ uint8_t dlSfCnt = 0;
+ uint8_t splfrmIdx = 0;
- TRC2(rgSCHCmnIsSplSubfrm);
if(splfrmCnt > 0)
{
* @param[in] RgDlHqProcCb *hqP
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchDlHqTbCb *tbCb
- * @param[in] U8 tbAllocIdx
+ * @param[in] uint8_t tbAllocIdx
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdHqAndDai
+static Void rgSCHCmnUpdHqAndDai
(
RgSchDlHqProcCb *hqP,
RgSchDlSf *subFrm,
RgSchDlHqTbCb *tbCb,
-U8 tbAllocIdx
+uint8_t tbAllocIdx
)
#else
-PRIVATE Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
+static Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
RgSchDlHqProcCb *hqP;
RgSchDlSf *subFrm;
RgSchDlHqTbCb *tbCb;
-U8 tbAllocIdx;
+uint8_t tbAllocIdx;
#endif
{
RgSchUeCb *ue = hqP->hqE->ue;
- TRC2(rgSCHCmnUpdHqAndDai);
if(subFrm != NULLP)
{
if(ue && !tbAllocIdx)
{
Bool havePdcch = (tbCb->hqP->pdcch ? TRUE : FALSE);
- U8 dlDai;
+ uint8_t dlDai;
dlDai = rgSCHCmnUpdDai(ue, &tbCb->fdbkTime, tbCb->m, havePdcch,tbCb->hqP,
&tbCb->dai);
fdbk reception */
tbCb->pucchFdbkIdx = tbCb->hqP->ulDai;
- RETVOID;
+ return;
}
* @param[in] RgDlHqProcCb *hqP
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchDlHqTbCb *tbCb
- * @return U8 dlDai
+ * @return uint8_t dlDai
*
**/
#ifdef ANSI
-U8 rgSCHCmnUpdDai
+uint8_t rgSCHCmnUpdDai
(
RgSchUeCb *ue,
CmLteTimingInfo *fdbkTime,
-U8 m,
+uint8_t m,
Bool havePdcch,
RgSchDlHqProcCb *hqP,
-U8 *ulDai
+uint8_t *ulDai
)
#else
-U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
+uint8_t rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
RgSchUeCb *ue;
CmLteTimingInfo *fdbkTime;
-U8 m;
+uint8_t m;
Bool havePdcch;
RgSchDlHqProcCb *hqP;
-U8 *ulDai;
+uint8_t *ulDai;
#endif
{
RgSchTddANInfo *anInfo;
- U8 servCellIdx;
- U8 ackNackFdbkArrSize;
+ uint8_t servCellIdx;
+ uint8_t ackNackFdbkArrSize;
- TRC2(rgSCHCmnUpdDai);
if(hqP != NULLP)
{/* Non SPS */
}
#endif /* ifdef LTE_TDD */
-U32 rgHqRvRetxCnt[4][2];
-U32 rgUlrate_grant;
+uint32_t rgHqRvRetxCnt[4][2];
+uint32_t rgUlrate_grant;
/**
* @brief This function fills the HqP TB with rbAllocInfo.
*
* @param[in] RgSchCellCb* cell
* @param[in] RgSchDlRbAlloc *rbAllocInfo,
- * @param[in] U8 tbAllocIdx
+ * @param[in] uint8_t tbAllocIdx
* @param[in] RgSchPdcch *pdcch
* @return Void
*
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
)
#else
Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
-U8 tbAllocIdx;
+uint8_t tbAllocIdx;
RgSchPdcch *pdcch;
#endif
#else
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPTb
+static Void rgSCHCmnFillHqPTb
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
)
#else
-PRIVATE Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
+static Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
-U8 tbAllocIdx;
+uint8_t tbAllocIdx;
RgSchPdcch *pdcch;
#endif
#endif /* LTEMAC_SPS */
RgSchDlHqTbCb *tbInfo = tbAllocInfo->tbCb;
RgSchDlHqProcCb *hqP = tbInfo->hqP;
- TRC2(rgSCHCmnFillHqPTb);
/*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
* Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
//tbInfo->dlGrnt.numRb = rbAllocInfo->rbsAlloc;
rgSCHUtlDlHqPTbAddToTx(hqP->subFrm, hqP, tbInfo->tbIdx);
}
- RETVOID;
+ return;
}
/**
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2
+static Void rgSCHCmnFillHqPPdcchDciFrmtB1B2
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
+static Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
- TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
//Currently hardcoding values here.
break;
}
- RETVOID;
+ return;
}
-extern U32 totPcellSCell;
-extern U32 addedForScell;
-extern U32 addedForScell1;
-extern U32 addedForScell2;
+uint32_t totPcellSCell;
+uint32_t addedForScell;
+uint32_t addedForScell1;
+uint32_t addedForScell2;
/**
* @brief This function fills the PDCCH information from dlProc.
*
{
RgSchCmnDlCell *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchPdcch *pdcch = rbAllocInfo->pdcch;
- U8 tpc = 1;
+ uint8_t tpc = 1;
- TRC2(rgSCHCmnFillHqPPdcch);
if (hqP->hqE->ue)
{
"Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
break;
}
- RETVOID;
+ return;
}
#ifdef UNUSED_FUNC
/**
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1
+static Void rgSCHCmnFillHqPPdcchDciFrmt1
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
+static Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1Info.tpcCmd = tpc;
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
#endif
- RETVOID;
+ return;
}
/**
* @brief This function fills the PDCCH DCI format 1A information from dlProc.
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A
+static Void rgSCHCmnFillHqPPdcchDciFrmt1A
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
+static Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
}
#endif
- RETVOID;
+ return;
}
/**
* @brief This function fills the PDCCH DCI format 1B information from dlProc.
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B
+static Void rgSCHCmnFillHqPPdcchDciFrmt1B
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
+static Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1bInfo.tpcCmd = tpc;
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
}
#endif
- RETVOID;
+ return;
}
/**
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2
+static Void rgSCHCmnFillHqPPdcchDciFrmt2
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
+static Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
}
#endif
- RETVOID;
+ return;
}
/**
* @brief This function fills the PDCCH DCI format 2A information from dlProc.
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A
+static Void rgSCHCmnFillHqPPdcchDciFrmt2A
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
+static Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
#ifdef LTE_TDD
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
#endif
- RETVOID;
+ return;
}
#endif
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnInitVars
+static Void rgSCHCmnInitVars
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnInitVars(cell)
+static Void rgSCHCmnInitVars(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnInitVars);
cellUl->idx = RGSCH_INVALID_INFO;
cellUl->schdIdx = RGSCH_INVALID_INFO;
cellUl->reTxIdx[0] = RGSCH_INVALID_INFO;
cellUl->reTxIdx[1] = RGSCH_INVALID_INFO;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
}
{
CmLteTimingInfo timeInfo;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U16 idx;
+ uint16_t idx;
- TRC2(rgSCHCmnUpdVars);
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
cellUl->idx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
idx = ((cellUl->schdIdx) % (RG_SCH_CMN_UL_NUM_SF));
- cellUl->reTxIdx[0] = (U8) idx;
+ cellUl->reTxIdx[0] = (uint8_t) idx;
#ifdef UL_ADPT_DBG
printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
#endif
* mainly the prachMaskIndex */
rgSCHCmnUpdRachParam(cell);
- RETVOID;
+ return;
}
#endif
*
* @param[in] CmLteTimingInfo *timeInfo
* @param[in] RgSchCellCb *cell
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetPhichUlSfIdx
+uint8_t rgSCHCmnGetPhichUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-U8 rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
+uint8_t rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchDlSf *dlsf;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 idx;
- U16 numUlSf;
- U16 sfn;
- U8 subframe;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t idx;
+ uint16_t numUlSf;
+ uint16_t sfn;
+ uint8_t subframe;
- TRC2(rgSCHCmnGetPhichUlSfIdx);
dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
sfn = (RGSCH_MAX_SFN + timeInfo->sfn -
dlsf->phichOffInfo.sfnOffset) % RGSCH_MAX_SFN;
- /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
+ /* ccpu00130980: numUlSf(uint16_t) parameter added to avoid integer
* wrap case such that idx will be proper*/
numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
* Purpose: Gets uplink subframe index based on SFN and subframe number.
*
* @param[in] CmLteTimingInfo *timeInfo
- * @param[in] U8 ulDlCfgIdx
- * @return U8
+ * @param[in] uint8_t ulDlCfgIdx
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetUlSfIdx
+uint8_t rgSCHCmnGetUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-U8 rgSCHCmnGetUlSfIdx(timeInfo, cell)
+uint8_t rgSCHCmnGetUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 idx = 0;
- U16 numUlSf;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t idx = 0;
+ uint16_t numUlSf;
- TRC2(rgSCHCmnGetUlSfIdx);
- /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
+ /* ccpu00130980: numUlSf(uint16_t) parameter added to avoid integer
* wrap case such that idx will be proper*/
numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
numUlSf = ((numUlSf * timeInfo->sfn) + \
* Purpose: Gets uplink subframe index based on SFN and subframe number.
*
* @param[in] CmLteTimingInfo *timeInfo
- * @param[in] U8 ulDlCfgIdx
- * @return U8
+ * @param[in] uint8_t ulDlCfgIdx
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetUlHqProcIdx
+uint8_t rgSCHCmnGetUlHqProcIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-U8 rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
+uint8_t rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
{
- U8 procId;
- U32 numUlSf;
+ uint8_t procId;
+ uint32_t numUlSf;
#ifndef LTE_TDD
numUlSf = (timeInfo->sfn * RGSCH_NUM_SUB_FRAMES_5G + timeInfo->slot);
procId = numUlSf % RGSCH_NUM_UL_HQ_PROC;
#else
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
/*ccpu00130639 - MOD - To get correct UL HARQ Proc IDs for all UL/DL Configs*/
- U8 numUlSfInSfn;
+ uint8_t numUlSfInSfn;
S8 sfnCycle = cell->tddHqSfnCycle;
- U8 numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
+ uint8_t numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
/* TRACE 5 Changes */
- TRC2(rgSCHCmnGetUlHqProcIdx);
/* Calculate the number of UL SF in one SFN */
numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
#endif
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
rgSCHUhmFreeProc(alloc->hqProc, cell);
rgSCHUtlUlAllocRelease(alloc);
rgSCHRamDelRaCb(cell, raCb, TRUE);
- RETVOID;
+ return;
}
}
hqProc = alloc->hqProc;
rgSCHUtlUlAllocRelease(alloc);
rgSCHUhmFreeProc(hqProc, cell);
- RETVOID;
+ return;
}
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
rgSCHUhmFreeProc(alloc->hqProc, cell);
rgSCHUtlUlAllocRls(sf, alloc);
rgSCHRamDelRaCb(cell, raCb, TRUE);
- RETVOID;
+ return;
}
}
#endif
rgSCHUtlUlAllocRls(sf, alloc);
- RETVOID;
+ return;
}
/**
RgSchDlSf *sf;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnPdcchAllocCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillNdmrs);
alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
- RETVOID;
+ return;
}
/***********************************************************
Bool isRetx;
#endif
{
- TRC2(rgSCHCmnUlAllocLnkHqProc);
if(TRUE == isRetx)
{
#endif
rgSCHUhmNewTx(proc, (((RgUeUlHqCb*)proc->hqEnt)->maxHqRetx), alloc);
}
- RETVOID;
+ return;
}
/**
CmLteTimingInfo frm = cell->crntTime;
RgSchDlSf *sf;
- TRC2(rgSCHCmnPdcchRlsCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, pdcch);
- RETVOID;
+ return;
}
/***********************************************************
*
#endif
{
- TRC2(rgSCHCmnUlFillPdcchWithAlloc);
pdcch->ue = ue;
pdcch->rnti = alloc->rnti;
}
- RETVOID;
+ return;
}
/***********************************************************
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillTpc);
alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
- RETVOID;
+ return;
}
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnAddUeToRefreshQ
+static Void rgSCHCmnAddUeToRefreshQ
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 wait
+uint32_t wait
)
#else
-PRIVATE Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
+static Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 wait;
+uint32_t wait;
#endif
{
RgSchCmnCell *sched = RG_SCH_CMN_GET_CELL(cell);
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnAddUeToRefreshQ);
UNUSED(cell);
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
arg.evnt = RG_SCH_CMN_EVNT_UE_REFRESH;
arg.wait = wait;
cmPlcCbTq(&arg);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlUeReset
+static Void rgSCHCmnUlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnUlUeReset(cell, ue)
+static Void rgSCHCmnUlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- U8 lcgCnt=0;
+ uint8_t lcgCnt=0;
RgSchCmnLcg *lcgCmn;
CmLList *node;
RgSchCmnAllocRecord *allRcd;
- TRC2(rgSCHCmnUlUeReset);
ue->ul.minReqBytes = 0;
ue->ul.totalBsr = 0;
cellSchd->apisUl->rgSCHUlUeReset(cell, ue);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnResetRiCqi
+static Void rgSCHCmnResetRiCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnResetRiCqi(cell, ue)
+static Void rgSCHCmnResetRiCqi(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnResetRiCqi);
rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
cell->isCpUlExtend);
}
#endif
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlUeReset
+static Void rgSCHCmnDlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnDlUeReset(cell, ue)
+static Void rgSCHCmnDlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlUeReset);
if (ueDl->rachInfo.poLnk.node != NULLP)
{
RgSchUeCb *ue;
#endif
{
- U8 idx;
+ uint8_t idx;
Pst pst;
RgInfResetHqEnt hqEntRstInfo;
- TRC2(rgSCHCmnUeReset);
/* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
rgSCHCmnDelRachInfo(cell, ue);
rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
RgSchMacRstHqEnt(&pst,&hqEntRstInfo);
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtUlUe);
/* : take care of this in UL retransmission */
cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtDlUe);
cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
- RETVOID;
+ return;
}
/**
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHCmnHdlUlTransInd);
/* Update the latest UL dat/sig transmission time */
RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
}
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
-PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4
+static RgSchCmnRank rgSCHCmnComp4TxMode4
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
-PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
- U32 *pmiBitMap;
+static RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0, bitMap1;
- TRC2(rgSCHCmnComp4TxMode4);
+ uint32_t bitMap0, bitMap1;
bitMap0 = pmiBitMap[0];
bitMap1 = pmiBitMap[1];
if((bitMap1) & 0xFFFF)
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
-PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4
+static RgSchCmnRank rgSCHCmnComp2TxMode4
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
-PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
- U32 *pmiBitMap;
+static RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode4);
+ uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
if((bitMap0>>26)& 0x0F)
{
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
-PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3
+static RgSchCmnRank rgSCHCmnComp4TxMode3
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
-PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
- U32 *pmiBitMap;
+static RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0;
- TRC2(rgSCHCmnComp4TxMode3);
+ uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
if((bitMap0>>28)& 1)
{
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
-PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3
+static RgSchCmnRank rgSCHCmnComp2TxMode3
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
-PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
- U32 *pmiBitMap;
+static RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode3);
+ uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
if((bitMap0>>30)& 1)
{
*
*
* @param[in] RgrTxMode txMode
- * @param[in] U32 *pmiBitMap
- * @param[in] U8 numTxPorts
+ * @param[in] uint32_t *pmiBitMap
+ * @param[in] uint8_t numTxPorts
* @return RgSchCmnRank
**/
#ifdef ANSI
-PRIVATE RgSchCmnRank rgSCHCmnComputeRank
+static RgSchCmnRank rgSCHCmnComputeRank
(
RgrTxMode txMode,
- U32 *pmiBitMap,
- U8 numTxPorts
+ uint32_t *pmiBitMap,
+ uint8_t numTxPorts
)
#else
-PRIVATE RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
+static RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
RgrTxMode txMode;
- U32 *pmiBitMap;
- U8 numTxPorts;
+ uint32_t *pmiBitMap;
+ uint8_t numTxPorts;
#endif
{
- TRC2(rgSCHCmnComputeRank);
if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
{
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
RgSchDlHqProcCb *hqP;
- U8 cnt;
+ uint8_t cnt;
S16 ret;
- TRC2(rgSCHCmnDlDeInitHqEnt);
ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
/* Free only If the Harq proc are created*/
rgSCHLaaDeInitDlHqProcCb (cell, hqE);
#endif
- RETVOID;
+ return;
}
/**
{
RgSchDlHqProcCb *hqP;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlInitHqEnt);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
{
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnGetRefreshDist
+static uint8_t rgSCHCmnGetRefreshDist
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE U8 rgSCHCmnGetRefreshDist(cell, ue)
+static uint8_t rgSCHCmnGetRefreshDist(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- U8 refOffst;
+ uint8_t refOffst;
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnGetRefreshDist);
for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
{
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 *waitPer
+ * @param[in] uint32_t *waitPer
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnGetRefreshPer
+static Void rgSCHCmnGetRefreshPer
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 *waitPer
+uint32_t *waitPer
)
#else
-PRIVATE Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
+static Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 *waitPer;
+uint32_t *waitPer;
#endif
{
- U32 refreshPer;
- U32 crntSubFrm;
+ uint32_t refreshPer;
+ uint32_t crntSubFrm;
- TRC2(rgSCHCmnGetRefreshPer);
refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot;
*waitPer = RGSCH_CEIL(*waitPer, RG_SCH_CMN_REFRESH_TIMERES);
*waitPer = *waitPer + rgSCHCmnGetRefreshDist(cell, ue);
- RETVOID;
+ return;
}
RgSchErrInfo *err;
#endif
{
- U8 i;
+ uint8_t i;
S16 ret;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnAllocRecord *allRcd;
RgSchDlRbAlloc *allocInfo;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
#ifdef DEBUGP
Inst inst = ue->cell->instIdx;
#endif
- U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- TRC2(rgSCHCmnRgrSCellUeCfg);
+ uint32_t idx = (uint8_t)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
pCellUeDl = &pCellUeSchCmn->dl;
RGSCH_ARRAY_BOUND_CHECK(sCell->instIdx, rgUeCatTbl, pCellUeSchCmn->cmn.ueCat);
ueDl->maxTbBits = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlTbBits;
/*CA dev-Start*/
- U8 ri = 0;
+ uint8_t ri = 0;
ri = RGSCH_MIN(ri, sCell->numTxAntPorts);
if(((CM_LTE_UE_CAT_6 == pCellUeSchCmn->cmn.ueCat )
||(CM_LTE_UE_CAT_7 == pCellUeSchCmn->cmn.ueCat))
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
Inst inst = ue->cell->instIdx;
- TRC2(rgSCHCmnRgrSCellUeDel);
cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
RgrUeCfg *cfg;
#endif
{
- TRC2(rgSCHCmnRgrUeCfg);
RgSchUeGrp *ue5gtfGrp;
ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
RgSchCmnUe *ueSchCmn;
RgSchCmnUlUe *ueUl;
RgSchCmnDlUe *ueDl;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnAllocRecord *allRcd;
- U32 waitPer;
- U32 idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
+ uint32_t waitPer;
+ uint32_t idx = (uint8_t)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
- TRC2(rgSCHCmnRgrUeCfg);
/* 1. Allocate Common sched control block */
RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
/*CA dev-Start*/
- U8 ri = 0;
+ uint8_t ri = 0;
ri = RGSCH_MIN(ri, cell->numTxAntPorts);
if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat))
**/
#ifdef TFU_UPGRADE
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
+static Void rgSCHCmnDlHdlTxModeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
-U8 numTxPorts
+uint8_t numTxPorts
)
#else
-PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
+static Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
-U8 numTxPorts;
+uint8_t numTxPorts;
#endif
#else
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
+static Void rgSCHCmnDlHdlTxModeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg
)
#else
-PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg)
+static Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlHdlTxModeRecfg);
if (ueRecfg->txMode.pres != PRSNT_NODEF)
{
- RETVOID;
+ return;
}
/* ccpu00140894- Starting Timer for TxMode Transition Completion*/
ue->txModeTransCmplt =FALSE;
RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
}
/* MIMO Fix End: need to set FORCE TD bitmap based on TX mode */
- RETVOID;
+ return;
}
if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_START)
{
{
RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
}
- RETVOID;
+ return;
}
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdUeMimoInfo
+static Void rgSCHCmnUpdUeMimoInfo
(
RgrUeCfg *ueCfg,
RgSchCmnDlUe *ueDl,
RgSchCmnCell *cellSchd
)
#else
-PRIVATE Void rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd)
+static Void rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd)
RgrUeCfg *ueCfg;
RgSchCmnDlUe *ueDl;
RgSchCellCb *cell;
RgSchCmnCell *cellSchd;
#endif
{
- TRC2(rgSCHCmnUpdUeMimoInfo)
#ifdef TFU_UPGRADE
if(ueCfg->txMode.pres)
{
ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
- RETVOID;
+ return;
}
/***********************************************************
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdUeUlCqiInfo
+static Void rgSCHCmnUpdUeUlCqiInfo
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isEcp
)
#else
-PRIVATE Void rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, isEcp)
+static Void rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, isEcp)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchCmnUlUe *ueUl;
#endif
{
- TRC2(rgSCHCmnUpdUeUlCqiInfo)
#ifdef TFU_UPGRADE
if(ue->srsCb.srsCfg.type == RGR_SCH_SRS_SETUP)
ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
}
- RETVOID;
+ return;
}
/***********************************************************
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdUeCatCfg
+static Void rgSCHCmnUpdUeCatCfg
(
RgSchUeCb *ue,
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnUpdUeCatCfg(ue, cell)
+static Void rgSCHCmnUpdUeCatCfg(ue, cell)
RgSchUeCb *ue;
RgSchCellCb *cell;
#endif
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUpdUeCatCfg)
ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
/*CA dev-Start*/
- U8 ri = 0;
+ uint8_t ri = 0;
ri = RGSCH_MIN(ri, cell->numTxAntPorts);
if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat))
}
ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
- U32 waitPer;
+ uint32_t waitPer;
- TRC2(rgSCHCmnRgrUeRecfg);
/* Basic validations */
if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
{
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlUeDelAllocs
+static Void rgSCHCmnUlUeDelAllocs
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnUlUeDelAllocs(cell, ue)
+static Void rgSCHCmnUlUeDelAllocs(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
- U8 i;
+ uint8_t i;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUlUeDelAllocs);
for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
{
}
}
}
- RETVOID;
+ return;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDelUeFrmRefreshQ
+static Void rgSCHCmnDelUeFrmRefreshQ
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnDelUeFrmRefreshQ(cell, ue)
+static Void rgSCHCmnDelUeFrmRefreshQ(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDelUeFrmRefreshQ);
#ifdef RGL_SPECIFIC_CHANGES
if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
#endif
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
arg.evnt = RG_SCH_CMN_EVNT_UE_REFRESH;
cmRmvCbTq(&arg);
- RETVOID;
+ return;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUeCcchSduDel
+static Void rgSCHCmnUeCcchSduDel
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
)
#else
-PRIVATE Void rgSCHCmnUeCcchSduDel(cell, ueCb)
+static Void rgSCHCmnUeCcchSduDel(cell, ueCb)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
#endif
RgSchDlHqProcCb *ccchSduHqP = NULLP;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUeCcchSduDel);
hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
if (hqE == NULLP)
{
- RETVOID;
+ return;
}
ccchSduHqP = hqE->ccchSduProc;
if(ueCb->ccchSduLnk.node != NULLP)
rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
}
}
- RETVOID;
+ return;
}
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLList *node;
RgSchCmnAllocRecord *allRcd;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
- U32 idx = 0;
- TRC2(rgSCHCmnUeDel);
+ uint32_t idx = 0;
if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
{
/* Common scheduler config has not happened yet */
- RETVOID;
+ return;
}
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
if(hqE)
}
/* Fix : syed Moved hqEnt deinit to rgSCHCmnDlDeInitHqEnt */
- idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
+ idx = (uint8_t)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch))), (sizeof(RgSchCmnUe)));
- RETVOID;
+ return;
} /* rgSCHCmnUeDel */
\f
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlCnsdrCmnRt
+static S16 rgSCHCmnDlCnsdrCmnRt
(
RgSchCellCb *cell,
RgrDlCmnCodeRateCfg *dlCmnCodeRate
)
#else
-PRIVATE S16 rgSCHCmnDlCnsdrCmnRt(cell, dlCmnCodeRate)
+static S16 rgSCHCmnDlCnsdrCmnRt(cell, dlCmnCodeRate)
RgSchCellCb *cell;
RgrDlCmnCodeRateCfg *dlCmnCodeRate;
#endif
{
RgSchCmnCell *cellDl = RG_SCH_CMN_GET_CELL(cell);
- U32 bitsPerRb;
- U32 bitsPer2Rb;
- U32 bitsPer3Rb;
- U8 i, rbNum;
- U32 pdcchBits;
+ uint32_t bitsPerRb;
+ uint32_t bitsPer2Rb;
+ uint32_t bitsPer3Rb;
+ uint8_t i, rbNum;
+ uint32_t pdcchBits;
- TRC2(rgSCHCmnDlCnsdrCmnRt);
/* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
* bits per 1024/2 REs */
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlRgrCellCfg
+static S16 rgSCHCmnDlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cfg,
RgSchErrInfo *err
)
#else
-PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
+static S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
RgSchCellCb *cell;
RgrCellCfg *cfg;
RgSchErrInfo *err;
#endif
{
RgSchCmnCell *cellSch;
- U8 cp;
- U8 sfCount;
- U8 numPdcchSym;
- U8 noSymPerSlot;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 splSubfrmIdx = cfg->spclSfCfgIdx;
- U8 swPtCnt = 0;
+ uint8_t cp;
+ uint8_t sfCount;
+ uint8_t numPdcchSym;
+ uint8_t noSymPerSlot;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t splSubfrmIdx = cfg->spclSfCfgIdx;
+ uint8_t swPtCnt = 0;
Bool isSplfrm;
RgSchTddSubfrmInfo subfrmInfo = rgSchTddMaxUlSubfrmTbl[cell->ulDlCfgIdx];
S16 ret;
- U8 splSfIdx;
- U8 antPortIdx;
- U8 numCrs;
- U8 cfi;
- U8 cfiIdx;
+ uint8_t splSfIdx;
+ uint8_t antPortIdx;
+ uint8_t numCrs;
+ uint8_t cfi;
+ uint8_t cfiIdx;
RgSchDlSf *sf;
- U8 splSfCfi;
- U8 mPhich;
+ uint8_t splSfCfi;
+ uint8_t mPhich;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlRgrCellCfg
+static S16 rgSCHCmnDlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cfg,
RgSchErrInfo *err
)
#else
-PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
+static S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
RgSchCellCb *cell;
RgrCellCfg *cfg;
RgSchErrInfo *err;
{
S16 ret;
RgSchCmnCell *cellSch;
- U8 cp;
- U8 numPdcchSym;
- U8 noSymPerSlot;
- U8 cfi;
- U8 cfiIdx;
+ uint8_t cp;
+ uint8_t numPdcchSym;
+ uint8_t noSymPerSlot;
+ uint8_t cfi;
+ uint8_t cfiIdx;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
* is necessarily satisfied (does a 'ceiling'
* computation).
*
- * Ret : Required RBs (U8)
+ * Ret : Required RBs (uint8_t)
*
* Notes:
*
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHCmnUlCalcReqRbCeil
+uint8_t rgSCHCmnUlCalcReqRbCeil
(
-U32 bytes,
-U8 cqi,
+uint32_t bytes,
+uint8_t cqi,
RgSchCmnUlCell *cellUl
)
#else
-U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
-U32 bytes;
-U8 cqi;
+uint8_t rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
+uint32_t bytes;
+uint8_t cqi;
RgSchCmnUlCell *cellUl;
#endif
{
- U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
- TRC2(rgSCHCmnUlCalcReqRbCeil);
- return ((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
+ uint32_t numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
+ return ((uint8_t)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnPrecompMsg3Vars
+static S16 rgSCHCmnPrecompMsg3Vars
(
RgSchCmnUlCell *cellUl,
-U8 ccchCqi,
-U16 msgSzA,
-U8 sbSize,
+uint8_t ccchCqi,
+uint16_t msgSzA,
+uint8_t sbSize,
Bool isEcp
)
#else
-PRIVATE S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
+static S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
RgSchCmnUlCell *cellUl;
-U8 ccchCqi;
-U16 msgSzA;
-U8 sbSize;
+uint8_t ccchCqi;
+uint16_t msgSzA;
+uint8_t sbSize;
Bool isEcp;
#endif
{
- U8 numSb;
- U8 ccchTbs;
- U8 ccchMcs;
- U8 numRb = 0;
- U8 iTbs = 0;
- U16 msg3GrntSz = 0;
+ uint8_t numSb;
+ uint8_t ccchTbs;
+ uint8_t ccchMcs;
+ uint8_t numRb = 0;
+ uint8_t iTbs = 0;
+ uint16_t msg3GrntSz = 0;
- TRC2(rgSCHCmnPrecompMsg3Vars);
if (ccchCqi > cellUl->max16qamCqi)
{
}
/* #ifndef RG_SCH_CMN_EXP_CP_SUP For ECP Pick the index 1 */
/* Fix */
- ccchTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
+ ccchTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ccchCqi];
ccchMcs = rgSCHCmnUlGetIMcsFrmITbs(ccchTbs, CM_LTE_UE_CAT_1);
/* MCS should fit in 4 bits in RAR */
* Since, UE doesn't exist right now, we use CAT_1 for ue
* category*/
while((ccchMcs = (rgSCHCmnUlGetIMcsFrmITbs(
- rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
+ rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
) >
RG_SCH_CMN_MAX_MSG3_IMCS)
{
ccchCqi--;
}
- iTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
+ iTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ccchCqi];
if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
{
return ROK;
}
-U32 gPrntPucchDet=0;
+uint32_t gPrntPucchDet=0;
#ifdef LTE_TDD
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUlCalcAvailBw
+static S16 rgSCHCmnUlCalcAvailBw
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
-U8 cfi,
-U8 *rbStartRef,
-U8 *bwAvailRef
+uint8_t cfi,
+uint8_t *rbStartRef,
+uint8_t *bwAvailRef
)
#else
-PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
+static S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
-U8 cfi;
-U8 *rbStartRef;
-U8 *bwAvailRef;
-#endif
-{
- U8 c = 3;
- U8 ulBw = cell->bwCfg.ulTotalBw;
- U8 n2Rb = cell->pucchCfg.resourceSize;
- U8 pucchDeltaShft = cell->pucchCfg.deltaShift;
- U16 n1Pucch = cell->pucchCfg.n1PucchAn;
- U8 n1Cs = cell->pucchCfg.cyclicShift;
-
- U8 n1PerRb;
- U8 totalCce;
- U16 n1Max;
- U8 n1Rb;
- U32 mixedRb;
- U8 exclRb; /* RBs to exclude */
- U8 n1RbPart;
- U8 puschRbStart;
+uint8_t cfi;
+uint8_t *rbStartRef;
+uint8_t *bwAvailRef;
+#endif
+{
+ uint8_t c = 3;
+ uint8_t ulBw = cell->bwCfg.ulTotalBw;
+ uint8_t n2Rb = cell->pucchCfg.resourceSize;
+ uint8_t pucchDeltaShft = cell->pucchCfg.deltaShift;
+ uint16_t n1Pucch = cell->pucchCfg.n1PucchAn;
+ uint8_t n1Cs = cell->pucchCfg.cyclicShift;
+
+ uint8_t n1PerRb;
+ uint8_t totalCce;
+ uint16_t n1Max;
+ uint8_t n1Rb;
+ uint32_t mixedRb;
+ uint8_t exclRb; /* RBs to exclude */
+ uint8_t n1RbPart;
+ uint8_t puschRbStart;
/* To avoid PUCCH and PUSCH collision issue */
- U8 P;
- U8 n1PlusOne;
- U8 mi;
+ uint8_t P;
+ uint8_t n1PlusOne;
+ uint8_t mi;
/* Maximum value of M as per Table 10.1-1 */
- U8 M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
+ uint8_t M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUlCalcAvailBw
+static S16 rgSCHCmnUlCalcAvailBw
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
-U8 cfi,
-U8 *rbStartRef,
-U8 *bwAvailRef
+uint8_t cfi,
+uint8_t *rbStartRef,
+uint8_t *bwAvailRef
)
#else
-PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
+static S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
-U8 cfi;
-U8 *rbStartRef;
-U8 *bwAvailRef;
-#endif
-{
- U8 c = 3;
- U8 ulBw = cell->bwCfg.ulTotalBw;
- U8 n2Rb = cell->pucchCfg.resourceSize;
- U8 pucchDeltaShft = cell->pucchCfg.deltaShift;
- U16 n1Pucch = cell->pucchCfg.n1PucchAn;
- U8 n1Cs = cell->pucchCfg.cyclicShift;
- U8 n1PerRb;
- U8 totalCce;
- U16 n1Max;
- U8 n1Rb;
- U32 mixedRb;
- U8 exclRb; /* RBs to exclude */
- U8 n1RbPart;
- U8 puschRbStart;
+uint8_t cfi;
+uint8_t *rbStartRef;
+uint8_t *bwAvailRef;
+#endif
+{
+ uint8_t c = 3;
+ uint8_t ulBw = cell->bwCfg.ulTotalBw;
+ uint8_t n2Rb = cell->pucchCfg.resourceSize;
+ uint8_t pucchDeltaShft = cell->pucchCfg.deltaShift;
+ uint16_t n1Pucch = cell->pucchCfg.n1PucchAn;
+ uint8_t n1Cs = cell->pucchCfg.cyclicShift;
+ uint8_t n1PerRb;
+ uint8_t totalCce;
+ uint16_t n1Max;
+ uint8_t n1Rb;
+ uint32_t mixedRb;
+ uint8_t exclRb; /* RBs to exclude */
+ uint8_t n1RbPart;
+ uint8_t puschRbStart;
#ifdef LTE_ADV
- U16 numOfN3PucchRb;
+ uint16_t numOfN3PucchRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
/* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in
* TS 36.211 */
n1RbPart = (c*n1Cs)/pucchDeltaShft;
- n1Rb = (U8)((n1Max - n1RbPart) / n1PerRb);
+ n1Rb = (uint8_t)((n1Max - n1RbPart) / n1PerRb);
mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
/* get the total Number of RB's to be excluded for PUSCH */
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUlCellInit
+static S16 rgSCHCmnUlCellInit
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PRIVATE S16 rgSCHCmnUlCellInit(cell, cellCfg)
+static S16 rgSCHCmnUlCellInit(cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
{
S16 ret;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 maxUePerUlSf = cellCfg->maxUePerUlSf;
+ uint8_t maxUePerUlSf = cellCfg->maxUePerUlSf;
#ifdef RGR_V1
/* Added configuration for maximum number of MSG3s */
- U8 maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
-#endif
- U8 maxUlBwPerUe = cellCfg->maxUlBwPerUe;
- U8 sbSize = cellCfg->puschSubBand.size;
- U8 i;
- U8 rbStart;
- U8 bwAvail;
- U8 cfi;
- U8 maxSbPerUe;
- U8 numSb;
+ uint8_t maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
+#endif
+ uint8_t maxUlBwPerUe = cellCfg->maxUlBwPerUe;
+ uint8_t sbSize = cellCfg->puschSubBand.size;
+ uint8_t i;
+ uint8_t rbStart;
+ uint8_t bwAvail;
+ uint8_t cfi;
+ uint8_t maxSbPerUe;
+ uint8_t numSb;
#ifdef LTE_TDD
- U16 ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint16_t ulDlCfgIdx = cell->ulDlCfgIdx;
/* [ccpu00127294]-MOD-Change the max Ul subfrms size in TDD */
- U8 maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx];
- U8 ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL * 2 */
- U8 maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx];
+ uint8_t ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL * 2 */
+ uint8_t maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- U16 subfrm;
+ uint16_t subfrm;
S8 dlIdx;
#else
- U8 maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
+ uint8_t maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
#endif
#ifdef LTE_L2_MEAS
- U8 idx;
+ uint8_t idx;
#endif
- U8 iTbs;
+ uint8_t iTbs;
#if (defined(LTE_L2_MEAS) )
Inst inst = cell->instIdx;
#endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUlCellInit);
cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
if (maxUePerUlSf == 0)
{
S16 ret;
RgSchCmnCell *cellSch;
- TRC2(rgSCHCmnRgrCellCfg);
/* As part of RGR cell configuration, validate the CRGCellCfg
* There is no trigger for crgCellCfg from SC1 */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnRgrCellRecfg);
if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
{
- U8 oldCqi = cellUl->dfltUlCqi;
+ uint8_t oldCqi = cellUl->dfltUlCqi;
if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
{
err->errCause = RGSCHERR_SCH_CFG;
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlCellDeinit
+static Void rgSCHCmnUlCellDeinit
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnUlCellDeinit(cell)
+static Void rgSCHCmnUlCellDeinit(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 ulSfIdx;
+ uint8_t ulSfIdx;
#ifdef LTE_TDD
- U8 maxSubfrms = cellUl->numUlSubfrms;
+ uint8_t maxSubfrms = cellUl->numUlSubfrms;
#endif
#ifdef LTE_L2_MEAS
CmLList *lnk = NULLP;
RgSchL2MeasCb *measCb;
#endif
- TRC2(rgSCHCmnUlCellDeinit);
#ifdef LTE_L2_MEAS
#ifdef LTE_TDD
for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
}
#endif
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnCellDel);
#ifdef LTE_L2_MEAS
glblTtiCnt = 0;
#endif
if (cellSch == NULLP)
{
- RETVOID;
+ return;
}
/* Perform the deinit for the UL scheduler */
rgSCHCmnUlCellDeinit(cell);
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(cell->sc.sch)), (sizeof(RgSchCmnCell)));
- RETVOID;
+ return;
} /* rgSCHCmnCellDel */
\f
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnValidateDlQos
+static S16 rgSCHCmnValidateDlQos
(
RgrLchQosCfg *dlQos
)
#else
-PRIVATE S16 rgSCHCmnValidateDlQos(dlQos)
+static S16 rgSCHCmnValidateDlQos(dlQos)
RgrLchQosCfg *dlQos;
#endif
{
- U8 qci = dlQos->qci;
+ uint8_t qci = dlQos->qci;
- TRC2(rgSCHCmnValidateDlQos);
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchCfg);
ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchRecfg)
if(dlLc->lcType != CM_LTE_LCH_DCCH)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgCfg);
ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgRecfg);
ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
)
#else
S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchDel);
#ifdef EMTC_ENABLE
if(TRUE == ue->isEmtcUe)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
- TRC2(rgSCHCmnLcgDel);
if (lcgCmn == NULLP)
{
- RETVOID;
+ return;
}
if (RGSCH_IS_GBR_BEARER(lcgCmn->cfgdGbr))
{
cellSch->apisUl->rgSCHFreeUlLcg(cell, ue, lcg);
}
- RETVOID;
+ return;
}
\f
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnFreeDlLc);
if (svc->sch == NULLP)
{
- RETVOID;
+ return;
}
#ifdef EMTC_ENABLE
if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
rgSCHLaaDeInitDlLchCb(cell, svc);
#endif
- RETVOID;
+ return;
}
#ifdef RGR_V1
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz
+static Void rgSCHCmnDlCcchSduRetxFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo)
+static Void rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchUeCb *ue;
- TRC2(rgSCHCmnDlCcchSduRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
/* reset the UE allocation Information */
rgSCHCmnDlUeResetTemp(ue, hqP);
}
- RETVOID;
+ return;
}
#endif
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchRetxFnlz
+static Void rgSCHCmnDlCcchRetxFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchRetxFnlz(cell, allocInfo)
+static Void rgSCHCmnDlCcchRetxFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchRaCb *raCb;
- TRC2(rgSCHCmnDlCcchRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
/* Fix: syed dlAllocCb reset should be performed.
hqP = (RgSchDlHqProcCb *)(node->node);
raCb = hqP->hqE->raCb;
node = node->next;
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
- RETVOID;
+ return;
}
#ifdef RGR_V1
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchSduTxFnlz
+static Void rgSCHCmnDlCcchSduTxFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo)
+static Void rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchSduTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
/* reset the UE allocation Information */
rgSCHCmnDlUeResetTemp(ueCb, hqP);
}
- RETVOID;
+ return;
}
#endif
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCcchTxFnlz
+static Void rgSCHCmnDlCcchTxFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlCcchTxFnlz(cell, allocInfo)
+static Void rgSCHCmnDlCcchTxFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
}
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
/*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
/* rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
/* reset the UE allocation Information */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
- RETVOID;
+ return;
}
/* R8 Upgrade */
/**
* Invoked by: Common Scheduler
*
* @param[in] RgSchCellCb *cell
- * @param[in] U32 ueCount
- * @return U8
+ * @param[in] uint32_t ueCount
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetBiIndex
+uint8_t rgSCHCmnGetBiIndex
(
RgSchCellCb *cell,
-U32 ueCount
+uint32_t ueCount
)
#else
-U8 rgSCHCmnGetBiIndex(cell, ueCount)
+uint8_t rgSCHCmnGetBiIndex(cell, ueCount)
RgSchCellCb *cell;
-U32 ueCount;
+uint32_t ueCount;
#endif
{
S16 prevVal = 0; /* To Store Intermediate Value */
- U16 newBiVal = 0; /* To store Bi Value in millisecond */
- U8 idx = 0;
- U16 timeDiff = 0;
+ uint16_t newBiVal = 0; /* To store Bi Value in millisecond */
+ uint8_t idx = 0;
+ uint16_t timeDiff = 0;
- TRC2(rgSCHCmnGetBiIndex)
if (cell->biInfo.prevBiTime != 0)
{
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRaRspFnlz
+static Void rgSCHCmnDlRaRspFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlRaRspFnlz(cell, allocInfo)
+static Void rgSCHCmnDlRaRspFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- U32 rarCnt = 0;
+ uint32_t rarCnt = 0;
RgSchDlRbAlloc *raRspAlloc;
RgSchDlSf *subFrm = NULLP;
RgSchRaCb *raCb;
Bool preamGrpA;
RgSchUlAlloc *ulAllocRef=NULLP;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 allocRapidCnt = 0;
+ uint8_t allocRapidCnt = 0;
#ifdef LTE_TDD
- U32 msg3SchdIdx = 0;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 msg3Subfrm;
+ uint32_t msg3SchdIdx = 0;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t msg3Subfrm;
#endif
- TRC2(rgSCHCmnDlRaRspFnlz);
for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
{
subFrm->raRsp[rarCnt].pdcch = NULLP;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
"Not even one RaReq.");
- RETVOID;
+ return;
}
}
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
cell->crntTime.sfn,
cell->crntTime.slot);
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] Bool si
- * @param[in] U16 i
- * @return U8
+ * @param[in] uint16_t i
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlCalcRvForBcch
+static uint8_t rgSCHCmnDlCalcRvForBcch
(
RgSchCellCb *cell,
Bool si,
-U16 i
+uint16_t i
)
#else
-PRIVATE U8 rgSCHCmnDlCalcRvForBcch(cell, si, i)
+static uint8_t rgSCHCmnDlCalcRvForBcch(cell, si, i)
RgSchCellCb *cell;
Bool si;
-U16 i;
+uint16_t i;
#endif
{
- U8 k, rv;
+ uint8_t k, rv;
CmLteTimingInfo frm;
- TRC2(rgSCHCmnDlCalcRvForBcch);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlBcchPcchFnlz
+static Void rgSCHCmnDlBcchPcchFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlBcchPcchFnlz(cell, allocInfo)
+static Void rgSCHCmnDlBcchPcchFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
RgSchDlSf *subFrm;
#ifdef LTE_TDD
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
#else
#ifdef LTEMAC_HDFDD
- U8 nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
#else
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
#endif
#endif
#endif
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnDlBcchPcchFnlz);
/* handle PCCH */
rbAllocInfo = &allocInfo->pcchAlloc;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
"No Pcch Present");
- RETVOID;
+ return;
}
/* Added Dl TB count for paging message transmission*/
}
else
{
- U16 i;
+ uint16_t i;
#ifdef RGR_SI_SCH
Buffer *pdu;
#endif/*RGR_SI_SCH*/
}
- RETVOID;
+ return;
}
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlSetAllUnSched
+static Void rgSCHCmnUlSetAllUnSched
(
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnUlSetAllUnSched(allocInfo)
+static Void rgSCHCmnUlSetAllUnSched(allocInfo)
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
CmLList *node;
- TRC2(rgSCHCmnUlSetAllUnSched);
node = allocInfo->contResLst.first;
while (node)
node = allocInfo->ueLst.first;
}
- RETVOID;
+ return;
}
#endif
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
- TRC2(rgSCHCmnUlAdd2CntResLst);
cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
- TRC2(rgSCHCmnUlAdd2UeLst);
if (ulAllocInfo->reqLnk.node == NULLP)
{
cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
/**
#endif
{
RgSchUlSf *sf = allocInfo->sf;
- TRC2(rgSCHCmnAllocUlRb);
/* Schedule for new transmissions */
rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
&allocInfo->ueLst, &allocInfo->schdUeLst,
&allocInfo->nonSchdUeLst, (Bool)TRUE);
- RETVOID;
+ return;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlRbAllocForLst
+static Void rgSCHCmnUlRbAllocForLst
(
RgSchCellCb *cell,
RgSchUlSf *sf,
-U32 count,
+uint32_t count,
CmLListCp *reqLst,
CmLListCp *schdLst,
CmLListCp *nonSchdLst,
Bool isNewTx
)
#else
-PRIVATE Void rgSCHCmnUlRbAllocForLst(cell, sf, count, reqLst, schdLst,
+static Void rgSCHCmnUlRbAllocForLst(cell, sf, count, reqLst, schdLst,
nonSchdLst, isNewTx)
RgSchCellCb *cell;
RgSchUlSf *sf;
-U32 count;
+uint32_t count;
CmLListCp *reqLst;
CmLListCp *schdLst;
CmLListCp *nonSchdLst;
RgSchUlHole *hole;
#ifdef LTE_L2_MEAS
#ifdef LTE_TDD
- U8 k;
+ uint8_t k;
CmLteTimingInfo timeInfo;
#endif
#endif
- TRC2(rgSCHCmnUlRbAllocForLst);
if(schdLst->count == 0)
{
#ifdef LTE_L2_MEAS
if(isNewTx == TRUE)
{
- cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (U8) count;
+ cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (uint8_t) count;
#ifdef LTE_TDD
RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, timeInfo, TFU_ULCNTRL_DLDELTA);
k = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][timeInfo.subframe];
RgSchUeCb *ue = (RgSchUeCb *)lnk->node;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
S16 ret;
- U8 maxRb;
+ uint8_t maxRb;
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
ue->isMsg4PdcchWithCrnti = FALSE;
}
- RETVOID;
+ return;
}
#ifdef UNUSED_FUNC
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi
+static S16 rgSCHCmnUlMdfyGrntForCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 maxRb,
-U32 *numSb,
-U8 *iTbs,
-U32 hqSz,
-U32 stepDownItbs,
-U32 effTgt
+uint32_t maxRb,
+uint32_t *numSb,
+uint8_t *iTbs,
+uint32_t hqSz,
+uint32_t stepDownItbs,
+uint32_t effTgt
)
#else
-PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
+static S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 maxRb;
-U32 *numSb;
-U8 *iTbs;
-U32 hqSz;
-U32 stepDownItbs;
-U32 effTgt;
+uint32_t maxRb;
+uint32_t *numSb;
+uint8_t *iTbs;
+uint32_t hqSz;
+uint32_t stepDownItbs;
+uint32_t effTgt;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(ue->cell);
- U32 nPrb;
- U32 totREs;
- U32 cqiRiREs;
- U32 hqREs;
- U32 remREsForPusch;
- U32 bitsPerRe;
- U32 tbSz;
- U32 betaOffVal = ue->ul.betaOffstVal;
- U32 cqiRiRptSz = ue->ul.cqiRiSz;
- U32 betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
- U32 resNumSb = *numSb;
- U32 puschEff = 1000;
- U8 modOdr;
- U8 iMcs;
+ uint32_t nPrb;
+ uint32_t totREs;
+ uint32_t cqiRiREs;
+ uint32_t hqREs;
+ uint32_t remREsForPusch;
+ uint32_t bitsPerRe;
+ uint32_t tbSz;
+ uint32_t betaOffVal = ue->ul.betaOffstVal;
+ uint32_t cqiRiRptSz = ue->ul.cqiRiSz;
+ uint32_t betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
+ uint32_t resNumSb = *numSb;
+ uint32_t puschEff = 1000;
+ uint8_t modOdr;
+ uint8_t iMcs;
Bool mdfyiTbsFlg = FALSE;
- U8 resiTbs = *iTbs;
+ uint8_t resiTbs = *iTbs;
- TRC2(rgSCHCmnUlMdfyGrntForCqi)
do
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUlRbAllocForUe
+static S16 rgSCHCmnUlRbAllocForUe
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
-U8 maxRb,
+uint8_t maxRb,
RgSchUlHole *hole
)
#else
-PRIVATE S16 rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole)
+static S16 rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUeCb *ue;
-U8 maxRb;
+uint8_t maxRb;
RgSchUlHole *hole;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
RgSchUlAlloc *alloc = NULLP;
- U32 nPrb = 0;
- U8 numVrbg;
- U8 iMcs;
- U8 iMcsCrnt;
+ uint32_t nPrb = 0;
+ uint8_t numVrbg;
+ uint8_t iMcs;
+ uint8_t iMcsCrnt;
#ifndef RG_5GTF
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->schdHqProcIdx];
#else
RgSchUlHqProcCb *proc = NULLP;
#endif
RgSchPdcch *pdcch;
- U32 reqVrbg;
- U8 numVrbgTemp;
+ uint32_t reqVrbg;
+ uint8_t numVrbgTemp;
#ifdef RG_5GTF
TfuDciFormat dciFrmt;
- U8 numLyr;
+ uint8_t numLyr;
#endif
- TRC2(rgSCHCmnUlRbAllocForUe);
#ifdef RG_5GTF
rgSCHUhmGetAvlHqProc(cell, ue, &proc);
if (proc == NULLP)
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlRbAllocAddUeToLst);
UNUSED(cell);
gUl5gtfUeRbAllocDone++;
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlAllocFnlz
+static Void rgSCHCmnUlAllocFnlz
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnUlAllocFnlz(cell, allocInfo)
+static Void rgSCHCmnUlAllocFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlAllocFnlz);
/* call scheduler specific Finalization */
cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
/**
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlAllocFnlz);
rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
cellSch->apisDl->rgSCHDlAllocFnlz(cell, allocInfo);
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
}
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlUpdSf
+static Void rgSCHCmnUlUpdSf
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUlSf *sf
)
#else
-PRIVATE Void rgSCHCmnUlUpdSf(cell, allocInfo, sf)
+static Void rgSCHCmnUlUpdSf(cell, allocInfo, sf)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
RgSchUlSf *sf;
#endif
{
CmLList *lnk;
- TRC2(rgSCHCmnUlUpdSf);
while ((lnk = sf->allocs.first))
{
*/
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlHndlAllocRetx
+static Void rgSCHCmnUlHndlAllocRetx
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUlAlloc *alloc
)
#else
-PRIVATE Void rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc)
+static Void rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
{
- U32 bytes;
+ uint32_t bytes;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlHndlAllocRetx);
bytes = \
rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
[alloc->grnt.numRb-1]/8;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
alloc->rnti);
- RETVOID;
+ return;
}
retxAlloc->grnt.iMcs = alloc->grnt.iMcs;
retxAlloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl\
retxAlloc->hqProc = alloc->hqProc;
rgSCHUhmRetx(retxAlloc->hqProc);
}
- RETVOID;
+ return;
}
#endif
**/
/* ccpu00132653- The definition of this function made common for TDD and FDD*/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlAlloc
+static Void rgSCHCmnUlAlloc
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnUlAlloc(cell)
+static Void rgSCHCmnUlAlloc(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnUlRbAllocInfo allocInfo;
RgSchCmnUlRbAllocInfo *allocInfoRef = &allocInfo;
#ifdef RG_5GTF
- U8 idx;
+ uint8_t idx;
#endif
- TRC2(rgSCHCmnUlAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure */
rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
g5gtfTtiCnt = 0;
}
- RETVOID;
+ return;
}
/**
Pst pst;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSndCnsldtInfo);
subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
cell->crntSfIdx = (cell->crntSfIdx + 1) % RGSCH_SF_ALLOC_SIZE;
#endif
- RETVOID;
+ return;
}
/**
* @brief Consolidate Subframe Allocations.
CmLListCp ulInActvLst;
RgSchCmnCell *cellSch = NULLP;
- TRC2(rgSCHCmnCnsldtSfAlloc);
cmLListInit(&dlDrxInactvTmrLst);
cmLListInit(&dlInActvLst);
/*re/start DRX inactivity timer for the UEs*/
(Void)rgSCHDrxStrtInActvTmr(cell,&dlDrxInactvTmrLst,RG_SCH_DRX_DL);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnInitDlRbAllocInfo
+static Void rgSCHCmnInitDlRbAllocInfo
(
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnInitDlRbAllocInfo(allocInfo)
+static Void rgSCHCmnInitDlRbAllocInfo(allocInfo)
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitDlRbAllocInfo);
- cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
- RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
+ memset(&allocInfo->pcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(&allocInfo->bcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo->raRspAlloc, 0, RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
allocInfo->msg4Alloc.msg4DlSf = NULLP;
cmLListInit(&allocInfo->msg4Alloc.msg4TxLst);
cmLListInit(&allocInfo->dedAlloc.errIndTxHqPLst);
cmLListInit(&allocInfo->dedAlloc.schdErrIndTxHqPLst);
cmLListInit(&allocInfo->dedAlloc.nonSchdErrIndTxHqPLst);
- RETVOID;
+ return;
}
/**
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitUlRbAllocInfo);
allocInfo->sf = NULLP;
cmLListInit(&allocInfo->contResLst);
cmLListInit(&allocInfo->schdContResLst);
cmLListInit(&allocInfo->schdUeLst);
cmLListInit(&allocInfo->nonSchdUeLst);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnGrpPwrCntrlPucch
+static Void rgSCHCmnGrpPwrCntrlPucch
(
RgSchCellCb *cell,
RgSchDlSf *dlSf
)
#else
-PRIVATE Void rgSCHCmnGrpPwrCntrlPucch(cell, dlSf)
+static Void rgSCHCmnGrpPwrCntrlPucch(cell, dlSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
#endif
{
- TRC2(rgSCHCmnGrpPwrCntrlPucch);
rgSCHPwrGrpCntrlPucch(cell, dlSf);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnGrpPwrCntrlPusch
+static Void rgSCHCmnGrpPwrCntrlPusch
(
RgSchCellCb *cell,
RgSchUlSf *ulSf
)
#else
-PRIVATE Void rgSCHCmnGrpPwrCntrlPusch(cell, ulSf)
+static Void rgSCHCmnGrpPwrCntrlPusch(cell, ulSf)
RgSchCellCb *cell;
RgSchUlSf *ulSf;
#endif
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- TRC2(rgSCHCmnGrpPwrCntrlPusch);
/* Got to pass DL SF corresponding to UL SF, so get that first.
* There is no easy way of getting dlSf by having the RgSchUlSf*,
rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf);
- RETVOID;
+ return;
}
/* Fix: syed align multiple UEs to refresh at same time */
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnApplyUeRefresh
+static S16 rgSCHCmnApplyUeRefresh
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE S16 rgSCHCmnApplyUeRefresh(cell, ue)
+static S16 rgSCHCmnApplyUeRefresh(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U32 effGbrBsr = 0;
- U32 effNonGbrBsr = 0;
- U32 lcgId;
+ uint32_t effGbrBsr = 0;
+ uint32_t effNonGbrBsr = 0;
+ uint32_t lcgId;
- TRC2(rgSCHCmnApplyUeRefresh);
/* Reset the refresh cycle variableCAP */
ue->ul.effAmbr = ue->ul.cfgdAmbr;
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnTmrExpiry
+static S16 rgSCHCmnTmrExpiry
(
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
)
#else
-PRIVATE S16 rgSCHCmnTmrExpiry(cb, tmrEvnt)
+static S16 rgSCHCmnTmrExpiry(cb, tmrEvnt)
PTR cb; /* Pointer to timer control block */
S16 tmrEvnt; /* Timer Event */
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
#endif
- TRC2(rgSCHCmnTmrExpiry);
#if (ERRCLASS & ERRCLS_DEBUG)
if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnTmrProc
+static S16 rgSCHCmnTmrProc
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnTmrProc(cell)
+static S16 rgSCHCmnTmrProc(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
/* Moving the assignment of scheduler pointer
to available scope for optimization */
- TRC2(rgSCHCmnTmrProc);
if ((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES_5G) == 0)
{
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSchCmnUpdCfiVal
+static Void rgSchCmnUpdCfiVal
(
RgSchCellCb *cell,
-U8 delta
+uint8_t delta
)
#else
-PRIVATE Void rgSchCmnUpdCfiVal(cell, delta)
+static Void rgSchCmnUpdCfiVal(cell, delta)
RgSchCellCb *cell;
-U8 delta;
+uint8_t delta;
#endif
{
RgSchDlSf *dlSf;
CmLteTimingInfo pdsch;
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 dlIdx;
+ uint8_t dlIdx;
#ifdef LTE_TDD
- U8 mPhich;
+ uint8_t mPhich;
RgSchDlSf *tddSf;
- U8 idx;
- U8 splSfCfi = 0;
+ uint8_t idx;
+ uint8_t splSfCfi = 0;
#endif
- TRC2(rgSchCmnUpdCfiVal);
pdsch = cell->crntTime;
RGSCH_INCR_SUB_FRAME(pdsch, delta);
}
}
- RETVOID;
+ return;
}
/***********************************************************
**********************************************************/
#ifdef LTE_TDD
#ifdef ANSI
-PRIVATE Void rgSchCmnUpdtPdcchSfIdx
+static Void rgSchCmnUpdtPdcchSfIdx
(
RgSchCellCb *cell,
-U8 dlIdx,
-U8 sfNum
+uint8_t dlIdx,
+uint8_t sfNum
)
#else
-PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
+static Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
RgSchCellCb *cell;
-U8 dlIdx;
-U8 sfNum;
+uint8_t dlIdx;
+uint8_t sfNum;
#endif
#else
#ifdef ANSI
-PRIVATE Void rgSchCmnUpdtPdcchSfIdx
+static Void rgSchCmnUpdtPdcchSfIdx
(
RgSchCellCb *cell,
-U8 dlIdx
+uint8_t dlIdx
)
#else
-PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
+static Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
RgSchCellCb *cell;
-U8 dlIdx;
+uint8_t dlIdx;
#endif
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC2(rgSchCmnUpdtPdcchSfIdx);
/* Resetting the parameters on CFI switching */
cell->dynCfiCb.cceUsed = 0;
Void rgSchCmnUpdCfiDb
(
RgSchCellCb *cell,
-U8 delta
+uint8_t delta
)
#else
Void rgSchCmnUpdCfiDb(cell, delta)
RgSchCellCb *cell;
-U8 delta;
+uint8_t delta;
#endif
{
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
#ifdef LTE_TDD
- U8 mPhich;
+ uint8_t mPhich;
Bool isHiDci0;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 nCceLowerCfi = 0;
- U8 currCfi;
- U8 cceFailIdx;
- U32 totalCce;
- U8 dlIdx;
- U16 ttiMod;
+ uint8_t nCceLowerCfi = 0;
+ uint8_t currCfi;
+ uint8_t cceFailIdx;
+ uint32_t totalCce;
+ uint8_t dlIdx;
+ uint16_t ttiMod;
- TRC2(rgSchCmnUpdCfiDb);
/* Get Downlink Subframe */
frm = cell->crntTime;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCommonChSch);
cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
{
rgSCHCmnDlCcchRarAlloc(cell);
}
- RETVOID;
+ return;
}
/**
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlSch);
#ifdef LTE_ADV
/* LAA_SCELL: */
if(TRUE == rgSCHLaaSCellEnabled(cell))
{
- RETVOID;
+ return;
}
#endif
#endif
#endif
- RETVOID;
+ return;
}
\f
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlDedBoUpd);
/* RACHO : if UEs idle time exceeded and a BO update
* is received, then add UE to the pdcch Order Q */
{
rgSCHCmnSpsDlDedBoUpd(cell, ue, svc);
/* Note: Retrun from here, no update needed in other schedulers */
- RETVOID;
+ return;
}
#endif
#ifdef EMTC_ENABLE
rgSCHSCellDlDedBoUpd(cell, ue, svc);
}
#endif
- RETVOID;
+ return;
}
\f
#endif
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnRmvFrmTaLst);
#ifdef EMTC_ENABLE
if(cell->emtcEnable && ue->isEmtcUe)
cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
ue->dlTaLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
/* Fix: syed Remove the msg4Proc from cell
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
{
}
#endif
}
- RETVOID;
+ return;
}
\f
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlProcAddToRetx);
if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
{
{
/* Invoke SPS module for SPS HARQ proc re-transmission handling */
rgSCHCmnSpsDlProcAddToRetx(cell, hqP);
- RETVOID;
+ return;
}
#endif /* LTEMAC_SPS */
#ifdef EMTC_ENABLE
cellSch->apisDl->rgSCHDlProcAddToRetx(cell, hqP);
}
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 ri
+ * @param[in] uint8_t ri
* @param[in] Bool isPeriodic
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlSetUeRi
+static Void rgSCHCmnDlSetUeRi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 ri,
+uint8_t ri,
Bool isPer
)
#else
-PRIVATE Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
+static Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 ri;
+uint8_t ri;
Bool isPer;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUeInfo *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDlSetUeRi);
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
* specific during which SCH expecting UE can complete TX mode transition*/
if (ue->txModeTransCmplt == FALSE)
{
- RETVOID;
+ return;
}
/* Restrict the Number of TX layers to cell->numTxAntPorts.
RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 pmi
+ * @param[in] uint8_t pmi
* @return Void
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlSetUePmi
+static S16 rgSCHCmnDlSetUePmi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 pmi
+uint8_t pmi
)
#else
-PRIVATE S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
+static S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 pmi;
+uint8_t pmi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlSetUePmi);
if (ue->txModeTransCmplt == FALSE)
{
**/
#ifdef RGR_CQI_REPT
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
+static inline Void rgSCHCmnDlProcCqiMode10
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool *isCqiAvail
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail)
+static inline Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
#else
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
+static inline Void rgSCHCmnDlProcCqiMode10
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi)
+static inline Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode10);
if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
{
}
else
{
- RETVOID;
+ return;
}
}
else if (pucchCqi->u.mode10Info.type == TFU_RPT_RI)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode10Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
**/
#ifdef RGR_CQI_REPT
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
+static inline Void rgSCHCmnDlProcCqiMode11
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool *is2ndCwCqiAvail
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
+static inline Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
#else
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
+static inline Void rgSCHCmnDlProcCqiMode11
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi)
+static inline Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode11);
if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
{
}
else
{
- RETVOID;
+ return;
}
rgSCHCmnDlSetUePmi(cell, ue, \
pucchCqi->u.mode11Info.u.cqi.pmi);
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode11Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
**/
#ifdef RGR_CQI_REPT
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
+static inline Void rgSCHCmnDlProcCqiMode20
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool *isCqiAvail
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail )
+static inline Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail )
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
#else
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
+static inline Void rgSCHCmnDlProcCqiMode20
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi)
+static inline Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode20);
if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
{
}
else
{
- RETVOID;
+ return;
}
}
}
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode20Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
**/
#ifdef RGR_CQI_REPT
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
+static inline Void rgSCHCmnDlProcCqiMode21
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool *is2ndCwCqiAvail
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
+static inline Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
#else
#ifdef ANSI
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
+static inline Void rgSCHCmnDlProcCqiMode21
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi
)
#else
-PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi)
+static inline Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode21);
if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
{
}
else
{
- RETVOID;
+ return;
}
rgSCHCmnDlSetUePmi(cell, ue, \
pucchCqi->u.mode21Info.u.cqi.u.wideCqi.pmi);
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode21Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
**/
#ifdef RGR_CQI_REPT
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCqiOnPucchInd
+static Void rgSCHCmnDlCqiOnPucchInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool *is2ndCwCqiAvail
)
#else
-PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
+static Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
#else
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCqiOnPucchInd
+static Void rgSCHCmnDlCqiOnPucchInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPucch *pucchCqi
)
#else
-PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi)
+static Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPucch *pucchCqi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlCqiOnPucchInd);
/* ccpu00117452 - MOD - Changed
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
break;
}
- RETVOID;
+ return;
} /* rgSCHCmnDlCqiOnPucchInd */
**/
#ifdef RGR_CQI_REPT
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCqiOnPuschInd
+static Void rgSCHCmnDlCqiOnPuschInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool *is2ndCwCqiAvail
)
#else
-PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
+static Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPusch *puschCqi;
#endif
#else
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlCqiOnPuschInd
+static Void rgSCHCmnDlCqiOnPuschInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDlCqiPusch *puschCqi
)
#else
-PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi)
+static Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiPusch *puschCqi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U32 prevRiVal = 0;
- TRC2(rgSCHCmnDlCqiOnPuschInd);
+ uint32_t prevRiVal = 0;
if (puschCqi->ri.pres == PRSNT_NODEF)
{
if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
puschCqi->ri.val,ue->ueId);
- RETVOID;
+ return;
}
}
ue->mimoInfo.puschFdbkVld = FALSE;
}
else
{
- RETVOID;
+ return;
}
break;
case TFU_PUSCH_CQI_MODE_30:
#endif
#ifdef CA_DBG
{
- extern U32 gACqiRcvdCount;
+ uint32_t gACqiRcvdCount;
gACqiRcvdCount++;
}
}
else
{
- RETVOID;
+ return;
}
break;
case TFU_PUSCH_CQI_MODE_12:
}
else
{
- RETVOID;
+ return;
}
if((puschCqi->u.mode12Info.cqiIdx[1]) &&
(puschCqi->u.mode12Info.cqiIdx[1] < RG_SCH_CMN_MAX_CQI))
}
else
{
- RETVOID;
+ return;
}
ue->mimoInfo.puschFdbkVld = TRUE;
ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_12;
}
else
{
- RETVOID;
+ return;
}
if((puschCqi->u.mode22Info.wideBandCqi[1]) &&
(puschCqi->u.mode22Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
}
else
{
- RETVOID;
+ return;
}
rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode22Info.wideBandPmi);
ue->mimoInfo.puschFdbkVld = TRUE;
break;
}
- RETVOID;
+ return;
} /* rgSCHCmnDlCqiOnPuschInd */
\f
Bool is2ndCwCqiAvail = FALSE;
#endif
- TRC2(rgSCHCmnDlCqiInd);
#ifdef RGR_CQI_REPT
if (isPucchInfo)
}
else
{
- U8 dlCqiDeltaPrev = 0;
+ uint8_t dlCqiDeltaPrev = 0;
dlCqiDeltaPrev = ue->prevCqi - ueDl->mimoInfo.cwInfo[0].cqi;
if (dlCqiDeltaPrev > 3)
dlCqiDeltaPrev = 3;
cell->tenbStats->sch.dlNumCw0Cqi ++;
cell->tenbStats->sch.dlNumCw1Cqi ++;
#endif
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr
+static uint8_t rgSCHCmnCalcWcqiFrmSnr
(
RgSchCellCb *cell,
TfuSrsRpt *srsRpt
)
#else
-PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
+static uint8_t rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
RgSchCellCb *cell;
TfuSrsRpt *srsRpt;
#endif
{
- U8 wideCqi=1; /*Calculated value from SNR*/
- TRC2(rgSCHCmnCalcWcqiFrmSnr);
+ uint8_t wideCqi=1; /*Calculated value from SNR*/
/*Need to map a certain SNR with a WideCQI value.
* The CQI calculation is still primitive. Further, need to
* use a improvized method for calculating WideCQI from SNR*/
CmLteTimingInfo timingInfo;
#endif
{
- U8 wideCqi; /*Calculated value from SNR*/
- U32 recReqTime; /*Received Time in TTI*/
- TRC2(rgSCHCmnSrsInd);
+ uint8_t wideCqi; /*Calculated value from SNR*/
+ uint32_t recReqTime; /*Received Time in TTI*/
recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
wideCqi = rgSCHCmnCalcWcqiFrmSnr(cell, srsRpt);
}
rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi);
- RETVOID;
+ return;
}/*rgSCHCmnSrsInd*/
#endif
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
CmLListCp poInactvLst;
- TRC2(rgSCHCmnDlTARpt);
/* RACHO: If UE idle time is more than threshold, then
* set its poInactv pdcch order inactivity */
/* Fix : syed Ignore if TaTmr is not configured */
if ((ue->dl.taCb.cfgTaTmr) && (rgSCHCmnUeIdleExdThrsld(cell, ue) == ROK))
{
- U32 prevDlMsk = ue->dl.dlInactvMask;
- U32 prevUlMsk = ue->ul.ulInactvMask;
+ uint32_t prevDlMsk = ue->dl.dlInactvMask;
+ uint32_t prevUlMsk = ue->ul.ulInactvMask;
ue->dl.dlInactvMask |= RG_PDCCHODR_INACTIVE;
ue->ul.ulInactvMask |= RG_PDCCHODR_INACTIVE;
/* Indicate Specific scheduler for this UEs inactivity */
ue->ueId);
}
}
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 wideCqi
+ * @param[in] uint8_t wideCqi
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt
+static Void rgSCHCmnFindUlCqiUlTxAnt
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 wideCqi
+uint8_t wideCqi
)
#else
-PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
+static Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 wideCqi;
+uint8_t wideCqi;
#endif
{
ue->validTxAnt = 1;
- RETVOID;
+ return;
} /* rgSCHCmnFindUlCqiUlTxAnt */
#endif
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef UL_LA
- U8 iTbsNew;
+ uint8_t iTbsNew;
S32 previTbs;
#endif
#if (defined(SCH_STATS) || defined(TENB_STATS))
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
#endif
- TRC2(rgSCHCmnUlCqiInd);
/* consider inputs from SRS handlers about SRS occassions
* in determining the UL TX Antenna selection */
ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
}
#endif
- RETVOID;
+ return;
} /* rgSCHCmnUlCqiInd */
/**
#endif
{
#ifndef RG_5GTF
- U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
+ uint8_t procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
#endif
- TRC2(rgSCHCmnUlHqProcForUe);
#ifndef RG_5GTF
*procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
#else
*procRef = rgSCHUhmGetUlProcByTime(cell, ue, frm);
#endif
- RETVOID;
+ return;
}
#ifdef RG_UNUSED
RgSchUlHqProcCb *oldProc;
#endif
{
- TRC2(rgSCHCmnUpdUlHqProc);
UNUSED(cell);
UNUSED(oldProc);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
- TRC2(rgSCHCmnBsrTmrExpry)
ueCb->isSrGrant = TRUE;
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *ulLcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *ulLcg,
-U8 bsr,
+uint8_t bsr,
RgSchErrInfo *err
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
-U8 bsr;
+uint8_t bsr;
RgSchErrInfo *err;
#endif
{
- U8 lcgCnt;
+ uint8_t lcgCnt;
#ifdef LTE_L2_MEAS
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
#endif
RgSchCmnLcg *cmnLcg = NULLP;
#ifdef LTE_L2_MEAS
- U8 idx;
+ uint8_t idx;
#endif
- TRC2(rgSCHCmnUpdBsrShort);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
#ifdef LTE_ADV
if (ue->ul.isUlCaEnabled && ue->numSCells)
{
- for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
+ for(uint8_t sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
{
#ifndef PAL_ENABLE_UL_CA
if((ue->cellInfo[sCellIdx] != NULLP) &&
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *ulLcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *ulLcg,
-U8 bsr,
+uint8_t bsr,
RgSchErrInfo *err
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
-U8 bsr;
+uint8_t bsr;
RgSchErrInfo *err;
#endif
{
RgSchCmnLcg *cmnLcg = NULLP;
S32 cnt;
#ifdef LTE_L2_MEAS
- U8 idx;
+ uint8_t idx;
#endif
- TRC2(rgSCHCmnUpdBsrTrunc);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
#ifdef LTE_ADV
if (ue->ul.isUlCaEnabled && ue->numSCells)
{
- for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
+ for(uint8_t sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
{
#ifndef PAL_ENABLE_UL_CA
if((ue->cellInfo[sCellIdx] != NULLP) &&
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 bsArr[]
+ * @param[in] uint8_t bsArr[]
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *bsArr,
+uint8_t *bsArr,
RgSchErrInfo *err
)
#else
S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *bsArr;
+uint8_t *bsArr;
RgSchErrInfo *err;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U32 tmpBsArr[4] = {0, 0, 0, 0};
- U32 nonGbrBs = 0;
+ uint32_t tmpBsArr[4] = {0, 0, 0, 0};
+ uint32_t nonGbrBs = 0;
#ifdef LTE_L2_MEAS
- U8 idx1;
- U8 idx2;
+ uint8_t idx1;
+ uint8_t idx2;
#endif
- U32 lcgId;
+ uint32_t lcgId;
- TRC2(rgSCHCmnUpdBsrLong);
#ifdef LTE_L2_MEAS
for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
#ifdef LTE_ADV
if (ue->ul.isUlCaEnabled && ue->numSCells)
{
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
#ifndef PAL_ENABLE_UL_CA
if((ue->cellInfo[idx] != NULLP) &&
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdExtPhr);
UNUSED(err);
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 phr,
+uint8_t phr,
RgSchErrInfo *err
)
#else
S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 phr;
+uint8_t phr;
RgSchErrInfo *err;
#endif
{
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdPhr);
UNUSED(err);
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnContResUlGrant);
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLList *node = ueUl->ulAllocLst.last;
- TRC2(rgSCHCmnSrRcvd);
#ifdef EMTC_ENABLE
emtcStatsUlTomSrInd++;
/* ACC_TDD */
RgSchUlAlloc* alloc = NULLP;
- TRC2(rgSCHCmnFirstRcptnReq);
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
/* ACC-TDD */
//RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
- TRC2(rgSCHCmnNextRcptnReq);
/* ACC-TDD */
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
RgSchUeCb *ueCb;
- TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
-
cmLListInit(&ulUeLst);
while(alloc)
(Void)rgSCHDrxStrtInActvTmr(cell,&ulUeLst,RG_SCH_DRX_UL);
- RETVOID;
+ return;
}
* Invoked by: TOM
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return RgSchUlAlloc*
**/
#ifdef ANSI
RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
(
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
)
#else
RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
/* ACC-TDD */
RgSchUlAlloc *alloc = NULLP;
- TRC2(rgSCHCmnFirstHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
)
#else
RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnNextHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHCmnUlGetITbsFrmIMcs
+uint8_t rgSCHCmnUlGetITbsFrmIMcs
(
-U8 iMcs
+uint8_t iMcs
)
#else
-U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
-U8 iMcs;
+uint8_t rgSCHCmnUlGetITbsFrmIMcs(iMcs)
+uint8_t iMcs;
#endif
{
- TRC2(rgSCHCmnUlGetITbsFrmIMcs);
return (rgUlIMcsTbl[iMcs].iTbs);
}
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHCmnUlGetIMcsFrmITbs
+uint8_t rgSCHCmnUlGetIMcsFrmITbs
(
-U8 iTbs,
+uint8_t iTbs,
CmLteUeCategory ueCtg
)
#else
-U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
-U8 iTbs;
+uint8_t rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
+uint8_t iTbs;
CmLteUeCategory ueCtg;
#endif
{
- U8 iMcs;
- TRC2(rgSCHCmnUlGetIMcsFrmITbs);
+ uint8_t iMcs;
if (iTbs <= 10)
{
*
**********************************************************/
#ifdef ANSI
-U32 rgSCHCmnUlMinTbBitsForITbs
+uint32_t rgSCHCmnUlMinTbBitsForITbs
(
RgSchCmnUlCell *cellUl,
-U8 iTbs
+uint8_t iTbs
)
#else
-U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
+uint32_t rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
RgSchCmnUlCell *cellUl;
-U8 iTbs;
+uint8_t iTbs;
#endif
{
- TRC2(rgSCHCmnUlMinTbBitsForITbs);
RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs);
RgSchUlAlloc *rgSCHCmnUlSbAlloc
(
RgSchUlSf *sf,
-U8 numSb,
+uint8_t numSb,
RgSchUlHole *hole
)
#else
RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
RgSchUlSf *sf;
-U8 numSb;
+uint8_t numSb;
RgSchUlHole *hole;
#endif
{
- U8 holeSz; /* valid hole size */
+ uint8_t holeSz; /* valid hole size */
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlSbAlloc);
if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
{
RgSchCmnUeUlAlloc *ulAllocInfo;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlUeFillAllocInfo);
ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
ulAllocInfo = &ueUl->alloc;
rgSCHCmnUlUpdOutStndAlloc(cell, ue, ulAllocInfo->allocdBytes);
}
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdUlCompEffBsr
+static Void rgSCHCmnUpdUlCompEffBsr
(
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnUpdUlCompEffBsr(ue)
+static Void rgSCHCmnUpdUlCompEffBsr(ue)
RgSchUeCb *ue;
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,ue->cell);
CmLList *node = ueUl->ulAllocLst.last;
RgSchCmnAllocRecord *allRcd;
- U32 outStndAlloc=0;
- U32 nonLcg0OutStndAllocBs=0;
- U32 nonLcg0Bsr=0;
- U8 lcgId;
+ uint32_t outStndAlloc=0;
+ uint32_t nonLcg0OutStndAllocBs=0;
+ uint32_t nonLcg0Bsr=0;
+ uint8_t lcgId;
RgSchCmnLcg *cmnLcg = NULLP;
- TRC2(rgSCHCmnUpdUlCompEffBsr);
while (node)
{
/* better be handled in individual scheduler */
ue->ul.effBsr = nonLcg0Bsr +\
((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
- RETVOID;
+ return;
}
/**
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
RgSchCmnUeUlAlloc *ulAllocInfo = &ueUl->alloc;
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRecordUeAlloc);
cmLListDelFrm(lst, &allRcd->lnk);
#ifndef LTE_TDD
cell->measurements.ulBytesCnt += ulAllocInfo->allocdBytes;
- RETVOID;
+ return;
}
/** PHR handling for MSG3
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
/* Stack Crash problem for TRACE5 changes */
- TRC2(rgSCHCmnUlRecMsg3Alloc);
cmLListDelFrm(lst, node);
allRcd->allocTime = raCb->msg3AllocTime;
rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
- RETVOID;
+ return;
}
/**
* @brief Keeps track of the most recent RG_SCH_CMN_MAX_ALLOC_TRACK
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 alloc
+ * @param[in] uint32_t alloc
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 alloc
+uint32_t alloc
)
#else
Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 alloc;
+uint32_t alloc;
#endif
{
- U32 nonLcg0Alloc=0;
- TRC2(rgSCHCmnUlUpdOutStndAlloc);
+ uint32_t nonLcg0Alloc=0;
/* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
/* Resetting UEs lower Cap */
ue->ul.minReqBytes = 0;
- RETVOID;
+ return;
}
* Invoked by: Scheduler
*
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHCmnUlGetITbs
+uint8_t rgSCHCmnUlGetITbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isEcp
)
#else
-U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
+uint8_t rgSCHCmnUlGetITbs(cell, ue, isEcp)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isEcp;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
/* CQI will be capped to maxUlCqi for 16qam UEs */
CmLteUeCategory ueCtgy = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- U8 cqi;
+ uint8_t cqi;
#ifdef UL_LA
S32 iTbs;
- U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi];
+ uint8_t maxiTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ueUl->maxUlCqi];
#endif
- TRC2(rgSCHCmnUlGetITbs);
/* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
#ifdef TFU_UPGRADE
cqi = ueUl->crntUlCqi[0];
}
#endif
- return (rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
+ return (rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][cqi]);
}
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRbInfoAddUeTx
+static Void rgSCHCmnDlRbInfoAddUeTx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchDlHqProcCb *hqP
)
#else
-PRIVATE Void rgSCHCmnDlRbInfoAddUeTx(cell, allocInfo, ue, hqP)
+static Void rgSCHCmnDlRbInfoAddUeTx(cell, allocInfo, ue, hqP)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbInfoAddUeTx);
if (hqP->reqLnk.node == NULLP)
{
hqP->reqLnk.node = (PTR)hqP;
}
}
- RETVOID;
+ return;
}
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx
+static Void rgSCHCmnDlRbInfoAddUeRetx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchDlHqProcCb *hqP
)
#else
-PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx(cell, allocInfo, ue, hqP)
+static Void rgSCHCmnDlRbInfoAddUeRetx(cell, allocInfo, ue, hqP)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetx);
if (cellSch->dl.isDlFreqSel)
{
cmLListAdd2Tail(&allocInfo->dedAlloc.retxHqPLst, &hqP->reqLnk);
hqP->reqLnk.node = (PTR)hqP;
}
- RETVOID;
+ return;
}
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx
+static Void rgSCHCmnDlRbInfoAddUeRetxTx
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchDlHqProcCb *hqP
)
#else
-PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx(allocInfo, ue, hqP)
+static Void rgSCHCmnDlRbInfoAddUeRetxTx(allocInfo, ue, hqP)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
if (cellSch->dl.isDlFreqSel)
{
cmLListAdd2Tail(&allocInfo->dedAlloc.txRetxHqPLst, &hqP->reqLnk);
hqP->reqLnk.node = (PTR)hqP;
}
- RETVOID;
+ return;
}
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst
+static Void rgSCHCmnDlAdd2NonSchdRetxLst
(
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst(allocInfo, ue, hqP)
+static Void rgSCHCmnDlAdd2NonSchdRetxLst(allocInfo, ue, hqP)
RgSchCmnDlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
{
CmLList *schdLnkNode;
- TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
#ifdef LTEMAC_SPS
if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) &&
(RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP)))
{
- RETVOID;
+ return;
}
#endif
RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
cmLListAdd2Tail(&allocInfo->dedAlloc.nonSchdRetxHqPLst, schdLnkNode);
- RETVOID;
+ return;
}
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlANFdbkInit
+static S16 rgSCHCmnDlANFdbkInit
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnDlANFdbkInit(cell)
+static S16 rgSCHCmnDlANFdbkInit(cell)
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 sfNum;
- U8 idx;
- U8 dlIdx;
- U8 calcSfnOffset;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t idx;
+ uint8_t dlIdx;
+ uint8_t calcSfnOffset;
S8 calcSfNum;
- U8 ulSfCnt =0;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo;
- U8 maxUlSubfrms;
+ uint8_t maxUlSubfrms;
- TRC2(rgSCHCmnDlANFdbkInit);
ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlKdashUlAscInit
+static S16 rgSCHCmnDlKdashUlAscInit
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnDlKdashUlAscInit(cell)
+static S16 rgSCHCmnDlKdashUlAscInit(cell)
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 sfNum;
- U8 dlIdx;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t dlIdx;
S8 calcSfnOffset;
S8 calcSfNum;
- U8 ulSfCnt =0;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
- U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- U8 dlPres = 0;
+ uint8_t dlPres = 0;
- TRC2(rgSCHCmnDlKdashUlAscInit);
/* Generate ACK/NACK offset information for each DL subframe in a radio frame
* Calculate this information based on K` in UL Association Set table */
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlNpValInit
+static S16 rgSCHCmnDlNpValInit
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnDlNpValInit(cell)
+static S16 rgSCHCmnDlNpValInit(cell)
RgSchCellCb *cell;
#endif
{
- U8 idx;
- U16 np;
- TRC2(rgSCHCmnDlNpValInit);
+ uint8_t idx;
+ uint16_t np;
/* Always Np is 0 for p=0 */
cell->rgSchTddNpValTbl[0] = 0;
for(idx=1; idx < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; idx++)
{
np = cell->bwCfg.dlTotalBw * (idx * RG_SCH_CMN_NUM_SUBCAR - 4);
- cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
+ cell->rgSchTddNpValTbl[idx] = (uint8_t) (np/36);
}
return ROK;
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlCreateRachPrmLst
+static S16 rgSCHCmnDlCreateRachPrmLst
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnDlCreateRachPrmLst(cell)
+static S16 rgSCHCmnDlCreateRachPrmLst(cell)
RgSchCellCb *cell;
#endif
{
- U8 raArrSz;
+ uint8_t raArrSz;
S16 ret;
- U8 lstSize;
+ uint8_t lstSize;
- TRC2(rgSCHCmnDlCreateRachPrmLst);
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlRachInfoInit
+static S16 rgSCHCmnDlRachInfoInit
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnDlRachInfoInit(cell)
+static S16 rgSCHCmnDlRachInfoInit(cell)
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 sfNum;
- U8 ulSfCnt =0;
- U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfNum;
+ uint8_t ulSfCnt =0;
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- U8 raArrSz;
- RgSchTddRachRspLst rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
- U8 startWin;
- U8 endWin;
- U8 sfnIdx;
- U8 subfrmIdx;
- U8 endSubfrmIdx;
- U8 startSubfrmIdx;
- S16 ret;
- RgSchTddRachDelInfo *delInfo;
- S8 sfnOffset;
- U8 numSubfrms;
-
- TRC2(rgSCHCmnDlRachInfoInit);
-
- cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
+ uint8_t raArrSz;
+ RgSchTddRachRspLst rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
+ uint8_t startWin;
+ uint8_t endWin;
+ uint8_t sfnIdx;
+ uint8_t subfrmIdx;
+ uint8_t endSubfrmIdx;
+ uint8_t startSubfrmIdx;
+ S16 ret;
+ RgSchTddRachDelInfo *delInfo;
+ S8 sfnOffset;
+ uint8_t numSubfrms;
+
+
+ memset(rachRspLst, 0, sizeof(rachRspLst));
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlPhichOffsetInit
+static S16 rgSCHCmnDlPhichOffsetInit
(
RgSchCellCb *cell
)
#else
-PRIVATE S16 rgSCHCmnDlPhichOffsetInit(cell)
+static S16 rgSCHCmnDlPhichOffsetInit(cell)
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 sfNum;
- U8 dlIdx;
- U8 dlPres = 0;
- U8 calcSfnOffset;
- U8 calcSfNum;
- U8 ulSfCnt =0;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t dlIdx;
+ uint8_t dlPres = 0;
+ uint8_t calcSfnOffset;
+ uint8_t calcSfNum;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
- U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- TRC2(rgSCHCmnDlPhichOffsetInit);
/* Generate PHICH offset information for each DL subframe in a radio frame
* Calculate this information based on K in PHICH table */
RgSchCellCb *cell;
#endif
{
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- CmLteTimingInfo timeInfo;
- U8 idx;
- U8 ulSubframe;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 msg3Subfrm;
- U8 Mval;
- TRC2(rgSCHCmnUpdVars);
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ CmLteTimingInfo timeInfo;
+ uint8_t idx;
+ uint8_t ulSubframe;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t msg3Subfrm;
+ uint8_t Mval;
/* ccpu00132654-ADD- Initializing all the indices in every subframe*/
rgSCHCmnInitVars(cell);
else
{
/* introduce some reuse with above code? */
- U8 offst;
+ uint8_t offst;
RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
//offst = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
offst = rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][timeInfo.subframe];
* mainly the prachMaskIndex */
rgSCHCmnUpdRachParam(cell);
- RETVOID;
+ return;
}
/**
* Purpose: Gets 'p' value for HARQ ACK/NACK reception from CCE.
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 cce
- * @return U8
+ * @param[in] uint8_t cce
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetPValFrmCCE
+uint8_t rgSCHCmnGetPValFrmCCE
(
RgSchCellCb *cell,
-U8 cce
+uint8_t cce
)
#else
-U8 rgSCHCmnGetPValFrmCCE(cell, cce)
+uint8_t rgSCHCmnGetPValFrmCCE(cell, cce)
RgSchCellCb *cell;
-U8 cce;
+uint8_t cce;
#endif
{
- U8 i;
- TRC2(rgSCHCmnGetPValFrmCCE);
+ uint8_t i;
for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
{
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlAdapRetx
+static Void rgSCHCmnUlAdapRetx
(
RgSchUlAlloc *alloc,
RgSchUlHqProcCb *proc
)
#else
-PRIVATE Void rgSCHCmnUlAdapRetx(alloc, proc)
+static Void rgSCHCmnUlAdapRetx(alloc, proc)
RgSchUlAlloc *alloc;
RgSchUlHqProcCb *proc;
#endif
{
- TRC2(rgSCHCmnUlAdapRetx);
rgSCHUhmRetx(proc, alloc);
#ifndef RG_5GTF
{
alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
}
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnHdlUlInactUes
+static Void rgSCHCmnHdlUlInactUes
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnHdlUlInactUes(cell)
+static Void rgSCHCmnHdlUlInactUes(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp ulInactvLst;
- TRC2(rgSCHCmnHdlUlInactUes);
/* Get a List of Inactv UEs for UL*/
cmLListInit(&ulInactvLst);
/* take care of this in UL retransmission */
cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnHdlDlInactUes
+static Void rgSCHCmnHdlDlInactUes
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnHdlDlInactUes(cell)
+static Void rgSCHCmnHdlDlInactUes(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp dlInactvLst;
- TRC2(rgSCHCmnHdlDlInactUes);
/* Get a List of Inactv UEs for DL */
cmLListInit(&dlInactvLst);
rgSCHMeasGapANRepGetDlInactvUe (cell, &dlInactvLst);
cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
- RETVOID;
+ return;
}
/* RACHO: Rach handover functions start here */
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUeIdleExdThrsld
+static S16 rgSCHCmnUeIdleExdThrsld
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE S16 rgSCHCmnUeIdleExdThrsld(cell, ue)
+static S16 rgSCHCmnUeIdleExdThrsld(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
/* Time difference in subframes */
- U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
+ uint32_t sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
- TRC2(rgSCHCmnUeIdleExdThrsld);
- if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
+ if (sfDiff > (uint32_t)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
return ROK;
}
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnCfgRachDedPrm
+static Void rgSCHCmnCfgRachDedPrm
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnCfgRachDedPrm(cell)
+static Void rgSCHCmnCfgRachDedPrm(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
- U32 sfDiff;
- U8 cnt;
- TRC2(rgSCHCmnCfgRachDedPrm);
+ uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
+ uint32_t sfDiff;
+ uint8_t cnt;
if (cell->macPreambleSet.pres == NOTPRSNT)
{
- RETVOID;
+ return;
}
cellSch->rachCfg.numDedPrm = cell->macPreambleSet.size;
cellSch->rachCfg.dedPrmStart = cell->macPreambleSet.start;
sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
}
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx
+static Void rgSCHCmnUpdNxtPrchMskIdx
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx(cell)
+static Void rgSCHCmnUpdNxtPrchMskIdx(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUpdNxtPrchMskIdx);
/* Determine the next prach mask Index */
if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
}
}
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUpdRachParam
+static Void rgSCHCmnUpdRachParam
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnUpdRachParam(cell)
+static Void rgSCHCmnUpdRachParam(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
- U32 sfDiff;
- TRC2(rgSCHCmnUpdRachParam);
+ uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
+ uint32_t sfDiff;
if (cell->macPreambleSet.pres == NOTPRSNT)
{
- RETVOID;
+ return;
}
sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, \
cell->crntTime);
if (sfDiff > gap)
{
/* applFrm is still a valid next Prach Oppurtunity */
- RETVOID;
+ return;
}
rgSCHCmnUpdNxtPrchMskIdx(cell);
/* Reset remDedPrm as numDedPrm */
cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
- RETVOID;
+ return;
}
/**
* @param[in] RgSchDlSf *dlSf
* @param[in] RgSchUeCb *ue
* @param[out] RgSchPdcch **pdcch
- * @param[out] U8 *rapId
- * @param[out] U8 *prachMskIdx
+ * @param[out] uint8_t *rapId
+ * @param[out] uint8_t *prachMskIdx
* @return Void
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnAllocPOParam
+static S16 rgSCHCmnAllocPOParam
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUeCb *ue,
RgSchPdcch **pdcch,
-U8 *rapId,
-U8 *prachMskIdx
+uint8_t *rapId,
+uint8_t *prachMskIdx
)
#else
-PRIVATE S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
+static S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchUeCb *ue;
RgSchPdcch **pdcch;
-U8 *rapId;
-U8 *prachMskIdx;
+uint8_t *rapId;
+uint8_t *prachMskIdx;
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnAllocPOParam);
if (cell->macPreambleSet.pres == PRSNT_NODEF)
{
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnGenPdcchOrder
+static Void rgSCHCmnGenPdcchOrder
(
RgSchCellCb *cell,
RgSchDlSf *dlSf
)
#else
-PRIVATE Void rgSCHCmnGenPdcchOrder(cell, dlSf)
+static Void rgSCHCmnGenPdcchOrder(cell, dlSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLList *node = cellSch->rachCfg.pdcchOdrLst.first;
RgSchUeCb *ue;
- U8 rapId;
- U8 prachMskIdx;
+ uint8_t rapId;
+ uint8_t prachMskIdx;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnGenPdcchOrder);
while (node)
{
/* Reset UE's power state */
rgSCHPwrUeReset(cell, ue);
}
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ
+static Void rgSCHCmnDlAdd2PdcchOdrQ
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ(cell, ue)
+static Void rgSCHCmnDlAdd2PdcchOdrQ(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
if (ueDl->rachInfo.poLnk.node == NULLP)
{
cmLListAdd2Tail(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ
+static Void rgSCHCmnDlRmvFrmPdcchOdrQ
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue)
+static Void rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = NULLP;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchUeCb *ue
* @param[in] RgSchPdcch *pdcch
- * @param[in] U8 rapId
- * @param[in] U8 prachMskIdx
+ * @param[in] uint8_t rapId
+ * @param[in] uint8_t prachMskIdx
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFillPdcchOdr2Sf
+static Void rgSCHCmnFillPdcchOdr2Sf
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchPdcch *pdcch,
-U8 rapId,
-U8 prachMskIdx
+uint8_t rapId,
+uint8_t prachMskIdx
)
#else
-PRIVATE Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
+static Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchPdcch *pdcch;
-U8 rapId;
-U8 prachMskIdx;
+uint8_t rapId;
+uint8_t prachMskIdx;
#endif
{
RgSchUeACqiCb *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell);
- TRC2(rgSCHCmnFillPdcchOdr2Sf);
pdcch->rnti = ue->ueId;
pdcch->dci.dciFormat = TFU_DCI_FORMAT_1A;
}
#endif
- RETVOID;
+ return;
}
\f
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDelRachInfo
+static Void rgSCHCmnDelRachInfo
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnDelRachInfo(cell, ue)
+static Void rgSCHCmnDelRachInfo(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 rapIdIdx;
+ uint8_t rapIdIdx;
- TRC2(rgSCHCmnDelRachInfo);
if (ueDl->rachInfo.poLnk.node)
{
&ueDl->rachInfo.rapIdLnk);
ueDl->rachInfo.rapIdLnk.node = NULLP;
}
- RETVOID;
+ return;
}
/**
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnHdlHoPo
+static Void rgSCHCmnHdlHoPo
(
RgSchCellCb *cell,
CmLListCp *raRspLst,
RgSchRaReqInfo *raReq
)
#else
-PRIVATE Void rgSCHCmnHdlHoPo(cell, raRspLst, raReq)
+static Void rgSCHCmnHdlHoPo(cell, raRspLst, raReq)
RgSchCellCb *cell;
CmLListCp *raRspLst;
RgSchRaReqInfo *raReq;
#endif
{
RgSchUeCb *ue = raReq->ue;
- TRC2(rgSCHCmnHdlHoPo);
if ( ue->isDrxEnabled )
{
rgSCHDrxDedRa(cell,ue);
}
rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq);
- RETVOID;
+ return;
}
/**
RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
)
#else
RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
RgSchCellCb *cell;
-U16 rapId
+uint16_t rapId
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnGetHoUe);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
}
#ifdef ANSI
-PRIVATE Void rgSCHCmnDelDedPreamble
+static Void rgSCHCmnDelDedPreamble
(
RgSchCellCb *cell,
-U8 preambleId
+uint8_t preambleId
)
#else
-PRIVATE rgSCHCmnDelDedPreamble(cell, preambleId)
+static rgSCHCmnDelDedPreamble(cell, preambleId)
RgSchCellCb *cell;
-U8 preambleId;
+uint8_t preambleId;
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnDelDedPreamble);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo
)
#else
RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
RgSchCellCb *cell;
-U16 rapId;
+uint16_t rapId;
CmLteTimingInfo timingInfo;
#endif
{
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- U8 rapIdIdx;
- TRC2(rgSCHCmnGetPoUe);
+ uint8_t rapIdIdx;
rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
* Invoked by: Scheduler
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 ueCtgy
- * @return U8
+ * @param[in] uint8_t ueCtgy
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHCmnUlGetCqi
+uint8_t rgSCHCmnUlGetCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteUeCategory ueCtgy
)
#else
-U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
+uint8_t rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteUeCategory ueCtgy;
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- U8 cqi;
+ uint8_t cqi;
- TRC2(rgSCHCmnUlGetCqi);
cqi = ueUl->maxUlCqi;
#ifdef TFU_UPGRADE
*
**********************************************************/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe
+static S16 rgSCHCmnUlRbAllocForPoHoUe
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
-U8 maxRb
+uint8_t maxRb
)
#else
-PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
+static S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUeCb *ue;
-U8 maxRb;
+uint8_t maxRb;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- U8 sbSize = cellUl->sbSize;
- U32 maxBits = ue->ul.maxBytesPerUePerTti*8;
- U32 bits;
+ uint8_t sbSize = cellUl->sbSize;
+ uint32_t maxBits = ue->ul.maxBytesPerUePerTti*8;
+ uint32_t bits;
RgSchUlAlloc *alloc;
- U32 nPrb;
- U8 iTbs;
- U32 eff;
- U32 numSb;
- U8 iMcs;
- U8 iMcsCrnt;
- U8 cqi;
- U8 modOdr;
+ uint32_t nPrb;
+ uint8_t iTbs;
+ uint32_t eff;
+ uint32_t numSb;
+ uint8_t iMcs;
+ uint8_t iMcsCrnt;
+ uint8_t cqi;
+ uint8_t modOdr;
RgSchUlHole *hole;
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRbAllocForPoHoUe);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
return RFAILED;
}
/*MS_WORKAROUND for HO ccpu00121116*/
cqi = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
- RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend], cqi);
- iTbs = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
+ RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(uint8_t)cell->isCpUlExtend], cqi);
+ iTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)cell->isCpUlExtend][cqi];
iMcs = rgSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
while(iMcs > RG_SCH_CMN_MAX_MSG3_IMCS)
{
cqi--;
- iTbs = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
+ iTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)cell->isCpUlExtend][cqi];
iMcs = rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg);
}
/* Filling the modorder in the grant structure*/
}
iMcsCrnt = iMcs;
- alloc = rgSCHCmnUlSbAlloc(sf, (U8)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
+ alloc = rgSCHCmnUlSbAlloc(sf, (uint8_t)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
hole);
if (alloc == NULLP)
{
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnAllocPoHoGrnt
+static Void rgSCHCmnAllocPoHoGrnt
(
RgSchCellCb *cell,
CmLListCp *raRspLst,
RgSchRaReqInfo *raReq
)
#else
-PRIVATE Void rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq)
+static Void rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq)
RgSchCellCb *cell;
CmLListCp *raRspLst;
RgSchUeCb *ue;
RgSchUlGrnt *grnt;
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
- TRC2(rgSCHCmnAllocPoHoGrnt);
/* Clearing previous allocs if any*/
rgSCHCmnUlUeDelAllocs(cell, ue);
/* Fix : syed allocs are limited */
if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
{
- RETVOID;
+ return;
}
ueUl->alloc.reqBytes = RG_SCH_MIN_GRNT_HOPO;
if (rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, RGSCH_MAX_UL_RB) != ROK)
{
- RETVOID;
+ return;
}
/* Fill grant information */
{
RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx, "Failed to get"
"the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
- RETVOID;
+ return;
}
ue->ul.rarGrnt.rapId = raReq->raReq.rapId;
ue->ul.rarGrnt.hop = grnt->hop;
if((sf->numACqiCount < RG_SCH_MAX_ACQI_PER_ULSF) && (RG_SCH_APCQI_NO != ue->dl.reqForCqi))
{
#ifdef LTE_ADV
- U8 idx = 0;
+ uint8_t idx = 0;
/* Send two bits cqireq field if more than one cells are configured else one*/
for (idx = 1;idx < CM_LTE_MAX_CELLS;idx++)
{
cmLListAdd2Tail(raRspLst, &ue->ul.rarGrnt.raRspLnk);
ue->ul.rarGrnt.raRspLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCmnUlCell *cellUl
* @param[out] RgSchUlAlloc *alloc
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
*
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlNonadapRetx
+static Void rgSCHCmnUlNonadapRetx
(
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
)
#else
-PRIVATE Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
+static Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
RgSchCmnUlCell *cellUl;
RgSchUlAlloc *alloc;
-U8 idx;
+uint8_t idx;
#endif
{
- TRC2(rgSCHCmnUlNonadapRetx);
rgSCHUhmRetx(alloc->hqProc, alloc);
/* Update alloc to retx */
}
alloc->grnt.isRtx = TRUE;
alloc->pdcch = NULLP;
- RETVOID;
+ return;
}
/**
* @brief Check if 2 allocs overlap
* @return Bool
**/
#ifdef ANSI
-PRIVATE Bool rgSCHCmnUlAllocsOvrLap
+static Bool rgSCHCmnUlAllocsOvrLap
(
RgSchUlAlloc *alloc1,
RgSchUlAlloc *alloc2
)
#else
-PRIVATE Bool rgSCHCmnUlAllocsOvrLap(alloc1, alloc2)
+static Bool rgSCHCmnUlAllocsOvrLap(alloc1, alloc2)
RgSchUlAlloc *alloc1;
RgSchUlAlloc *alloc2;
#endif
{
- TRC2(rgSCHCmnUlAllocsOvrLap);
if (((alloc1->sbStart >= alloc2->sbStart) &&
(alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlCpyAllocInfo
+static Void rgSCHCmnUlCpyAllocInfo
(
RgSchCellCb *cell,
RgSchUlAlloc *srcAlloc,
RgSchUlAlloc *dstAlloc
)
#else
-PRIVATE Void rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc)
+static Void rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc)
RgSchCellCb *cell;
RgSchUlAlloc *srcAlloc;
RgSchUlAlloc *dstAlloc;
#endif
{
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlCpyAllocInfo);
dstAlloc->grnt = srcAlloc->grnt;
dstAlloc->hqProc = srcAlloc->hqProc;
#endif
}
- RETVOID;
+ return;
}
/**
* @brief Update TX and RETX subframe's allocation
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf
+static Void rgSCHCmnUlInsAllocFrmNewSf2OldSf
(
RgSchCellCb *cell,
RgSchUlSf *newSf,
RgSchUlAlloc *srcAlloc
)
#else
-PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, srcAlloc)
+static Void rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, srcAlloc)
RgSchCellCb *cell;
RgSchUlSf *newSf;
RgSchUlSf *oldSf;
/* MS_WORKAROUND ccpu00120827 */
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
- U8 remAllocs;
- TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
+ uint8_t remAllocs;
if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
"rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
srcAlloc->rnti);
- RETVOID;
+ return;
}
#endif
/* Copy the srcAlloc's state information in to dstAlloc */
/* Set new Tx merged Alloc Flag to TRUE, indicating that this
* alloc shall not be processed for non-adaptive retransmission */
dstAlloc->mrgdNewTxAlloc = TRUE;
- RETVOID;
+ return;
}
/**
* @brief Merge all allocations of newSf to oldSf.
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlMergeSfAllocs
+static Void rgSCHCmnUlMergeSfAllocs
(
RgSchCellCb *cell,
RgSchUlSf *oldSf,
RgSchUlSf *newSf
)
#else
-PRIVATE Void rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf)
+static Void rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf)
RgSchCellCb *cell;
RgSchUlSf *oldSf;
RgSchUlSf *newSf;
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlMergeSfAllocs);
UNUSED(cell);
/* Merge each alloc of newSf in to oldSf
rgSCHUtlUlAllocRls(newSf, alloc);
} while((alloc = nxtAlloc) != NULLP);
}
- RETVOID;
+ return;
}
/**
* @brief Swap Hole/Alloc DB context of newSf and oldSf.
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlSwapSfAllocs
+static Void rgSCHCmnUlSwapSfAllocs
(
RgSchCellCb *cell,
RgSchUlSf *oldSf,
RgSchUlSf *newSf
)
#else
-PRIVATE Void rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf)
+static Void rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf)
RgSchCellCb *cell;
RgSchUlSf *oldSf;
RgSchUlSf *newSf;
{
RgSchUlAllocDb *tempAllocDb = newSf->allocDb;
RgSchUlHoleDb *tempHoleDb = newSf->holeDb;
- U8 tempAvailSbs = newSf->availSubbands;
+ uint8_t tempAvailSbs = newSf->availSubbands;
- TRC2(rgSCHCmnUlSwapSfAllocs);
UNUSED(cell);
newSf->allocDb = oldSf->allocDb;
/* Fix ccpu00120610*/
newSf->allocCountRef = &newSf->allocDb->count;
oldSf->allocCountRef = &oldSf->allocDb->count;
- RETVOID;
+ return;
}
/**
* @brief Perform non-adaptive RETX for non-colliding allocs.
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *newSf
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlPrcNonAdptRetx
+static Void rgSCHCmnUlPrcNonAdptRetx
(
RgSchCellCb *cell,
RgSchUlSf *newSf,
-U8 idx
+uint8_t idx
)
#else
-PRIVATE Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
+static Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
RgSchCellCb *cell;
RgSchUlSf *newSf;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlPrcNonAdptRetx);
/* perform non-adaptive retx allocation(adjustment) */
if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
} while((alloc = nxtAlloc) != NULLP);
}
- RETVOID;
+ return;
}
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *oldSf
* @param[in] RgSchUlSf *newSf
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlPrfmSfMerge
+static Void rgSCHCmnUlPrfmSfMerge
(
RgSchCellCb *cell,
RgSchUlSf *oldSf,
RgSchUlSf *newSf,
-U8 idx
+uint8_t idx
)
#else
-PRIVATE Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
+static Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
RgSchCellCb *cell;
RgSchUlSf *oldSf;
RgSchUlSf *newSf;
-U8 idx;
+uint8_t idx;
#endif
{
- TRC2(rgSCHCmnUlPrfmSfMerge);
/* Preassigned resources for msg3 in newSf.
* Hence do adaptive retx for all NACKED TXs */
rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
/* Perform non-adaptive RETX for non-colliding allocs */
rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx);
- RETVOID;
+ return;
}
#endif
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs
+static Void rgSCHCmnUlRmvCmpltdAllocs
(
RgSchCellCb *cell,
RgSchUlSf *sf
)
#else
-PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs(cell, sf)
+static Void rgSCHCmnUlRmvCmpltdAllocs(cell, sf)
RgSchCellCb *cell;
RgSchUlSf *sf;
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlRmvCmpltdAllocs);
if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
{
- RETVOID;
+ return;
}
do
{
RgSchUeCb *ueCb = alloc->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnUlUe *ulUe = &(cmnUe->ul);
- U8 cqi = ulUe->crntUlCqi[0];
- U16 numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
+ uint8_t cqi = ulUe->crntUlCqi[0];
+ uint16_t numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
hqRetxStats.ulCqiStat[(cqi - 1)].mcs = alloc->grnt.iMcs;
}
} while ((alloc = nxtAlloc) != NULLP);
- RETVOID;
+ return;
}
/**
* - Perform retransmission
*
* @param[in] RgSchUlSf *sf
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
**/
#ifdef ANSI
Void rgSCHCmnRlsUlSf
(
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
)
#else
Void rgSCHCmnRlsUlSf(cell, idx)
RgSchCellCb *cell;
-U8 idx;
+uint8_t idx;
#endif
{
- TRC2(rgSCHCmnRlsUlSf);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
/* Initialize the reTxLst of UL HqProcs for RETX subframe */
if (rgSCHUtlUlAllocFirst(oldSf) == NULLP)
{
- RETVOID;
+ return;
}
/* Release all completed TX allocs from sf */
rgSCHCmnUlRmvCmpltdAllocs(cell, oldSf);
oldSf->numACqiCount = 0;
}
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlUpdAllocRetx
+static Void rgSCHCmnUlUpdAllocRetx
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PRIVATE Void rgSCHCmnUlUpdAllocRetx(cell, alloc)
+static Void rgSCHCmnUlUpdAllocRetx(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlUpdAllocRetx);
alloc->hqProc->reTxAlloc.rnti = alloc->rnti;
alloc->hqProc->reTxAlloc.numSb = alloc->numSb;
#endif
cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
- RETVOID;
+ return;
}
/**
* @param[in] RgSchUlSf *sf
* @param[in] RgSchUlHqProcCb *proc;
* @param[in] RgSchUlHole *hole;
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-PRIVATE Bool rgSCHCmnUlAdapRetxAlloc
+static Bool rgSCHCmnUlAdapRetxAlloc
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PRIVATE Bool rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole)
+static Bool rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUlHqProcCb *proc;
RgSchUlHole *hole;
#endif
{
- U8 numSb = proc->reTxAlloc.numSb;
- U8 iMcs = proc->reTxAlloc.iMcs;
+ uint8_t numSb = proc->reTxAlloc.numSb;
+ uint8_t iMcs = proc->reTxAlloc.iMcs;
CmLteTimingInfo frm = cell->crntTime;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlAdapRetxAlloc);
/* Fetch PDCCH for msg3 */
/* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *sf
- * @return U8
+ * @return uint8_t
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlSfRlsRetxProcs
+static Void rgSCHCmnUlSfRlsRetxProcs
(
RgSchCellCb *cell,
RgSchUlSf *sf
)
#else
-PRIVATE Void rgSCHCmnUlSfRlsRetxProcs(cell, sf)
+static Void rgSCHCmnUlSfRlsRetxProcs(cell, sf)
RgSchCellCb *cell;
RgSchUlSf *sf;
#endif
RgSchUlHqProcCb *proc;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfRlsRetxProcs);
cp = &(cellUl->reTxLst);
node = cp->first;
cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
proc->reTxLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
#endif
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *sf
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnUlSfReTxAllocs
+static Void rgSCHCmnUlSfReTxAllocs
(
RgSchCellCb *cell,
RgSchUlSf *sf
)
#else
-PRIVATE Void rgSCHCmnUlSfReTxAllocs(cell, sf)
+static Void rgSCHCmnUlSfReTxAllocs(cell, sf)
RgSchCellCb *cell;
RgSchUlSf *sf;
#endif
RgSchUeCb *ue;
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfReTxAllocs);
cp = &(cellUl->reTxLst);
node = cp->first;
/* Fix: syed Adaptive Msg3 Retx crash. */
proc->reTxLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
/**
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlRbAlloc
+static Void rgSCHCmnDlRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnDlRbAlloc(cell, allocInfo)
+static Void rgSCHCmnDlRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
{
rgSCHCmnNonDlfsRbAlloc(cell, allocInfo);
}
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
* Processing Steps:
* - Fill-up rbgInfo data structure for given DL bandwidth and rbgSize
*
- * @param[in] U8 dlTotalBw
- * @param[in] U8 dlSubsetBw
- * @param[in] U8 maxRaType1SubsetBw
- * @param[in] U8 rbgSize
+ * @param[in] uint8_t dlTotalBw
+ * @param[in] uint8_t dlSubsetBw
+ * @param[in] uint8_t maxRaType1SubsetBw
+ * @param[in] uint8_t rbgSize
* @param[out] RgSchBwRbgInfo *rbgInfo
* @return Void
**/
#ifdef ANSI
Void rgSCHCmnDlGetRbgInfo
(
-U8 dlTotalBw,
-U8 dlSubsetBw,
-U8 maxRaType1SubsetBw,
-U8 rbgSize,
+uint8_t dlTotalBw,
+uint8_t dlSubsetBw,
+uint8_t maxRaType1SubsetBw,
+uint8_t rbgSize,
RgSchBwRbgInfo *rbgInfo
)
#else
Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
rbgSize, rbgInfo)
-U8 dlTotalBw;
-U8 dlSubsetBw;
-U8 maxRaType1SubsetBw;
-U8 rbgSize;
+uint8_t dlTotalBw;
+uint8_t dlSubsetBw;
+uint8_t maxRaType1SubsetBw;
+uint8_t rbgSize;
RgSchBwRbgInfo *rbgInfo;
#endif
{
#ifdef RGSCH_SPS_UNUSED
- U8 idx = 0;
- U8 lastRbgIdx = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
- U8 currRbgSize = rbgSize;
- U8 subsetSizeIdx = 0;
- U8 subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
- U8 lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
- U8 numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
+ uint8_t idx = 0;
+ uint8_t lastRbgIdx = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
+ uint8_t currRbgSize = rbgSize;
+ uint8_t subsetSizeIdx = 0;
+ uint8_t subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
+ uint8_t lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
+ uint8_t numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
#endif
/* Compute maximum number of SPS RBGs for the cell */
rbgInfo->lastRbgSize = rbgSize -
(dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
#ifdef RGSCH_SPS_UNUSED
- cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
+ memcpy(rbgInfo->rbgSubsetSize, subsetSize, 4 * sizeof(uint8_t));
#endif
rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
dlTotalBw:(rbgInfo->numRbgs * rbgSize);
* - Update RA Type 0, RA Type 1 and RA type 2 masks.
*
* @param[in] RgSchDlSfAllocInfo *allocedInfo
- * @param[in] U8 rbsReq
+ * @param[in] uint8_t rbsReq
* @param[in] RgSchBwRbgInfo *rbgInfo
- * @param[out] U8 *numAllocRbs
+ * @param[out] uint8_t *numAllocRbs
* @param[out] RgSchDlSfAllocInfo *resAllocInfo
* @param[in] Bool isPartialAlloc
*
**/
#ifdef ANSI
-U8 rgSCHCmnDlRaType0Alloc
+uint8_t rgSCHCmnDlRaType0Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 *numAllocRbs,
+uint8_t *numAllocRbs,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
#else
-U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
+uint8_t rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
numAllocRbs, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
-U8 rbsReq;
+uint8_t rbsReq;
RgSchBwRbgInfo *rbgInfo;
-U8 *numAllocRbs;
+uint8_t *numAllocRbs;
RgSchDlSfAllocInfo *resAllocInfo;
Bool isPartialAlloc;
#endif
{
/* Note: This function atttempts allocation only full allocation */
- U32 remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
- U8 type2MaskIdx, cnt, rbIdx;
- U8 maskSize, rbg;
- U8 bestNumAvailRbs = 0;
- U8 usedRbs = 0;
- U8 numAllocRbgs = 0;
- U8 rbgSize = rbgInfo->rbgSize;
- U32 *rbgMask = &(resAllocInfo->raType0Mask);
+ uint32_t remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
+ uint8_t type2MaskIdx, cnt, rbIdx;
+ uint8_t maskSize, rbg;
+ uint8_t bestNumAvailRbs = 0;
+ uint8_t usedRbs = 0;
+ uint8_t numAllocRbgs = 0;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint32_t *rbgMask = &(resAllocInfo->raType0Mask);
#ifdef RGSCH_SPS_UNUSED
- U8 rbgSubset;
- U32 ueRaType1Mask;
- U32 *raType1Mask = resAllocInfo->raType1Mask;
- U32 *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint8_t rbgSubset;
+ uint32_t ueRaType1Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
#endif
- U32 *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
- U32 allocedMask = allocedInfo->raType0Mask;
+ uint32_t allocedMask = allocedInfo->raType0Mask;
maskSize = rbgInfo->numRbgs;
* - Update RA Type1, RA type 0 and RA type 2 masks.
*
* @param[in] RgSchDlSfAllocInfo *allocedInfo
- * @param[in] U8 rbsReq
+ * @param[in] uint8_t rbsReq
* @param[in] RgSchBwRbgInfo *rbgInfo
- * @param[in] U8 startRbgSubset
- * @param[in] U8 *allocRbgSubset
+ * @param[in] uint8_t startRbgSubset
+ * @param[in] uint8_t *allocRbgSubset
* @param[out] rgSchDlSfAllocInfo *resAllocInfo
* @param[in] Bool isPartialAlloc
*
- * @return U8
+ * @return uint8_t
* Number of allocated RBs
**/
#ifdef ANSI
-U8 rgSCHCmnDlRaType1Alloc
+uint8_t rgSCHCmnDlRaType1Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 startRbgSubset,
-U8 *allocRbgSubset,
+uint8_t startRbgSubset,
+uint8_t *allocRbgSubset,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
#else
-U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
+uint8_t rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
allocRbgSubset, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
-U8 rbsReq;
+uint8_t rbsReq;
RgSchBwRbgInfo *rbgInfo;
-U8 startRbgSubset;
-U8 *allocRbgSubset;
+uint8_t startRbgSubset;
+uint8_t *allocRbgSubset;
RgSchDlSfAllocInfo *resAllocInfo;
Bool isPartialAlloc;
#endif
{
/* Note: This function atttempts only full allocation */
- U8 *rbgSubsetSzArr;
- U8 type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
- U8 offset, rbg, maskSize, bestSubsetIdx;
- U8 startPos = 0;
- U8 bestNumAvailRbs = 0;
- U8 numAllocRbs = 0;
- U32 ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
- U32 remNumRbs, allocedMask;
- U8 usedRbs = 0;
- U8 rbgSize = rbgInfo->rbgSize;
- U8 rbgSubset = startRbgSubset;
- U32 *rbgMask = &resAllocInfo->raType0Mask;
- U32 *raType1Mask = resAllocInfo->raType1Mask;
- U32 *raType2Mask = resAllocInfo->raType2Mask;
- U32 *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
- U32 *allocMask = allocedInfo->raType1Mask;
+ uint8_t *rbgSubsetSzArr;
+ uint8_t type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
+ uint8_t offset, rbg, maskSize, bestSubsetIdx;
+ uint8_t startPos = 0;
+ uint8_t bestNumAvailRbs = 0;
+ uint8_t numAllocRbs = 0;
+ uint32_t ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
+ uint32_t remNumRbs, allocedMask;
+ uint8_t usedRbs = 0;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint8_t rbgSubset = startRbgSubset;
+ uint32_t *rbgMask = &resAllocInfo->raType0Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint32_t *allocMask = allocedInfo->raType1Mask;
/* Initialize the subset size Array */
rbgSubsetSzArr = rbgInfo->rbgSubsetSize;
{
/* Initialize alloced mask and subsetSize depending on the RBG
* subset of allocation */
- U8 startIdx = 0;
+ uint8_t startIdx = 0;
maskSize = rbgSubsetSzArr[bestSubsetIdx];
allocedMask = allocMask[bestSubsetIdx];
RG_SCH_CMN_DL_GET_START_POS(allocedMask, maskSize,
* - Update RA Type2, RA type 1 and RA type 0 masks.
*
* @param[in] RgSchDlSfAllocInfo *allocedInfo
- * @param[in] U8 rbsReq
+ * @param[in] uint8_t rbsReq
* @param[in] RgSchBwRbgInfo *rbgInfo
- * @param[out] U8 *rbStart
+ * @param[out] uint8_t *rbStart
* @param[out] rgSchDlSfAllocInfo *resAllocInfo
* @param[in] Bool isPartialAlloc
*
- * @return U8
+ * @return uint8_t
* Number of allocated RBs
**/
#ifdef ANSI
-U8 rgSCHCmnDlRaType2Alloc
+uint8_t rgSCHCmnDlRaType2Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 *rbStart,
+uint8_t *rbStart,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
#else
-U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
+uint8_t rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
-U8 rbsReq;
+uint8_t rbsReq;
RgSchBwRbgInfo *rbgInfo;
-U8 *rbStart;
+uint8_t *rbStart;
RgSchDlSfAllocInfo *resAllocInfo;
Bool isPartialAlloc;
#endif
{
- U8 numAllocRbs = 0;
- U8 rbIdx;
- U8 rbgSize = rbgInfo->rbgSize;
- U32 *rbgMask = &resAllocInfo->raType0Mask;
+ uint8_t numAllocRbs = 0;
+ uint8_t rbIdx;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint32_t *rbgMask = &resAllocInfo->raType0Mask;
#ifdef RGSCH_SPS_UNUSED
- U32 *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
#endif
- U32 *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
#ifdef RGSCH_SPS_UNUSED
- U32 *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
#endif
- U32 *allocedMask = allocedInfo->raType2Mask;
+ uint32_t *allocedMask = allocedInfo->raType2Mask;
/* Note: This function atttempts only full allocation */
rgSCHCmnDlGetBestFitHole(allocedMask, rbgInfo->numRbs,
if (numAllocRbs)
{
/* Update the allocation in RA type 0 and RA type 1 masks */
- U8 rbCnt = numAllocRbs;
+ uint8_t rbCnt = numAllocRbs;
#ifdef RGSCH_SPS_UNUSED
- U8 rbgSubset;
- U32 ueRaType1Mask;
+ uint8_t rbgSubset;
+ uint32_t ueRaType1Mask;
#endif
- U32 ueRaType0Mask;
+ uint32_t ueRaType0Mask;
rbIdx = *rbStart;
while(rbCnt)
* Processing Steps:
* - Determine RA Type 0 mask for given rbIdex and rbg size.
*
- * @param[in] U8 rbIdx
- * @param[in] U8 rbgSize
- * @return U32 RA type 0 mask
+ * @param[in] uint8_t rbIdx
+ * @param[in] uint8_t rbgSize
+ * @return uint32_t RA type 0 mask
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnGetRaType0Mask
+static uint32_t rgSCHCmnGetRaType0Mask
(
-U8 rbIdx,
-U8 rbgSize
+uint8_t rbIdx,
+uint8_t rbgSize
)
#else
-PRIVATE U32 rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
-U8 rbIdx;
-U8 rbgSize;
+static uint32_t rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
+uint8_t rbIdx;
+uint8_t rbgSize;
#endif
{
- U8 rbg;
- U32 rbgPosInRbgMask = 0;
+ uint8_t rbg;
+ uint32_t rbgPosInRbgMask = 0;
rbg = rbIdx/rbgSize;
rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
* Processing Steps:
* - Determine RA Type 1 mask for given rbIdex and rbg size.
*
- * @param[in] U8 rbIdx
- * @param[in] U8 rbgSize
- * @param[out] U8 *type1Subset
- * @return U32 RA type 1 mask
+ * @param[in] uint8_t rbIdx
+ * @param[in] uint8_t rbgSize
+ * @param[out] uint8_t *type1Subset
+ * @return uint32_t RA type 1 mask
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnGetRaType1Mask
+static uint32_t rgSCHCmnGetRaType1Mask
(
-U8 rbIdx,
-U8 rbgSize,
-U8 *type1Subset
+uint8_t rbIdx,
+uint8_t rbgSize,
+uint8_t *type1Subset
)
#else
-PRIVATE U32 rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
-U8 rbIdx;
-U8 rbgSize;
-U8 *type1Subset;
+static uint32_t rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
+uint8_t rbIdx;
+uint8_t rbgSize;
+uint8_t *type1Subset;
#endif
{
- U8 rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
- U32 rbPosInSubset;
+ uint8_t rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
+ uint32_t rbPosInSubset;
rbg = rbIdx/rbgSize;
rbgSubset = rbg % rbgSize;
* Processing Steps:
* - Determine RA Type 2 mask for given rbIdx and rbg size.
*
- * @param[in] U8 rbIdx
- * @param[out] U8 *maskIdx
- * @return U32 RA type 2 mask
+ * @param[in] uint8_t rbIdx
+ * @param[out] uint8_t *maskIdx
+ * @return uint32_t RA type 2 mask
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnGetRaType2Mask
+static uint32_t rgSCHCmnGetRaType2Mask
(
-U8 rbIdx,
-U8 *maskIdx
+uint8_t rbIdx,
+uint8_t *maskIdx
)
#else
-PRIVATE U32 rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
-U8 rbIdx;
-U8 *maskIdx;
+static uint32_t rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
+uint8_t rbIdx;
+uint8_t *maskIdx;
#endif
{
- U32 rbPosInType2;
+ uint32_t rbPosInType2;
*maskIdx = rbIdx / 32;
rbPosInType2 = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
Bool isPartialAlloc;
#endif
{
- U8 rbgSize = cell->rbgSize;
- U8 numAllocRbs = 0;
- U8 numAllocRbgs = 0;
- U8 rbStart = 0;
- U8 idx, noLyr, iTbs;
+ uint8_t rbgSize = cell->rbgSize;
+ uint8_t numAllocRbs = 0;
+ uint8_t numAllocRbgs = 0;
+ uint8_t rbStart = 0;
+ uint8_t idx, noLyr, iTbs;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchDlSfAllocInfo *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
RgSchBwRbgInfo *spsRbgInfo = &cell->spsBwRbgInfo;
/* If no RBS could be allocated, attempt RA TYPE 1 */
numAllocRbs = rgSCHCmnDlRaType1Alloc(dlSfAlloc,
- rbAllocInfo->rbsReq, spsRbgInfo, (U8)dlSfAlloc->nxtRbgSubset,
+ rbAllocInfo->rbsReq, spsRbgInfo, (uint8_t)dlSfAlloc->nxtRbgSubset,
&rbAllocInfo->allocInfo.raType1.rbgSubset,
&rbAllocInfo->resAllocInfo, isPartialAlloc);
iTbs = rbAllocInfo->tbInfo[1].iTbs;
noLyr = rbAllocInfo->tbInfo[1].noLyr;
rbAllocInfo->tbInfo[1].bytesAlloc =
- rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;;
+ rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;
}
/* Update rbAllocInfo with the allocation information */
*
**********************************************************/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlGetBestFitHole
+static Void rgSCHCmnDlGetBestFitHole
(
-U32 *allocMask,
-U8 numMaskRbs,
-U32 *crntAllocMask,
-U8 rbsReq,
-U8 *allocStart,
-U8 *allocNumRbs,
+uint32_t *allocMask,
+uint8_t numMaskRbs,
+uint32_t *crntAllocMask,
+uint8_t rbsReq,
+uint8_t *allocStart,
+uint8_t *allocNumRbs,
Bool isPartialAlloc
)
#else
-PRIVATE Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
+static Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
crntAllocMask, rbsReq, allocStart, allocNumRbs, isPartialAlloc)
-U32 *allocMask;
-U8 numMaskRbs;
-U32 *crntAllocMask;
-U8 rbsReq;
-U8 *allocStart;
-U8 *allocNumRbs;
+uint32_t *allocMask;
+uint8_t numMaskRbs;
+uint32_t *crntAllocMask;
+uint8_t rbsReq;
+uint8_t *allocStart;
+uint8_t *allocNumRbs;
Bool isPartialAlloc;
#endif
{
- U8 maskSz = (numMaskRbs + 31)/32;
- U8 maxMaskPos = (numMaskRbs % 32);
- U8 maskIdx, maskPos;
- U8 numAvailRbs = 0;
- U8 bestAvailNumRbs = 0;
+ uint8_t maskSz = (numMaskRbs + 31)/32;
+ uint8_t maxMaskPos = (numMaskRbs % 32);
+ uint8_t maskIdx, maskPos;
+ uint8_t numAvailRbs = 0;
+ uint8_t bestAvailNumRbs = 0;
S8 bestStartPos = -1;
S8 startPos = -1;
- U32 tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
- U32 bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
+ uint32_t tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
+ uint32_t bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
*allocNumRbs = numAvailRbs;
*allocStart = 0;
++numAvailRbs;
if (numAvailRbs == rbsReq)
{
- *allocStart = (U8)startPos;
+ *allocStart = (uint8_t)startPos;
*allocNumRbs = rbsReq;
break;
}
{
bestAvailNumRbs = numAvailRbs;
bestStartPos = startPos;
- cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(bestMask, tmpMask, 4 * sizeof(uint32_t));
}
numAvailRbs = 0;
startPos = -1;
- cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
+ memset(tmpMask, 0, 4 * sizeof(uint32_t));
}
}
if (*allocNumRbs == rbsReq)
if (*allocNumRbs == rbsReq)
{
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
- RETVOID;
+ memcpy(crntAllocMask, tmpMask, 4 * sizeof(uint32_t));
+ return;
}
else
{
if (bestAvailNumRbs && isPartialAlloc)
{
/* Partial allocation could have been done */
- *allocStart = (U8)bestStartPos;
+ *allocStart = (uint8_t)bestStartPos;
*allocNumRbs = bestAvailNumRbs;
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, bestMask, 4 * sizeof(uint32_t));
}
}
- RETVOID;
+ return;
}
#endif /* LTEMAC_SPS */
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE Void rgSCHCmnFindCodeRate
+static Void rgSCHCmnFindCodeRate
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 idx
+uint8_t idx
)
#else
-PRIVATE Void rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,idx)
+static Void rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,idx)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
-U8 idx;
+uint8_t idx;
#endif
{
- RETVOID;
+ return;
}
#endif
* - Adjust Imcs according to tbSize and ITBS.
*
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 *idx
+ * @param[in] uint8_t *idx
* @return void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj
+static Void rgSCHCmnNonDlfsPbchTbImcsAdj
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo,
-U8 idx,
-U8 rbsReq
+uint8_t idx,
+uint8_t rbsReq
)
#else
-PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj(cell,allocInfo, idx, rbsReq)
+static Void rgSCHCmnNonDlfsPbchTbImcsAdj(cell,allocInfo, idx, rbsReq)
RgSchCellCb *cell;
RgSchDlRbAlloc *allocInfo;
-U8 idx;
-U8 rbsReq;
+uint8_t idx;
+uint8_t rbsReq;
#endif
{
- U8 noLyrs = 0;
- U8 tbs = 0;
- U32 origBytesReq;
- U8 noRbgs = 0;
- U8 noRbs = 0;
+ uint8_t noLyrs = 0;
+ uint8_t tbs = 0;
+ uint32_t origBytesReq;
+ uint8_t noRbgs = 0;
+ uint8_t noRbs = 0;
RgSchDlSf *dlSf = allocInfo->dlSf;
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
/* This line will help in case if tbs is zero and reduction in MCS is not possible */
if (allocInfo->rbsReq == 0 )
{
- RETVOID;
+ return;
}
origBytesReq = rgTbSzTbl[noLyrs - 1][tbs][rbsReq - 1]/8;
RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
}
- RETVOID;
+ return;
}
/* Added funcion to adjust TBSize*/
/**
* Processing Steps:
*
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 numOvrlapgPbchRb
- * @param[in] U8 idx
- * @param[in] U8 pbchSsRsSym
+ * @param[in] uint8_t numOvrlapgPbchRb
+ * @param[in] uint8_t idx
+ * @param[in] uint8_t pbchSsRsSym
* @return void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj
+static Void rgSCHCmnNonDlfsPbchTbSizeAdj
(
RgSchDlRbAlloc *allocInfo,
-U8 numOvrlapgPbchRb,
-U8 pbchSsRsSym,
-U8 idx,
-U32 bytesReq
+uint8_t numOvrlapgPbchRb,
+uint8_t pbchSsRsSym,
+uint8_t idx,
+uint32_t bytesReq
)
#else
-PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,idx,bytesReq)
+static Void rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,idx,bytesReq)
RgSchDlRbAlloc *allocInfo;
-U8 numOvrlapgPbchRb;
-U8 pbchSsRsSym;
-U8 idx;
-U32 bytesReq;
+uint8_t numOvrlapgPbchRb;
+uint8_t pbchSsRsSym;
+uint8_t idx;
+uint32_t bytesReq;
#endif
{
- U32 reducedTbs = 0;
- U8 noLyrs = 0;
- U8 tbs = 0;
+ uint32_t reducedTbs = 0;
+ uint8_t noLyrs = 0;
+ uint8_t tbs = 0;
noLyrs = allocInfo->tbInfo[idx].noLyr;
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
- reducedTbs = bytesReq - (((U32)numOvrlapgPbchRb * (U32)pbchSsRsSym * 6)/8);
+ reducedTbs = bytesReq - (((uint32_t)numOvrlapgPbchRb * (uint32_t)pbchSsRsSym * 6)/8);
/* find out the ITbs & Imcs by identifying first Highest
number of bits compared with reduced bits considering the bits that are
allocInfo->tbInfo[idx].iTbs = tbs;
RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
- RETVOID;
+ return;
}
/* Added this function to find num of ovrlapping PBCH rb*/
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[out] U8 addtlRbsAvl
+ * @param[out] uint8_t addtlRbsAvl
* @return void
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl
+static uint8_t rgSCHCmnFindNumAddtlRbsAvl
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo
)
#else
-PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
+static uint8_t rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
#endif
{
- U8 addtlRbsAvl = 0;
+ uint8_t addtlRbsAvl = 0;
- TRC2(rgSCHCmnFindNumAddtlRbsAvl)
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[out] U8* numOvrlapgPbchRb
+ * @param[out] uint8_t* numOvrlapgPbchRb
* @return void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs
+static Void rgSCHCmnFindNumPbchOvrlapRbs
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 *numOvrlapgPbchRb
+uint8_t *numOvrlapgPbchRb
)
#else
-PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,numOvrlapgPbchRb)
+static Void rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,numOvrlapgPbchRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
-U8 *numOvrlapgPbchRb;
+uint8_t *numOvrlapgPbchRb;
#endif
{
*numOvrlapgPbchRb = 0;
- TRC2(rgSCHCmnFindNumPbchOvrlapRbs)
/*Find if we have already crossed the start boundary for PBCH 6 RBs,
* if yes then lets find the number of RBs which are getting overlapped
* with this allocation.*/
*numOvrlapgPbchRb = (cell->pbchRbEnd) - dlSf->bwAlloced;
}
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 pbchSsRsSym
+ * @param[in] uint8_t pbchSsRsSym
* @return void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj
+static Void rgSCHCmnNonDlfsPbchRbAllocAdj
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo,
-U8 pbchSsRsSym,
+uint8_t pbchSsRsSym,
Bool isBcchPcch
)
#else
-PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo,pbchSsRsSym)
+static Void rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo,pbchSsRsSym)
RgSchCellCb *cell;
RgSchDlRbAlloc *allocInfo;
-U8 pbchSsRsSym;
+uint8_t pbchSsRsSym;
Bool isBcchPcch;
#endif
{
RgSchDlSf *dlSf = allocInfo->dlSf;
- U8 numOvrlapgPbchRb = 0;
- U8 numOvrlapgAdtlPbchRb = 0;
- U8 totSym;
- U8 addtlRbsReq = 0;
- U8 moreAddtlRbsReq = 0;
- U8 addtlRbsAdd = 0;
- U8 moreAddtlRbsAdd = 0;
- U8 tbs;
- U8 origRbsReq = 0;
- U32 bytesReq;
- U8 noLyr;
- U8 divResult;
+ uint8_t numOvrlapgPbchRb = 0;
+ uint8_t numOvrlapgAdtlPbchRb = 0;
+ uint8_t totSym;
+ uint8_t addtlRbsReq = 0;
+ uint8_t moreAddtlRbsReq = 0;
+ uint8_t addtlRbsAdd = 0;
+ uint8_t moreAddtlRbsAdd = 0;
+ uint8_t tbs;
+ uint8_t origRbsReq = 0;
+ uint32_t bytesReq;
+ uint8_t noLyr;
+ uint8_t divResult;
- TRC2(rgSCHCmnNonDlfsPbchRbAllocAdj);
origRbsReq = allocInfo->rbsReq;
}
if (isBcchPcch == TRUE)
{
- RETVOID;
+ return;
}
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
}
}
- RETVOID;
+ return;
} /* end of rgSCHCmnNonDlfsPbchRbAllocAdj */
#endif
#endif
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc
+static S16 rgSCHCmnNonDlfsCmnRbAlloc
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
+static S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchDlRbAlloc *allocInfo;
#endif
#ifndef LTE_TDD
#ifdef LTEMAC_SPS
#endif
- U8 pbchSsRsSym = 0;
- U8 pbchFrame = 0;
- U8 tbs = 0;
+ uint8_t pbchSsRsSym = 0;
+ uint8_t pbchFrame = 0;
+ uint8_t tbs = 0;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
#endif
RgSchDlSf *dlSf = allocInfo->dlSf;
#ifdef LTEMAC_SPS
- U8 rbStart = 0;
- U8 spsRbsAlloc = 0;
+ uint8_t rbStart = 0;
+ uint8_t spsRbsAlloc = 0;
RgSchDlSfAllocInfo *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
#endif
- TRC2(rgSCHCmnNonDlfsCmnRbAlloc);
allocInfo->tbInfo[0].noLyr = 1;
/* Note: Initialize the masks to 0, this might not be needed since alloInfo
* is initialized to 0 at the beginning of allcoation */
allocInfo->resAllocInfo.raType0Mask = 0;
- cmMemset((U8*)allocInfo->resAllocInfo.raType1Mask, 0,
- RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
- cmMemset((U8*)allocInfo->resAllocInfo.raType2Mask, 0,
- RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
+ memset(allocInfo->resAllocInfo.raType1Mask, 0,
+ RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (uint32_t));
+ memset(allocInfo->resAllocInfo.raType2Mask, 0,
+ RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (uint32_t));
if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
(dlSf->bwAlloced == dlSf->bw))
allocInfo->allocInfo.raType2.rbStart = rbStart;
#else
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
#endif
}
else
{
#endif
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
allocInfo->rbsAlloc = allocInfo->rbsReq;
#ifdef LTEMAC_SPS
if (spsRbsAlloc)
{
- U8 idx;
+ uint8_t idx;
/* Update type 0, 1 and 2 masks */
dlSfAlloc->raType0Mask |= allocInfo->resAllocInfo.raType0Mask;
#ifdef RGSCH_SPS_UNUSED
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsCmnRbAllocRar
+static S16 rgSCHCmnNonDlfsCmnRbAllocRar
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
+static S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchDlRbAlloc *allocInfo;
#endif
{
RgSchDlSf *dlSf = allocInfo->dlSf;
- TRC2(rgSCHCmnNonDlfsCmnRbAllocRar);
if(dlSf->bwAlloced == dlSf->bw)
allocInfo->allocInfo.raType2.isLocal = TRUE;
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
allocInfo->rbsAlloc = allocInfo->rbsReq;
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl
+static Bool rgSCHCmnNonDlfsSFRBwAvlbl
(
RgSchCellCb *cell,
RgSchSFRPoolInfo **sfrpoolInfo,
Bool isUeCellEdge
)
#else
-PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl(cell, sfrpoolInfo, dlSf, allocInfo, isUeCellEdge)
+static Bool rgSCHCmnNonDlfsSFRBwAvlbl(cell, sfrpoolInfo, dlSf, allocInfo, isUeCellEdge)
RgSchCellCb *cell;
RgSchSFRPoolInfo **sfrpoolInfo;
RgSchDlSf *dlSf;
RgSchSFRPoolInfo *sfrPool;
RgSchSFRPoolInfo *sfrCEPool;
- U8 tbs;
- U8 noLyrs;
+ uint8_t tbs;
+ uint8_t noLyrs;
RgSchSFRPoolInfo *poolWithMaxAvlblBw = NULLP;
- U32 bwAvlbl = 0;
- U32 addtnlPRBs = 0;
+ uint32_t bwAvlbl = 0;
+ uint32_t addtnlPRBs = 0;
if (dlSf->bw <= dlSf->bwAlloced)
{
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl
+static Bool rgSCHCmnNonDlfsBwAvlbl
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo
)
#else
-PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl(cell, dlSf, allocInfo)
+static Bool rgSCHCmnNonDlfsBwAvlbl(cell, dlSf, allocInfo)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
#endif
{
- U8 tbs;
- U8 noLyrs;
- U8 ignoredDfctRbg = FALSE;
+ uint8_t tbs;
+ uint8_t noLyrs;
+ uint8_t ignoredDfctRbg = FALSE;
- TRC2(rgSCHCmnNonDlfsBwAvlbl);
if (dlSf->bw <= dlSf->bwAlloced)
{
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
CmLListCp *l;
CmLList *n;
RgSchSFRPoolInfo *sfrPool;
- TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
l = &dlSf->sfrTotalPoolInfo.ccPool;
n = cmLListFirst(l);
}
else
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
+static S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
+static S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
CmLListCp *l;
RgSchSFRPoolInfo *sfrCCPool2 = NULL;
S16 ret = RFAILED;
- TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
/* Move the type2End pivot forward */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc
+static Void rgSCHCmnNonDlfsUpdTyp2Alloc
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
-PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
+static Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
- TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
/* Move the type2End pivot forward */
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
//#ifndef LTEMAC_SPS
/*Fix for ccpu00123918*/
dlSf->type2Start += numRb;
//#endif
- RETVOID;
+ return;
}
/**
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsType0Alloc
+static Void rgSCHCmnNonDlfsType0Alloc
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUeCb *ue
)
#else
-PRIVATE Void rgSCHCmnNonDlfsType0Alloc(cell, dlSf, allocInfo, dlUe)
+static Void rgSCHCmnNonDlfsType0Alloc(cell, dlSf, allocInfo, dlUe)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
RgSchUeCb *ue;
#endif
{
- U32 dlAllocMsk = 0;
- U8 rbgFiller = dlSf->lstRbgDfct;
- U8 noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
- //U8 noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
- U8 noRbs;
- U8 noLyr;
- U8 iTbs;
- U32 tb1BytesAlloc = 0;
- U32 tb2BytesAlloc = 0;
+ uint32_t dlAllocMsk = 0;
+ uint8_t rbgFiller = dlSf->lstRbgDfct;
+ uint8_t noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
+ //uint8_t noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
+ uint8_t noRbs;
+ uint8_t noLyr;
+ uint8_t iTbs;
+ uint32_t tb1BytesAlloc = 0;
+ uint32_t tb2BytesAlloc = 0;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnNonDlfsType0Alloc);
//if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
/* Fix for ccpu00123919*/
{
if (--noRbgs == 0)
{
- RETVOID;
+ return;
}
noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
}
{
if (--noRbgs == 0)
{
- RETVOID;
+ return;
}
noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
}
else
{
allocInfo->tbInfo[1].bytesAlloc =
- rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
+ rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
/* DwPts Scheduling Changes Start */
#ifdef LTE_TDD
if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
/* The last RBG which can be smaller than the RBG size is consedered
* only for the first time allocation of TYPE0 UE */
dlSf->lstRbgDfct = 0;
- RETVOID;
+ return;
}
#endif
#ifndef LTE_TDD
*
* Processing Steps:
*
- * @param[in] U8 *rntpPtr
- * @param[in] U8 startRb
- * @param[in] U8 numRb
+ * @param[in] uint8_t *rntpPtr
+ * @param[in] uint8_t startRb
+ * @param[in] uint8_t numRb
*
* @return Void
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE S16 rgSCHCmnBuildRntpInfo
+static S16 rgSCHCmnBuildRntpInfo
(
RgSchCellCb *cell,
-U8 *rntpPtr,
-U8 startRb,
-U8 nmbRb,
-U16 bw
+uint8_t *rntpPtr,
+uint8_t startRb,
+uint8_t nmbRb,
+uint16_t bw
)
#else
-PRIVATE S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
+static S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
RgSchCellCb *cell;
-U8 *rntpPtr;
-U8 startRb;
-U8 nmbRb;
-U16 bw;
+uint8_t *rntpPtr;
+uint8_t startRb;
+uint8_t nmbRb;
+uint16_t bw;
#endif
{
- U16 rbPtrStartIdx; /* Start Index of Octete Buffer to be filled */
- U16 rbPtrEndIdx; /* End Index of Octete Buffer to be filled */
- U16 rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
- U16 nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
+ uint16_t rbPtrStartIdx; /* Start Index of Octete Buffer to be filled */
+ uint16_t rbPtrEndIdx; /* End Index of Octete Buffer to be filled */
+ uint16_t rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
+ uint16_t nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
- TRC2(rgSCHCmnBuildRntpInfo);
rbPtrStartIdx = (startRb)/8;
rbPtrEndIdx = (startRb + nmbRb)/8;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
+static S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
RgSchSFRPoolInfo *sfrPool,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
+static S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
RgSchSFRPoolInfo *sfrPool;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
#ifndef LTEMAC_SPS
S16 ret;
#endif
- TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc
+static Void rgSCHCmnNonDlfsSFRPoolType0Alloc
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo
)
#else
-PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, poolInfo, allocInfo)
+static Void rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, poolInfo, allocInfo)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchSFRPoolInfo *poolInfo;
RgSchDlRbAlloc *allocInfo;
#endif
{
- U32 dlAllocMsk = 0;
- U8 rbgFiller = 0;
- U8 noRbgs = 0;
- U8 noRbs;
- U8 noLyr;
- U8 iTbs;
+ uint32_t dlAllocMsk = 0;
+ uint8_t rbgFiller = 0;
+ uint8_t noRbgs = 0;
+ uint8_t noRbs;
+ uint8_t noLyr;
+ uint8_t iTbs;
- TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
{
{
if (--noRbgs == 0)
{
- RETVOID;
+ return;
}
noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
}
else
{
allocInfo->tbInfo[1].bytesAlloc =
- rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
+ rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
}
}
/* The last RBG which can be smaller than the RBG size is consedered
* only for the first time allocation of TYPE0 UE */
dlSf->lstRbgDfct = 0;
- RETVOID;
+ return;
}
#endif
/**
**/
#ifdef ANSI
-PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp
+static void rgSCHCmnNonDlfsDsfrRntpComp
(
RgSchCellCb *cell,
RgSchDlSf *dlSf
)
#else
-PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp(cell, dlSf)
+static void rgSCHCmnNonDlfsDsfrRntpComp(cell, dlSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
#endif
{
- PRIVATE U16 samples = 0;
- U16 i;
- U16 bwBytes = (dlSf->bw-1)/8;
+ static uint16_t samples = 0;
+ uint16_t i;
+ uint16_t bwBytes = (dlSf->bw-1)/8;
RgrLoadInfIndInfo *rgrLoadInf;
- U16 len;
- U16 ret = ROK;
+ uint16_t len;
+ uint16_t ret = ROK;
- TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
"allocate memory for sending LoadInfo");
- RETVOID;
+ return;
}
rgrLoadInf->u.rntpInfo.pres = cell->rntpAggrInfo.pres;
"rgSCHUtlRgrLoadInfInd() returned RFAILED");
}
- cmMemset(cell->rntpAggrInfo.val,0,len);
+ memset(cell->rntpAggrInfo.val,0,len);
samples = 0;
}
}
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlSf *dlSf
- * @param[out] U8 *isDlBwAvail
+ * @param[out] uint8_t *isDlBwAvail
*
* @return S16
* -# ROK
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
-PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc
+static S16 rgSCHCmnSFRNonDlfsUeRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 *isDlBwAvail
+uint8_t *isDlBwAvail
)
#else
-PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
+static S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
-U8 *isDlBwAvail;
+uint8_t *isDlBwAvail;
#endif
{
RgSchDlRbAlloc *allocInfo;
Bool isUECellEdge;
RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
- TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
allocInfo->allocInfo.raType2.isLocal = TRUE;
/* rg004.201 patch - ccpu00109921 fix end */
/* MS_FIX for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)sfrpoolInfo->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)sfrpoolInfo->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
/* rg007.201 - Changes for MIMO feature addition */
/* rg008.201 - Removed dependency on MIMO compile-time flag */
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlSf *dlSf
- * @param[out] U8 *isDlBwAvail
+ * @param[out] uint8_t *isDlBwAvail
*
* @return S16
* -# ROK
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc
+static S16 rgSCHCmnNonDlfsUeRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 *isDlBwAvail
+uint8_t *isDlBwAvail
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
+static S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
-U8 *isDlBwAvail;
+uint8_t *isDlBwAvail;
#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *dlUe;
#ifdef LAA_DBG
- U32 dbgRbsReq = 0;
+ uint32_t dbgRbsReq = 0;
#endif
- TRC2(rgSCHCmnNonDlfsUeRbAlloc);
#ifdef RG_5GTF
RgSch5gtfUeCb *ue5gtfCb = &(ue->ue5gtfCb);
*
* @param[in] RgSchCellCb *cell
* @param[in, out] RgSchCmnCcchSduRbAlloc *allocInfo
- * @param[in] U8 isRetx
+ * @param[in] uint8_t isRetx
*
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc
+static Void rgSCHCmnNonDlfsCcchSduAlloc
(
RgSchCellCb *cell,
RgSchCmnCcchSduRbAlloc *allocInfo,
-U8 isRetx
+uint8_t isRetx
)
#else
-PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
+static Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
RgSchCellCb *cell;
RgSchCmnCcchSduRbAlloc *allocInfo;
-U8 isRetx;
+uint8_t isRetx;
#endif
{
S16 ret;
RgSchDlSf *dlSf = allocInfo->ccchSduDlSf;
RgSchUeCb *ueCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
if (isRetx)
{
cmLListAdd2Tail(nonSchdCcchSduLst, schdLnkNode);
toBeSchdLnk = toBeSchdLnk->next;
} while(toBeSchdLnk);
- RETVOID;
+ return;
}
/* Allocation successful: Add UE to the scheduled list */
}
- RETVOID;
+ return;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc
+static S16 rgSCHCmnNonDlfsCcchSduRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchDlSf *dlSf
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf)
+static S16 rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
/*Fix for ccpu00123918*/
/* Push this harq process back to the free queue */
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
allocInfo->rbsAlloc = allocInfo->rbsReq;
allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc
+static S16 rgSCHCmnNonDlfsMsg4RbAlloc
(
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgSchDlSf *dlSf
)
#else
-PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf)
+static S16 rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf)
RgSchCellCb *cell;
RgSchRaCb *raCb;
RgSchDlSf *dlSf;
#endif
{
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
/* LTE_ADV_FLAG_REMOVED_START */
#ifndef LTE_TDD
*
* @param[in] RgSchCellCb *cell
* @param[in, out] RgSchCmnMsg4RbAlloc *allocInfo
- * @param[in] U8 isRetx
+ * @param[in] uint8_t isRetx
*
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc
+static Void rgSCHCmnNonDlfsMsg4Alloc
(
RgSchCellCb *cell,
RgSchCmnMsg4RbAlloc *allocInfo,
-U8 isRetx
+uint8_t isRetx
)
#else
-PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
+static Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
RgSchCellCb *cell;
RgSchCmnMsg4RbAlloc *allocInfo;
-U8 isRetx;
+uint8_t isRetx;
#endif
{
S16 ret;
RgSchDlSf *dlSf = allocInfo->msg4DlSf;
RgSchRaCb *raCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsMsg4Alloc);
if (isRetx)
{
cmLListAdd2Tail(nonSchdMsg4Lst, schdLnkNode);
toBeSchdLnk = toBeSchdLnk->next;
} while(toBeSchdLnk);
- RETVOID;
+ return;
}
/* Allocation successful: Add UE to the scheduled list */
}
- RETVOID;
+ return;
}
/**
RgSchDlSf *dlSf = allocInfo->dedDlSf;
RgSchUeCb *ue = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- U8 isDlBwAvail;
- TRC2(rgSCHCmnNonDlfsDedRbAlloc);
+ uint8_t isDlBwAvail;
/* Perform allocaations for the list */
}
}
- RETVOID;
+ return;
}
/**
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- U8 raRspCnt = 0;
+ uint8_t raRspCnt = 0;
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsRbAlloc);
/* Allocate for MSG4 retransmissions */
if (allocInfo->msg4Alloc.msg4RetxLst.count)
}
/* LTE_ADV_FLAG_REMOVED_END */
#endif /* LTE_TDD */
- RETVOID;
+ return;
}
/***********************************************************
**********************************************************/
#ifdef LTEMAC_SPS
#ifdef ANSI
-U32 rgSCHCmnCalcRiv
+uint32_t rgSCHCmnCalcRiv
(
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
#else
-U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
-U8 bw;
-U8 rbStart;
-U8 numRb;
+uint32_t rgSCHCmnCalcRiv(bw, rbStart, numRb)
+uint8_t bw;
+uint8_t rbStart;
+uint8_t numRb;
#endif
#else
#ifdef ANSI
-U32 rgSCHCmnCalcRiv
+uint32_t rgSCHCmnCalcRiv
(
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
#else
-U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
-U8 bw;
-U8 rbStart;
-U8 numRb;
+uint32_t rgSCHCmnCalcRiv(bw, rbStart, numRb)
+uint8_t bw;
+uint8_t rbStart;
+uint8_t numRb;
#endif
#endif
{
- U8 numRbMinus1 = numRb - 1;
- U32 riv;
+ uint8_t numRbMinus1 = numRb - 1;
+ uint32_t riv;
- TRC2(rgSCHCmnCalcRiv);
if (numRbMinus1 <= bw/2)
{
*
* @param[in] RgSchCellCb* cell
* @param[in] RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES]
- * @param[in] U8 raArrSz
+ * @param[in] uint8_t raArrSz
* @return S16
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlCpyRachInfo
+static S16 rgSCHCmnDlCpyRachInfo
(
RgSchCellCb *cell,
RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
-U8 raArrSz
+uint8_t raArrSz
)
#else
-PRIVATE S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
+static S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
RgSchCellCb *cell;
RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES];
-U8 raArrSz;
+uint8_t raArrSz;
#endif
{
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 sfNum;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfNum;
S16 sfnIdx;
- U16 subfrmIdx;
- U8 numRfs;
- U8 numSubfrms;
- U8 sfcount;
+ uint16_t subfrmIdx;
+ uint8_t numRfs;
+ uint8_t numSubfrms;
+ uint8_t sfcount;
S16 ret;
- TRC2(rgSCHCmnDlCpyRachInfo);
/* Allocate RACH response information for each DL
* subframe in a radio frame */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchCmnDlUe *ueDl
- * @param[in] U8 cqi
+ * @param[in] uint8_t cqi
*
* @return S32 iTbs
*
**/
#ifdef LTE_TDD
#ifdef ANSI
-PRIVATE S32 rgSchCmnFetchItbs
+static S32 rgSchCmnFetchItbs
(
RgSchCellCb *cell,
RgSchCmnDlUe *ueDl,
RgSchDlSf *subFrm,
-U8 cqi,
-U8 cfi,
-U8 cwIdx,
-U8 noLyr
+uint8_t cqi,
+uint8_t cfi,
+uint8_t cwIdx,
+uint8_t noLyr
)
#else
-PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
+static S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
RgSchCellCb *cell;
RgSchCmnDlUe *ueDl;
RgSchDlSf *subFrm;
-U8 cqi;
-U8 cfi;
-U8 cwIdx;
-U8 noLyr;
+uint8_t cqi;
+uint8_t cfi;
+uint8_t cwIdx;
+uint8_t noLyr;
#endif
#else
#ifdef ANSI
-PRIVATE S32 rgSchCmnFetchItbs
+static S32 rgSchCmnFetchItbs
(
RgSchCellCb *cell,
RgSchCmnDlUe *ueDl,
-U8 cqi,
-U8 cfi,
-U8 cwIdx,
-U8 noLyr
+uint8_t cqi,
+uint8_t cfi,
+uint8_t cwIdx,
+uint8_t noLyr
)
#else
-PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
+static S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
RgSchCellCb *cell;
RgSchCmnDlUe *ueDl;
-U8 cqi;
-U8 cfi;
-U8 cwIdx;
-U8 noLyr;
+uint8_t cqi;
+uint8_t cfi;
+uint8_t cwIdx;
+uint8_t noLyr;
#endif
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
S32 iTbs = 0;
- TRC2(rgSchCmnFetchItbs);
#ifdef LTE_TDD
/* Special Handling for Spl Sf when CFI is 3 as
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw
+static Void rgSCHCmnDlAllocTxRb1Tb1Cw
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchDlRbAlloc *allocInfo;
S16 ret;
- U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
+ uint8_t numRb;
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
/* Adding UE to RbAllocInfo TX Lst */
rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
#endif
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw
+static Void rgSCHCmnDlAllocRetxRb1Tb1Cw
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchDlRbAlloc *allocInfo;
S16 ret;
- U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
+ uint8_t numRb;
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
* to the nonSchdTxRetxUeLst and let spfc scheduler take care of it during
* finalization. */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
/* Fill UE alloc Info */
allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
#endif
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM1
+static Void rgSCHCmnDlAllocTxRbTM1
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM1);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM1
+static Void rgSCHCmnDlAllocRetxRbTM1
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM1);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM2
+static Void rgSCHCmnDlAllocTxRbTM2
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM2);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM2
+static Void rgSCHCmnDlAllocRetxRbTM2
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM2);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM3
+static Void rgSCHCmnDlAllocTxRbTM3
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM3);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM3
+static Void rgSCHCmnDlAllocRetxRbTM3
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM3);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
proc, cellWdAllocInfo);
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[out] U8 *raType
+ * @param[out] uint8_t *raType
* @return TfuDciFormat
*
**/
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *raType
+uint8_t *raType
)
#else
TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *raType;
+uint8_t *raType;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSlctPdcchFrmt);
/* ccpu00140894- Selective DCI Format and RA type should be selected only
* after TX Mode transition is completed*/
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlTM3RetxRetx
+static Void rgSCHCmnDlTM3RetxRetx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
Bool swpFlg;
- U8 precInfo;
- U8 noTxLyrs;
- U8 precInfoAntIdx;
+ uint8_t precInfo;
+ uint8_t noTxLyrs;
+ uint8_t precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlTM4RetxRetx
+static Void rgSCHCmnDlTM4RetxRetx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
Bool swpFlg = FALSE;
- U8 precInfo;
+ uint8_t precInfo;
#ifdef FOUR_TX_ANTENNA
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
#endif
- U8 noTxLyrs;
+ uint8_t noTxLyrs;
- TRC2(rgSCHCmnDlTM4RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
precInfo = 0;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx
+static Void rgSCHCmnDlSMGetAttrForTxRetx
(
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
Bool *swpFlg
)
#else
-PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, frthrScp,\
+static Void rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, frthrScp,\
swpFlg)
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
*frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
}
}
- RETVOID;
+ return;
}
\f
* Invoked by: rgSCHCmnDlGetAttrForTM3
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM3PrecInf2
+static uint8_t rgSCHCmnDlTM3PrecInf2
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
+static uint8_t rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
- TRC2(rgSCHCmnDlTM3PrecInf2);
return (0);
}
* Invoked by: rgSCHCmnDlGetAttrForTM4
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM4PrecInf2
+static uint8_t rgSCHCmnDlTM4PrecInf2
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
+static uint8_t rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precIdx;
+ uint8_t precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf2);
if (ueDl->mimoInfo.ri == numTxLyrs)
{
* Invoked by: rgSCHCmnDlGetAttrForTM3
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM3PrecInf4
+static uint8_t rgSCHCmnDlTM3PrecInf4
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
+static uint8_t rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
- U8 precIdx;
+ uint8_t precIdx;
- TRC2(rgSCHCmnDlTM3PrecInf4);
if (bothCwEnbld)
{
* Invoked by: rgSCHCmnDlGetAttrForTM4
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM4PrecInf4
+static uint8_t rgSCHCmnDlTM4PrecInf4
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
+static uint8_t rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precInfoBaseIdx, precIdx;
+ uint8_t precInfoBaseIdx, precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf4);
precInfoBaseIdx = (ue->mimoInfo.puschFdbkVld)? (16):
(ueDl->mimoInfo.pmi);
*
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
- * @param[out] U8 *numTxLyrs
+ * @param[out] uint8_t *numTxLyrs
* @param[out] Bool *isTraDiv
- * @param[out] U8 *prcdngInf
- * @param[out] U8 *raType
+ * @param[out] uint8_t *prcdngInf
+ * @param[out] uint8_t *raType
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlGetAttrForTM3
+static Void rgSCHCmnDlGetAttrForTM3
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numTxLyrs,
+uint8_t *numTxLyrs,
TfuDciFormat *dciFrmt,
-U8 *prcdngInf,
+uint8_t *prcdngInf,
RgSchDlHqTbCb **retxTb,
RgSchDlHqTbCb **txTb,
Bool *frthrScp,
Bool *swpFlg,
-U8 *raType
+uint8_t *raType
)
#else
-PRIVATE Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
+static Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U8 *numTxLyrs;
+uint8_t *numTxLyrs;
TfuDciFormat *dciFrmt;
-U8 *prcdngInf;
+uint8_t *prcdngInf;
RgSchDlHqTbCb **retxTb;
RgSchDlHqTbCb **txTb;
Bool *frthrScp;
Bool *swpFlg;
-U8 *raType;
+uint8_t *raType;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM3);
/* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with
HQP */
*numTxLyrs = 1;
*frthrScp = FALSE;
*prcdngInf = 0;
- RETVOID;
+ return;
}
/* Determine the 2 TB transmission attributes */
*raType = RG_SCH_CMN_RA_TYPE0;
}
*prcdngInf = 0;
- RETVOID;
+ return;
}
else /* NumAntPorts == 4 */
{
*raType = RG_SCH_CMN_RA_TYPE0;
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
*prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
else
{
*raType = RG_SCH_CMN_RA_TYPE0;
}
*prcdngInf = 0;
- RETVOID;
+ return;
}
}
}
- RETVOID;
+ return;
}
*
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
- * @param[out] U8 *numTxLyrs
+ * @param[out] uint8_t *numTxLyrs
* @param[out] Bool *isTraDiv
- * @param[out] U8 *prcdngInf
- * @param[out] U8 *raType
+ * @param[out] uint8_t *prcdngInf
+ * @param[out] uint8_t *raType
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlGetAttrForTM4
+static Void rgSCHCmnDlGetAttrForTM4
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numTxLyrs,
+uint8_t *numTxLyrs,
TfuDciFormat *dciFrmt,
-U8 *prcdngInf,
+uint8_t *prcdngInf,
RgSchDlHqTbCb **retxTb,
RgSchDlHqTbCb **txTb,
Bool *frthrScp,
Bool *swpFlg,
-U8 *raType
+uint8_t *raType
)
#else
-PRIVATE Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
+static Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U8 *numTxLyrs;
+uint8_t *numTxLyrs;
TfuDciFormat *dciFrmt;
-U8 *prcdngInf;
+uint8_t *prcdngInf;
RgSchDlHqTbCb **retxTb;
RgSchDlHqTbCb **txTb;
Bool *frthrScp;
Bool *swpFlg;
-U8 *raType;
+uint8_t *raType;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM4);
*frthrScp = FALSE;
/* Integration_fix: SPS Proc shall always have only one Cw */
*numTxLyrs = 1;
*frthrScp = FALSE;
*prcdngInf = 0;
- RETVOID;
+ return;
}
if (ueDl->mimoInfo.ri == 1)
*raType = RG_SCH_CMN_RA_TYPE0;
*frthrScp = FALSE;
*prcdngInf = 0; /*When RI= 1*/
- RETVOID;
+ return;
}
/* Determine the 2 TB transmission attributes */
*numTxLyrs = 1;
*prcdngInf = (getPrecInfoFunc[1][cell->numTxAntPorts/2 - 1])\
(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
else /* NumAntPorts == 4 */
{
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
*prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
else
{
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
*prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
}
}
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlTM3TxRetx
+static Void rgSCHCmnDlTM3TxRetx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
RgSchDlHqTbCb *retxTb, *txTb;
Bool frthrScp;
Bool swpFlg;
- U8 prcdngInf;
- U8 numTxLyrs;
+ uint8_t prcdngInf;
+ uint8_t numTxLyrs;
- TRC2(rgSCHCmnDlTM3TxRetx);
frthrScp = FALSE;
ret = ROK;
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Adding UE to RbAllocInfo RETX-TX Lst */
rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
prcdngInf, numTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlTM4TxRetx
+static Void rgSCHCmnDlTM4TxRetx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
RgSchDlHqTbCb *retxTb, *txTb;
Bool frthrScp;
Bool swpFlg;
- U8 prcdngInf;
- U8 numTxLyrs;
+ uint8_t prcdngInf;
+ uint8_t numTxLyrs;
- TRC2(rgSCHCmnDlTM4TxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
* with the proc to the nonSchdTxRetxUeLst and let spfc scheduler
* take care of it during finalization. */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Adding UE to RbAllocInfo RETX-TX Lst */
rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
prcdngInf, numTxLyrs, subFrm)
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlTM3TxTx
+static Void rgSCHCmnDlTM3TxTx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
- U8 noTxLyrs;
- U8 precInfo;
+ uint8_t numRb;
+ uint8_t noTxLyrs;
+ uint8_t precInfo;
S16 ret;
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = 1;
precInfo = 0; /* TD */
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = ueDl->mimoInfo.ri;
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlTM4TxTx
+static Void rgSCHCmnDlTM4TxTx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
- U8 precInfo;
- U8 noTxLyrs;
- U8 precInfoAntIdx;
+ uint8_t numRb;
+ uint8_t precInfo;
+ uint8_t noTxLyrs;
+ uint8_t precInfoAntIdx;
S16 ret;
- TRC2(rgSCHCmnDlTM4TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = 1;
precInfo = 0; /* TD */
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = 1;
precInfo = 0; /* PrecInfo as 0 for RI=1*/
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = ueDl->mimoInfo.ri;
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM4
+static Void rgSCHCmnDlAllocTxRbTM4
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM4);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM4
+static Void rgSCHCmnDlAllocRetxRbTM4
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM4);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
proc, cellWdAllocInfo);
}
- RETVOID;
+ return;
}
#ifdef RG_UNUSED
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM5
+static Void rgSCHCmnDlAllocTxRbTM5
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM5
+static Void rgSCHCmnDlAllocRetxRbTM5
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
- RETVOID;
+ return;
}
#endif
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM6
+static Void rgSCHCmnDlAllocTxRbTM6
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl;
S16 ret;
- U8 numRb;
+ uint8_t numRb;
- TRC2(rgSCHCmnDlAllocTxRbTM6);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
/* Fill UE alloc Info */
allocInfo->rbsReq = numRb;
allocInfo->dlSf = subFrm;
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM6
+static Void rgSCHCmnDlAllocRetxRbTM6
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl;
S16 ret;
- U8 numRb;
+ uint8_t numRb;
- TRC2(rgSCHCmnDlAllocRetxRbTM6);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Adding UE to allocInfo RETX Lst */
rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
/* Fill UE alloc Info */
allocInfo->rbsReq = numRb;
allocInfo->dlSf = subFrm;
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocTxRbTM7
+static Void rgSCHCmnDlAllocTxRbTM7
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocTxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocTxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM7);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM7
+static Void rgSCHCmnDlAllocRetxRbTM7
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PRIVATE Void rgSCHCmnDlAllocRetxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+static Void rgSCHCmnDlAllocRetxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM7);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return S16
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- U32 newSchBits = 0;
- U32 prevSchBits = 0;
+ uint32_t newSchBits = 0;
+ uint32_t prevSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocTxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
{
RgSchTddSfType txSfType = 0;
- TRC2(rgSCHCmnRetxAvoidTdd);
/* Get the RBs of TB that will be retransmitted */
if (proc->tbInfo[0].state == HQ_TB_NACKED)
RgSchDlHqProcCb *proc;
#endif
{
- U8 reqRbs;
+ uint8_t reqRbs;
- TRC2(rgSCHCmnRetxAllocAvoid);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return S16
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- U32 newSchBits = 0;
+ uint32_t newSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocRetxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqTbCb *tbInfo
- * @param[in] U32 bo
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return S16
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb
+static S16 rgSCHCmnDlAlloc1CwTxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 bo,
-U8 *numRb,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
)
#else
-PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
+static S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U32 bo;
-U8 *numRb;
-U32 *effBo;
+uint32_t bo;
+uint8_t *numRb;
+uint32_t *effBo;
#endif
{
- U32 tbSz;
- U8 imcs;
- U8 iTbs;
+ uint32_t tbSz;
+ uint8_t imcs;
+ uint8_t iTbs;
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U32 oldReq;
- U32 reqBytes;
+ uint32_t oldReq;
+ uint32_t reqBytes;
/* Correcting wrap around issue.
* This change has been done at mutliple places in this function.*/
- U32 tempNumRb;
- TRC2(rgSCHCmnDlAlloc1CwTxRb);
+ uint32_t tempNumRb;
reqBytes = bo;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbSz, \
iTbs, imcs, tbInfo, ue->ue5gtfCb.rank);
- *numRb = (U8) tempNumRb;
+ *numRb = (uint8_t) tempNumRb;
/* Update the subframe Allocated BW field */
subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
* of specific scheduler.
*
* @param[in] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 tbInfoIdx
- * @param[in] U32 cnsmdBytes
+ * @param[in] uint8_t tbInfoIdx
+ * @param[in] uint32_t cnsmdBytes
* @return Void
*
**/
Void rgSCHCmnRdcImcsTxTb
(
RgSchDlRbAlloc *allocInfo,
-U8 tbInfoIdx,
-U32 cnsmdBytes
+uint8_t tbInfoIdx,
+uint32_t cnsmdBytes
)
#else
Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
RgSchDlRbAlloc *allocInfo;
-U8 tbInfoIdx;
-U32 cnsmdBytes;
+uint8_t tbInfoIdx;
+uint32_t cnsmdBytes;
#endif
{
- RETVOID;
+ return;
/*The below functionality is not needed.*/
- U8 noLyr;
- U8 iTbs;
- U16 numRb;
+ uint8_t noLyr;
+ uint8_t iTbs;
+ uint16_t numRb;
- TRC2(rgSCHCmnRdcImcsTxTb);
iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
{
if ((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) == cnsmdBytes)
{
- RETVOID;
+ return;
}
}
/* Get iTbs as suitable for the consumed bytes */
{
RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].\
tbCb->dlGrnt.iMcs);
- RETVOID;
+ return;
}
iTbs--;
}
iTbs++;
RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].tbCb->dlGrnt.iMcs);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
* @param[in] RgSchDlHqProcCb bo
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb
+static S16 rgSCHCmnDlAlloc2CwTxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U32 bo,
-U8 *numRbRef,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRbRef,
+uint32_t *effBo
)
#else
-PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
+static S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U32 bo;
-U8 *numRbRef;
-U32 *effBo;
+uint32_t bo;
+uint8_t *numRbRef;
+uint32_t *effBo;
#endif
{
- U32 noRes;
- U32 eff1, eff2;
- U32 tb1Sz, tb2Sz;
- U8 imcs1, imcs2;
- U8 noLyr1, noLyr2;
- U8 iTbs1, iTbs2;
+ uint32_t noRes;
+ uint32_t eff1, eff2;
+ uint32_t tb1Sz, tb2Sz;
+ uint8_t imcs1, imcs2;
+ uint8_t noLyr1, noLyr2;
+ uint8_t iTbs1, iTbs2;
RgSchCmnDlCell *cellDl;
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U32 oldReq;
- U32 reqBytes;
+ uint32_t oldReq;
+ uint32_t reqBytes;
/* Fix: MUE_PERTTI_DL */
- U32 numRb;
+ uint32_t numRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
+ uint8_t cfi = cellSch->dl.currCfi;
S16 availBw;
- U32 availBits = 0;
+ uint32_t availBits = 0;
#ifdef LTE_ADV
- U32 boTmp = bo;
+ uint32_t boTmp = bo;
#endif
- TRC2(rgSCHCmnDlAlloc2CwTxRb);
reqBytes = bo;
cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
}
else
{
- U8 cqi = ueDl->mimoInfo.cwInfo[0].cqi;
+ uint8_t cqi = ueDl->mimoInfo.cwInfo[0].cqi;
#ifdef LTE_TDD
- iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
+ iTbs1 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
#else
- iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
+ iTbs1 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
#endif
cqi = ueDl->mimoInfo.cwInfo[1].cqi;
#ifdef LTE_TDD
- iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
+ iTbs2 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
#else
- iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
+ iTbs2 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
#endif
}
if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
{
/* Max Rb for Special Sf is approximated as 4/3 of maxRb */
- rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (U8*)&numRb, ueDl->maxRb*4/3,
+ rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (uint8_t*)&numRb, ueDl->maxRb*4/3,
&iTbs1, &iTbs2, noLyr1,
noLyr2, &tb1Sz, &tb2Sz, cfi);
/* Check for available Bw */
iTbs1, imcs1, &proc->tbInfo[0], noLyr1);
RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
iTbs2, imcs2, &proc->tbInfo[1], noLyr2);
- *numRbRef = (U8)numRb;
+ *numRbRef = (uint8_t)numRb;
return ROK;
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqTbCb *reTxTb
* @param[in] RgSchDlHqTbCb *txTb
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb
+static S16 rgSCHCmnDlAlloc2CwTxRetxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *reTxTb,
RgSchDlHqTbCb *txTb,
-U8 *numRb,
-U32 *effBo
+uint8_t *numRb,
+uint32_t *effBo
)
#else
-PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
+static S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
effBo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqTbCb *reTxTb;
RgSchDlHqTbCb *txTb;
-U8 *numRb;
-U32 *effBo;
+uint8_t *numRb;
+uint32_t *effBo;
#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U8 imcs1, imcs2;
- U8 noLyr2;
- U16 tb2Sz;
+ uint8_t imcs1, imcs2;
+ uint8_t noLyr2;
+ uint16_t tb2Sz;
RgSchCmnDlUeCwInfo *otherCw;
S16 availBw;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 cfi = cellDl->currCfi;
- U8 iTbs;
+ uint8_t cfi = cellDl->currCfi;
+ uint8_t iTbs;
- TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
else
{
#ifdef LTE_TDD
- iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi,
+ iTbs = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi,
!(ueDl->mimoInfo.btrCwIdx), noLyr2);
#else
- iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi,
+ iTbs = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi,
!(ueDl->mimoInfo.btrCwIdx), noLyr2);
#endif
}
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
- * @param[out] U8 *numRb
+ * @param[out] uint8_t *numRb
* @param[out] Bool *swpFlg
- * @param[out] U32 *effBo
+ * @param[out] uint32_t *effBo
* @return Void
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb
+static S16 rgSCHCmnDlAlloc2CwRetxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numRb,
+uint8_t *numRb,
Bool *swpFlg,
-U32 *effBo
+uint32_t *effBo
)
#else
-PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
+static S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
numRb, swpFlg, effBo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U8 *numRb;
+uint8_t *numRb;
Bool *swpFlg;
-U32 *effBo;
+uint32_t *effBo;
#endif
{
RgSchDlRbAlloc *allocInfo;
- U8 imcs1;
- U8 imcs2;
+ uint8_t imcs1;
+ uint8_t imcs2;
RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
- TRC2(rgSCHCmnDlAlloc2CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqTbCb *tbInfo
- * @param[in] U8 noLyr
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[in] uint8_t noLyr
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return S16
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb
+static S16 rgSCHCmnDlAlloc1CwRetxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U8 noLyr,
-U8 *numRb,
-U32 *effBo
+uint8_t noLyr,
+uint8_t *numRb,
+uint32_t *effBo
)
#else
-PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
+static S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
numRb, effBo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U8 noLyr;
-U8 *numRb;
-U32 *effBo;
+uint8_t noLyr;
+uint8_t *numRb;
+uint32_t *effBo;
#endif
{
RgSchDlRbAlloc *allocInfo;
- U8 imcs;
+ uint8_t imcs;
- TRC2(rgSCHCmnDlAlloc1CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
#endif
{
- TRC2(rgSCHCmnDlRelPdcchFbk);
rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
- RETVOID;
+ return;
}
#endif
{
- TRC2(rgSCHCmnDlProcAck);
if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
{
/* Invoke SPS module if SPS service was scheduled for this HARQ proc */
rgSCHCmnSpsDlProcAck(cell, hqP);
}
- RETVOID;
+ return;
}
#ifdef RGSCH_SPS_STATS
-extern U32 rgSchStatCrntiCeRcvCnt;
+uint32_t rgSchStatCrntiCeRcvCnt;
#endif
/**
* @brief This function is invoked to handle CRNTI CE reception for an UE
#endif
{
- TRC2(rgSCHCmnHdlCrntiCE);
#ifdef RGSCH_SPS_STATS
rgSchStatCrntiCeRcvCnt++;
#endif
rgSCHCmnSpsUlUeReset(cell, ue);
}
- RETVOID;
+ return;
}
#endif
{
- TRC2(rgSCHCmnUlSpsRelInd);
rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
- RETVOID;
+ return;
} /* end of rgSCHCmnUlSpsRelInd */
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U16 spsSduSize
+uint16_t spsSduSize
)
#else
Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U16 spsSduSize;
+uint16_t spsSduSize;
#endif
{
- TRC2(rgSCHCmnUlSpsActInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcActInd(cell, ue,spsSduSize);
}
- RETVOID;
+ return;
} /* end of rgSCHCmnUlSpsActInd */
#endif
{
- TRC2(rgSCHCmnUlCrcInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
}
- RETVOID;
+ return;
} /* end of rgSCHCmnUlCrcFailInd */
#endif
{
- TRC2(rgSCHCmnUlCrcFailInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
}
- RETVOID;
+ return;
} /* end of rgSCHCmnUlCrcFailInd */
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnDlBcchPcchAlloc
+static Void rgSCHCmnDlBcchPcchAlloc
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnDlBcchPcchAlloc(cell)
+static Void rgSCHCmnDlBcchPcchAlloc(cell)
RgSchCellCb *cell;
#endif
{
#ifdef LTE_TDD
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
#else
#ifdef LTEMAC_HDFDD
- U8 nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
#else
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
#endif
#endif
RgInfSfAlloc *nextsfAlloc = &(cell->sfAllocArr[nextSfIdx]);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlBcchPcchAlloc);
/*Reset the bitmask for BCCH/PCCH*/
/* Finalize the Allocations for reqested Against alloced */
rgSCHCmnDlBcchPcchFnlz(cell, allocInfo);
#endif /* DISABLE_MIB_SIB */
- RETVOID;
+ return;
}
/**
**/
#ifdef ANSI
-PRIVATE Void rgSCHBcchPcchDlRbAlloc
+static Void rgSCHBcchPcchDlRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHBcchPcchDlRbAlloc(cell, allocInfo)
+static Void rgSCHBcchPcchDlRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHBcchPcchDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo);
}
- RETVOID;
+ return;
}
/**
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc
+static Void rgSCHCmnNonDlfsBcchPcchRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo)
+static Void rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
/* 143473 */
/* Allocate for PCCH */
{
rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
}
- RETVOID;
+ return;
}
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE Void rgSCHChkNUpdSiCfg
+static Void rgSCHChkNUpdSiCfg
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHChkNUpdSiCfg(cell)
+static Void rgSCHChkNUpdSiCfg(cell)
RgSchCellCb *cell;
#endif
{
CmLteTimingInfo pdSchTmInfo;
- TRC2(rgSCHChkNUpdSiCfg);
pdSchTmInfo = cell->crntTime;
/*if(!((((pdSchTmInfo.hSfn * 1024) + pdSchTmInfo.sfn) % cell->siCfg.modPrd == 0)
&& (0 == pdSchTmInfo.slot)))*/
{
- RETVOID;
+ return;
}
/*Check whether MIB has been updated*/
/*Check whether SIs have been updated*/
if(cell->siCb.siBitMask & RGSCH_SI_SI_UPD)
{
- U8 idx;
+ uint8_t idx;
/*Check if SI cfg have been modified And Check if numSi have
been changed, if yes then we would need to update the
cell->siCb.siBitMask &= ~RGSCH_SI_SICFG_UPD;
}
- RETVOID;
+ return;
}
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE Void rgSCHSelectSi
+static Void rgSCHSelectSi
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHSelectSi(cell)
+static Void rgSCHSelectSi(cell)
RgSchCellCb *cell;
#endif
{
CmLteTimingInfo crntTmInfo;
- U8 siWinSize;
- U16 x;
- U16 windowId;
+ uint8_t siWinSize;
+ uint16_t x;
+ uint16_t windowId;
- TRC2(rgSCHSelectSi);
crntTmInfo = cell->crntTime;
else
{
cell->siCb.inWindow--;
- RETVOID;
+ return;
}
}
else /* New window. Re-init the winSize counter with the window length */
/ siWinSize;
if(windowId >= RGR_MAX_NUM_SI)
- RETVOID;
+ return;
/* Update the siCtx if there is a valid SI and its periodicity
* has occurred */
cell->siCb.siCtx.siId = 0;
}
- RETVOID;
+ return;
}
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE Void rgSCHDlSiSched
+static Void rgSCHDlSiSched
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc
)
#else
-PRIVATE Void rgSCHDlSiSched(cell, allocInfo, subfrmAlloc)
+static Void rgSCHDlSiSched(cell, allocInfo, subfrmAlloc)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
RgInfSfAlloc *subfrmAlloc;
{
CmLteTimingInfo crntTimInfo;
RgSchDlSf *sf;
- U8 nPrb = 0;
- U8 mcs = 0;
+ uint8_t nPrb = 0;
+ uint8_t mcs = 0;
MsgLen msgLen = 0;
- U32 rb=0;
+ uint32_t rb=0;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
/* DwPTS Scheduling Changes Start */
#ifdef LTE_TDD
- U16 lostRe;
- U8 cfi = cellDl->currCfi;
+ uint16_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
/* DwPTS Scheduling Changes End */
- TRC2(rgSCHDlSiSched);
crntTimInfo = cell->crntTime;
&& (RGSCH_MIB_TX_SF_NUM == crntTimInfo.slot))
{
MsgLen mibLen = 0;
- U8 sfnOctet, mibOct2 = 0;
- U8 mibOct1 = 0;
+ uint8_t sfnOctet, mibOct2 = 0;
+ uint8_t mibOct1 = 0;
/*If MIB has not been yet setup by Application, return*/
if(NULLP == cell->siCb.crntSiInfo.mib)
- RETVOID;
+ return;
SFndLenMsg(cell->siCb.crntSiInfo.mib, &mibLen);
sf->bch.tbSize = mibLen;
/*Set the bits of MIB to reflect SFN */
/*First get the Most signficant 8 bits of SFN */
- sfnOctet = (U8)(crntTimInfo.sfn >> 2);
+ sfnOctet = (uint8_t)(crntTimInfo.sfn >> 2);
/*Get the first two octets of MIB, and then update them
using the SFN octet value obtained above.*/
if(ROK != SExamMsg((Data *)(&mibOct1),
cell->siCb.crntSiInfo.mib, 0))
- RETVOID;
+ return;
if(ROK != SExamMsg((Data *)(&mibOct2),
cell->siCb.crntSiInfo.mib, 1))
- RETVOID;
+ return;
/* ccpu00114572- Fix for improper way of MIB Octet setting for SFN */
mibOct1 = (mibOct1 & 0xFC) | (sfnOctet >> 6);
/*Now, replace the two octets in MIB */
if(ROK != SRepMsg((Data)(mibOct1),
cell->siCb.crntSiInfo.mib, 0))
- RETVOID;
+ return;
if(ROK != SRepMsg((Data)(mibOct2),
cell->siCb.crntSiInfo.mib, 1))
- RETVOID;
+ return;
/*Copy the MIB msg buff into interface buffer */
SCpyMsgMsg(cell->siCb.crntSiInfo.mib,
/*If SIB1 has not been yet setup by Application, return*/
if(NULLP == (cell->siCb.crntSiInfo.sib1Info.sib1))
{
- RETVOID;
+ return;
}
allocInfo->bcchAlloc.schdFirst = TRUE;
Bool invalid = FALSE;
if(cell->siCb.siCtx.siId == 0)
- RETVOID;
+ return;
/*Check if the Si-Window for the current Si-Context is completed*/
invalid = rgSCHCmnChkPastWin(crntTimInfo, cell->siCb.siCtx.maxTimeToTx);
rgSCHUtlFreeWarningSiPdu(cell);
cell->siCb.siCtx.warningSiFlag = FALSE;
}
- RETVOID;
+ return;
}
/*Check the timinginfo of the current SI-Context to see if its
cell->siCb.siCtx.timeToTx,
cell->siCb.siCtx.maxTimeToTx)))
{
- RETVOID;
+ return;
}
/*Check if retransmission count has become 0*/
if(0 == cell->siCb.siCtx.retxCntRem)
{
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_START */
[((crntTimInfo.sfn*RGSCH_NUM_SUB_FRAMES) + crntTimInfo.slot) % RGR_ABS_PATTERN_LEN]))
{
/* Skip the SI scheduling to next tti */
- RETVOID;
+ return;
}
}
}
* and Other SI */
if((rgSCHUtlGetMcsAndNPrb(cell, &nPrb, &mcs, &msgLen)) != ROK)
{
- RETVOID;
+ return;
}
cell->siCb.siCtx.i = RGSCH_CALC_SF_DIFF(crntTimInfo,
/*rgSCHCmnClcRbAllocForFxdTb(cell, msgLen, cellDl->ccchCqi, &rb);*/
if(cellDl->bitsPerRb==0)
{
- while ((rgTbSzTbl[0][0][rb]) < (U32) (msgLen*8))
+ while ((rgTbSzTbl[0][0][rb]) < (uint32_t) (msgLen*8))
{
rb++;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDlSiSched(): "
"BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
- RETVOID;
+ return;
}
/* Update the subframe Allocated BW field */
allocInfo->bcchAlloc.nPrb = nPrb;
allocInfo->bcchAlloc.tbInfo[0].bytesReq = msgLen;
allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
- RETVOID;
+ return;
}
#endif /*RGR_SI_SCH*/
*
**/
#ifdef ANSI
-PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept
+static S16 rgSCHCmnUeDlPwrCtColltCqiRept
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCqiRept *ueCqiRpt
)
#else
-PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, ueCqiRpt)
+static S16 rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, ueCqiRpt)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCqiRept *ueCqiRpt;
#endif
{
- U8 *cqiCount = NULLP;
+ uint8_t *cqiCount = NULLP;
S16 retVal;
RgrStaIndInfo *staInfo = NULLP;
- TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
/* Step 1: Store the CQI in collation array */
/* Step 2: Increament the tracking count */
/* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
#ifdef CA_DBG
{
- extern U32 gCqiReptToAppCount;
+ uint32_t gCqiReptToAppCount;
gCqiReptToAppCount++;
}
Bool *reTxAllwd;
#endif
{
- TRC3(rgSCHCmnChkRetxAllowDtx)
*reTxAllwd = TRUE;
*reTxAllwd = FALSE;
}
- RETVOID;
+ return;
}
/**
* (0,0) (8,0) (16,0) (SFN, SF)
*
*
- * @param[in] U16 sfn
- * @param[in] U8 sf
- * @return U16 siSetId
+ * @param[in] uint16_t sfn
+ * @param[in] uint8_t sf
+ * @return uint16_t siSetId
**/
#ifdef ANSI
-U16 rgSCHCmnGetSiSetId
+uint16_t rgSCHCmnGetSiSetId
(
-U16 sfn,
-U8 sf,
-U16 minPeriodicity
+uint16_t sfn,
+uint8_t sf,
+uint16_t minPeriodicity
)
#else
-U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
-U16 sfn;
-U8 sf
-U16 minPeriodicity;
+uint16_t rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
+uint16_t sfn;
+uint8_t sf
+uint16_t minPeriodicity;
#endif
{
/* 80 is the minimum SI periodicity in sf. Also
* Function: rgSCHCmnCalcDwPtsTbSz
*
* @param[in] RgSchCellCb *cell
- * @param[in] U32 bo
- * @param[in/out] U8 *rb
- * @param[in/out] U8 *iTbs
- * @param[in] U8 lyr
- * @param[in] U8 cfi
- * @return U32 tbSz
+ * @param[in] uint32_t bo
+ * @param[in/out] uint8_t *rb
+ * @param[in/out] uint8_t *iTbs
+ * @param[in] uint8_t lyr
+ * @param[in] uint8_t cfi
+ * @return uint32_t tbSz
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnCalcDwPtsTbSz
+static uint32_t rgSCHCmnCalcDwPtsTbSz
(
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 *iTbs,
-U8 lyr,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t *iTbs,
+uint8_t lyr,
+uint8_t cfi
)
#else
-PRIVATE U32 rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
+static uint32_t rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
RgSchCellCb *cell;
-U32 bo;
-U8 *rb;
-U8 *iTbs;
-U8 lyr;
-U8 cfi;
+uint32_t bo;
+uint8_t *rb;
+uint8_t *iTbs;
+uint8_t lyr;
+uint8_t cfi;
#endif
{
- U32 tbSz;
+ uint32_t tbSz;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U32 numRE = *rb * cellDl->noResPerRb[cfi];
- U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
+ uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
+ uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
* Function: rgSCHCmnCalcDwPtsTbSz2Cw
*
* @param[in] RgSchCellCb *cell
- * @param[in] U32 bo
- * @param[in/out] U8 *rb
- * @param[in] U8 maxRb
- * @param[in/out] U8 *iTbs1
- * @param[in/out] U8 *iTbs2
- * @param[in] U8 lyr1
- * @param[in] U8 lyr2
- * @return[in/out] U32 *tb1Sz
- * @return[in/out] U32 *tb2Sz
- * @param[in] U8 cfi
+ * @param[in] uint32_t bo
+ * @param[in/out] uint8_t *rb
+ * @param[in] uint8_t maxRb
+ * @param[in/out] uint8_t *iTbs1
+ * @param[in/out] uint8_t *iTbs2
+ * @param[in] uint8_t lyr1
+ * @param[in] uint8_t lyr2
+ * @return[in/out] uint32_t *tb1Sz
+ * @return[in/out] uint32_t *tb2Sz
+ * @param[in] uint8_t cfi
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw
+static Void rgSCHCmnCalcDwPtsTbSz2Cw
(
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 maxRb,
-U8 *iTbs1,
-U8 *iTbs2,
-U8 lyr1,
-U8 lyr2,
-U32 *tb1Sz,
-U32 *tb2Sz,
-U8 cfi
-)
-#else
-PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2,
+uint32_t bo,
+uint8_t *rb,
+uint8_t maxRb,
+uint8_t *iTbs1,
+uint8_t *iTbs2,
+uint8_t lyr1,
+uint8_t lyr2,
+uint32_t *tb1Sz,
+uint32_t *tb2Sz,
+uint8_t cfi
+)
+#else
+static Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2,
lyr1, lyr2, tb1Sz, tb2Sz, cfi)
RgSchCellCb *cell;
-U32 bo;
-U8 *rb;
-U8 maxRb;
-U8 *iTbs1;
-U8 *iTbs2;
-U8 lyr1;
-U8 lyr2;
-U32 *tb1Sz;
-U32 *tb2Sz;
-U8 cfi;
+uint32_t bo;
+uint8_t *rb;
+uint8_t maxRb;
+uint8_t *iTbs1;
+uint8_t *iTbs2;
+uint8_t lyr1;
+uint8_t lyr2;
+uint32_t *tb1Sz;
+uint32_t *tb2Sz;
+uint8_t cfi;
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U32 numRE = *rb * cellDl->noResPerRb[cfi];
- U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
+ uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
+ uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
*rb = numDwPtsRb;
- RETVOID;
+ return;
}
#endif
RgInfUeDatInd *datInd;
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnUpdUeDataIndLcg);
for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
{
if (datInd->lcgInfo[idx].bytesRcvd != 0)
{
- U8 lcgId = datInd->lcgInfo[idx].lcgId;
- U32 bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
+ uint8_t lcgId = datInd->lcgInfo[idx].lcgId;
+ uint32_t bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
{
*
*/
#ifdef ANSI
-PRIVATE Void rgSCHCmnInitRbAlloc
+static Void rgSCHCmnInitRbAlloc
(
RgSchCellCb *cell
)
#else
-PRIVATE Void rgSCHCmnInitRbAlloc (cell)
+static Void rgSCHCmnInitRbAlloc (cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- U8 idx;
+ uint8_t idx;
- TRC2(rgSCHCmnInitRbAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure.*/
rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
/* Update subframe-wide allocation information with SPS allocation */
rgSCHCmnSpsDlUpdDlSfAllocWithSps(cell, frm, dlSf);
#endif
- RETVOID;
+ return;
}
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 newTxMode
+ * @param[in] uint8_t newTxMode
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHCmnSendTxModeInd
+static Void rgSCHCmnSendTxModeInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 newTxMode
+uint8_t newTxMode
)
#else
-PRIVATE Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
+static Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 newTxMode;
+uint8_t newTxMode;
#endif
{
RgmTransModeInd *txModeChgInd;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnSendTxModeInd);
if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
{
cell->rgmSap->sapCfg.sapPst.pool, (Data**)&txModeChgInd,
sizeof(RgmTransModeInd)) != ROK)
{
- RETVOID;
+ return;
}
RG_SCH_FILL_RGM_TRANSMODE_IND(ue->ueId, cell->cellId, newTxMode, txModeChgInd);
RgUiRgmChangeTransModeInd(&(cell->rgmSap->sapCfg.sapPst),
ue->mimoInfo.txModDownChgFactor = 0;
ueDl->laCb[0].deltaiTbs = 0;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 iTbs
+ * @param[in] uint8_t iTbs
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 reportediTbs,
-U8 previTbs,
-U8 maxiTbs
+uint8_t reportediTbs,
+uint8_t previTbs,
+uint8_t maxiTbs
)
#else
Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 reportediTbs;
-U8 previTbs;
-U8 maxiTbs;
+uint8_t reportediTbs;
+uint8_t previTbs;
+uint8_t maxiTbs;
#endif
{
RgrTxMode txMode; /*!< UE's Transmission Mode */
RgrTxMode modTxMode; /*!< UE's Transmission Mode */
- TRC2(rgSchCheckAndTriggerModeChange);
txMode = ue->mimoInfo.txMode;
}
}
- RETVOID;
+ return;
}
#endif
RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnIsDlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnIsUlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
Void rgSchCmnPreDlSch
(
RgSchCellCb **cell,
- U8 nCell,
+ uint8_t nCell,
RgSchCellCb **cellLst
)
#else
Void rgSchCmnPreDlSch(cell, nCell, cellLst)
RgSchCellCb **cell;
- U8 nCell;
+ uint8_t nCell;
RgSchCellCb **cellLst;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell[0]);
RgSchDlSf *sf;
- U8 idx;
+ uint8_t idx;
- TRC2(rgSchCmnPreDlSch);
if(nCell > CM_LTE_MAX_CELLS)
{
- RETVOID;
+ return;
}
if (cell[0]->isDlDataAllwd && (cell[0]->stopDlSch == FALSE))
* in that cell */
for (idx = 0; idx < nCell; idx++)
{
- U8 j;
+ uint8_t j;
cellSch = RG_SCH_CMN_GET_CELL(cell[idx]);
sf = cellSch->allocInfo.dedAlloc.dedDlSf;
if(sf->remUeCnt < subfrm->remUeCnt)
{
- U8 k;
+ uint8_t k;
for(k = idx; k > j; k--)
{
cellLst[k] = cellLst[k-1];
cellLst[idx] = cell[idx];
}
}
- RETVOID;
+ return;
}
/** @brief DL scheduler for SPS, and all other downlink data
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSchCmnPstDlSch);
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
{
}
#ifdef ANSI
-U8 rgSCHCmnCalcPcqiBitSz
+uint8_t rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
- U8 numTxAnt
+ uint8_t numTxAnt
)
#else
-U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
+uint8_t rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
RgSchUeCb *ueCb;
- U8 numTxAnt;
+ uint8_t numTxAnt;
#endif
{
- U8 confRepMode;
- U8 pcqiSz;
- U8 ri;
+ uint8_t confRepMode;
+ uint8_t pcqiSz;
+ uint8_t ri;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHCmnCalcPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef RG_5GTF
RgSchDynTddCb *rgSchDynTddInfo = &(rgSchCb[cell->instIdx].rgSchDynTdd);
- U16 dlCntrlSfIdx;
+ uint16_t dlCntrlSfIdx;
#endif
- TRC2(rgSCHCmnDlSch);
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
#ifdef RG_5GTF
cellSch->dl.time.slot);
*/
}
- RETVOID;
+ return;
}
}
#endif
/* Do group power control for PUCCH */
rgSCHCmnGrpPwrCntrlPucch(cell, dlSf);
- RETVOID;
+ return;
}
/**********************************************************************