@brief This module does processing related to handling of lower interface APIs
invoked by PHY towards scheduler.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=228;
-static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
#include "common_def.h"
#include "rg_sch_inf.h" /* defines and macros for MAC */
#include "rg_sch.h" /* defines and macros for MAC */
#include "rg_sch_cmn.h" /* typedefs for MAC */
-#include "rl_interface.h"
-#include "rl_common.h"
/* header/extern include files (.x) */
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,
uint16_t rapId
));
-EXTERN Void rgSchTomTtiEmtcSched ARGS(
+Void rgSchTomTtiEmtcSched ARGS(
(
- RgSchCellCb *cell
+RgSchCellCb *cell
));
-EXTERN S16 rgSCHEmtcRamVldtProcRaReq
+S16 rgSCHEmtcRamVldtProcRaReq
(
uint8_t raRntiCnt,
uint8_t raReqCnt,
Bool *isEmtcUe,
RgSchErrInfo *err
);
-EXTERN Void rgSCHEmtcUpdCqiInfo
+Void rgSCHEmtcUpdCqiInfo
(
RgSchUeCb *ue,
RgSchUePCqiCb *cqiCb,
uint16_t *cqiIdx
);
-EXTERN Void rgSCHEmtcUpdSRInfo
+Void rgSCHEmtcUpdSRInfo
(
RgSchUeCb *ue,
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,
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,
- uint16_t validIdx,
- RgSchErrInfo *err
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
);
-EXTERN S16 rgSCHEmtcTomUtlFillHqFdbkRecpReq
+S16 rgSCHEmtcTomUtlFillHqFdbkRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t 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 uint32_t gDlMpdcchBlank;
-EXTERN uint32_t gUlMpdcchBlank;
-EXTERN S16 rgSCHUtlIotResPrcTti
+uint32_t gDlMpdcchBlank;
+uint32_t gUlMpdcchBlank;
+S16 rgSCHUtlIotResPrcTti
(
RgSchCellCb *cell
);
#endif
-EXTERN RgSchUeCb* rgSCHCmnGetHoUe
+RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
uint16_t rapId
);
-EXTERN RgSchUeCb* rgSCHCmnGetPoUe
+RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
uint16_t rapId,
);
S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
(
- RgSchCellCb *cell,
- uint8_t cqiReq,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- uint16_t validIdx
- ));
+RgSchCellCb *cell,
+uint8_t cqiReq,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+));
S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- uint16_t validIdx
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+));
S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- uint16_t validIdx
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+));
S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres
- ));
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres
+));
-void schFillCrntTime(
- SlotIndInfo slotInd,
- Inst schInst);
+void schFillCrntTime( SlotTimingInfo slotInd,Inst schInst);
#ifdef CA_DBG
-EXTERN uint32_t delayedApiCnt;
+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;
#endif
#ifdef RG_5GTF
-EXTERN uint32_t gUl5gtfPdcchSend;
+uint32_t gUl5gtfPdcchSend;
#endif
#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr ARGS
+static S16 rgSCHTomUtlFillCqiSrsWithSr ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUeRecpReqInfo *pucchRecpInfo,
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,
uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillRiRecpReq ARGS((
+static S16 rgSCHTomUtlFillRiRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq ARGS((
+static S16 rgSCHTomUtlFillPcqiRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlFillSrsRecpReq ARGS((
+static S16 rgSCHTomUtlFillSrsRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
uint16_t validIdx,
RgSchErrInfo *err));
-PRIVATE S16 rgSCHTomUtlGenIndices ARGS((
+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,
- uint16_t validIdx,
- RgSchErrInfo *err
- ));
-PRIVATE Void rgSchTomFillCellTtiInfo ARGS
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+));
+static Void rgSchTomFillCellTtiInfo ARGS
((
TfuTtiIndInfo *ttiInd,
Inst schInst,
uint32_t ri2Cnt ;
uint32_t gDlNumUePerTti[20] = {0};
uint32_t gUlNumUePerTti[20] = {0};
-PRIVATE S16 rgSCHTomUtlProcDlSf ARGS((
+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,
uint16_t validIdx,
RgSchErrInfo *err));
#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
+static S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
RgSchErrInfo *err));
S16 rgSCHTomFillOnlySrsRecpReq ARGS
((
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo
- ));
-PRIVATE S16 rgSCHTomUtlFillCqiSrSrsWithHq ARGS
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo
+));
+static S16 rgSCHTomUtlFillCqiSrSrsWithHq ARGS
((
- RgSchCellCb *cell,
- TfuRecpReqInfo *recpReqInfo,
- RgSchUeCb *ue,
- TfuUeRecpReqInfo *pucchRecpInfo,
- uint16_t validIdx,
- Bool isDatPresOnSecCell
- ));
+RgSchCellCb *cell,
+TfuRecpReqInfo *recpReqInfo,
+RgSchUeCb *ue,
+TfuUeRecpReqInfo *pucchRecpInfo,
+uint16_t validIdx,
+Bool isDatPresOnSecCell
+));
S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
((
- RgSchUeCb *ueCb
+RgSchUeCb *ueCb
));
uint8_t rgSCHTomUtlFetchPcqiBitSz ARGS
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,
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,
uint16_t validIdx
));
#else
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
));
#endif
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
uint16_t validIdx
));
#else
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbk ARGS((
+static S16 rgSCHTomUtlFillSfHqFdbk ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err,
));
#endif
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForOneUe ARGS((
+static S16 rgSCHTomUtlFillSfHqFdbkForOneUe ARGS((
RgSchDlHqProcCb *hqCb,
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cellCb,
));
#endif
#ifdef LTEMAC_SPS
-EXTERN Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
+Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
#ifndef LTE_TDD
#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHTomCnsdrRelPdcch ARGS
+static S16 rgSCHTomCnsdrRelPdcch ARGS
((
- RgSchCellCb *cell,
- RgSchDlSf *dlSf,
- TfuRecpReqInfo *recpReqInfo,
- uint16_t 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
((
uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchCellCb *cellCb,
uint16_t *hqRes
));
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1 ARGS
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1 ARGS
((
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- uint8_t 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,
- uint8_t noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- RgSchCellCb *cellCb,
- uint8_t elemIdx
+RgSchDlHqProcCb *hqCb,
+TfuUePucchRecpReq *hqRecpReq,
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb,
+uint8_t elemIdx
));
#endif/*LTE_ADV*/
#endif/*LTE_TDD*/
/*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 uint8_t 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 uint32_t rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
+/*const static uint32_t rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28},
{0,1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276,300,325,351,378},
{0,0,1,4,10,20,35,56,84,120,165,220,286,364,455,560,680,816,969,1140,1330,1540,1771,2024,2300,2600,2925,3276},
/*Tables Derived from 3GPP TS 36.211 Section 5.5.3.3 */
/* Table 5.5.3.3-1 */
#ifndef LTE_TDD
-CONSTANT RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
+const RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
{TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE},
{TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE},
};
#else
/* Table 5.5.3.3-2 */
-CONSTANT RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
+const RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
{FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE},
{FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE},
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHGetDedPrmUe
(
RgSchCellCb *cell,
-uint16_t rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo,
RgSchUeCb **ue
)
-#else
-S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
-RgSchCellCb *cell;
-uint16_t rapId;
-CmLteTimingInfo timingInfo;
-RgSchUeCb **ue;
-#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- printf("rapId[%d] cellSch->rachCfg.dedPrmStart[%d] cellSch->rachCfg.numDedPrm[%d]\n",rapId,cellSch->rachCfg.dedPrmStart,cellSch->rachCfg.numDedPrm);
+ DU_LOG("\nINFO --> SCH : rapId[%d] cellSch->rachCfg.dedPrmStart[%d] cellSch->rachCfg.numDedPrm[%d]\n",\
+ rapId,cellSch->rachCfg.dedPrmStart,cellSch->rachCfg.numDedPrm);
/* Finding UE in handOver List */
if ((rapId < cellSch->rachCfg.dedPrmStart) ||
(rapId > cellSch->rachCfg.dedPrmStart +
{
/* This ded Preamble corresponds to handover */
*ue = rgSCHCmnGetHoUe(cell, rapId);
- printf(" his ded Preamble corresponds to hando\n");
+ DU_LOG("\nDEBUG --> SCH : ded Preamble corresponds to handover\n");
}
else/* Finding UE from PDCCH Order Mappings */
{
/* Get the UE which has transmitted this RaReq */
*ue = rgSCHCmnGetPoUe(cell, rapId, timingInfo);
- printf(" ==== inding UE from PDCCH Order Mapping\n");
+ DU_LOG("\nDEBUG --> SCH : UE from PDCCH Order Mapping\n");
}
return ROK;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomRaReqInd
(
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd
)
-#else
-S16 rgSCHTomRaReqInd(cell, raReqInd)
-RgSchCellCb *cell;
-TfuRaReqIndInfo *raReqInd;
-#endif
{
- S16 ret;
- uint8_t raRntiCnt;
- uint8_t raReqCnt;
- RgSchErrInfo err;
- Bool isEmtcUe = FALSE;
- uint16_t rapId;
- RgSchUeCb *ue = NULLP;
+ S16 ret;
+ uint8_t raRntiCnt;
+ uint8_t raReqCnt;
+ RgSchErrInfo err;
+ Bool isEmtcUe = FALSE;
+ uint16_t rapId;
+ RgSchUeCb *ue = NULLP;
if(cell->cellId != raReqInd->cellId)
{
err.errType = RGSCHERR_TOM_RAREQIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHTomRaReqInd(): No cell found with raReq cellId = (%d) errorType (%d)"
+ DU_LOG("\nERROR --> SCH : rgSCHTomRaReqInd(): No cell found with raReq cellId = (%d) errorType (%d)"
" errorCause(%d)",raReqInd->cellId, err.errType, err.errCause);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if(raReqInd->rachInfoArr[raRntiCnt].raRnti > RGSCH_MAX_RA_RNTI)
{
- RGSCHLOGERROR(cell->instIdx, ERRCLS_INT_PAR, ERG013,
- (ErrVal)raReqInd->rachInfoArr[raRntiCnt].raRnti,
- ("rgSCHTomRaReqInd(): raRnti is out of range\n"));
+ DU_LOG("\nERROR --> SCH : rgSCHTomRaReqInd(): raRnti is out of range\n");
continue;
}
#endif
if(ret == RFAILED)
{
err.errType = RGSCHERR_TOM_RAREQIND;
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
- "RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed errType(%d) "
+ DU_LOG("\nERROR --> SCH : RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed errType(%d) "
"errCause(%d)", raReqInd->rachInfoArr[raRntiCnt].raRnti,
err.errType, err.errCause);
continue;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUlCqiInd
(
RgSchCellCb *cell,
TfuUlCqiIndInfo *ulCqiInd
)
-#else
-S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
-RgSchCellCb *cell;
-TfuUlCqiIndInfo *ulCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
node = ulCqiInd->ulCqiRpt.first;
if(cell->cellId != ulCqiInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHTomUlCqiInd() Unable to get the ulCqiInd cell with id(%d)",
+ DU_LOG("\nERROR --> SCH : rgSCHTomUlCqiInd() Unable to get the ulCqiInd cell with id(%d)",
ulCqiInd->cellId);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if(ulCqiInfo->numSubband == 0)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Num Subband is"
+ DU_LOG("\nERROR --> SCH : Num Subband is"
"out of range RNTI:%d",ulCqiInfo->rnti);
continue;
}
if((ue = rgSCHDbmGetSpsUeCb(cell, ulCqiInfo->rnti)) == NULLP)
#endif
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get "
- "the ue for RNTI:%d", ulCqiInfo->rnti);
+ DU_LOG("\nERROR --> SCH : Unable to get the ue for RNTI:%d", ulCqiInfo->rnti);
continue;
}
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomPucchDeltaPwrInd
(
RgSchCellCb *cell,
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
)
-#else
-S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
-RgSchCellCb *cell;
-TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != pucchDeltaPwr->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHTomPucchDeltaPwrInd() Unable to get the pucchDeltaPwr cell with id(%d)",
+ DU_LOG("\nERROR --> SCH : rgSCHTomPucchDeltaPwrInd() Unable to get the pucchDeltaPwr cell with id(%d)",
pucchDeltaPwr->cellId);
return RFAILED;
}
if((ue = rgSCHDbmGetSpsUeCb(cell, ueElem->rnti)) == NULLP)
#endif
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d "
+ DU_LOG("\nERROR --> SCH : RNTI:%d "
"rgSCHTomPucchDeltaPwrInd() Unable to get the ue ",
ueElem->rnti);
continue;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomHarqAckInd
(
RgSchCellCb *cell,
TfuHqIndInfo *harqAckInd
)
-#else
-S16 rgSCHTomHarqAckInd(cell, harqAckInd)
-RgSchCellCb *cell;
-TfuHqIndInfo *harqAckInd;
-#endif
{
RgSchErrInfo err;
RgSchUeCb *ue;
if(cell->cellId != harqAckInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() Unable to get"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() Unable to get"
" the cell for cellId (%d)", harqAckInd->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
if ((rgSCHDhm5gtfHqFdbkInd (ue, cell, harqAckInd->timingInfo, fdbk, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
if ((rgSCHDhmRlsDlsfHqProc (cell, harqAckInd->timingInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Release Downlink "
+ DU_LOG("\nERROR --> SCH : Unable to Release Downlink "
"subframe for cellId (%d) ", cell->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
}
cell, harqAckInd->timingInfo, hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d)",
err.errType, err.errCause);
continue;
cell, harqAckInd->timingInfo, hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
cell, harqAckInd->timingInfo, hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d).",
err.errType, err.errCause);
continue;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB or RA CB ", hqInfo->rnti);
err.errType = RGSCHERR_TOM_HARQACKIND;
continue;
/* Check with TDD call DHM*/
if ((rgSCHDhmRlsDlsfHqProc (cell, harqAckInd->timingInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Release Downlink "
+ DU_LOG("\nERROR --> SCH : Unable to Release Downlink "
"subframe for cellId (%d) ", harqAckInd->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomSrInd
(
RgSchCellCb *cell,
TfuSrIndInfo *srInd
)
-#else
-S16 rgSCHTomSrInd(cell, srInd)
-RgSchCellCb *cell;
-TfuSrIndInfo *srInd;
-#endif
{
S16 ret = RFAILED;
RgSchErrInfo err;
if(cell->cellId != srInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for srcInd cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for srcInd cellId"
":%d ", srInd->cellId);
err.errType = RGSCHERR_TOM_SRIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
ue = rgSCHDbmGetUeCb (cell, srInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the UE CB",
srInfo->rnti);
continue;
}
if (ret != ROK)
{
err.errType = RGSCHERR_TOM_SRIND;
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Scheduler processing failed "
+ DU_LOG("\nERROR --> SCH : Scheduler processing failed "
"errType(%d) errCause(%d) RNTI:%d", err.errType, err.errCause,srInfo->rnti);
continue;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomDoaInd
(
RgSchCellCb *cell,
TfuDoaIndInfo *doaInd
)
-#else
-S16 rgSCHTomDoaInd(cell, doaInd )
-RgSchCellCb *cell;
-TfuDoaIndInfo *doaInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != doaInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for doaInd cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for doaInd cellId"
":%d", doaInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, doaInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the UE CB",
doaInfo->rnti);
continue;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomDlCqiInd
(
RgSchCellCb *cell,
TfuDlCqiIndInfo *dlCqiInd
)
-#else
-S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
-RgSchCellCb *cell;
-TfuDlCqiIndInfo *dlCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != dlCqiInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", dlCqiInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, dlCqiInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%dUnable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%dUnable to get the UE CB",
dlCqiInfo->rnti);
continue;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMovePcqiNxtOccasion
+static S16 rgSCHTomUtlMovePcqiNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- RgSchUePCqiCb *cqiCb
- )
-#else
-PRIVATE S16 rgSCHTomUtlMovePcqiNxtOccasion(cell, ue, cqiCb)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- RgSchUePCqiCb *cqiCb;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchUePCqiCb *cqiCb
+)
{
uint16_t cqiIdx = 0;
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,
&cqiCb->cqiLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to remove node",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to remove node",
ue->ueId);
}
cqiCb->nCqiTrIdx = cqiIdx;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMovePriNxtOccasion
+static S16 rgSCHTomUtlMovePriNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- RgSchUePCqiCb *riCb
- )
-#else
-PRIVATE S16 rgSCHTomUtlMovePriNxtOccasion(cell, ue, riCb)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- RgSchUePCqiCb *riCb;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchUePCqiCb *riCb
+)
{
uint16_t riIdx;
uint16_t riDist=0;
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[riCb->nRiTrIdx].riLst,
&riCb->riLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"[%d]UEID:Unable to remove node",
+ DU_LOG("\nERROR --> SCH : [%d]UEID:Unable to remove node",
ue->ueId);
}
RG_SCH_RECORD(&riCb->histElem,RGSCH_ACTION_DEL, &cell->pCqiSrsSrLst[riCb->nRiTrIdx].riLst);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMoveSrNxtOccasion
+static S16 rgSCHTomUtlMoveSrNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue
- )
-#else
-PRIVATE S16 rgSCHTomUtlMoveSrNxtOccasion(cell, ue)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue
+)
{
uint16_t srIdx = 0;
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[ue->srCb.nSrTrIdx].srLst,
&ue->srCb.srLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to remove node",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to remove node",
ue->ueId);
}
ue->srCb.nSrTrIdx = srIdx;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlMoveSrsNxtOccasion
+static S16 rgSCHTomUtlMoveSrsNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue
- )
-#else
-PRIVATE S16 rgSCHTomUtlMoveSrsNxtOccasion(cell, ue)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue
+)
{
uint16_t srsIdx;
uint16_t srsDist;
if (NULLP == cmLListDelFrm(&cell->pCqiSrsSrLst[ue->srsCb.nSrsTrIdx].srsLst,
&ue->srsCb.srsLstEnt))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to remove node",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to remove node",
ue->ueId);
}
cmLListAdd2Tail(&cell->pCqiSrsSrLst[srsIdx].srsLst,
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomRawCqiInd
(
- RgSchCellCb *cell,
- TfuRawCqiIndInfo *rawCqiInd
+RgSchCellCb *cell,
+TfuRawCqiIndInfo *rawCqiInd
)
-#else
-S16 rgSCHTomRawCqiInd(cell, rawCqiInd)
- RgSchCellCb *cell;
- TfuRawCqiIndInfo *rawCqiInd;
-#endif
{
RgSchUeCb *ue;
CmLList *node;
TfuRawCqiRpt* rawCqiInfo;
RgSchErrInfo err;
- uint32_t cellIdx;
+ uint32_t cellIdx;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
RgSchCellCb *iterCellP;
#if DL_LA
RgSchCmnDlUe *ueDl;
#endif
- uint8_t cqi;
- uint8_t ri;
- uint8_t hqAck;
- Pst pst;
- RgSchRaCb *raCb;
- TfuHqInfo hqInfo;
+ uint8_t cqi;
+ uint8_t ri;
+ uint8_t hqAck;
+ Pst pst;
+ RgSchRaCb *raCb;
+ TfuHqInfo hqInfo;
if(cell->cellId != rawCqiInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", rawCqiInd->cellId);
return RFAILED;
}
/*
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d Unable to get the UECB",
+ DU_LOG("\nERROR --> SCH : CRNTI:%d Unable to get the UECB",
rawCqiInfo->crnti);
continue;
}
#ifdef RG_5GTF
/*
if (rawCqiInfo->numBits >= 5)
- printf("cellId [%d] crnti [%d] numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n",
+ DU_LOG("\nINFO --> SCH : cellId [%d] crnti [%d] numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n",
cell->cellId, rawCqiInfo->crnti, rawCqiInfo->numBits, rawCqiInfo->uciPayload,
rawCqiInd->timingInfo.sfn, rawCqiInd->timingInfo.slot);
*/
if ((rgSCHDhm5gtfHqFdbkInd (ue, cell, rawCqiInd->timingInfo, fdbk, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d)",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d).",
err.errType, err.errCause);
continue;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB or RA CB ", rawCqiInfo->crnti);
err.errType = RGSCHERR_TOM_HARQACKIND;
continue;
}
/*
- printf("rawCqiInfo->numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n", rawCqiInfo->numBits,
+ DU_LOG("rawCqiInfo->numBits [%d] uciPayload [0x%08x] sfn/sf [%d:%d]\n", rawCqiInfo->numBits,
rawCqiInfo->uciPayload, rawCqiInd->timingInfo.sfn, rawCqiInd->timingInfo.slot);
*/
}
if(ue) {
if (cqi == 0)
{
- printf("\n UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
+ DU_LOG("\nERROR --> SCH : UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
cqi = 15;
}
ue->ue5gtfCb.mcs = rgSch5gtfCqi2Mcs[cqi - 1];
#endif
}
/*
- printf("UE[%d] CQI[%d] MCS[%d] RI[%d]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri);
+ DU_LOG("\nERROR --> SCH : UE[%d] CQI[%d] MCS[%d] RI[%d]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri);
*/
}
else if (rawCqiInfo->numBits == 6)
hqAck = (rawCqiInfo->uciPayload >> 31) & 0x1;
if (cqi == 0)
{
- printf("UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
+ DU_LOG("\nERROR --> SCH : UE[%d] CQI[%d] Invalid\n", ue->ueId, cqi);
cqi = 13;
}
ue->ue5gtfCb.mcs = rgSch5gtfCqi2Mcs[cqi - 1];
if ((rgSCHDhm5gtfHqFdbkInd (ue, cell, rawCqiInd->timingInfo, fdbk, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() "
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() "
"HARQ feedback processing failed errType(%d)errCause(%d)n",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d)",
err.errType, err.errCause);
continue;
cell, rawCqiInd->timingInfo, &hqInfo, rlsHqBufs, &err)) != ROK)
{
err.errType = RGSCHERR_TOM_HARQACKIND;
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() HARQ"
+ DU_LOG("\nERROR --> SCH : rgSCHTomHarqAckInd() HARQ"
" feedback processing failed errType(%d) errCause(%d).",
err.errType, err.errCause);
continue;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB or RA CB ", rawCqiInfo->crnti);
err.errType = RGSCHERR_TOM_HARQACKIND;
continue;
}
/*
- printf("\nUE[%u] CQI[%u] MCS[%u] RI[%u] HQ[%u]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri, hqAck);
+ DU_LOG("\nERROR --> SCH : UE[%u] CQI[%u] MCS[%u] RI[%u] HQ[%u]\n", ue->ueId, cqi, ue->ue5gtfCb.mcs, ri, hqAck);
*/
}
}
if ((rgSCHDhmRlsDlsfHqProc (cell, rawCqiInd->timingInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Release Downlink "
+ DU_LOG("\nERROR --> SCH : Unable to Release Downlink "
"subframe for cellId (%d) ", cell->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomSrsInd
(
- RgSchCellCb *cell,
- TfuSrsIndInfo *srsInd
- )
-#else
-S16 rgSCHTomSrsInd(cell, srsInd)
- RgSchCellCb *cell;
- TfuSrsIndInfo *srsInd;
-#endif
+RgSchCellCb *cell,
+TfuSrsIndInfo *srsInd
+)
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != srsInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", srsInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, srsInfo->ueId);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the "
"UE CB", srsInfo->ueId);
continue;
}
*
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlGenIndices
+static S16 rgSCHTomUtlGenIndices
(
- uint32_t label,
- uint8_t posM,
- uint8_t valN,
- uint8_t valK,
- TfuSubbandInfo* sbInfo
- )
-#else
-PRIVATE S16 rgSCHTomUtlGenIndices(label, posM, valN, valK, sbInfo)
- uint32_t label;
- uint8_t posM;
- uint8_t valN;
- uint8_t valK;
- TfuSubbandInfo* sbInfo;
-#endif
+uint32_t label,
+uint8_t posM,
+uint8_t valN,
+uint8_t valK,
+TfuSubbandInfo* sbInfo
+)
{
uint8_t idx, kval, xval, xmin;
uint32_t binCoe;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomCrcInd
(
RgSchCellCb *cell,
TfuCrcIndInfo *crcInd
)
-#else
-S16 rgSCHTomCrcInd(cell, crcInd)
-RgSchCellCb *cell;
-TfuCrcIndInfo *crcInd;
-#endif
{
RgSchUeCb *ue = NULLP;
RgSchRaCb *raCb = NULLP;
if(cell->cellId != crcInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
":%d", crcInd->cellId);
return RFAILED;
}
if (RGSCH_TIMEINFO_SAME(lastCrc, crntCrc))
{
/*Removed the WA to drop 2nd CRC*/
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Recieved CRC "
+ DU_LOG("\nINFO --> SCH : Recieved CRC "
"twice per TTI @(%u,%u)", cell->crntTime.sfn,
cell->crntTime.slot);
}
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&cntrlInfo,
sizeof(TfuCntrlReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate TfuCntrlReqInfo "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuCntrlReqInfo "
"for cell");
return ret;
}
if ((rgSCHTomUtlProcDlSfAtCrc (ulSf, crntHiDci0Frm, cell, cntrlInfo, &err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomCrcInd() Unable to process"
+ DU_LOG("\nERROR --> SCH : rgSCHTomCrcInd() Unable to process"
" downlink subframe for cellId %d", crcInd->cellId);
err.errType = RGSCHERR_TOM_TTIIND;
return RFAILED;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomTimingAdvInd
(
RgSchCellCb *cell,
TfuTimingAdvIndInfo *timingAdvInd
- )
-#else
-S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
-RgSchCellCb *cell;
-TfuTimingAdvIndInfo *timingAdvInd;
-#endif
+)
{
RgSchUeCb *ue;
CmLList *node;
if(cell->cellId != timingAdvInd->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
+ DU_LOG("\nERROR --> SCH : Unable to get the cell for cellId"
"=(%d)", timingAdvInd->cellId);
return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, timingAdvInfo->rnti);
if (ue == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to get the UE CB",
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to get the UE CB",
timingAdvInfo->rnti);
continue;
}
* 4: Fill the Tfu structures for DL and UL Config requests
* 5: Handle the RGR Config messages per Cell
*
- * @param[in] SlotIndInfo *slotInd
+ * @param[in] SlotTimingInfo *slotInd
* @param[in] Inst schInst
* @return Void
**/
-#ifdef ANSI
Void rgSCHTomTtiInd
(
-SlotIndInfo *slotInd,
+SlotTimingInfo *slotInd,
Inst schInst
)
-#else
-Void rgSCHTomTtiInd(slotInd, schInst)
-SlotIndInfo *slotInd;
-Inst schInst;
-#endif
{
RgInfSfAlloc *subfrmAlloc;
RgTfuCntrlReqInfo *cntrlInfo = NULLP;
S16 ret = ROK;
- uint8_t i;
- uint8_t nCell = 0;
+ uint8_t i;
+ uint8_t nCell = 0;
RgSchCellCb *cell[CM_LTE_MAX_CELLS];
RgSchCellCb *cellLst[CM_LTE_MAX_CELLS];
if ((ret = rgSCHUtlAllocEventMem((cell[i]->instIdx), (Ptr *)&cntrlInfo,
sizeof(RgTfuCntrlReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell[i]->cellId,"Unable to Allocate TfuCntrlReqInfo"
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuCntrlReqInfo"
" for cell");
return;
}
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*/
* -# 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;
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate TfuRecpReqInfo "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuRecpReqInfo "
"for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
err);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to fill Data recption "
+ DU_LOG("\nERROR --> SCH : Unable to fill Data recption "
"requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
ret = rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, validIdx,err);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to fill Harq Feedback "
+ DU_LOG("\nERROR --> SCH : Unable to fill Harq Feedback "
"reception requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
}
/* sending the RecpReq to Phy */
- if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
+ //if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info for cell");
+ DU_LOG("\nERROR --> SCH : Unable to send Cntrl info for cell");
}
return ROK;
} /* end of rgSCHTomUtlProcUlSf */
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlPrcUlTddSpclSf
+static S16 rgSCHTomUtlPrcUlTddSpclSf
(
-RgSchCellCb *cell,
-RgSchErrInfo *err
+RgSchCellCb *cell,
+RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlPrcUlTddSpclSf (cell, err)
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
TfuRecpReqInfo *recpReqInfo;
- uint16_t validIdx; /* Index computed from recreq's timing info*/
+ uint16_t validIdx; /* Index computed from recreq's timing info*/
Inst inst = cell->instIdx;
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to "
+ DU_LOG("\nERROR --> SCH : rgSCHTomUtlPrcUlTddSpclSf() Unable to "
"Allocate TfuRecpReqInfo for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
ret = rgSCHTomUtlFillSrsRecpReq (recpReqInfo, cell, validIdx, err);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to fill"
+ DU_LOG("\nERROR --> SCH : rgSCHTomUtlPrcUlTddSpclSf() Unable to fill"
" SRS recption requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
}
/* sending the RecpReq to Phy */
- if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
+ //if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to send "
+ DU_LOG("\nERROR --> SCH : rgSCHTomUtlPrcUlTddSpclSf() Unable to send "
"Cntrl info for cell");
}
return ROK;
* @param [out] RgSchErrInfo *err
* @return S16
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcDlSf
+static S16 rgSCHTomUtlProcDlSf
(
RgSchDlSf *dlSf,
RgSchDlSf *ulSf,
RgTfuCntrlReqInfo *cntrlInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlProcDlSf (dlSf, ulSf, cell, cntrlInfo, err)
-RgSchDlSf *dlSf;
-RgSchDlSf *ulSf;
-RgSchCellCb *cell;
-RgTfuCntrlReqInfo *cntrlInfo;
-RgSchErrInfo *err;
-#endif
{
- Inst inst = cell->instIdx;
- S16 ret;
- uint8_t sfTyp = 1; /* Dl Subframe */
+ S16 ret;
+ uint8_t sfTyp = 1; /* Dl Subframe */
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
cntrlInfo->ulTiming = cell->hiDci0Time;
if((0 == (cntrlInfo->dlTiming.sfn % 30)) && (0 == cntrlInfo->dlTiming.slot))
{
- //printf("5GTF_CHECK rgSCHTomUtlProcDlSf Cntrl dl (%d : %d) ul (%d : %d)\n", cntrlInfo->dlTiming.sfn, cntrlInfo->dlTiming.subframe, cntrlInfo->ulTiming.sfn, cntrlInfo->ulTiming.subframe);
+ //DU_LOG("\nERROR --> SCH : 5GTF_CHECK rgSCHTomUtlProcDlSf Cntrl dl (%d : %d) ul (%d : %d)\n", \
+ cntrlInfo->dlTiming.sfn, cntrlInfo->dlTiming.subframe, cntrlInfo->ulTiming.sfn, cntrlInfo->ulTiming.subframe);
}
/* Fill PCFICH info */
/* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
/* Fill PHICH info */
if ((ret = rgSCHTomUtlFillPhich (cell, cntrlInfo, ulSf, err)) != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PHICH info "
- "for cellId (%d)\n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to send PHICH info "
+ "for cellId (%d)\n", cell->cellId);
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
if ((ret = rgSCHTomUtlFillUlPdcch (cell, cntrlInfo, ulSf, err)) !=
ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PDCCH info "
- "for cellId (%d)\n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to send PDCCH info "
+ "for cellId (%d)\n", cell->cellId);
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
/* Fill PDCCH info */
if ((ret = rgSCHTomUtlFillDlPdcch(cell,cntrlInfo, dlSf, err)) != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PDCCH info "
- "for cellId (%d)\n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to send PDCCH info "
+ "for cellId (%d)\n", cell->cellId);
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
#endif
/* Now always sending down a cntrl req */
/* sending the cntrl data to Phy */
- if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo)
- != ROK)
+ //if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo)
+ //!= ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info "
- "for cell");
+ DU_LOG("\nERROR --> SCH : Unable to send Cntrl info for cell");
}
return ROK;
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillPhich
+static S16 rgSCHTomUtlFillPhich
(
RgSchCellCb *cell,
TfuCntrlReqInfo *cntrlInfo,
RgSchDlSf *dlSf,
RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillPhich(cell, cntrlInfo, dlSf, err)
-RgSchCellCb *cell;
-TfuCntrlReqInfo *cntrlInfo;
-RgSchDlSf *dlSf;
-RgSchErrInfo *err;
-#endif
+)
{
S16 ret;
CmLList *node;
* @param[in] CmLteRnti rnti
* @return Void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTmrRestartScellDeactTmr
+static Void rgSCHTmrRestartScellDeactTmr
(
- RgSchCellCb *cell,
- RgSchUeCb *ueCb
- )
-#else
-PRIVATE Void rgSCHTmrRestartScellDeactTmr (cell, ueCb)
- RgSchCellCb *cell;
- RgSchUeCb *ueCb;
-
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ueCb
+)
{
RgSchUeCellInfo *sCellInfo = NULLP;
* -# ROK
* -# RFAILED
*/
-EXTERN uint32_t 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;
} /* end of rgSCHTomUtlFillDlPdcch*/
#ifdef RGSCH_SPS_STATS
-extern uint32_t rgSchSpsRelSentToTf;
-extern uint32_t 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;
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcTA
-(
-RgSchCellCb *cell
-)
-#else
-PRIVATE S16 rgSCHTomUtlProcTA (cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHTomUtlProcTA(RgSchCellCb *cell)
{
CmLList *node;
RgSchUeCb *ue;
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
S16 rgSCHTomUtlFillHqFdbkInfo
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchDlHqProcCb *hqCb,
- RgSchDlSf *nxtDlsf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchDlHqProcCb *prvHqCb,
- RgSchErrInfo *err
- )
-#else
-S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchDlHqProcCb *hqCb;
- RgSchDlSf *nxtDlsf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchDlHqProcCb *prvHqCb;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqProcCb *hqCb,
+RgSchDlSf *nxtDlsf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchDlHqProcCb *prvHqCb,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchDlHqProcCb *prvHqCb,
RgSchErrInfo *err
)
-#else
-S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchDlHqProcCb *hqCb;
-RgSchDlSf *nxtDlsf;
-TfuUeRecpReqInfo *pucchRecpInfo;
-RgSchDlHqProcCb *prvHqCb;
-RgSchErrInfo *err;
-#endif
#endif
{
S16 ret;
RgSchDlHqTbCb *tbCb;
- uint32_t idx;
+ uint32_t idx;
Bool isAddToLst = FALSE;
for (idx = 0 ;idx < 2; idx++)
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell");
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkFor5gtf
+static S16 rgSCHTomUtlFillHqFdbkFor5gtf
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchDlHqInfo *dlSfHqInfo,
- RgSchDlSf *dlSf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkFor5gtf (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchDlHqInfo *dlSfHqInfo;
- RgSchDlSf *dlSf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqInfo *dlSfHqInfo,
+RgSchDlSf *dlSf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchErrInfo *err
+)
{
-#ifdef DEBUGP
- Inst inst = cell->instIdx;
-#endif
S16 ret;
RgSchUeCb *ue;
TfuUePucchRecpReq *pucchReqInfo = NULLP;
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
- "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
+ "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B
+static S16 rgSCHTomUtlFillHqFdbkForFrmt1B
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchDlHqInfo *dlSfHqInfo,
- RgSchDlSf *dlSf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t 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;
- uint8_t primCellTbCount = 0;
+ uint8_t primCellTbCount = 0;
hqPNode = dlSfHqInfo->hqPLst.first;
ue = (RgSchUeCb*)dlSfHqInfo->dlSfUeLnk.node;
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
- "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cellId=%d \n", cell->cellId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3
+static S16 rgSCHTomUtlFillHqFdbkForFrmt3
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchDlHqInfo *dlSfHqInfo,
- RgSchDlSf *dlSf,
- TfuUeRecpReqInfo *pucchRecpInfo,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3 (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchDlHqInfo *dlSfHqInfo;
- RgSchDlSf *dlSf;
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchDlHqInfo *dlSfHqInfo,
+RgSchDlSf *dlSf,
+TfuUeRecpReqInfo *pucchRecpInfo,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3
+static S16 rgSCHTomUtlFillHqFdbkForFrmt3
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
TfuUeRecpReqInfo *pucchRecpInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3 (recpReqInfo, cell, hqCb, dlSf, pucchRecpInfo, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchDlHqInfo *dlSfHqInfo;
-RgSchDlSf *dlSf;
-TfuUeRecpReqInfo *pucchRecpInfo;
-RgSchErrInfo *err;
-#endif
#endif
{
#ifdef DEBUGP
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
- "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
+ "TfuUeRecpReqInfo for cellId=%d \n", cell->cellId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq
+static S16 rgSCHTomUtlFillHqFdbkRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
#else
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq
+static S16 rgSCHTomUtlFillHqFdbkRecpReq
(
-TfuRecpReqInfo *recpReqInfo,
-RgSchCellCb *cell,
-RgSchErrInfo *err
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
#endif
{
CmLList *node;
* -# RFAILED
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSrRecpReq
+static S16 rgSCHTomUtlFillSrRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSrRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlWillUeRprtCqiRi
+static S16 rgSCHTomUtlWillUeRprtCqiRi
(
- RgSchUeCb *ue,
- Bool *willueRprtCqiRi
- )
-#else
-PRIVATE S16 rgSCHTomUtlWillUeRprtCqiRi ( ue, willueRprtCqiRi)
- RgSchUeCb *ue;
- Bool *willueRprtCqiRi;
-#endif
+RgSchUeCb *ue,
+Bool *willueRprtCqiRi
+)
{
/* Intialising Reporting probability as TRUE */
*willueRprtCqiRi = TRUE;
* -# RFAILED
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillRiRecpReq
+static S16 rgSCHTomUtlFillRiRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillRiRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
"TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq
+static S16 rgSCHTomUtlFillCqiRiRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
- TfuUeRecpReqInfo *pucchRecpInfo;
- RgSchUeCb *ue = NULLP;
- uint16_t ret;
+ TfuUeRecpReqInfo *pucchRecpInfo;
+ RgSchUeCb *ue = NULLP;
+ uint16_t ret;
while ((ue = rgSCHDbmGetNextUeCb(cell, ue)) != NULLP)
{
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# RFAILED
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq
+static S16 rgSCHTomUtlFillPcqiRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
S16 ret;
-
RgSchUeCb *ue;
- uint8_t ri; /*RI value*/
- Bool willUeRprtCqi; /* Flag set due to CQI Mask
- and UE Inactive state (DRX)*/
- uint8_t cqiPmiSz;
+ uint8_t ri; /*RI value*/
+ Bool willUeRprtCqi; /* Flag set due to CQI Mask and UE Inactive state (DRX)*/
+ uint8_t cqiPmiSz;
RgSchUePCqiCb *cqiCb = NULLP;
Bool isAddToLst = FALSE;
cqiPmiSz = rgSCHTomUtlFetchPcqiBitSz(ue, cell->numTxAntPorts, &ri);
if(!cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unable to Fill CqiPmi "
- "size", ue->ueId);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
continue;
}
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSrsRecpReq
+static S16 rgSCHTomUtlFillSrsRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSrsRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLList *node;
TfuUeRecpReqInfo *pucchRecpInfo;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo),&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for RNTI:%d ",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for RNTI:%d ",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq
+static S16 rgSCHTomUtlFillDatRecpReq
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq (recpReqInfo, cell, err)
-TfuRecpReqInfo *recpReqInfo;
-RgSchCellCb *cell;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
RgSchUlAlloc *alloc;
sizeof(TfuUeRecpReqInfo),
&(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
- "TfuUeRecpReqInfo for RNTI:%d ", alloc->ue->ueId);
+ DU_LOG("\nERROR --> SCH : Unable to Allocate TfuUeRecpReqInfo for RNTI:%d ", alloc->ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
* -# ROK
* -# RFAILED
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq
+static S16 rgSCHTomUtlFillDatRecpReq
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cell,
- uint16_t validIdx,
- RgSchErrInfo *err
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillDatRecpReq (recpReqInfo, cell, validIdx, err)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cell;
- uint16_t validIdx;
- RgSchErrInfo *err;
-#endif
+TfuRecpReqInfo *recpReqInfo,
+RgSchCellCb *cell,
+uint16_t validIdx,
+RgSchErrInfo *err
+)
{
CmLteTimingInfo dci0Time;
- uint8_t idx;
+ uint8_t idx;
S16 ret;
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
Bool isAperiodic = FALSE; /*Set when Aperiodic CQI is expected */
- uint8_t numUePerTti = 0;
+ uint8_t numUePerTti = 0;
if((0 == (recpReqInfo->timingInfo.sfn % 30)) && (0 == recpReqInfo->timingInfo.slot))
{
- //printf("5GTF_CHECK rgSCHTomUtlFillDatRecpReq (%d : %d)\n", recpReqInfo->timingInfo.sfn, recpReqInfo->timingInfo.slot);
+ //DU_LOG("\nERROR --> SCH : 5GTF_CHECK rgSCHTomUtlFillDatRecpReq (%d : %d)\n",\
+ recpReqInfo->timingInfo.sfn, recpReqInfo->timingInfo.slot);
}
/* processing steps are
* - Run through the UL allocations going out in this subframe.
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if(ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
+ DU_LOG("\nERROR --> SCH : Unable to Allocate "
"TfuUeRecpReqInfo for RNTI:%d ", alloc->rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
* File :
*
**********************************************************/
-#ifdef ANSI
S16 rgSCHTomUtlFillRiBitWidthInfo
(
- RgSchUeCb *ueCb
- )
-#else
-S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
- RgSchUeCb *ueCb;
-#endif
+RgSchUeCb *ueCb
+)
{
RgSchUePCqiCb *riCb = ueCb->nPRiCb;
* File :
*
**********************************************************/
-#ifdef ANSI
uint8_t rgSCHTomUtlFetchPcqiBitSz
(
- RgSchUeCb *ueCb,
- uint8_t numTxAnt,
- uint8_t *ri
- )
-#else
-uint8_t rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
- RgSchUeCb *ueCb;
- uint8_t numTxAnt;
- uint8_t *ri;
-#endif
+RgSchUeCb *ueCb,
+uint8_t numTxAnt,
+uint8_t *ri
+)
{
uint8_t confRepMode;
uint8_t pcqiSz;
* File :
*
**********************************************************/
-#ifdef ANSI
S16 rgSCHTomUtlPcqiSbCalcBpIdx
(
- CmLteTimingInfo crntTimInfo,
- RgSchUeCb *ueCb,
- RgSchUePCqiCb *cqiCb
- )
-#else
-S16 rgSCHTomUtlPcqiSbCalcBpIdx(crntTimInfo, ueCb, cqiCb)
- CmLteTimingInfo crntTimInfo;
- RgSchUeCb *ueCb;
- RgSchUePCqiCb *cqiCb;
-#endif
+CmLteTimingInfo crntTimInfo,
+RgSchUeCb *ueCb,
+RgSchUePCqiCb *cqiCb
+)
{
uint16_t tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
uint16_t prdNum = tti/cqiCb->cqiPeri;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlMoveNxtOccasion
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- uint16_t validIdx
- )
-#else
-S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- uint16_t validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint16_t validIdx
+)
{
RgSchUePCqiCb *cqiCb = ue->nPCqiCb;
RgSchUePCqiCb *riCb = ue->nPRiCb;
* File :
*
**********************************************************/
-#ifdef ANSI
Void rgSCHTomPrepareAcqiRecp
(
- RgSchUeCb *ueCb,
- RgSchCellCb *cell,
- TfuUePuschCqiRecpInfo *cqiRecpReqInfo,
- uint8_t ccIdx
- )
-#else
- Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
- RgSchUeCb *ueCb;
- RgSchCellCb *cell;
- TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- uint8_t ccIdx;
-#endif
+RgSchUeCb *ueCb,
+RgSchCellCb *cell,
+TfuUePuschCqiRecpInfo *cqiRecpReqInfo,
+uint8_t ccIdx
+)
{
uint8_t confRepMode;
RgSchCqiRawPuschMode12 *mode12Info;
RgSchCqiRawPuschMode22 *mode22Info;
RgSchCqiRawPuschMode30 *mode30Info;
RgSchCqiRawPuschMode31 *mode31Info;
- uint8_t numTxAnt = cell->numTxAntPorts;
- uint8_t sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
- uint8_t numOfCells = 0;
+ uint8_t numTxAnt = cell->numTxAntPorts;
+ uint8_t sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
+ uint8_t numOfCells = 0;
RgSchUeACqiCb *acqiCb = &ueCb->cellInfo[sCellIdx]->acqiCb;
/* Fill TFU Recp */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatAperRecpReq
(
- RgSchCellCb *cell,
- uint8_t cqiReq,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- uint16_t validIdx
- )
-#else
-S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
- RgSchCellCb *cell;
- uint8_t cqiReq;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
- uint16_t 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
- uint8_t triggerSet = 0;
- uint8_t sIdx = 0;
+ uint8_t triggerSet = 0;
+ uint8_t sIdx = 0;
#endif
/*Fill RI Reception Params*/
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatPriRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- uint16_t validIdx
- )
-#else
-S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
-hqPres, validIdx)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
- uint16_t validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+)
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatPCqiRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres,
- uint16_t validIdx
- )
-#else
-S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
- timeInfo, hqPres, validIdx)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
- uint16_t validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres,
+uint16_t validIdx
+)
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- uint8_t cqiPmiSz; /*Raw CQI/PMI Size*/
- uint8_t ri;
+ uint8_t cqiPmiSz; /*Raw CQI/PMI Size*/
+ uint8_t ri;
/*Fill CQI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
cqiPmiSz = rgSCHTomUtlFetchPcqiBitSz(alloc->ue, cell->numTxAntPorts, &ri);
if(0 == cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Fill "
+ DU_LOG("\nERROR --> SCH : Unable to Fill "
"CqiPmi size RNTI:%d",alloc->rnti);
return RFAILED;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomUtlFillDatSrsRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo,
- CmLteTimingInfo *timeInfo,
- Bool hqPres
- )
-#else
-S16 rgSCHTomUtlFillDatSrsRecpReq(cell, alloc, datRecpInfo, timeInfo,
- hqPres)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
- CmLteTimingInfo *timeInfo;
- Bool hqPres;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo,
+CmLteTimingInfo *timeInfo,
+Bool hqPres
+)
{
datRecpInfo->rnti = alloc->rnti;
rgSCHTomFillOnlySrsRecpReq(cell,alloc, datRecpInfo);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHTomFillOnlySrsRecpReq
(
- RgSchCellCb *cell,
- RgSchUlAlloc *alloc,
- TfuUeRecpReqInfo *datRecpInfo
- )
-#else
-S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
- RgSchCellCb *cell;
- RgSchUlAlloc *alloc;
- TfuUeRecpReqInfo *datRecpInfo;
-#endif
+RgSchCellCb *cell,
+RgSchUlAlloc *alloc,
+TfuUeRecpReqInfo *datRecpInfo
+)
{
TfuUePuschSrsRecpInfo *srsRecpReqInfo;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillCqiSrSrsWithHq
+static S16 rgSCHTomUtlFillCqiSrSrsWithHq
(
- RgSchCellCb *cell,
- TfuRecpReqInfo *recpReqInfo,
- RgSchUeCb *ue,
- TfuUeRecpReqInfo *pucchRecpInfo,
- uint16_t validIdx,
- Bool isDatPresOnSecCell
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillCqiSrSrsWithHq(cell, recpReqInfo, ue,
- pucchRecpInfo, validIdx,isDatPresOnSecCell)
-RgSchCellCb *cell;
-TfuRecpReqInfo *recpReqInfo;
-RgSchUeCb *ue;
-TfuUeRecpReqInfo *pucchRecpInfo;
-uint16_t validIdx;
-Bool isDatPresOnSecCell;
-#endif
+RgSchCellCb *cell,
+TfuRecpReqInfo *recpReqInfo,
+RgSchUeCb *ue,
+TfuUeRecpReqInfo *pucchRecpInfo,
+uint16_t validIdx,
+Bool isDatPresOnSecCell
+)
{
RgSchUePCqiCb *cqiCb;
RgSchUePCqiCb *riCb;
- 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;
+ uint8_t ri; /*To fetch RI value*/
+ Bool willUeRprtCqi; /* Flag set due to CQI Mask and UE Inactive state (DRX)*/
+ Bool willUeRprtSr = TRUE;
+ TfuAckNackMode hqFdbkMode;
+ uint8_t numCqiBit;
+ uint8_t totalPucchBits;
+ Bool dropCqi = FALSE;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = NULL;
#endif
rgSCHTomUtlFetchPcqiBitSz(ue, cell->numTxAntPorts, &ri);
if(0 == pucchRecpInfo->t.pucchRecpReq.cqiInfo.cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d "
- "Unable to Fill CqiPmi size", ue->ueId);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
return RFAILED;
}
if(pucchRecpInfo->t.pucchRecpReq.uciInfo == TFU_PUCCH_HARQ_SR)
* -# RFAILED
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr
+static S16 rgSCHTomUtlFillCqiSrsWithSr
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuRecpReqInfo *recpReqInfo,
- TfuUeRecpReqInfo *pucchRecpInfo,
- uint16_t validIdx
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr(cell, ue, recpReqInfo,
- pucchRecpInfo, validIdx)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-TfuRecpReqInfo *recpReqInfo;
-TfuUeRecpReqInfo *pucchRecpInfo;
-uint16_t validIdx;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuRecpReqInfo *recpReqInfo,
+TfuUeRecpReqInfo *pucchRecpInfo,
+uint16_t validIdx
+)
{
- RgSchUePCqiCb *cqiCb;
- RgSchUePCqiCb *riCb;
- uint8_t ri; /*To fetch RI value*/
- Bool willUeRprtCqi; /* Flag set due to CQI Mask and
+ RgSchUePCqiCb *cqiCb;
+ RgSchUePCqiCb *riCb;
+ uint8_t ri; /*To fetch RI value*/
+ Bool willUeRprtCqi; /* Flag set due to CQI Mask and
UE Inactive state (DRX)*/
riCb = ue->nPRiCb;
cqiCb = ue->nPCqiCb;
rgSCHTomUtlFetchPcqiBitSz(ue, cell->numTxAntPorts, &ri);
if(0 == pucchRecpInfo->t.pucchRecpReq.cqiInfo.cqiPmiSz)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d"
- " Unable to Fill CqiPmi size", ue->ueId);
+ DU_LOG("\nERROR --> SCH : RNTI:%d Unable to Fill CqiPmi size", ue->ueId);
return RFAILED;
- }
+ }
pucchRecpInfo->t.pucchRecpReq.uciInfo = TFU_PUCCH_SR_CQI;
}
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk
+static S16 rgSCHTomUtlFillSfRepHqFdbk
(
- TfuRecpReqInfo *recpReqInfo,
- RgSchCellCb *cellCb,
- RgSchErrInfo *err,
- RgSchDlSf *dlSf,
- uint8_t noFdbks,
- CmMemListCp *memCp,
- uint8_t elemIdx,
- RgSchDlSf *nxtDlsf,
- uint16_t validIdx
- )
-#else
-PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk (recpReqInfo, cellCb, err, dlSf,
-noFdbks, memCp, elemIdx, nxtDlsf, validIdx)
- TfuRecpReqInfo *recpReqInfo;
- RgSchCellCb *cellCb;
- RgSchErrInfo *err;
- RgSchDlSf *dlSf;
- uint8_t noFdbks;
- CmMemListCp *memCp;
- uint8_t elemIdx;
- RgSchDlSf *nxtDlsf;
- uint16_t 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,
-uint8_t noFdbks,
-CmMemListCp *memCp,
-uint8_t 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;
- uint8_t noFdbks;
- CmMemListCp *memCp;
- uint8_t elemIdx;
- RgSchDlSf *nxtDlsf;
-#endif
#endif
{
RgSchDlHqProcCb *hqCb;
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to"
+ DU_LOG("\nERROR --> SCH : Unable to"
"Allocate TfuUeRecpReqInfo for RNTI:%d ", ueCb->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
* -# RFAILED
*/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkInfo
+static S16 rgSCHTomUtlFillSfHqFdbkInfo
(
- 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
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkInfo (recpReqInfo, cellCb, err, dlSf,
- noFdbks, memCp, elemIdx, nxtDlsf, validIdx, hqCb, pucchInfo, alloc, prvHqCb)
-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;
-#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,
- uint8_t noFdbks,
- CmMemListCp *memCp,
- uint8_t 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;
-uint8_t noFdbks;
-CmMemListCp *memCp;
-uint8_t 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;
* @param [out]uint16_t *hqRes
* @return void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlGethqRes
+static Void rgSCHTomUtlGethqRes
(
-uint8_t noFdbks,
-RgSchDlSf *dlSf,
-RgSchPdcch *pdcch,
-RgSchCellCb *cellCb,
-uint16_t *hqRes
+uint8_t noFdbks,
+RgSchDlSf *dlSf,
+RgSchPdcch *pdcch,
+RgSchCellCb *cellCb,
+uint16_t *hqRes
)
-#else
-PRIVATE Void rgSCHTomUtlGethqRes(noFdbks,dlSf,pdcch,cellCb,hqRes)
-uint8_t noFdbks;
-RgSchDlSf *dlSf;
-RgSchPdcch *pdcch;
-RgSchCellCb *cellCb;
-uint16_t *hqRes;
-#endif
{
- uint8_t M;
- uint8_t P;
- uint8_t m;
- uint8_t nP;
- uint8_t nPlusOne;
- uint8_t 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;
* @param [in] RgSchCellCb *cellCb
* @return void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1
(
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- uint8_t 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;
- uint8_t noFdbks;
- RgSchDlSf *dlSf;
- RgSchPdcch *pdcch;
- RgSchCellCb *cellCb;
-#endif
{
- RgSchUeCb *ue = NULLP;
- Bool isCellSec = FALSE;
- uint16_t hqRes;
+ RgSchUeCb *ue = NULLP;
+ Bool isCellSec = FALSE;
+ uint16_t hqRes;
/*ccpu00147920: UeCb is NULL for SPS activation*/
if(pdcch && pdcch->ue)
* @param [in] uint8_t elemIdx
* @return void
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234
+static Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234
(
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- uint8_t noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- RgSchCellCb *cellCb,
- uint8_t 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;
- uint8_t noFdbks;
- RgSchDlSf *dlSf;
- RgSchPdcch *pdcch;
- RgSchCellCb *cellCb;
- uint8_t elemIdx;
-#endif
{
- RgSchUeCb *ue;
- Bool isCellSec = FALSE;
- uint16_t hqRes = 0;
- uint8_t servCellIdx;
+ RgSchUeCb *ue;
+ Bool isCellSec = FALSE;
+ uint16_t hqRes = 0;
+ uint8_t servCellIdx;
if(pdcch)
{/* SPS Release pdcch or dynamic data */
* @param [out]TfuUePucchRecpReq *hqRecpReq
* @return S16
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForFrmt1BCS
+static S16 rgSCHTomUtlFillSfHqFdbkForFrmt1BCS
(
- RgSchDlHqProcCb *hqCb,
- TfuUePucchRecpReq *hqRecpReq,
- uint8_t noFdbks,
- RgSchDlSf *dlSf,
- RgSchPdcch *pdcch,
- uint8_t 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;
- uint8_t noFdbks;
- RgSchDlSf *dlSf;
- RgSchPdcch *pdcch;
- uint8_t elemIdx;
- RgSchCellCb *cellCb;
-#endif
{
/* Update teh fdbk mode if something different is present
* in L1 API file for F1BS *//* 1 --> F1BCS */
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForOneUe
+static S16 rgSCHTomUtlFillSfHqFdbkForOneUe
(
RgSchDlHqProcCb *hqCb,
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
-uint8_t noFdbks,
+uint8_t noFdbks,
CmMemListCp *memCp,
-uint8_t elemIdx,
+uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
CmLteRnti rnti,
RgrTddAckNackMode ackNackMode,
RgSchUePucchRecpInfo **pucchInfoRef,
RgSchPdcch *pdcch,
-TknUInt16 n1PucchTkn,
+TknUInt16 n1PucchTkn,
Bool *allocRef,
-uint8_t 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;
-uint8_t noFdbks;
-CmMemListCp *memCp;
-uint8_t elemIdx;
-RgSchDlSf *nxtDlsf;
-CmLteRnti rnti;
-RgrTddAckNackMode ackNackMode;
-RgSchUePucchRecpInfo **pucchInfoRef;
-RgSchPdcch *pdcch;
-TknUInt16 n1PucchTkn;
-Bool *allocRef;
-uint8_t hqSz;
-#endif
{
RgSchUePucchRecpInfo *pucchInfo = *pucchInfoRef;
Bool alloc = FALSE;
S16 ret;
TfuUePucchRecpReq *hqRecpReq;
#ifdef TFU_UPGRADE
- 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;
+ 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
- uint8_t multCnt;
+ uint8_t multCnt;
#endif
#ifdef LTEMAC_SPS
Bool isFirstFdbk = FALSE;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&pucchInfo,
sizeof(RgSchUePucchRecpInfo), memCp)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to "
+ DU_LOG("\nERROR --> SCH : Unable to "
"Allocate TfuUeRecpReqInfo for cell RNTI:%d",rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
if ((ret = rgSCHUtlGetEventMem((Ptr *)&(pucchInfo->pucchRecpInfo),
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp))) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to "
+ DU_LOG("\nERROR --> SCH : Unable to "
"Allocate TfuUeRecpReqInfo for cell RNTI:%d",rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
if(anInfo == NULL)
{/* ANInfo must be there. adding block
because of kworks*/
- RGSCHDBGERRNEW(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),
- "ANInfo should not be NULL for cellId=%d \n", cellCb->cellId));
+ DU_LOG("\nERROR --> SCH : ANInfo should not be NULL for cellId=%d \n", cellCb->cellId);
return RFAILED;
}
#endif
}else
{/* This needs to be revisited while
adding support for PUCCH format 3 */
- RGSCHDBGERRNEW(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),"Invalid Pucch format configured.."));
+ DU_LOG("\nERROR --> SCH : Invalid Pucch format configured..");
return RFAILED;
}
}
* @param [out] RgSchErrInfo *err
* @return S16
*/
-#ifdef ANSI
-PRIVATE S16 rgSCHTomUtlProcDlSfAtCrc
+static S16 rgSCHTomUtlProcDlSfAtCrc
(
RgSchDlSf *ulSf,
CmLteTimingInfo crntUlFrm,
TfuCntrlReqInfo *cntrlInfo,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHTomUtlProcDlSfAtCrc (ulSf, crntUlFrm, cell, cntrlInfo, err)
-RgSchDlSf *ulSf;
-CmLteTimingInfo crntUlFrm;
-RgSchCellCb *cell;
-TfuCntrlReqInfo *cntrlInfo;
-RgSchErrInfo *err;
-#endif
{
Inst inst = cell->instIdx;
S16 ret;
/* Fill PHICH info */
if ((ret = rgSCHTomUtlFillPhich (cell, cntrlInfo, ulSf, err)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send PHICH info for "
- "cell");
+ DU_LOG("\nERROR --> SCH : Unable to send PHICH info for cell");
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
/* Fill UL Pdcch */
if ((ret = rgSCHTomUtlFillUlPdcch (cell, cntrlInfo, ulSf, err)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send PDCCH info for "
- "cell");
+ DU_LOG("\nERROR --> SCH : Unable to send PDCCH info for cell");
RGSCH_FREE_MEM(cntrlInfo);
return ret;
}
if (cntrlInfo->ulPdcchLst.count || cntrlInfo->phichLst.count)
#endif
{
- if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo)
- != ROK)
+ //if (rgSCHUtlTfuCntrlReq(inst, cell->tfuSap->sapCfg.suId, cntrlInfo) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info for"
- " cell");
+ DU_LOG("\nERROR --> SCH : Unable to send Cntrl info for cell");
}
}
else
*
* @param [in] RgSchCellCb *cell
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlSendSfnTick
+static Void rgSCHTomUtlSendSfnTick
(
RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSCHTomUtlSendSfnTick (cell)
-RgSchCellCb *cell;
-#endif
{
RgrTtiIndInfo *rgrTtiInd;
if (rgSCHUtlAllocSBuf (cell->instIdx,
(Data**)&rgrTtiInd, sizeof(RgrTtiIndInfo)) != ROK)
{
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),
- "Mem alloc failed for RGR TTI ind, cellId (%d))\n",
- cell->cellId));
+ DU_LOG("\nERROR --> SCH : Mem alloc failed for RGR TTI ind, cellId (%d))\n",
+ cell->cellId);
return;
}
rgrTtiInd->cellId = cell->cellId;
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));
return;
* @return None
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE Void rgSCHDynTDDMrkCrntSfIdx
-(
-Inst schInst
-)
-#else /* ANSI */
-PRIVATE Void rgSCHDynTDDMrkCrntSfIdx(schInst)
-Inst schInst;
-#endif /* ANSI */
+static Void rgSCHDynTDDMrkCrntSfIdx(Inst schInst)
{
RgSchDynTddCb *rgSchDynTddInfo = &(rgSchCb[schInst].rgSchDynTdd);
rgSchDynTddInfo->crntDTddSfIdx = (rgSchDynTddInfo->crntDTddSfIdx + 1) %
RG_SCH_DYNTDD_MAX_SFINFO;
- //printf("Initializing Index %d \n", rgSchDynTddInfo->crntDTddSfIdx);
+ //DU_LOG("\nERROR --> SCH : Initializing Index %d \n", rgSchDynTddInfo->crntDTddSfIdx);
return;
}
*
*/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-PRIVATE Void rgSchTomFillCellTtiInfo
+static Void rgSchTomFillCellTtiInfo
(
TfuTtiIndInfo *ttiInd,
Inst schInst,
-uint8_t *nCell,
+uint8_t *nCell,
RgSchCellCb *cells[]
)
-#else
-PRIVATE Void rgSchTomFillCellTtiInfo (ttiInd, schInst, nCell, cells)
-TfuTtiIndInfo *ttiInd;
-Inst schInst;
-uint8_t *nCell;
-RgSchCellCb *cells[];
-#endif
{
- uint8_t i = 0;
- uint8_t strtCellId;
- TfuTtiCellInfo *cellInfo;
- RgSchCellCb *cell;
- uint32_t Idx1;
+ uint8_t i = 0;
+ uint8_t strtCellId;
+ TfuTtiCellInfo *cellInfo;
+ RgSchCellCb *cell;
+ uint32_t Idx1;
CmLteTimingInfo frm;
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);
}
#endif
void schFillCrntTime(
- SlotIndInfo slotInd,
+ SlotTimingInfo slotInd,
Inst schInst)
{
uint8_t cellCount = 0;
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiUlAndDlCmnChSch
+static Void rgSchTomTtiUlAndDlCmnChSch
(
RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiUlAndDlCmnChSch (cell)
-RgSchCellCb *cell;
-#endif
{
cell->rlsHqArr[cell->crntHqIdx].numUes = 0;
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiMiscFunctions
+static Void rgSchTomTtiMiscFunctions
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiMiscFunctions (cell)
-RgSchCellCb *cell;
-#endif
{
uint8_t suId = cell->tfuSap->sapCfg.suId;
if(rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&rgrLoadInf,
sizeof(RgrLoadInfIndInfo)) != ROK)
{
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"Could not "
- "allocate memory for sending LoadInfo\n"));
+ DU_LOG("\nERROR --> SCH : Could not "\
+ "allocate memory for sending LoadInfo\n");
return;
}
cell->lteAdvCb.absLoadTtiCnt = 0;
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomTtiDlSch
+static Void rgSchTomTtiDlSch
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomTtiDlSch (cell)
-RgSchCellCb *cell;
-#endif
{
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
* 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);
* 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);
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSchTomUtlTddRlsSfAndHarq
+static Void rgSchTomUtlTddRlsSfAndHarq
(
-RgSchCellCb *cell
+RgSchCellCb *cell
)
-#else
-PRIVATE Void rgSchTomUtlTddRlsSfAndHarq (cell)
-RgSchCellCb *cell;
-#endif
{
/* ccpu00132341-MOD- rgSchTddRlsDlSubfrmTbl is dependent on DELTA(=2).
* Returns: Void
*
*/
-#ifdef ANSI
-PRIVATE Void rgSCHTomUtlProcTddUlSf
-(
-RgSchCellCb *cell
-)
-#else
-PRIVATE Void rgSCHTomUtlProcTddUlSf (cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHTomUtlProcTddUlSf(RgSchCellCb *cell)
{
RgSchErrInfo err;
if (rgSCHTomUtlProcUlSf (cell, &err) != ROK)
{
/* fill in err type and call sta ind */
- RGSCHDBGERRNEW(cell->instIdx, (rgSchPBuf(cell->instIdx),
- "Unable to process Uplink subframe for cellId (%d))\n",
- cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to process Uplink subframe for cellId (%d))\n", cell->cellId);
}
}
/* TDD Fix , to allow Special SF SRS CFg */
if (rgSCHTomUtlPrcUlTddSpclSf(cell, &err) != ROK)
{
/* fill in err type and call sta ind */
- RGSCHDBGERRNEW(cell->instIdx, (rgSchPBuf(cell->instIdx),
- "Unable to process Sipceial subframe for cellId (%d))\n",
- cell->cellId));
+ DU_LOG("\nERROR --> SCH : Unable to process Sipceial subframe for cellId (%d))\n", cell->cellId);
}
}
Code Review / o-du / l2.git / blobdiff