static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system service interface */
-#include "cm_hash.h" /* common hash list */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
-#include "cm5.h"
+#include "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "tfu.h"
#include "rl_common.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
#include "tfu.x" /* TFU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "rgr.x" /* layer management typedefs for MAC */
U8 sbSize,
Bool isEcp
));
-PUBLIC Void rgSCHEmtcCmnUeCcchSduDel
+Void rgSCHEmtcCmnUeCcchSduDel
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
PRIVATE Void rgSCHSelectSi ARGS((RgSchCellCb *cell));
#endif /*RGR_SI_SCH*/
/* LTE_ADV_FLAG_REMOVED_START */
+#ifdef UNUSED_FUNC
#ifndef LTE_TDD
PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
(
U16 bw
);
#endif
+PRIVATE Void rgSCHCmnNonDlfsType0Alloc
+(
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+RgSchDlRbAlloc *allocInfo,
+RgSchUeCb *ue
+);
+PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
+PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
+RgSchCmnUlCell *cellUl,
+RgSchUlAlloc *alloc,
+U8 idx
+));
+PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
+RgSchCellCb *cell,
+RgSchUlSf *sf
+));
-PUBLIC Void rgSCHCmnDlSpsSch
+#ifdef TFU_UPGRADE
+PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+U32 maxRb,
+U32 *numSb,
+U8 *iTbs,
+U32 hqSz,
+U32 stepDownItbs,
+U32 effTgt
+));
+#endif
+PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+U8 tpc
+));
+PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+U8 tpc
+));
+PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+U8 tpc
+));
+PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+U8 tpc
+));
+PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+U8 tpc
+));
+
+#endif
+
+Void rgSCHCmnDlSpsSch
(
RgSchCellCb *cell
);
RgSchCellCb *cell,
RgSchUeCb *ue));
#ifdef DL_LA
-PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa ARGS
+Void rgSCHCmnDlSetUeAllocLmtLa ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ue
));
#endif
-PRIVATE Void rgSCHCmnNonDlfsType0Alloc
-(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo,
-RgSchUeCb *ue
-);
PRIVATE Void rgSCHCmnInitRbAlloc ARGS
((
RgSchCellCb *cell
/* local defines */
-PUBLIC RgSchdApis rgSchCmnApis;
+ RgSchdApis rgSchCmnApis;
PRIVATE RgUlSchdApis rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
PRIVATE RgDlSchdApis rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
#ifdef EMTC_ENABLE
RgSchCmnDlRbAllocInfo *cellWdAllocInfo));
typedef U8 (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
U8 numLyrs, Bool bothCwEnbld));
-
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-U8 tpc
-));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-U8 tpc
-));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-U8 tpc
-));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-U8 tpc
-));
-PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-U8 tpc
-));
PRIVATE Void rgSCHCmnDlAllocTxRbTM1 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
U16 servCellId
));
-PUBLIC Bool rgSchCmnChkDataOnlyOnPcell
+Bool rgSchCmnChkDataOnlyOnPcell
(
RgSchUeCb *ue,
RgSchDlSf *dlSf
);
#endif /*LTE_ADV */
-PUBLIC U8 rgSCHCmnCalcPcqiBitSz
+U8 rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
U8 numTxAnt
));
#endif
-PUBLIC Bool rgSCHCmnRetxAllocAvoid ARGS((
+Bool rgSCHCmnRetxAllocAvoid ARGS((
RgSchDlSf *subFrm,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
));
-PUBLIC U16 rgSCHCmnGetSiSetId ARGS((
+U16 rgSCHCmnGetSiSetId ARGS((
U16 sfn,
U8 sf,
U16 minPeriodicity
));
-#ifdef TFU_UPGRADE
-PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-U32 maxRb,
-U32 *numSb,
-U8 *iTbs,
-U32 hqSz,
-U32 stepDownItbs,
-U32 effTgt
-));
-#endif
#ifdef RG_5GTF
//TODO_SID: Currenly table is only for 100 Prbs. Need to modify wrt VRBG table 8.1.5.2.1-1 V5G_213
/* CQI Offset Index to Beta CQI Offset value mapping,
* stored as parts per 1000. Reserved is set to 0.
* Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
-PUBLIC U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
+U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
3125, 3500, 4000, 5000, 6250};
-PUBLIC U32 rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
+U32 rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
4000, 5000, 6250, 8000,10000, 12625, 15875, 20000,
31000, 50000,80000,126000,0};
-PUBLIC U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
+U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
15875,20000,0,0,0};
-PUBLIC S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
+S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
/* Include CRS REs while calculating Efficiency */
CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
#ifdef TFU_UPGRADE
-PUBLIC S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
-PUBLIC S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
+S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
+S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
#endif
typedef struct rgSchCmnDlUeDciFrmtOptns
/* BI table from 36.321 Table 7.2.1 */
CONSTANT PRIVATE S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
0, 10, 20, 30,40,60,80,120,160,240,320,480,960};
-PUBLIC RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
+RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
{ 0, 0 },
{RGSCH_CMN_QM_CQI_1,RGSCH_CMN_UL_EFF_CQI_1 },
{RGSCH_CMN_QM_CQI_2,RGSCH_CMN_UL_EFF_CQI_2 },
#ifdef LTE_TDD
-PUBLIC RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
+RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
{RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME},
{RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME},
{RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME},
/* SPS_INTG_FIX */
#ifdef LTEMAC_SPS
-PUBLIC U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
+U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
/* 0 */ 6,
/* 1 */ 7,
/* 2 */ 8,
/* Special Subframes in OFDM symbols */
/* ccpu00134197-MOD-Correct the number of symbols */
-PUBLIC RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
+RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
{3, 1, 1, 3, 1, 1},
{9, 1, 1, 8, 1, 1},
{10, 1, 1, 9, 1, 1},
};
/* PHICH 'm' value Table */
-PUBLIC RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
+RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
{2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
{0, 1, 0, 0, 1, 0, 1, 0, 0, 1},
{0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
};
/* PHICH 'K' value Table */
-PUBLIC RgSchTddKPhichTbl rgSchTddKPhichTbl = {
+RgSchTddKPhichTbl rgSchTddKPhichTbl = {
{0, 0, 4, 7, 6, 0, 0, 4, 7, 6},
{0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
{0, 0, 6, 0, 0, 0, 0, 6, 0, 0},
};
/* Uplink association index 'K' value Table */
-PUBLIC RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
+RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
{0, 0, 6, 4, 0, 0, 0, 6, 4, 0},
{0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
{0, 0, 4, 4, 4, 0, 0, 0, 0, 0},
/* PUSCH 'K' value Table */
-PUBLIC RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
+RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{0, 6, 0, 0, 4, 0, 6, 0, 0, 4},
{0, 0, 0, 4, 0, 0, 0, 0, 4, 0},
/* PDSCH to PUCCH Table for DL Harq Feed back. Based on the
Downlink association set index 'K' table */
-PUBLIC U8 rgSchTddPucchTxTbl[7][10] = {
+U8 rgSchTddPucchTxTbl[7][10] = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{7, 6, 0, 0, 4, 7, 6, 0, 0, 4},
{7, 6, 0, 4, 8, 7, 6, 0, 4, 8},
So at sf4 the new CFI can be applied. To arrive at sf4 from
sf0, the sfIdx has to be increased by 3 */
-PUBLIC U8 rgSchTddPdcchSfIncTbl[7][10] = {
+U8 rgSchTddPdcchSfIncTbl[7][10] = {
/* A/N Bundl: 0,1,5,6*/ {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
/* A/N Bundl: 0,4,5,9*/ {2, 2, 0, 0, 3, 2, 2, 0, 0, 3},
/* A/N Bundl: 4,9*/ {3, 6, 0, 5, 4, 3, 6, 0, 5, 4},
#ifdef LTEMAC_SPS
/* subframe offset values to be used when twoIntervalsConfig is enabled in UL
* SPS for a UE */
-PUBLIC RgSchTddSfOffTbl rgSchTddSfOffTbl = {
+RgSchTddSfOffTbl rgSchTddSfOffTbl = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 1, -1, 0, 0, 0, 1, -1, 0},
{0, 0, 5, 0, 0, 0, 0, -5, 0, 0},
* as that of Msg3SubfrmTbl, indicates competition with msg3.
* As of now, this is same as Msg3SubfrmTbl (leaving out uldlcfg 2),
* except that all 255s are now zeros. */
-PUBLIC RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
+RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
{0, 0, 0, 6, 8, 0, 0, 0, 6, 8},
{0, 0, 6, 9, 0, 0, 0, 6, 9, 0},
{0, 0, 10, 0, 0, 0, 0, 10, 0, 0},
};
/* Inverse DL Assoc Set index Table */
-PUBLIC RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
+RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{7, 6, 0, 0, 4, 7, 6, 0, 0, 4},
{7, 6, 0, 4, 8, 7, 6, 0, 4, 8},
PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
/* Downlink HARQ processes Table */
-PUBLIC RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
+RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
/* Uplink HARQ processes Table */
-PUBLIC RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
+RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
/* Downlink association index set 'K' value Table */
-PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
+RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
{ {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
{ {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
/* ccpu132282-ADD-the table rgSchTddDlAscSetIdxKTbl is rearranged in
* decreasing order of Km, this is used to calculate the NCE used for
* calculating N1Pucch Resource for Harq*/
-PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
+RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
{ {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
{ {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
/* Minimum number of Ack/Nack feeback information to be
stored for each UL-DL configuration */
-PUBLIC RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
+RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
/* Uplink switch points and number of UL subframes Table */
-PUBLIC RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
+RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
{2,3,3}, {2,2,2}, {2,1,1}, {1,3,0}, {1,2,0}, {1,1,0}, {2,3,2}
};
/* Uplink switch points and number of DL subframes Table */
-PUBLIC RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
+RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
{2,2,2}, {2,3,3}, {2,4,4}, {1,7,0}, {1,8,0}, {1,9,0}, {2,2,3}
};
/* Number of UL subframes present before a particular subframe */
-PUBLIC RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
+RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
{0, 0, 1, 2, 3, 3, 3, 4, 5, 6},
{0, 0, 1, 2, 2, 2, 2, 3, 4, 4},
{0, 0, 1, 1, 1, 1, 1, 2, 2, 2},
};
/* Number of DL subframes present till a particular subframe */
-PUBLIC RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
+RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
{1, 2, 2, 2, 2, 3, 4, 4, 4, 4},
{1, 2, 2, 2, 3, 4, 5, 5, 5, 6},
{1, 2, 2, 3, 4, 5, 6, 6, 7, 8},
/* Nearest possible UL subframe Index from UL subframe
* DL Index < UL Index */
-PUBLIC RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
+RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
{0, 1, 1, 1, 1, 5, 6, 6, 6, 6},
{0, 1, 1, 1, 4, 5, 6, 6, 6, 9},
{0, 1, 1, 3, 4, 5, 6, 6, 8, 9},
/* Nearest possible DL subframe Index from UL subframe
* DL Index > UL Index
* 10 represents Next SFN low DL Idx */
-PUBLIC RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
+RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
{0, 1, 5, 5, 5, 5, 6, 10, 10, 10},
{0, 1, 4, 4, 4, 5, 6, 9, 9, 9},
{0, 1, 3, 3, 4, 5, 6, 8, 8, 9},
};
/* RACH Message3 related information */
-PUBLIC RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
+RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
{7, 6, 255, 255, 255, 7, 6, 255, 255, 255},
{7, 6, 255, 255, 8, 7, 6, 255, 255, 8},
{7, 6, 255, 9, 8, 7, 6, 255, 9, 8},
867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
};
+U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
-PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
-
-PUBLIC U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
-
-PUBLIC RgSchTbSzTbl rgTbSzTbl = {
+RgSchTbSzTbl rgTbSzTbl = {
{
{16, 32, 56, 88, 120, 152, 176, 208, 224, 256, 288, 328, 344, 376, 392, 424, 456, 488, 504, 536, 568, 600, 616, 648, 680, 712, 744, 776, 776, 808, 840, 872, 904, 936, 968, 1000, 1032, 1032, 1064, 1096, 1128, 1160, 1192, 1224, 1256, 1256, 1288, 1320, 1352, 1384, 1416, 1416, 1480, 1480, 1544, 1544, 1608, 1608, 1608, 1672, 1672, 1736, 1736, 1800, 1800, 1800, 1864, 1864, 1928, 1928, 1992, 1992, 2024, 2088, 2088, 2088, 2152, 2152, 2216, 2216, 2280, 2280, 2280, 2344, 2344, 2408, 2408, 2472, 2472, 2536, 2536, 2536, 2600, 2600, 2664, 2664, 2728, 2728, 2728, 2792, 2792, 2856, 2856, 2856, 2984, 2984, 2984, 2984, 2984, 3112},
{24, 56, 88, 144, 176, 208, 224, 256, 328, 344, 376, 424, 456, 488, 520, 568, 600, 632, 680, 712, 744, 776, 808, 872, 904, 936, 968, 1000, 1032, 1064, 1128, 1160, 1192, 1224, 1256, 1288, 1352, 1384, 1416, 1416, 1480, 1544, 1544, 1608, 1608, 1672, 1736, 1736, 1800, 1800, 1864, 1864, 1928, 1992, 1992, 2024, 2088, 2088, 2152, 2152, 2216, 2280, 2280, 2344, 2344, 2408, 2472, 2472, 2536, 2536, 2600, 2600, 2664, 2728, 2728, 2792, 2792, 2856, 2856, 2856, 2984, 2984, 2984, 3112, 3112, 3112, 3240, 3240, 3240, 3240, 3368, 3368, 3368, 3496, 3496, 3496, 3496, 3624, 3624, 3624, 3752, 3752, 3752, 3752, 3880, 3880, 3880, 4008, 4008, 4008},
RgSchCellCb *cell,
RgSchUeCb *ue
));
-PUBLIC RgSchUeCb* rgSCHCmnGetHoUe ARGS((
+RgSchUeCb* rgSCHCmnGetHoUe ARGS((
RgSchCellCb *cell,
U16 rapId
));
RgSchCellCb *cell,
U8 preambleId
));
-PUBLIC RgSchUeCb* rgSCHCmnGetPoUe ARGS((
+RgSchUeCb* rgSCHCmnGetPoUe ARGS((
RgSchCellCb *cell,
U16 rapId,
CmLteTimingInfo timingInfo
RgSchCellCb *cell
));
-/*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now PUBLIC */
+/*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now */
PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUlAlloc **ulAllocRef,
U8 *hqProcIdRef
));
-PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
- RgSchCmnUlCell *cellUl,
- RgSchUlAlloc *alloc,
- U8 idx
- ));
-
PRIVATE Void rgSCHCmnDlCcchRarAlloc ARGS((
RgSchCellCb *cell
));
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc
));
-PUBLIC Bool rgSCHCmnChkInWin ARGS((
+Bool rgSCHCmnChkInWin ARGS((
CmLteTimingInfo frm,
CmLteTimingInfo start,
CmLteTimingInfo end
));
-PUBLIC Bool rgSCHCmnChkPastWin ARGS((
+Bool rgSCHCmnChkPastWin ARGS((
CmLteTimingInfo frm,
CmLteTimingInfo end
));
RgSchUlSf *sf
));
/* Fix: syed Adaptive Msg3 Retx crash. */
-PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
-RgSchCellCb *cell,
-RgSchUlSf *sf
-));
-
#ifdef TFU_UPGRADE
PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
((
RgSchDlRbAlloc *allocInfo
));
#ifdef DEBUGP
+#ifdef UNUSED_FUNC
PRIVATE Void rgSCHCmnFindCodeRate ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
));
#endif
#endif
+#endif
PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
RgSchCellCb *cell,
RgSchCmnMsg4RbAlloc *msg4AllocInfo,
U8 resOfCrs; /* Effective REs occupied by CRS */
U8 i, j;
- TRC2(rgSCHCmnCompEff);
switch (cpType)
{
U8 noSymPerRb;
U8 i, j;
- TRC2(rgSCHCmnCompUlEff);
switch (cpType)
{
U8 resOfCrs; /* Effective REs occupied by CRS */
U8 i, j;
- TRC2(rgSCHCmn2LyrCompEff);
switch (cpType)
{
#endif
{
- TRC2(rgSCHCmnGetDciFrmtSizes);
/* DCI Format 0 size determination */
rgSchCmnDciFrmtSizes[0] = 1 +
U8 i;
U8 j;
- TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
{
RgSchCmnTbSzEff *effTbl;
RgSchCmnCqiToTbs *tbsTbl;
- TRC2(rgSCHCmnDlInit);
/* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
/* Init Efficiency table for normal cyclic prefix */
CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
S16 i;
S16 j;
- TRC2(rgSCHCmnUlInit);
/* Initaializing new variable added for UL eff */
rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnInit
+Void rgSCHCmnInit
(
)
#else
-PUBLIC Void rgSCHCmnInit()
+Void rgSCHCmnInit()
#endif
{
U8 idx;
- TRC2(rgSCHCmnInit);
rgSCHCmnDlInit();
rgSCHCmnUlInit();
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlRlsSubFrm
+Void rgSCHCmnDlRlsSubFrm
(
RgSchCellCb *cell,
CmLteTimingInfo frm
)
#else
-PUBLIC Void rgSCHCmnDlRlsSubFrm(cell, frm)
+Void rgSCHCmnDlRlsSubFrm(cell, frm)
RgSchCellCb *cell;
CmLteTimingInfo frm;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *sf;
- TRC2(rgSCHCmnDlRlsSubFrm);
/* Get the pointer to the subframe */
sf = rgSCHUtlSubFrmGet(cell, frm);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCcchRarAlloc);
rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
/* LTE_ADV_FLAG_REMOVED_START */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnCcchSduAlloc);
/* Return if subframe BW exhausted */
if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"bw<=bwAssigned for UEID:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rbAllocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
ueDl->proc->reqLnk.node = (PTR)ueDl->proc;
allocInfo->ccchSduAlloc.ccchSduDlSf->schdCcchUe++;
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief This function scheduler for downlink CCCH messages.
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduTx);
node = cell->ccchSduUeLst.first;
while(node)
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchTx);
node = cell->raInfo.toBeSchdLst.first;
while(node)
RgSchCmnDlUe *ueDl;
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduRetx);
node = cellSch->dl.ccchSduRetxLst.first;
while(node)
U8 retxBw = 0;
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchRetx);
node = cellSch->dl.msg4RetxLst.first;
while(node)
#endif/*RGR_SI_SCH*/
- TRC2(rgSCHCmnDlBcchPcch);
frm = cell->crntTime;
#ifdef LTEMAC_HDFDD
+ RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
#else
- RGSCH_SUBFRAME_INDEX(frm);
+ // RGSCH_SUBFRAME_INDEX(frm);
//RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
#endif
*
*/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnChkInWin
+Bool rgSCHCmnChkInWin
(
CmLteTimingInfo frm,
CmLteTimingInfo start,
CmLteTimingInfo end
)
#else
-PUBLIC Bool rgSCHCmnChkInWin(frm, start, end)
+Bool rgSCHCmnChkInWin(frm, start, end)
CmLteTimingInfo frm;
CmLteTimingInfo start;
CmLteTimingInfo end;
{
Bool inWin = FALSE;
- TRC2(rgSCHCmnChkInWin);
if (end.sfn > start.sfn)
{
}
}
- RETVALUE(inWin);
+ return (inWin);
} /* end of rgSCHCmnChkInWin*/
/*
*
*/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnChkPastWin
+Bool rgSCHCmnChkPastWin
(
CmLteTimingInfo frm,
CmLteTimingInfo end
)
#else
-PUBLIC Bool rgSCHCmnChkPastWin(frm, end)
+Bool rgSCHCmnChkPastWin(frm, end)
CmLteTimingInfo frm;
CmLteTimingInfo end;
#endif
CmLteTimingInfo refFrm = end;
Bool pastWin;
- TRC2(rgSCHCmnChkPastWin);
RGSCH_INCR_FRAME(refFrm.sfn);
RGSCH_INCR_SUB_FRAME(end, 1);
pastWin = rgSCHCmnChkInWin(frm, end, refFrm);
- RETVALUE(pastWin);
+ return (pastWin);
} /* end of rgSCHCmnChkPastWin*/
\f
/**
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnClcAlloc);
bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
*
**/
#ifdef ANSI
-PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc
+RgSchPdcch *rgSCHCmnCmnPdcchAlloc
(
RgSchCellCb *cell,
RgSchDlSf *subFrm
)
#else
-PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
+RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 numCce; /*store num CCEs based on
aggregation level */
- TRC2(rgSCHCmnCmnPdcchAlloc);
aggrLvl = cellSch->dl.cmnChAggrLvl;
numCce = 16;
break;
default:
- RETVALUE(NULLP);
+ return (NULLP);
}
if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
subFrm->cceCnt += numCce;
pdcch->pdcchSearchSpace = RG_SCH_CMN_SEARCH_SPACE;
- RETVALUE(pdcch);
+ return (pdcch);
}
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u",
aggrLvl);
- RETVALUE(NULLP);
+ return (NULLP);
}
\f
**/
#ifdef LTEMAC_SPS
#ifdef ANSI
-PUBLIC Void rgSCHCmnClcRbAlloc
+Void rgSCHCmnClcRbAlloc
(
RgSchCellCb *cell,
U32 bo,
RgSchDlSf *sf
)
#else
-PUBLIC Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
+Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
RgSchCellCb *cell;
U32 bo;
U8 cqi;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi = cellSch->dl.currCfi;
U32 tmpRb=0;
- TRC2(rgSCHCmnClcRbAlloc);
/* first get the CQI to MCS table and determine the number of RBs */
effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnMsg4Alloc);
/* SR_RACH_STATS : MSG4 TO BE TXED */
rgNumMsg4ToBeTx++;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
"bw<=bwAssigned");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHDhmGetMsg4HqProc failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
raCb->rbAllocInfo.dlSf = allocInfo->msg4Alloc.msg4DlSf;
rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnMsg4DedAlloc failed.");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
raCb->dlHqE->msg4Proc->reqLnk.node = (PTR)raCb->dlHqE->msg4Proc;
allocInfo->msg4Alloc.msg4DlSf->schdCcchUe++;
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**/
#ifdef ANSI
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc
+RgSchPdcch *rgSCHCmnPdcchAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isDtx
)
#else
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
+RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *subFrm;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
- TRC2(rgSCHCmnPdcchAlloc);
/* 3.1 consider the selected DCI format size in determining the
* aggregation level */
// prc_trace_format_string(PRC_TRACE_GROUP_PS, PRC_TRACE_INFO_LOW,"Forcing alloc in CMN search spc size %d fmt %d \n",
// pdcch->dciNumOfBits, dciFrmt);
}
- RETVALUE(pdcch);
+ return (pdcch);
}
#endif
"PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
- RETVALUE(NULLP);
+ return (NULLP);
}
if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
/* MSG4 */
pdcch->dciNumOfBits = cell->dciSize.size[dciFrmt];
}
- RETVALUE(pdcch);
+ return (pdcch);
}
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
- RETVALUE(NULLP);
+ return (NULLP);
}
#ifdef RGR_V1
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnCcchSduDedAlloc);
rbAllocinfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rbAllocinfo->rnti = ueCb->ueId;
rbAllocinfo->tbInfo[0].noLyr = 1;
- RETVALUE(ROK);
+ return ROK;
}
#endif
\f
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnMsg4DedAlloc);
effBo = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rbAllocinfo->tbInfo[0].schdlngForTb = TRUE;
rbAllocinfo->tbInfo[0].noLyr = 1;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_TDD
U8 sfnIdx;
U8 subfrmIdx;
U16 rntiIdx=0;
- TRC2(rgSCHCmnDlRaRsp);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
U8 raIdx;
RgSchCmnCell *sched;
U8 i,noRaRnti=0;
- TRC2(rgSCHCmnDlRaRsp);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnRaRspAlloc);
#ifndef RGR_V1
UNUSED(cellUl);
#endif
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"bw == bwAssigned RARNTI:%d",rarnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
reqLst = &cell->raInfo.raReqLst[raIndex];
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"reqLst Count=0 RARNTI:%d",rarnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
remNumRapid = reqLst->count;
if (!isAlloc)
{
RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
subFrm->bwAssigned = subFrm->bwAssigned + rb;
allocInfo->raRspAlloc[noRaRnti].tbInfo[0].noLyr = 1;
allocInfo->raRspAlloc[noRaRnti].vrbgReq = RGSCH_CEIL(nPrb,MAX_5GTF_VRBG_SIZE);
schdNumRapid += remNumRapid;
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocFillRbInfo
+Void rgSCHCmnUlAllocFillRbInfo
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
+Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
U8 cfi = cellDl->currCfi;
- TRC2(rgSCHCmnUlAllocFillRbInfo);
alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) +
cell->dynCfiCb.bwInfo[cfi].startRb;
U8 iMcs;
U8 numSb;
- TRC2(rgSCHCmnMsg3GrntReq);
*ulAllocRef = NULLP;
rgSCHUhmNewTx(hqProc, (U8)(cell->rachCfg.maxMsg3Tx - 1), alloc);
//RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
printf(
- "\nRNTI:%d MSG3 ALLOC proc(%p)procId(%d)schdIdx(%d)\n",
+ "\nRNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
alloc->rnti,
((PTR)alloc->hqProc),
alloc->hqProc->procId,
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi = cellSch->dl.currCfi;
- TRC2(rgSCHCmnDlSetUeAllocLmt);
#ifdef EMTC_ENABLE
if(TRUE == isEmtcUe)
U8 cqiBasediTbs;
U8 actualiTbs;
- TRC2(rgSCHCheckAndSetTxScheme);
maxiTbs = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
[RG_SCH_CMN_MAX_CQI - 1];
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa
+Void rgSCHCmnDlSetUeAllocLmtLa
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
+Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
U8 maxiTbs;
U8 cwIdx = 0;
- TRC2(rgSCHCmnDlSetUeAllocLmtLa);
maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
if(ueDl->cqiFlag == TRUE)
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlHqPResetTemp
+Void rgSCHCmnDlHqPResetTemp
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlHqPResetTemp(hqP)
+Void rgSCHCmnDlHqPResetTemp(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHCmnDlHqPResetTemp);
/* Fix: syed having a hqP added to Lists for RB assignment rather than
* a UE, as adding UE was limiting handling some scenarios */
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlUeResetTemp
+Void rgSCHCmnDlUeResetTemp
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlUeResetTemp(ue, hqP)
+Void rgSCHCmnDlUeResetTemp(ue, hqP)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
#endif
Void *tmpCb;
#endif
- TRC2(rgSCHCmnDlUeResetTemp);
/* Fix : syed check for UE's existence was useless.
* Instead we need to check that reset is done only for the
#ifdef LTE_ADV
tmpCb = allocInfo->laaCb;
#endif
- cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo, 0, sizeof(RgSchDlRbAlloc));
allocInfo->rnti = ue->ueId;
#ifdef LTE_ADV
allocInfo->laaCb = tmpCb;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlUeResetTemp
+Void rgSCHCmnUlUeResetTemp
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlUeResetTemp(cell, ue)
+Void rgSCHCmnUlUeResetTemp(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnUlUe *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlUeResetTemp);
- cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
+ memset(&cmnUlUe->alloc, 0, sizeof(cmnUlUe->alloc));
RETVOID;
} /* rgSCHCmnUlUeResetTemp */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnFillPdcch
+Void rgSCHCmnFillPdcch
(
RgSchCellCb *cell,
RgSchPdcch *pdcch,
RgSchDlRbAlloc *rbAllocInfo
)
#else
-PUBLIC Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
+Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
RgSchCellCb *cell;
RgSchPdcch *pdcch;
RgSchDlRbAlloc *rbAllocInfo;
#endif
{
- TRC2(rgSCHCmnFillPdcch);
/* common channel pdcch filling,
* only 1A and Local is supported */
U8 dlSfCnt = 0;
U8 splfrmIdx = 0;
- TRC2(rgSCHCmnIsSplSubfrm);
if(splfrmCnt > 0)
{
if(splfrmIdx == curSubfrmIdx)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/**
{
RgSchUeCb *ue = hqP->hqE->ue;
- TRC2(rgSCHCmnUpdHqAndDai);
if(subFrm != NULLP)
{
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUpdDai
+U8 rgSCHCmnUpdDai
(
RgSchUeCb *ue,
CmLteTimingInfo *fdbkTime,
U8 *ulDai
)
#else
-PUBLIC U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
+U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
RgSchUeCb *ue;
CmLteTimingInfo *fdbkTime;
U8 m;
U8 ackNackFdbkArrSize;
- TRC2(rgSCHCmnUpdDai);
if(hqP != NULLP)
{/* Non SPS */
*ulDai = anInfo->ulDai;
}
#endif
- RETVALUE(anInfo->dlDai);
+ return (anInfo->dlDai);
}
#endif /* ifdef LTE_TDD */
-PUBLIC U32 rgHqRvRetxCnt[4][2];
-PUBLIC U32 rgUlrate_grant;
+U32 rgHqRvRetxCnt[4][2];
+U32 rgUlrate_grant;
/**
* @brief This function fills the HqP TB with rbAllocInfo.
**/
#ifdef LTEMAC_SPS
#ifdef ANSI
-PUBLIC Void rgSCHCmnFillHqPTb
+Void rgSCHCmnFillHqPTb
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
+Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
U8 tbAllocIdx;
RgSchDlHqTbCb *tbInfo = tbAllocInfo->tbCb;
RgSchDlHqProcCb *hqP = tbInfo->hqP;
- TRC2(rgSCHCmnFillHqPTb);
/*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
* Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
#endif
{
- TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
//Currently hardcoding values here.
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnFillHqPPdcch
+Void rgSCHCmnFillHqPPdcch
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
+Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch = rbAllocInfo->pdcch;
U8 tpc = 1;
- TRC2(rgSCHCmnFillHqPPdcch);
if (hqP->hqE->ue)
{
}
RETVOID;
}
-
+#ifdef UNUSED_FUNC
/**
* @brief This function fills the PDCCH DCI format 1 information from dlProc.
*
* @return Void
*
**/
+
#ifdef ANSI
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1
(
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1Info.tpcCmd = tpc;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
#endif
RETVOID;
-}
+}
/**
* @brief This function fills the PDCCH DCI format 1B information from dlProc.
*
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1bInfo.tpcCmd = tpc;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
RETVOID;
}
-
+#endif
/**
* @brief init of Sch vars.
*
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnInitVars);
cellUl->idx = RGSCH_INVALID_INFO;
cellUl->schdIdx = RGSCH_INVALID_INFO;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUpdVars
+Void rgSCHCmnUpdVars
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnUpdVars(cell)
+Void rgSCHCmnUpdVars(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
U16 idx;
- TRC2(rgSCHCmnUpdVars);
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
cellUl->idx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetPhichUlSfIdx
+U8 rgSCHCmnGetPhichUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-PUBLIC U8 rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
+U8 rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
U16 sfn;
U8 subframe;
- TRC2(rgSCHCmnGetPhichUlSfIdx);
dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
if(dlsf->phichOffInfo.sfnOffset == RGSCH_INVALID_INFO)
{
- RETVALUE(RGSCH_INVALID_INFO);
+ return (RGSCH_INVALID_INFO);
}
subframe = dlsf->phichOffInfo.subframe;
numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
idx = numUlSf % (cellUl->numUlSubfrms);
- RETVALUE(idx);
+ return (idx);
}
/**
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetUlSfIdx
+U8 rgSCHCmnGetUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-PUBLIC U8 rgSCHCmnGetUlSfIdx(timeInfo, cell)
+U8 rgSCHCmnGetUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
U8 idx = 0;
U16 numUlSf;
- TRC2(rgSCHCmnGetUlSfIdx);
/* ccpu00130980: numUlSf(U16) parameter added to avoid integer
* wrap case such that idx will be proper*/
rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->subframe]) - 1;
idx = numUlSf % (cellUl->numUlSubfrms);
- RETVALUE(idx);
+ return (idx);
}
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetUlHqProcIdx
+U8 rgSCHCmnGetUlHqProcIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-PUBLIC U8 rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
+U8 rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
U8 numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
/* TRACE 5 Changes */
- TRC2(rgSCHCmnGetUlHqProcIdx);
/* Calculate the number of UL SF in one SFN */
numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
procId = numUlSf % numUlHarq;
#endif
- RETVALUE(procId);
+ return (procId);
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlFreeAlloc
+Void rgSCHCmnUlFreeAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlFreeAlloc(cell, alloc)
+Void rgSCHCmnUlFreeAlloc(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlFreeAllocation
+Void rgSCHCmnUlFreeAllocation
(
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
+Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
* -# NULLP when unsuccessful
**/
#ifdef ANSI
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
+RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
+RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchDlSf *sf;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnPdcchAllocCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
//pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, y, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_0, FALSE);
pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_A1, FALSE);
}
- RETVALUE(pdcch);
+ return (pdcch);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocFillNdmrs
+Void rgSCHCmnUlAllocFillNdmrs
(
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
+Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
RgSchCmnUlCell *cellUl;
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillNdmrs);
alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
RETVOID;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocLnkHqProc
+Void rgSCHCmnUlAllocLnkHqProc
(
RgSchUeCb *ue,
RgSchUlAlloc *alloc,
Bool isRetx
)
#else
-PUBLIC Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
+Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
RgSchUeCb *ue;
RgSchUlAlloc *alloc;
RgSchUlHqProcCb *proc;
Bool isRetx;
#endif
{
- TRC2(rgSCHCmnUlAllocLnkHqProc);
if(TRUE == isRetx)
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnPdcchRlsCrntSf
+Void rgSCHCmnPdcchRlsCrntSf
(
RgSchCellCb *cell,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
+Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
RgSchCellCb *cell;
RgSchPdcch *pdcch;
#endif
CmLteTimingInfo frm = cell->crntTime;
RgSchDlSf *sf;
- TRC2(rgSCHCmnPdcchRlsCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc
+Void rgSCHCmnUlFillPdcchWithAlloc
(
RgSchPdcch *pdcch,
RgSchUlAlloc *alloc,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
+Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
RgSchPdcch *pdcch;
RgSchUlAlloc *alloc;
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHCmnUlFillPdcchWithAlloc);
pdcch->ue = ue;
pdcch->rnti = alloc->rnti;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAllocFillTpc
+Void rgSCHCmnUlAllocFillTpc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
+Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillTpc);
alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
RETVOID;
}
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnAddUeToRefreshQ);
UNUSED(cell);
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
RgSchCmnLcg *lcgCmn;
CmLList *node;
RgSchCmnAllocRecord *allRcd;
- TRC2(rgSCHCmnUlUeReset);
ue->ul.minReqBytes = 0;
ue->ul.totalBsr = 0;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnResetRiCqi);
rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
cell->isCpUlExtend);
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlUeReset);
if (ueDl->rachInfo.poLnk.node != NULLP)
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUeReset
+Void rgSCHCmnUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUeReset(cell, ue)
+Void rgSCHCmnUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
Pst pst;
RgInfResetHqEnt hqEntRstInfo;
- TRC2(rgSCHCmnUeReset);
/* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
rgSCHCmnDelRachInfo(cell, ue);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnActvtUlUe
+Void rgSCHCmnActvtUlUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnActvtUlUe(cell, ue)
+Void rgSCHCmnActvtUlUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtUlUe);
/* : take care of this in UL retransmission */
cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnActvtDlUe
+Void rgSCHCmnActvtDlUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnActvtDlUe(cell, ue)
+Void rgSCHCmnActvtDlUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtDlUe);
cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
RETVOID;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdlUlTransInd
+Void rgSCHCmnHdlUlTransInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
+Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHCmnHdlUlTransInd);
/* Update the latest UL dat/sig transmission time */
RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
#endif
{
U32 bitMap0, bitMap1;
- TRC2(rgSCHCmnComp4TxMode4);
bitMap0 = pmiBitMap[0];
bitMap1 = pmiBitMap[1];
if((bitMap1) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap1>>16) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else if((bitMap0) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_3);
+ return (RG_SCH_CMN_RANK_3);
}
else if((bitMap0>>16) & 0xFFFF)
{
- RETVALUE (RG_SCH_CMN_RANK_4);
+ return (RG_SCH_CMN_RANK_4);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode4);
bitMap0 = pmiBitMap[0];
if((bitMap0>>26)& 0x0F)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap0>>30) & 3)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp4TxMode3);
bitMap0 = pmiBitMap[0];
if((bitMap0>>28)& 1)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap0>>29) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else if((bitMap0>>30) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_3);
+ return (RG_SCH_CMN_RANK_3);
}
else if((bitMap0>>31) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_4);
+ return (RG_SCH_CMN_RANK_4);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode3);
bitMap0 = pmiBitMap[0];
if((bitMap0>>30)& 1)
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
else if((bitMap0>>31) &1)
{
- RETVALUE (RG_SCH_CMN_RANK_2);
+ return (RG_SCH_CMN_RANK_2);
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
U8 numTxPorts;
#endif
{
- TRC2(rgSCHCmnComputeRank);
if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
{
- RETVALUE (rgSCHCmnComp2TxMode3(pmiBitMap));
+ return (rgSCHCmnComp2TxMode3(pmiBitMap));
}
else if (numTxPorts ==4 && txMode == RGR_UE_TM_3)
{
- RETVALUE (rgSCHCmnComp4TxMode3(pmiBitMap));
+ return (rgSCHCmnComp4TxMode3(pmiBitMap));
}
else if (numTxPorts ==2 && txMode == RGR_UE_TM_4)
{
- RETVALUE (rgSCHCmnComp2TxMode4(pmiBitMap));
+ return (rgSCHCmnComp2TxMode4(pmiBitMap));
}
else if (numTxPorts ==4 && txMode == RGR_UE_TM_4)
{
- RETVALUE (rgSCHCmnComp4TxMode4(pmiBitMap));
+ return (rgSCHCmnComp4TxMode4(pmiBitMap));
}
else
{
- RETVALUE (RG_SCH_CMN_RANK_1);
+ return (RG_SCH_CMN_RANK_1);
}
}
**/
/*KWORK_FIX:Changed function return type to void */
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlDeInitHqEnt
+Void rgSCHCmnDlDeInitHqEnt
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqE
)
#else
-PUBLIC Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
+Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
RgSchCellCb *cell;
RgSchDlHqEnt *hqE;
#endif
U8 cnt;
S16 ret;
- TRC2(rgSCHCmnDlDeInitHqEnt);
ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
/* Free only If the Harq proc are created*/
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnDlInitHqEnt
+S16 rgSCHCmnDlInitHqEnt
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqEnt
)
#else
-PUBLIC S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
+S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
RgSchCellCb *cell;
RgSchDlHqEnt *hqEnt;
#endif
U8 cnt;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlInitHqEnt);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
{
if (rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(hqP->sch), (sizeof(RgSchCmnDlHqProc))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#ifdef EMTC_ENABLE
{
if(ROK != cellSchd->apisEmtcDl->rgSCHDlUeHqEntInit(cell, hqEnt))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
if(ROK != cellSchd->apisDl->rgSCHDlUeHqEntInit(cell, hqEnt))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnDlInitHqEnt */
/**
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnGetRefreshDist);
for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
{
cell->refreshUeCnt[refOffst]++;
ue->refreshOffset = refOffst;
/* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst, cell->refreshUeCnt[refOffst]); */
- RETVALUE(refOffst);
+ return (refOffst);
}
}
cell->refreshUeCnt[refOffst-1]++;
ue->refreshOffset = refOffst-1;
- RETVALUE(refOffst-1);
+ return (refOffst-1);
}
/**
* @brief This function computes initial Refresh Wait Period.
U32 refreshPer;
U32 crntSubFrm;
- TRC2(rgSCHCmnGetRefreshPer);
refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrSCellUeCfg
+S16 rgSCHCmnRgrSCellUeCfg
(
RgSchCellCb *sCell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
+S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
RgSchCellCb *sCell;
RgSchUeCb *ue;
RgrUeSecCellCfg *sCellInfoCfg;
Inst inst = ue->cell->instIdx;
#endif
U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- TRC2(rgSCHCmnRgrSCellUeCfg);
pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
pCellUeDl = &pCellUeSchCmn->dl;
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueSchCmn = RG_SCH_CMN_GET_UE(ue,sCell);
if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* TODO: enhance for DLFS RB Allocation for SCELLs in future dev */
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
"Failed for CRNTI:%d", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueUlPcell = RG_SCH_CMN_GET_UL_UE(ue, ue->cell);
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
"for CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
allRcd->allocTime = sCell->crntTime;
cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
"power config for UE CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ue->ul.isUlCaEnabled = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrSCellUeCfg */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrSCellUeDel
+S16 rgSCHCmnRgrSCellUeDel
(
RgSchUeCellInfo *sCellInfo,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
+S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
RgSchUeCellInfo *sCellInfo;
RgSchUeCb *ue;
#endif
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
Inst inst = ue->cell->instIdx;
- TRC2(rgSCHCmnRgrSCellUeDel);
cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
(Data**)(&(sCellInfo->sch)), (sizeof(RgSchCmnUe)));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrSCellUeDel */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmn5gtfUeCfg
+S16 rgSCHCmn5gtfUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *cfg
)
#else
-PUBLIC S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
+S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
#endif
{
- TRC2(rgSCHCmnRgrUeCfg);
RgSchUeGrp *ue5gtfGrp;
ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
- RETVALUE(ROK);
+ return ROK;
}
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrUeCfg
+S16 rgSCHCmnRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
+S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
U32 waitPer;
U32 idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
- TRC2(rgSCHCmnRgrUeCfg);
/* 1. Allocate Common sched control block */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
ue->dl.ueDlCqiCfg = ueCfg->ueDlCqiCfg;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
"configured as 0 for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DL ambr */
ue->dl.ambrCfgd = (ueCfg->ueQosCfg.dlAmbr * RG_SCH_CMN_REFRESH_TIME)/100;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
"for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
allRcd->allocTime = cell->crntTime;
cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
}
/* After initialising UL part, do power related init */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
"power config for UE CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
"SPS config for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif /* LTEMAC_SPS */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
"for CRNTI:%d",ueCfg->crnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
rgSCHCmn5gtfUeCfg(cell, ue, ueCfg);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrUeCfg */
/**
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlHdlTxModeRecfg);
if (ueRecfg->txMode.pres != PRSNT_NODEF)
{
RgSchCmnCell *cellSchd;
#endif
{
- TRC2(rgSCHCmnUpdUeMimoInfo)
#ifdef TFU_UPGRADE
if(ueCfg->txMode.pres)
{
#endif
{
- TRC2(rgSCHCmnUpdUeUlCqiInfo)
#ifdef TFU_UPGRADE
if(ue->srsCb.srsCfg.type == RGR_SCH_SRS_SETUP)
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUpdUeCatCfg)
ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrUeRecfg
+S16 rgSCHCmnRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
U32 waitPer;
- TRC2(rgSCHCmnRgrUeRecfg);
/* Basic validations */
if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
{
"reporting mode %d for old CRNIT:%d",
(int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->dl.ueDlCqiCfg.prdCqiCfg = ueRecfg->prdDlCqiRecfg;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
"configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue->ul.cfgdAmbr = (ueRecfg->ueQosRecfg.ueBr * \
RG_SCH_CMN_REFRESH_TIME)/100;
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
/* DLFS UE Config */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrUeRecfg*/
/***********************************************************
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUlUeDelAllocs);
for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
{
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDelUeFrmRefreshQ);
#ifdef RGL_SPECIFIC_CHANGES
if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
#endif
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
RgSchDlHqProcCb *ccchSduHqP = NULLP;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUeCcchSduDel);
hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
if (hqE == NULLP)
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUeDel
+Void rgSCHCmnUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUeDel(cell, ue)
+Void rgSCHCmnUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
U8 cnt;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
U32 idx = 0;
- TRC2(rgSCHCmnUeDel);
if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
{
U8 i, rbNum;
U32 pdcchBits;
- TRC2(rgSCHCmnDlCnsdrCmnRt);
/* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
* bits per 1024/2 REs */
}
if (dlCmnCodeRate->ccchCqi == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
else
{
cellDl->dl.ccchCqi = dlCmnCodeRate->ccchCqi;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_TDD
U8 splSfCfi;
U8 mPhich;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
}
if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Intialize the RACH response scheduling related infromation */
if(rgSCHCmnDlRachInfoInit(cell) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate PRACH preamble list */
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (!cfg->maxCcchPerDlSf)
{
}
if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*ccpu00118273 - ADD - start */
ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
ret = rgSCHPwrCellCfg(cell, cfg);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset;
cellSch->dl.rarTxPwrOffset = cfg->rarTxPwrOffset;
cellSch->dl.phichTxPwrOffset = cfg->phichTxPwrOffset;
cellSch->dl.msg4pAVal = cfg->msg4pAVal;
- RETVALUE(ROK);
+ return ROK;
}
#else /* LTE_TDD */
/**
U8 cfi;
U8 cfiIdx;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
"FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
cellSch->dl.maxUePerDlSf,
cellSch->dl.maxUeNewTxPerTti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
- RETVALUE(RFAILED);
+ return RFAILED;
}
else if (!cfg->maxCcchPerDlSf)
{
if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListInit(&cellSch->dl.msg4RetxLst);
#ifdef RGR_V1
ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
ret = rgSCHPwrCellCfg(cell, cfg);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset;
cellSch->dl.rarTxPwrOffset = cfg->rarTxPwrOffset;
cellSch->dl.phichTxPwrOffset = cfg->phichTxPwrOffset;
RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
- RETVALUE(ROK);
+ return ROK;
}
#endif /* LTE_TDD */
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlCalcReqRbCeil
+U8 rgSCHCmnUlCalcReqRbCeil
(
U32 bytes,
U8 cqi,
RgSchCmnUlCell *cellUl
)
#else
-PUBLIC U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
+U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
U32 bytes;
U8 cqi;
RgSchCmnUlCell *cellUl;
#endif
{
U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
- TRC2(rgSCHCmnUlCalcReqRbCeil);
- RETVALUE((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
+ return ((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
}
/***********************************************************
U8 iTbs = 0;
U16 msg3GrntSz = 0;
- TRC2(rgSCHCmnPrecompMsg3Vars);
if (ccchCqi > cellUl->max16qamCqi)
{
if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(msgSzA, ccchCqi, cellUl), sbSize);
* Refer- TG36.321- section- 5.1.2*/
cellUl->ra.prmblANumSb = numSb;
cellUl->ra.prmblAIMcs = ccchMcs;
- RETVALUE(ROK);
+ return ROK;
}
-PUBLIC U32 gPrntPucchDet=0;
+U32 gPrntPucchDet=0;
#ifdef LTE_TDD
/***********************************************************
/* Maximum value of M as per Table 10.1-1 */
U8 M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
if (puschRbStart * 2 >= ulBw)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*rbStartRef = puschRbStart;
cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
}
- RETVALUE(ROK);
+ return ROK;
}
#else
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
if (puschRbStart*2 >= ulBw)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
- RETVALUE(RFAILED);
+ return RFAILED;
}
*rbStartRef = puschRbStart;
cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
#endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUlCellInit);
cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
if (maxUePerUlSf == 0)
"FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
cellUl->maxAllocPerUlSf,
cellUl->maxUeNewTxPerTti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
- RETVALUE(ret);
+ return (ret);
}
}
#endif
if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
- RETVALUE(RFAILED);
+ return RFAILED;
}
//Setting the subband size to 4 which is size of VRBG in 5GTF
#ifdef RG_5GTF
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
"maxUlBwPerUe/sbSize is zero");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl->maxSbPerUe = rgSchCmnMult235Tbl[maxSbPerUe].prvMatch;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
"Invalid cqi");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl->dfltUlCqi = cellCfg->ulCmnCodeRate.ccchCqi;
cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
#endif
cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
cellUl->sbSize = sbSize;
if (ret != ROK)
{
cellUl->numUlSubfrms = 0;
- RETVALUE(ret);
+ return (ret);
}
/* store the DL subframe corresponding to the PUSCH offset
#endif
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
if (cfi == 1)
cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi,
cell->pucchCfg.maxPucchRb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DMRS values */
cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
for (i = 0; i < cellUl->dmrsArrSize; ++i)
{
rgSCHUtlFreeSBuf(cell->instIdx,
(Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
#endif
- RETVALUE(ret);
+ return (ret);
}
}
RG_SCH_RESET_HCSG_UL_PRB_CNTR(cellUl);
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrCellCfg
+S16 rgSCHCmnRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
+S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
{
S16 ret;
RgSchCmnCell *cellSch;
- TRC2(rgSCHCmnRgrCellCfg);
/* As part of RGR cell configuration, validate the CRGCellCfg
* There is no trigger for crgCellCfg from SC1 */
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
cellSch = (RgSchCmnCell *)(cell->sc.sch);
cellSch->cfiCfg = cellCfg->cfiCfg;
{
/* There is no downlink deinit to be performed */
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
ret = rgSCHCmnDlRgrCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
/* DL scheduler has no initializations to make */
/* As of now DL scheduler always returns ROK */
ret = cellSch->apisEmtcUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
#endif
ret = cellSch->apisUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
#ifdef EMTC_ENABLE
if(TRUE == cellCfg->emtcEnable)
ret = cellSch->apisEmtcDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
#endif
ret = rgSCHCmnSpsCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
#endif
ret = cellSch->apisDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
rgSCHCmnInitVars(cell);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnRgrCellCfg*/
\f
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrCellRecfg
+S16 rgSCHCmnRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
+S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnRgrCellRecfg);
if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
{
err->errCause = RGSCHERR_SCH_CFG;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
"Invalid cqi");
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl->dfltUlCqi = recfg->ulCmnCodeRate.ccchCqi;
ret = rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
cellUl->dfltUlCqi = oldCqi;
rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
- RETVALUE(ret);
+ return (ret);
}
}
if (rgSCHCmnDlCnsdrCmnRt(cell, &recfg->dlCmnCodeRate) != ROK)
{
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ret = cellSch->apisEmtcUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Invoke DL sched for cell Recfg */
ret = cellSch->apisEmtcDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Invoke DL sched for cell Recfg */
ret = cellSch->apisDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ret = cellSch->apisDlfs->rgSCHDlfsCellRecfg(cell, recfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellSch->dl.isDlFreqSel = recfg->dlfsRecfg.isDlFreqSel;
}
ret = rgSCHPwrCellRecfg(cell, recfg);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
CmLList *lnk = NULLP;
RgSchL2MeasCb *measCb;
#endif
- TRC2(rgSCHCmnUlCellDeinit);
#ifdef LTE_L2_MEAS
#ifdef LTE_TDD
for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnCellDel
+Void rgSCHCmnCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnCellDel(cell)
+Void rgSCHCmnCellDel(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnCellDel);
#ifdef LTE_L2_MEAS
glblTtiCnt = 0;
{
U8 qci = dlQos->qci;
- TRC2(rgSCHCmnValidateDlQos);
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((qci >= RG_SCH_CMN_GBR_QCI_START) &&
{
if ((dlQos->mbr == 0) || (dlQos->mbr < dlQos->gbr))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLchCfg
+S16 rgSCHCmnRgrLchCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
+S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchCfg);
ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
"SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
if(lcCfg->lcType != CM_LTE_LCH_DCCH)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
"DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
/* Perform DL service activation in the scheduler */
((RgSchCmnDlSvc *)(dlLc->sch))->qci = lcCfg->dlInfo.dlQos.qci;
ret = cellSch->apisEmtcDl->rgSCHRgrDlLcCfg(cell, ue,dlLc ,lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisDl->rgSCHRgrDlLcCfg(cell, ue, dlLc, lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "rgSchCmnRgrLchCfg(): "
"SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLchRecfg
+S16 rgSCHCmnRgrLchRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
+S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchRecfg)
if(dlLc->lcType != CM_LTE_LCH_DCCH)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
"not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
- RETVALUE(ret);
+ return (ret);
}
((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcRecfg->dlRecfg.dlQos.gbr * \
RG_SCH_CMN_REFRESH_TIME)/100;
ret = cellSch->apisEmtcDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = cellSch->apisUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
"supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLcgCfg
+S16 rgSCHCmnRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
+S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgCfg);
ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
/* Indicate MAC that this LCG is GBR LCG */
rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcgCfg->ulInfo.lcgId, TRUE);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLcgRecfg
+S16 rgSCHCmnRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
+S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgRecfg);
ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
ret = cellSch->apisUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
if (ret != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
/* In case of RAB modification */
rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, FALSE);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
* File :
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnRgrLchDel
+S16 rgSCHCmnRgrLchDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
+S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchDel);
#ifdef EMTC_ENABLE
if(TRUE == ue->isEmtcUe)
{
{
cellSch->apisUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnLcgDel
+Void rgSCHCmnLcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg
)
#else
-PUBLIC Void rgSCHCmnLcgDel(cell, ue, lcg)
+Void rgSCHCmnLcgDel(cell, ue, lcg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
- TRC2(rgSCHCmnLcgDel);
if (lcgCmn == NULLP)
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnFreeDlLc
+Void rgSCHCmnFreeDlLc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHCmnFreeDlLc(cell, ue, svc)
+Void rgSCHCmnFreeDlLc(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnFreeDlLc);
if (svc->sch == NULLP)
{
RETVOID;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchUeCb *ue;
- TRC2(rgSCHCmnDlCcchSduRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchRaCb *raCb;
- TRC2(rgSCHCmnDlCcchRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
/* Fix: syed dlAllocCb reset should be performed.
hqP = (RgSchDlHqProcCb *)(node->node);
raCb = hqP->hqE->raCb;
node = node->next;
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
RETVOID;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchSduTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
}
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
/*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
/* rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
/* reset the UE allocation Information */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetBiIndex
+U8 rgSCHCmnGetBiIndex
(
RgSchCellCb *cell,
U32 ueCount
)
#else
-PUBLIC U8 rgSCHCmnGetBiIndex(cell, ueCount)
+U8 rgSCHCmnGetBiIndex(cell, ueCount)
RgSchCellCb *cell;
U32 ueCount;
#endif
U8 idx = 0;
U16 timeDiff = 0;
- TRC2(rgSCHCmnGetBiIndex)
if (cell->biInfo.prevBiTime != 0)
{
}while(idx < RG_SCH_CMN_NUM_BI_VAL-1);
cell->biInfo.prevBiTime = rgSchCmnBiTbl[idx];
/* For 16 Entries in Table 7.2.1 36.321.880 - 3 reserved so total 13 Entries */
- RETVALUE(idx); /* Returning reserved value from table UE treats it has 960 ms */
+ return (idx); /* Returning reserved value from table UE treats it has 960 ms */
} /* rgSCHCmnGetBiIndex */
U8 msg3Subfrm;
#endif
- TRC2(rgSCHCmnDlRaRspFnlz);
for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
{
{
U8 k, rv;
CmLteTimingInfo frm;
- TRC2(rgSCHCmnDlCalcRvForBcch);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
k = (frm.sfn/2) % 4;
}
rv = RGSCH_CEIL(3*k, 2) % 4;
- RETVALUE(rv);
+ return (rv);
}
/**
#endif
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnDlBcchPcchFnlz);
/* handle PCCH */
rbAllocInfo = &allocInfo->pcchAlloc;
{
CmLList *node;
- TRC2(rgSCHCmnUlSetAllUnSched);
node = allocInfo->contResLst.first;
while (node)
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAdd2CntResLst
+Void rgSCHCmnUlAdd2CntResLst
(
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
+Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
RgSchCmnUlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
- TRC2(rgSCHCmnUlAdd2CntResLst);
cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
RETVOID;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlAdd2UeLst
+Void rgSCHCmnUlAdd2UeLst
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
+Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
RgSchUeCb *ue;
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
- TRC2(rgSCHCmnUlAdd2UeLst);
if (ulAllocInfo->reqLnk.node == NULLP)
{
cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnAllocUlRb
+Void rgSCHCmnAllocUlRb
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHCmnAllocUlRb(cell, allocInfo)
+Void rgSCHCmnAllocUlRb(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
RgSchUlSf *sf = allocInfo->sf;
- TRC2(rgSCHCmnAllocUlRb);
/* Schedule for new transmissions */
rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
CmLteTimingInfo timeInfo;
#endif
#endif
- TRC2(rgSCHCmnUlRbAllocForLst);
if(schdLst->count == 0)
{
RETVOID;
}
+#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
/***********************************************************
*
Bool mdfyiTbsFlg = FALSE;
U8 resiTbs = *iTbs;
- TRC2(rgSCHCmnUlMdfyGrntForCqi)
do
if ((nPrb >= maxRb) && (resiTbs <= 10))
{
/* Could not accomodate ACQI */
- RETVALUE(RFAILED);
+ return RFAILED;
}
totREs = nPrb * RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
tbSz = rgTbSzTbl[0][resiTbs][nPrb-1];
*numSb = resNumSb;
*iTbs = resiTbs;
- RETVALUE(ROK);
+ return ROK;
}
#endif
+#endif
/***********************************************************
*
* Func : rgSCHCmnUlRbAllocForUe
U8 numLyr;
#endif
- TRC2(rgSCHCmnUlRbAllocForUe);
#ifdef RG_5GTF
rgSCHUhmGetAvlHqProc(cell, ue, &proc);
if (proc == NULLP)
{
//printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
gUl5gtfPdcchSchd++;
#if defined (TENB_STATS) && defined (RG_5GTF)
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
- RETVALUE(RFAILED);
+ return RFAILED;
}
gUl5gtfAllocAllocated++;
#if defined (TENB_STATS) && defined (RG_5GTF)
ueUl->alloc.alloc = alloc;
/*rntiwari-Adding the debug for generating the graph.*/
/* No grant attr recorded now */
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst
+Void rgSCHCmnUlRbAllocAddUeToLst
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLListCp *lst
)
#else
-PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
+Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLListCp *lst;
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlRbAllocAddUeToLst);
UNUSED(cell);
gUl5gtfUeRbAllocDone++;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlAllocFnlz);
/* call scheduler specific Finalization */
cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlAllocFnlz
+Void rgSCHCmnDlAllocFnlz
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDlAllocFnlz(cell)
+Void rgSCHCmnDlAllocFnlz(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlAllocFnlz);
rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
#endif
{
CmLList *lnk;
- TRC2(rgSCHCmnUlUpdSf);
while ((lnk = sf->allocs.first))
{
{
U32 bytes;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlHndlAllocRetx);
bytes = \
rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
[alloc->grnt.numRb-1]/8;
#endif
- TRC2(rgSCHCmnUlAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure */
rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSndCnsldtInfo
+Void rgSCHCmnSndCnsldtInfo
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnSndCnsldtInfo(cell)
+Void rgSCHCmnSndCnsldtInfo(cell)
RgSchCellCb *cell;
#endif
{
Pst pst;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSndCnsldtInfo);
subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnCnsldtSfAlloc
+Void rgSCHCmnCnsldtSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnCnsldtSfAlloc(cell)
+Void rgSCHCmnCnsldtSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
CmLListCp ulInActvLst;
RgSchCmnCell *cellSch = NULLP;
- TRC2(rgSCHCmnCnsldtSfAlloc);
cmLListInit(&dlDrxInactvTmrLst);
cmLListInit(&dlInActvLst);
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitDlRbAllocInfo);
- cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
+ memset(&allocInfo->pcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(&allocInfo->bcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo->raRspAlloc, 0,
RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
allocInfo->msg4Alloc.msg4DlSf = NULLP;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnInitUlRbAllocInfo
+Void rgSCHCmnInitUlRbAllocInfo
(
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
+Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitUlRbAllocInfo);
allocInfo->sf = NULLP;
cmLListInit(&allocInfo->contResLst);
cmLListInit(&allocInfo->schdContResLst);
RgSchDlSf *dlSf;
#endif
{
- TRC2(rgSCHCmnGrpPwrCntrlPucch);
rgSCHPwrGrpCntrlPucch(cell, dlSf);
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- TRC2(rgSCHCmnGrpPwrCntrlPusch);
/* Got to pass DL SF corresponding to UL SF, so get that first.
* There is no easy way of getting dlSf by having the RgSchUlSf*,
U32 effNonGbrBsr = 0;
U32 lcgId;
- TRC2(rgSCHCmnApplyUeRefresh);
/* Reset the refresh cycle variableCAP */
ue->ul.effAmbr = ue->ul.cfgdAmbr;
cellSch->apisUl->rgSCHUlUeRefresh(cell, ue);
cellSch->apisDl->rgSCHDlUeRefresh(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
#if (ERRCLASS & ERRCLS_DEBUG)
#endif
- TRC2(rgSCHCmnTmrExpiry);
#if (ERRCLASS & ERRCLS_DEBUG)
if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
"timer event CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
UNUSED(tmrEvnt);
rgSCHCmnAddUeToRefreshQ(cell, ue, RG_SCH_CMN_REFRESH_TIME);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
/* Moving the assignment of scheduler pointer
to available scope for optimization */
- TRC2(rgSCHCmnTmrProc);
if ((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES_5G) == 0)
{
cmPrcTmr(&sched->tmrTqCp, sched->tmrTq, (PFV)rgSCHCmnTmrExpiry);
}
- RETVALUE(ROK);
+ return ROK;
}
U8 splSfCfi = 0;
#endif
- TRC2(rgSchCmnUpdCfiVal);
pdsch = cell->crntTime;
RGSCH_INCR_SUB_FRAME(pdsch, delta);
{
U8 idx;
- TRC2(rgSchCmnUpdtPdcchSfIdx);
/* Resetting the parameters on CFI switching */
cell->dynCfiCb.cceUsed = 0;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSchCmnUpdCfiDb
+Void rgSchCmnUpdCfiDb
(
RgSchCellCb *cell,
U8 delta
)
#else
-PUBLIC Void rgSchCmnUpdCfiDb(cell, delta)
+Void rgSchCmnUpdCfiDb(cell, delta)
RgSchCellCb *cell;
U8 delta;
#endif
U8 dlIdx;
U16 ttiMod;
- TRC2(rgSchCmnUpdCfiDb);
/* Get Downlink Subframe */
frm = cell->crntTime;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlCommonChSch
+Void rgSCHCmnDlCommonChSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDlCommonChSch(cell)
+Void rgSCHCmnDlCommonChSch(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCommonChSch);
cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlSch
+Void rgSCHCmnUlSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnUlSch(cell)
+Void rgSCHCmnUlSch(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlSch);
#ifdef LTE_ADV
/* LAA_SCELL: */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlDedBoUpd
+Void rgSCHCmnDlDedBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
+Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlDedBoUpd);
/* RACHO : if UEs idle time exceeded and a BO update
* is received, then add UE to the pdcch Order Q */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnRmvFrmTaLst
+Void rgSCHCmnRmvFrmTaLst
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnRmvFrmTaLst(cell, ue)
+Void rgSCHCmnRmvFrmTaLst(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnRmvFrmTaLst);
#ifdef EMTC_ENABLE
if(cell->emtcEnable && ue->isEmtcUe)
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx
+Void rgSCHCmnDlMsg4ProcRmvFrmRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
+Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlProcAddToRetx
+Void rgSCHCmnDlProcAddToRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlProcAddToRetx(cell, hqP)
+Void rgSCHCmnDlProcAddToRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlProcAddToRetx);
if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
{
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUeInfo *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDlSetUeRi);
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlSetUePmi);
if (ue->txModeTransCmplt == FALSE)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cell->numTxAntPorts == 2)
{
if (pmi > 3)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (ueDl->mimoInfo.ri == 2)
{
/* PMI 2 and 3 are invalid incase of 2 TxAnt and 2 Layered SM */
if (pmi == 2 || pmi == 3)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDl->mimoInfo.pmi = pmi+1;
}
{
if (pmi > 15)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDl->mimoInfo.pmi = pmi;
}
/* Reset the No PMI Flag in forceTD */
RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
- RETVALUE(ROK);
+ return ROK;
}
/**
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode10);
if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode11);
if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode20);
if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode21);
if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlCqiOnPucchInd);
/* ccpu00117452 - MOD - Changed
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U32 prevRiVal = 0;
- TRC2(rgSCHCmnDlCqiOnPuschInd);
if (puschCqi->ri.pres == PRSNT_NODEF)
{
if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlCqiInd
+Void rgSCHCmnDlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
+Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isPucchInfo;
Bool is2ndCwCqiAvail = FALSE;
#endif
- TRC2(rgSCHCmnDlCqiInd);
#ifdef RGR_CQI_REPT
if (isPucchInfo)
#endif
{
U8 wideCqi=1; /*Calculated value from SNR*/
- TRC2(rgSCHCmnCalcWcqiFrmSnr);
/*Need to map a certain SNR with a WideCQI value.
* The CQI calculation is still primitive. Further, need to
* use a improvized method for calculating WideCQI from SNR*/
{
wideCqi=15;
}
- RETVALUE(wideCqi);
+ return (wideCqi);
}/*rgSCHCmnCalcWcqiFrmSnr*/
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnSrsInd
+Void rgSCHCmnSrsInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
+Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuSrsRpt *srsRpt;
{
U8 wideCqi; /*Calculated value from SNR*/
U32 recReqTime; /*Received Time in TTI*/
- TRC2(rgSCHCmnSrsInd);
recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlTARpt
+Void rgSCHCmnDlTARpt
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnDlTARpt(cell, ue)
+Void rgSCHCmnDlTARpt(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
CmLListCp poInactvLst;
- TRC2(rgSCHCmnDlTARpt);
/* RACHO: If UE idle time is more than threshold, then
* set its poInactv pdcch order inactivity */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlCqiInd
+Void rgSCHCmnUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
#endif
- TRC2(rgSCHCmnUlCqiInd);
/* consider inputs from SRS handlers about SRS occassions
* in determining the UL TX Antenna selection */
ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlHqProcForUe
+Void rgSCHCmnUlHqProcForUe
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
RgSchUlHqProcCb **procRef
)
#else
-PUBLIC Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
+Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
RgSchCellCb *cell;
CmLteTimingInfo frm;
RgSchUeCb *ue;
#ifndef RG_5GTF
U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
#endif
- TRC2(rgSCHCmnUlHqProcForUe);
#ifndef RG_5GTF
*procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
#else
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdUlHqProc
+S16 rgSCHCmnUpdUlHqProc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *curProc,
RgSchUlHqProcCb *oldProc
)
#else
-PUBLIC S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
+S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
RgSchCellCb *cell;
RgSchUlHqProcCb *curProc;
RgSchUlHqProcCb *oldProc;
#endif
{
- TRC2(rgSCHCmnUpdUlHqProc);
UNUSED(cell);
UNUSED(oldProc);
#if (ERRCLASS & ERRCLS_DEBUG)
if (curProc->alloc == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
curProc->alloc->hqProc = curProc;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnUpdUlHqProc */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnBsrTmrExpry
+S16 rgSCHCmnBsrTmrExpry
(
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHCmnBsrTmrExpry(ueCb)
+S16 rgSCHCmnBsrTmrExpry(ueCb)
RgSchUeCb *ueCb;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
- TRC2(rgSCHCmnBsrTmrExpry)
ueCb->isSrGrant = TRUE;
if(ueCb->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHSrRcvd(ueCb->cell, ueCb);
- RETVALUE(ROK);
+ return ROK;
}
}
else
cellSch->apisUl->rgSCHSrRcvd(ueCb->cell, ueCb);
}
- RETVALUE (ROK);
+ return (ROK);
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdBsrShort
+S16 rgSCHCmnUpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
+S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
#ifdef LTE_L2_MEAS
U8 idx;
#endif
- TRC2(rgSCHCmnUpdBsrShort);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (lcgCnt=0; lcgCnt<4; lcgCnt++)
{
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
- RETVALUE(ROK);
+ return ROK;
}
}
else
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdBsrTrunc
+S16 rgSCHCmnUpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
+S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
U8 idx;
#endif
- TRC2(rgSCHCmnUpdBsrTrunc);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* set all higher prio lcgs bs to 0 and update this lcgs bs and
total bsr= sumofall lcgs bs */
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
- RETVALUE(ROK);
+ return ROK;
}
}
else
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdBsrLong
+S16 rgSCHCmnUpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
+S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 *bsArr;
#endif
U32 lcgId;
- TRC2(rgSCHCmnUpdBsrLong);
#ifdef LTE_L2_MEAS
for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHUpdBsrLong(cell, ue, bsArr);
- RETVALUE(ROK);
+ return ROK;
}
}
else
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdExtPhr
+S16 rgSCHCmnUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
+S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo *extPhr;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdExtPhr);
UNUSED(err);
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnUpdExtPhr */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnUpdPhr
+S16 rgSCHCmnUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
+S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdPhr);
UNUSED(err);
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHCmnUpdPhr */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnContResUlGrant
+S16 rgSCHCmnContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnContResUlGrant(cell, ue, err)
+S16 rgSCHCmnContResUlGrant(cell, ue, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchErrInfo *err;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnContResUlGrant);
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHContResUlGrant(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
}
else
{
cellSch->apisUl->rgSCHContResUlGrant(cell, ue);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnSrRcvd
+S16 rgSCHCmnSrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
+S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLList *node = ueUl->ulAllocLst.last;
- TRC2(rgSCHCmnSrRcvd);
#ifdef EMTC_ENABLE
emtcStatsUlTomSrInd++;
if(ue->isEmtcUe)
{
cellSch->apisEmtcUl->rgSCHSrRcvd(cell, ue);
- RETVALUE(ROK);
+ return ROK;
}
}
else
{
cellSch->apisUl->rgSCHSrRcvd(cell, ue);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq
+RgSchUlAlloc *rgSCHCmnFirstRcptnReq
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
+RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
RgSchCellCb *cell;
#endif
{
/* ACC_TDD */
RgSchUlAlloc* alloc = NULLP;
- TRC2(rgSCHCmnFirstRcptnReq);
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
}
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq
+RgSchUlAlloc *rgSCHCmnNextRcptnReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
+RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
/* ACC-TDD */
//RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
- TRC2(rgSCHCmnNextRcptnReq);
/* ACC-TDD */
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
alloc = NULLP;
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
* @brief Collates DRX enabled UE's scheduled in this SF
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl
+Void rgSCHCmnDrxStrtInActvTmrInUl
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
+Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
RgSchCellCb *cell;
#endif
{
RgSchUeCb *ueCb;
- TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
-
cmLListInit(&ulUeLst);
while(alloc)
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
+RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
+RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
U8 idx;
#endif
/* ACC-TDD */
RgSchUlAlloc *alloc = NULLP;
- TRC2(rgSCHCmnFirstHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
}
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
+RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
+RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
U8 idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnNextHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
{
alloc = NULLP;
}
- RETVALUE(alloc);
+ return (alloc);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs
+U8 rgSCHCmnUlGetITbsFrmIMcs
(
U8 iMcs
)
#else
-PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
+U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
U8 iMcs;
#endif
{
- TRC2(rgSCHCmnUlGetITbsFrmIMcs);
- RETVALUE(rgUlIMcsTbl[iMcs].iTbs);
+ return (rgUlIMcsTbl[iMcs].iTbs);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs
+U8 rgSCHCmnUlGetIMcsFrmITbs
(
U8 iTbs,
CmLteUeCategory ueCtg
)
#else
-PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
+U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
U8 iTbs;
CmLteUeCategory ueCtg;
#endif
{
U8 iMcs;
- TRC2(rgSCHCmnUlGetIMcsFrmITbs);
if (iTbs <= 10)
{
}
#endif
- RETVALUE(iMcs);
+ return (iMcs);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs
+U32 rgSCHCmnUlMinTbBitsForITbs
(
RgSchCmnUlCell *cellUl,
U8 iTbs
)
#else
-PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
+U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
RgSchCmnUlCell *cellUl;
U8 iTbs;
#endif
{
- TRC2(rgSCHCmnUlMinTbBitsForITbs);
RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs);
- RETVALUE(rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
+ return (rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc
+RgSchUlAlloc *rgSCHCmnUlSbAlloc
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
+RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
{
U8 holeSz; /* valid hole size */
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlSbAlloc);
if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
{
}
alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
}
- RETVALUE(alloc);
+ return (alloc);
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlUeFillAllocInfo
+Void rgSCHCmnUlUeFillAllocInfo
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
+Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnUeUlAlloc *ulAllocInfo;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlUeFillAllocInfo);
ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
ulAllocInfo = &ueUl->alloc;
U32 nonLcg0Bsr=0;
U8 lcgId;
RgSchCmnLcg *cmnLcg = NULLP;
- TRC2(rgSCHCmnUpdUlCompEffBsr);
while (node)
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlRecordUeAlloc
+Void rgSCHCmnUlRecordUeAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnUlRecordUeAlloc(cell, ue)
+Void rgSCHCmnUlRecordUeAlloc(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
RgSchCmnUeUlAlloc *ulAllocInfo = &ueUl->alloc;
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRecordUeAlloc);
cmLListDelFrm(lst, &allRcd->lnk);
#ifndef LTE_TDD
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlRecMsg3Alloc
+Void rgSCHCmnUlRecMsg3Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
+Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
/* Stack Crash problem for TRACE5 changes */
- TRC2(rgSCHCmnUlRecMsg3Alloc);
cmLListDelFrm(lst, node);
allRcd->allocTime = raCb->msg3AllocTime;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlUpdOutStndAlloc
+Void rgSCHCmnUlUpdOutStndAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 alloc
)
#else
-PUBLIC Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
+Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 alloc;
#endif
{
U32 nonLcg0Alloc=0;
- TRC2(rgSCHCmnUlUpdOutStndAlloc);
/* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetITbs
+U8 rgSCHCmnUlGetITbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
+U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isEcp;
U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi];
#endif
- TRC2(rgSCHCmnUlGetITbs);
/* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
#ifdef TFU_UPGRADE
iTbs = 19;
}
#endif
- RETVALUE(iTbs);
+ return (iTbs);
#endif
#else
if ( (ueCtgy != CM_LTE_UE_CAT_5) && (ueUl->crntUlCqi[0] > ueUl->maxUlCqi ))
cqi = ueUl->crntUlCqi[0];
}
#endif
- RETVALUE(rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
+ return (rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
}
/**
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbInfoAddUeTx);
if (hqP->reqLnk.node == NULLP)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetx);
if (cellSch->dl.isDlFreqSel)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
if (cellSch->dl.isDlFreqSel)
{
{
CmLList *schdLnkNode;
- TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
#ifdef LTEMAC_SPS
if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) &&
RgSchTddSubfrmInfo ulSubfrmInfo;
U8 maxUlSubfrms;
- TRC2(rgSCHCmnDlANFdbkInit);
ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
cell->subFrms[sfNum]->dlFdbkInfo.sfnOffset;
cell->subFrms[dlIdx]->dlFdbkInfo.m = cell->subFrms[sfNum]->dlFdbkInfo.m;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
[RGSCH_NUM_SUB_FRAMES-1];
U8 dlPres = 0;
- TRC2(rgSCHCmnDlKdashUlAscInit);
/* Generate ACK/NACK offset information for each DL subframe in a radio frame
* Calculate this information based on K` in UL Association Set table */
cell->subFrms[dlIdx]->ulAscInfo.sfnOffset =
cell->subFrms[sfNum]->ulAscInfo.sfnOffset;
}
- RETVALUE(ROK);
+ return ROK;
}
{
U8 idx;
U16 np;
- TRC2(rgSCHCmnDlNpValInit);
/* Always Np is 0 for p=0 */
cell->rgSchTddNpValTbl[0] = 0;
cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
S16 ret;
U8 lstSize;
- TRC2(rgSCHCmnDlCreateRachPrmLst);
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
(Data **)(&cell->raInfo.raReqLst), (Size)(lstSize * sizeof(CmLListCp)));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
cell->raInfo.lstSize = lstSize;
- RETVALUE(ROK);
+ return ROK;
}
S8 sfnOffset;
U8 numSubfrms;
- TRC2(rgSCHCmnDlRachInfoInit);
- cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
+ memset(rachRspLst, 0, sizeof(rachRspLst));
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
ret = rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- TRC2(rgSCHCmnDlPhichOffsetInit);
/* Generate PHICH offset information for each DL subframe in a radio frame
* Calculate this information based on K in PHICH table */
cell->subFrms[dlIdx]->phichOffInfo.sfnOffset =
cell->subFrms[sfNum]->phichOffInfo.sfnOffset;
}
- RETVALUE(ROK);
+ return ROK;
}
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUpdVars
+Void rgSCHCmnUpdVars
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnUpdVars(cell)
+Void rgSCHCmnUpdVars(cell)
RgSchCellCb *cell;
#endif
{
U8 ulDlCfgIdx = cell->ulDlCfgIdx;
U8 msg3Subfrm;
U8 Mval;
- TRC2(rgSCHCmnUpdVars);
/* ccpu00132654-ADD- Initializing all the indices in every subframe*/
rgSCHCmnInitVars(cell);
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnGetPValFrmCCE
+U8 rgSCHCmnGetPValFrmCCE
(
RgSchCellCb *cell,
U8 cce
)
#else
-PUBLIC U8 rgSCHCmnGetPValFrmCCE(cell, cce)
+U8 rgSCHCmnGetPValFrmCCE(cell, cce)
RgSchCellCb *cell;
U8 cce;
#endif
{
U8 i;
- TRC2(rgSCHCmnGetPValFrmCCE);
for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
{
if(cce < cell->rgSchTddNpValTbl[i])
{
- RETVALUE(i-1);
+ return (i-1);
}
}
- RETVALUE(0);
+ return (0);
}
#endif
RgSchUlHqProcCb *proc;
#endif
{
- TRC2(rgSCHCmnUlAdapRetx);
rgSCHUhmRetx(proc, alloc);
#ifndef RG_5GTF
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp ulInactvLst;
- TRC2(rgSCHCmnHdlUlInactUes);
/* Get a List of Inactv UEs for UL*/
cmLListInit(&ulInactvLst);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp dlInactvLst;
- TRC2(rgSCHCmnHdlDlInactUes);
/* Get a List of Inactv UEs for DL */
cmLListInit(&dlInactvLst);
/* Time difference in subframes */
U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
- TRC2(rgSCHCmnUeIdleExdThrsld);
if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
- RETVALUE(ROK);
+ return ROK;
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
U32 sfDiff;
U8 cnt;
- TRC2(rgSCHCmnCfgRachDedPrm);
if (cell->macPreambleSet.pres == NOTPRSNT)
{
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUpdNxtPrchMskIdx);
/* Determine the next prach mask Index */
if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
U32 sfDiff;
- TRC2(rgSCHCmnUpdRachParam);
if (cell->macPreambleSet.pres == NOTPRSNT)
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnAllocPOParam);
if (cell->macPreambleSet.pres == PRSNT_NODEF)
{
if (cellSch->rachCfg.remDedPrm == 0)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* The stored prachMskIdx is the index of PRACH Oppurtunities in
* raOccasions.subframes[].
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
*prachMskIdx = 0;
*rapId = 0;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
U8 prachMskIdx;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnGenPdcchOrder);
while (node)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
if (ueDl->rachInfo.poLnk.node == NULLP)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = NULLP;
{
RgSchUeACqiCb *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell);
- TRC2(rgSCHCmnFillPdcchOdr2Sf);
pdcch->rnti = ue->ueId;
pdcch->dci.dciFormat = TFU_DCI_FORMAT_1A;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 rapIdIdx;
- TRC2(rgSCHCmnDelRachInfo);
if (ueDl->rachInfo.poLnk.node)
{
#endif
{
RgSchUeCb *ue = raReq->ue;
- TRC2(rgSCHCmnHdlHoPo);
if ( ue->isDrxEnabled )
{
*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHCmnGetHoUe
+RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
U16 rapId
)
#else
-PUBLIC RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
+RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
RgSchCellCb *cell;
U16 rapId
#endif
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnGetHoUe);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if (ueDl->rachInfo.hoRapId == rapId)
{
- RETVALUE(ue);
+ return (ue);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
#ifdef ANSI
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnDelDedPreamble);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHCmnGetPoUe
+RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
U16 rapId,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
+RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
RgSchCellCb *cell;
U16 rapId;
CmLteTimingInfo timingInfo;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
U8 rapIdIdx;
- TRC2(rgSCHCmnGetPoUe);
rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
ueDl->rachInfo.rapIdLnk.node = (PTR)NULLP;
if (RGSCH_TIMEINFO_SAME(ueDl->rachInfo.asgnOppr, timingInfo))
{
- RETVALUE(ue);
+ return (ue);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnUlGetCqi
+U8 rgSCHCmnUlGetCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteUeCategory ueCtgy
)
#else
-PUBLIC U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
+U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteUeCategory ueCtgy;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
U8 cqi;
- TRC2(rgSCHCmnUlGetCqi);
cqi = ueUl->maxUlCqi;
#ifdef TFU_UPGRADE
cqi = ueUl->crntUlCqi[0];
}
#endif
- RETVALUE(cqi);
+ return (cqi);
}/* End of rgSCHCmnUlGetCqi */
/***********************************************************
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRbAllocForPoHoUe);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*MS_WORKAROUND for HO ccpu00121116*/
cqi = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
#if (ERRCLASS & ERRCLS_DEBUG)
if (!bits)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
RG_SCH_UL_MCS_TO_MODODR(alloc->grnt.iMcsCrnt,alloc->grnt.modOdr);
rgSCHUhmNewTx(proc, ueUl->hqEnt.maxHqRetx, alloc);
/* No grant attr recorded now */
- RETVALUE(ROK);
+ return ROK;
}
/**
RgSchUlGrnt *grnt;
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
- TRC2(rgSCHCmnAllocPoHoGrnt);
/* Clearing previous allocs if any*/
rgSCHCmnUlUeDelAllocs(cell, ue);
* @return Void
*
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE Void rgSCHCmnUlNonadapRetx
(
U8 idx;
#endif
{
- TRC2(rgSCHCmnUlNonadapRetx);
rgSCHUhmRetx(alloc->hqProc, alloc);
/* Update alloc to retx */
alloc->pdcch = NULLP;
RETVOID;
}
-
/**
* @brief Check if 2 allocs overlap
*
#endif
{
- TRC2(rgSCHCmnUlAllocsOvrLap);
if (((alloc1->sbStart >= alloc2->sbStart) &&
(alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
((alloc2->sbStart >= alloc1->sbStart) &&
(alloc2->sbStart <= alloc1->sbStart + alloc1->numSb-1)))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
- RETVALUE(FALSE);
+ return (FALSE);
}
-
/**
* @brief Copy allocation Info from src to dst.
*
#endif
{
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlCpyAllocInfo);
dstAlloc->grnt = srcAlloc->grnt;
dstAlloc->hqProc = srcAlloc->hqProc;
RETVOID;
}
-
-
/**
* @brief Update TX and RETX subframe's allocation
* markings.
/* MS_WORKAROUND ccpu00120827 */
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
U8 remAllocs;
- TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
{
dstAlloc->mrgdNewTxAlloc = TRUE;
RETVOID;
}
-
/**
* @brief Merge all allocations of newSf to oldSf.
*
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlMergeSfAllocs);
UNUSED(cell);
/* Merge each alloc of newSf in to oldSf
}
RETVOID;
}
-
/**
* @brief Swap Hole/Alloc DB context of newSf and oldSf.
*
RgSchUlHoleDb *tempHoleDb = newSf->holeDb;
U8 tempAvailSbs = newSf->availSubbands;
- TRC2(rgSCHCmnUlSwapSfAllocs);
UNUSED(cell);
newSf->allocDb = oldSf->allocDb;
oldSf->allocCountRef = &oldSf->allocDb->count;
RETVOID;
}
-
/**
* @brief Perform non-adaptive RETX for non-colliding allocs.
*
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlPrcNonAdptRetx);
/* perform non-adaptive retx allocation(adjustment) */
if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
U8 idx;
#endif
{
- TRC2(rgSCHCmnUlPrfmSfMerge);
/* Preassigned resources for msg3 in newSf.
* Hence do adaptive retx for all NACKED TXs */
rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
RETVOID;
}
-
+#endif
/**
* @brief Update TX and RETX subframe's allocation
* markings.
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlRmvCmpltdAllocs);
if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnRlsUlSf
+Void rgSCHCmnRlsUlSf
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC Void rgSCHCmnRlsUlSf(cell, idx)
+Void rgSCHCmnRlsUlSf(cell, idx)
RgSchCellCb *cell;
U8 idx;
#endif
{
- TRC2(rgSCHCmnRlsUlSf);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlUpdAllocRetx);
alloc->hqProc->reTxAlloc.rnti = alloc->rnti;
alloc->hqProc->reTxAlloc.numSb = alloc->numSb;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlAdapRetxAlloc);
/* Fetch PDCCH for msg3 */
/* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
if (pdcch == NULLP)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
/* Fetch UL Alloc for msg3 */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"UL Alloc fail for msg3 retx for rnti: %d\n",
proc->reTxAlloc.rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
"Num SB not suffiecient for adap retx for rnti: %d",
proc->reTxAlloc.rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Fix: syed Adaptive Msg3 Retx crash. */
* @param[in] RgSchUlSf *sf
* @return U8
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE Void rgSCHCmnUlSfRlsRetxProcs
(
RgSchUlHqProcCb *proc;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfRlsRetxProcs);
cp = &(cellUl->reTxLst);
node = cp->first;
}
RETVOID;
}
-
+#endif
/**
* @brief Attempts allocation for UEs for which retransmissions
RgSchUeCb *ue;
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfReTxAllocs);
cp = &(cellUl->reTxLst);
node = cp->first;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlGetRbgInfo
+Void rgSCHCmnDlGetRbgInfo
(
U8 dlTotalBw,
U8 dlSubsetBw,
RgSchBwRbgInfo *rbgInfo
)
#else
-PUBLIC Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
+Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
rbgSize, rbgInfo)
U8 dlTotalBw;
U8 dlSubsetBw;
rbgInfo->lastRbgSize = rbgSize -
(dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
#ifdef RGSCH_SPS_UNUSED
- cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
+ memcpy(rbgInfo->rbgSubsetSize, subsetSize, 4 * sizeof(U8));
#endif
rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
dlTotalBw:(rbgInfo->numRbgs * rbgSize);
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnDlRaType0Alloc
+U8 rgSCHCmnDlRaType0Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
U8 rbsReq,
Bool isPartialAlloc
)
#else
-PUBLIC U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
+U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
numAllocRbs, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
U8 rbsReq;
* same */
}
- RETVALUE(numAllocRbgs);
+ return (numAllocRbgs);
}
#ifdef RGSCH_SPS_UNUSED
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnDlRaType1Alloc
+U8 rgSCHCmnDlRaType1Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
U8 rbsReq,
Bool isPartialAlloc
)
#else
-PUBLIC U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
+U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
allocRbgSubset, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
U8 rbsReq;
*allocRbgSubset = bestSubsetIdx;
} /* End of if (bestNumAvailRbs) */
- RETVALUE(numAllocRbs);
+ return (numAllocRbs);
}
#endif
/**
**/
#ifdef ANSI
-PUBLIC U8 rgSCHCmnDlRaType2Alloc
+U8 rgSCHCmnDlRaType2Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
U8 rbsReq,
Bool isPartialAlloc
)
#else
-PUBLIC U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
+U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
U8 rbsReq;
}
}
- RETVALUE(numAllocRbs);
+ return (numAllocRbs);
}
/**
rbg = rbIdx/rbgSize;
rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
- RETVALUE(rbgPosInRbgMask);
+ return (rbgPosInRbgMask);
}
#ifdef RGSCH_SPS_UNUSED
rbPosInSubset = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
*type1Subset = rbgSubset;
- RETVALUE(rbPosInSubset);
+ return (rbPosInSubset);
}
#endif /* RGSCH_SPS_UNUSED */
/**
*maskIdx = rbIdx / 32;
rbPosInType2 = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
- RETVALUE(rbPosInType2);
+ return (rbPosInType2);
}
/**
* RFAILED failed
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnAllocUeInSpsBw
+Bool rgSCHCmnAllocUeInSpsBw
(
RgSchDlSf *dlSf,
RgSchCellCb *cell,
Bool isPartialAlloc
)
#else
-PUBLIC Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
+Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
RgSchDlSf *dlSf;
RgSchCellCb *cell;
RgSchUeCb *ue;
if ((0 == rbAllocInfo->tbInfo[0].schdlngForTb) &&
(0 == rbAllocInfo->tbInfo[1].schdlngForTb))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Check if the requirement can be accomodated in SPS BW */
if (dlSf->spsAllocdBw == spsRbgInfo->numRbs)
{
/* SPS Bandwidth has been exhausted: no further allocations possible */
- RETVALUE(FALSE);
+ return (FALSE);
}
if (!isPartialAlloc)
{
if((dlSf->spsAllocdBw + rbAllocInfo->rbsReq) > spsRbgInfo->numRbs)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
if (!numAllocRbs)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
if (!(rbAllocInfo->pdcch =
rbAllocInfo->dciFormat, FALSE)))
{
/* Note: Returning TRUE since PDCCH might be available for another UE */
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Update Tb info for each scheduled TB */
}
dlSf->spsAllocdBw += numAllocRbs;
- RETVALUE(TRUE);
+ return (TRUE);
}
/***********************************************************
{
bestAvailNumRbs = numAvailRbs;
bestStartPos = startPos;
- cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(bestMask, tmpMask, 4 * sizeof(U32));
}
numAvailRbs = 0;
startPos = -1;
- cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
+ memset(tmpMask, 0, 4 * sizeof(U32));
}
}
if (*allocNumRbs == rbsReq)
if (*allocNumRbs == rbsReq)
{
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, tmpMask, 4 * sizeof(U32));
RETVOID;
}
else
*allocStart = (U8)bestStartPos;
*allocNumRbs = bestAvailNumRbs;
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, bestMask, 4 * sizeof(U32));
}
}
* @param[in,out] RgSchDlRbAlloc *allocInfo
* @return void
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE Void rgSCHCmnFindCodeRate
(
{
U8 addtlRbsAvl = 0;
- TRC2(rgSCHCmnFindNumAddtlRbsAvl)
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
addtlRbsAvl = (dlSf->bw - dlSf->bwAlloced) - allocInfo->rbsReq;
}
- RETVALUE(addtlRbsAvl);
+ return (addtlRbsAvl);
}
/* Added this function to find num of ovrlapping PBCH rb*/
#endif
{
*numOvrlapgPbchRb = 0;
- TRC2(rgSCHCmnFindNumPbchOvrlapRbs)
/*Find if we have already crossed the start boundary for PBCH 6 RBs,
* if yes then lets find the number of RBs which are getting overlapped
* with this allocation.*/
U8 divResult;
- TRC2(rgSCHCmnNonDlfsPbchRbAllocAdj);
origRbsReq = allocInfo->rbsReq;
RETVOID;
} /* end of rgSCHCmnNonDlfsPbchRbAllocAdj */
#endif
-
+#endif
/**
* @brief Performs RB allocation for frequency non-selective cell.
*
U8 spsRbsAlloc = 0;
RgSchDlSfAllocInfo *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
#endif
- TRC2(rgSCHCmnNonDlfsCmnRbAlloc);
allocInfo->tbInfo[0].noLyr = 1;
/* Note: Initialize the masks to 0, this might not be needed since alloInfo
* is initialized to 0 at the beginning of allcoation */
allocInfo->resAllocInfo.raType0Mask = 0;
- cmMemset((U8*)allocInfo->resAllocInfo.raType1Mask, 0,
+ memset(allocInfo->resAllocInfo.raType1Mask, 0,
RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
- cmMemset((U8*)allocInfo->resAllocInfo.raType2Mask, 0,
+ memset(allocInfo->resAllocInfo.raType2Mask, 0,
RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
if(dlSf->bwAlloced == dlSf->bw)
#endif
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef LTE_TDD
if (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced))
if (!spsRbsAlloc)
#endif /* LTEMAC_SPS */
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
if (allocInfo->pdcch == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
}
#endif
- RETVALUE(ROK);
+ return ROK;
}
#endif
{
RgSchDlSf *dlSf = allocInfo->dlSf;
- TRC2(rgSCHCmnNonDlfsCmnRbAllocRar);
if(dlSf->bwAlloced == dlSf->bw)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->tbInfo[0].noLyr = 1;
allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
if (allocInfo->pdcch == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, NULLP, dlSf, 13, TFU_DCI_FORMAT_B1, FALSE);
if (allocInfo->pdcch == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
RgSchSfBeamInfo *beamInfo = &(dlSf->sfBeamInfo[0]);
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
printf("5GTF_ERROR vrbg allocated > 25\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
allocInfo->tbInfo[0].cmnGrnt.vrbgStart = beamInfo->vrbgStart;
printf("\n[%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
__func__,allocInfo->tbInfo[0].bytesAlloc,allocInfo->vrbgReq);
- RETVALUE(ROK);
+ return ROK;
}
* -# TRUE
* -# FALSE
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl
(
/* Check if type0 allocation can cater to this RETX requirement */
if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
else
{
/* cannot allocate same number of required RBs */
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
cell->rbgSize) - dlSf->lstRbgDfct))
{
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
noLyrs = allocInfo->tbInfo[0].noLyr;
allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
continue;
}
- // RETVALUE(FALSE);
+ // return (FALSE);
}
}
else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
cell->rbgSize);
sfrPool->adjCCPool->bw -= addtnlPRBs;
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced))
{
*sfrpoolInfo = sfrCEPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else if(allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
{
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Check if CE and CC boundary has unallocated prbs */
else if ((sfrPool->poolstartRB == sfrPool->type2Start) &&
sfrCEPool->type0End = ((sfrCEPool->poolendRB + 1 - addtnlPRBs) / cell->rbgSize) - 1;
}
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else if ( bwAvlbl <
((sfrCEPool->bw - sfrCEPool->bwAlloced) +
allocInfo->tbInfo[0].bytesReq =
rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
if (allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
{
*sfrpoolInfo = sfrPool;
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
{
dlSf->sfrTotalPoolInfo.ccBwFull = TRUE;
}
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
allocInfo->tbInfo[0].bytesReq =
rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
*sfrpoolInfo = poolWithMaxAvlblBw;
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
if (n == NULLP)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
}
}
- RETVALUE(FALSE);
+ return (FALSE);
}
+#endif
#endif /* end of ifndef LTE_TDD*/
/* LTE_ADV_FLAG_REMOVED_END */
* -# TRUE
* -# FALSE
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl
(
U8 noLyrs;
U8 ignoredDfctRbg = FALSE;
- TRC2(rgSCHCmnNonDlfsBwAvlbl);
if (dlSf->bw <= dlSf->bwAlloced)
{
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
/* Check if type0 allocation can cater to this RETX requirement */
if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
{
- RETVALUE(FALSE);
+ return (FALSE);
}
}
else
{
/* cannot allocate same number of required RBs */
- RETVALUE(FALSE);
+ return (FALSE);
}
}
}
if(allocInfo->rbsReq <= (((dlSf->type0End - dlSf->type2End + 1)*\
cell->rbgSize) - dlSf->lstRbgDfct))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
/* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB
* allocation in TDD when requested RBs are more than available RBs*/
}
- RETVALUE(FALSE);
+ return (FALSE);
}
/* Fix: Number of RBs in case of RETX should be same as
* that of initial transmission. */
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
allocInfo->rnti);
printf ("RB Alloc failed for LAA TB type 0\n");
- RETVALUE(FALSE);
+ return (FALSE);
}
- RETVALUE(TRUE);
+ return (TRUE);
}
}
else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
{
if (allocInfo->rbsReq <= (dlSf->bw - dlSf->bwAlloced))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
/* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB
* allocation in TDD when requested RBs are more than available RBs*/
{
printf ("RB Alloc failed for LAA TB type 2\n");
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
/* Fix: Number of RBs in case of RETX should be same as
* that of initial transmission. */
- RETVALUE(TRUE);
+ return (TRUE);
}
}
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
- RETVALUE(FALSE);
+ return (FALSE);
}
+#endif
/* LTE_ADV_FLAG_REMOVED_START */
#ifndef LTE_TDD
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
+Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
U8 numRb
)
#else
-PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
+Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
U8 rbStrt;
CmLListCp *l;
CmLList *n;
RgSchSFRPoolInfo *sfrPool;
- TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
l = &dlSf->sfrTotalPoolInfo.ccPool;
*
* @return Void
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
(
RgSchSFRPoolInfo *sfrCCPool2 = NULL;
S16 ret = RFAILED;
- TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
/* Move the type2End pivot forward */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
n = cmLListNext(l);
if(n)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
/*MS_FIX for ccpu00123918*/
dlSf->type2Start += numRb;
#endif
- RETVALUE(ROK);
+ return ROK;
+
}
+#endif
#endif /* end of ifndef LTE_TDD*/
/* LTE_ADV_FLAG_REMOVED_END */
/**
U8 numRb;
#endif
{
- TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
/* Move the type2End pivot forward */
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
//#ifndef LTEMAC_SPS
*
* @return Void
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE Void rgSCHCmnNonDlfsType0Alloc
(
U32 tb2BytesAlloc = 0;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnNonDlfsType0Alloc);
//if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
/* Fix for ccpu00123919*/
dlSf->lstRbgDfct = 0;
RETVOID;
}
+#endif
#ifndef LTE_TDD
/**
*
* @return Void
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE S16 rgSCHCmnBuildRntpInfo
(
U16 rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
U16 nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
- TRC2(rgSCHCmnBuildRntpInfo);
rbPtrStartIdx = (startRb)/8;
rbPtrEndIdx = (startRb + nmbRb)/8;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnBuildRntpInfo():"
"rntpPtr can't be NULLP (Memory Allocation Failed)");
- RETVALUE(RFAILED);
+ return RFAILED;
}
while(rbPtrStartIdx <= rbPtrEndIdx)
/* dsfr_pal_fixes ** 25-March-2013 ** SKS ** Adding Debug logs to print RNTP */
- RETVALUE(ROK);
+ return ROK;
}
-
/**
* @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
*
S16 ret;
#endif
- TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
sfrPool->bwAlloced += numRb;
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
U8 noLyr;
U8 iTbs;
- TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
{
dlSf->lstRbgDfct = 0;
RETVOID;
}
-
+#endif
/**
* @brief Computes RNTP Info for a subframe.
*
U16 len;
U16 ret = ROK;
- TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
"rgSCHUtlRgrLoadInfInd() returned RFAILED");
}
- cmMemset(cell->rntpAggrInfo.val,0,len);
+ memset(cell->rntpAggrInfo.val,0,len);
samples = 0;
}
}
* -# ROK
* -# RFAILED
**/
+#ifdef UNUSED_FUNC
#ifdef ANSI
PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc
(
Bool isUECellEdge;
RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
- TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
{
*isDlBwAvail = FALSE;
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX || dlUe->proc->tbInfo[1].isAckNackDtx)
if (!(allocInfo->pdcch))
{
/* Returning ROK since PDCCH might be available for another UE and further allocations could be done */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
dlSf->bwAlloced += allocInfo->rbsReq;
#endif
- RETVALUE(ROK);
+ return ROK;
}
+#endif
/* LTE_ADV_FLAG_REMOVED_END */
#endif /* LTE_TDD */
#ifdef LAA_DBG
U32 dbgRbsReq = 0;
#endif
- TRC2(rgSCHCmnNonDlfsUeRbAlloc);
#ifdef RG_5GTF
RgSch5gtfUeCb *ue5gtfCb = &(ue->ue5gtfCb);
"5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
ue->ueId);
printf("5GTF_ERROR vrbg allocated > 25\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX
"5GTF_ERROR : PDCCH allocation failed :ue (%u)",
ue->ueId);
printf("5GTF_ERROR PDCCH allocation failed\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef RG_5GTF
//maxPrb = RGSCH_MIN((allocInfo->vrbgReq * MAX_5GTF_VRBG_SIZE), ue5gtfCb->maxPrb);
allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
#endif
- RETVALUE(ROK);
+ return ROK;
}
#ifdef RGR_V1
RgSchDlSf *dlSf = allocInfo->ccchSduDlSf;
RgSchUeCb *ueCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
if (isRetx)
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
(allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
#endif
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Retrieve PDCCH */
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if (!(allocInfo->pdcch))
{
/* Returning RFAILED since PDCCH not available for any CCCH allocations */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update allocation information */
/* ccpu00131941 - bwAlloced is updated from SPS bandwidth */
- RETVALUE(ROK);
+ return ROK;
}
#endif
#endif
{
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
"5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
raCb->ue->ueId);
printf("5GTF_ERROR vrbg allocated > 25\n");
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef LTEMAC_SPS
#endif
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* DTX Changes: One Variable is passed to check whether it is DTX or Not */
if (!(allocInfo->pdcch))
{
/* Returning RFAILED since PDCCH not available for any CCCH allocations */
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef RG_5GTF
#endif
- RETVALUE(ROK);
+ return ROK;
}
/**
RgSchDlSf *dlSf = allocInfo->msg4DlSf;
RgSchRaCb *raCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsMsg4Alloc);
if (isRetx)
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc
+Void rgSCHCmnNonDlfsDedRbAlloc
(
RgSchCellCb *cell,
RgSchCmnUeRbAlloc *allocInfo,
CmLListCp *nonSchdHqPLst
)
#else
-PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
+Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
schdHqPLst, nonSchdHqPLst)
RgSchCellCb *cell;
RgSchCmnUeRbAlloc *allocInfo;
RgSchUeCb *ue = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
U8 isDlBwAvail;
- TRC2(rgSCHCmnNonDlfsDedRbAlloc);
/* Perform allocaations for the list */
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnNonDlfsRbAlloc
+Void rgSCHCmnNonDlfsRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
+Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
U8 raRspCnt = 0;
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsRbAlloc);
/* Allocate for MSG4 retransmissions */
if (allocInfo->msg4Alloc.msg4RetxLst.count)
**********************************************************/
#ifdef LTEMAC_SPS
#ifdef ANSI
-PUBLIC U32 rgSCHCmnCalcRiv
+U32 rgSCHCmnCalcRiv
(
U8 bw,
U8 rbStart,
U8 numRb
)
#else
-PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
+U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
U8 bw;
U8 rbStart;
U8 numRb;
#endif
#else
#ifdef ANSI
-PUBLIC U32 rgSCHCmnCalcRiv
+U32 rgSCHCmnCalcRiv
(
U8 bw,
U8 rbStart,
U8 numRb
)
#else
-PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
+U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
U8 bw;
U8 rbStart;
U8 numRb;
U8 numRbMinus1 = numRb - 1;
U32 riv;
- TRC2(rgSCHCmnCalcRiv);
if (numRbMinus1 <= bw/2)
{
{
riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
}
- RETVALUE(riv);
+ return (riv);
} /* rgSCHCmnCalcRiv */
#ifdef LTE_TDD
U8 sfcount;
S16 ret;
- TRC2(rgSCHCmnDlCpyRachInfo);
/* Allocate RACH response information for each DL
* subframe in a radio frame */
sizeof(RgSchTddRachRspLst));
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
for(sfnIdx=raArrSz-1; sfnIdx>=0; sfnIdx--)
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
/**
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
S32 iTbs = 0;
- TRC2(rgSchCmnFetchItbs);
#ifdef LTE_TDD
/* Special Handling for Spl Sf when CFI is 3 as
ueDl->laCb[cwIdx].deltaiTbs = 0;
}
- RETVALUE(iTbs);
+ return (iTbs);
}
\f
/**
RgSchDlRbAlloc *allocInfo;
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchDlRbAlloc *allocInfo;
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM1);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM1);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM2);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM2);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM3);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM3);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
*
**/
#ifdef ANSI
-PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt
+TfuDciFormat rgSCHCmnSlctPdcchFrmt
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 *raType
)
#else
-PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
+TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 *raType;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSlctPdcchFrmt);
/* ccpu00140894- Selective DCI Format and RA type should be selected only
* after TX Mode transition is completed*/
if ((cellSch->dl.isDlFreqSel) && (ue->txModeTransCmplt))
{
*raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciRAType;
- RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
+ return (rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
}
else
{
*raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciRAType;
- RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
+ return (rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
}
}
U8 noTxLyrs;
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
#endif
U8 noTxLyrs;
- TRC2(rgSCHCmnDlTM4RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
Bool bothCwEnbld;
#endif
{
- TRC2(rgSCHCmnDlTM3PrecInf2);
- RETVALUE(0);
+ return (0);
}
\f
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf2);
if (ueDl->mimoInfo.ri == numTxLyrs)
{
{
precIdx = (ueDl->mimoInfo.pmi < 2)? 0:1;
}
- RETVALUE(precIdx);
+ return (precIdx);
}
\f
{
U8 precIdx;
- TRC2(rgSCHCmnDlTM3PrecInf4);
if (bothCwEnbld)
{
{
precIdx = 1;
}
- RETVALUE(precIdx);
+ return (precIdx);
}
\f
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoBaseIdx, precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf4);
precInfoBaseIdx = (ue->mimoInfo.puschFdbkVld)? (16):
(ueDl->mimoInfo.pmi);
precInfoBaseIdx += 1;
precIdx = precInfoBaseIdx + (numTxLyrs-1)*17;
}
- RETVALUE(precIdx);
+ return (precIdx);
}
\f
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM3);
/* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with
HQP */
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM4);
*frthrScp = FALSE;
/* Integration_fix: SPS Proc shall always have only one Cw */
U8 prcdngInf;
U8 numTxLyrs;
- TRC2(rgSCHCmnDlTM3TxRetx);
frthrScp = FALSE;
ret = ROK;
U8 prcdngInf;
U8 numTxLyrs;
- TRC2(rgSCHCmnDlTM4TxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
S16 ret;
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
S16 ret;
- TRC2(rgSCHCmnDlTM4TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM4);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM4);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRbTM6);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRbTM6);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM7);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM7);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnDlAllocTxRb
+S16 rgSCHCmnDlAllocTxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PUBLIC S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
U32 prevSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocTxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* DwPTS Scheduling Changes Start */
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnRetxAvoidTdd
+Bool rgSCHCmnRetxAvoidTdd
(
RgSchDlSf *curSf,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
)
#else
-PUBLIC Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
+Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
RgSchDlSf *curSf;
RgSchCellCb *cell;
RgSchDlHqProcCb *proc;
{
RgSchTddSfType txSfType = 0;
- TRC2(rgSCHCmnRetxAvoidTdd);
/* Get the RBs of TB that will be retransmitted */
if (proc->tbInfo[0].state == HQ_TB_NACKED)
/* Avoid re-transmission on Normal SF when the corresponding TB wss transmitted on SPCL SF */
if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
#endif
#endif
/* Avoid re-transmission on Normal SF when the corresponding TB wss tranmitted on SPCL SF */
if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
#endif
#endif
if (txSfType > curSf->sfType)
{
/* Avoid retx */
- RETVALUE(TRUE);
+ return (TRUE);
}
/* Allow Retx */
- RETVALUE(FALSE);
+ return (FALSE);
}
#else
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnRetxAllocAvoid
+Bool rgSCHCmnRetxAllocAvoid
(
RgSchDlSf *subFrm,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
)
#else
-PUBLIC Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
+Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
RgSchDlSf *subFrm;
RgSchCellCb *cell;
RgSchDlHqProcCb *proc;
{
U8 reqRbs;
- TRC2(rgSCHCmnRetxAllocAvoid);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
if ((subFrm->bwAssigned < cell->pbchRbEnd) &&
(((subFrm->bwAssigned + reqRbs) - cell->pbchRbStart) > 0))
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
- RETVALUE(FALSE);
+ return (FALSE);
}
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHCmnDlAllocRetxRb
+S16 rgSCHCmnDlAllocRetxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
#else
-PUBLIC S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
+S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
U32 newSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocRetxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
/* Check for DL BW exhaustion */
if (subFrm->bw <= subFrm->bwAssigned)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Call TM specific RB allocation routine */
(dlAllocRetxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
}
- RETVALUE(ROK);
+ return ROK;
}
\f
/* Correcting wrap around issue.
* This change has been done at mutliple places in this function.*/
U32 tempNumRb;
- TRC2(rgSCHCmnDlAlloc1CwTxRb);
reqBytes = bo;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
/* Update the subframe Allocated BW field */
subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnRdcImcsTxTb
+Void rgSCHCmnRdcImcsTxTb
(
RgSchDlRbAlloc *allocInfo,
U8 tbInfoIdx,
U32 cnsmdBytes
)
#else
-PUBLIC Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
+Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
RgSchDlRbAlloc *allocInfo;
U8 tbInfoIdx;
U32 cnsmdBytes;
U8 iTbs;
U16 numRb;
- TRC2(rgSCHCmnRdcImcsTxTb);
iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
U32 boTmp = bo;
#endif
- TRC2(rgSCHCmnDlAlloc2CwTxRb);
reqBytes = bo;
cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
{
RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHCmnDlAllocRb(): UEs max allocation exceed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
noLyr1 = ueDl->mimoInfo.cwInfo[0].noLyr;
#ifdef LTE_ADV
if (ROK != rgSCHLaaCmn2TBPrbCheck(allocInfo, tb1Sz, tb2Sz, boTmp, effBo, iTbs1, iTbs2, numRb, proc))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
*numRbRef = (U8)numRb;
- RETVALUE(ROK);
+ return ROK;
}
\f
U8 cfi = cellDl->currCfi;
U8 iTbs;
- TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
if(*numRb <= 3)
{
RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if ((S16)*numRb > availBw)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the subframe Allocated BW field */
subFrm->bwAssigned += *numRb;
*effBo = reTxTb->tbSz + tb2Sz;
- RETVALUE(ROK);
+ return ROK;
}
\f
U8 imcs2;
RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
- TRC2(rgSCHCmnDlAlloc2CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
if(*numRb <= 3)
{
RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the subframe Allocated BW field */
subFrm->bwAssigned += *numRb;
- RETVALUE(ROK);
+ return ROK;
}
\f
RgSchDlRbAlloc *allocInfo;
U8 imcs;
- TRC2(rgSCHCmnDlAlloc1CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
*numRb = tbInfo->dlGrnt.numRb;
if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Update the subframe Allocated BW field */
subFrm->bwAssigned += *numRb;
0, imcs, tbInfo, tbInfo->numLyrs);
*effBo = tbInfo->tbSz;
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTEMAC_SPS
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlRelPdcchFbk
+Void rgSCHCmnDlRelPdcchFbk
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isAck
)
#else
-PUBLIC Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
+Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isAck;
#endif
{
- TRC2(rgSCHCmnDlRelPdcchFbk);
rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
RETVOID;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlProcAck
+Void rgSCHCmnDlProcAck
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHCmnDlProcAck(cell, hqP)
+Void rgSCHCmnDlProcAck(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHCmnDlProcAck);
if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnHdlCrntiCE
+Void rgSCHCmnHdlCrntiCE
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHCmnHdlCrntiCE(cell, ue)
+Void rgSCHCmnHdlCrntiCE(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHCmnHdlCrntiCE);
#ifdef RGSCH_SPS_STATS
rgSchStatCrntiCeRcvCnt++;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlSpsRelInd
+Void rgSCHCmnUlSpsRelInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isExplRel
)
#else
-PUBLIC Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
+Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isExplRel;
#endif
{
- TRC2(rgSCHCmnUlSpsRelInd);
rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
RETVOID;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlSpsActInd
+Void rgSCHCmnUlSpsActInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U16 spsSduSize
)
#else
-PUBLIC Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
+Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
RgSchCellCb *cell;
RgSchUeCb *ue;
U16 spsSduSize;
#endif
{
- TRC2(rgSCHCmnUlSpsActInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlCrcInd
+Void rgSCHCmnUlCrcInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo crcTime
)
#else
-PUBLIC Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
+Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo crcTime;
#endif
{
- TRC2(rgSCHCmnUlCrcInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUlCrcFailInd
+Void rgSCHCmnUlCrcFailInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo crcTime
)
#else
-PUBLIC Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
+Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo crcTime;
#endif
{
- TRC2(rgSCHCmnUlCrcFailInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlBcchPcchAlloc);
/*Reset the bitmask for BCCH/PCCH*/
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHBcchPcchDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
/* 143473 */
/* Allocate for PCCH */
{
CmLteTimingInfo pdSchTmInfo;
- TRC2(rgSCHChkNUpdSiCfg);
pdSchTmInfo = cell->crntTime;
U16 x;
U16 windowId;
- TRC2(rgSCHSelectSi);
crntTmInfo = cell->crntTime;
#endif
/* DwPTS Scheduling Changes End */
- TRC2(rgSCHDlSiSched);
crntTimInfo = cell->crntTime;
S16 retVal;
RgrStaIndInfo *staInfo = NULLP;
- TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
/* Step 1: Store the CQI in collation array */
/* Step 2: Increament the tracking count */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
"allocate memory for sending StaInd CRNTI:%d",ue->ueId);
- RETVALUE(retVal);
+ return (retVal);
}
/* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
#endif
retVal = rgSCHUtlFillSndStaInd(cell, ue, staInfo,
ue->cqiReptCfgInfo.numColltdCqiRept);
- RETVALUE(retVal);
+ return (retVal);
}
- RETVALUE(ROK);
+ return ROK;
} /* End of rgSCHCmnUeDlPwrCtColltCqiRept */
#endif /* End of RGR_CQI_REPT */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnChkRetxAllowDtx
+Void rgSCHCmnChkRetxAllowDtx
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
Bool *reTxAllwd
)
#else
-PUBLIC Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
+Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
RgSchDlHqProcCb *proc;
Bool *reTxAllwd;
#endif
{
- TRC3(rgSCHCmnChkRetxAllowDtx)
*reTxAllwd = TRUE;
* @return U16 siSetId
**/
#ifdef ANSI
-PUBLIC U16 rgSCHCmnGetSiSetId
+U16 rgSCHCmnGetSiSetId
(
U16 sfn,
U8 sf,
U16 minPeriodicity
)
#else
-PUBLIC U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
+U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
U16 sfn;
U8 sf
U16 minPeriodicity;
{
/* 80 is the minimum SI periodicity in sf. Also
* all other SI periodicities are multiples of 80 */
- RETVALUE (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
+ return (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
}
#ifdef LTE_TDD
/**
U32 numRE = *rb * cellDl->noResPerRb[cfi];
U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
}
*rb = numDwPtsRb;
- RETVALUE(tbSz/8);
+ return (tbSz/8);
}
/**
U32 numRE = *rb * cellDl->noResPerRb[cfi];
U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHCmnUpdUeDataIndLcg
+Void rgSCHCmnUpdUeDataIndLcg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgInfUeDatInd *datInd
)
#else
-PUBLIC Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
+Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfUeDatInd *datInd;
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnUpdUeDataIndLcg);
for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
{
RgSchDlSf *dlSf;
U8 idx;
- TRC2(rgSCHCmnInitRbAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure.*/
rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
RgmTransModeInd *txModeChgInd;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnSendTxModeInd);
if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchCheckAndTriggerModeChange
+Void rgSchCheckAndTriggerModeChange
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 maxiTbs
)
#else
-PUBLIC Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
+Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 reportediTbs;
RgrTxMode txMode; /*!< UE's Transmission Mode */
RgrTxMode modTxMode; /*!< UE's Transmission Mode */
- TRC2(rgSchCheckAndTriggerModeChange);
txMode = ue->mimoInfo.txMode;
* @return Void
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnIsDlCsgPrio
+Bool rgSCHCmnIsDlCsgPrio
(
RgSchCellCb *cell
)
#else
-PUBLIC Bool rgSCHCmnIsDlCsgPrio(cell)
+Bool rgSCHCmnIsDlCsgPrio(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnIsDlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
if(((cmnDlCell->ncsgPrbCnt * 100) / cmnDlCell->totPrbCnt) < cell->minDlResNonCsg)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
* @return Void
**/
#ifdef ANSI
-PUBLIC Bool rgSCHCmnIsUlCsgPrio
+Bool rgSCHCmnIsUlCsgPrio
(
RgSchCellCb *cell
)
#else
-PUBLIC Bool rgSCHCmnIsUlCsgPrio(cell)
+Bool rgSCHCmnIsUlCsgPrio(cell)
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnIsUlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
if (((cmnUlCell->ncsgPrbCnt * 100) /cmnUlCell->totPrbCnt) < cell->minUlResNonCsg)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
else
{
- RETVALUE(TRUE);
+ return (TRUE);
}
}
}
*
*/
#ifdef ANSI
- PUBLIC Void rgSchCmnPreDlSch
+ Void rgSchCmnPreDlSch
(
RgSchCellCb **cell,
U8 nCell,
RgSchCellCb **cellLst
)
#else
-PUBLIC Void rgSchCmnPreDlSch(cell, nCell, cellLst)
+Void rgSchCmnPreDlSch(cell, nCell, cellLst)
RgSchCellCb **cell;
U8 nCell;
RgSchCellCb **cellLst;
RgSchDlSf *sf;
U8 idx;
- TRC2(rgSchCmnPreDlSch);
if(nCell > CM_LTE_MAX_CELLS)
{
*
*/
#ifdef ANSI
-PUBLIC Void rgSchCmnPstDlSch
+Void rgSchCmnPstDlSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSchCmnPstDlSch(cell)
+Void rgSchCmnPstDlSch(cell)
RgSchCellCb *cell
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSchCmnPstDlSch);
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
{
}
#ifdef ANSI
-PUBLIC U8 rgSCHCmnCalcPcqiBitSz
+U8 rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
U8 numTxAnt
)
#else
-PUBLIC U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
+U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
RgSchUeCb *ueCb;
U8 numTxAnt;
#endif
U8 ri;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHCmnCalcPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
break;
}
- RETVALUE(pcqiSz);
+ return (pcqiSz);
}
/** @brief DL scheduler for SPS, and all other downlink data
*
*/
#ifdef ANSI
-PUBLIC Void rgSCHCmnDlSch
+Void rgSCHCmnDlSch
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHCmnDlSch (cell)
+Void rgSCHCmnDlSch (cell)
RgSchCellCb *cell;
#endif
{
U16 dlCntrlSfIdx;
#endif
- TRC2(rgSCHCmnDlSch);
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
#ifdef RG_5GTF
Code Review / o-du / l2.git / blobdiff