static int RLOG_FILE_ID=230;
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_mblk.h" /* common memory link list library */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
+#include "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "tfu.h"
#include "rg_sch_cmn.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer */
-#include "ssi.x" /* system service interface */
-#include "cm5.x" /* common timers */
-#include "cm_lib.x" /* common library */
-#include "cm_hash.x" /* common hash list */
-#include "cm_mblk.x" /* common memory link list library */
-#include "cm_llist.x" /* common linked list library */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common LTE */
#include "lrg.x"
#include "rgr.x"
#include "tfu.x"
/* local defines */
-PRIVATE S16 rgSCHDbmInitUeCbLst ARGS(( RgSchCellCb *cellCb, U16 numBins));
+static S16 rgSCHDbmInitUeCbLst ARGS(( RgSchCellCb *cellCb, uint16_t numBins));
#ifdef LTE_TDD
-PRIVATE S16 rgSCHDbmInitUeTfuPendLst ARGS(( RgSchCellCb *cellCb, U16 numBins));
+static S16 rgSCHDbmInitUeTfuPendLst ARGS(( RgSchCellCb *cellCb, uint16_t numBins));
#endif
-PRIVATE Void rgSCHDbmInitDedLcLst ARGS((RgSchUeCb *ueCb));
-PRIVATE Void rgSCHDbmInitCmnLcLst ARGS((RgSchCellCb *cellCb));
+static Void rgSCHDbmInitDedLcLst ARGS((RgSchUeCb *ueCb));
+static Void rgSCHDbmInitCmnLcLst ARGS((RgSchCellCb *cellCb));
#ifdef LTEMAC_SPS
-PRIVATE S16 rgSCHDbmInitSpsUeCbLst ARGS((RgSchCellCb *cellCb,
- U16 numBins));
+static S16 rgSCHDbmInitSpsUeCbLst ARGS((RgSchCellCb *cellCb,
+ uint16_t numBins));
#endif
-PRIVATE Void rgSCHDbmInitRaCbLst ARGS(( RgSchCellCb *cellCb));
+static Void rgSCHDbmInitRaCbLst ARGS(( RgSchCellCb *cellCb));
#ifndef LTE_TDD
-PRIVATE Void rgSCHDbmInitRaReqLst ARGS(( RgSchCellCb *cellCb));
+static Void rgSCHDbmInitRaReqLst ARGS(( RgSchCellCb *cellCb));
#endif
-PRIVATE Void rgSCHDbmInitCrntRgrCfgLst ARGS(( RgSchCellCb *cellCb));
-PRIVATE Void rgSCHDbmInitPndngRgrCfgLst ARGS(( RgSchCellCb *cellCb));
+static Void rgSCHDbmInitCrntRgrCfgLst ARGS(( RgSchCellCb *cellCb));
+static Void rgSCHDbmInitPndngRgrCfgLst ARGS(( RgSchCellCb *cellCb));
#ifdef EMTC_ENABLE
-PUBLIC S16 rgSCHDbmPutEmtcRnti ARGS((RgSchCellCb *cellCb,RgSchRntiLnk *rntiLnk));
+ S16 rgSCHDbmPutEmtcRnti ARGS((RgSchCellCb *cellCb,RgSchRntiLnk *rntiLnk));
#endif
/* local typedefs */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInitCell
+S16 rgSCHDbmInitCell
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmInitCell(cellCb)
+S16 rgSCHDbmInitCell(cellCb)
RgSchCellCb *cellCb;
#endif
{
S16 ret;
- TRC2(rgSCHDbmInitCell);
-
/* Initialize ue list */
if ((ret = rgSCHDbmInitUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#ifdef LTE_TDD
if ((ret = rgSCHDbmInitUeTfuPendLst(cellCb,
RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#endif
#ifdef LTEMAC_SPS
/* Initialize SPS Ue list */
if ((ret = rgSCHDbmInitSpsUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
- RETVALUE(ret);
+ return (ret);
#endif /* LTEMAC_SPS */
/* Initialize BCCH/PCCH logical channels */
cmLListInit(&cellCb->l2mList);
#endif /* LTE_L2_MEAS */
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDbmInitCell */
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHDbmInitUeCbLst
+static S16 rgSCHDbmInitUeCbLst
(
RgSchCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
-PRIVATE S16 rgSCHDbmInitUeCbLst(cellCb, numBins)
+static S16 rgSCHDbmInitUeCbLst(cellCb, numBins)
RgSchCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
RgSchUeCellInfo ueCellInfo;
- TRC2(rgSCHDbmInitUeCbLst)
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
- RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
+ return (cmHashListInit(&cellCb->ueLst, numBins, (uint16_t)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool));
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDeInitUeCbLst
+S16 rgSCHDbmDeInitUeCbLst
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmDeInitUeCbLst(cellCb)
+S16 rgSCHDbmDeInitUeCbLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmDeInitUeCbLst)
- RETVALUE(cmHashListDeinit(&cellCb->ueLst));
+ return (cmHashListDeinit(&cellCb->ueLst));
} /* rgSCHDbmDeInitUeCbLst */
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHDbmInitSpsUeCbLst
+static S16 rgSCHDbmInitSpsUeCbLst
(
RgSchCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
-PRIVATE S16 rgSCHDbmInitSpsUeCbLst(cellCb, numBins)
+static S16 rgSCHDbmInitSpsUeCbLst(cellCb, numBins)
RgSchCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
RgSchUeCb ue;
- TRC2(rgSCHDbmInitSpsUeCbLst)
- RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
+ return (cmHashListInit(&cellCb->spsUeLst, numBins, (uint16_t) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool));
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDeInitSpsUeCbLst
+S16 rgSCHDbmDeInitSpsUeCbLst
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmDeInitSpsUeCbLst(cellCb)
+S16 rgSCHDbmDeInitSpsUeCbLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmDeInitSpsUeCbLst)
- RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
+ return (cmHashListDeinit(&cellCb->spsUeLst));
} /* rgSCHDbmDeInitSpsUeCbLst */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInsUeCb
+S16 rgSCHDbmInsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmInsUeCb(cellCb, ueCb)
+S16 rgSCHDbmInsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- TRC2(rgSCHDbmInsUeCb)
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
- RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCellInfo,
- (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
+ return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCellInfo,
+ (uint8_t *)&ueCb->ueId, (uint16_t)sizeof(ueCb->ueId)));
} /* rgSCHDbmInsUeCb */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInsSpsUeCb
+S16 rgSCHDbmInsSpsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmInsSpsUeCb(cellCb, ueCb)
+S16 rgSCHDbmInsSpsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDbmInsSpsUeCb)
-
- RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
- (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
+ return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
+ (uint8_t *)&ueCb->spsRnti, (uint16_t)sizeof(ueCb->spsRnti)));
} /* end of rgSCHDbmInsSpsUeCb */
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetUeCb
+RgSchUeCb* rgSCHDbmGetUeCb
(
RgSchCellCb *cellCb,
CmLteRnti ueId
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetUeCb(cellCb, ueId)
+RgSchUeCb* rgSCHDbmGetUeCb(cellCb, ueId)
RgSchCellCb *cellCb;
CmLteRnti ueId;
#endif
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- TRC2(rgSCHDbmGetUeCb)
-
- cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
+ cmHashListFind(&cellCb->ueLst, (uint8_t *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCellInfo);
- RETVALUE(!ueCellInfo?NULLP:ueCellInfo->ue);
+ return (!ueCellInfo?NULLP:ueCellInfo->ue);
} /* rgSCHDbmGetUeCb */
#ifdef LTEMAC_SPS
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetSpsUeCb
+RgSchUeCb* rgSCHDbmGetSpsUeCb
(
RgSchCellCb *cellCb,
CmLteRnti spsRnti
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetSpsUeCb(cellCb, spsRnti)
+RgSchUeCb* rgSCHDbmGetSpsUeCb(cellCb, spsRnti)
RgSchCellCb *cellCb;
CmLteRnti spsRnti;
#endif
{
RgSchUeCb *ueCb = NULLP;
- TRC2(rgSCHDbmGetSpsUeCb)
-
- cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
+ cmHashListFind(&cellCb->spsUeLst, (uint8_t *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
- RETVALUE(ueCb);
+ return (ueCb);
} /* rgSCHDbmGetSpsUeCb */
#endif
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetNextUeCb
+RgSchUeCb* rgSCHDbmGetNextUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetNextUeCb(cellCb, ueCb)
+RgSchUeCb* rgSCHDbmGetNextUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
RgSchUeCellInfo *ueCellInfo = NULLP;
RgSchUeCellInfo *nextUeCellInfo = NULLP;
- TRC2(rgSCHDbmGetNextUeCb)
-
if (ueCb)
{
ueCellInfo = ueCb->cellInfo[
}
cmHashListGetNext(&cellCb->ueLst, (PTR) ueCellInfo, (PTR *)&nextUeCellInfo);
- RETVALUE(!nextUeCellInfo?NULLP:nextUeCellInfo->ue);
+ return (!nextUeCellInfo?NULLP:nextUeCellInfo->ue);
} /* rgSCHDbmGetNextUeCb */
#ifdef LTEMAC_SPS
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchUeCb* rgSCHDbmGetNextSpsUeCb
+RgSchUeCb* rgSCHDbmGetNextSpsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC RgSchUeCb* rgSCHDbmGetNextSpsUeCb(cellCb, ueCb)
+RgSchUeCb* rgSCHDbmGetNextSpsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
RgSchUeCb *nextUeCb = NULLP;
- TRC2(rgSCHDbmGetNextSpsUeCb)
-
cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
- RETVALUE(nextUeCb);
+ return (nextUeCb);
} /* end of rgSCHDbmGetNextSpsUeCb */
#endif /* LTEMAC_SPS */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDelL2MUe
+S16 rgSCHDbmDelL2MUe
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmDelL2MUe(cellCb, ueCb)
+S16 rgSCHDbmDelL2MUe(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
- U8 lcCnt = 0;
+ uint8_t lcCnt = 0;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
- TRC2(rgSCHDbmDelL2MUe)
-
ueUl->hqEnt.numBusyHqProcs = 0;
/* Clean cell level UE Active Count */
for (lcCnt =0; lcCnt < RGSCH_MAX_LC_PER_UE; lcCnt++)
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmDelL2MUe */
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDelUeCb
+S16 rgSCHDbmDelUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmDelUeCb(cellCb, ueCb)
+S16 rgSCHDbmDelUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- TRC2(rgSCHDbmDelUeCb)
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
- RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCellInfo));
+ return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCellInfo));
} /* rgSCHDbmDelUeCb */
#ifdef LTEMAC_SPS
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDelSpsUeCb
+S16 rgSCHDbmDelSpsUeCb
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmDelSpsUeCb(cellCb, ueCb)
+S16 rgSCHDbmDelSpsUeCb(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDbmDelSpsUeCb)
- RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
+ return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
} /* end of rgSCHDbmDelSpsUeCb */
#endif /* LTEMAC_SPS */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmInitUe
+S16 rgSCHDbmInitUe
(
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHDbmInitUe(ueCb)
+S16 rgSCHDbmInitUe(ueCb)
RgSchUeCb *ueCb;
#endif
{
S16 ret = ROK;
- TRC2(rgSCHDbmInitUe);
-
/* Initialize Dedicated logical channels */
rgSCHDbmInitDedLcLst(ueCb);
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDbmInitUe */
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHDbmInitDedLcLst
+static Void rgSCHDbmInitDedLcLst
(
RgSchUeCb *ueCb
)
#else
-PRIVATE Void rgSCHDbmInitDedLcLst(ueCb)
+static Void rgSCHDbmInitDedLcLst(ueCb)
RgSchUeCb *ueCb;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC2(rgSCHDbmInitDedLcLst);
-
for (idx = 0; idx < RGSCH_MAX_LC_PER_UE; ++idx)
{
/* Set Dedicated LCs as not configured */
}
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInitDedLcLst */
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHDbmInitCmnLcLst
+static Void rgSCHDbmInitCmnLcLst
(
RgSchCellCb *cellCb
)
#else
-PRIVATE Void rgSCHDbmInitCmnLcLst(cellCb)
+static Void rgSCHDbmInitCmnLcLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- U8 idx;
+ uint8_t idx;
- TRC2(rgSCHDbmInitCmnLcLst);
-
for (idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
{
cellCb->cmnLcCb[idx].lcId = RGSCH_INVALID_LC_ID;
}
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInitCmnLcLst */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsDlDedLcCb
+Void rgSCHDbmInsDlDedLcCb
(
RgSchUeCb *ueCb,
RgSchDlLcCb *dlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsDlDedLcCb(ueCb, dlLcCb)
+Void rgSCHDbmInsDlDedLcCb(ueCb, dlLcCb)
RgSchUeCb *ueCb;
RgSchDlLcCb *dlLcCb;
#endif
{
- TRC2(rgSCHDbmInsDlDedLcCb);
ueCb->dl.lcCb[dlLcCb->lcId - 1] = dlLcCb;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmDelDlDedLcCb
+Void rgSCHDbmDelDlDedLcCb
(
RgSchUeCb *ueCb,
RgSchDlLcCb *dlLcCb
)
#else
-PUBLIC Void rgSCHDbmDelDlDedLcCb(ueCb, dlLcCb)
+Void rgSCHDbmDelDlDedLcCb(ueCb, dlLcCb)
RgSchUeCb *ueCb;
RgSchDlLcCb *dlLcCb;
#endif
{
- TRC2(rgSCHDbmDelDlDedLcCb);
#ifdef LTE_L2_MEAS
/* Clean cell level UE Active Count */
ueCb->dl.lcCb[dlLcCb->lcId - 1] = NULLP;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmDelDlDedLcCb */
* @return RgSchDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchDlLcCb* rgSCHDbmGetDlDedLcCb
+RgSchDlLcCb* rgSCHDbmGetDlDedLcCb
(
RgSchUeCb *ueCb,
CmLteLcId idx
)
#else
-PUBLIC RgSchDlLcCb* rgSCHDbmGetDlDedLcCb(ueCb, idx)
+RgSchDlLcCb* rgSCHDbmGetDlDedLcCb(ueCb, idx)
RgSchUeCb *ueCb;
CmLteLcId idx;
#endif
{
- TRC2(rgSCHDbmGetDlDedLcCb);
-
if (idx < RGSCH_DEDLC_MIN_LCID || idx > RGSCH_DEDLC_MAX_LCID)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
- RETVALUE(ueCb->dl.lcCb[idx-1]);
+ return (ueCb->dl.lcCb[idx-1]);
} /* rgSCHDbmGetDlDedLcCb */
* @return RgSchDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb
+RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb
(
RgSchUeCb *ueCb
)
#else
-PUBLIC RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb(ueCb)
+RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb(ueCb)
RgSchUeCb *ueCb;
#endif
{
- U8 idx;
- TRC2(rgSCHDbmGetFirstDlDedLcCb)
+ uint8_t idx;
for(idx = 0; idx < RGSCH_DEDLC_MAX_LCID; idx++)
{
if(ueCb->dl.lcCb[idx])
{
- RETVALUE(ueCb->dl.lcCb[idx]);
+ return (ueCb->dl.lcCb[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetFirstDlDedLcCb */
/**
* @brief Handler for accessing the existing next dl dedicated lcCb at idx
* @return RgSchDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb
+RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb
(
RgSchUeCb *ueCb,
RgSchDlLcCb *lcCb
)
#else
-PUBLIC RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb(ueCb, lcCb)
+RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb(ueCb, lcCb)
RgSchUeCb *ueCb;
RgSchDlLcCb *lcCb;
#endif
{
- U8 idx;
- TRC2(rgSCHDbmGetNextDlDedLcCb);
+ uint8_t idx;
if (!lcCb)
{
- RETVALUE(rgSCHDbmGetFirstDlDedLcCb(ueCb));
+ return (rgSCHDbmGetFirstDlDedLcCb(ueCb));
}
for(idx = lcCb->lcId; idx < RGSCH_DEDLC_MAX_LCID; idx++)
{
if(ueCb->dl.lcCb[idx])
{
- RETVALUE(ueCb->dl.lcCb[idx]);
+ return (ueCb->dl.lcCb[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetNextDlDedLcCb */
/**
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb
+RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb
(
RgSchCellCb *cellCb,
CmLteLcId lcId
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb(cellCb, lcId)
+RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb(cellCb, lcId)
RgSchCellCb *cellCb;
CmLteLcId lcId;
#endif
{
- U8 idx;
-
- TRC2(rgSCHDbmGetCmnLcCb)
+ uint8_t idx;
for(idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
{
if(cellCb->cmnLcCb[idx].lcId == lcId)
{
- RETVALUE(&(cellCb->cmnLcCb[idx]));
+ return (&(cellCb->cmnLcCb[idx]));
}
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetCmnLcCb */
/**
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch
+RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetBcchOnBch)
if(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX]));
+ return (&(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetBcchOnBch */
/**
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch
+RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetFirstBcchOnDlsch)
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1]));
+ return (&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetFirstBcchOnDlsch */
/**
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch
+RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetSecondBcchOnDlsch)
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2]));
+ return (&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetSecondBcchOnDlsch */
/**
* @return RgSchClcDlLcCb*
**/
#ifdef ANSI
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetPcch
+RgSchClcDlLcCb* rgSCHDbmGetPcch
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchClcDlLcCb* rgSCHDbmGetPcch(cellCb)
+RgSchClcDlLcCb* rgSCHDbmGetPcch(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmGetPcch)
if(cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId != RGSCH_INVALID_LC_ID)
{
- RETVALUE(&(cellCb->cmnLcCb[RGSCH_PCCH_IDX]));
+ return (&(cellCb->cmnLcCb[RGSCH_PCCH_IDX]));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetPcch */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsBcchOnBch
+Void rgSCHDbmInsBcchOnBch
(
RgSchCellCb *cellCb,
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsBcchOnBch(cellCb, cmnDlLcCb)
+Void rgSCHDbmInsBcchOnBch(cellCb, cmnDlLcCb)
RgSchCellCb *cellCb;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInsBcchOnBch)
cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId = cmnDlLcCb->lcId;
cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].boLst = cmnDlLcCb->boLst;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInsBcchOnBch */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsBcchOnDlsch
+Void rgSCHDbmInsBcchOnDlsch
(
RgSchCellCb *cellCb,
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsBcchOnDlsch(cellCb, cmnDlLcCb)
+Void rgSCHDbmInsBcchOnDlsch(cellCb, cmnDlLcCb)
RgSchCellCb *cellCb;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInsBcchOnDlsch)
-
if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId == RGSCH_INVALID_LC_ID)
{
cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId = cmnDlLcCb->lcId;
}
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInsBcchOnDlsch */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsPcch
+Void rgSCHDbmInsPcch
(
RgSchCellCb *cellCb,
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInsPcch(cellCb, cmnDlLcCb)
+Void rgSCHDbmInsPcch(cellCb, cmnDlLcCb)
RgSchCellCb *cellCb;
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInsPcch)
cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId = cmnDlLcCb->lcId;
cellCb->cmnLcCb[RGSCH_PCCH_IDX].boLst = cmnDlLcCb->boLst;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInsPcch */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInitCmnLcBoLst
+Void rgSCHDbmInitCmnLcBoLst
(
RgSchClcDlLcCb *cmnDlLcCb
)
#else
-PUBLIC Void rgSCHDbmInitCmnLcBoLst(cmnDlLcCb)
+Void rgSCHDbmInitCmnLcBoLst(cmnDlLcCb)
RgSchClcDlLcCb *cmnDlLcCb;
#endif
{
- TRC2(rgSCHDbmInitCmnLcBoLst)
cmLListInit(&cmnDlLcCb->boLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitCmnLcBoLst */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsCmnLcBoRpt
+Void rgSCHDbmInsCmnLcBoRpt
(
RgSchClcDlLcCb *cmnDlLcCb,
RgSchClcBoRpt *cmnBoRpt
)
#else
-PUBLIC Void rgSCHDbmInsCmnLcBoRpt(cmnDlLcCb, cmnBoRpt)
+Void rgSCHDbmInsCmnLcBoRpt(cmnDlLcCb, cmnBoRpt)
RgSchClcDlLcCb *cmnDlLcCb;
RgSchClcBoRpt *cmnBoRpt;
#endif
{
- TRC2(rgSCHDbmInsCmnLcBoRpt)
-
cmnBoRpt->boLstEnt.next = NULLP;
cmnBoRpt->boLstEnt.prev = NULLP;
cmnBoRpt->boLstEnt.node = (PTR)cmnBoRpt;
cmLListAdd2Tail(&cmnDlLcCb->boLst, &cmnBoRpt->boLstEnt);
- RETVOID;
+ return;
} /* rgSCHDbmInsCmnLcBoRpt */
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHDbmInitRaCbLst
+static Void rgSCHDbmInitRaCbLst
(
RgSchCellCb *cellCb
)
#else
-PRIVATE Void rgSCHDbmInitRaCbLst(cellCb)
+static Void rgSCHDbmInitRaCbLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmInitRaCbLst)
cmLListInit(&cellCb->raInfo.raCbLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitRaCbLst */
* @return RgSchRaCb*
**/
#ifdef ANSI
-PUBLIC RgSchRaCb* rgSCHDbmGetRaCb
+RgSchRaCb* rgSCHDbmGetRaCb
(
RgSchCellCb *cellCb,
CmLteRnti key
)
#else
-PUBLIC RgSchRaCb* rgSCHDbmGetRaCb(cellCb, key)
+RgSchRaCb* rgSCHDbmGetRaCb(cellCb, key)
RgSchCellCb *cellCb;
CmLteRnti key;
#endif
{
CmLList *tmpNode;
- TRC2(rgSCHDbmGetRaCb)
-
CM_LLIST_FIRST_NODE(&cellCb->raInfo.raCbLst,tmpNode);
while(tmpNode)
{
if(((RgSchRaCb *)tmpNode->node)->tmpCrnti == key)
{
- RETVALUE((RgSchRaCb *)(tmpNode->node));
+ return ((RgSchRaCb *)(tmpNode->node));
}
CM_LLIST_NEXT_NODE(&cellCb->raInfo.raCbLst,tmpNode);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetRaCb */
#ifndef LTE_TDD
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHDbmInitRaReqLst
+static Void rgSCHDbmInitRaReqLst
(
RgSchCellCb *cellCb
)
#else
-PRIVATE Void rgSCHDbmInitRaReqLst(cellCb)
+static Void rgSCHDbmInitRaReqLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- U8 idx;
-
- TRC2(rgSCHDbmInitRaReqLst)
+ uint8_t idx;
/* ccpu00133557- Memory Leak Fix- initializing for the all nodes
* in RAREQ list*/
{
cmLListInit(&cellCb->raInfo.raReqLst[idx]);
}
- RETVOID;
+ return;
} /* rgSCHDbmInitRaReqLst */
#endif
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHDbmInitCrntRgrCfgLst
+static Void rgSCHDbmInitCrntRgrCfgLst
(
RgSchCellCb *cellCb
)
#else
-PRIVATE Void rgSCHDbmInitCrntRgrCfgLst(cellCb)
+static Void rgSCHDbmInitCrntRgrCfgLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmInitCrntRgrCfgLst)
cmLListInit(&cellCb->rgCfgInfo.crntRgrCfgLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitCrntRgrCfgLst */
/**
* @return Void
**/
#ifdef ANSI
-PRIVATE Void rgSCHDbmInitPndngRgrCfgLst
+static Void rgSCHDbmInitPndngRgrCfgLst
(
RgSchCellCb *cellCb
)
#else
-PRIVATE Void rgSCHDbmInitPndngRgrCfgLst(cellCb)
+static Void rgSCHDbmInitPndngRgrCfgLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmInitPndngRgrCfgLst)
cmLListInit(&cellCb->rgCfgInfo.pndngRgrCfgLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitPndngRgrCfgLst */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsCrntRgrCfgElem
+Void rgSCHDbmInsCrntRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC Void rgSCHDbmInsCrntRgrCfgElem(cellCb, cfgElem)
+Void rgSCHDbmInsCrntRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmInsCrntRgrCfgElem)
-
cfgElem->cfgReqLstEnt.next = NULLP;
cfgElem->cfgReqLstEnt.prev = NULLP;
cmLListAdd2Tail(&cellCb->rgCfgInfo.crntRgrCfgLst, &cfgElem->cfgReqLstEnt);
- RETVOID;
+ return;
} /* rgSCHDbmInsCrntRgrCfgElem */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmInsPndngRgrCfgElem
+Void rgSCHDbmInsPndngRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC Void rgSCHDbmInsPndngRgrCfgElem(cellCb, cfgElem)
+Void rgSCHDbmInsPndngRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmInsPndngRgrCfgElem)
cfgElem->cfgReqLstEnt.next = NULLP;
cfgElem->cfgReqLstEnt.prev = NULLP;
cfgElem->cfgReqLstEnt.node = (PTR)cfgElem;
cmLListAdd2Tail(&cellCb->rgCfgInfo.pndngRgrCfgLst, &cfgElem->cfgReqLstEnt);
- RETVOID;
+ return;
} /* rgSCHDbmInsPndngRgrCfgElem */
/**
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem
+RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmGetNextCrntRgrCfgElem)
if(!cfgElem)
{
- RETVALUE( cellCb->rgCfgInfo.crntRgrCfgLst.first ?
+ return ( cellCb->rgCfgInfo.crntRgrCfgLst.first ?
(RgSchCfgElem *)(cellCb->rgCfgInfo.crntRgrCfgLst.first->node) : NULLP );
}
- RETVALUE( cfgElem->cfgReqLstEnt.next ?
+ return ( cfgElem->cfgReqLstEnt.next ?
(RgSchCfgElem *)(cfgElem->cfgReqLstEnt.next->node) : NULLP );
} /* rgSCHDbmGetNextCrntRgrCfgElem */
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem
+RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmGetNextPndngRgrCfgElem)
if(!cfgElem)
{
- RETVALUE( cellCb->rgCfgInfo.pndngRgrCfgLst.first ?
+ return ( cellCb->rgCfgInfo.pndngRgrCfgLst.first ?
(RgSchCfgElem *)(cellCb->rgCfgInfo.pndngRgrCfgLst.first->node) : NULLP );
}
- RETVALUE( cfgElem->cfgReqLstEnt.next ?
+ return ( cfgElem->cfgReqLstEnt.next ?
(RgSchCfgElem *)(cfgElem->cfgReqLstEnt.next->node) : NULLP );
} /* rgSCHDbmGetNextPndngRgrCfgElem */
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey
+RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey
(
RgSchCellCb *cellCb,
CmLteTimingInfo key
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey(cellCb, key)
+RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey(cellCb, key)
RgSchCellCb *cellCb;
CmLteTimingInfo key;
#endif
{
CmLList *tmpNode;
- TRC2(rgSCHDbmGetPndngRgrCfgElemByKey)
-
CM_LLIST_FIRST_NODE(&cellCb->rgCfgInfo.pndngRgrCfgLst,tmpNode);
while(tmpNode)
{
if((((RgSchCfgElem *)tmpNode->node)->actvTime.sfn == key.sfn) &&
(((RgSchCfgElem *)tmpNode->node)->actvTime.slot == key.slot))
{
- RETVALUE((RgSchCfgElem *)(tmpNode->node));
+ return ((RgSchCfgElem *)(tmpNode->node));
}
CM_LLIST_NEXT_NODE(&cellCb->rgCfgInfo.pndngRgrCfgLst,tmpNode);
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmGetPndngRgrCfgElemByKey */
/**
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem
+RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmDelCrntRgrCfgElem)
if(cmLListDelFrm(&cellCb->rgCfgInfo.crntRgrCfgLst,&cfgElem->cfgReqLstEnt))
{
- RETVALUE((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
+ return ((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmDelCrntRgrCfgElem */
/**
* @return RgSchCfgElem*
**/
#ifdef ANSI
-PUBLIC RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem
+RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem
(
RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem
)
#else
-PUBLIC RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem(cellCb, cfgElem)
+RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem(cellCb, cfgElem)
RgSchCellCb *cellCb;
RgSchCfgElem *cfgElem;
#endif
{
- TRC2(rgSCHDbmDelPndngRgrCfgElem)
-
if(cmLListDelFrm(&cellCb->rgCfgInfo.pndngRgrCfgLst,&cfgElem->cfgReqLstEnt))
{
- RETVALUE((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
+ return ((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
}
- RETVALUE(NULLP);
+ return (NULLP);
} /* rgSCHDbmDelPndngRgrCfgElem */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmRntiDbInit
+S16 rgSCHDbmRntiDbInit
(
RgSchCellCb *cellCb,
-U16 rntiStart,
-U16 maxRntis
+uint16_t rntiStart,
+uint16_t maxRntis
)
#else
-PUBLIC S16 rgSCHDbmRntiDbInit(cellCb, rntiStart, maxRntis)
+S16 rgSCHDbmRntiDbInit(cellCb, rntiStart, maxRntis)
RgSchCellCb *cellCb;
-U16 rntiStart;
-U16 maxRntis;
+uint16_t rntiStart;
+uint16_t maxRntis;
#endif
{
- U16 rnti;
+ uint16_t rnti;
RgSchRntiLnk *rntiPool;
- TRC2(rgSCHDbmRntiDbInit)
-
- /* Fix for Change Request ccpu00099150 */
+ /* Fix for Change Request ccpu00099150 */
if(rgSCHUtlAllocSBuf(cellCb->instIdx,
(Data **)&cellCb->rntiDb.rntiPool,maxRntis*sizeof(RgSchRntiLnk)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellCb->rntiDb.rntiStart = rntiStart;
cellCb->rntiDb.maxRntis = maxRntis;
}
else
{
- U16 idx;
+ uint16_t idx;
rntiPool[0].rnti = rnti++;
rntiPool[0].prv = NULLP;
rntiPool[0].nxt = &rntiPool[1];
cellCb->rntiDb.lastRnti = &rntiPool[idx];
}
cellCb->rntiDb.freeRnti = &rntiPool[0];
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmRntiDbInit */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmRntiDbDeInit
+Void rgSCHDbmRntiDbDeInit
(
RgSchCellCb *cellCb
)
#else
-PUBLIC Void rgSCHDbmRntiDbDeInit(cellCb)
+Void rgSCHDbmRntiDbDeInit(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmRntiDbDeInit)
-
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cellCb->instIdx, (Data **)(&(cellCb->rntiDb.rntiPool)),
cmLListInit(&cellCb->rntiDb.rntiGuardPool);
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmRntiDbDeInit */
* @return RgSchRntiLnk*
**/
#ifdef ANSI
-PUBLIC RgSchRntiLnk* rgSCHDbmGetRnti
+RgSchRntiLnk* rgSCHDbmGetRnti
(
RgSchCellCb *cellCb
)
#else
-PUBLIC RgSchRntiLnk* rgSCHDbmGetRnti(cellCb)
+RgSchRntiLnk* rgSCHDbmGetRnti(cellCb)
RgSchCellCb *cellCb;
#endif
{
RgSchRntiLnk *rntiLnk;
- TRC2(rgSCHDbmGetRnti)
-
if (!(cellCb->rntiDb.freeRnti))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI exhausted count:%d",
cellCb->rntiDb.count);
- RETVALUE(NULLP);
+ return (NULLP);
}
rntiLnk = cellCb->rntiDb.freeRnti;
cellCb->rntiDb.count--;
printf("rgSCHDbmGetRnti::rntiLnk->rnti %u\n",rntiLnk->rnti);
- RETVALUE(rntiLnk);
+ return (rntiLnk);
} /* rgSCHDbmGetRnti */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHDbmRlsRnti
+Void rgSCHDbmRlsRnti
(
RgSchCellCb *cellCb,
RgSchRntiLnk *rntiLnk
)
#else
-PUBLIC Void rgSCHDbmRlsRnti(cellCb, rntiLnk)
+Void rgSCHDbmRlsRnti(cellCb, rntiLnk)
RgSchCellCb *cellCb;
RgSchRntiLnk *rntiLnk;
#endif
{
- TRC2(rgSCHDbmRlsRnti)
#ifdef EMTC_ENABLE
if(ROK==rgSCHDbmPutEmtcRnti(cellCb,rntiLnk))
{
-RETVOID;
+return;
}
#endif
rntiLnk->nxt = NULLP;
cellCb->rntiDb.count++;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmRlsRnti */
* -# RFAILED
**/
#ifdef ANSI
-PRIVATE S16 rgSCHDbmInitUeTfuPendLst
+static S16 rgSCHDbmInitUeTfuPendLst
(
RgSchCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
-PRIVATE S16 rgSCHDbmInitUeTfuPendLst(cellCb, numBins)
+static S16 rgSCHDbmInitUeTfuPendLst(cellCb, numBins)
RgSchCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
RgSchUePucchRecpInfo pucchInfo;
- TRC2(rgSCHDbmInitUeTfuPendLst)
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
- if(cmHashListInit(&cellCb->ueTfuPendLst, numBins, (U16)((PTR)&(pucchInfo.hashLstEnt) - (PTR)&pucchInfo), FALSE,
+ if(cmHashListInit(&cellCb->ueTfuPendLst, numBins, (uint16_t)((PTR)&(pucchInfo.hashLstEnt) - (PTR)&pucchInfo), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmInitUeTfuPendLst */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDbmDeInitUeTfuPendLst
+S16 rgSCHDbmDeInitUeTfuPendLst
(
RgSchCellCb *cellCb
)
#else
-PUBLIC S16 rgSCHDbmDeInitUeTfuPendLst(cellCb)
+S16 rgSCHDbmDeInitUeTfuPendLst(cellCb)
RgSchCellCb *cellCb;
#endif
{
- TRC2(rgSCHDbmDeInitUeTfuPendLst)
cmHashListDeinit(&cellCb->ueTfuPendLst);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDbmDeInitUeTfuPendLst */
#endif