EXTERN U32 rgSchCmnBetaCqiOffstTbl[16];
EXTERN U32 rgSchCmnBetaRiOffstTbl[16];
EXTERN RgSchdApis rgSchCmnApis;
-EXTERN PUBLIC S16 RgUiRgmSendPrbRprtInd ARGS((
+EXTERN S16 RgUiRgmSendPrbRprtInd ARGS((
Pst* pst,
SuId suId,
RgmPrbRprtInd *prbRprtInd
));
-EXTERN PUBLIC S16 RgUiRgmSendTmModeChangeInd ARGS((
+EXTERN S16 RgUiRgmSendTmModeChangeInd ARGS((
Pst* pst,
SuId suId,
RgmTransModeInd *txModeChngInd
));
#ifdef EMTC_ENABLE
-EXTERN PUBLIC S16 rgSCHEmtcUtlGetSfAlloc ARGS((
+EXTERN S16 rgSCHEmtcUtlGetSfAlloc ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC S16 rgSCHEmtcUtlPutSfAlloc ARGS((
+EXTERN S16 rgSCHEmtcUtlPutSfAlloc ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHEmtcUtlUpdUeDciSize ARGS((
+EXTERN Void rgSCHEmtcUtlUpdUeDciSize ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb
));
-EXTERN PUBLIC Void rgSCHEmtcGetDciFrmt61ASize ARGS((
+EXTERN Void rgSCHEmtcGetDciFrmt61ASize ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC Void rgSCHEmtcGetDciFrmt60ASize ARGS((
+EXTERN Void rgSCHEmtcGetDciFrmt60ASize ARGS((
RgSchCellCb *cell
));
-EXTERN PUBLIC S16 rgSCHEmtcUtlFillPdschDciInfo ARGS((
+EXTERN S16 rgSCHEmtcUtlFillPdschDciInfo ARGS((
TfuPdschDciInfo *pdsch,
TfuDciInfo *pdcchDci
));
-EXTERN PUBLIC Void rgSCHEmtcUtlRlsRnti ARGS((
+EXTERN Void rgSCHEmtcUtlRlsRnti ARGS((
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
U8 *isLegacy
));
-EXTERN PUBLIC S16 rgSCHEmtcPdcchAlloc ARGS((
+EXTERN S16 rgSCHEmtcPdcchAlloc ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch
));
-EXTERN PUBLIC Void rgSCHEmtcPdcchFree ARGS((
+EXTERN Void rgSCHEmtcPdcchFree ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch
));
#endif
/* Functions specific to TM1/TM2/TM6/TM7 for PRB calculation*/
-PUBLIC Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
+Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
/* Functions specific to TM3/TM4 for PRB calculation*/
-PUBLIC Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
+Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
U32 bo,
U32 *prbReqrd));
#ifdef LTE_ADV
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
+RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
U16 cellId
));
#endif
*
*/
#ifdef ANSI
-PUBLIC F64 rgSCHUtlPower
+F64 rgSCHUtlPower
(
F64 x,
F64 n
)
#else
-PUBLIC F64 rgSCHUtlPower(x, n)
+F64 rgSCHUtlPower(x, n)
F64 x;
F64 n;
#endif
*
*/
#ifdef ANSI
-PUBLIC U32 rgSCHUtlParse
+U32 rgSCHUtlParse
(
U8 *buff,
U8 startPos,
U8 buffSize
)
#else
-PUBLIC U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
+U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
U8 *buff;
U8 startPos;
U8 endPos;
*
*/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlFindDist
+U8 rgSCHUtlFindDist
(
U16 crntTime,
U16 tempIdx
)
#else
-PUBLIC U8 rgSCHUtlFindDist(crntTime, tempIdx)
+U8 rgSCHUtlFindDist(crntTime, tempIdx)
U16 crntTime;
U16 tempIdx;
#endif
*
**/
#ifdef ANSI
-PUBLIC Bool rgSCHUtlPdcchAvail
+Bool rgSCHUtlPdcchAvail
(
RgSchCellCb *cell,
RgSchPdcchInfo *pdcchInfo,
RgSchPdcch **pdcch
)
#else
-PUBLIC Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
+Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
RgSchCellCb *cell;
RgSchPdcchInfo *pdcchInfo;
CmLteAggrLvl aggrLvl;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPdcchPut
+Void rgSCHUtlPdcchPut
(
RgSchCellCb *cell,
RgSchPdcchInfo *pdcchInfo,
RgSchPdcch *pdcch
)
#else
-PUBLIC Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
+Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
RgSchCellCb *cell;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPdcchInit
+Void rgSCHUtlPdcchInit
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
U16 nCce
)
#else
-PUBLIC Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
+Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
U16 nCce;
*
**/
#ifdef ANSI
-PUBLIC Void rgSchSFRTotalPoolFree
+Void rgSchSFRTotalPoolFree
(
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo,
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
+Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
RgSchSFRTotalPoolInfo *sfrTotalPoolInfo;
RgSchCellCb *cell;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchSFRTotalPoolInit
+S16 rgSchSFRTotalPoolInit
(
RgSchCellCb *cell,
RgSchDlSf *sf
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchDSFRRntpInfoInit
+S16 rgSchDSFRRntpInfoInit
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
*
**/
#ifdef ANSI
-PUBLIC S16 rgSchDSFRRntpInfoFree
+S16 rgSchDSFRRntpInfoFree
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
**/
#ifdef LTE_TDD
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddPhich
+S16 rgSCHUtlAddPhich
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
U8 iPhich
)
#else
-PUBLIC S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
+S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
RgSchCellCb *cell;
CmLteTimingInfo frm;
U8 hqFeedBack;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddPhich
+S16 rgSCHUtlAddPhich
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
Bool isForMsg3
)
#else
-PUBLIC S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
+S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
RgSchCellCb *cell;
CmLteTimingInfo frm;
U8 hqFeedBack;
*
**/
#ifdef ANSI
-PUBLIC RgSchDlSf* rgSCHUtlSubFrmGet
+RgSchDlSf* rgSCHUtlSubFrmGet
(
RgSchCellCb *cell,
CmLteTimingInfo frm
)
#else
-PUBLIC RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
+RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
RgSchCellCb *cell;
CmLteTimingInfo frm;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSubFrmPut
+Void rgSCHUtlSubFrmPut
(
RgSchCellCb *cell,
RgSchDlSf *sf
)
#else
-PUBLIC Void rgSCHUtlSubFrmPut(cell, sf)
+Void rgSCHUtlSubFrmPut(cell, sf)
RgSchCellCb *cell;
RgSchDlSf *sf;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlLog32bitNbase2
+U8 rgSCHUtlLog32bitNbase2
(
U32 n
)
#else
-PUBLIC U8 rgSCHUtlLog32bitNbase2(n)
+U8 rgSCHUtlLog32bitNbase2(n)
U32 n;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlRelPdcchFbk
+Void rgSCHUtlDlRelPdcchFbk
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 isAck
)
#else
-PUBLIC Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
+Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 isAck;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlProcAck
+Void rgSCHUtlDlProcAck
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHUtlDlProcAck(cell, hqP)
+Void rgSCHUtlDlProcAck(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrntiCE
+Void rgSCHUtlHdlCrntiCE
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlHdlCrntiCE(cell, ue)
+Void rgSCHUtlHdlCrntiCE(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlCalcNCce
+U8 rgSCHUtlCalcNCce
(
U8 bw,
RgrPhichNg ng,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
+U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
U8 bw;
RgrPhichNg ng;
U8 cfi;
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlCalcNCce
+U8 rgSCHUtlCalcNCce
(
U8 bw,
RgrPhichNg ng,
Bool isEcp
)
#else
-PUBLIC U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
+U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
U8 bw;
RgrPhichNg ng;
U8 cfi;
**/
#ifdef LTE_TDD
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetPhichInfo
+S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
U8 *rbStartRef,
U8 *iPhich
)
#else
-PUBLIC S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
+S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
RgSchUlHqProcCb *hqProc;
U8 *rbStartRef;
U8 *nDmrsRef;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetPhichInfo
+S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
U8 *rbStartRef,
U8 *nDmrsRef
)
#else
-PUBLIC S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
+S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
RgSchUlHqProcCb *hqProc;
U8 *rbStartRef;
U8 *nDmrsRef;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocRcptInfo
+S16 rgSCHUtlAllocRcptInfo
(
RgSchUlAlloc *alloc,
CmLteRnti *rnti,
U8 *hqPId
)
#else
-PUBLIC S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
+S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
rvRef, size, modType, isRtx, nDmrs, ndi,
hqPId)
RgSchUlAlloc *alloc;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocRcptInfo
+S16 rgSCHUtlAllocRcptInfo
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
TfuUeUlSchRecpInfo *recpReq
)
#else
-PUBLIC S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
+S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
CmLteTimingInfo *timeInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPrachCfgInit
+Void rgSCHUtlPrachCfgInit
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg
)
#else
-PUBLIC Void rgSCHUtlPrachCfgInit(cell, cellCfg)
+Void rgSCHUtlPrachCfgInit(cell, cellCfg)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellCfg
+S16 rgSCHUtlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
+S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *errInfo;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellCfg
+S16 rgSCHUtlRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
+S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *errInfo;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrCellRecfg
+S16 rgSCHUtlRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
+S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFreeCell
+S16 rgSCHUtlFreeCell
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlFreeCell(cell)
+S16 rgSCHUtlFreeCell(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeCfg
+S16 rgSCHUtlRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
+S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcCfg
+S16 rgSCHUtlRgrLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
+S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcRecfg
+S16 rgSCHUtlRgrLcRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
+S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcDel
+S16 rgSCHUtlRgrLcDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
+S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcgCfg
+S16 rgSCHUtlRgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *errInfo
)
#else
-PUBLIC S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
+S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgCfg *cfg;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLcgRecfg
+S16 rgSCHUtlRgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
+S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrLcgRecfg *recfg;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRgrLcgDel
+Void rgSCHUtlRgrLcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 lcgId
)
#else
-PUBLIC Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
+Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDoaInd
+Void rgSCHUtlDoaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuDoaRpt *doaRpt
)
#else
-PUBLIC Void rgSCHUtlDoaInd(cell, ue, doaRpt)
+Void rgSCHUtlDoaInd(cell, ue, doaRpt)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDoaRpt *doaRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlCqiInd
+Void rgSCHUtlDlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
+Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuDlCqiRpt *dlCqiRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSrsInd
+Void rgSCHUtlSrsInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
+Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuSrsRpt *srsRpt;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlTARpt
+Void rgSCHUtlDlTARpt
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlDlTARpt(cell, ue)
+Void rgSCHUtlDlTARpt(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlRlsSubFrm
+Void rgSCHUtlDlRlsSubFrm
(
RgSchCellCb *cell,
CmLteTimingInfo subFrm
)
#else
-PUBLIC Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
+Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
RgSchCellCb *cell;
CmLteTimingInfo subFrm;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdACqiTrigWt
+Void rgSCHUtlUpdACqiTrigWt
(
RgSchUeCb *ue,
RgSchUeCellInfo *cellInfo,
U8 isAck
)
#else
-PUBLIC Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
+Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
RgSchUeCb *ue;
RgSchUeCellInfo *cellInfo;
U8 isAck;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlUlTransInd
+Void rgSCHUtlHdlUlTransInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrcInd
+Void rgSCHUtlHdlCrcInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlHdlCrcFailInd
+Void rgSCHUtlHdlCrcFailInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
+Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlProcAddToRetx
+Void rgSCHUtlDlProcAddToRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHUtlDlProcAddToRetx(cell, hqP)
+Void rgSCHUtlDlProcAddToRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlHqPTbAddToTx
+Void rgSCHUtlDlHqPTbAddToTx
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
U8 tbIdx
)
#else
-PUBLIC Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
+Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
U8 tbIdx;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlHqPTbRmvFrmTx
+Void rgSCHUtlDlHqPTbRmvFrmTx
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
Bool isRepeting
)
#else
-PUBLIC Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
+Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
U8 tbIdx;
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb
+RgSchCellCb* rgSchUtlGetCellCb
(
Inst inst,
U16 cellId
)
#else
-PUBLIC RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
+RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
Inst inst;
U16 cellId;
#endif
* @return U8 servCellIdx
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlGetServCellIdx
+U8 rgSchUtlGetServCellIdx
(
Inst inst,
U16 cellId,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
+U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
Inst inst;
U16 cellId;
RgSchUeCb *ue;
* @return RgSchUeCb*
**/
#ifdef ANSI
-PUBLIC S16 rgSchUtlVldtCellId
+S16 rgSchUtlVldtCellId
(
Inst inst,
U16 cellId
)
#else
-PUBLIC S16 rgSchUtlVldtCellId(inst, cellId)
+S16 rgSchUtlVldtCellId(inst, cellId)
Inst inst;
U16 cellId;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeRecfg
+S16 rgSCHUtlRgrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeDlLc
+Void rgSCHUtlFreeDlLc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHUtlFreeDlLc(cell, ue, svc)
+Void rgSCHUtlFreeDlLc(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeUe
+Void rgSCHUtlFreeUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlFreeUe(cell, ue)
+Void rgSCHUtlFreeUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDlDedBoUpd
+Void rgSCHUtlDlDedBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *lc
)
#else
-PUBLIC Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
+Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *lc;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRecMsg3Alloc
+Void rgSCHUtlRecMsg3Alloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
+Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchRaCb *raCb;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdUlHqProc
+S16 rgSCHUtlUpdUlHqProc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *curProc,
RgSchUlHqProcCb *oldProc
)
#else
-PUBLIC S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
+S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
RgSchCellCb *cell;
RgSchUlHqProcCb *curProc;
RgSchUlHqProcCb *oldProc;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlContResUlGrant
+S16 rgSCHUtlContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlContResUlGrant(cell, ue, err)
+S16 rgSCHUtlContResUlGrant(cell, ue, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSrRcvd
+S16 rgSCHUtlSrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
+S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrShort
+Void rgSCHUtlUpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
+Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrTrunc
+Void rgSCHUtlUpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
+Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 lcgId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdBsrLong
+Void rgSCHUtlUpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
+Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 bsr0;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdExtPhr
+S16 rgSCHUtlUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
+S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo * extPhr;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdPhr
+S16 rgSCHUtlUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
+S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlCqiInd
+Void rgSCHUtlUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPucchDeltaPwrInd
+Void rgSCHUtlPucchDeltaPwrInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 delta
)
#else
-PUBLIC Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
+Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
RgSchCellCb *cell;
RgSchUeCb *ue;
S8 delta;
* @return S16
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUeReset
+Void rgSCHUtlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHUtlUeReset(cell, ue)
+Void rgSCHUtlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHqProcForUe
+Void rgSCHUtlUlHqProcForUe
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
RgSchUlHqProcCb **procRef
)
#else
-PUBLIC Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
+Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
RgSchCellCb *cell;
CmLteTimingInfo frm;
RgSchUeCb *ue;
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstRcptnReq
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
RgSchCellCb *cell;
#endif
{
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlNextRcptnReq
+RgSchUlAlloc *rgSCHUtlNextRcptnReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
+RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
(
RgSchCellCb *cell,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
U8 idx;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U8 idx
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
U8 idx;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuBndReq
+S16 rgSCHUtlTfuBndReq
(
Inst instId,
SuId suId,
SpId spId
)
#else
-PUBLIC S16 rgSCHUtlTfuBndReq(instId, suId, spId)
+S16 rgSCHUtlTfuBndReq(instId, suId, spId)
Inst instId;
SuId suId;
SpId spId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuUBndReq
+S16 rgSCHUtlTfuUBndReq
(
Inst inst,
RgSchLowSapCfgInfo sapCfg,
Reason reason
)
#else
-PUBLIC S16 rgSCHUtlTfuUBndReq(inst, sapCfg, reason)
+S16 rgSCHUtlTfuUBndReq(inst, sapCfg, reason)
Inst inst;
RgSchLowSapCfgInfo sapCfg;
Reason reason;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlResetSfAlloc
+S16 rgSCHUtlResetSfAlloc
(
RgInfSfAlloc *sfAlloc,
Bool resetCmnLcInfo,
Bool restAlloc
)
#else
-PUBLIC S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
+S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
RgInfSfAlloc *sfAlloc;
Bool resetCmnLcInfo;
Bool restAlloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetRlsHqAlloc
+S16 rgSCHUtlGetRlsHqAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlGetRlsHqAlloc(cell)
+S16 rgSCHUtlGetRlsHqAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlPutRlsHqAlloc
+S16 rgSCHUtlPutRlsHqAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlPutRlsHqAlloc(cell)
+S16 rgSCHUtlPutRlsHqAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetSfAlloc
+S16 rgSCHUtlGetSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlGetSfAlloc(cell)
+S16 rgSCHUtlGetSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlPutSfAlloc
+S16 rgSCHUtlPutSfAlloc
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlPutSfAlloc(cell)
+S16 rgSCHUtlPutSfAlloc(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocSBuf
+S16 rgSCHUtlAllocSBuf
(
Inst inst, /* Instance of the invoking scheduler */
Data **pData, /* Pointer of the data to be returned */
Size size /* size */
)
#else
-PUBLIC S16 rgSCHUtlAllocSBuf(inst, pData, size)
+S16 rgSCHUtlAllocSBuf(inst, pData, size)
Inst inst; /* Instance of the invoking scheduler */
Data **pData; /* Pointer of the data to be returned */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeSBuf
+Void rgSCHUtlFreeSBuf
(
Inst inst, /* Instance of the invoking scheduler */
Data **data, /* pointer to data */
Size size /* size */
)
#else
-PUBLIC Void rgSCHUtlFreeSBuf(inst, data, size)
+Void rgSCHUtlFreeSBuf(inst, data, size)
Inst inst; /* Instance of the invoking scheduler */
Data **data; /* pointer to data */
Size size; /* size */
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeWarningSiSeg
+Void rgSCHUtlFreeWarningSiSeg
(
Region reg,
Pool pool,
CmLListCp *siPduLst
)
#else
-PUBLIC Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
+Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
Region reg;
Pool pool;
CmLListCp *siPduLst;
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFreeWarningSiPdu
+Void rgSCHUtlFreeWarningSiPdu
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlFreeWarningSiPdu(cell)
+Void rgSCHUtlFreeWarningSiPdu(cell)
RgSchCellCb *cell;
#endif
{
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC Buffer *rgSCHUtlGetWarningSiPdu
+Buffer *rgSCHUtlGetWarningSiPdu
(
RgSchCellCb *cell
)
#else
-PUBLIC Buffer *rgSCHUtlGetWarningSiPdu(cell)
+Buffer *rgSCHUtlGetWarningSiPdu(cell)
RgSchCellCb *cell;
#endif
{
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetMcsAndNPrb
+S16 rgSCHUtlGetMcsAndNPrb
(
RgSchCellCb *cell,
U8 *nPrb,
MsgLen *msgLen
)
#else
-PUBLIC S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
+S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
U8 *nPrb;
U8 *mcs;
* File: rg_utl.c
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlCalMcsAndNPrb
+S16 rgSCHUtlCalMcsAndNPrb
(
RgSchCellCb *cell,
U8 cfgType,
U8 siId
)
#else
-PUBLIC S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
+S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
U8 cfgType;
MsgLen msgLen;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlFillDgnParams
+Void rgSCHUtlFillDgnParams
(
Inst inst,
RgUstaDgn *dgn,
U8 dgnType
)
#else
-PUBLIC Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
+Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
Inst inst;
RgUstaDgn *dgn;
U8 dgnType;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetPstToLyr
+Void rgSCHUtlGetPstToLyr
(
Pst *pst,
RgSchCb *schCb,
Inst macInst
)
#else
-PUBLIC Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
+Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
Pst *pst;
RgSchCb *schCb;
Inst macInst;
pst->dstProcId = schCb->rgSchInit.procId;
pst->dstInst = macInst;
- pst->dstEnt = ENTRG;
- pst->srcEnt = ENTRG;
+ pst->dstEnt = ENTMAC;
+ pst->srcEnt = ENTMAC;
pst->selector = 0;
pst->prior = PRIOR0;
pst->intfVer = 0;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillRgInfCmnLcInfo
+S16 rgSCHUtlFillRgInfCmnLcInfo
(
RgSchDlSf *sf,
RgInfSfAlloc *sfAlloc,
Bool sendInd
)
#else
-PUBLIC S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
+S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
RgSchDlSf *sf;
RgInfSfAlloc *sfAlloc;
CmLteLcId lcId;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillRgInfRarInfo
+S16 rgSCHUtlFillRgInfRarInfo
(
RgSchDlSf *sf,
RgInfSfAlloc *sfAlloc,
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
+S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
RgSchDlSf *sf;
RgInfSfAlloc *sfAlloc;
RgSchCellCb *cell;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillPdschDciInfo
+S16 rgSCHUtlFillPdschDciInfo
(
TfuPdschDciInfo *pdsch,
TfuDciInfo *pdcchDci
)
#else
-PUBLIC S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
+S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
TfuPdschDciInfo *pdsch;
TfuDciInfo *pdcchDci;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSchDSFRPwrCheck
+Void rgSchDSFRPwrCheck
(
RgSchDlSf *sf,
Bool *isAllUePwrHigh
**********************************************************/
/* CA dev Start */
#ifdef ANSI
-PUBLIC Void rgSCHUtlFillRgInfUeInfo
+Void rgSCHUtlFillRgInfUeInfo
(
RgSchDlSf *sf,
RgSchCellCb *cell,
CmLListCp *ulInActvLst
)
#else
-PUBLIC Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
+Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
{
RgSchDlSf *sf;
RgSchCellCb *cell;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdSch
+S16 rgSCHUtlUpdSch
(
RgInfSfDatInd *subfrmInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
+S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
RgInfSfDatInd *subfrmInfo;
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAddUeToCcchSduLst
+S16 rgSCHUtlAddUeToCcchSduLst
(
RgSchCellCb *cell,
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
+S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdtBo
+S16 rgSCHUtlUpdtBo
(
RgSchCellCb *cell,
RgInfCmnBoRpt *staRsp
)
#else
-PUBLIC S16 rgSCHUtlUpdtBo(cell, staRsp)
+S16 rgSCHUtlUpdtBo(cell, staRsp)
RgSchCellCb *cell;
RgInfCmnBoRpt *staRsp;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlHndlCcchBoUpdt
+S16 rgSCHUtlHndlCcchBoUpdt
(
RgSchCellCb *cell,
RgInfCmnBoRpt *boRpt
)
#else
-PUBLIC S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
+S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
RgSchCellCb *cell;
RgInfCmnBoRpt *boRpt;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S32 rgSCHUtlGetAllwdCchTbSz
+S32 rgSCHUtlGetAllwdCchTbSz
(
U32 bo,
U8 *nPrb,
U8 *mcs
)
#else
-PUBLIC S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
+S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
U32 bo;
U8 *nPrb;
U8 *mcs;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlHndlBcchPcchBoUpdt
+S16 rgSCHUtlHndlBcchPcchBoUpdt
(
RgSchCellCb *cell,
RgInfCmnBoRpt *boUpdt
)
#else
-PUBLIC S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
+S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
RgSchCellCb *cell;
RgInfCmnBoRpt *boUpdt;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrBndCfm
+S16 rgSCHUtlRgrBndCfm
(
Inst instId,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrBndCfm(instId, suId, status)
+S16 rgSCHUtlRgrBndCfm(instId, suId, status)
Inst instId;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgmBndCfm
+S16 rgSCHUtlRgmBndCfm
(
Inst instId,
SuId suId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgmBndCfm(instId, suId, status)
+S16 rgSCHUtlRgmBndCfm(instId, suId, status)
Inst instId;
SuId suId;
U8 status;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 schSendCfgCfm
+S16 schSendCfgCfm
(
Region reg,
Pool pool,
U8 status
)
#else
-PUBLIC S16 schSendCfgCfm(reg, pool, transId, status)
+S16 schSendCfgCfm(reg, pool, transId, status)
Region reg;
Pool pool;
RgrCfgTransId transId;
cfmPst.srcEnt = (Ent)ENTDUAPP;
cfmPst.srcInst = (Inst) 0;
cfmPst.srcProcId = SFndProcId();
- cfmPst.dstEnt = (Ent)ENTRG;
+ cfmPst.dstEnt = (Ent)ENTMAC;
cfmPst.dstInst = (Inst) 0;
cfmPst.dstProcId = SFndProcId();
cfmPst.selector = ODU_SELECTOR_LC;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrTtiInd
+S16 rgSCHUtlRgrTtiInd
(
RgSchCellCb *cell,
RgrTtiIndInfo *rgrTti
)
#else
-PUBLIC S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
+S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
RgSchCellCb *cell;
RgrTtiIndInfo *rgrTti;
#endif
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlProcMsg3
+S16 rgSCHUtlProcMsg3
(
RgInfSfDatInd *subfrmInfo,
RgSchCellCb *cellCb,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
+S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
RgInfSfDatInd *subfrmInfo;
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSpsRelInd
+S16 rgSCHUtlSpsRelInd
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
Bool isExplRel
)
#else
-PUBLIC S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
+S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
Bool isExplRel;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlSpsActInd
+S16 rgSCHUtlSpsActInd
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
U16 spsSduSize
)
#else
-PUBLIC S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
+S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
U16 spsSduSize;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuGrpPwrCntrlReq
+S16 rgSCHUtlTfuGrpPwrCntrlReq
(
Inst inst,
S16 sapId,
TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq
)
#else
-PUBLIC S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
+S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
Inst inst;
S16 sapId;
TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuCntrlReq
+S16 rgSCHUtlTfuCntrlReq
(
Inst inst,
S16 sapId,
TfuCntrlReqInfo *cntrlReq
)
#else
-PUBLIC S16 rgSCHUtlTfuCntrlReq(inst, sapId, cntrlReq)
+S16 rgSCHUtlTfuCntrlReq(inst, sapId, cntrlReq)
Inst inst;
S16 sapId;
TfuCntrlReqInfo *cntrlReq;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlDlActvtUe
+S16 rgSCHUtlDlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHUtlDlActvtUe(cell, ue)
+S16 rgSCHUtlDlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlActvtUe
+S16 rgSCHUtlUlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC S16 rgSCHUtlUlActvtUe(cell, ue)
+S16 rgSCHUtlUlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlTfuRecpReq
+S16 rgSCHUtlTfuRecpReq
(
Inst inst,
S16 sapId,
TfuRecpReqInfo *recpReq
)
#else
-PUBLIC S16 rgSCHUtlTfuRecpReq(inst, sapId, recpReq)
+S16 rgSCHUtlTfuRecpReq(inst, sapId, recpReq)
Inst inst;
S16 sapId;
TfuRecpReqInfo *recpReq;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlValidateTfuSap
+S16 rgSCHUtlValidateTfuSap
(
Inst inst,
SuId suId
)
#else
-PUBLIC S16 rgSCHUtlValidateTfuSap(inst, suId)
+S16 rgSCHUtlValidateTfuSap(inst, suId)
Inst inst;
SuId suId;
#endif
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocEventMem
+S16 rgSCHUtlAllocEventMem
(
Inst inst,
Ptr *memPtr,
Size memSize
)
#else
-PUBLIC S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
+S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
Inst inst;
Ptr *memPtr;
Size memSize;
*
*/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetEventMem
+S16 rgSCHUtlGetEventMem
(
Ptr *ptr,
Size len,
Ptr memCp
)
#else
-PUBLIC S16 rgSCHUtlGetEventMem(ptr, len, memCp)
+S16 rgSCHUtlGetEventMem(ptr, len, memCp)
Ptr *ptr;
Size len;
Ptr memCp;
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlAllocUeANFdbkInfo
+S16 rgSCHUtlAllocUeANFdbkInfo
(
RgSchUeCb *ue,
U8 servCellIdx
)
#else
-PUBLIC S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
+S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
U8 servCellIdx;
#endif
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlDelUeANFdbkInfo
+Void rgSCHUtlDelUeANFdbkInfo
(
RgSchUeCb *ue,
U8 servCellIdx
)
#else
-PUBLIC Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
+Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
U8 servCellIdx;
#endif
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlInitUeANFdbkInfo
+S16 rgSCHUtlInitUeANFdbkInfo
(
RgSchTddANInfo *anFdInfo
)
#else
-PUBLIC S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
+S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
RgSchTddANInfo *anFdInfo;
#endif
{
* @return RgSchTddANInfo*
**/
#ifdef ANSI
-PUBLIC RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
(
RgSchUeCb *ueCb,
CmLteTimingInfo *timeInfo,
U8 servCellIdx
)
#else
-PUBLIC RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
RgSchUeCb *ueCb;
CmLteTimingInfo *timeInfo;
U8 servCellIdx;
*
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlGetDlSfIdx
+U8 rgSCHUtlGetDlSfIdx
(
RgSchCellCb *cell,
CmLteTimingInfo *timeInfo
)
#else
-PUBLIC U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
+U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
RgSchCellCb *cell;
CmLteTimingInfo *timeInfo;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetNxtDlSfInfo
+Void rgSCHUtlGetNxtDlSfInfo
(
CmLteTimingInfo curDlTime,
RgSchCellCb *cell,
CmLteTimingInfo *nxtDlTime
)
#else
-PUBLIC Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
+Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
CmLteTimingInfo curDlTime;
RgSchCellCb *cell;
RgSchDlSf *dlSf;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlGetPrevDlSfInfo
+Void rgSCHUtlGetPrevDlSfInfo
(
RgSchCellCb *cell,
CmLteTimingInfo curDlTime,
U8 *numSubfrm
)
#else
-PUBLIC Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
+Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
RgSchCellCb *cell;
CmLteTimingInfo curDlTime;
CmLteTimingInfo *prevDlTime;
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlSfInit
+S16 rgSCHUtlUlSfInit
(
RgSchCellCb *cell,
RgSchUlSf *sf,
U8 maxUePerSf
)
#else
-PUBLIC S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
+S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
RgSchCellCb *cell;
RgSchUlSf *sf;
U8 idx;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlSfDeinit
+Void rgSCHUtlUlSfDeinit
(
RgSchCellCb *cell,
RgSchUlSf *sf
)
#else
-PUBLIC Void rgSCHUtlUlSfDeinit(cell, sf)
+Void rgSCHUtlUlSfDeinit(cell, sf)
RgSchCellCb *cell;
RgSchUlSf *sf;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
(
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
RgSchUlSf *sf;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
(
RgSchUlSf *sf,
U8 numSb,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
RgSchUlSf *sf;
U8 numSb;
RgSchUlHole *hole;
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocFirst
+RgSchUlAlloc *rgSCHUtlUlAllocFirst
(
RgSchUlSf *sf
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
+RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
RgSchUlSf *sf;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocNxt
+RgSchUlAlloc *rgSCHUtlUlAllocNxt
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
+RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
(
RgSchUlAllocDb *db,
RgSchUlAlloc *prv
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
RgSchUlAllocDb *db;
RgSchUlAlloc *prv;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
(
RgSchUlAllocDb *db
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
RgSchUlAllocDb *db;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleAddAllocation
+Void rgSCHUtlUlHoleAddAllocation
(
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleAddAllocation(alloc)
+Void rgSCHUtlUlHoleAddAllocation(alloc)
RgSchUlAlloc *alloc;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocRelease
+Void rgSCHUtlUlAllocRelease
(
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocRelease(alloc)
+Void rgSCHUtlUlAllocRelease(alloc)
RgSchUlAlloc *alloc;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocRls
+Void rgSCHUtlUlAllocRls
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocRls(sf, alloc)
+Void rgSCHUtlUlAllocRls(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleFirst
+RgSchUlHole *rgSCHUtlUlHoleFirst
(
RgSchUlSf *sf
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
+RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
RgSchUlSf *sf;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleNxt
+RgSchUlHole *rgSCHUtlUlHoleNxt
(
RgSchUlSf *sf,
RgSchUlHole *hole
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
+RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
RgSchUlSf *sf;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleAddAlloc
+Void rgSCHUtlUlHoleAddAlloc
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
+Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
RgSchUlSf *sf;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleJoin
+Void rgSCHUtlUlHoleJoin
(
RgSchUlHoleDb *db,
RgSchUlHole *prv,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
+Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *prv;
RgSchUlHole *nxt;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleExtndRight
+Void rgSCHUtlUlHoleExtndRight
(
RgSchUlHoleDb *db,
RgSchUlHole *prv,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
+Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *prv;
RgSchUlAlloc *alloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleExtndLeft
+Void rgSCHUtlUlHoleExtndLeft
(
RgSchUlHoleDb *db,
RgSchUlHole *nxt,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
+Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
RgSchUlHoleDb *db;
RgSchUlHole *nxt;
RgSchUlAlloc *alloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleNew
+Void rgSCHUtlUlHoleNew
(
RgSchUlHoleDb *db,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleNew(db, alloc)
+Void rgSCHUtlUlHoleNew(db, alloc)
RgSchUlHoleDb *db;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleUpdAllocLnks
+Void rgSCHUtlUlHoleUpdAllocLnks
(
RgSchUlHole *hole,
RgSchUlAlloc *prvAlloc,
RgSchUlAlloc *nxtAlloc
)
#else
-PUBLIC Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
+Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
RgSchUlHole *hole;
RgSchUlAlloc *prvAlloc;
RgSchUlAlloc *nxtAlloc;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleIns
+Void rgSCHUtlUlHoleIns
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleIns(db, hole)
+Void rgSCHUtlUlHoleIns(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleIncr
+Void rgSCHUtlUlHoleIncr
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleIncr(db, hole)
+Void rgSCHUtlUlHoleIncr(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleDecr
+Void rgSCHUtlUlHoleDecr
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleDecr(db, hole)
+Void rgSCHUtlUlHoleDecr(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleRls
+Void rgSCHUtlUlHoleRls
(
RgSchUlHoleDb *db,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleRls(db, hole)
+Void rgSCHUtlUlHoleRls(db, hole)
RgSchUlHoleDb *db;
RgSchUlHole *hole;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlAllocMemInit
+S16 rgSCHUtlUlAllocMemInit
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem,
U8 maxAllocs
)
#else
-PUBLIC S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
+S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
U8 maxAllocs;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocMemDeinit
+Void rgSCHUtlUlAllocMemDeinit
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem
)
#else
-PUBLIC Void rgSCHUtlUlAllocMemDeinit(cell, mem)
+Void rgSCHUtlUlAllocMemDeinit(cell, mem)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUlHoleMemInit
+S16 rgSCHUtlUlHoleMemInit
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem,
RgSchUlHole **holeRef
)
#else
-PUBLIC S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
+S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
U8 maxHoles;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleMemDeinit
+Void rgSCHUtlUlHoleMemDeinit
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem
)
#else
-PUBLIC Void rgSCHUtlUlHoleMemDeinit(cell, mem)
+Void rgSCHUtlUlHoleMemDeinit(cell, mem)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocMemGet
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet
(
RgSchUlAllocMem *mem
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
RgSchUlAllocMem *mem;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlAllocMemRls
+Void rgSCHUtlUlAllocMemRls
(
RgSchUlAllocMem *mem,
RgSchUlAlloc *alloc
)
#else
-PUBLIC Void rgSCHUtlUlAllocMemRls(mem, alloc)
+Void rgSCHUtlUlAllocMemRls(mem, alloc)
RgSchUlAllocMem *mem;
RgSchUlAlloc *alloc;
#endif
*
**********************************************************/
#ifdef ANSI
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleMemGet
+RgSchUlHole *rgSCHUtlUlHoleMemGet
(
RgSchUlHoleMem *mem
)
#else
-PUBLIC RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
+RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
RgSchUlHoleMem *mem;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUlHoleMemRls
+Void rgSCHUtlUlHoleMemRls
(
RgSchUlHoleMem *mem,
RgSchUlHole *hole
)
#else
-PUBLIC Void rgSCHUtlUlHoleMemRls(mem, hole)
+Void rgSCHUtlUlHoleMemRls(mem, hole)
RgSchUlHoleMem *mem;
RgSchUlHole *hole;
#endif
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
(
RgSchUlSf *sf,
U8 startSb,
U8 numSb
)
#else
-PUBLIC RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
RgSchUlSf *sf;
U8 startSb;
U8 numSb;
* @return RgSchUlAlloc*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlValidateMeasReq
+S16 rgSCHUtlValidateMeasReq
(
RgSchCellCb *cellCb,
LrgSchMeasReqInfo *schL2MeasInfo,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
+S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
RgSchCellCb *cellCb;
LrgSchMeasReqInfo *schL2MeasInfo;
RgSchErrInfo *err;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrSiCfgCfm
+S16 rgSCHUtlRgrSiCfgCfm
(
Inst instId,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
+S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
Inst instId;
SpId spId;
RgrCfgTransId transId;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrWarningSiCfgCfm
+S16 rgSCHUtlRgrWarningSiCfgCfm
(
Inst instId,
SpId spId,
U8 status
)
#else
-PUBLIC S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
+S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
Inst instId;
SpId spId;
U8 siId;
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHUtlPutSiInfo
+Void rgSCHUtlPutSiInfo
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlPutSiInfo(cell)
+Void rgSCHUtlPutSiInfo(cell)
RgSchCellCb *cell;
#endif
{
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlGetDrxSchdUesInDl
+S16 rgSCHUtlGetDrxSchdUesInDl
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
CmLListCp *ulInActvLst
)
#else
-PUBLIC S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
+S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
RgSchDlHqProcCb *dlHq;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillSndStaInd
+S16 rgSCHUtlFillSndStaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 numCqiRept
)
#else
-PUBLIC S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
+S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrStaIndInfo *staInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrStaInd
+S16 rgSCHUtlRgrStaInd
(
RgSchCellCb *cell,
RgrStaIndInfo *rgrSta
)
#else
-PUBLIC S16 rgSCHUtlRgrStaInd(cell, rgrSta)
+S16 rgSCHUtlRgrStaInd(cell, rgrSta)
RgSchCellCb *cell;
RgrStaIndInfo *rgrSta;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlIndRntiRls2Mac
+Void rgSCHUtlIndRntiRls2Mac
(
RgSchCellCb *cell,
CmLteRnti rnti,
CmLteRnti newRnti
)
#else
-PUBLIC Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
+Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
RgSchCellCb *cell;
CmLteRnti rnti;
Bool ueIdChng;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrLoadInfInd
+S16 rgSCHUtlRgrLoadInfInd
(
RgSchCellCb *cell,
RgrLoadInfIndInfo *rgrLoadInf
)
#else
-PUBLIC S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
+S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
RgSchCellCb *cell;
RgrLoadInfIndInfo *rgrLoadInf;
#endif
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlRlsRnti
+Void rgSCHUtlRlsRnti
(
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
CmLteRnti newRnti
)
#else
-PUBLIC Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
+Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
RgSchCellCb *cell;
RgSchRntiLnk *rntiLnk;
Bool ueIdChngd;
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlFillSndUeStaInd
+S16 rgSCHUtlFillSndUeStaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeStaIndInfo *ueStaInfo
)
#else
-PUBLIC S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
+S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeStaIndInfo *ueStaInfo;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlRgrUeStaInd
+S16 rgSCHUtlRgrUeStaInd
(
RgSchCellCb *cell,
RgrUeStaIndInfo *rgrUeSta
)
#else
-PUBLIC S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
+S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
RgSchCellCb *cell;
RgrUeStaIndInfo *rgrUeSta;
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage
+S16 rgSCHUtlUpdAvgPrbUsage
(
RgSchCellCb *cell
)
#else
-PUBLIC S16 rgSCHUtlUpdAvgPrbUsage(cell)
+S16 rgSCHUtlUpdAvgPrbUsage(cell)
RgSchCellCb *cell;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlReTxTa
+Void rgSCHUtlReTxTa
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHUtlReTxTa(cellCb, ueCb)
+Void rgSCHUtlReTxTa(cellCb, ueCb)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
#endif
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlCfg0ReTxIdx
+U8 rgSchUtlCfg0ReTxIdx
(
RgSchCellCb *cell,
CmLteTimingInfo phichTime,
U8 hqFdbkIdx
)
#else
-PUBLIC U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
+U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
RgSchCellCb *cell;
CmLteTimingInfo phichTime;
U8 hqFdbkIdx;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlDlCalc1CwPrb
+Void rgSchUtlDlCalc1CwPrb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
+Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlDlCalc2CwPrb
+Void rgSchUtlDlCalc2CwPrb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
+Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSchUtlCalcTotalPrbReq
+Void rgSchUtlCalcTotalPrbReq
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *prbReqrd
)
#else
-PUBLIC Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
+Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 bo;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlGetNumSbs
+U8 rgSchUtlGetNumSbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U32 *numSbs
)
#else
-PUBLIC U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
+U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
U32 *numSbs;
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSchUtlSortInsUeLst
+U8 rgSchUtlSortInsUeLst
(
RgSchCellCb *cell,
CmLListCp *ueLst,
U8 vrbgRequired
)
#else
-PUBLIC U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
+U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
RgSchCellCb *cell;
CmLListCp *ueLst;
CmLList *node;
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlBuildNSendLcgReg
+S16 rgSCHUtlBuildNSendLcgReg
(
RgSchCellCb *cell,
CmLteRnti crnti,
Bool isGbr
)
#else
-PUBLIC S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
+S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
RgSchCellCb *cell;
CmLteRnti crnti;
U8 lcgId;
* -# ROK
**/
#ifdef ANSI
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode
+TfuAckNackMode rgSchUtlGetFdbkMode
(
RgrSchFrmt1b3TypEnum fdbkType
)
#else
-PUBLIC TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
+TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
RgrSchFrmt1b3TypEnum fdbkType;
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlSndUeSCellDel2Mac
+Void rgSCHUtlSndUeSCellDel2Mac
(
RgSchCellCb *cell,
CmLteRnti rnti
)
#else
-PUBLIC Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
+Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
RgSchCellCb *cell;
CmLteRnti rnti;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC U8 rgSCHUtlGetMaxTbSupp
+U8 rgSCHUtlGetMaxTbSupp
(
RgrTxMode txMode
)
#else
-PUBLIC U8 rgSCHUtlGetMaxTbSupp(txMode)
+U8 rgSCHUtlGetMaxTbSupp(txMode)
RgrTxMode txMode
#endif
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgSCHTomUtlGetTrigSet
+Void rgSCHTomUtlGetTrigSet
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlUpdUeDciSize
+Void rgSCHUtlUpdUeDciSize
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
Bool isCsi2Bit
)
#else
-PUBLIC Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
+Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
Bool isCsi2Bit;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlCalcDciSizes
+Void rgSCHUtlCalcDciSizes
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlCalcDciSizes(cell)
+Void rgSCHUtlCalcDciSizes(cell)
RgSchCellCb *cell;
#endif
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHUtlCpuOvrLdAdjItbsCap
+Void rgSCHUtlCpuOvrLdAdjItbsCap
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
+Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
RgSchCellCb *cell
#endif
{
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHUtlResetCpuOvrLdState
+S16 rgSCHUtlResetCpuOvrLdState
(
RgSchCellCb *cell,
U8 crntCpuOvrLdIns
)
#else
-PUBLIC S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
+S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
RgSchCellCb *cell;
U8 crntCpuOvrLdIns;
#endif
return ROK;
}
#ifdef EMTC_ENABLE
-PUBLIC S16 rgSCHUtlAddToResLst
+S16 rgSCHUtlAddToResLst
(
CmLListCp *cp,
RgSchIotRes *iotRes
iotRes->resLnk.node = (PTR)iotRes;
return ROK;
}
-PUBLIC S16 rgSCHUtlDelFrmResLst
+S16 rgSCHUtlDelFrmResLst
(
RgSchUeCb *ue,
RgSchIotRes *iotRes