@brief This file has APIs to handle the random access procedure functionality for the scheduler.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_MODULE_ID=4096;
-static int RLOG_FILE_ID=171;
/* header include files (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-
-#include "gen.h" /* general */
-#include "ssi.h" /* system services */
-
-#include "cm_tkns.h" /* Common Token Defines */
-#include "cm_llist.h" /* Common Link List Defines */
-#include "cm_hash.h" /* Common Hash List Defines */
-#include "cm_mblk.h" /* common memory link list library */
-#include "cm_lte.h" /* Common LTE */
+#include "common_def.h"
#include "rg_env.h" /* MAC Environment Defines */
#include "rgr.h" /* RGR Interface defines */
#include "rg_sch_err.h" /* Scheduler error defines */
#include "rg_sch.h" /* Scheduler defines */
#include "rg_sch_cmn.h"
-#include "rl_interface.h"
-#include "rl_common.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general */
-#include "ssi.x" /* system services */
-#include "cm5.x" /* Timer */
-#include "cm_tkns.x" /* Common Token Definitions */
-#include "cm_llist.x" /* Common Link List Definitions */
-#include "cm_lib.x" /* Common Library Definitions */
-#include "cm_hash.x" /* Common Hash List Definitions */
-#include "cm_mblk.x" /* common memory link list library */
-#include "cm_lte.x" /* Common LTE */
#include "rgr.x" /* RGR Interface includes */
#include "rgm.x" /* RGR Interface includes */
#include "rg_sch.x" /* Scheduler includes */
#include "rg_sch_cmn.x"
#ifdef EMTC_ENABLE
-EXTERN Bool rgSCHRamVldtRgrEmtcUeCfg ARGS((
+Bool rgSCHRamVldtRgrEmtcUeCfg ARGS((
RgSchCellCb *cell,
RgrUeCfg *ueCfg
));
-EXTERN S16 rgSCHRamRmvAllFrmEmtcRaInfoSchdLst
+S16 rgSCHRamRmvAllFrmEmtcRaInfoSchdLst
(
RgSchCellCb *cell
);
-EXTERN Void rgSCHEmtcUtlUpdCmnNb
+Void rgSCHEmtcUtlUpdCmnNb
(
RgSchRaCb *raCb
);
-EXTERN Void rgSCHEmtcHqPAlloc
+Void rgSCHEmtcHqPAlloc
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqEnt
#endif
/* local defines */
/* local typedefs */
-PRIVATE Void rgSCHRamUlFreeAllocation ARGS((RgSchUlSf *sf,RgSchUlAlloc *alloc,
+static Void rgSCHRamUlFreeAllocation ARGS((RgSchUlSf *sf,RgSchUlAlloc *alloc,
RgSchCellCb *cell,Bool isEmtc));
-PRIVATE S16 rgSCHRamContResCrnti ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
+static S16 rgSCHRamContResCrnti ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
RgSchRaCb *raCb, RgSchErrInfo *err));
-PRIVATE S16 rgSCHRamContResCcchsdu ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
+static S16 rgSCHRamContResCcchsdu ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
#ifdef EMTC_ENABLE
-EXTERN S16 rgSCHEmtcRamContResCcchsdu ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
-EXTERN S16 rgSCHRamEmtcContResCcchsdu ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
-EXTERN Void rgSCHChkEmtcContResGrdTmrExp ARGS((RgSchCellCb *cell));
-EXTERN Void rgSCHChkEmtcContResTmrExp ARGS((RgSchCellCb *cell));
-EXTERN Void rgSCHEmtcRaInfoFree ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
+S16 rgSCHEmtcRamContResCcchsdu ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
+S16 rgSCHRamEmtcContResCcchsdu ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
+Void rgSCHChkEmtcContResGrdTmrExp ARGS((RgSchCellCb *cell));
+Void rgSCHChkEmtcContResTmrExp ARGS((RgSchCellCb *cell));
+Void rgSCHEmtcRaInfoFree ARGS((RgSchCellCb *cell, RgSchRaCb *raCb));
#endif
#ifdef RGR_V1
-PRIVATE Void rgSCHChkContResGrdTmrExp ARGS((RgSchCellCb *cell));
-PRIVATE Void rgSCHChkContResTmrExp ARGS((RgSchCellCb *cell));
-PRIVATE Void rgSCHRamProcContResExp ARGS((RgSchCellCb *cell,
+static Void rgSCHChkContResGrdTmrExp ARGS((RgSchCellCb *cell));
+static Void rgSCHChkContResTmrExp ARGS((RgSchCellCb *cell));
+static Void rgSCHRamProcContResExp ARGS((RgSchCellCb *cell,
RgSchRaCb *raCb));
-PRIVATE Void rgSCHRamProcContResGrdExp ARGS((RgSchCellCb *cell,
+static Void rgSCHRamProcContResGrdExp ARGS((RgSchCellCb *cell,
RgSchRaCb *raCb));
#ifdef EMTC_ENABLE
-EXTERN Void rgSCHChkEmtcContResGrdTmrExp ARGS((RgSchCellCb *cell));
-EXTERN Void rgSCHChkEmtcContResTmrExp ARGS((RgSchCellCb *cell));
+Void rgSCHChkEmtcContResGrdTmrExp ARGS((RgSchCellCb *cell));
+Void rgSCHChkEmtcContResTmrExp ARGS((RgSchCellCb *cell));
#endif
#endif
/* forward references */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamVldtUeCfg
-(
-RgSchCellCb *cell,
-RgrUeCfg *ueCfg
-)
-#else
-PUBLIC S16 rgSCHRamVldtUeCfg(cell, ueCfg)
-RgSchCellCb *cell;
-RgrUeCfg *ueCfg;
-#endif
+S16 rgSCHRamVldtUeCfg(RgSchCellCb *cell,RgrUeCfg *ueCfg)
{
- TRC2(rgSCHRamVldtUeCfg);
if (ueCfg->dedPreambleId.pres == PRSNT_NODEF)
{
if ((ueCfg->dedPreambleId.val < cell->rachCfg.numRaPreamble) ||
#endif
)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamProcRaReq
+S16 rgSCHRamProcRaReq
(
-U8 raReqCnt,
+uint8_t raReqCnt,
RgSchCellCb *cell,
CmLteRnti raRnti,
TfuRachInfo *raReqInd,
RgSchUeCb *ue,
RgSchErrInfo *err
)
-#else
-PUBLIC S16 rgSCHRamProcRaReq(raReqCnt, cell, raRnti, raReqInd, timingInfo, ue, err)
-U8 raReqCnt;
-RgSchCellCb *cell;
-CmLteRnti raRnti;
-TfuRachInfo *raReqInd;
-CmLteTimingInfo timingInfo;
-RgSchUeCb *ue;
-RgSchErrInfo *err;
-#endif
{
RgSchRaReqInfo *raReqInfo;
- U16 raIndex;
+ uint16_t raIndex;
#ifdef LTE_TDD
- U8 fid;
- U8 tid;
+ uint8_t fid;
+ uint8_t tid;
#endif
- TRC2(rgSCHRamProcRaReq)
/* SR_RACH_STATS : RACH REQ */
/* allocate new raReqInfos and enqueue them */
if (raReqInd->raReqInfoArr[raReqCnt].rapId >= RGSCH_MAX_NUM_RA_PREAMBLE)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed errType(%d) ",
- raReqInd->raRnti);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : RARNTI:%d rgSCHTomRaReqInd(): RAM processing failed", raReqInd->raRnti);
+ return RFAILED;
}
/* SR_RACH_STATS : DED PREAMB*/
if((rgSCHUtlAllocSBuf(cell->instIdx, (Data **)(&raReqInfo),
sizeof(RgSchRaReqInfo))) == RFAILED)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHRamProcRaReq(): Allocation"
+ DU_LOG("\nERROR --> SCH : rgSCHRamProcRaReq(): Allocation"
" of RaReq failed RARNTI:%d",raRnti);
err->errCause = RGSCHERR_RAM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Insert the given raReqInfo */
cmLListAdd2Tail(&cell->raInfo.raReqLst[raIndex], &raReqInfo->raReqLstEnt);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamProcRaReq */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamCreateRaCb
+S16 rgSCHRamCreateRaCb
(
RgSchCellCb *cell,
RgSchRaCb **raCb,
RgSchErrInfo *err
)
-#else
-PUBLIC S16 rgSCHRamCreateRaCb(cell, raCb, err)
-RgSchCellCb *cell;
-RgSchRaCb **raCb;
-RgSchErrInfo *err;
-#endif
{
RgSchRntiLnk *rntiLnk;
Inst inst = cell->instIdx;
- TRC2(rgSCHRamCreateRaCb)
if((rgSCHUtlAllocSBuf(inst, (Data **)(raCb),
sizeof(RgSchRaCb))) == RFAILED)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHRamCreateRaCb(): Allocation of "
+ DU_LOG("\nERROR --> SCH : rgSCHRamCreateRaCb(): Allocation of "
"RaCb failed");
err->errCause = RGSCHERR_RAM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
rntiLnk = rgSCHDbmGetRnti(cell);
rgNumRarFailDuetoRntiExhaustion++;
/* No rnti available! */
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHRamCreateRaCb(): Allocation of "
+ DU_LOG("\nERROR --> SCH : rgSCHRamCreateRaCb(): Allocation of "
"temporary RNTI failed at MAC(CRNTI exhausted)");
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst, (Data **)(raCb), sizeof(RgSchRaCb));
err->errCause = RGSCHERR_RAM_RNTI_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Allocate and initialize the DL HARQ portion of the RACB */
if ((*raCb)->dlHqE == NULLP)
{
/* No memory available! */
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHRamCreateRaCb(): Creation of"
+ DU_LOG("\nERROR --> SCH : rgSCHRamCreateRaCb(): Creation of"
" DL HARQ failed");
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(inst, (Data **)(raCb), sizeof(RgSchRaCb));
err->errCause = RGSCHERR_RAM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef EMTC_ENABLE
(*raCb)->isEmtcRaCb = FALSE;
(*raCb)->raCbLnk.node = (PTR)(*raCb);
cmLListAdd2Tail(&cell->raInfo.raCbLst, &(*raCb)->raCbLnk);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamCreateRaCb */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamRgrUeCfg
+S16 rgSCHRamRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb,
RgSchErrInfo *err
)
-#else
-PUBLIC S16 rgSCHRamRgrUeCfg(cell, ue, raCb, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchRaCb *raCb;
-RgSchErrInfo *err;
-#endif
{
/* Releasing HARQ processes of old UE when ue
* reconfig with new crnti */
- /* U32 cnt; */
+ /* uint32_t cnt; */
RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
- TRC2(rgSCHRamRgrUeCfg)
/* Fix : set UE inactive in DL until UE is reinitialization completed */
err->errCause = RGSCHERR_RAM_NO_MSG3_RCVD;
*hqEnt = NULLP;
raCb->dlHqE->ue = NULLP;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamRgrUeCfg */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHRamContResCrnti
+static S16 rgSCHRamContResCrnti
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchRaCb *raCb,
RgSchErrInfo *err
)
-#else
-PRIVATE S16 rgSCHRamContResCrnti(cell, ue, raCb, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchRaCb *raCb;
-RgSchErrInfo *err;
-#endif
{
TfuUlCqiRpt ulCqiRpt;
RgSchCmnCell *cellSch= (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHRamContResCrnti)
/* Fix: syed It is incorrect to copy over msg3HqProc to ueCb's
/* No need of raCb any more */
rgSCHRamDelRaCb(cell, raCb, TRUE);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamContResCrnti */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PRIVATE S16 rgSCHRamContResCcchsdu
+static S16 rgSCHRamContResCcchsdu
(
RgSchCellCb *cell,
RgSchRaCb *raCb
)
-#else
-PRIVATE S16 rgSCHRamContResCcchsdu(cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
{
#ifdef RGR_V1
CmLteTimingInfo expTime = {0};
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
- TRC2(rgSCHRamContResCcchsdu)
if(raCb->raState != RGSCH_RA_MSG3_PENDING)
{
- RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
- "RNTI:%d RaCb in wrong State %d Drop Msg 3",
+ DU_LOG("\nERROR --> SCH : RNTI:%d RaCb in wrong State %d Drop Msg 3",
raCb->rntiLnk->rnti,
raCb->raState);
- RETVALUE(ROK);
+ return ROK;
}
raCb->raState = RGSCH_RA_MSG4_PENDING;
raCb->contResTmrLnk.node = (PTR)(raCb);
cmLListAdd2Tail(&(cell->contResGrdTmrLst), &(raCb->contResTmrLnk));
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamContResCcchsdu */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamProcMsg3
+S16 rgSCHRamProcMsg3
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgInfUeDatInd *pdu,
RgSchErrInfo *err
)
-#else
-PUBLIC S16 rgSCHRamProcMsg3(cell, ue, raCb, pdu, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchRaCb *raCb;
-RgInfUeDatInd *pdu;
-RgSchErrInfo *err;
-#endif
{
- TRC2(rgSCHRamProcMsg3)
/* Update raCb with PHR if received along with Msg3 */
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamProcMsg3 */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamUpdtBo
+S16 rgSCHRamUpdtBo
(
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgInfCmnBoRpt *staRsp
)
-#else
-PUBLIC S16 rgSCHRamUpdtBo(cell, raCb, staRsp)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-RgInfCmnBoRpt *staRsp;
-#endif
{
- TRC2(rgSCHRamUpdtBo)
/* Update Bo in RaCb */
- raCb->dlCcchInfo.bo = (U32)(staRsp->bo);
+ raCb->dlCcchInfo.bo = (uint32_t)(staRsp->bo);
/* SR_RACH_STATS : MSG4 WITH CCCH SDU */
rgNumMsg4WithCCCHSdu++;
rgSCHRamAddToRaInfoSchdLst(cell, raCb);
/* MSG4 Fix End */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamUpdtBo */
/**
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg3DatInd
-(
-RgSchRaCb *raCb
-)
-#else
-PUBLIC S16 rgSCHRamMsg3DatInd(raCb)
-RgSchRaCb *raCb;
-#endif
+S16 rgSCHRamMsg3DatInd(RgSchRaCb *raCb)
{
- TRC2(rgSCHRamMsg3DatInd)
/* SR_RACH_STATS : MSG3 ACK*/
rgNumMsg3CrcPassed++;
/*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
rgSCHUhmProcMsg3DatInd(&(raCb->msg3HqProc));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg3DatInd */
/**
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg3FailureInd
-(
-RgSchRaCb *raCb
-)
-#else
-PUBLIC S16 rgSCHRamMsg3FailureInd(raCb)
-RgSchRaCb *raCb;
-#endif
+S16 rgSCHRamMsg3FailureInd(RgSchRaCb *raCb)
{
- TRC2(rgSCHRamMsg3FailureInd)
/*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
rgSCHUhmProcMsg3Failure(&(raCb->msg3HqProc));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg3FailureInd */
/**
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg4FdbkInd
-(
-RgSchRaCb *raCb
-)
-#else
-PUBLIC S16 rgSCHRamMsg4FdbkInd(raCb)
-RgSchRaCb *raCb;
-#endif
+S16 rgSCHRamMsg4FdbkInd(RgSchRaCb *raCb)
{
- TRC2(rgSCHRamMsg4FdbkInd)
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg4FdbkInd */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamMsg4Done
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb
-)
-#else
-PUBLIC S16 rgSCHRamMsg4Done(cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
+S16 rgSCHRamMsg4Done(RgSchCellCb *cell,RgSchRaCb *raCb)
{
- TRC2(rgSCHRamMsg4Done)
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "rgSCHRamMsg4Done(): tmpCRNTI = %u",
+ DU_LOG("\nDEBUG --> SCH : rgSCHRamMsg4Done(): tmpCRNTI = %u",
raCb->tmpCrnti);
if(raCb->ue != NULLP)
else if(raCb->toDel == TRUE)
{
#ifdef XEON_SPECIFIC_CHANGES
- CM_LOG_DEBUG(CM_LOG_ID_SCH, "Deleting RacB:%d\n", raCb->tmpCrnti);
+ DU_LOG("\nDEBUG --> SCH : Deleting RacB:%d\n", raCb->tmpCrnti);
#endif
/* Delete RACB and release RNTI */
rgSCHRamDelRaCb(cell, raCb, TRUE);
else
{
#ifdef XEON_SPECIFIC_CHANGES
- CM_LOG_DEBUG(CM_LOG_ID_SCH, "Releasing Harq of RacB:%d\n", raCb->tmpCrnti);
+ DU_LOG("\nDEBUG --> SCH : Releasing Harq of RacB:%d\n", raCb->tmpCrnti);
#endif
raCb->raState = RGSCH_RA_MSG4_DONE;
/* Release harq process as final feedback is received for Msg4. In other
* cases, delRaCb will take care of releasing the harq process */
- printf("=======Harq process released \n");
- RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
- "Harq process released ");
+ DU_LOG("\nDEBUG --> SCH : Harq process released ");
rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, TRUE);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamMsg4Done */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamDelRaCb
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb,
-Bool rlsRnti
-)
-#else
-PUBLIC S16 rgSCHRamDelRaCb(cell, raCb, rlsRnti)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-Bool rlsRnti;
-#endif
+S16 rgSCHRamDelRaCb(RgSchCellCb *cell,RgSchRaCb *raCb,Bool rlsRnti)
{
- Inst inst = cell->instIdx;
- Bool isEmtc = FALSE;
- TRC2(rgSCHRamDelRaCb)
+ Inst inst = cell->instIdx;
+ Bool isEmtc = FALSE;
/* Delete from all the lists it is enqueued */
cmLListDelFrm(&(cell->raInfo.raCbLst),&(raCb->raCbLnk));
if ((raCb->dlHqE->msg4Proc->subFrm != NULLP) &&
(raCb->dlHqE->msg4Proc->hqPSfLnk.node != NULLP))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"TMP CRNTI:%d RACH FAILURE!! "
+ DU_LOG("\nERROR --> SCH : TMP CRNTI:%d RACH FAILURE!! "
"msg4proc removed from SF", raCb->tmpCrnti);
rgSCHUtlDlHqPTbRmvFrmTx(raCb->dlHqE->msg4Proc->subFrm,
raCb->dlHqE->msg4Proc, 0, FALSE);
#endif
rgSCHUtlFreeSBuf(inst, (Data **)&raCb, sizeof(RgSchRaCb));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamDelRaCb */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamTtiHndlr
-(
-RgSchCellCb *cell
-)
-#else
-PUBLIC S16 rgSCHRamTtiHndlr(cell)
-RgSchCellCb *cell;
-#endif
+S16 rgSCHRamTtiHndlr(RgSchCellCb *cell)
{
RgSchRaCb *raCb;
- U16 raSfn;
- U16 crntSfn;
- U16 dist; /* Number of frames between raCb's creation and crnt
- frame */
- U8 idx;
- U32 maxCnt;
+ uint16_t raSfn;
+ uint16_t crntSfn;
+ uint16_t dist; /* Number of frames between raCb's creation and crnt frame */
+ uint8_t idx;
+ uint32_t maxCnt;
#ifndef LTE_TDD
- U8 winGap;
- U8 raIdx;
+ uint8_t winGap;
+ uint8_t raIdx;
RgSchRaReqInfo *raReqInfo;
#else
CmLteTimingInfo frm;
- U8 raIdx;
+ uint8_t raIdx;
#endif
- TRC2(rgSCHRamTtiHndlr)
crntSfn = cell->crntTime.sfn;
winGap = (rgRaPrmblToRaFrmTbl[cell->rachCfg.preambleFormat]-1)+
(cell->rachCfg.raWinSize -1 ) + RGSCH_RARSP_WAIT_PERIOD;
- raIdx = (((crntSfn & 1) * RGSCH_MAX_RA_RNTI+ cell->crntTime.subframe
+ raIdx = (((crntSfn & 1) * RGSCH_MAX_RA_RNTI+ cell->crntTime.slot
+ RG_SCH_CMN_DL_DELTA - winGap)+ RGSCH_RAREQ_ARRAY_SIZE )
% RGSCH_RAREQ_ARRAY_SIZE;
/* Fixes for RACH handling: Added deletion of queued RaReq */
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
- if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][frm.subframe] !=
+ if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx][frm.slot] !=
RG_SCH_TDD_UL_SUBFRAME)
{
- raIdx = rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][frm.subframe]-1;
+ raIdx = rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][frm.slot]-1;
rgSCHRamDelRaReq(cell, cell->crntTime, raIdx);
}
#endif
/* ccpu00132536:MOD- racb timeout will be verified in each SFN such that
* the RACB whose processing is not completed in RG_MAX_RA_PRC_FRM
* will be deleted*/
- if (cell->crntTime.subframe == 0)
+ if (cell->crntTime.slot == 0)
{
maxCnt = cell->raInfo.raCbLst.count;
for (idx = 0; idx < maxCnt; idx++)
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamTtiHndlr */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamFreeCell
-(
-RgSchCellCb *cell
-)
-#else
-PUBLIC S16 rgSCHRamFreeCell(cell)
-RgSchCellCb *cell;
-#endif
+S16 rgSCHRamFreeCell(RgSchCellCb *cell)
{
RgSchRaReqInfo *raReqInfo;
RgSchRaCb *raCb;
- U8 idx;
- U8 raCbCnt;
+ uint8_t idx;
+ uint8_t raCbCnt;
Inst inst = cell->instIdx;
- U8 lstSz;
+ uint8_t lstSz;
#ifdef LTE_TDD
- U8 maxUlSubframes;
- U8 maxDlSubframes;
+ uint8_t maxUlSubframes;
+ uint8_t maxDlSubframes;
#endif
- TRC2(rgSCHRamFreeCell)
#ifdef LTE_TDD
rgSCHRamDelRaCb(cell, raCb, TRUE);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamFreeCell */
#ifdef RGR_V1
-#ifdef ANSI
-PRIVATE Void rgSCHRamProcContResExp
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb
-)
-#else
-PRIVATE Void rgSCHRamProcContResExp (cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
+static Void rgSCHRamProcContResExp(RgSchCellCb *cell,RgSchRaCb *raCb)
{
- TRC2(rgSCHRamProcContResExp);
raCb->expiryTime.sfn = RGSCH_CONTRES_EXP;
/*MSG4 Fix*/
if (raCb->ue)
/* Delete RACB and release RNTI */
rgSCHRamDelRaCb(cell, raCb, TRUE);
}
- RETVOID;
+ return;
}
-#ifdef ANSI
-PRIVATE Void rgSCHRamProcContResGrdExp
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb
-)
-#else
-PRIVATE Void rgSCHRamProcContResGrdExp (cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
+static Void rgSCHRamProcContResGrdExp(RgSchCellCb *cell,RgSchRaCb *raCb)
{
- TRC2(rgSCHRamProcContResGrdExp)
/*Guard timer has expired, schedule only the contention REsolution CE with
raCb->contResTmrLnk.node = NULLP;
/* MSG4 Fix Start */
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "Con Res Grd Tmr exp RNTI:%d",
+ DU_LOG("\nDEBUG --> SCH : Con Res Grd Tmr exp RNTI:%d",
raCb->rntiLnk->rnti);
rgSCHRamAddToRaInfoSchdLst(cell, raCb);
/* MSG4 Fix End */
- RETVOID;
+ return;
}
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE Void rgSCHChkContResTmrExp
-(
-RgSchCellCb *cell
-)
-#else
-PRIVATE Void rgSCHChkContResTmrExp(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHChkContResTmrExp(RgSchCellCb *cell)
{
- CmLList *chkLnk = NULLP;
- RgSchRaCb *raCb = NULLP;
+ CmLList *chkLnk = NULLP;
+ RgSchRaCb *raCb = NULLP;
- TRC2(rgSCHChkContResTmrExp)
chkLnk = cmLListFirst(&(cell->contResTmrLst));
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE Void rgSCHChkContResGrdTmrExp
-(
-RgSchCellCb *cell
-)
-#else
-PRIVATE Void rgSCHChkContResGrdTmrExp(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHChkContResGrdTmrExp(RgSchCellCb *cell)
{
- CmLList *chkLnk = NULLP;
- RgSchRaCb *raCb = NULLP;
+ CmLList *chkLnk = NULLP;
+ RgSchRaCb *raCb = NULLP;
- TRC2(rgSCHChkContResGrdTmrExp)
chkLnk = cmLListFirst(&(cell->contResGrdTmrLst));
*
* @param[in,out] RgSchCellCb *cell
* @param[in] CmLteTimingInfo timingInfo
- * @param[in] U8 raIdx
+ * @param[in] uint8_t raIdx
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 rgSCHRamDelRaReq
+S16 rgSCHRamDelRaReq
(
-RgSchCellCb *cell,
-CmLteTimingInfo timingInfo,
-U8 raIdx
+RgSchCellCb *cell,
+CmLteTimingInfo timingInfo,
+uint8_t raIdx
)
-#else
-PUBLIC S16 rgSCHRamDelRaReq(cell, timingInfo, raIdx)
-RgSchCellCb *cell;
-CmLteTimingInfo timingInfo;
-U8 raIdx;
-#endif
{
- U8 subfrmIdx;
+ uint8_t subfrmIdx;
RgSchTddRachRspLst *rachRsp;
- U16 sfnIdx;
+ uint16_t sfnIdx;
S16 calcSfn;
- U8 subfrm;
+ uint8_t subfrm;
RgSchRaReqInfo *raReqInfo;
- U8 idx;
- U8 i;
- U8 raRntiIdx;
+ uint8_t idx;
+ uint8_t i;
+ uint8_t raRntiIdx;
CmLteRnti raRnti;
- TRC2(rgSCHRamDelRaReq)
rachRsp = &cell->rachRspLst[raIdx];
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
/*MSG4 Fix Start */
-#ifdef ANSI
-PUBLIC S16 rgSCHRamAddToRaInfoSchdLst
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb
-)
-#else
-PUBLIC S16 rgSCHRamAddToRaInfoSchdLst(cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
+S16 rgSCHRamAddToRaInfoSchdLst(RgSchCellCb *cell,RgSchRaCb *raCb)
{
CmLteTimingInfo expTime ={0};
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHRamAddToRaInfoSchdLst)
/*Fix: This can be called even when guard timer is not expired.
* In this case CR timer expiry should be guard timer expiry time + Guard timer time*/
cmLListAdd2Tail(&(cell->raInfo.toBeSchdLst), &(raCb->schdLnk));
raCb->contResTmrLnk.node = (PTR)(raCb);
cmLListAdd2Tail(&(cell->contResTmrLst), &(raCb->contResTmrLnk));
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamAddToRaInfoSchdLst */
-#ifdef ANSI
-PUBLIC S16 rgSCHRamRmvFrmRaInfoSchdLst
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb
-)
-#else
-PUBLIC S16 rgSCHRamRmvFrmRaInfoSchdLst(cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
+S16 rgSCHRamRmvFrmRaInfoSchdLst(RgSchCellCb *cell,RgSchRaCb *raCb)
{
- TRC2(rgSCHRamRmvFrmRaInfoSchdLst)
cmLListDelFrm(&(cell->raInfo.toBeSchdLst), &(raCb->schdLnk));
raCb->schdLnk.node = NULLP;
cmLListDelFrm(&(cell->contResTmrLst), &(raCb->contResTmrLnk));
raCb->contResTmrLnk.node = NULLP;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHRamRmvFrmRaInfoSchdLst */
/*MSG4 Fix End*/
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE Void rgSCHRamUlFreeAllocation
+static Void rgSCHRamUlFreeAllocation
(
RgSchUlSf *sf,
RgSchUlAlloc *alloc,
RgSchCellCb *cell,
Bool isEmtc
-
)
-#else
-PRIVATE Void rgSCHRamUlFreeAllocation(sf, alloc, cell,isEmtc)
-RgSchUlSf *sf;
-RgSchUlAlloc *alloc;
-RgSchCellCb *cell;
-Bool isEmtc;
-#endif
{
- TRC2(rgSCHRamUlFreeAllocation);
rgSCHUhmFreeProc(alloc->hqProc, cell);
if(!isEmtc)
{
rgSCHUtlUlAllocRls(sf, alloc);
}
- RETVOID;
+ return;
}
/**********************************************************************
Code Review / o-du / l2.git / blobdiff