/* LTE-MAC Scheduler instance control block structures */
-PUBLIC RgSchCb rgSchCb[RGSCH_MAX_INST];
+RgSchCb rgSchCb[RGSCH_MAX_INST];
#ifdef PHY_ERROR_LOGING
-PUBLIC RgSchUlAllocCntr rgSchUlAllocCntr;
+RgSchUlAllocCntr rgSchUlAllocCntr;
#endif
#ifdef EMTC_ENABLE
));
#endif
-PUBLIC S16 rgSCHEnbPfsDlCfg ARGS((
+S16 rgSCHEnbPfsDlCfg ARGS((
Inst instIdx,
RgSchErrInfo *err
));
RgSchRaCb *raCb,RgSchUeCb *ue, RgSchErrInfo *errInfo));
PRIVATE S16 rgSCHCfgRgrCmnLcCfg ARGS((RgSchCellCb *cell, RgrCmnLchCfg *lcCfg,
RgSchErrInfo *errInfo));
-PUBLIC Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,U8 idx));
+Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,U8 idx));
#ifdef RGR_SI_SCH
PRIVATE S16 rgSCHCfgVldtRgrCellSiCfg ARGS(( Inst inst, RgrSiCfg *siCfg));
#endif/*RGR_SI_SCH */
RgrCellCsgParamCfg *csgParam));
#ifdef TFU_UPGRADE
-PUBLIC S16 rgSCHCfgACqiUeCfg ARGS(( RgSchCellCb *cellCb,RgSchUeCb *ue, RgSchUeACqiCb *aCqiCb,
+S16 rgSCHCfgACqiUeCfg ARGS(( RgSchCellCb *cellCb,RgSchUeCb *ue, RgSchUeACqiCb *aCqiCb,
RgrTxMode ueTxMode,RgrUeAprdDlCqiCfg *aCqiCfg, CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHCfgAcqiUeReCfg ARGS(( RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgAcqiUeReCfg ARGS(( RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeAprdDlCqiCfg *acqiCfg, CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, U16 cfgIdx,
+S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, U16 cfgIdx,
U16 *peri, U16 *offset ));
-PUBLIC S16 rgSCHCfgRiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgRiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg, CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHCfgPCqiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgPCqiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,CmLteUeCategory ueCat ));
-PUBLIC S16 rgSCHCfgSrsUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
+S16 rgSCHCfgSrsUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg ));
-PUBLIC S16 rgSCHCfgSrUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
+S16 rgSCHCfgSrUeCfg ARGS((RgSchCellCb *cellCb,RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg));
-PUBLIC S16 rgSCHCfgPCqiUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgPCqiUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,CmLteUeCategory ueCat));
-PUBLIC S16 rgSCHCfgSrsUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgSrsUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg));
-PUBLIC S16 rgSCHCfgSrUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
+S16 rgSCHCfgSrUeReCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg));
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode ARGS((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrTxmodePuschMode ARGS((RgSchCellCb *cellCb,
RgrTxMode txMde, RgrAprdCqiMode puschMode,RgSchErrInfo *errInfo));
-PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg ARGS(( RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUeACqiCfg ARGS(( RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUeAprdDlCqiCfg *acqiCfg, RgrUeTxModeCfg txMode,
RgSchErrInfo *errInfo ));
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode ARGS((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrTxmodePucchMode ARGS((RgSchCellCb *cellCb,
RgrTxMode txMde, RgrPrdCqiMode pucchMode,RgSchErrInfo *errInfo));
#ifdef LTEMAC_HDFDD
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUePrdDlCqiCfg *cqiCfg, Bool hdFdd,
RgrUeTxModeCfg txMode, RgSchErrInfo *errInfo));
#else
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUePrdDlCqiCfg *cqiCfg, RgrUeTxModeCfg txMode,
RgSchErrInfo *errInfo));
#endif
#ifdef LTEMAC_HDFDD
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUeUlSrsCfg *srsCfg, Bool hdFdd,
RgSchErrInfo *errInfo));
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
+S16 rgSCHCfgVldtRgrUeUlSrsCfg ARGS ((RgSchCellCb *cellCb,
CmLteRnti crnti, RgrUeUlSrsCfg *srsCfg,
RgSchErrInfo *errInfo));
#endif
#ifdef LTEMAC_HDFDD
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
+S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
RgrUeSrCfg *srCfg, Bool hdFdd, RgSchErrInfo *errInfo));
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
+S16 rgSCHCfgVldtRgrUeSrCfg ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
RgrUeSrCfg *srCfg, RgSchErrInfo *errInfo));
#endif
PRIVATE S16 rgSCHCfgVldtCqiSrSrsUeCfg ARGS (( RgSchCellCb *cellCb,
RgrUeRecfg *ueReCfg,
RgSchErrInfo *errInfo ));
-PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel ARGS ((RgSchCellCb *cellCb,
+S16 rgSCHCfgPCqiSrsSrUeDel ARGS ((RgSchCellCb *cellCb,
RgSchUeCb *ueCb));
PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz ARGS (( RgSchUeACqiCb *acqiCb,U8 numTxAnt,
RgrUeRecfg *ueReCfg,
RgSchErrInfo *errInfo ));
#ifdef LTE_ADV
-PUBLIC S16 rgSCHSCellCfgUeCfg ARGS((
+S16 rgSCHSCellCfgUeCfg ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
RgSchErrInfo *err
));
-PUBLIC S16 rgSCHSCellCfgUePucchReCfg ARGS((
+S16 rgSCHSCellCfgUePucchReCfg ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
RgSchErrInfo *err
));
-PUBLIC S16 rgSCHCfgVldtRgrUeSCellRecfg ARGS((
+S16 rgSCHCfgVldtRgrUeSCellRecfg ARGS((
RgrUeRecfg *ueRecfg,
RgSchCellCb *cell,
RgSchUeCb *ue,
PRIVATE S16 rgSchAddToL2Meas ARGS ((RgSchCellCb *cellCb,RgSchDlLcCb *dlLc));
#endif
#ifdef EMTC_ENABLE
-PUBLIC S16 rgSCHEmtcCfgVldtDrxOnDurCfg
+S16 rgSCHEmtcCfgVldtDrxOnDurCfg
(
U16 onDurTmr
);
-PUBLIC Void rgSCHUtlUpdEmtcY
+Void rgSCHUtlUpdEmtcY
(
RgSchUeCb *ue
);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrSchedEnbCfg
+S16 rgSCHCfgVldtRgrSchedEnbCfg
(
Inst inst,
RgrSchedEnbCfg *schedEnbCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrSchedEnbCfg(inst, schedEnbCfg, errInfo)
+S16 rgSCHCfgVldtRgrSchedEnbCfg(inst, schedEnbCfg, errInfo)
Inst inst;
RgrSchedEnbCfg *schedEnbCfg;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrSchedEnbCfg);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "VALIDATE RGR SCH ENB CONFIG: \n"));
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_ENB_CFG;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellCfg
+S16 rgSCHCfgVldtRgrCellCfg
(
Inst inst,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellCfg(inst, cellCfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrCellCfg(inst, cellCfg, cell, errInfo)
Inst inst;
RgrCellCfg *cellCfg;
RgSchCellCb *cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_CFG;
/* check if cell exists already */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrSchCfg
+S16 rgSCHCfgVldtRgrSchCfg
(
Inst inst,
RgrSchedEnbCfg *rgSchedCfg
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrSchCfg(inst, rgSchedCfg)
+S16 rgSCHCfgVldtRgrSchCfg(inst, rgSchedCfg)
Inst inst;
RgrSchedCfg *rgSchedCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrSchCfg);
-
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Validating \
scheduler related Configuration"));
if (rgSchedCfg->ulSchdType > (RGSCH_NUM_SCHEDULERS - 1))
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellSchCfg
+S16 rgSCHCfgVldtRgrCellSchCfg
(
Inst inst,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)
+S16 rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)
Inst inst;
RgrCellCfg *cellCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellSchCfg);
#if RGSCH_NUM_DLFS_SCHEDULERS
if (cellCfg->dlfsSchdType > RGSCH_NUM_DLFS_SCHEDULERS - 1)
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellRACfg
+S16 rgSCHCfgVldtRgrCellRACfg
(
Inst inst,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)
+S16 rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)
Inst inst;
RgrCellCfg *cellCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellRACfg);
-
#ifdef LTE_TDD
if ((cellCfg->rachCfg.preambleFormat > RGSCH_MAX_TDD_RA_PREAMBLE_FMT) ||
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeCfg
+S16 rgSCHCfgVldtRgrUeCfg
(
Inst inst,
RgrUeCfg *ueCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeCfg(inst, ueCfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrUeCfg(inst, ueCfg, cell, errInfo)
Inst inst;
RgrUeCfg *ueCfg;
RgSchCellCb **cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrUeCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_CFG;
if (((*cell) == NULLP) ||
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrCellRecfg
+S16 rgSCHCfgVldtRgrCellRecfg
(
Inst inst,
RgrCellRecfg *cellRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrCellRecfg(inst, cellRecfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrCellRecfg(inst, cellRecfg, cell, errInfo)
Inst inst;
RgrCellRecfg *cellRecfg;
RgSchCellCb **cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrCellRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_RECFG;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellCfgUeCfg
+S16 rgSCHSCellCfgUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, err)
+S16 rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
RgrUePrdDlCqiCfg *pCqiCfg;
#endif
- TRC2(rgSCHSCellCfgUeCfg);
-
RLOG0(L_INFO, "SCELL recfg received from APP \n");
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSCellCfgUePucchReCfg
+S16 rgSCHSCellCfgUePucchReCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, err)
+S16 rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
RgrUeSCellAckPucchCfg *sCellPucchRecfg = NULLP;
U8 idx;
- TRC2(rgSCHSCellCfgUePucchReCfg);
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
"--------------------------------------------------------------------\n"
"UE SCell PUCCH ReConfiguration at SCH: rnti (%u) cell(%u)\n"
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeSCellRecfg
+S16 rgSCHCfgVldtRgrUeSCellRecfg
(
RgrUeRecfg *ueRecfg,
RgSchCellCb *cell,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSCellRecfg(inst, ueRecfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrUeSCellRecfg(inst, ueRecfg, cell, ue, errInfo)
RgrUeRecfg *ueRecfg;
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchCellCb *sCell = NULLP;
Inst inst = cell->instIdx;
- TRC2(rgSCHCfgVldtRgrUeSCellRecfg);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "VALIDATE RGR UE SCELL RECONFIG: cellId %d "
"oldUeId %d cell %p \n", ueRecfg->cellId, ueRecfg->oldCrnti));
RgSchUeCellInfo *sCellInfo = NULLP;
RgSchCmnCell *cellSch = NULLP;
- TRC2(rgSCHSCellCfgUeCfgRollBack);
-
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
"--------------------------------------------------------------------\n"
"UE SCell config roll back at SCH: rnti (%u) cell(%u)\n"
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeRecfg
+S16 rgSCHCfgVldtRgrUeRecfg
(
Inst inst,
RgrUeRecfg *ueRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeRecfg(inst, ueRecfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrUeRecfg(inst, ueRecfg, cell, ue, errInfo)
Inst inst;
RgrUeRecfg *ueRecfg;
RgSchCellCb **cell;
#endif
{
- TRC2(rgSCHCfgVldtRgrUeRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_RECFG;
if (((*cell) == NULLP) ||
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLchRecfg
+S16 rgSCHCfgVldtRgrLchRecfg
(
Inst inst,
RgrLchRecfg *lcRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLchRecfg(inst, lcRecfg, cell, ue, dlLc, errInfo)
+S16 rgSCHCfgVldtRgrLchRecfg(inst, lcRecfg, cell, ue, dlLc, errInfo)
Inst inst;
RgrLchRecfg *lcRecfg;
RgSchCellCb **cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLchRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LC_RECFG;
if (((*cell) == NULLP) ||
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeReset
+S16 rgSCHCfgVldtRgrUeReset
(
Inst inst,
RgrRst *reset,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeReset(inst, reset, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrUeReset(inst, reset, cell, ue, errInfo)
Inst inst;
RgrRst *reset;
RgSchCellCb *cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrUeReset);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_RESET;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLcgRecfg
+S16 rgSCHCfgVldtRgrLcgRecfg
(
Inst inst,
RgrLcgRecfg *lcgRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLcgRecfg(inst, lcgRecfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrLcgRecfg(inst, lcgRecfg, cell, ue, errInfo)
Inst inst;
RgrLcgRecfg *lcgRecfg;
RgSchCellCb *cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLcgRecfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LCG_RECFG;
if (((cell) == NULLP) ||
U16 numDlSf;
#endif
- TRC2(rgSCHDynCfiCfg);
-
cell->dynCfiCb.isDynCfiEnb = cellCfg->isDynCfiEnb;
/* Initializing Failure Sample Period */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrSchedEnbCfg
+S16 rgSCHCfgRgrSchedEnbCfg
(
Inst inst,
SpId spId,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrSchedEnbCfg(inst, spId, schedEnbCfg, errInfo)
+S16 rgSCHCfgRgrSchedEnbCfg(inst, spId, schedEnbCfg, errInfo)
Inst inst,
SpId spId;
RgrSchedEnbCfg *schedEnbCfg;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgRgrSchedEnbCfg);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "APPLYING RGR SCH ENB CONFIG: \n"));
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_ENB_CFG;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCH5gtfCellCfg
+S16 rgSCH5gtfCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC S16 rgSCH5gtfCellCfg(cell, cellCfg)
+S16 rgSCH5gtfCellCfg(cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
{
U8 idx;
- TRC2(rgSCHCfgRgrCellCfg);
-
for(idx = 0; idx < MAX_5GTF_GROUP; idx++)
{
cell->cell5gtfCb.ueGrp5gConf[idx].beamBitMask = 0;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrCellCfg
+S16 rgSCHCfgRgrCellCfg
(
RgSchCb *instCb,
SpId spId,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrCellCfg(instCb, spId, cellCfg, errInfo)
+S16 rgSCHCfgRgrCellCfg(instCb, spId, cellCfg, errInfo)
RgSchCb *instCb;
SpId spId;
RgrCellCfg *cellCfg;
Inst inst = instCb->rgSchInit.inst;
U32 Idx1 = (U8)((cellCfg->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- TRC2(rgSCHCfgRgrCellCfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_CFG;
- cmMemset((U8*)&pst, (U8)0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
/* Allocate the scheduler's cell control block */
if((ret = rgSCHUtlAllocSBuf(inst, (Data**)&cell, sizeof(RgSchCellCb)))
{
cell->lteAdvCb.absCfg =
cellCfg->rgrLteAdvCfg.absCfg;
- cmMemset((U8*)cell->lteAdvCb.absLoadInfo, 0, sizeof(U32)*RGR_ABS_PATTERN_LEN);
+ memset(cell->lteAdvCb.absLoadInfo, 0, sizeof(U32)*RGR_ABS_PATTERN_LEN);
cell->lteAdvCb.absLoadTtiCnt = 0;
}
cell->t300TmrVal = cellCfg->t300TmrVal;
#ifdef RGR_SI_SCH
/*Initialize the SI CB in Cell CB */
- cmMemset((U8 *)&cell->siCb, 0, sizeof(RgSchSiCb));
+ memset(&cell->siCb, 0, sizeof(RgSchSiCb));
#endif
/*Fix: Added Guard Pool for RNTI which will contain RNTIs
*for UEs deleted from Scheduler but not yet from MAC*/
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeCfg
+S16 rgSCHCfgRgrUeCfg
(
RgSchCellCb *cell,
RgrUeCfg *ueCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeCfg(cell, ueCfg, errInfo)
+S16 rgSCHCfgRgrUeCfg(cell, ueCfg, errInfo)
RgSchCellCb *cell;
RgrUeCfg *ueCfg;
RgSchErrInfo *errInfo;
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = NULLP;
#endif
- TRC2(rgSCHCfgRgrUeCfg);
do {
errInfo->errCause = RGSCHERR_CFG_RGR_UE_CFG;
#endif
{
- TRC2(rgSCHCfgRgrUePhrMsg3);
-
/* Record msg3 allocation in the UE */
rgSCHUtlRecMsg3Alloc(cell, ue, raCb);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDynCfiReCfg
+Void rgSCHDynCfiReCfg
(
RgSchCellCb *cell,
Bool isDynCfiEnb
)
#else
-PUBLIC Void rgSCHDynCfiReCfg(cell, isDynCfiEnb)
+Void rgSCHDynCfiReCfg(cell, isDynCfiEnb)
RgSchCellCb *cell;
Bool isDynCfiEnb;
#endif
U8 idx;
RgSchCmnDlCell *cellSchDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHDynCfiReCfg);
-
if(isDynCfiEnb)
{
cell->dynCfiCb.ttiCnt = 0;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrCellRecfg
+S16 rgSCHCfgRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *cellRecfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrCellRecfg(cell, cellRecfg, errInfo)
+S16 rgSCHCfgRgrCellRecfg(cell, cellRecfg, errInfo)
RgSchCellCb *cell;
RgrCellRecfg *cellRecfg;
RgSchErrInfo *errInfo;
U16 len; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
/* LTE_ADV_FLAG_REMOVED_END */
- TRC2(rgSCHCfgRgrCellRecfg);
-
-
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_RECFG;
/* Invoke scheduler to update scheduler specific information */
}
if(cellRecfg->rgrLteAdvCfg.pres & RGR_SFR)
{
- cmMemcpy((U8 *)&cell->lteAdvCb.sfrCfg, (U8 *)&cellRecfg->rgrLteAdvCfg.sfrCfg,
+ memcpy(&cell->lteAdvCb.sfrCfg, &cellRecfg->rgrLteAdvCfg.sfrCfg,
sizeof(RgrSfrConfig));
/* dsfr_pal_fixes ** 21-March-2013 ** SKS */
if (cellRecfg->rgrLteAdvCfg.sfrCfg.status == RGR_ENABLE)
RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
U8 idx;
- TRC2(rgSCHCfgRgrUeRecfgRntiChg);
-
/* Handle CRNTI change in reconfiguration */
if (ueRecfg->oldCrnti != ueRecfg->newCrnti)
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeRecfg
+S16 rgSCHCfgRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeRecfg(cell, ue, ueRecfg, errInfo)
+S16 rgSCHCfgRgrUeRecfg(cell, ue, ueRecfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
Bool dciChange = TRUE;
#endif
- TRC2(rgSCHCfgRgrUeRecfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_UE_RECFG;
#ifdef LTE_ADV
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLchRecfg
+S16 rgSCHCfgRgrLchRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLchRecfg(cell, ue, dlLc, lcRecfg, errInfo)
+S16 rgSCHCfgRgrLchRecfg(cell, ue, dlLc, lcRecfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
{
S16 ret = ROK;
- TRC2(rgSCHCfgRgrLchRecfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_LC_RECFG;
/* Invoke Scheduler to update the new configuration */
ret = rgSCHUtlRgrLcRecfg(cell, ue, dlLc, lcRecfg, errInfo);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcgRecfg
+S16 rgSCHCfgRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcgRecfg(cell, ue, lcgRecfg, errInfo)
+S16 rgSCHCfgRgrLcgRecfg(cell, ue, lcgRecfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgRecfg *lcgRecfg;
{
S16 ret = ROK;
- TRC2(rgSCHCfgRgrLcgRecfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_LCG_RECFG;
/*Added for handling LCG ReConfig if the LCG was deleted */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeReset
+S16 rgSCHCfgRgrUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeReset(cell, ue, reset, errInfo)
+S16 rgSCHCfgRgrUeReset(cell, ue, reset, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrRst *reset;
U32 idx;
RgSchRaCb *raCb;
- TRC2(rgSCHCfgRgrUeReset);
-
-
errInfo->errCause = RGSCHERR_CFG_RGR_UE_RESET;
/* Setting BO of Each Logical Channel of the UE to 0 */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrCellDel
+S16 rgSCHCfgRgrCellDel
(
RgSchCellCb *cell,
RgrDel *cellDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrCellDel(cell, cellDelInfo, errInfo)
+S16 rgSCHCfgRgrCellDel(cell, cellDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *cellDelInfo;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgRgrCellDel);
-
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_DEL;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrUeDel
+S16 rgSCHCfgRgrUeDel
(
RgSchCellCb *cell,
RgrDel *ueDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrUeDel(cell, ueDelInfo, errInfo)
+S16 rgSCHCfgRgrUeDel(cell, ueDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *ueDelInfo;
RgSchErrInfo *errInfo;
RgSchCellCb *secCellCb = NULLP;
#endif
- TRC2(rgSCHCfgRgrUeDel);
errInfo->errCause = RGSCHERR_CFG_RGR_UE_DEL;
if (cell->cellId != ueDelInfo->u.ueDel.cellId)
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcDel
+S16 rgSCHCfgRgrLcDel
(
RgSchCellCb *cell,
RgrDel *lcDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcDel(cell, lcDelInfo, errInfo)
+S16 rgSCHCfgRgrLcDel(cell, lcDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *lcDelInfo;
RgSchErrInfo *errInfo;
RgSchUlLcCb *ulLc;
#endif
- TRC2(rgSCHCfgRgrLcDel);
-
errInfo->errCause = RGSCHERR_CFG_RGR_LC_DEL;
/* Fetch the Active cell */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcgDel
+S16 rgSCHCfgRgrLcgDel
(
RgSchCellCb *cell,
RgrDel *lcDelInfo,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcgDel(cell, lcDelInfo, errInfo)
+S16 rgSCHCfgRgrLcgDel(cell, lcDelInfo, errInfo)
RgSchCellCb *cell;
RgrDel *lcDelInfo;
RgSchErrInfo *errInfo;
#endif
U8 lcgId = 0;
- TRC2(rgSCHCfgRgrLcgDel);
-
-
lcgId = lcDelInfo->u.lcgDel.lcgId;
errInfo->errCause = RGSCHERR_CFG_RGR_LCG_DEL;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLcCfg
+S16 rgSCHCfgVldtRgrLcCfg
(
Inst inst,
RgrLchCfg *lcCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLcCfg(inst, lcCfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrLcCfg(inst, lcCfg, cell, ue, errInfo)
Inst inst;
RgrLchCfg *lcCfg;
RgSchCellCb **cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLcCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LC_CFG;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLcgCfg
+S16 rgSCHCfgVldtRgrLcgCfg
(
Inst inst,
RgrLcgCfg *lcgCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLcgCfg(inst, lcgCfg, cell, ue, errInfo)
+S16 rgSCHCfgVldtRgrLcgCfg(inst, lcgCfg, cell, ue, errInfo)
Inst inst;
RgrLcgCfg *lcgCfg;
RgSchCellCb **cell;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrLcgCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LCG_CFG;
UNUSED(cellCfg);
UNUSED(errInfo);
- TRC2(rgSCHCfgVldtRgrCellPwrCfg);
-
/* This function does nothing now, placeholder for
* subsequent power config validations that may be needed */
U8 bitMask = 0x00;
U8 cnt=0;
- TRC2(rgSCHCfgVldtRgrCmnLcCfg);
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CMN_LC_CFG;
for (idx = 0; idx < cellCfg->numCmnLcs; idx++)
#endif
{
- TRC2(rgSCHCfgVldtUeCqiModeCfg)
-
#ifndef TFU_UPGRADE
if((ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx < 1) ||
(ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx > 1024))
#endif
{
- TRC2(rgSCHCfgVldtUeMeasGapAckNakRepCfg)
-
#ifdef LTE_TDD
if ((ueCfg->ackNackModeEnum == RGR_TDD_ACKNACK_MODE_MULT) &&
(ueCfg->ueAckNackCfg.isAckNackEnabled == TRUE))
#endif
{
- TRC2(rgSCHCfgVldtUeMeasGapAckNakRepRecfg)
if((ueRecfg->ueAckNackRecfg.isAckNackEnabled == FALSE) &&
(!ueRecfg->ueMeasGapRecfg.isMesGapEnabled))
{
U8 idx = 0;
- TRC2(rgSCHCfgVldtUeDlSpsCfg);
-
/* peridicity validation done in SPS module */
if ((dlSpsCfg->numPucchVal > RG_SCH_MAX_NUM_N1PUCCH_PER_UE) ||
(dlSpsCfg->numPucchVal == 0))
#endif
{
- TRC2(rgSCHCfgVldtUePwrCfg);
-
/* Group power control works only in accumulated mode */
if (!pwrCfg->isAccumulated)
{
#endif
{
- TRC2(rgSCHCfgVldtUeGrpPwrCfg);
-
if ((grpPwrCfg->pres) &&
(((grpPwrCfg->tpcRnti > cell->rntiDb.rntiStart) &&
((grpPwrCfg->tpcRnti <
#endif
{
- TRC2(rgSCHCfgVldtSpsReCfg);
if ((ueRecfg->ueRecfgTypes & RGR_UE_DLSPS_RECFG) &&
(ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled))
{
#endif
{
- TRC2(rgSCHCfgVldtCqiReptReCfg);
/* Validate DL Power Control Config parameters */
if (ueRecfg->ueCqiReptCfg.numColltdCqiRept > RGR_CQIRPTS_MAXN)
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLchCfg
+S16 rgSCHCfgRgrLchCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLchCfg(cell, ue, lcCfg, errInfo)
+S16 rgSCHCfgRgrLchCfg(cell, ue, lcCfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLchCfg *lcCfg;
RgSchUlLcCb *ulLc;
#endif
- TRC2(rgSCHCfgRgrLchCfg);
-
errInfo->errCause = RGSCHERR_CFG_RGR_DED_LC_CFG;
/* Allocate the downlink logical channel control block */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRgrLcgCfg
+S16 rgSCHCfgRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgRgrLcgCfg(cell, ue, lcgCfg, errInfo)
+S16 rgSCHCfgRgrLcgCfg(cell, ue, lcgCfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgCfg *lcgCfg;
U32 idx;
RgSchUlLcCb *ulLc;
#endif
- TRC2(rgSCHCfgRgrLcgCfg);
errInfo->errCause = RGSCHERR_CFG_RGR_DED_LCG_CFG;
#endif
{
RgSchClcDlLcCb cmnLcCb;
- TRC2(rgSCHCfgRgrCmnLcCfg);
errInfo->errCause = RGSCHERR_CFG_RGR_CMN_LC_CFG;
- cmMemset((U8 *)&cmnLcCb, 0, sizeof(cmnLcCb));
+ memset(&cmnLcCb, 0, sizeof(cmnLcCb));
/* Handle configuration for CCCH/BCCH/PCCH */
if (lcCfg->lcType == CM_LTE_LCH_CCCH)
#endif
{
Inst inst = cell->instIdx;
- TRC2(rgSCHCfgFreeDlDedLcCb);
rgSCHUtlFreeDlLc(cell, ue, dlLc);
RgSchClcDlLcCb *cmnDlLc;
#endif
{
- TRC2(rgSCHCfgFreeDlCmnLcCb);
- cmMemset((U8*)cmnDlLc, 0, sizeof(*cmnDlLc));
+ memset(cmnDlLc, 0, sizeof(*cmnDlLc));
cmnDlLc->lcId = RGSCH_INVALID_LC_ID;
RETVOID;
} /* rgSCHCfgFreeDlCmnLcCb */
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCfgFreeCellCb
+Void rgSCHCfgFreeCellCb
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCfgFreeCellCb(cell)
+Void rgSCHCfgFreeCellCb(cell)
RgSchCellCb *cell;
#endif
{
RgSchWarningSiPdu *warningSiPdu;
U8 idx;
- TRC2(rgSCHCfgFreeCellCb);
/* ccpu00132385- SI Warning PDUs which are not processed need to be deleted */
/* Search for used index in WarningSi */
for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
Inst inst = cell->instIdx;
U8 lcCnt;
U8 lcgId;
- TRC2(rgSCHCfgFreeUeCb);
/* Free all logical channel info per UE */
while((dlLc = rgSCHDbmGetNextDlDedLcCb(ue, NULLP)) != NULLP)
RgSchCfgElem *rgCfgElem;
Inst inst = cell->instIdx;
- TRC2(rgSCHCfgFreeRgrCfgLst);
-
/* Free CURRENT RGR cfg list */
while ((rgCfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
{
{
RgSchClcDlLcCb *dlCmnLc;
- TRC2(rgSCHCfgFreeCmnLcLst);
if ((dlCmnLc = rgSCHDbmGetBcchOnBch(cell)) != NULLP)
{
RgSchUeCellInfo *sCellInfo;
CmLList *node;
#endif
- TRC2(rgSCHCfgFreeUeLst);
/* Free Ues in the list */
while ((ue = rgSCHDbmGetNextUeCb(cell, NULLP)) != NULLP)
{
RgSchUeCb *ue;
- TRC2(rgSCHCfgFreeSpsUeLst);
-
/* Free Ues in the list */
while ((ue = rgSCHDbmGetNextSpsUeCb(cell, NULLP)))
{
UNUSED(inst);
- TRC2(rgSCHCfgVldtRgrCellSiCfg);
-
-
#ifndef LTE_TDD
/* Check that retxCnt value should be <= value of siWinSize.
This validation is only applicable for FDD mode. */
U32 idx;
UNUSED(inst);
- TRC2(rgSCHCfgVldtRgrCellLteAdvCfg);
-
-
if((lteAdvCfg->pres & RGR_SFR) && (RGR_ENABLE == lteAdvCfg->sfrCfg.status))
{
if(lteAdvCfg->sfrCfg.cellEdgeRbRange.startRb > lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb)
return RFAILED;
}
- cmMemcpy(temp, (U8 *) lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
+ memcpy(temp, lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
/* Added validation for ABS pattern len */
for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
#endif
{
- TRC2(rgSCHCfgVldtRgrCellCsgParamCfg);
-
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "Validating CSG Parameters \n"));
if(csgParam->minDlResNonCsg > 100)
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrSiCfg
+S16 rgSCHCfgVldtRgrSiCfg
(
Inst inst,
RgrSiCfgReqInfo *siCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrSiCfg(inst, siCfg, cell, errInfo)
+S16 rgSCHCfgVldtRgrSiCfg(inst, siCfg, cell, errInfo)
Inst inst;
RgrSiCfgReqInfo *siCfg;
RgSchCellCb *cell;
MsgLen msgLen = 0;
U8 numSi;
- TRC2(rgSCHCfgVldtRgrSiCfg);
-
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_SI_CFG;
/*Validate the cfgType parameter */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrLoadInf
+S16 rgSCHCfgVldtRgrLoadInf
(
Inst inst,
RgrLoadInfReqInfo *loadInfReq,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, errInfo)
+S16 rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, errInfo)
Inst inst;
RgrLoadInfReqInfo *loadInfReq;
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHCfgVldtRgrLoadInf);
-
-
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LOAD_INF;
/* Validate if the CC startRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode
+S16 rgSCHCfgVldtRgrTxmodePuschMode
(
RgSchCellCb *cellCb,
RgrTxMode txMde,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde, puschMode,errInfo)
+S16 rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde, puschMode,errInfo)
RgSchCellCb *cellCb;
RgrTxMode txMde;
RgrAprdCqiMode puschMode;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrTxmodePuschMode);
-
if (txMde == RGR_UE_TM_1 || txMde == RGR_UE_TM_2 ||
txMde == RGR_UE_TM_3 || txMde == RGR_UE_TM_7)
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg
+S16 rgSCHCfgVldtRgrUeACqiCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg(cellCb, crnti, acqiCfg,txMode, errInfo)
+S16 rgSCHCfgVldtRgrUeACqiCfg(cellCb, crnti, acqiCfg,txMode, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeAprdDlCqiCfg *acqiCfg;
{
RgrTxMode txMde;
RgrAprdCqiMode puschMode;
- TRC2(rgSCHCfgVldtRgrUeACqiCfg);
-
if(acqiCfg->pres)
{
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode
+S16 rgSCHCfgVldtRgrTxmodePucchMode
(
RgSchCellCb *cellCb,
RgrTxMode txMde,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde, pucchMode,errInfo)
+S16 rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde, pucchMode,errInfo)
RgSchCellCb *cellCb;
RgrTxMode txMde;
RgrPrdCqiMode pucchMode;
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHCfgVldtRgrTxmodePucchMode);
-
if (pucchMode == RGR_PRD_CQI_MOD10 || pucchMode == RGR_PRD_CQI_MOD20 )
{
*/
#ifdef LTEMAC_HDFDD
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg
+S16 rgSCHCfgVldtRgrUePCqiCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, hdFdd,
+S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, hdFdd,
txMode, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg
+S16 rgSCHCfgVldtRgrUePCqiCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, txMode, errInfo)
+S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, txMode, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUePrdDlCqiCfg *cqiCfg;
RgrTxMode txMde;
RgrPrdCqiMode pucchMode;
- TRC2(rgSCHCfgVldtRgrUePCqiCfg);
-
txMde = RGR_UE_TM_1;
pucchMode = RGR_PRD_CQI_MOD20;
if ( RGR_SCH_PCQI_SETUP == cqiCfg->type )
*/
#ifdef LTEMAC_HDFDD
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg
+S16 rgSCHCfgVldtRgrUeUlSrsCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, hdFdd, errInfo)
+S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, hdFdd, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeUlSrsCfg *srsCfg;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg
+S16 rgSCHCfgVldtRgrUeUlSrsCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, errInfo)
+S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeUlSrsCfg *srsCfg;
U16 srsOffset=0;
U8 srsSubframe=0;
- TRC2(rgSCHCfgVldtRgrUeUlSrsCfg);
-
-
if ( RGR_SCH_SRS_SETUP == srsCfg->type )
{
*/
#ifdef LTEMAC_HDFDD
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg
+S16 rgSCHCfgVldtRgrUeSrCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, hdFdd, errInfo)
+S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, hdFdd, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeSrCfg *srCfg;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg
+S16 rgSCHCfgVldtRgrUeSrCfg
(
RgSchCellCb *cellCb,
CmLteRnti crnti,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, errInfo)
+S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, errInfo)
RgSchCellCb *cellCb;
CmLteRnti crnti;
RgrUeSrCfg *srCfg;
#endif
{
- TRC2(rgSCHCfgVldtRgrUeSrCfg);
-
-
-
if ( RGR_SCH_SR_SETUP == srCfg->type )
{
/* 1. Validate SR Configuration related parameter values */
#endif
{
- TRC2(rgSCHCfgVldtCqiSrSrsUeCfg);
-
-
/* 1. Validate UE Aperiodic CQI related parameters */
if ( ROK != rgSCHCfgVldtRgrUeACqiCfg (cellCb, ueCfg->crnti,
&ueCfg->ueDlCqiCfg.aprdCqiCfg, ueCfg->txMode, errInfo ))
#endif
{
RgrUeTxModeCfg txMode;
- TRC3(rgSCHCfgVldtCqiSrSrsUeReCfg);
txMode.pres = TRUE;
txMode.tmTrnstnState = RGR_TXMODE_RECFG_CMPLT;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgACqiUeCfg
+S16 rgSCHCfgACqiUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ue,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgACqiUeCfg(cellCb,ue,acqiCb ueTxMode, aCqiCfg, ueCat)
+S16 rgSCHCfgACqiUeCfg(cellCb,ue,acqiCb ueTxMode, aCqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ue;
RgSchUeACqiCb *acqiCb;
U8 cqiPmiSzR1; /*CQIPMI Size for Rank =1*/
U8 cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
- TRC3(rgSCHCfgACqiUeCfg);
-
cqiPmiSzR1 = 0;
cqiPmiSzRn1 = 0;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgPCqiUeCfg
+S16 rgSCHCfgPCqiUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
+S16 rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
U8 temp;
U8 loop;
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHCfgPCqiUeCfg);
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)+
(cellCb->crntTime.slot);
ueCb->rawCqiBitW[loop].type = TFU_RECP_REQ_INVLD; /* setting invalid type*/
}
/* 1. Copy the Received CQI Cfg parameters to ueCb */
- cmMemcpy((U8 *)&cqiCb->cqiCfg, (U8 *)cqiCfg,
+ memcpy(&cqiCb->cqiCfg, cqiCfg,
sizeof(RgrUePrdDlCqiCfg));
/* 2. Compute Periodic CQI Periodicity and subframe offset */
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgRiUeCfg
+S16 rgSCHCfgRiUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
+S16 rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
U16 tempIdx;
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHCfgRiUeCfg);
-
-
-
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrsUeCfg
+S16 rgSCHCfgSrsUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg
)
#else
-PUBLIC S16 rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg)
+S16 rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeUlSrsCfg *srsCfg;
U16 crntTime;
U16 tempIdx;
- TRC3(rgSCHCfgSrsUeCfg);
-
-
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
if(RGR_SCH_SRS_SETUP == srsCfg->type)
{
/* 1. Copy the Received Cfg parameters to local cb */
- cmMemcpy((U8 *)&ueCb->srsCb.srsCfg, (U8 *)srsCfg, sizeof(RgrUeUlSrsCfg));
+ memcpy(&ueCb->srsCb.srsCfg, srsCfg, sizeof(RgrUeUlSrsCfg));
#ifndef LTE_TDD
/* 2. Compute SRS Offset and Periodicity */
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrUeCfg
+S16 rgSCHCfgSrUeCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg
)
#else
-PUBLIC S16 rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg)
+S16 rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeSrCfg *srCfg;
U16 srTrInsTime;
U16 crntTime;
- TRC3(rgSCHCfgSrUeCfg);
-
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
if(srCfg->type == RGR_SCH_SR_SETUP)
{
/* 1. Copy the Received Cfg parameters to local cb */
- cmMemcpy((U8 *)&ueCb->srCb.srCfg, (U8 *)srCfg, sizeof(RgrUeSrCfg));
+ memcpy(&ueCb->srCb.srCfg, srCfg, sizeof(RgrUeSrCfg));
/* 2. Compute SR periodicity and offset */
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgPCqiUeReCfg
+S16 rgSCHCfgPCqiUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgPCqiUeReCfg(cellCb, ueCb, cqiCfg, ueCat)
+S16 rgSCHCfgPCqiUeReCfg(cellCb, ueCb, cqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
{
RgSchUePCqiCb *cqiCb = NULLP;
- TRC3(rgSCHCfgPCqiUeReCfg);
cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
/* Fix: ccpu00124008 Fix for incorrect check causing missed CQI reception instance */
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrsUeReCfg
+S16 rgSCHCfgSrsUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeUlSrsCfg *srsCfg
)
#else
-PUBLIC S16 rgSCHCfgSrsUeReCfg(cellCb, ueCb, srsCfg)
+S16 rgSCHCfgSrsUeReCfg(cellCb, ueCb, srsCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeUlSrsCfg *srsCfg;
#endif
{
- TRC3(rgSCHCfgSrsUeReCfg);
-
-
if(( RGR_SCH_SRS_SETUP == srsCfg->type) ||
( RGR_SCH_SRS_SETUP != ueCb->srsCb.srsCfg.type ))
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgSrUeReCfg
+S16 rgSCHCfgSrUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgrUeSrCfg *srCfg
)
#else
-PUBLIC S16 rgSCHCfgSrUeReCfg(cellCb, ueCb, srCfg)
+S16 rgSCHCfgSrUeReCfg(cellCb, ueCb, srCfg)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeSrCfg *srCfg;
#endif
{
- TRC3(rgSCHCfgSrUeReCfg);
-
/* Fix : syed Incorrect check for SR RECFG */
if((srCfg->type == RGR_SCH_SR_SETUP) &&
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgAcqiUeReCfg
+S16 rgSCHCfgAcqiUeReCfg
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLteUeCategory ueCat
)
#else
-PUBLIC S16 rgSCHCfgAcqiUeReCfg(cellCb, ueCb, acqiCfg, ueCat)
+S16 rgSCHCfgAcqiUeReCfg(cellCb, ueCb, acqiCfg, ueCat)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgrUeAprdDlCqiCfg *acqiCfg;
CmLteUeCategory ueCat;
#endif
{
- TRC3(rgSCHCfgAcqiUeReCfg);
return (rgSCHCfgACqiUeCfg(cellCb,ueCb,(RG_SCH_CMN_GET_ACQICB(ueCb,cellCb))
,ueCb->mimoInfo.txMode, acqiCfg, ueCat));
* -# ROK
*/
#ifdef ANSI
-PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel
+S16 rgSCHCfgPCqiSrsSrUeDel
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel(cellCb, ueCb)
+S16 rgSCHCfgPCqiSrsSrUeDel(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
U32 sCellCnt = 0;
#endif
RgSchUePCqiCb *cqiRiCb = NULLP;
- TRC3(rgSCHCfgPCqiSrsSrUeDel);
cqiRiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetCfgPerOff
+S16 rgSCHUtlGetCfgPerOff
(
RgSchPerTbl tbl,
U16 cfgIdx,
U16 *offset
)
#else
-PUBLIC S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
+S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
RgSchPerTbl tbl;
U16 cfgIdx;
U16 *peri;
U8 min = 0;
U8 max = 0;
CONSTANT RgSchUePCqiSrsSrCfgIdxTbl* table;
- TRC3(rgSCHUtlGetCfgPerOff);
/* Added the function instead of the MACRO to get the
* periodicity table */
U32 confRepMode;
-
- TRC3(rgSCHCfgUtlFetchAcqiBitSz);
-
confRepMode = acqiCb->aCqiCfg.aprdModeEnum;
switch(confRepMode)
{
#endif
{
CONSTANT RgSchUePCqiSrsSrCfgIdxTbl * table;
- TRC3(rgSCHCfgUtlGetPcqiCrsSrRiTbl);
switch (tblType)
{
RgrUeDrxCfg *ueDrxCfg;
#endif
{
- TRC2(rgSCHCfgVldtDrxUeCfg)
-
if (ueDrxCfg->isDrxEnabled == FALSE)
{
U8 onDurTmr;
#endif
{
- TRC2(rgSCHCfgVldtDrxOnDurCfg)
switch ( onDurTmr )
{
U16 inActvTmr;
#endif
{
- TRC2(rgSCHCfgVldtDrxInActvCfg)
-
switch ( inActvTmr )
{
case RGR_DRX_PRD_1PSF:
U8 reTxTmr;
#endif
{
- TRC2(rgSCHCfgVldtDrxReTxCfg)
-
switch ( reTxTmr )
{
case RGR_DRX_PRD_1PSF:
RgrDrxLongCycleOffst lngCycleOffst;
#endif
{
- TRC2(rgSCHCfgVldtDrxLngCycCfg)
-
if ( rgSCHCfgVldtDrxLngCyclTmrs(lngCycleOffst.longDrxCycle) != ROK )
{
return RFAILED;
U16 val;
#endif
{
- TRC2(rgSCHCfgVldtDrxLngCyclTmrs)
switch ( val )
{
RgrDrxShortDrx shrtCycCfg;
#endif
{
- TRC2(rgSCHCfgVldtDrxShrtCycCfg)
-
switch(shrtCycCfg.shortDrxCycle)
{
case RGR_DRX_PRD_2SF:
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHCfgUeTaRecfg)
-
UNUSED(err);
/* Update the TA related information */
#endif
{
S16 retVal;
- TRC3(rgSCHCfgUeCqiReptReCfg)
/* Check has it been disabled */
if(ueRecfg->ueCqiReptCfg.numColltdCqiRept)
* @return VOID
**/
#ifdef ANSI
-PUBLIC Void rgSCHSCellFreeBuf
+Void rgSCHSCellFreeBuf
(
Inst inst,
RgSchUeCb *ue,
U8 idx
)
#else
-PUBLIC Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
+Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
Inst inst;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
RgSchUeCellInfo *sCellInfo = NULLP;
RgrUeSecCellCfg *sCellInfoRecfg = NULLP;
- TRC2(rgSCHSCellFreeBuf);
for(U8 i = 0; i <= idx; i++)
{
Code Review / o-du / l2.git / blobdiff