@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 "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system services */
-#include "cm5.h" /* common timers defines */
-#include "cm_hash.h" /* common hash list defines */
-#include "cm_llist.h" /* common linked list defines */
-#include "cm_mblk.h" /* memory management */
-#include "cm_tkns.h" /* common tokens */
-#include "cm_lte.h" /* common tokens */
+#include "common_def.h"
#include "tfu.h" /* RGU defines */
#include "lrg.h" /* layer management defines for LTE-MAC */
#include "rgr.h" /* layer management defines for LTE-MAC */
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
#include "tfu.x" /* RGU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "rgr.x" /* layer management typedefs for MAC */
#ifdef EMTC_ENABLE
#include "rg_sch_emtc_ext.x"
#endif
-U8 rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,U8 numTxAnt);
-PUBLIC S16 rgSCHDhm5gtfHqFdbkInd(RgSchUeCb *ue,RgSchCellCb *cell,CmLteTimingInfo timingInfo,TfuHqFdbk fdbk,RgSchErrInfo *err);
+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
);
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
+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
+));
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
+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
+));
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
+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
+));
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
+S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres
+));
-PUBLIC void schFillCrntTime(
- SlotIndInfo slotInd,
- Inst schInst);
+void schFillCrntTime( SlotIndInfo 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 */
-PUBLIC U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
-PUBLIC 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));
#endif
#ifdef TFU_UPGRADE
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq ARGS
+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
+));
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
+S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
((
- RgSchUeCb *ueCb
+RgSchUeCb *ueCb
));
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz ARGS
+uint8_t rgSCHTomUtlFetchPcqiBitSz ARGS
((
RgSchUeCb *ueCb,
-U8 numTxAnt,
-U8 *ri
+uint8_t numTxAnt,
+uint8_t *ri
));
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
+uint8_t rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
((
RgSchUeCb *ueCb,
TfuCqiPucchMode21 *mode21Info,
-U8 numTxAnt,
-U8 *ri
+uint8_t numTxAnt,
+uint8_t *ri
));
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion ARGS
+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 PUBLIC 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*/
-PUBLIC 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},
{0,0,0,0,1,6,21,56,126,252,462,792,1287,2002,3003,4368,6188,8568,11628,15504,20349,26334,33649,42504,53130,65780,80730,98280},
{0,0,0,0,0,1,7,28,84,210,462,924,1716,3003,5005,8008,12376,18564,27132,38760,54264,74613,100947,134596,177100,230230,296010,376740}
};
-
+*/
/*ccpu00116923 - ADD - SRS present support*/
/*Tables Derived from 3GPP TS 36.211 Section 5.5.3.3 */
/* Table 5.5.3.3-1 */
#ifndef LTE_TDD
-CONSTANT PUBLIC 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 PUBLIC 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},
{FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE}
};
#endif
-PUBLIC S8 rgSchCmnAper20n22DiffCqi[4] = {1, 2, 3, 4};
-PUBLIC S8 rgSchCmnAper30n31DiffCqi[4] = {0, 1, 2, -1};
+S8 rgSchCmnAper20n22DiffCqi[4] = {1, 2, 3, 4};
+S8 rgSchCmnAper30n31DiffCqi[4] = {0, 1, 2, -1};
#endif
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHGetDedPrmUe
+S16 rgSCHGetDedPrmUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo,
RgSchUeCb **ue
)
-#else
-PUBLIC 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");
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for processing Random Access request indication
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomRaReqInd
+S16 rgSCHTomRaReqInd
(
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd
)
-#else
-PUBLIC 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;
-
- TRC2(rgSCHTomRaReqInd);
+ 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);
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (raRntiCnt = 0; raRntiCnt < raReqInd->nmbOfRaRnti; raRntiCnt++)
#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;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomRaReqInd */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUlCqiInd
+S16 rgSCHTomUlCqiInd
(
RgSchCellCb *cell,
TfuUlCqiIndInfo *ulCqiInd
)
-#else
-PUBLIC S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
-RgSchCellCb *cell;
-TfuUlCqiIndInfo *ulCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
TfuUlCqiRpt *ulCqiInfo;
- TRC2(rgSCHTomUlCqiInd);
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);
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (;node; node=node->next)
#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;
}
}
/* wideband cqi is directly reported now. and also isTxPort0 */
rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUlCqiInd */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomPucchDeltaPwrInd
+S16 rgSCHTomPucchDeltaPwrInd
(
RgSchCellCb *cell,
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
)
-#else
-PUBLIC S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
-RgSchCellCb *cell;
-TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
TfuPucchDeltaPwr *ueElem;
- TRC2(rgSCHTomPucchDeltaPwrInd);
-
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);
- RETVALUE(RFAILED);
+ return RFAILED;
}
node = pucchDeltaPwr->pucchDeltaPwrLst.first;
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;
}
rgSCHUtlPucchDeltaPwrInd(cell, ue, ueElem->pucchDeltaPwr);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomPucchDeltaPwrInd */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomHarqAckInd
+S16 rgSCHTomHarqAckInd
(
RgSchCellCb *cell,
TfuHqIndInfo *harqAckInd
)
-#else
-PUBLIC 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;
- TRC2(rgSCHTomHarqAckInd);
-
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;
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
#ifdef RG_5GTF
node = harqAckInd->hqIndLst.first;
for (;node; node=node->next)
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;
}
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomHarqAckInd */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomSrInd
+S16 rgSCHTomSrInd
(
RgSchCellCb *cell,
TfuSrIndInfo *srInd
)
-#else
-PUBLIC S16 rgSCHTomSrInd(cell, srInd)
-RgSchCellCb *cell;
-TfuSrIndInfo *srInd;
-#endif
{
S16 ret = RFAILED;
RgSchErrInfo err;
CmLList *node;
TfuSrInfo *srInfo;
- TRC2(rgSCHTomSrInd);
-
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;
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = srInd->srLst.first;
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;
}
}
- RETVALUE(ret);
+ return ROK;
} /* end of rgSCHTomSrInd */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomDoaInd
+S16 rgSCHTomDoaInd
(
RgSchCellCb *cell,
TfuDoaIndInfo *doaInd
)
-#else
-PUBLIC S16 rgSCHTomDoaInd(cell, doaInd )
-RgSchCellCb *cell;
-TfuDoaIndInfo *doaInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
TfuDoaRpt *doaInfo;
- TRC2(rgSCHTomDoaInd);
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);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = doaInd->doaRpt.first;
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;
}
rgSCHUtlDoaInd(cell, ue, doaInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomDoaInd */
/**
* @brief Handler for processing downlink CQI indication recieved from
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomDlCqiInd
+S16 rgSCHTomDlCqiInd
(
RgSchCellCb *cell,
TfuDlCqiIndInfo *dlCqiInd
)
-#else
-PUBLIC S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
-RgSchCellCb *cell;
-TfuDlCqiIndInfo *dlCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
TfuDlCqiRpt *dlCqiInfo;
- TRC2(rgSCHTomDlCqiInd);
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);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = dlCqiInd->dlCqiRptsLst.first;
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;
}
rgSCHUtlDlCqiInd(cell, ue, dlCqiInfo, dlCqiInd->timingInfo);
rgSCHUtlHdlUlTransInd(cell, ue, dlCqiInd->timingInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomDlCqiInd */
/**
* -# 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;
- TRC2(rgSCHTomUtlMovePcqiNxtOccasion);
if(cqiCb->cqiCfg.cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP)
{
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;
rgSCHUtlSCellHndlCqiCollsn(cqiCb);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMovePcqiNxtOccasion */
/**
* -# 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;
-
- TRC2(rgSCHTomUtlMovePriNxtOccasion);
+ 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);
#ifdef XEON_SPECIFIC_CHANGES
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);
#ifdef LTE_ADV
rgSCHUtlSCellHndlRiCollsn(riCb);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMovePriNxtOccasion */
/**
* -# 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;
-
- TRC2(rgSCHTomUtlMoveSrNxtOccasion);
+ 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;
cmLListAdd2Tail(&cell->pCqiSrsSrLst[ue->srCb.nSrTrIdx].srLst,
&ue->srCb.srLstEnt);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMoveSrNxtOccasion */
/**
* -# 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;
- TRC2(rgSCHTomUtlMoveSrsNxtOccasion);
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
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,
}
ue->srsCb.nSrsTrIdx = srsIdx;
ue->srsCb.srsDist = srsDist;
-
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMoveSrsNxtOccasion */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomRawCqiInd
+S16 rgSCHTomRawCqiInd
(
- RgSchCellCb *cell,
- TfuRawCqiIndInfo *rawCqiInd
+RgSchCellCb *cell,
+TfuRawCqiIndInfo *rawCqiInd
)
-#else
-PUBLIC 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;
-
- TRC2(rgSCHTomRawCqiInd);
+ 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);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = rawCqiInd->rawCqiRpt.first;
/*
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;
}
rlsHqBufs->numUes = 0;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomRawCqiInd */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomSrsInd
+S16 rgSCHTomSrsInd
(
- RgSchCellCb *cell,
- TfuSrsIndInfo *srsInd
- )
-#else
-PUBLIC S16 rgSCHTomSrsInd(cell, srsInd)
- RgSchCellCb *cell;
- TfuSrsIndInfo *srsInd;
-#endif
+RgSchCellCb *cell,
+TfuSrsIndInfo *srsInd
+)
{
RgSchUeCb *ue;
CmLList *node;
TfuSrsRpt* srsInfo;
- TRC2(rgSCHTomSrsInd);
-
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);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = srsInd->srsRpt.first;
for (;node; node=node->next)
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;
}
rgSCHUtlSrsInd(cell, ue, srsInfo, srsInd->timingInfo);
rgSCHUtlHdlUlTransInd(cell, ue, srsInd->timingInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomSrsInd */
/*
*
*/
#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++)
{
xmin = idx+1;
label = label-binCoe;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlGenIndices*/
#endif
#endif
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomCrcInd
+S16 rgSCHTomCrcInd
(
RgSchCellCb *cell,
TfuCrcIndInfo *crcInd
)
-#else
-PUBLIC 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
RgSchUlHqProcCb *ulHqProc;
#endif
- TRC2(rgSCHTomCrcInd);
-
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);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
#ifdef RG_ULSCHED_AT_CRC
#ifndef LTE_ADV
{
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");
- RETVALUE(ret);
+ return ret;
}
rgSCHCmnUlSch(cell);
#ifdef LTE_L2_MEAS
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;
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
#endif /* RG_ULSCHED_AT_CRC */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomCrcInd */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomTimingAdvInd
+S16 rgSCHTomTimingAdvInd
(
RgSchCellCb *cell,
TfuTimingAdvIndInfo *timingAdvInd
- )
-#else
-PUBLIC S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
-RgSchCellCb *cell;
-TfuTimingAdvIndInfo *timingAdvInd;
-#endif
+)
{
RgSchUeCb *ue;
CmLList *node;
TfuTimingAdvInfo *timingAdvInfo;
-
- TRC2(rgSCHTomTimingAdvInd);
-
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);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = timingAdvInd->timingAdvLst.first;
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;
}
rgSCHDhmUpdTa (cell, ue, timingAdvInfo->timingAdv);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomTimingAdvInd */
/**
* @param[in] Inst schInst
* @return Void
**/
-#ifdef ANSI
-PUBLIC Void rgSCHTomTtiInd
+Void rgSCHTomTtiInd
(
SlotIndInfo *slotInd,
Inst schInst
)
-#else
-PUBLIC 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];
- TRC2(rgSCHTomTtiInd);
-
#ifdef LTE_L2_MEAS
glblTtiCnt++;
#endif
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;
- TRC2(rgSCHTomUtlProcUlSf)
-
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;
- RETVALUE(ret);
+ return ret;
}
recpReqInfo->cellId = cell->cellId;
cmLListInit(&recpReqInfo->ueRecpReqLst);
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);
- RETVALUE(ret);
+ return ret;
}
/* Filling HARQ Reception requests */
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);
- RETVALUE(ret);
+ 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");
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlProcUlSf */
#ifdef LTE_TDD
* -# 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;
- TRC2(rgSCHTomUtlPrcUlTddSpclSf)
-
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;
- RETVALUE(ret);
+ return ret;
}
recpReqInfo->cellId = cell->cellId;
cmLListInit(&recpReqInfo->ueRecpReqLst);
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);
- RETVALUE(ret);
+ 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");
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlPrcUlTddSpclSf */
#endif
#endif
* @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 */
-
- TRC2(rgSCHTomUtlProcDlSf);
+ 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);
- RETVALUE(ret);
+ 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);
- RETVALUE(ret);
+ return ret;
}
}
#ifdef EMTC_ENABLE
/* 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);
- RETVALUE(ret);
+ return ret;
}
rgBwAlloInfo[dlSf->sfNum] += dlSf->bwAssigned;
rgBwAlcnt[dlSf->sfNum] ++;
#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;
- RETVALUE(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;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
#endif
- TRC2(rgSCHTomUtlFillPhich)
ret = ROK;
/* Traversing the list of Phichs */
node = dlSf->phichInfo.phichs.first;
&(cntrlInfo->memCp))) != ROK)
{
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
harqAck->txPower = 0;
harqAck->lnk.node = (PTR)harqAck;
node = node->next;
} /* end of while */
- RETVALUE(ret);
+ return ret;
} /* end of */
* @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;
- TRC2(rgSCHTomUtlFillDlPdcch)
ret = ROK;
/* Traversing the scheduled Harq processes */
node = dlSf->pdcchInfo.pdcchs.first;
&(cntrlInfo->memCp))) != ROK)
{
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef LTEMAC_SPS
tfuPdcch->crnti = pdcch->crnti;
gDlNumUePerTti[numUePerTti-1]++;
}
}
- RETVALUE(ret);
+ return ret;
} /* 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;
- TRC2(rgSCHTomUtlFillUlPdcch)
ret = ROK;
/* Traversing the scheduled Harq processes */
node = dlSf->pdcchInfo.pdcchs.first;
&(cntrlInfo->memCp))) != ROK)
{
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
tfuPdcch->rnti = pdcch->rnti;
#ifdef LTE_ADV
// abort();
}
#endif
- RETVALUE(ret);
+ return ret;
} /* end of rgSCHTomUtlFillUlPdcch*/
/** @brief This function does the processing for Timing adjustment.
* -# 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;
- TRC2(rgSCHTomUtlProcTA);
-
node = cell->taUeLst.first;
while (node)
{
ue->dl.taCb.numRemSf--;
}
} /* end of taUeLst */
-
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlProcTA */
/** @brief This function handles filling of Hq reception request to
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo
+S16 rgSCHTomUtlFillHqFdbkInfo
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- U16 validIdx,
- RgSchDlHqProcCb *hqCb,
- RgSchDlSf *nxtDlsf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchDlHqProcCb *prvHqCb,
- RgSchErrInfo *err
- )
-#else
-PUBLIC 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
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo
+S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchDlHqProcCb *prvHqCb,
RgSchErrInfo *err
)
-#else
-PUBLIC 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;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
if ((hqCb->hqE->ue != NULLP) /*&&
break;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkInfo */
#ifdef RG_5GTF
*
* @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;
- CmLList *hqPNode;
RgSchUeCb *ue;
TfuUePucchRecpReq *pucchReqInfo = NULLP;
- hqPNode = dlSfHqInfo->hqPLst.first;
ue = (RgSchUeCb*)dlSfHqInfo->dlSfUeLnk.node;
if (ue == NULLP)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
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;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchRecpInfo->rnti = ue->ueId; /* Even for Rel pdcch also setting CRNTI
cmLListAdd2Tail(&recpReqInfo->ueRecpReqLst, &(pucchRecpInfo->lnk));
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkForFrmt1B */
#endif
*
* @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;
if (ue == NULLP)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
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;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchRecpInfo->rnti = ue->ueId; /* Even for Rel pdcch also setting CRNTI
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = ue->f1bCsAVal;
- cmMemset((U8 *)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] =
#endif/*TFU_UPGRADE*/
cmLListAdd2Tail(&recpReqInfo->ueRecpReqLst, &(pucchRecpInfo->lnk));
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkForFrmt1B */
/** @brief This function handles filling of Hq reception request to
* Per Hq Proc.
*
* @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
if (ue == NULLP)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
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;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchRecpInfo->rnti = ue->ueId; /* Even for Rel pdcch also setting CRNTI
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = 1;
- cmMemset((U8 *)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
#endif/*TFU_UPGRADE*/
cmLListAdd2Tail(&recpReqInfo->ueRecpReqLst, &(pucchRecpInfo->lnk));
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkForFrmt3 */
#endif/*LTE_ADV*/
* -# 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;
RgSchUeCb *ue;
RgSchDlHqProcCb *prvHqCb=NULLP;
- TRC2(rgSCHTomUtlFillHqFdbkRecpReq);
-
#ifdef CA_DBG
{
gF1bCsPres = FALSE;
/* Check with TDD Code */
/* FOR ACK NACK REP */
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlFillHqFdbkRecpReq */
#ifdef TFU_UPGRADE
/** @brief This function handles filling of SR reception request to
* -# 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;
#endif
- TRC2(rgSCHTomUtlFillSrRecpReq);
-
isAddToLst = FALSE;
node = cell->pCqiSrsSrLst[validIdx].srLst.first;
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;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
/*Fill SR params*/
}
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillSrRecpReq */
#endif
#endif
* -# 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
+)
{
- TRC2(rgSCHTomUtlWillUeRprtCqiRi);
-
/* Intialising Reporting probability as TRUE */
*willueRprtCqiRi = TRUE;
{/*onDuration NOT running, do not expect cqi/pmi/ri*/
*willueRprtCqiRi = FALSE;
}
- RETVALUE(ROK);
- }
+ return ROK;
+ }
#endif /*end of LTEMAC_R9*/
/* ccpu00134258: Fix for CQI DRX issue*/
if(ue->drxCb->onDurTmrLen > 2)
}
}
}/*ue->isDrxEnabled*/
-
- RETVALUE(ROK);
+ return ROK;
} /*End of rgSCHTomUtlWillUeRprtCqiRi*/
/** @brief This function handles filling of RI reception request to
*
* @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;
Bool willUeRprtCqi; /* Flag set due to CQI Mask
and UE inactive state (DRX) */
RgSchUePCqiCb *riCb = NULLP;
- TRC2(rgSCHTomUtlFillRiRecpReq);
node = cell->pCqiSrsSrLst[validIdx].riLst.first;
while(node)
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;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
/*Fill RI params*/
riCb->riDist--;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillRiRecpReq */
#endif
#ifdef RG_5GTF
*
* @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;
-
- TRC2(rgSCHTomUtlFillCqiRiRecpReq);
+ 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;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
pucchRecpInfo->rnti = ue->ueId;
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
}
}
-
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillCqiRiRecpReq */
#endif
#endif
*
* @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;
- TRC2(rgSCHTomUtlFillPcqiRecpReq);
-
node = cell->pCqiSrsSrLst[validIdx].cqiLst.first;
while(node)
{
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;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
}
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillPcqiRecpReq */
/** @brief This function handles filling of SRS reception request to
* PHY.
*
* @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;
S16 ret;
RgSchUeCb *ue;
- TRC2(rgSCHTomUtlFillSrsRecpReq);
-
node = cell->pCqiSrsSrLst[validIdx].srsLst.first;
while(node)
{
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;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
ue->srsCb.srsDist--;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillSrsRecpReq */
#endif
#ifndef TFU_UPGRADE
* -# 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;
TfuUeRecpReqInfo *datRecpInfo;
- TRC2(rgSCHTomUtlFillDatRecpReq)
/* processing steps are
* - Run through the UL allocations going out in this subframe.
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;
- RETVALUE(ret);
+ return ret;
}
if (!alloc->forMsg3)
{
alloc = rgSCHUtlNextRcptnReq (cell, alloc);
} /* end of while */
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlFillDatRecpReq */
#else
*
* @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 hqPres; /*Set when HARQ Rec Req is present*/
Bool isAperiodic = FALSE; /*Set when Aperiodic CQI is expected */
- U8 numUePerTti = 0;
-
- TRC2(rgSCHTomUtlFillDatRecpReq);
+ 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;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
datRecpInfo->t.puschRecpReq.initialNSrs.pres = FALSE;
datRecpInfo->t.puschRecpReq.initialNumRbs.pres = FALSE;
#endif
datRecpInfo->type = TFU_RECP_REQ_PUSCH;
- /* ccpu00131944 - Intializing hqPres in each iteration*/
- hqPres = FALSE;
/* Check if this if for MSG3 - no scope for feedback along with it. */
if ((FALSE == alloc->forMsg3))
{
cell->ulNumUeSchedPerTti[numUePerTti-1]++;
gUlNumUePerTti[numUePerTti - 1]++;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlFillDatRecpReq */
#endif
/* rg009.201. Added changes of TFU_UPGRADE */
* File :
*
**********************************************************/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo
+S16 rgSCHTomUtlFillRiBitWidthInfo
(
- RgSchUeCb *ueCb
- )
-#else
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
- RgSchUeCb *ueCb;
-#endif
+RgSchUeCb *ueCb
+)
{
RgSchUePCqiCb *riCb = ueCb->nPRiCb;
- TRC2(rgSCHTomUtlFillRiBitWidthInfo);
if (ueCb->mimoInfo.txMode != RGR_UE_TM_3 &&
ueCb->mimoInfo.txMode != RGR_UE_TM_4)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ueCb->rawCqiBitW[ueCb->cqiRiWritIdx].type = TFU_RECP_REQ_PUCCH;
ueCb->rawCqiBitW[ueCb->cqiRiWritIdx].u.pucch.pucchRawCqiInfo.mode=
}
RG_SCH_INCR_CQIRI_INDEX(ueCb->cqiRiWritIdx);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
* 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
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz
+uint8_t rgSCHTomUtlFetchPcqiBitSz
(
- RgSchUeCb *ueCb,
- U8 numTxAnt,
- U8 *ri
- )
-#else
-PUBLIC 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;
TfuCqiPucchMode21 *mode21Info;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHTomUtlFetchPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
}
RG_SCH_INCR_CQIRI_INDEX(ueCb->cqiRiWritIdx);
- RETVALUE(pcqiSz);
+ return pcqiSz;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlPcqiSbCalcBpIdx
+S16 rgSCHTomUtlPcqiSbCalcBpIdx
(
- CmLteTimingInfo crntTimInfo,
- RgSchUeCb *ueCb,
- RgSchUePCqiCb *cqiCb
- )
-#else
-PUBLIC 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;
- TRC2(rgSCHTomUtlPcqiSbCalcBpIdx);
if((prdNum % cqiCb->h) == 0)
{
cqiCb->isWb = TRUE;
cqiCb->prioLvl = RG_SCH_CQI_PRIO_LVL_0;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
*
* @param[in] RgSchCellCb *cell,
* RgSchUeCb *ue,
- * U16 validIdx
+ * uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion
+S16 rgSCHTomUtlMoveNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- U16 validIdx
- )
-#else
-PUBLIC 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;
- TRC2(rgSCHTomUtlMoveNxtOccasion);
/* ccpu00140578::Skip the UE if already RI recpetion
* is processed in the same subframe */
{
rgSCHTomUtlMoveSrNxtOccasion(cell, ue);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMoveNxtOccasion */
* to aid decoding of Aperiodic CQI.
*
* Ret : Void
- * ROK - RETVOID
+ * ROK - void
*
* Notes:
*
* File :
*
**********************************************************/
-#ifdef ANSI
-PUBLIC Void rgSCHTomPrepareAcqiRecp
+Void rgSCHTomPrepareAcqiRecp
(
- RgSchUeCb *ueCb,
- RgSchCellCb *cell,
- TfuUePuschCqiRecpInfo *cqiRecpReqInfo,
- U8 ccIdx
- )
-#else
-PUBLIC 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;
- TRC2(rgSCHTomPrepareAcqiRecp);
-
/* Fill TFU Recp */
cqiRecpReqInfo->reportType = TFU_APERIODIC_CQI_TYPE; /* Aperiodic */
if (ueCb->mimoInfo.txMode == RGR_UE_TM_3 ||
default:
break;
}
- RETVOID;
+ return;
}
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq
+S16 rgSCHTomUtlFillDatAperRecpReq
(
- RgSchCellCb *cell,
- U8 cqiReq,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- )
-#else
-PUBLIC 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
- TRC2(rgSCHTomUtlFillDatAperRecpReq);
/*Fill RI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatAperRecpReq */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq
+S16 rgSCHTomUtlFillDatPriRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- )
-#else
-PUBLIC 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;
- TRC2(rgSCHTomUtlFillDatPriRecpReq);
/*Fill RI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatPriRecpReq */
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq
+S16 rgSCHTomUtlFillDatPCqiRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- U16 validIdx
- )
-#else
-PUBLIC 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;
-
- TRC2(rgSCHTomUtlFillDatPCqiRecpReq);
-
+ 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);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fill only the first RI index since Periodic can come
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatPCqiRecpReq */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq
+S16 rgSCHTomUtlFillDatSrsRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres
- )
-#else
-PUBLIC 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
+)
{
- TRC2(rgSCHTomUtlFillDatSrsRecpReq);
datRecpInfo->rnti = alloc->rnti;
rgSCHTomFillOnlySrsRecpReq(cell,alloc, datRecpInfo);
if(hqPres)
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatSrsRecpReq */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq
+S16 rgSCHTomFillOnlySrsRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo
- )
-#else
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo
+)
{
TfuUePuschSrsRecpInfo *srsRecpReqInfo;
- TRC2(rgSCHTomFillOnlySrsRecpReq);
srsRecpReqInfo = &datRecpInfo->t.puschRecpReq.srsInfo;
srsRecpReqInfo->srsBw = (TfuUlSrsBwInfo)alloc->ue->srsCb.srsCfg.srsSetup.srsBw;
* Refer Section 5.2.2.6 of TS 36.212 V8.5.0*/
datRecpInfo->t.puschRecpReq.ulSchInfo.nSrs = 1;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomFillOnlySrsRecpReq */
/**
* 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
RgSchEmtcUeInfo *emtcUe = NULLP;
#endif
- TRC2(rgSCHTomUtlFillCqiSrSrsWithHq);
-
if(ue)
{
/*Changes for PUCCH Format3 */
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);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
+ return RFAILED;
}
if(pucchRecpInfo->t.pucchRecpReq.uciInfo == TFU_PUCCH_HARQ_SR)
{
}
}
UNUSED(dropCqi);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillCqiSrSrsWithHq */
/**
* 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)*/
- TRC2(rgSCHTomUtlFillCqiSrsWithSr);
-
riCb = ue->nPRiCb;
cqiCb = ue->nPCqiCb;
rgSCHTomUtlWillUeRprtCqiRi(ue, &willUeRprtCqi);
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);
- RETVALUE(RFAILED);
- }
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
+ return RFAILED;
+ }
pucchRecpInfo->t.pucchRecpReq.uciInfo = TFU_PUCCH_SR_CQI;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillCqiSrsWithSr */
#endif
* @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;
RgSchDlHqTbCb *tbCb;
RgSchDlHqProcCb *prvHqCb = NULLP;
- TRC2(rgSCHTomUtlFillSfRepHqFdbk)
-
node = dlSf->ackNakRepQ.first;
while (node)
{
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;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->rnti = ueCb->ueId;
#ifndef TFU_UPGRADE
/* Go to the next node */
node = node->next;
}
-
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function handles filling of HARQ feedback recption request
* @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;
-
- TRC2(rgSCHTomUtlFillSfHqFdbkInfo)
+ uint8_t hqSz = 0;
+ uint32_t idx = 0;
#ifndef TFU_UPGRADE
RG_SCH_ADD_TO_CRNT_TIME(cellCb->crntTime, futTime, TFU_RECPREQ_DLDELTA);
if((anInfo == NULLP) ||
(anInfo->latestMIdx != dlSf->dlFdbkInfo.m))
{
- RETVALUE(ROK);
- }
+ return ROK;
+ }
}
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
}
}
else
{
- RETVALUE(ROK);
+ return ROK;
}
/* Do not proceed if PUSCH
&&(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;
n1PucchTkn, &alloc, hqSz);
if (ret != ROK)
{
- RETVALUE(ret);
+ return ret;
}
/* TODO:: In case of F1BCS and CSI in same subframe
* UE shall drop the CSI if there was at least one
//if((elemIdx != (noFdbks - 1)))
{
cmHashListInsert(&cellCb->ueTfuPendLst, (PTR) pucchInfo,
- (U8 *)&rnti ,(U16) sizeof(CmLteRnti));
+ (uint8_t *)&rnti ,(uint16_t) sizeof(CmLteRnti));
alloc = FALSE;
}
prvHqCb = hqCb;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_ADV
* 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 */
default:
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
* 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;
- RETVALUE(ret);
+ return ret;
}
alloc = TRUE;
#ifdef TFU_ALLOC_EVENT_NO_INIT
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;
- RETVALUE(ret);
+ return ret;
}
- cmMemset((U8 *)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
- cmMemset((U8 *)&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
#endif
pucchInfo->pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchInfo->pucchRecpInfo->rnti = rnti;
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));
- RETVALUE(RFAILED);
-
+ 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.."));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : Invalid Pucch format configured..");
+ return RFAILED;
}
}
else
if((elemIdx != noFdbks) && alloc)
{
cmHashListInsert(&cellCb->ueTfuPendLst, (PTR) pucchInfo,
- (U8 *)&rnti, (U16) sizeof(rnti));
+ (uint8_t *)&rnti, (uint16_t) sizeof(rnti));
alloc = FALSE;
}
else
*pucchInfoRef = pucchInfo;
*allocRef = alloc;
- RETVALUE(ROK);
+ return ROK;
}
#endif
* @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;
- TRC2(rgSCHTomUtlProcDlSfAtCrc);
-
-
cntrlInfo->numDlActvUes = 0;
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
/* 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);
- RETVALUE(ret);
+ 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);
- RETVALUE(ret);
+ return ret;
}
#ifdef EMTC_ENABLE
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
{
RGSCH_FREE_MEM(cntrlInfo);
}
-
- RETVALUE(ROK);
+ return ROK;
} /* end of */
#endif /* #ifdef RG_ULSCHED_AT_CRC*/
*
* @param [in] RgSchCellCb *cell
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlSendSfnTick
+static Void rgSCHTomUtlSendSfnTick
(
RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSCHTomUtlSendSfnTick (cell)
-RgSchCellCb *cell;
-#endif
{
RgrTtiIndInfo *rgrTtiInd;
- TRC2(rgSCHTomUtlSendSfnTick);
-
/* TTI to be sent to RRM only once per system frame */
/* Added support for period = 0 to disable tick to RRM */
if ((cell->rrmTtiIndPrd != 0) &&
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
* Function: rgSCHDynTDDMrkCrntSfIdx
* Purpose: update the dyn tdd sunframe index
* @param[in] Inst schInst
- * @RETVALUE None
+ * @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);
- TRC2(rgSCHDynTDDMrkCrntSfIdx)
RG_SCH_DYN_TDD_MARKTYPE(rgSchDynTddInfo, rgSchDynTddInfo->crntDTddSfIdx,
RG_SCH_DYNTDD_NOTDEF);
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;
- TRC2 (rgSchTomFillCellTtiInfo);
-
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);
SlotIndInfo 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
{
- TRC2(rgSchTomTtiUlAndDlCmnChSch);
-
cell->rlsHqArr[cell->crntHqIdx].numUes = 0;
cell->crntHqIdx++;
cell->crntHqIdx = cell->crntHqIdx % RGSCH_NUM_SUB_FRAMES;
*/
#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;
- TRC2(rgSchTomTtiMiscFunctions);
-
/* 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
{
- TRC2(rgSchTomTtiDlSch);
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);
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
- TRC2(rgSchTomTtiCnsldtSfAlloc);
-
/* Prepare Subframe allocation info and send to MAC */
rgSCHCmnCnsldtSfAlloc(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);
RgSchErrInfo err;
- TRC2(rgSchTomTtiL1DlAndUlCfg);
-
rgSCHTomUtlProcDlSf (dlSf, ulSf, cell, cntrlInfo, &err);
/* Mark this frame as sent */
dlSf->txDone = TRUE;
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
{
- TRC2(rgSchTomUtlTddRlsSfAndHarq);
/* ccpu00132341-MOD- rgSchTddRlsDlSubfrmTbl is dependent on DELTA(=2).
* Instead rgSchTddDlAscSetIdxKTbl can be used as the K set gives proper
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;
- TRC2(rgSCHTomUtlProcTddUlSf);
-
if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx]
[cell->rcpReqTime.subframe] == RG_SCH_TDD_UL_SUBFRAME)
{
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