@brief This module does processing related to handling of lower interface APIs
invoked by PHY towards scheduler.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=228;
-static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
#include "common_def.h"
#include "rg_sch_inf.h" /* defines and macros for MAC */
#include "rg_sch.h" /* defines and macros for MAC */
#include "rg_sch_cmn.h" /* typedefs for MAC */
-#include "rl_interface.h"
-#include "rl_common.h"
/* header/extern include files (.x) */
#ifdef EMTC_ENABLE
#include "rg_sch_emtc_ext.x"
#endif
-U8 rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,U8 numTxAnt);
+uint8_t rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,uint8_t numTxAnt);
S16 rgSCHDhm5gtfHqFdbkInd(RgSchUeCb *ue,RgSchCellCb *cell,CmLteTimingInfo timingInfo,TfuHqFdbk fdbk,RgSchErrInfo *err);
/* local defines */
#ifdef EMTC_ENABLE
-EXTERN Bool rgSCHEmtcChkEmtcUe ARGS(
+Bool rgSCHEmtcChkEmtcUe ARGS(
(
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
));
-EXTERN Void rgSchTomTtiEmtcSched ARGS(
+Void rgSchTomTtiEmtcSched ARGS(
(
- RgSchCellCb *cell
+RgSchCellCb *cell
));
-EXTERN S16 rgSCHEmtcRamVldtProcRaReq
+S16 rgSCHEmtcRamVldtProcRaReq
(
-U8 raRntiCnt,
-U8 raReqCnt,
+uint8_t raRntiCnt,
+uint8_t raReqCnt,
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd,
RgSchUeCb *ue,
Bool *isEmtcUe,
RgSchErrInfo *err
);
-EXTERN Void rgSCHEmtcUpdCqiInfo
+Void rgSCHEmtcUpdCqiInfo
(
RgSchUeCb *ue,
RgSchUePCqiCb *cqiCb,
-U16 *cqiIdx
+uint16_t *cqiIdx
);
-EXTERN Void rgSCHEmtcUpdSRInfo
+Void rgSCHEmtcUpdSRInfo
(
RgSchUeCb *ue,
-U16 *srIdx
+uint16_t *srIdx
);
-EXTERN Void rgSCHCmnEmtcHdlCrcFailInd
+Void rgSCHCmnEmtcHdlCrcFailInd
(
RgSchCellCb *cell,
RgSchRaCb *raCb
);
-EXTERN S16 rgSCHEmtcTomUtlProcAtCrc
+S16 rgSCHEmtcTomUtlProcAtCrc
(
RgSchCellCb *cell,
CmLteTimingInfo crntHiDci0Frm,
TfuCntrlReqInfo *cntrlInfo,
RgSchErrInfo *err
);
-EXTERN Void rgSCHEmtcInitUeRecpReqLst
+Void rgSCHEmtcInitUeRecpReqLst
(
TfuRecpReqInfo *recpReqInfo
);
-EXTERN Void rgSCHEmtcFillPucchRecpInfo
+Void rgSCHEmtcFillPucchRecpInfo
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqCb,
-U16 *hqRes
+uint16_t *hqRes
);
-EXTERN Bool rgSCHEmtcAddRecpInfoToLst
+Bool rgSCHEmtcAddRecpInfoToLst
(
RgSchDlHqProcCb *hqCb,
TfuRecpReqInfo *recpReqInfo,
TfuUeRecpReqInfo *pucchRecpInfo,
Bool isEmtcUe
);
-EXTERN Void rgSCHEmtcWillUeRptCqi
+Void rgSCHEmtcWillUeRptCqi
(
RgSchUeCb *ue,
Bool *willUeRprtCqi
);
-EXTERN Void rgSchEmtcTomTtiCnsldtSfAlloc
+Void rgSchEmtcTomTtiCnsldtSfAlloc
(
RgSchCellCb *cell
);
-EXTERN S16 rgSchEmtcTomTtiL1DlAndUlCfg
+S16 rgSchEmtcTomTtiL1DlAndUlCfg
(
RgSchCellCb *cell,
RgTfuCntrlReqInfo *cntrlInfo
);
-EXTERN S16 rgSCHTomEmtcUtlFillDatRecpReq
+S16 rgSCHTomEmtcUtlFillDatRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
);
-EXTERN S16 rgSCHEmtcTomUtlFillHqFdbkRecpReq
+S16 rgSCHEmtcTomUtlFillHqFdbkRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
);
-EXTERN S16 rgSCHEmtcDhmRlsDlsfHqProc
+S16 rgSCHEmtcDhmRlsDlsfHqProc
(
RgSchCellCb *cell,
CmLteTimingInfo timingInfo
);
-EXTERN Void rgSCHEmtcCmnUlSch
+Void rgSCHEmtcCmnUlSch
(
- RgSchCellCb *cell
+RgSchCellCb *cell
);
#ifdef RG_ULSCHED_AT_CRC
-EXTERN S16 rgSCHEmtcTomUtlProcDlSfAtCrc
+S16 rgSCHEmtcTomUtlProcDlSfAtCrc
(
RgSchEmtcDlSf *ulSf,
CmLteTimingInfo crntUlFrm,
RgSchErrInfo *err
);
-EXTERN RgSchEmtcDlSf* rgSCHEmtcUtlSubFrmGet
+RgSchEmtcDlSf* rgSCHEmtcUtlSubFrmGet
(
RgSchCellCb *cell,
CmLteTimingInfo frm
);
#endif
-EXTERN U32 gDlMpdcchBlank;
-EXTERN U32 gUlMpdcchBlank;
-EXTERN S16 rgSCHUtlIotResPrcTti
+uint32_t gDlMpdcchBlank;
+uint32_t gUlMpdcchBlank;
+S16 rgSCHUtlIotResPrcTti
(
RgSchCellCb *cell
);
#endif
-EXTERN RgSchUeCb* rgSCHCmnGetHoUe
+RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
);
-EXTERN RgSchUeCb* rgSCHCmnGetPoUe
+RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo
);
S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
(
- RgSchCellCb *cell,
- U8 cqiReq,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- ));
+RgSchCellCb *cell,
+uint8_t cqiReq,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+));
S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+));
S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+));
S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres
+));
-void schFillCrntTime(
- SlotIndInfo slotInd,
- Inst schInst);
+void schFillCrntTime( SlotTimingInfo slotInd,Inst schInst);
#ifdef CA_DBG
-EXTERN U32 delayedApiCnt;
-U32 gPCellTb1AckCount=0,gPCellTb2AckCount=0,gPCellTb1NackCount=0,gPCellTb2NackCount=0;
-U32 gSCellSchedCount=0,gPrimarySchedCount=0;
-U32 gSCellTb1AckCount=0,gSCellTb2AckCount=0,gSCellTb1NackCount=0,gSCellTb2NackCount=0;
-U32 gPCellTb1DtxCount = 0, gPCellTb2DtxCount = 0, gSCellTb1DtxCount = 0, gSCellTb2DtxCount = 0;
-U32 gHqFdbkCount = 0;
+uint32_t delayedApiCnt;
+uint32_t gPCellTb1AckCount=0,gPCellTb2AckCount=0,gPCellTb1NackCount=0,gPCellTb2NackCount=0;
+uint32_t gSCellSchedCount=0,gPrimarySchedCount=0;
+uint32_t gSCellTb1AckCount=0,gSCellTb2AckCount=0,gSCellTb1NackCount=0,gSCellTb2NackCount=0;
+uint32_t gPCellTb1DtxCount = 0, gPCellTb2DtxCount = 0, gSCellTb1DtxCount = 0, gSCellTb2DtxCount = 0;
+uint32_t gHqFdbkCount = 0;
-U32 gCqiRecpCount = 0;
-U32 gCqiRecpPuschCount = 0;
-U32 gCqiRcvdCount = 0;
+uint32_t gCqiRecpCount = 0;
+uint32_t gCqiRecpPuschCount = 0;
+uint32_t gCqiRcvdCount = 0;
Bool gF1bCsPres = FALSE;
-U32 gRiReqCount = 0;
-U32 gCqiReqCount = 0;
-U32 gF1bCsCount = 0;
-U32 gACqiRcvdCount = 0;
-U32 gCqiReptToAppCount = 0;
-U32 gRawACqiCount= 0;
-U32 gCqiDropCount,gPucchDropCount;
-U32 gCqiPucchLowSnrDropCount,gCqiPucchConfMaskDropCount,gCqiPuschConfMaskDropCount;
-U32 gDci0Count = 0;
-U32 gUlCrcFailCount = 0;
-U32 gUlCrcPassCount = 0;
-U32 gPuschCqiDropCount = 0;
-U32 gCaDbgCaFrmt = 0;
-U32 gCaDbgNonCaFrmt = 0;
-U32 gPcellZeroBoOcc=0,gScellZeroBoOcc=0, dbgDelayedDatReqInMac=0,gDropDatReqCnt=0, gIccPktRcvrMemDropCnt=0;
+uint32_t gRiReqCount = 0;
+uint32_t gCqiReqCount = 0;
+uint32_t gF1bCsCount = 0;
+uint32_t gACqiRcvdCount = 0;
+uint32_t gCqiReptToAppCount = 0;
+uint32_t gRawACqiCount= 0;
+uint32_t gCqiDropCount,gPucchDropCount;
+uint32_t gCqiPucchLowSnrDropCount,gCqiPucchConfMaskDropCount,gCqiPuschConfMaskDropCount;
+uint32_t gDci0Count = 0;
+uint32_t gUlCrcFailCount = 0;
+uint32_t gUlCrcPassCount = 0;
+uint32_t gPuschCqiDropCount = 0;
+uint32_t gCaDbgCaFrmt = 0;
+uint32_t gCaDbgNonCaFrmt = 0;
+uint32_t gPcellZeroBoOcc=0,gScellZeroBoOcc=0, dbgDelayedDatReqInMac=0,gDropDatReqCnt=0, gIccPktRcvrMemDropCnt=0;
#endif
#ifdef EMTC_ENABLE
-U32 gUlCrcFailCounter = 0;
-U32 gUlCrcPassCounter = 0;
+uint32_t gUlCrcFailCounter = 0;
+uint32_t gUlCrcPassCounter = 0;
#endif
#ifdef RG_5GTF
-EXTERN U32 gUl5gtfPdcchSend;
+uint32_t gUl5gtfPdcchSend;
#endif
#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr ARGS
+static S16 rgSCHTomUtlFillCqiSrsWithSr ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuRecpReqInfo *recpReqInfo,
TfuUeRecpReqInfo *pucchRecpInfo,
-U16 validIdx
+uint16_t validIdx
));
-PRIVATE Bool rgSCHTomUtlFillDatHarqRecpReq ARGS
+static Bool rgSCHTomUtlFillDatHarqRecpReq ARGS
((
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
TfuUeRecpReqInfo *datRecpInfo,
TfuRecpReqInfo *recpReqInfo
));
-PRIVATE S16 rgSCHTomUtlFillSrRecpReq ARGS((
+static S16 rgSCHTomUtlFillSrRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillRiRecpReq ARGS((
+static S16 rgSCHTomUtlFillRiRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq ARGS((
+static S16 rgSCHTomUtlFillPcqiRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillSrsRecpReq ARGS((
+static S16 rgSCHTomUtlFillSrsRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlGenIndices ARGS((
-U32 label,
-U8 posM,
-U8 valN,
-U8 valK,
+static S16 rgSCHTomUtlGenIndices ARGS((
+uint32_t label,
+uint8_t posM,
+uint8_t valN,
+uint8_t valK,
TfuSubbandInfo* sbInfo));
#endif
-PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq ARGS(
+static S16 rgSCHTomUtlFillCqiRiRecpReq ARGS(
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- ));
-PRIVATE Void rgSchTomFillCellTtiInfo ARGS
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+));
+static Void rgSchTomFillCellTtiInfo ARGS
((
TfuTtiIndInfo *ttiInd,
Inst schInst,
-U8 *nCell,
+uint8_t *nCell,
RgSchCellCb *cells[]
));
#endif
/* local typedefs */
-U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
-U32 rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
+uint32_t rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
+uint32_t rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
/* local externs */
/* rg006.201: [ccpu000111706, ccpu00112394]: Separated UL and DL TTI
* processing */
#ifdef LTE_L2_MEAS
- U64 glblTtiCnt = 0;
+ uint64_t glblTtiCnt = 0;
#endif
-U32 ri1Cnt ;
-U32 ri2Cnt ;
-U32 gDlNumUePerTti[20] = {0};
-U32 gUlNumUePerTti[20] = {0};
-PRIVATE S16 rgSCHTomUtlProcDlSf ARGS((
+uint32_t ri1Cnt ;
+uint32_t ri2Cnt ;
+uint32_t gDlNumUePerTti[20] = {0};
+uint32_t gUlNumUePerTti[20] = {0};
+static S16 rgSCHTomUtlProcDlSf ARGS((
RgSchDlSf *dlSf,
RgSchDlSf *ulSf,
RgSchCellCb *cell,
RgTfuCntrlReqInfo *cntrlInfo,
RgSchErrInfo *err));
#ifdef RG_ULSCHED_AT_CRC
-PRIVATE S16 rgSCHTomUtlProcDlSfAtCrc ARGS((
+static S16 rgSCHTomUtlProcDlSfAtCrc ARGS((
RgSchDlSf *ulSf,
CmLteTimingInfo crntUlFrm,
RgSchCellCb *cell,
#endif /* RG_ULSCHED_AT_CRC */
#ifdef LTE_TDD
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlPrcUlTddSpclSf ARGS((
+static S16 rgSCHTomUtlPrcUlTddSpclSf ARGS((
RgSchCellCb *cell,
RgSchErrInfo *err));
#endif /* TFU_UPGRADE */
#endif
-PRIVATE S16 rgSCHTomUtlFillPhich ARGS((
+static S16 rgSCHTomUtlFillPhich ARGS((
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *dlSf,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillDlPdcch ARGS((
+static S16 rgSCHTomUtlFillDlPdcch ARGS((
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *dlSf,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillUlPdcch ARGS((
+static S16 rgSCHTomUtlFillUlPdcch ARGS((
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *ulSf,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlProcTA ARGS((
+static S16 rgSCHTomUtlProcTA ARGS((
RgSchCellCb *cell));
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
+static S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err));
#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
+static S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
RgSchErrInfo *err));
S16 rgSCHTomFillOnlySrsRecpReq ARGS
((
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo
- ));
-PRIVATE S16 rgSCHTomUtlFillCqiSrSrsWithHq ARGS
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo
+));
+static S16 rgSCHTomUtlFillCqiSrSrsWithHq ARGS
((
- RgSchCellCb *cell,
- TfuRecpReqInfo *recpReqInfo,
- RgSchUeCb *ue,
- TfuUeRecpReqInfo *pucchRecpInfo,
- U16 validIdx,
- Bool isDatPresOnSecCell
- ));
+RgSchCellCb *cell,
+TfuRecpReqInfo *recpReqInfo,
+RgSchUeCb *ue,
+TfuUeRecpReqInfo *pucchRecpInfo,
+uint16_t validIdx,
+Bool isDatPresOnSecCell
+));
S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
((
- RgSchUeCb *ueCb
+RgSchUeCb *ueCb
));
-U8 rgSCHTomUtlFetchPcqiBitSz ARGS
+uint8_t rgSCHTomUtlFetchPcqiBitSz ARGS
((
RgSchUeCb *ueCb,
-U8 numTxAnt,
-U8 *ri
+uint8_t numTxAnt,
+uint8_t *ri
));
-U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
+uint8_t rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
((
RgSchUeCb *ueCb,
TfuCqiPucchMode21 *mode21Info,
-U8 numTxAnt,
-U8 *ri
+uint8_t numTxAnt,
+uint8_t *ri
));
S16 rgSCHTomUtlMoveNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U16 validIdx
+uint16_t validIdx
));
-PRIVATE S16 rgSCHTomUtlMovePcqiNxtOccasion ARGS
+static S16 rgSCHTomUtlMovePcqiNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchUePCqiCb *cqiCb
));
-PRIVATE S16 rgSCHTomUtlMovePriNxtOccasion ARGS
+static S16 rgSCHTomUtlMovePriNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchUePCqiCb *riCb
));
-PRIVATE S16 rgSCHTomUtlMoveSrNxtOccasion ARGS
+static S16 rgSCHTomUtlMoveSrNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE S16 rgSCHTomUtlMoveSrsNxtOccasion ARGS
+static S16 rgSCHTomUtlMoveSrsNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PRIVATE S16 rgSCHTomUtlWillUeRprtCqiRi ARGS((
+static S16 rgSCHTomUtlWillUeRprtCqiRi ARGS((
RgSchUeCb *ue,
Bool *willueRprtCqiRii));
#endif
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq ARGS((
+static S16 rgSCHTomUtlFillDatRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err));
#else
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq ARGS((
+static S16 rgSCHTomUtlFillDatRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
RgSchErrInfo *err));
#ifdef LTE_TDD
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
- U16 validIdx
+ uint16_t validIdx
));
#else
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf
));
#endif
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
- U16 validIdx
+ uint16_t validIdx
));
#else
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf
));
#endif
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForOneUe ARGS((
+static S16 rgSCHTomUtlFillSfHqFdbkForOneUe ARGS((
RgSchDlHqProcCb *hqCb,
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
CmLteRnti rnti,
RgrTddAckNackMode ackNackMode,
RgSchUePucchRecpInfo **pucchInfoRef,
RgSchPdcch *pdcch,
- TknU16 n1PucchTkn,
+ TknUInt16 n1PucchTkn,
Bool *allocRef,
- U8 hqSz
+ uint8_t hqSz
));
#endif
#ifdef LTEMAC_SPS
-EXTERN Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
+Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
#ifndef LTE_TDD
#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomCnsdrRelPdcch ARGS
+static S16 rgSCHTomCnsdrRelPdcch ARGS
((
- RgSchCellCb *cell,
- RgSchDlSf *dlSf,
- TfuRecpReqInfo *recpReqInfo,
- U16 validIdx,
- RgSchErrInfo *err
- ));
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+TfuRecpReqInfo *recpReqInfo,
+uint16_t validIdx,
+RgSchErrInfo *err
+));
#else
- PRIVATE S16 rgSCHTomCnsdrRelPdcch ARGS
+static S16 rgSCHTomCnsdrRelPdcch ARGS
((
- RgSchCellCb *cell,
- RgSchDlSf *dlSf,
- TfuRecpReqInfo *recpReqInfo,
+ RgSchCellCb *cell,
+ RgSchDlSf *dlSf,
+ TfuRecpReqInfo *recpReqInfo,
RgSchErrInfo *err
));
#endif
#endif
#endif
-PRIVATE Void rgSchTomTtiMiscFunctions ARGS
+static Void rgSchTomTtiMiscFunctions ARGS
((
RgSchCellCb *cell
));
-PRIVATE Void rgSchTomTtiUlAndDlCmnChSch ARGS
+static Void rgSchTomTtiUlAndDlCmnChSch ARGS
((
RgSchCellCb *cell
));
-PRIVATE Void rgSchTomTtiDlSch ARGS
+static Void rgSchTomTtiDlSch ARGS
((
RgSchCellCb *cell
));
-PRIVATE Void rgSchTomTtiCnsldtSfAlloc ARGS
+static Void rgSchTomTtiCnsldtSfAlloc ARGS
((
RgSchCellCb *cell
));
-PRIVATE Void rgSchTomTtiL1DlAndUlCfg ARGS
+static Void rgSchTomTtiL1DlAndUlCfg ARGS
((
RgSchCellCb *cell,
RgTfuCntrlReqInfo *cntrlInfo
));
#ifdef RGR_RRM_TICK
-PRIVATE Void rgSCHTomUtlSendSfnTick ARGS
+static Void rgSCHTomUtlSendSfnTick ARGS
((
RgSchCellCb *cell
));
#endif
#ifdef LTE_TDD
-PRIVATE Void rgSchTomUtlTddRlsSfAndHarq ARGS
+static Void rgSchTomUtlTddRlsSfAndHarq ARGS
((
RgSchCellCb *cell
));
-PRIVATE Void rgSCHTomUtlProcTddUlSf ARGS
+static Void rgSCHTomUtlProcTddUlSf ARGS
((
RgSchCellCb *cell
));
#ifdef LTE_ADV
-PRIVATE Void rgSCHTomUtlGethqRes ARGS
+static Void rgSCHTomUtlGethqRes ARGS
((
-U8 noFdbks,
+uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb,
-U16 *hqRes
+uint16_t *hqRes
));
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1 ARGS
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1 ARGS
((
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- RgSchCellCb *cellCb
+RgSchDlHqProcCb *hqCb,
+TfuUePucchRecpReq *hqRecpReq,
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb
));
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234 ARGS
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234 ARGS
((
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- RgSchCellCb *cellCb,
- U8 elemIdx
+RgSchDlHqProcCb *hqCb,
+TfuUePucchRecpReq *hqRecpReq,
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb,
+uint8_t elemIdx
));
#endif/*LTE_ADV*/
#endif/*LTE_TDD*/
-U32 rgDlCqiRptCnt[16], rgTotDlCqiRpt;
+uint32_t rgDlCqiRptCnt[16], rgTotDlCqiRpt;
#ifdef RG_5GTF
-U32 rgSch5gtfCqi2Mcs[15] =
+uint32_t rgSch5gtfCqi2Mcs[15] =
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
#endif
/* forward references */
/*HARQ Feedback interpretation in accordance with Femto Forum.
Note: There is no value as '0' in Femto Forum Spec but in order to retain
the existing usage in MAC (and its Acceptance), its being considered*/
-//CONSTANT PRIVATE U8 rgSchTomHqFbkMap[8] = {0,1,0,0,4,4,4,4};
+//const static uint8_t rgSchTomHqFbkMap[8] = {0,1,0,0,4,4,4,4};
/*added #defines instead of magic numbers*/
-/*CONSTANT PRIVATE U32 rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
+/*const static uint32_t rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28},
{0,1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276,300,325,351,378},
{0,0,1,4,10,20,35,56,84,120,165,220,286,364,455,560,680,816,969,1140,1330,1540,1771,2024,2300,2600,2925,3276},
/*Tables Derived from 3GPP TS 36.211 Section 5.5.3.3 */
/* Table 5.5.3.3-1 */
#ifndef LTE_TDD
-CONSTANT RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
+const RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
{TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE},
{TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE},
};
#else
/* Table 5.5.3.3-2 */
-CONSTANT RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
+const RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
{FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE},
{FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE},
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHGetDedPrmUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo,
RgSchUeCb **ue
)
-#else
-S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
-RgSchCellCb *cell;
-U16 rapId;
-CmLteTimingInfo timingInfo;
-RgSchUeCb **ue;
-#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- printf("rapId[%d] cellSch->rachCfg.dedPrmStart[%d] cellSch->rachCfg.numDedPrm[%d]\n",rapId,cellSch->rachCfg.dedPrmStart,cellSch->rachCfg.numDedPrm);
+ DU_LOG("\nINFO --> SCH : rapId[%d] cellSch->rachCfg.dedPrmStart[%d] cellSch->rachCfg.numDedPrm[%d]\n",\
+ rapId,cellSch->rachCfg.dedPrmStart,cellSch->rachCfg.numDedPrm);
/* Finding UE in handOver List */
if ((rapId < cellSch->rachCfg.dedPrmStart) ||
(rapId > cellSch->rachCfg.dedPrmStart +
{
/* This ded Preamble corresponds to handover */
*ue = rgSCHCmnGetHoUe(cell, rapId);
- printf(" his ded Preamble corresponds to hando\n");
+ DU_LOG("\nDEBUG --> SCH : ded Preamble corresponds to handover\n");
}
else/* Finding UE from PDCCH Order Mappings */
{
/* Get the UE which has transmitted this RaReq */
*ue = rgSCHCmnGetPoUe(cell, rapId, timingInfo);
- printf(" ==== inding UE from PDCCH Order Mapping\n");
+ DU_LOG("\nDEBUG --> SCH : UE from PDCCH Order Mapping\n");
}
return ROK;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomRaReqInd
(
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd
)
-#else
-S16 rgSCHTomRaReqInd(cell, raReqInd)
-RgSchCellCb *cell;
-TfuRaReqIndInfo *raReqInd;
-#endif
{
- S16 ret;
- U8 raRntiCnt;
- U8 raReqCnt;
- RgSchErrInfo err;
- Bool isEmtcUe = FALSE;
- U16 rapId;
- RgSchUeCb *ue = NULLP;
+ S16 ret;
+ uint8_t raRntiCnt;
+ uint8_t raReqCnt;
+ RgSchErrInfo err;
+ Bool isEmtcUe = FALSE;
+ uint16_t rapId;
+ RgSchUeCb *ue = NULLP;
if(cell->cellId != raReqInd->cellId)
{
err.errType = RGSCHERR_TOM_RAREQIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHTomRaReqInd(): No cell found with raReq cellId = (%d) errorType (%d)"
+ DU_LOG("\nERROR --> SCH : rgSCHTomRaReqInd(): No cell found with raReq cellId = (%d) errorType (%d)"
" errorCause(%d)",raReqInd->cellId, err.errType, err.errCause);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if(raReqInd->rachInfoArr[raRntiCnt].raRnti > RGSCH_MAX_RA_RNTI)
{
- RGSCHLOGERROR(cell->instIdx, ERRCLS_INT_PAR, ERG013,
- (ErrVal)raReqInd->rachInfoArr[raRntiCnt].raRnti,
- ("rgSCHTomRaReqInd(): raRnti is out of range\n"));
+ DU_LOG("\nERROR --> SCH : rgSCHTomRaReqInd(): raRnti is out of range\n");
continue;
}
#endif
if(ret == RFAILED)
{
err.errType = RGSCHERR_TOM_RAREQIND;
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
- "RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed errType(%d) "
+ DU_LOG("\nERROR --> SCH : RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed errType(%d) "
"errCause(%d)", raReqInd->rachInfoArr[raRntiCnt].raRnti,
err.errType, err.errCause);
continue;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUlCqiInd
(
RgSchCellCb *cell,
TfuUlCqiIndInfo *ulCqiInd
)
-#else
-S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
-RgSchCellCb *cell;
-TfuUlCqiIndInfo *ulCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
node = ulCqiInd->ulCqiRpt.first;
if(cell->cellId != ulCqiInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHTomUlCqiInd() Unable to get the ulCqiInd cell with id(%d)",
+ DU_LOG("\nERROR --> SCH : rgSCHTomUlCqiInd() Unable to get the ulCqiInd cell with id(%d)",
ulCqiInd->cellId);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if(ulCqiInfo->numSubband == 0)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Num Subband is"
+ DU_LOG("\nERROR --> SCH : Num Subband is"
"out of range RNTI:%d",ulCqiInfo->rnti);
continue;
}
if((ue = rgSCHDbmGetSpsUeCb(cell, ulCqiInfo->rnti)) == NULLP)
#endif
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get "
- "the ue for RNTI:%d", ulCqiInfo->rnti);
+ DU_LOG("\nERROR --> SCH : Unable to get the ue for RNTI:%d", ulCqiInfo->rnti);
continue;
}
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomPucchDeltaPwrInd
(
RgSchCellCb *cell,
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
)
-#else
-S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
-RgSchCellCb *cell;
-TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != pucchDeltaPwr->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHTomPucchDeltaPwrInd() Unable to get the pucchDeltaPwr cell with id(%d)",
+ DU_LOG("\nERROR --> SCH : rgSCHTomPucchDeltaPwrInd() Unable to get the pucchDeltaPwr cell with id(%d)",
pucchDeltaPwr->cellId);
return RFAILED;
}
if((ue = rgSCHDbmGetSpsUeCb(cell, ueElem->rnti)) == NULLP)
#endif
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d "
+ DU_LOG("\nERROR --> SCH : RNTI:%d "
"rgSCHTomPucchDeltaPwrInd() Unable to get the ue ",
ueElem->rnti);
continue;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomHarqAckInd
(
RgSchCellCb *cell,
TfuHqIndInfo *harqAckInd
)
-#else
-S16 rgSCHTomHarqAckInd(cell, harqAckInd)
-RgSchCellCb *cell;
-TfuHqIndInfo *harqAckInd;
-#endif
{
RgSchErrInfo err;
RgSchUeCb *ue;
CmLList *node;
TfuHqInfo *hqInfo;
Pst pst;
- // U8 tbCnt;
+ // uint8_t tbCnt;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
- U32 cellIdx;
+ uint32_t cellIdx;
RgSchCellCb *iterCellP;
if(cell->cellId != harqAckInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() Unable to get"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() Unable to get"
" the cell for cellId (%d)", harqAckInd->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
if ((rgSCHDhm5gtfHqFdbkInd (ue, cell, harqAckInd->timingInfo, fdbk, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
if ((rgSCHDhmRlsDlsfHqProc (cell, harqAckInd->timingInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Release Downlink "
+ DU_LOG("\nERROR --> SCH : Unable to Release Downlink "
"subframe for cellId (%d) ", cell->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
}
cell, harqAckInd->timingInfo, hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d)",
err.errType, err.errCause);
continue;
cell, harqAckInd->timingInfo, hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
cell, harqAckInd->timingInfo, hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d).",
err.errType, err.errCause);
continue;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB or RA CB ", hqInfo->rnti);
err.errType = RGSCHERR_TOM_HARQACKIND;
continue;
/* Check with TDD call DHM*/
if ((rgSCHDhmRlsDlsfHqProc (cell, harqAckInd->timingInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Release Downlink "
+ DU_LOG("\nERROR --> SCH : Unable to Release Downlink "
"subframe for cellId (%d) ", harqAckInd->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomSrInd
(
RgSchCellCb *cell,
TfuSrIndInfo *srInd
)
-#else
-S16 rgSCHTomSrInd(cell, srInd)
-RgSchCellCb *cell;
-TfuSrIndInfo *srInd;
-#endif
{
S16 ret = RFAILED;
RgSchErrInfo err;
if(cell->cellId != srInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for srcInd cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for srcInd cellId"
":%d ", srInd->cellId);
err.errType = RGSCHERR_TOM_SRIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
ue = rgSCHDbmGetUeCb (cell, srInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the UE CB",
srInfo->rnti);
continue;
}
if (ret != ROK)
{
err.errType = RGSCHERR_TOM_SRIND;
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Scheduler processing failed "
+ DU_LOG("\nERROR --> SCH : Scheduler processing failed "
"errType(%d) errCause(%d) RNTI:%d", err.errType, err.errCause,srInfo->rnti);
continue;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomDoaInd
(
RgSchCellCb *cell,
TfuDoaIndInfo *doaInd
)
-#else
-S16 rgSCHTomDoaInd(cell, doaInd )
-RgSchCellCb *cell;
-TfuDoaIndInfo *doaInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != doaInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for doaInd cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for doaInd cellId"
":%d", doaInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, doaInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the UE CB",
doaInfo->rnti);
continue;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomDlCqiInd
(
RgSchCellCb *cell,
TfuDlCqiIndInfo *dlCqiInd
)
-#else
-S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
-RgSchCellCb *cell;
-TfuDlCqiIndInfo *dlCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != dlCqiInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", dlCqiInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, dlCqiInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%dUnable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%dUnable to get the UE CB",
dlCqiInfo->rnti);
continue;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMovePcqiNxtOccasion
+static S16 rgSCHTomUtlMovePcqiNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- RgSchUePCqiCb *cqiCb
- )
-#else
-PRIVATE S16 rgSCHTomUtlMovePcqiNxtOccasion(cell, ue, cqiCb)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- RgSchUePCqiCb *cqiCb;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchUePCqiCb *cqiCb
+)
{
- U16 cqiIdx = 0;
+ uint16_t cqiIdx = 0;
CmLteTimingInfo timingInfo;
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,
&cqiCb->cqiLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to remove node",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to remove node",
ue->ueId);
}
cqiCb->nCqiTrIdx = cqiIdx;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMovePriNxtOccasion
+static S16 rgSCHTomUtlMovePriNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- RgSchUePCqiCb *riCb
- )
-#else
-PRIVATE S16 rgSCHTomUtlMovePriNxtOccasion(cell, ue, riCb)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- RgSchUePCqiCb *riCb;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchUePCqiCb *riCb
+)
{
- U16 riIdx;
- U16 riDist=0;
- U16 effPeriodicity;
- U16 riTrInsTime;
- U16 crntTime;
- U16 tempIdx;
+ uint16_t riIdx;
+ uint16_t riDist=0;
+ uint16_t effPeriodicity;
+ uint16_t riTrInsTime;
+ uint16_t crntTime;
+ uint16_t tempIdx;
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
riIdx = tempIdx % RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
if (effPeriodicity >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
- riDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16)(crntTime + TFU_RECPREQ_DLDELTA + effPeriodicity));
+ riDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t)(crntTime + TFU_RECPREQ_DLDELTA + effPeriodicity));
}
else
{
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[riCb->nRiTrIdx].riLst,
&riCb->riLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"[%d]UEID:Unable to remove node",
+ DU_LOG("\nERROR --> SCH : [%d]UEID:Unable to remove node",
ue->ueId);
}
RG_SCH_RECORD(&riCb->histElem,RGSCH_ACTION_DEL, &cell->pCqiSrsSrLst[riCb->nRiTrIdx].riLst);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMoveSrNxtOccasion
+static S16 rgSCHTomUtlMoveSrNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue
- )
-#else
-PRIVATE S16 rgSCHTomUtlMoveSrNxtOccasion(cell, ue)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue
+)
{
- U16 srIdx = 0;
+ uint16_t srIdx = 0;
/* Compute Next Transmission Instance */
srIdx = ue->srCb.peri + ue->srCb.nSrTrIdx;
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[ue->srCb.nSrTrIdx].srLst,
&ue->srCb.srLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to remove node",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to remove node",
ue->ueId);
}
ue->srCb.nSrTrIdx = srIdx;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMoveSrsNxtOccasion
+static S16 rgSCHTomUtlMoveSrsNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue
- )
-#else
-PRIVATE S16 rgSCHTomUtlMoveSrsNxtOccasion(cell, ue)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue
+)
{
- U16 srsIdx;
- U16 srsDist;
- U16 tempIdx;
- U16 crntTime;
+ uint16_t srsIdx;
+ uint16_t srsDist;
+ uint16_t tempIdx;
+ uint16_t crntTime;
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
srsIdx = tempIdx %RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
if (ue->srsCb.peri > RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
- srsDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16)(crntTime + TFU_RECPREQ_DLDELTA + ue->srsCb.peri));
+ srsDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t)(crntTime + TFU_RECPREQ_DLDELTA + ue->srsCb.peri));
}
else
{
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[ue->srsCb.nSrsTrIdx].srsLst,
&ue->srsCb.srsLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to remove node",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to remove node",
ue->ueId);
}
cmLListAdd2Tail(&cell->pCqiSrsSrLst[srsIdx].srsLst,
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomRawCqiInd
(
- RgSchCellCb *cell,
- TfuRawCqiIndInfo *rawCqiInd
+RgSchCellCb *cell,
+TfuRawCqiIndInfo *rawCqiInd
)
-#else
-S16 rgSCHTomRawCqiInd(cell, rawCqiInd)
- RgSchCellCb *cell;
- TfuRawCqiIndInfo *rawCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
TfuRawCqiRpt* rawCqiInfo;
RgSchErrInfo err;
- U32 cellIdx;
+ uint32_t cellIdx;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
RgSchCellCb *iterCellP;
#if DL_LA
RgSchCmnDlUe *ueDl;
#endif
- U8 cqi;
- U8 ri;
- U8 hqAck;
- Pst pst;
- RgSchRaCb *raCb;
- TfuHqInfo hqInfo;
+ uint8_t cqi;
+ uint8_t ri;
+ uint8_t hqAck;
+ Pst pst;
+ RgSchRaCb *raCb;
+ TfuHqInfo hqInfo;
if(cell->cellId != rawCqiInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", rawCqiInd->cellId);
return RFAILED;
}
/*
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d Unable to get the UECB",
+ DU_LOG("\nERROR --> SCH : CRNTI:%d Unable to get the UECB",
rawCqiInfo->crnti);
continue;
}
#ifdef RG_5GTF
/*
if (rawCqiInfo->numBits >= 5)
- printf("cellId [%d] crnti [%d] numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n",
+ DU_LOG("\nINFO --> SCH : cellId [%d] crnti [%d] numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n",
cell->cellId, rawCqiInfo->crnti, rawCqiInfo->numBits, rawCqiInfo->uciPayload,
rawCqiInd->timingInfo.sfn, rawCqiInd->timingInfo.slot);
*/
if (rawCqiInfo->numBits == 1)
{
rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
- U8 fdbk = TFU_HQFDB_NACK;
+ uint8_t fdbk = TFU_HQFDB_NACK;
/* Process HARQ FdbkInd */
hqAck = (rawCqiInfo->uciPayload >> 31) & 0x1;
if (hqAck)
if ((rgSCHDhm5gtfHqFdbkInd (ue, cell, rawCqiInd->timingInfo, fdbk, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d)",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d).",
err.errType, err.errCause);
continue;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB or RA CB ", rawCqiInfo->crnti);
err.errType = RGSCHERR_TOM_HARQACKIND;
continue;
}
/*
- printf("rawCqiInfo->numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n", rawCqiInfo->numBits,
+ DU_LOG("rawCqiInfo->numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n", rawCqiInfo->numBits,
rawCqiInfo->uciPayload, rawCqiInd->timingInfo.sfn, rawCqiInd->timingInfo.slot);
*/
}
if(ue) {
if (cqi == 0)
{
- printf("\n UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
+ DU_LOG("\nERROR --> SCH : UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
cqi = 15;
}
ue->ue5gtfCb.mcs = rgSch5gtfCqi2Mcs[cqi - 1];
#endif
}
/*
- printf("UE[%d] CQI[%d] MCS[%d] RI[%d]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri);
+ DU_LOG("\nERROR --> SCH : UE[%d] CQI[%d] MCS[%d] RI[%d]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri);
*/
}
else if (rawCqiInfo->numBits == 6)
hqAck = (rawCqiInfo->uciPayload >> 31) & 0x1;
if (cqi == 0)
{
- printf("UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
+ DU_LOG("\nERROR --> SCH : UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
cqi = 13;
}
ue->ue5gtfCb.mcs = rgSch5gtfCqi2Mcs[cqi - 1];
if ((rgSCHDhm5gtfHqFdbkInd (ue, cell, rawCqiInd->timingInfo, fdbk, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d)",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d).",
err.errType, err.errCause);
continue;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB or RA CB ", rawCqiInfo->crnti);
err.errType = RGSCHERR_TOM_HARQACKIND;
continue;
}
/*
- printf("\nUE[%u] CQI[%u] MCS[%u] RI[%u] HQ[%u]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri, hqAck);
+ DU_LOG("\nERROR --> SCH : UE[%u] CQI[%u] MCS[%u] RI[%u] HQ[%u]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri, hqAck);
*/
}
}
if ((rgSCHDhmRlsDlsfHqProc (cell, rawCqiInd->timingInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Release Downlink "
+ DU_LOG("\nERROR --> SCH : Unable to Release Downlink "
"subframe for cellId (%d) ", cell->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomSrsInd
(
- RgSchCellCb *cell,
- TfuSrsIndInfo *srsInd
- )
-#else
-S16 rgSCHTomSrsInd(cell, srsInd)
- RgSchCellCb *cell;
- TfuSrsIndInfo *srsInd;
-#endif
+RgSchCellCb *cell,
+TfuSrsIndInfo *srsInd
+)
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != srsInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", srsInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, srsInfo->ueId);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB", srsInfo->ueId);
continue;
}
*
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlGenIndices
+static S16 rgSCHTomUtlGenIndices
(
- U32 label,
- U8 posM,
- U8 valN,
- U8 valK,
- TfuSubbandInfo* sbInfo
- )
-#else
-PRIVATE S16 rgSCHTomUtlGenIndices(label, posM, valN, valK, sbInfo)
- U32 label;
- U8 posM;
- U8 valN;
- U8 valK;
- TfuSubbandInfo* sbInfo;
-#endif
+uint32_t label,
+uint8_t posM,
+uint8_t valN,
+uint8_t valK,
+TfuSubbandInfo* sbInfo
+)
{
- U8 idx, kval, xval, xmin;
- U32 binCoe;
+ uint8_t idx, kval, xval, xmin;
+ uint32_t binCoe;
xmin =1;
for(kval=0; kval<posM;kval++)
{
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomCrcInd
(
RgSchCellCb *cell,
TfuCrcIndInfo *crcInd
)
-#else
-S16 rgSCHTomCrcInd(cell, crcInd)
-RgSchCellCb *cell;
-TfuCrcIndInfo *crcInd;
-#endif
{
RgSchUeCb *ue = NULLP;
RgSchRaCb *raCb = NULLP;
//RgSchCmnUlCell *cellUl;
Inst inst = cell->instIdx;
TfuCntrlReqInfo *cntrlInfo;
- U32 ret;
+ uint32_t ret;
#ifdef LTE_TDD
- U8 Mval;
- U8 idx;
+ uint8_t Mval;
+ uint8_t idx;
#endif
#endif
#ifdef LTE_TDD
if(cell->cellId != crcInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", crcInd->cellId);
return RFAILED;
}
if (RGSCH_TIMEINFO_SAME(lastCrc, crntCrc))
{
/*Removed the WA to drop 2nd CRC*/
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Recieved CRC "
+ DU_LOG("\nINFO --> SCH : Recieved CRC "
"twice per TTI @(%u,%u)", cell->crntTime.sfn,
cell->crntTime.slot);
}
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&cntrlInfo,
sizeof(TfuCntrlReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate TfuCntrlReqInfo "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuCntrlReqInfo "
"for cell");
return ret;
}
if ((rgSCHTomUtlProcDlSfAtCrc (ulSf, crntHiDci0Frm, cell, cntrlInfo, &err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomCrcInd() Unable to process"
+ DU_LOG("\nERROR --> SCH : rgSCHTomCrcInd() Unable to process"
" downlink subframe for cellId %d", crcInd->cellId);
err.errType = RGSCHERR_TOM_TTIIND;
return RFAILED;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomTimingAdvInd
(
RgSchCellCb *cell,
TfuTimingAdvIndInfo *timingAdvInd
- )
-#else
-S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
-RgSchCellCb *cell;
-TfuTimingAdvIndInfo *timingAdvInd;
-#endif
+)
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != timingAdvInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
"=(%d)", timingAdvInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, timingAdvInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the UE CB",
timingAdvInfo->rnti);
continue;
}
* 4: Fill the Tfu structures for DL and UL Config requests
* 5: Handle the RGR Config messages per Cell
*
- * @param[in] SlotIndInfo *slotInd
+ * @param[in] SlotTimingInfo *slotInd
* @param[in] Inst schInst
* @return Void
**/
-#ifdef ANSI
Void rgSCHTomTtiInd
(
-SlotIndInfo *slotInd,
+SlotTimingInfo *slotInd,
Inst schInst
)
-#else
-Void rgSCHTomTtiInd(slotInd, schInst)
-SlotIndInfo *slotInd;
-Inst schInst;
-#endif
{
RgInfSfAlloc *subfrmAlloc;
RgTfuCntrlReqInfo *cntrlInfo = NULLP;
S16 ret = ROK;
- U8 i;
- U8 nCell = 0;
+ uint8_t i;
+ uint8_t nCell = 0;
RgSchCellCb *cell[CM_LTE_MAX_CELLS];
RgSchCellCb *cellLst[CM_LTE_MAX_CELLS];
if ((ret = rgSCHUtlAllocEventMem((cell[i]->instIdx), (Ptr *)&cntrlInfo,
sizeof(RgTfuCntrlReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell[i]->cellId,"Unable to Allocate TfuCntrlReqInfo"
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuCntrlReqInfo"
" for cell");
- RETVOID;
+ return;
}
#ifdef EMTC_ENABLE
#ifdef CA_DBG
{
- U32 dbgUeIdChngAndDatReqInClCnt = 0;
- static U32 gTtiCount = 0;
+ uint32_t dbgUeIdChngAndDatReqInClCnt = 0;
+ static uint32_t gTtiCount = 0;
gTtiCount++;
if(gTtiCount == 3000)
{
#ifdef XEON_SPECIFIC_CHANGES
- printf("SChed:: (P/S)::(%u/%u) \n",
+ DU_LOG("\nINFO --> SCH : SChed:: (P/S)::(%u/%u) \n",
gPrimarySchedCount,gSCellSchedCount);
- printf("\n HQFDBK :: %u\n",gHqFdbkCount);
+ DU_LOG("\nINFO --> SCH : HQFDBK :: %u\n",gHqFdbkCount);
long int total;
long int total2 ;
total = gPCellTb1AckCount + gPCellTb1NackCount + gPCellTb1DtxCount;
total2 = gPCellTb2AckCount + gPCellTb2NackCount + gPCellTb2DtxCount;
- printf("\n PCell:: TB1:: (A/N/D)::(%u/%u/%u) TB2:: (A/N/D)::(%u/%u/%u)\n",
+ DU_LOG("\nINFO --> SCH : PCell:: TB1:: (A/N/D)::(%u/%u/%u) TB2:: (A/N/D)::(%u/%u/%u)\n",
gPCellTb1AckCount,gPCellTb1NackCount,gPCellTb1DtxCount,
gPCellTb2AckCount,gPCellTb2NackCount,gPCellTb2DtxCount);
if ((total != 0 ) && total2 != 0)
{
- printf("\n PCell:: TB1:: (AP/NP/DP)::(%.2f/%.2f/%.2f) TB2:: (AP/NP/DP)::(%.2f/%.2f/%.2f)\n",
+ DU_LOG("\nINFO --> SCH : PCell:: TB1:: (AP/NP/DP)::(%.2f/%.2f/%.2f) TB2:: (AP/NP/DP)::(%.2f/%.2f/%.2f)\n",
(float)gPCellTb1AckCount/total * 100,(float)gPCellTb1NackCount/total * 100,(float)gPCellTb1DtxCount/total * 100,
(float)gPCellTb2AckCount/total2 *100 ,(float)gPCellTb2NackCount/total2 *100 ,(float)gPCellTb2DtxCount/total2 *2);
}
total2 = gSCellTb2AckCount + gSCellTb2NackCount + gSCellTb2DtxCount;
- printf("\n SCell:: TB1:: (A/N/D)::(%u/%u/%u) TB2:: (A/N/D)::(%u/%u/%u)\n",
+ DU_LOG("\nINFO --> SCH : SCell:: TB1:: (A/N/D)::(%u/%u/%u) TB2:: (A/N/D)::(%u/%u/%u)\n",
gSCellTb1AckCount,gSCellTb1NackCount,gSCellTb1DtxCount,
gSCellTb2AckCount,gSCellTb2NackCount,gSCellTb2DtxCount);
if ((total != 0 ) && total2 != 0)
{
- printf("\n SCell:: TB1:: (AP/NP/DP)::(%.2f/%.2f/%.2f) TB2:: (AP/NP/DP)::(%.2f/%.2f/%.2f)\n",
+ DU_LOG("\nINFO --> SCH : SCell:: TB1:: (AP/NP/DP)::(%.2f/%.2f/%.2f) TB2:: (AP/NP/DP)::(%.2f/%.2f/%.2f)\n",
(float)gSCellTb1AckCount/total * 100,(float)gSCellTb1NackCount/total * 100,(float)gSCellTb1DtxCount/total * 100,
(float)gSCellTb2AckCount/total2 *100 ,(float)gSCellTb2NackCount/total2 *100 ,(float)gSCellTb2DtxCount/total2 *2);
}
- printf("\n CQI:: Recp(Pucch/Pusch):Rcvd(pcqi/rawacqireport/apcqi/AppReprt)::(%u/%u):(%u/%u/%u/%u)\n",
+ DU_LOG("\nINFO --> SCH : CQI:: Recp(Pucch/Pusch):Rcvd(pcqi/rawacqireport/apcqi/AppReprt)::(%u/%u):(%u/%u/%u/%u)\n",
gCqiRecpCount,gCqiRecpPuschCount,gCqiRcvdCount,gRawACqiCount,
gACqiRcvdCount,gCqiReptToAppCount);
- printf("\n (F1BCS Count/Cqi/Ri/CqiDrop/PucchDrop/PuschCqiDrop)::(%u/%u/%u/%u/%u/%u)\n",
+ DU_LOG("\nINFO --> SCH : (F1BCS Count/Cqi/Ri/CqiDrop/PucchDrop/PuschCqiDrop)::(%u/%u/%u/%u/%u/%u)\n",
gF1bCsCount,gCqiReqCount,gRiReqCount,gCqiDropCount,gPucchDropCount,gPuschCqiDropCount);
- printf("UL::(DCI0/CrcPass/CrcFail)::(%u/%u/%u)\n"
+ DU_LOG("\nINFO --> SCH : UL::(DCI0/CrcPass/CrcFail)::(%u/%u/%u)\n"
"gPcellZeroBoOcc:%u\t gScellZeroBoOcc:%u dbgUeIdChngAndDatReqInClCnt: %u\n"
"DelayedDatReqInMac: %u DelayedDatReqInCl : %u gIccPktRcvrMemDropCnt :%u\n",
gDci0Count,
dbgDelayedDatReqInMac,
gDropDatReqCnt, gIccPktRcvrMemDropCnt);
#else
- printf("SChed:: (P/S)::(%ld/%ld) \n",
+ DU_LOG("\nINFO --> SCH : SChed:: (P/S)::(%ld/%ld) \n",
gPrimarySchedCount,gSCellSchedCount);
- printf("\n HQFDBK :: %ld\n",gHqFdbkCount);
+ DU_LOG("\nINFO --> SCH : HQFDBK :: %ld\n",gHqFdbkCount);
+
- printf("\n PCell:: TB1:: (A/N/D)::(%ld/%ld/%ld) TB2:: (A/N/D)::(%ld/%ld/%ld)\n",
+ DU_LOG("\nINFO --> SCH : PCell:: TB1:: (A/N/D)::(%ld/%ld/%ld) TB2:: (A/N/D)::(%ld/%ld/%ld)\n",
gPCellTb1AckCount,gPCellTb1NackCount,gPCellTb1DtxCount,
gPCellTb2AckCount,gPCellTb2NackCount,gPCellTb2DtxCount);
- printf("\n SCell:: TB1:: (A/N/D)::(%ld/%ld/%ld) TB2:: (A/N/D)::(%ld/%ld/%ld)\n",
+ DU_LOG("\nINFO --> SCH : SCell:: TB1:: (A/N/D)::(%ld/%ld/%ld) TB2:: (A/N/D)::(%ld/%ld/%ld)\n",
gSCellTb1AckCount,gSCellTb1NackCount,gSCellTb1DtxCount,
gSCellTb2AckCount,gSCellTb2NackCount,gSCellTb2DtxCount);
- printf("\n CQI:: Recp(Pucch/Pusch):Rcvd(pcqi/rawacqireport/apcqi/AppReprt)::(%ld/%ld):(%ld/%ld/%ld/%ld)\n",
+ DU_LOG("\nINFO --> SCH : CQI:: Recp(Pucch/Pusch):Rcvd(pcqi/rawacqireport/apcqi/AppReprt)::\
+ (%ld/%ld):(%ld/%ld/%ld/%ld)\n",
gCqiRecpCount,gCqiRecpPuschCount,gCqiRcvdCount,gRawACqiCount,
gACqiRcvdCount,gCqiReptToAppCount);
- printf("\n CQI:: PucchCqiSnrDropCnt/PucchCqiConfBitMaskDropCnt/PuschCqiConfMaskDropCount :: (%ld/%ld/%ld) \n",gCqiPucchLowSnrDropCount,gCqiPucchConfMaskDropCount,gCqiPuschConfMaskDropCount);
+ DU_LOG("\nINFO --> SCH : CQI:: PucchCqiSnrDropCnt/PucchCqiConfBitMaskDropCnt/PuschCqiConfMaskDropCount\
+ :: (%ld/%ld/%ld) \n",gCqiPucchLowSnrDropCount,gCqiPucchConfMaskDropCount,gCqiPuschConfMaskDropCount);
- printf("\n (F1BCS Count/Cqi/Ri/CqiDrop/PucchDrop/PuschCqiDrop)::(%ld/%ld/%ld/%ld/%ld/%ld)\n",
+ DU_LOG("\nINFO --> SCH : (F1BCS Count/Cqi/Ri/CqiDrop/PucchDrop/PuschCqiDrop)::(%ld/%ld/%ld/%ld/%ld/%ld)\n",
gF1bCsCount,gCqiReqCount,gRiReqCount,gCqiDropCount,gPucchDropCount,gPuschCqiDropCount);
- printf("UL::(DCI0/CrcPass/CrcFail)::(%ld/%ld/%ld)\n"
+ DU_LOG("\nINFO --> SCH : UL::(DCI0/CrcPass/CrcFail)::(%ld/%ld/%ld)\n"
"gPcellZeroBoOcc:%ld\t gScellZeroBoOcc:%ld dbgUeIdChngAndDatReqInClCnt: %ld\n"
"DelayedDatReqInMac: %ld DelayedDatReqInCl : %ld gIccPktRcvrMemDropCnt :%ld\n",
gDci0Count,
dbgUeIdChngAndDatReqInClCnt,
dbgDelayedDatReqInMac,
gDropDatReqCnt, gIccPktRcvrMemDropCnt);
- //printf ("\n delayedApiCnt:%ld",delayedApiCnt);
+ //DU_LOG("\nINFO --> SCH : delayedApiCnt:%ld",delayedApiCnt);
#endif
/*LAA STATS*/
}
#endif
- RETVOID;
+ return;
} /* rgSCHTomTtiInd */
/** @brief This function does the TTI processin for the uplink subframe,
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcUlSf
+static S16 rgSCHTomUtlProcUlSf
(
RgSchCellCb *cell,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlProcUlSf (cell, err)
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
TfuRecpReqInfo *recpReqInfo;
#ifdef TFU_UPGRADE
- U16 validIdx = 0; /* Index computed from recreq's timing info*/
+ uint16_t validIdx = 0; /* Index computed from recreq's timing info*/
#endif
Inst inst = cell->instIdx;
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate TfuRecpReqInfo "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuRecpReqInfo "
"for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
err);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to fill Data recption "
+ DU_LOG("\nERROR --> SCH : Unable to fill Data recption "
"requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
ret = rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, validIdx,err);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to fill Harq Feedback "
+ DU_LOG("\nERROR --> SCH : Unable to fill Harq Feedback "
"reception requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
}
/* sending the RecpReq to Phy */
- if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
+ //if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info for cell");
+ DU_LOG("\nERROR --> SCH : Unable to send Cntrl info for cell");
}
return ROK;
} /* end of rgSCHTomUtlProcUlSf */
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlPrcUlTddSpclSf
+static S16 rgSCHTomUtlPrcUlTddSpclSf
(
-RgSchCellCb *cell,
-RgSchErrInfo *err
+RgSchCellCb *cell,
+RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlPrcUlTddSpclSf (cell, err)
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
TfuRecpReqInfo *recpReqInfo;
- U16 validIdx; /* Index computed from recreq's timing info*/
+ uint16_t validIdx; /* Index computed from recreq's timing info*/
Inst inst = cell->instIdx;
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to "
+ DU_LOG("\nERROR --> SCH : rgSCHTomUtlPrcUlTddSpclSf() Unable to "
"Allocate TfuRecpReqInfo for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
ret = rgSCHTomUtlFillSrsRecpReq (recpReqInfo, cell, validIdx, err);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to fill"
- " SRS recption requests for cell");;
+ DU_LOG("\nERROR --> SCH : rgSCHTomUtlPrcUlTddSpclSf() Unable to fill"
+ " SRS recption requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
}
/* sending the RecpReq to Phy */
- if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
+ //if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to send "
+ DU_LOG("\nERROR --> SCH : rgSCHTomUtlPrcUlTddSpclSf() Unable to send "
"Cntrl info for cell");
}
return ROK;
* @param [out] RgSchErrInfo *err
* @return S16
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcDlSf
+static S16 rgSCHTomUtlProcDlSf
(
RgSchDlSf *dlSf,
RgSchDlSf *ulSf,
RgTfuCntrlReqInfo *cntrlInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlProcDlSf (dlSf, ulSf, cell, cntrlInfo, err)
-RgSchDlSf *dlSf;
-RgSchDlSf *ulSf;
-RgSchCellCb *cell;
-RgTfuCntrlReqInfo *cntrlInfo;
-RgSchErrInfo *err;
-#endif
{
- Inst inst = cell->instIdx;
- S16 ret;
- U8 sfTyp = 1; /* Dl Subframe */
+ S16 ret;
+ uint8_t sfTyp = 1; /* Dl Subframe */
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
cntrlInfo->ulTiming = cell->hiDci0Time;
if((0 == (cntrlInfo->dlTiming.sfn % 30)) && (0 == cntrlInfo->dlTiming.slot))
{
- //printf("5GTF_CHECK rgSCHTomUtlProcDlSf Cntrl dl (%d : %d) ul (%d : %d)\n", cntrlInfo->dlTiming.sfn, cntrlInfo->dlTiming.subframe, cntrlInfo->ulTiming.sfn, cntrlInfo->ulTiming.subframe);
+ //DU_LOG("\nERROR --> SCH : 5GTF_CHECK rgSCHTomUtlProcDlSf Cntrl dl (%d : %d) ul (%d : %d)\n", \
+ cntrlInfo->dlTiming.sfn, cntrlInfo->dlTiming.subframe, cntrlInfo->ulTiming.sfn, cntrlInfo->ulTiming.subframe);
}
/* Fill PCFICH info */
/* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
*/
cntrlInfo->cfi = dlSf->pdcchInfo.currCfi;
#ifndef RG_ULSCHED_AT_CRC
- U8 Mval = 1;
+ uint8_t Mval = 1;
#ifdef LTE_TDD
Mval = rgSchTddPhichMValTbl[cell->ulDlCfgIdx]
[cell->hiDci0Time.subframe];
/* Fill PHICH info */
if ((ret = rgSCHTomUtlFillPhich (cell, cntrlInfo, ulSf, err)) != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PHICH info "
- "for cellId (%d)\n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to send PHICH info "
+ "for cellId (%d)\n", cell->cellId);
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
if ((ret = rgSCHTomUtlFillUlPdcch (cell, cntrlInfo, ulSf, err)) !=
ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PDCCH info "
- "for cellId (%d)\n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to send PDCCH info "
+ "for cellId (%d)\n", cell->cellId);
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
/* Fill PDCCH info */
if ((ret = rgSCHTomUtlFillDlPdcch(cell,cntrlInfo, dlSf, err)) != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PDCCH info "
- "for cellId (%d)\n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to send PDCCH info "
+ "for cellId (%d)\n", cell->cellId);
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
#endif
/* Now always sending down a cntrl req */
/* sending the cntrl data to Phy */
- if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo)
- != ROK)
+ //if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo)
+ //!= ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info "
- "for cell");
+ DU_LOG("\nERROR --> SCH : Unable to send Cntrl info for cell");
}
return ROK;
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillPhich
+static S16 rgSCHTomUtlFillPhich
(
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *dlSf,
RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillPhich(cell, cntrlInfo, dlSf, err)
-RgSchCellCb *cell;
-TfuCntrlReqInfo *cntrlInfo;
-RgSchDlSf *dlSf;
-RgSchErrInfo *err;
-#endif
+)
{
S16 ret;
CmLList *node;
* @param[in] CmLteRnti rnti
* @return Void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTmrRestartScellDeactTmr
+static Void rgSCHTmrRestartScellDeactTmr
(
- RgSchCellCb *cell,
- RgSchUeCb *ueCb
- )
-#else
-PRIVATE Void rgSCHTmrRestartScellDeactTmr (cell, ueCb)
- RgSchCellCb *cell;
- RgSchUeCb *ueCb;
-
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ueCb
+)
{
RgSchUeCellInfo *sCellInfo = NULLP;
* -# ROK
* -# RFAILED
*/
-EXTERN U32 numdlSpsRelSentToTf;
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillDlPdcch
+uint32_t numdlSpsRelSentToTf;
+static S16 rgSCHTomUtlFillDlPdcch
(
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *dlSf,
RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillDlPdcch(cell,cntrlInfo, dlSf, err)
-RgSchCellCb *cell;
-TfuCntrlReqInfo *cntrlInfo;
-RgSchDlSf *dlSf;
-RgSchErrInfo *err;
-#endif
+)
{
S16 ret;
CmLList *node;
RgSchPdcch *pdcch;
TfuPdcchInfo *tfuPdcch;
- U8 isDcivld = FALSE;
- U8 numUePerTti = 0;
+ uint8_t isDcivld = FALSE;
+ uint8_t numUePerTti = 0;
ret = ROK;
/* Traversing the scheduled Harq processes */
} /* end of rgSCHTomUtlFillDlPdcch*/
#ifdef RGSCH_SPS_STATS
-extern U32 rgSchSpsRelSentToTf;
-extern U32 rgSchSpsRelPdcchAllocd;
+uint32_t rgSchSpsRelSentToTf;
+uint32_t rgSchSpsRelPdcchAllocd;
#endif
/** @brief This function will send all the UL PDCCH's for the given
* subframe.
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillUlPdcch
+static S16 rgSCHTomUtlFillUlPdcch
(
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *dlSf,
RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillUlPdcch(cntrlInfo, dlSf, err)
-RgSchCellCb *cell;
-TfuCntrlReqInfo *cntrlInfo;
-RgSchDlSf *dlSf;
-RgSchErrInfo *err;
-#endif
+)
{
S16 ret;
CmLList *node;
RgSchPdcch *pdcch;
TfuPdcchInfo *tfuPdcch;
- U8 isDcivld = FALSE;
+ uint8_t isDcivld = FALSE;
ret = ROK;
/* Traversing the scheduled Harq processes */
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcTA
-(
-RgSchCellCb *cell
-)
-#else
-PRIVATE S16 rgSCHTomUtlProcTA (cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHTomUtlProcTA(RgSchCellCb *cell)
{
CmLList *node;
RgSchUeCb *ue;
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
S16 rgSCHTomUtlFillHqFdbkInfo
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchDlHqProcCb *hqCb,
- RgSchDlSf *nxtDlsf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchDlHqProcCb *prvHqCb,
- RgSchErrInfo *err
- )
-#else
-S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchDlHqProcCb *hqCb;
- RgSchDlSf *nxtDlsf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchDlHqProcCb *prvHqCb;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqProcCb *hqCb,
+RgSchDlSf *nxtDlsf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchDlHqProcCb *prvHqCb,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchDlHqProcCb *prvHqCb,
RgSchErrInfo *err
)
-#else
-S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchDlHqProcCb *hqCb;
-RgSchDlSf *nxtDlsf;
-TfuUeRecpReqInfo *pucchRecpInfo;
-RgSchDlHqProcCb *prvHqCb;
-RgSchErrInfo *err;
-#endif
#endif
{
S16 ret;
RgSchDlHqTbCb *tbCb;
- U32 idx;
+ uint32_t idx;
Bool isAddToLst = FALSE;
for (idx = 0 ;idx < 2; idx++)
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell");
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx,
+ * @param [in] uint16_t validIdx,
* @param [in] RgSchDlHqInfo *dlSfHqInfo,
* @param [in] RgSchDlSf *dlSf,
* @param [in] TfuUeRecpReqInfo *pucchRecpInfo,
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkFor5gtf
+static S16 rgSCHTomUtlFillHqFdbkFor5gtf
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchDlHqInfo *dlSfHqInfo,
- RgSchDlSf *dlSf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkFor5gtf (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchDlHqInfo *dlSfHqInfo;
- RgSchDlSf *dlSf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqInfo *dlSfHqInfo,
+RgSchDlSf *dlSf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchErrInfo *err
+)
{
-#ifdef DEBUGP
- Inst inst = cell->instIdx;
-#endif
S16 ret;
RgSchUeCb *ue;
TfuUePucchRecpReq *pucchReqInfo = NULLP;
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
- "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
+ "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx,
+ * @param [in] uint16_t validIdx,
* @param [in] RgSchDlHqInfo *dlSfHqInfo,
* @param [in] RgSchDlSf *dlSf,
* @param [in] TfuUeRecpReqInfo *pucchRecpInfo,
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B
+static S16 rgSCHTomUtlFillHqFdbkForFrmt1B
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchDlHqInfo *dlSfHqInfo,
- RgSchDlSf *dlSf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchDlHqInfo *dlSfHqInfo;
- RgSchDlSf *dlSf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqInfo *dlSfHqInfo,
+RgSchDlSf *dlSf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B
+static S16 rgSCHTomUtlFillHqFdbkForFrmt1B
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
TfuUeRecpReqInfo *pucchRecpInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B (recpReqInfo, cell, hqCb, dlSf, pucchRecpInfo, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchDlHqInfo *dlSfHqInfo;
-RgSchDlSf *dlSf;
-TfuUeRecpReqInfo *pucchRecpInfo;
-RgSchErrInfo *err;
-#endif
#endif
{
#ifdef DEBUGP
RgSchUeCb *ue;
TfuUePucchRecpReq *pucchReqInfo = NULLP;
Bool isDatPresOnSecCell = FALSE;
- U8 primCellTbCount = 0;
+ uint8_t primCellTbCount = 0;
hqPNode = dlSfHqInfo->hqPLst.first;
ue = (RgSchUeCb*)dlSfHqInfo->dlSfUeLnk.node;
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
- "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cellId=%d \n", cell->cellId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = ue->f1bCsAVal;
- memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(uint16_t)*TFU_MAX_HQ_RES);
#ifdef LTEMAC_SPS
/* Two Resources needs to be configured if the
* serving cell is in mimo mode else single
* mode should be in 2 indices */
if(RG_SCH_IS_CELL_SEC(ue,hqCb->hqE->cell))
{
- U8 cellIdx = ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(hqCb->hqE->cell)];
+ uint8_t cellIdx = ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(hqCb->hqE->cell)];
if(rgSCHUtlGetMaxTbSupp(ue->cellInfo[cellIdx]->txMode.txModeEnum) > 1)
{/* Sec cell is in mimo mode, use 0 and 1 */
pucchReqInfo->hqInfo.hqRes[0] =
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx,
+ * @param [in] uint16_t validIdx,
* @param [in] RgSchDlHqInfo *dlSfHqInfo,
* @param [in] RgSchDlSf *dlSf,
* @param [in] TfuUeRecpReqInfo *pucchRecpInfo,
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3
+static S16 rgSCHTomUtlFillHqFdbkForFrmt3
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchDlHqInfo *dlSfHqInfo,
- RgSchDlSf *dlSf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3 (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchDlHqInfo *dlSfHqInfo;
- RgSchDlSf *dlSf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqInfo *dlSfHqInfo,
+RgSchDlSf *dlSf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3
+static S16 rgSCHTomUtlFillHqFdbkForFrmt3
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
TfuUeRecpReqInfo *pucchRecpInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3 (recpReqInfo, cell, hqCb, dlSf, pucchRecpInfo, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchDlHqInfo *dlSfHqInfo;
-RgSchDlSf *dlSf;
-TfuUeRecpReqInfo *pucchRecpInfo;
-RgSchErrInfo *err;
-#endif
#endif
{
#ifdef DEBUGP
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
- "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
+ "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = 1;
- memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(uint16_t)*TFU_MAX_HQ_RES);
#endif/*TFU_UPGRADE*/
pucchReqInfo->hqInfo.hqRes[0] = dlSfHqInfo->n3ScellPucch.n3PucchIdx;
#ifdef TFU_UPGRADE
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq
+static S16 rgSCHTomUtlFillHqFdbkRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq
+static S16 rgSCHTomUtlFillHqFdbkRecpReq
(
-TfuRecpReqInfo *recpReqInfo,
-RgSchCellCb *cell,
-RgSchErrInfo *err
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
#endif
{
CmLList *node;
* -# RFAILED
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSrRecpReq
+static S16 rgSCHTomUtlFillSrRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSrRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlWillUeRprtCqiRi
+static S16 rgSCHTomUtlWillUeRprtCqiRi
(
- RgSchUeCb *ue,
- Bool *willueRprtCqiRi
- )
-#else
-PRIVATE S16 rgSCHTomUtlWillUeRprtCqiRi ( ue, willueRprtCqiRi)
- RgSchUeCb *ue;
- Bool *willueRprtCqiRi;
-#endif
+RgSchUeCb *ue,
+Bool *willueRprtCqiRi
+)
{
/* Intialising Reporting probability as TRUE */
*willueRprtCqiRi = TRUE;
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
* -# RFAILED
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillRiRecpReq
+static S16 rgSCHTomUtlFillRiRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillRiRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
"TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq
+static S16 rgSCHTomUtlFillCqiRiRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchUeCb *ue = NULLP;
- U16 ret;
+ TfuUeRecpReqInfo *pucchRecpInfo;
+ RgSchUeCb *ue = NULLP;
+ uint16_t ret;
while ((ue = rgSCHDbmGetNextUeCb(cell, ue)) != NULLP)
{
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
* -# RFAILED
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq
+static S16 rgSCHTomUtlFillPcqiRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
S16 ret;
-
RgSchUeCb *ue;
- U8 ri; /*RI value*/
- Bool willUeRprtCqi; /* Flag set due to CQI Mask
- and UE Inactive state (DRX)*/
- U8 cqiPmiSz;
+ uint8_t ri; /*RI value*/
+ Bool willUeRprtCqi; /* Flag set due to CQI Mask and UE Inactive state (DRX)*/
+ uint8_t cqiPmiSz;
RgSchUePCqiCb *cqiCb = NULLP;
Bool isAddToLst = FALSE;
cqiPmiSz = rgSCHTomUtlFetchPcqiBitSz(ue, cell->numTxAntPorts, &ri);
if(!cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to Fill CqiPmi "
- "size", ue->ueId);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
continue;
}
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSrsRecpReq
+static S16 rgSCHTomUtlFillSrsRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSrsRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for RNTI:%d ",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for RNTI:%d ",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq
+static S16 rgSCHTomUtlFillDatRecpReq
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq (recpReqInfo, cell, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
RgSchUlAlloc *alloc;
sizeof(TfuUeRecpReqInfo),
&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for RNTI:%d ", alloc->ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for RNTI:%d ", alloc->ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq
+static S16 rgSCHTomUtlFillDatRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- U16 validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLteTimingInfo dci0Time;
- U8 idx;
+ uint8_t idx;
S16 ret;
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
Bool isAperiodic = FALSE; /*Set when Aperiodic CQI is expected */
- U8 numUePerTti = 0;
+ uint8_t numUePerTti = 0;
if((0 == (recpReqInfo->timingInfo.sfn % 30)) && (0 == recpReqInfo->timingInfo.slot))
{
- //printf("5GTF_CHECK rgSCHTomUtlFillDatRecpReq (%d : %d)\n", recpReqInfo->timingInfo.sfn, recpReqInfo->timingInfo.slot);
+ //DU_LOG("\nERROR --> SCH : 5GTF_CHECK rgSCHTomUtlFillDatRecpReq (%d : %d)\n",\
+ recpReqInfo->timingInfo.sfn, recpReqInfo->timingInfo.slot);
}
/* processing steps are
* - Run through the UL allocations going out in this subframe.
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if(ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
"TfuUeRecpReqInfo for RNTI:%d ", alloc->rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
* File :
*
**********************************************************/
-#ifdef ANSI
S16 rgSCHTomUtlFillRiBitWidthInfo
(
- RgSchUeCb *ueCb
- )
-#else
-S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
- RgSchUeCb *ueCb;
-#endif
+RgSchUeCb *ueCb
+)
{
RgSchUePCqiCb *riCb = ueCb->nPRiCb;
*
* Desc : Fetch the CQI/PMI bits for a UE based on the mode, periodicity.
*
- * Ret : U8
+ * Ret : uint8_t
* ROK - Success
*
* Notes:
* File :
*
**********************************************************/
-#ifdef ANSI
-U8 rgSCHTomUtlFetchPcqiBitSz
+uint8_t rgSCHTomUtlFetchPcqiBitSz
(
- RgSchUeCb *ueCb,
- U8 numTxAnt,
- U8 *ri
- )
-#else
-U8 rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
- RgSchUeCb *ueCb;
- U8 numTxAnt;
- U8 *ri;
-#endif
+RgSchUeCb *ueCb,
+uint8_t numTxAnt,
+uint8_t *ri
+)
{
- U8 confRepMode;
- U8 pcqiSz;
+ uint8_t confRepMode;
+ uint8_t pcqiSz;
TfuCqiPucchMode10 *mode10Info;
TfuCqiPucchMode11 *mode11Info;
TfuCqiPucchMode20 *mode20Info;
* File :
*
**********************************************************/
-#ifdef ANSI
S16 rgSCHTomUtlPcqiSbCalcBpIdx
(
- CmLteTimingInfo crntTimInfo,
- RgSchUeCb *ueCb,
- RgSchUePCqiCb *cqiCb
- )
-#else
-S16 rgSCHTomUtlPcqiSbCalcBpIdx(crntTimInfo, ueCb, cqiCb)
- CmLteTimingInfo crntTimInfo;
- RgSchUeCb *ueCb;
- RgSchUePCqiCb *cqiCb;
-#endif
+CmLteTimingInfo crntTimInfo,
+RgSchUeCb *ueCb,
+RgSchUePCqiCb *cqiCb
+)
{
- U16 tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
- U16 prdNum = tti/cqiCb->cqiPeri;
+ uint16_t tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
+ uint16_t prdNum = tti/cqiCb->cqiPeri;
if((prdNum % cqiCb->h) == 0)
{
*
* @param[in] RgSchCellCb *cell,
* RgSchUeCb *ue,
- * U16 validIdx
+ * uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlMoveNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- U16 validIdx
- )
-#else
-S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- U16 validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint16_t validIdx
+)
{
RgSchUePCqiCb *cqiCb = ue->nPCqiCb;
RgSchUePCqiCb *riCb = ue->nPRiCb;
* to aid decoding of Aperiodic CQI.
*
* Ret : Void
- * ROK - RETVOID
+ * ROK - void
*
* Notes:
*
* File :
*
**********************************************************/
-#ifdef ANSI
Void rgSCHTomPrepareAcqiRecp
(
- RgSchUeCb *ueCb,
- RgSchCellCb *cell,
- TfuUePuschCqiRecpInfo *cqiRecpReqInfo,
- U8 ccIdx
- )
-#else
- Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
- RgSchUeCb *ueCb;
- RgSchCellCb *cell;
- TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- U8 ccIdx;
-#endif
+RgSchUeCb *ueCb,
+RgSchCellCb *cell,
+TfuUePuschCqiRecpInfo *cqiRecpReqInfo,
+uint8_t ccIdx
+)
{
- U8 confRepMode;
+ uint8_t confRepMode;
RgSchCqiRawPuschMode12 *mode12Info;
RgSchCqiRawPuschMode20 *mode20Info;
RgSchCqiRawPuschMode22 *mode22Info;
RgSchCqiRawPuschMode30 *mode30Info;
RgSchCqiRawPuschMode31 *mode31Info;
- U8 numTxAnt = cell->numTxAntPorts;
- U8 sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
- U8 numOfCells = 0;
+ uint8_t numTxAnt = cell->numTxAntPorts;
+ uint8_t sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
+ uint8_t numOfCells = 0;
RgSchUeACqiCb *acqiCb = &ueCb->cellInfo[sCellIdx]->acqiCb;
/* Fill TFU Recp */
default:
break;
}
- RETVOID;
+ return;
}
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatAperRecpReq
(
- RgSchCellCb *cell,
- U8 cqiReq,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- )
-#else
-S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
- RgSchCellCb *cell;
- U8 cqiReq;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
- U16 validIdx;
-#endif
+RgSchCellCb *cell,
+uint8_t cqiReq,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+)
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- RgSchUeCb *ueCb = alloc->ue;
+ RgSchUeCb *ueCb = alloc->ue;
#ifdef LTE_ADV
- U8 triggerSet = 0;
- U8 sIdx = 0;
+ uint8_t triggerSet = 0;
+ uint8_t sIdx = 0;
#endif
/*Fill RI Reception Params*/
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatPriRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- )
-#else
-S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
-hqPres, validIdx)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
- U16 validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+)
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatPCqiRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- )
-#else
-S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
- timeInfo, hqPres, validIdx)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
- U16 validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+)
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- U8 cqiPmiSz; /*Raw CQI/PMI Size*/
- U8 ri;
+ uint8_t cqiPmiSz; /*Raw CQI/PMI Size*/
+ uint8_t ri;
/*Fill CQI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
cqiPmiSz = rgSCHTomUtlFetchPcqiBitSz(alloc->ue, cell->numTxAntPorts, &ri);
if(0 == cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Fill "
+ DU_LOG("\nERROR --> SCH : Unable to Fill "
"CqiPmi size RNTI:%d",alloc->rnti);
return RFAILED;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatSrsRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres
- )
-#else
-S16 rgSCHTomUtlFillDatSrsRecpReq(cell, alloc, datRecpInfo, timeInfo,
- hqPres)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres
+)
{
datRecpInfo->rnti = alloc->rnti;
rgSCHTomFillOnlySrsRecpReq(cell,alloc, datRecpInfo);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomFillOnlySrsRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo
- )
-#else
-S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo
+)
{
TfuUePuschSrsRecpInfo *srsRecpReqInfo;
* TfuRecpReqInfo *recpReqInfo,
* RgSchDlHqProcCb *hqCb,
* @param[out] TfuUeRecpReqInfo *pucchRecpInfo
- * @param[in] U16 validIdx
+ * @param[in] uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillCqiSrSrsWithHq
+static S16 rgSCHTomUtlFillCqiSrSrsWithHq
(
- RgSchCellCb *cell,
- TfuRecpReqInfo *recpReqInfo,
- RgSchUeCb *ue,
- TfuUeRecpReqInfo *pucchRecpInfo,
- U16 validIdx,
- Bool isDatPresOnSecCell
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillCqiSrSrsWithHq(cell, recpReqInfo, ue,
- pucchRecpInfo, validIdx,isDatPresOnSecCell)
-RgSchCellCb *cell;
-TfuRecpReqInfo *recpReqInfo;
-RgSchUeCb *ue;
-TfuUeRecpReqInfo *pucchRecpInfo;
-U16 validIdx;
-Bool isDatPresOnSecCell;
-#endif
+RgSchCellCb *cell,
+TfuRecpReqInfo *recpReqInfo,
+RgSchUeCb *ue,
+TfuUeRecpReqInfo *pucchRecpInfo,
+uint16_t validIdx,
+Bool isDatPresOnSecCell
+)
{
RgSchUePCqiCb *cqiCb;
RgSchUePCqiCb *riCb;
- U8 ri; /*To fetch RI value*/
- Bool willUeRprtCqi; /* Flag set due to CQI Mask and
- UE Inactive state (DRX)*/
- Bool willUeRprtSr = TRUE;
- TfuAckNackMode hqFdbkMode;
- U8 numCqiBit;
- U8 totalPucchBits;
- Bool dropCqi = FALSE;
+ uint8_t ri; /*To fetch RI value*/
+ Bool willUeRprtCqi; /* Flag set due to CQI Mask and UE Inactive state (DRX)*/
+ Bool willUeRprtSr = TRUE;
+ TfuAckNackMode hqFdbkMode;
+ uint8_t numCqiBit;
+ uint8_t totalPucchBits;
+ Bool dropCqi = FALSE;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = NULL;
#endif
rgSCHTomUtlFetchPcqiBitSz(ue, cell->numTxAntPorts, &ri);
if(0 == pucchRecpInfo->t.pucchRecpReq.cqiInfo.cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d "
- "Unable to Fill CqiPmi size", ue->ueId);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
return RFAILED;
}
if(pucchRecpInfo->t.pucchRecpReq.uciInfo == TFU_PUCCH_HARQ_SR)
* RgSchUeCb *ue
* TfuRecpReqInfo *recpReqInfo,
* @param[out] TfuUeRecpReqInfo *pucchRecpInfo
- * @param[in] U16 validIdx
+ * @param[in] uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr
+static S16 rgSCHTomUtlFillCqiSrsWithSr
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuRecpReqInfo *recpReqInfo,
- TfuUeRecpReqInfo *pucchRecpInfo,
- U16 validIdx
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr(cell, ue, recpReqInfo,
- pucchRecpInfo, validIdx)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-TfuRecpReqInfo *recpReqInfo;
-TfuUeRecpReqInfo *pucchRecpInfo;
-U16 validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuRecpReqInfo *recpReqInfo,
+TfuUeRecpReqInfo *pucchRecpInfo,
+uint16_t validIdx
+)
{
- RgSchUePCqiCb *cqiCb;
- RgSchUePCqiCb *riCb;
- U8 ri; /*To fetch RI value*/
- Bool willUeRprtCqi; /* Flag set due to CQI Mask and
+ RgSchUePCqiCb *cqiCb;
+ RgSchUePCqiCb *riCb;
+ uint8_t ri; /*To fetch RI value*/
+ Bool willUeRprtCqi; /* Flag set due to CQI Mask and
UE Inactive state (DRX)*/
riCb = ue->nPRiCb;
cqiCb = ue->nPCqiCb;
rgSCHTomUtlFetchPcqiBitSz(ue, cell->numTxAntPorts, &ri);
if(0 == pucchRecpInfo->t.pucchRecpReq.cqiInfo.cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d"
- " Unable to Fill CqiPmi size", ue->ueId);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
return RFAILED;
- }
+ }
pucchRecpInfo->t.pucchRecpReq.uciInfo = TFU_PUCCH_SR_CQI;
}
* @param [in] RgSchCellCb *cell
* @param [out] RgSchErrInfo *err
* @param [in] RgSchDlSf *dlSf
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] CmMemListCp *memCp
- * @param [in] U8 elemIdx
+ * @param [in] uint8_t elemIdx
* @param [in] RgSchDlSf *nxtDlsf
* @return S16
* -# ROK
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk
+static S16 rgSCHTomUtlFillSfRepHqFdbk
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cellCb,
- RgSchErrInfo *err,
- RgSchDlSf *dlSf,
- U8 noFdbks,
- CmMemListCp *memCp,
- U8 elemIdx,
- RgSchDlSf *nxtDlsf,
- U16 validIdx
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk (recpReqInfo, cellCb, err, dlSf,
-noFdbks, memCp, elemIdx, nxtDlsf, validIdx)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cellCb;
- RgSchErrInfo *err;
- RgSchDlSf *dlSf;
- U8 noFdbks;
- CmMemListCp *memCp;
- U8 elemIdx;
- RgSchDlSf *nxtDlsf;
- U16 validIdx;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cellCb,
+RgSchErrInfo *err,
+RgSchDlSf *dlSf,
+uint8_t noFdbks,
+CmMemListCp *memCp,
+uint8_t elemIdx,
+RgSchDlSf *nxtDlsf,
+uint16_t validIdx
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk
+static S16 rgSCHTomUtlFillSfRepHqFdbk
(
-TfuRecpReqInfo *recpReqInfo,
-RgSchCellCb *cellCb,
-RgSchErrInfo *err,
-RgSchDlSf *dlSf,
-U8 noFdbks,
-CmMemListCp *memCp,
-U8 elemIdx,
-RgSchDlSf *nxtDlsf
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cellCb,
+RgSchErrInfo *err,
+RgSchDlSf *dlSf,
+uint8_t noFdbks,
+CmMemListCp *memCp,
+uint8_t elemIdx,
+RgSchDlSf *nxtDlsf
)
-#else
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk (recpReqInfo, cellCb, err, dlSf,
-noFdbks, memCp, elemIdx, nxtDlsf)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cellCb;
- RgSchErrInfo *err;
- RgSchDlSf *dlSf;
- U8 noFdbks;
- CmMemListCp *memCp;
- U8 elemIdx;
- RgSchDlSf *nxtDlsf;
-#endif
#endif
{
RgSchDlHqProcCb *hqCb;
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to"
+ DU_LOG("\nERROR --> SCH : Unable to"
"Allocate TfuUeRecpReqInfo for RNTI:%d ", ueCb->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
* @param [in] RgSchCellCb *cell
* @param [out] RgSchErrInfo *err
* @param [in] RgSchDlSf *dlSf
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] CmMemListCp *memCp
- * @param [in] U8 elemIdx
+ * @param [in] uint8_t elemIdx
* @param [in] RgSchDlSf *nxtDlsf
-* @param [in] U16 validIdx;
+* @param [in] uint16_t validIdx;
* @return S16
* -# ROK
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkInfo
+static S16 rgSCHTomUtlFillSfHqFdbkInfo
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cellCb,
- RgSchErrInfo *err,
- RgSchDlSf *dlSf,
- U8 noFdbks,
- CmMemListCp *memCp,
- U8 elemIdx,
- RgSchDlSf *nxtDlsf,
- U16 validIdx,
- RgSchDlHqProcCb *hqCb,
- RgSchUePucchRecpInfo *pucchInfo,
- Bool alloc,
- RgSchDlHqProcCb *prvHqCb
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkInfo (recpReqInfo, cellCb, err, dlSf,
- noFdbks, memCp, elemIdx, nxtDlsf, validIdx, hqCb, pucchInfo, alloc, prvHqCb)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cellCb;
-RgSchErrInfo *err;
-RgSchDlSf *dlSf;
-U8 noFdbks;
-CmMemListCp *memCp;
-U8 elemIdx;
-RgSchDlSf *nxtDlsf;
-U16 validIdx;
-RgSchDlHqProcCb *hqCb;
-RgSchUePucchRecpInfo *pucchInfo;
-Bool alloc;
-RgSchDlHqProcCb *prvHqCb;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cellCb,
+RgSchErrInfo *err,
+RgSchDlSf *dlSf,
+uint8_t noFdbks,
+CmMemListCp *memCp,
+uint8_t elemIdx,
+RgSchDlSf *nxtDlsf,
+uint16_t validIdx,
+RgSchDlHqProcCb *hqCb,
+RgSchUePucchRecpInfo *pucchInfo,
+Bool alloc,
+RgSchDlHqProcCb *prvHqCb
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkInfo
+static S16 rgSCHTomUtlFillSfHqFdbkInfo
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cellCb,
- RgSchErrInfo *err,
- RgSchDlSf *dlSf,
- U8 noFdbks,
- CmMemListCp *memCp,
- U8 elemIdx,
- RgSchDlSf *nxtDlsf,
- RgSchDlHqProcCb *hqCb,
- RgSchUePucchRecpInfo *pucchInfo,
- Bool alloc,
- RgSchDlHqProcCb *prvHqCb
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkInfo (recpReqInfo, cellCb, err, dlSf,
- noFdbks, memCp, elemIdx, nxtDlsf, hqCb, pucchInfo, alloc, prvHqCb)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cellCb;
-RgSchErrInfo *err;
-RgSchDlSf *dlSf;
-U8 noFdbks;
-CmMemListCp *memCp;
-U8 elemIdx;
-RgSchDlSf *nxtDlsf;
-RgSchDlHqProcCb *hqCb;
-RgSchUePucchRecpInfo *pucchInfo;
-Bool alloc;
-RgSchDlHqProcCb *prvHqCb;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cellCb,
+RgSchErrInfo *err,
+RgSchDlSf *dlSf,
+uint8_t noFdbks,
+CmMemListCp *memCp,
+uint8_t elemIdx,
+RgSchDlSf *nxtDlsf,
+RgSchDlHqProcCb *hqCb,
+RgSchUePucchRecpInfo *pucchInfo,
+Bool alloc,
+RgSchDlHqProcCb *prvHqCb
+)
#endif
{
S16 ret;
RgrTddAckNackMode ackNackMode;
RgSchDlHqTbCb *tbCb;
CmLteRnti rnti;
- U8 hqSz = 0;
- U32 idx = 0;
+ uint8_t hqSz = 0;
+ uint32_t idx = 0;
#ifndef TFU_UPGRADE
RG_SCH_ADD_TO_CRNT_TIME(cellCb->crntTime, futTime, TFU_RECPREQ_DLDELTA);
else
{
/* Get the TFU reception request pointer, if present */
- cmHashListFind(&cellCb->ueTfuPendLst, (U8*) &ueCb->ueId,
+ cmHashListFind(&cellCb->ueTfuPendLst, (uint8_t*) &ueCb->ueId,
sizeof(ueCb->ueId), 0, (PTR *) &pucchInfo);
}
#else
/* For upgrade we shall use the existing logic of pending list. */
- cmHashListFind(&cellCb->ueTfuPendLst, (U8*) &ueCb->ueId,
+ cmHashListFind(&cellCb->ueTfuPendLst, (uint8_t*) &ueCb->ueId,
sizeof(ueCb->ueId), 0, (PTR *) &pucchInfo);
#endif
}
&&(hqCb != prvHqCb)
)
{
- TknU16 n1PucchTkn = {FALSE, 0};
+ TknUInt16 n1PucchTkn = {FALSE, 0};
RgSchPdcch *pdcch;
- U8 tbIndx;
+ uint8_t tbIndx;
pdcch = tbCb->hqP->pdcch;
#ifdef LTEMAC_SPS
n1PucchTkn = hqCb->spsN1PucchRes;
//if((elemIdx != (noFdbks - 1)))
{
cmHashListInsert(&cellCb->ueTfuPendLst, (PTR) pucchInfo,
- (U8 *)&rnti ,(U16) sizeof(CmLteRnti));
+ (uint8_t *)&rnti ,(uint16_t) sizeof(CmLteRnti));
alloc = FALSE;
}
* Harq Reception Request for Format 1B with
* Channel Selection
*
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] RgSchDlSf *dlSf
* @param [in] RgSchPdcch *pdcch
* @param [in] RgSchCellCb *cellCb
- * @param [out]U16 *hqRes
+ * @param [out]uint16_t *hqRes
* @return void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlGethqRes
+static Void rgSCHTomUtlGethqRes
(
-U8 noFdbks,
-RgSchDlSf *dlSf,
-RgSchPdcch *pdcch,
-RgSchCellCb *cellCb,
-U16 *hqRes
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb,
+uint16_t *hqRes
)
-#else
-PRIVATE Void rgSCHTomUtlGethqRes(noFdbks,dlSf,pdcch,cellCb,hqRes)
-U8 noFdbks;
-RgSchDlSf *dlSf;
-RgSchPdcch *pdcch;
-RgSchCellCb *cellCb;
-U16 *hqRes;
-#endif
{
- U8 M;
- U8 P;
- U8 m;
- U8 nP;
- U8 nPlusOne;
- U8 nCce;
+ uint8_t M;
+ uint8_t P;
+ uint8_t m;
+ uint8_t nP;
+ uint8_t nPlusOne;
+ uint8_t nCce;
M = noFdbks;
m = dlSf->dlFdbkInfo.m;
*hqRes = (M - m - 1)* nP + (m * nPlusOne) + pdcch->nCce +
cellCb->pucchCfg.n1PucchAn;
- RETVOID;
+ return;
}
/** @brief This function fills the harq reception request for
*
* @param [in] RgSchDlHqProcCb *hqCb
* @param [in] TfuUePucchRecpReq *hqRecpReq
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] RgSchDlSf *dlSf
* @param [in] RgSchPdcch *pdcch
* @param [in] RgSchCellCb *cellCb
* @return void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1
(
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- RgSchCellCb *cellCb
+RgSchDlHqProcCb *hqCb,
+TfuUePucchRecpReq *hqRecpReq,
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb
)
-#else
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1(hqCb, hqRecpReq,
- noFdbks,dlSf,pdcch,cellCb)
- RgSchDlHqProcCb *hqCb;
- TfuUePucchRecpReq *hqRecpReq;
- U8 noFdbks;
- RgSchDlSf *dlSf;
- RgSchPdcch *pdcch;
- RgSchCellCb *cellCb;
-#endif
{
- RgSchUeCb *ue = NULLP;
- Bool isCellSec = FALSE;
- U16 hqRes;
+ RgSchUeCb *ue = NULLP;
+ Bool isCellSec = FALSE;
+ uint16_t hqRes;
/*ccpu00147920: UeCb is NULL for SPS activation*/
if(pdcch && pdcch->ue)
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
ue = hqCb->hqE->ue;
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
* mode should be in 2 indices */
if(isCellSec)
{
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqCb->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqCb->hqE->cell->instIdx,
hqCb->hqE->cell->cellId,
hqCb->hqE->ue);
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
default:
break;
}
- RETVOID;
+ return;
}
/** @brief This function fills the harq reception request for
*
* @param [in] RgSchDlHqProcCb *hqCb
* @param [in] TfuUePucchRecpReq *hqRecpReq
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] RgSchDlSf *dlSf
* @param [in] RgSchPdcch *pdcch
* @param [in] RgSchCellCb *cellCb
- * @param [in] U8 elemIdx
+ * @param [in] uint8_t elemIdx
* @return void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234
(
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- RgSchCellCb *cellCb,
- U8 elemIdx
+RgSchDlHqProcCb *hqCb,
+TfuUePucchRecpReq *hqRecpReq,
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb,
+uint8_t elemIdx
)
-#else
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234(
- hqCb,hqRecpReq,noFdbks,dlSf,pdcch,cellCb,elemIdx)
- RgSchDlHqProcCb *hqCb;
- TfuUePucchRecpReq *hqRecpReq;
- U8 noFdbks;
- RgSchDlSf *dlSf;
- RgSchPdcch *pdcch;
- RgSchCellCb *cellCb;
- U8 elemIdx;
-#endif
{
- RgSchUeCb *ue;
- Bool isCellSec = FALSE;
- U16 hqRes = 0;
- U8 servCellIdx;
+ RgSchUeCb *ue;
+ Bool isCellSec = FALSE;
+ uint16_t hqRes = 0;
+ uint8_t servCellIdx;
if(pdcch)
{/* SPS Release pdcch or dynamic data */
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
ue = hqCb->hqE->ue;
}
}
}
- RETVOID;
+ return;
}
/** @brief This function fills the harq reception request for
* @param [out]TfuUePucchRecpReq *hqRecpReq
* @return S16
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForFrmt1BCS
+static S16 rgSCHTomUtlFillSfHqFdbkForFrmt1BCS
(
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- U8 elemIdx,
- RgSchCellCb *cellCb
+RgSchDlHqProcCb *hqCb,
+TfuUePucchRecpReq *hqRecpReq,
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+uint8_t elemIdx,
+RgSchCellCb *cellCb
)
-#else
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForFrmt1BCS(hqCb,hqRecpReq,noFdbks,dlSf,pdcch,
- n1PucchTkn,elemIdx,cellCb)
- RgSchDlHqProcCb *hqCb;
- TfuUePucchRecpReq *hqRecpReq;
- U8 noFdbks;
- RgSchDlSf *dlSf;
- RgSchPdcch *pdcch;
- U8 elemIdx;
- RgSchCellCb *cellCb;
-#endif
{
/* Update teh fdbk mode if something different is present
* in L1 API file for F1BS *//* 1 --> F1BCS */
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForOneUe
+static S16 rgSCHTomUtlFillSfHqFdbkForOneUe
(
RgSchDlHqProcCb *hqCb,
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
-U8 noFdbks,
+uint8_t noFdbks,
CmMemListCp *memCp,
-U8 elemIdx,
+uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
CmLteRnti rnti,
RgrTddAckNackMode ackNackMode,
RgSchUePucchRecpInfo **pucchInfoRef,
RgSchPdcch *pdcch,
-TknU16 n1PucchTkn,
+TknUInt16 n1PucchTkn,
Bool *allocRef,
-U8 hqSz
+uint8_t hqSz
)
-#else
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForOneUe(hqCb,recpReqInfo, cellCb, err, dlSf,
- noFdbks, memCp, elemIdx, nxtDlsf, rnti, ackNackMode, pucchInfoRef,
- pdcch, n1PucchTkn, allocRef, hqSz)
-RgSchDlHqProcCb *hqCb;
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cellCb;
-RgSchErrInfo *err;
-RgSchDlSf *dlSf;
-U8 noFdbks;
-CmMemListCp *memCp;
-U8 elemIdx;
-RgSchDlSf *nxtDlsf;
-CmLteRnti rnti;
-RgrTddAckNackMode ackNackMode;
-RgSchUePucchRecpInfo **pucchInfoRef;
-RgSchPdcch *pdcch;
-TknU16 n1PucchTkn;
-Bool *allocRef;
-U8 hqSz;
-#endif
{
RgSchUePucchRecpInfo *pucchInfo = *pucchInfoRef;
Bool alloc = FALSE;
S16 ret;
TfuUePucchRecpReq *hqRecpReq;
#ifdef TFU_UPGRADE
- U8 M;
- U8 P;
- U8 m;
- U8 nP;
- U8 nPlusOne;
- U16 pucchRes;
- U8 resIdx;
- U8 nCce;
- U8 prevHqSize;
+ uint8_t M;
+ uint8_t P;
+ uint8_t m;
+ uint8_t nP;
+ uint8_t nPlusOne;
+ uint16_t pucchRes;
+ uint8_t resIdx;
+ uint8_t nCce;
+ uint8_t prevHqSize;
#else
- U8 multCnt;
+ uint8_t multCnt;
#endif
#ifdef LTEMAC_SPS
Bool isFirstFdbk = FALSE;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchInfo,
sizeof(RgSchUePucchRecpInfo), memCp)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to "
+ DU_LOG("\nERROR --> SCH : Unable to "
"Allocate TfuUeRecpReqInfo for cell RNTI:%d",rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&(pucchInfo->pucchRecpInfo),
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to "
+ DU_LOG("\nERROR --> SCH : Unable to "
"Allocate TfuUeRecpReqInfo for cell RNTI:%d",rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
- memset(pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(uint16_t)*TFU_MAX_HQ_RES);
#ifdef TFU_ALLOC_EVENT_NO_INIT
memset(&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
#endif
if(anInfo == NULL)
{/* ANInfo must be there. adding block
because of kworks*/
- RGSCHDBGERRNEW(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),
- "ANInfo should not be NULL for cellId=%d \n", cellCb->cellId));
+ DU_LOG("\nERROR --> SCH : ANInfo should not be NULL for cellId=%d \n", cellCb->cellId);
return RFAILED;
}
#endif
}else
{/* This needs to be revisited while
adding support for PUCCH format 3 */
- RGSCHDBGERRNEW(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),"Invalid Pucch format configured.."));
+ DU_LOG("\nERROR --> SCH : Invalid Pucch format configured..");
return RFAILED;
}
}
if((elemIdx != noFdbks) && alloc)
{
cmHashListInsert(&cellCb->ueTfuPendLst, (PTR) pucchInfo,
- (U8 *)&rnti, (U16) sizeof(rnti));
+ (uint8_t *)&rnti, (uint16_t) sizeof(rnti));
alloc = FALSE;
}
else
* @param [out] RgSchErrInfo *err
* @return S16
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcDlSfAtCrc
+static S16 rgSCHTomUtlProcDlSfAtCrc
(
RgSchDlSf *ulSf,
CmLteTimingInfo crntUlFrm,
TfuCntrlReqInfo *cntrlInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlProcDlSfAtCrc (ulSf, crntUlFrm, cell, cntrlInfo, err)
-RgSchDlSf *ulSf;
-CmLteTimingInfo crntUlFrm;
-RgSchCellCb *cell;
-TfuCntrlReqInfo *cntrlInfo;
-RgSchErrInfo *err;
-#endif
{
Inst inst = cell->instIdx;
S16 ret;
/* Fill PHICH info */
if ((ret = rgSCHTomUtlFillPhich (cell, cntrlInfo, ulSf, err)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send PHICH info for "
- "cell");
+ DU_LOG("\nERROR --> SCH : Unable to send PHICH info for cell");
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
/* Fill UL Pdcch */
if ((ret = rgSCHTomUtlFillUlPdcch (cell, cntrlInfo, ulSf, err)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send PDCCH info for "
- "cell");
+ DU_LOG("\nERROR --> SCH : Unable to send PDCCH info for cell");
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
if (cntrlInfo->ulPdcchLst.count || cntrlInfo->phichLst.count)
#endif
{
- if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo)
- != ROK)
+ //if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info for"
- " cell");
+ DU_LOG("\nERROR --> SCH : Unable to send Cntrl info for cell");
}
}
else
*
* @param [in] RgSchCellCb *cell
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlSendSfnTick
+static Void rgSCHTomUtlSendSfnTick
(
RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSCHTomUtlSendSfnTick (cell)
-RgSchCellCb *cell;
-#endif
{
RgrTtiIndInfo *rgrTtiInd;
if (rgSCHUtlAllocSBuf (cell->instIdx,
(Data**)&rgrTtiInd, sizeof(RgrTtiIndInfo)) != ROK)
{
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),
- "Mem alloc failed for RGR TTI ind, cellId (%d))\n",
- cell->cellId));
- RETVOID;
+ DU_LOG("\nERROR --> SCH : Mem alloc failed for RGR TTI ind, cellId (%d))\n",
+ cell->cellId);
+ return;
}
rgrTtiInd->cellId = cell->cellId;
//rgrTtiInd->hSfn = cell->crntTime.hSfn;
if (rgSCHUtlRgrTtiInd (cell, rgrTtiInd) != ROK)
{
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),
- "Failed to send RGR TTI ind, cellId (%d))\n",
- cell->cellId));
+ DU_LOG("\nERROR --> SCH : Failed to send RGR TTI ind, cellId (%d))\n",
+ cell->cellId);
rgSCHUtlFreeSBuf(cell->instIdx, (Data**)&rgrTtiInd,
sizeof(RgrTtiIndInfo));
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
#endif
* @return None
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE Void rgSCHDynTDDMrkCrntSfIdx
-(
-Inst schInst
-)
-#else /* ANSI */
-PRIVATE Void rgSCHDynTDDMrkCrntSfIdx(schInst)
-Inst schInst;
-#endif /* ANSI */
+static Void rgSCHDynTDDMrkCrntSfIdx(Inst schInst)
{
RgSchDynTddCb *rgSchDynTddInfo = &(rgSchCb[schInst].rgSchDynTdd);
rgSchDynTddInfo->crntDTddSfIdx = (rgSchDynTddInfo->crntDTddSfIdx + 1) %
RG_SCH_DYNTDD_MAX_SFINFO;
- //printf("Initializing Index %d \n", rgSchDynTddInfo->crntDTddSfIdx);
+ //DU_LOG("\nERROR --> SCH : Initializing Index %d \n", rgSchDynTddInfo->crntDTddSfIdx);
- RETVOID;
+ return;
}
#endif
#endif
*
* @param [in] TfuTtiIndInfo *ttiInd
* @param [in] Inst schInst
- * @param [out] U8 *nCell
+ * @param [out] uint8_t *nCell
* @param [out] RgSchCellCb *cell[]
*
* Returns: Void
*
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE Void rgSchTomFillCellTtiInfo
+static Void rgSchTomFillCellTtiInfo
(
TfuTtiIndInfo *ttiInd,
Inst schInst,
-U8 *nCell,
+uint8_t *nCell,
RgSchCellCb *cells[]
)
-#else
-PRIVATE Void rgSchTomFillCellTtiInfo (ttiInd, schInst, nCell, cells)
-TfuTtiIndInfo *ttiInd;
-Inst schInst;
-U8 *nCell;
-RgSchCellCb *cells[];
-#endif
{
- U8 i = 0;
- U8 strtCellId;
- TfuTtiCellInfo *cellInfo;
- RgSchCellCb *cell;
- U32 Idx1;
+ uint8_t i = 0;
+ uint8_t strtCellId;
+ TfuTtiCellInfo *cellInfo;
+ RgSchCellCb *cell;
+ uint32_t Idx1;
CmLteTimingInfo frm;
if (CM_LTE_MAX_CELLS < ttiInd->numCells)
{
- RETVOID;
+ return;
}
#ifdef RG_5GTF
{
cellInfo = &ttiInd->cells[i];
strtCellId = rgSchCb[schInst].genCfg.startCellId;
- Idx1 = (U8)((cellInfo->cellId - strtCellId)&(CM_LTE_MAX_CELLS-1));
+ Idx1 = (uint8_t)((cellInfo->cellId - strtCellId)&(CM_LTE_MAX_CELLS-1));
cell = rgSchCb[schInst].cells[Idx1];
/* Validate the cell */
if (cell == NULLP)
{
/* Use SCH inst 0 print buff */
- RGSCHDBGERRNEW(schInst,(rgSchPBuf(schInst),
- "RgLiTfuTtiInd()No cell exists for cellId %d\n",
+ DU_LOG("\nERROR --> SCH : RgLiTfuTtiInd()No cell exists for cellId %d\n",
cellInfo->cellId));
continue;
}
/* 4UE_TTI_DELTA */
if(cell->schTickDelta != cellInfo->schTickDelta)
{
- printf("\nMukesh: Delta changed for cellId=%d: curr delta=%d new delta=%d\n"
+ DU_LOG("\nERROR --> SCH : Delta changed for cellId=%d: curr delta=%d new delta=%d\n"
"dlblankSf=%d ulblankSf=%d dummyTti=%d \n",
cell->cellId, cell->schTickDelta, cellInfo->schTickDelta, cellInfo->dlBlankSf,cellInfo->ulBlankSf,
cellInfo->isDummyTti);
}
if((0 == (cellInfo->timingInfo.sfn % 30)) && (0 == cellInfo->timingInfo.slot))
{
- //printf("5GTF_CHECK rgSCHTOMTtiInd (%d : %d)\n", cellInfo->timingInfo.sfn, cellInfo->timingInfo.slot);
+ //DU_LOG("5GTF_CHECK rgSCHTOMTtiInd (%d : %d)\n", cellInfo->timingInfo.sfn, cellInfo->timingInfo.slot);
}
#ifndef EMTC_ENABLE
RGSCHCPYTIMEINFO(cellInfo->timingInfo, cell->crntTime);
cell->totalTime++;
#endif
#ifdef LTE_TDD
- U8 idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
+ uint8_t idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
RGSCH_NUM_SUB_FRAMES_5G;
cell->isDlDataAllwd = RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, idx);
}
#endif
void schFillCrntTime(
- SlotIndInfo slotInd,
+ SlotTimingInfo slotInd,
Inst schInst)
{
- U8 cellCount = 0;
+ uint8_t cellCount = 0;
for(cellCount = 0; cellCount < CM_LTE_MAX_CELLS; cellCount++)
{
RgSchCellCb *cell;
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiUlAndDlCmnChSch
+static Void rgSchTomTtiUlAndDlCmnChSch
(
RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiUlAndDlCmnChSch (cell)
-RgSchCellCb *cell;
-#endif
{
cell->rlsHqArr[cell->crntHqIdx].numUes = 0;
*/
#ifndef RG_ULSCHED_AT_CRC
{
- U8 Mval = 1;
- U8 idx; /* Index into Uplink Sf array */
+ uint8_t Mval = 1;
+ uint8_t idx; /* Index into Uplink Sf array */
#ifdef LTE_TDD
Mval = rgSchTddPhichMValTbl[cell->ulDlCfgIdx]
[cell->hiDci0Time.subframe];
/* Perform DL scheduling for Common channels */
rgSCHCmnDlCommonChSch(cell);
- RETVOID;
+ return;
}
/** @brief This function invokes the Non critical procedures like measurements,
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiMiscFunctions
+static Void rgSchTomTtiMiscFunctions
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiMiscFunctions (cell)
-RgSchCellCb *cell;
-#endif
{
- U8 suId = cell->tfuSap->sapCfg.suId;
+ uint8_t suId = cell->tfuSap->sapCfg.suId;
/* Invoke RAM Tti Handler */
rgSCHRamTtiHndlr(cell);
(cell->lteAdvCb.absCfg.absLoadPeriodicity))
{
RgrLoadInfIndInfo *rgrLoadInf;
- U8 idx;
+ uint8_t idx;
cell->lteAdvCb.absLoadTtiCnt++;
if(cell->lteAdvCb.absLoadTtiCnt >= cell->lteAdvCb.absCfg.absLoadPeriodicity)
if(rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&rgrLoadInf,
sizeof(RgrLoadInfIndInfo)) != ROK)
{
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"Could not "
- "allocate memory for sending LoadInfo\n"));
- RETVOID;
+ DU_LOG("\nERROR --> SCH : Could not "\
+ "allocate memory for sending LoadInfo\n");
+ return;
}
cell->lteAdvCb.absLoadTtiCnt = 0;
rgrLoadInf->cellId = cell->cellId;
#endif
/* LTE_ADV_FLAG_REMOVED_END */
- RETVOID;
+ return;
}
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiDlSch
+static Void rgSchTomTtiDlSch
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiDlSch (cell)
-RgSchCellCb *cell;
-#endif
{
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
rgSCHCmnDlSch(cell);
}
- RETVOID;
+ return;
}
/** @brief This function invokes Consolidates the allocations
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiCnsldtSfAlloc
+static Void rgSchTomTtiCnsldtSfAlloc
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiCnsldtSfAlloc (cell)
-RgSchCellCb *cell;
-#endif
{
RgSchDlSf *dlSf;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
rgSCHTomUtlProcTA(cell);
- RETVOID;
+ return;
}
/** @brief This function prepares the DL and UL Config requests
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiL1DlAndUlCfg
+static Void rgSchTomTtiL1DlAndUlCfg
(
RgSchCellCb *cell,
RgTfuCntrlReqInfo *cntrlInfo
)
-#else
-PRIVATE Void rgSchTomTtiL1DlAndUlCfg (cell, cntrlInfo)
-RgSchCellCb *cell;
-RgTfuCntrlReqInfo *cntrlInfo;
-#endif
{
RgSchDlSf *dlSf = rgSCHUtlSubFrmGet (cell, cell->dlDciTime);
RgSchDlSf *ulSf = rgSCHUtlSubFrmGet (cell, cell->hiDci0Time);
rgSCHTomUtlProcUlSf (cell, &err);
#endif
- RETVOID;
+ return;
}
#ifdef LTE_TDD
/** @brief This function prepares does the Downlink subframe re-init and
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomUtlTddRlsSfAndHarq
+static Void rgSchTomUtlTddRlsSfAndHarq
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomUtlTddRlsSfAndHarq (cell)
-RgSchCellCb *cell;
-#endif
{
/* ccpu00132341-MOD- rgSchTddRlsDlSubfrmTbl is dependent on DELTA(=2).
rgSCHDhmTddRlsSubFrm(cell, cell->hqRlsTime);
rgSCHDhmRlsDlsfHqProc(cell, cell->hqRlsTime);
}
- RETVOID;
+ return;
}
/** @brief This function processes the UL subframe and fills TFU reception
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlProcTddUlSf
-(
-RgSchCellCb *cell
-)
-#else
-PRIVATE Void rgSCHTomUtlProcTddUlSf (cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHTomUtlProcTddUlSf(RgSchCellCb *cell)
{
RgSchErrInfo err;
if (rgSCHTomUtlProcUlSf (cell, &err) != ROK)
{
/* fill in err type and call sta ind */
- RGSCHDBGERRNEW(cell->instIdx, (rgSchPBuf(cell->instIdx),
- "Unable to process Uplink subframe for cellId (%d))\n",
- cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to process Uplink subframe for cellId (%d))\n", cell->cellId);
}
}
/* TDD Fix , to allow Special SF SRS CFg */
if (rgSCHTomUtlPrcUlTddSpclSf(cell, &err) != ROK)
{
/* fill in err type and call sta ind */
- RGSCHDBGERRNEW(cell->instIdx, (rgSchPBuf(cell->instIdx),
- "Unable to process Sipceial subframe for cellId (%d))\n",
- cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to process Sipceial subframe for cellId (%d))\n", cell->cellId);
}
}
- RETVOID;
+ return;
}
#endif
Code Review / o-du / l2.git / blobdiff