@brief APIs to handle all the primitives invoked on RGU interface.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=184;
-static int RLOG_MODULE_ID=4096;
/* 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 "crg.h" /* CRG Interface defines */
#include "rgu.h" /* RGU Interface defines */
#include "rg_err.h" /* MAC error defines */
/* 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 "crg.x" /* CRG Interface includes */
#include "rgu.x" /* RGU Interface includes */
/* local typedefs */
S16 RgMacSchBrdcmDedBoUpdtReq ARGS((Inst inst, CmLteCellId cellId, CmLteRnti rnti, CmLteLcId lcId, S32 bo ));
-PRIVATE S16 rgROMHndlCcchDatReq ARGS((RgCellCb *cell,
+static S16 rgROMHndlCcchDatReq ARGS((RgCellCb *cell,
RgRguCmnDatReq *datReq, RgErrInfo *err));
-PRIVATE S16 rgROMHndlBcchPcchDatReq ARGS((RgCellCb *cell,
+static S16 rgROMHndlBcchPcchDatReq ARGS((RgCellCb *cell,
RgRguCmnDatReq *datReq, RgErrInfo *err));
-PRIVATE S16 rgROMHndlCcchStaRsp ARGS((RgCellCb *cell,
+static S16 rgROMHndlCcchStaRsp ARGS((RgCellCb *cell,
RgRguCmnStaRsp *staRsp, RgErrInfo *err));
-PRIVATE S16 rgROMHndlBcchPcchStaRsp ARGS((RgCellCb *cell,
+static S16 rgROMHndlBcchPcchStaRsp ARGS((RgCellCb *cell,
RgRguCmnStaRsp *staRsp, RgErrInfo *err));
/* ADD Changes for Downlink UE Timing Optimization */
#ifdef LTEMAC_DLUE_TMGOPTMZ
-PRIVATE S16 rgROMUpdDlSfRemDataCnt ARGS((RgCellCb *cellCb,
+static S16 rgROMUpdDlSfRemDataCnt ARGS((RgCellCb *cellCb,
RgDlSf *dlSf));
-PUBLIC S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf,
+S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf,
RgCellCb *cellCb,
RgErrInfo *err));
#endif
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgROMDedDatReq
-(
-Inst inst,
-RgRguDedDatReq *datReq
-)
-#else
-PUBLIC S16 rgROMDedDatReq(inst,datReq)
-Inst inst;
-RgRguDedDatReq *datReq;
-#endif
+S16 rgROMDedDatReq(Inst inst,RgRguDedDatReq *datReq)
{
#if 0
RgCellCb *cell;
RgUeCb *ue;
- U8 idx1,idx2;
+ uint8_t idx1,idx2;
RgDlHqProcCb *hqProc;
- U8 hqPId;
+ uint8_t hqPId;
RgErrInfo err;
Pst schPst;
RgInfDedBoRpt boRpt;
#ifdef LTEMAC_DLUE_TMGOPTMZ
S16 ret;
#endif
- U32 idx;
- //U8 datReqFailCnt = 0;
-
- TRC2(rgROMDedDatReq)
+ uint32_t idx;
+ //uint8_t datReqFailCnt = 0;
if (((cell = rgCb[inst].cell) == NULLP)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Handle Cell fetch failure */
- RGLOGERROR(inst,ERRCLS_INT_PAR,ERG001,(ErrVal)datReq->cellId,
- "rgROMDedDatReq(): Invalid cell Id");
+ DU_LOG("\nERROR --> MAC : rgROMDedDatReq(): Invalid cell Id");
#endif
err.errType = RGERR_ROM_DEDDATREQ;
err.errCause = RGERR_ROM_INV_CELL_ID;
/* Update stats */
rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Add loop here to scan for all UEs in the consolidated DDatReq*/
for(idx = 0; idx < datReq->nmbOfUeGrantPerTti; idx++)
{
- timingInfo.slot = (U8)((datReq->datReq[idx].transId >> 8) & 0XFF);
- timingInfo.sfn = (U16)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
+ timingInfo.slot = (uint8_t)((datReq->datReq[idx].transId >> 8) & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
if( (sf->txDone == TRUE) ||
rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
#ifdef CA_DBG
{
- EXTERN U32 dbgDelayedDatReqInMac;
+ uint32_t dbgDelayedDatReqInMac;
dbgDelayedDatReqInMac++;
}
#endif /* CA_DBG */
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
continue;
- // RETVALUE(RFAILED);
+ // return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, datReq->datReq[idx].rnti)) == NULLP)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Handle Ue fetch failure */
- RGLOGERROR(inst,ERRCLS_INT_PAR,ERG002,(ErrVal)datReq->datReq[idx].rnti,
- "rgROMDedDatReq(): Invalid ue Id");
+ DU_LOG("\nERROR --> MAC : rgROMDedDatReq(): Invalid ue Id");
#endif
err.errType = RGERR_ROM_DEDDATREQ;
err.errCause = RGERR_ROM_INV_UE_ID;
ret = rgROMUpdDlSfRemDataCnt(cell, sf);
if(ret == RFAILED)
{
- RLOG0(L_INFO, "Dropping due to no ue \n");
+ DU_LOG("\nERROR --> MAC : Dropping due to no ue \n");
#ifndef L2_OPTMZ
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
/* Return from here as above functions found more datReq than expected*/
- /* RETVALUE(ret); */
+ /* return (ret); */
}
#endif
/* Conitnue for next UE */
continue;
}
- hqPId = (U8)(datReq->datReq[idx].transId);
+ hqPId = (uint8_t)(datReq->datReq[idx].transId);
hqPId = hqPId >> 2;
/* get harq process and invoke DHM */
rgDHMGetHqProcFrmId(ue, hqPId, &hqProc);
if (rgDHMHndlDedDatReq(inst,hqProc, &datReq->datReq[idx], sf, &err) == RFAILED)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,datReq->cellId,
- "Handling of Data request in DHM failedi RNTI:%d",
+ DU_LOG("\nERROR --> MAC : Handling of Data request in DHM failedi RNTI:%d",
datReq->datReq[idx].rnti);
err.errType = RGERR_ROM_DEDDATREQ;
/* errcause shall be filled in appropriately by DHM */
ret = rgROMUpdDlSfRemDataCnt(cell, sf);
if(ret == RFAILED)
{
- RLOG0(L_INFO, "Dropping due to no failure of remCnt update");
+ DU_LOG("\nERROR --> MAC : Dropping due to no failure of remCnt update");
#ifndef L2_OPTMZ
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
/* Return from here as above functions found more datReq than expected*/
- //RETVALUE(ret);
+ //return (ret);
}
#endif
continue;
ret = rgROMUpdDlSfRemDataCnt(cell, sf);
if(ret == RFAILED)
{
- RLOG0(L_INFO, "\n Dropping due to no failure of remCnt update(1) \n");
+ DU_LOG("\nERROR --> MAC : Dropping due to no failure of remCnt update(1) \n");
#ifndef L2_OPTMZ
RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
#endif
/* Return from here as above functions found more datReq than expected*/
- // RETVALUE(ret);
+ // return (ret);
}
#endif
} /* for loop for num of Ue per TTI*/
#endif
/* Data send successfully to PHY. lets retuns ROK*/
- RETVALUE(ROK);
+ return ROK;
} /* rgROMDedDatReq */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgROMCmnDatReq
-(
-Inst inst,
-RgRguCmnDatReq *datReq
-)
-#else
-PUBLIC S16 rgROMCmnDatReq(inst,datReq)
-Inst inst;
-RgRguCmnDatReq *datReq;
-#endif
+S16 rgROMCmnDatReq(Inst inst, RgRguCmnDatReq *datReq)
{
RgCellCb *cell;
RgErrInfo err;
RgDlSf *sf;
#endif
- TRC2(rgROMCmnDatReq)
-
ret = ROK;
err.errType = RGERR_ROM_CMNDATREQ;
if(((cell = rgCb[inst].cell) == NULLP)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Handle Cell fetch failure */
- RGLOGERROR(inst,ERRCLS_INT_PAR,ERG003,(ErrVal)datReq->cellId,
- "rgROMCmnDatReq(): Invalid cell Id");
+ DU_LOG("\nERROR --> MAC : rgROMCmnDatReq(): Invalid cell Id");
#endif
err.errCause = RGERR_ROM_INV_CELL_ID;
/* Update stats */
{
rgUpdtRguCmnSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (datReq->lcId == cell->dlCcchId)
/*Get the timing Info*/
/* ADD Changes for Downlink UE Timing Optimization */
#ifdef LTEMAC_DLUE_TMGOPTMZ
- timingInfo.slot = (U8)((datReq->transId >> 8) & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
+ timingInfo.slot = (uint8_t)((datReq->transId >> 8) & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 16) & 0xFFFF);
#endif
}
else
/*Get the timing Info*/
/* ADD Changes for Downlink UE Timing Optimization */
#ifdef LTEMAC_DLUE_TMGOPTMZ
- timingInfo.slot = (U8)(datReq->transId & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
+ timingInfo.slot = (uint8_t)(datReq->transId & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 8) & 0xFFFF);
#endif
}
/*Added check for RFAILED as above function can return RFAILED*/
#endif
- RETVALUE(ret);
+ return (ret);
} /* rgROMCmnDatReq */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlCcchDatReq
-(
-RgCellCb *cell,
-RgRguCmnDatReq *datReq,
-RgErrInfo *err
-)
-#else
-PRIVATE S16 rgROMHndlCcchDatReq(cell, datReq, err)
-RgCellCb *cell;
-RgRguCmnDatReq *datReq;
-RgErrInfo *err;
-#endif
+static S16 rgROMHndlCcchDatReq(RgCellCb *cell, RgRguCmnDatReq *datReq, RgErrInfo *err)
{
Inst inst = cell->macInst - RG_INST_START;
RgUeCb *ue;
- U8 hqPId;
+ uint8_t hqPId;
RgDlHqProcCb *hqProc;
CmLteTimingInfo timingInfo;
RgDlSf *sf;
RgUstaDgn dgn; /* Alarm diagnostics structure */
#endif
- TRC2(rgROMHndlCcchDatReq);
-
-
err->errType = RGERR_ROM_CMNDATREQ;
if ((ue = rgDBMGetUeCb(cell, datReq->u.rnti)) == NULLP)
{
#if (ERRCLASS & ERRCLS_INT_PAR)
/* Handle Ue fetch failure */
- RGLOGERROR(inst,ERRCLS_INT_PAR,ERG004,(ErrVal)datReq->u.rnti,
- "rgROMHndlCcchDatReq(): Invalid ue Id");
+ DU_LOG("\nERROR --> MAC : rgROMHndlCcchDatReq(): Invalid ue Id");
#endif
err->errCause = RGERR_ROM_INV_UE_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- timingInfo.slot = (U8)((datReq->transId >> 8) & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
+ timingInfo.slot = (uint8_t)((datReq->transId >> 8) & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 16) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
if( (sf->txDone == TRUE) ||
LRG_CAUSE_DELAYED_DATREQ, &dgn);
#endif
err->errCause = RGERR_ROM_DELAYED_DATREQ;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- hqPId = (U8)(datReq->transId);
+ hqPId = (uint8_t)(datReq->transId);
hqPId = hqPId >> 2;
/* get harq process and invoke DHM */
/* invoke DHM to process CCCH data */
if (rgDHMHndlCmnDatReq(inst,hqProc, datReq, err) == RFAILED)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "Handling of Data request in DHM failed RNTI:%d LCID:%d",
+ DU_LOG("\nERROR --> MAC : Handling of Data request in DHM failed RNTI:%d LCID:%d",
datReq->u.rnti,datReq->lcId);
/* Release First TB */
rgDHMRlsHqProcTB(cell, hqProc, 1);
/* err shall be filled in appropriately by DHM */
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgROMHndlCcchDatReq */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlBcchPcchDatReq
-(
-RgCellCb *cell,
-RgRguCmnDatReq *datReq,
-RgErrInfo *err
-)
-#else
-PRIVATE S16 rgROMHndlBcchPcchDatReq(cell, datReq, err)
-RgCellCb *cell;
-RgRguCmnDatReq *datReq;
-RgErrInfo *err;
-#endif
+static S16 rgROMHndlBcchPcchDatReq(RgCellCb *cell, RgRguCmnDatReq *datReq, RgErrInfo *err)
{
Inst inst = cell->macInst - RG_INST_START;
RgPcchLcCb *pcch;
RgUstaDgn dgn; /* Alarm diagnostics structure */
#endif
- TRC2(rgROMHndlBcchPcchDatReq);
-
- timingInfo.slot = (U8)(datReq->transId & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
+ timingInfo.slot = (uint8_t)(datReq->transId & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 8) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
if( (sf->txDone == TRUE) ||
LRG_CAUSE_DELAYED_DATREQ, &dgn);
#endif
err->errCause = RGERR_ROM_DELAYED_DATREQ;
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef RGR_SI_SCH
SCpyMsgMsg(datReq->pdu, RG_GET_MEM_REGION(rgCb[inst]),
RG_GET_MEM_POOL(rgCb[inst]), &bcch->tb);
- RETVALUE(ROK);
+ return ROK;
}
bch = rgDBMGetBcchOnBch(cell);
{
/* Store BCH data received in Scheduled slot */
sf->bch.tb = datReq->pdu;
- RETVALUE(ROK);
+ return ROK;
}
#endif/*RGR_SI_SCH*/
-
+ UNUSED(inst);
pcch = rgDBMGetPcch(cell);
if ((pcch) && (pcch->lcId == datReq->lcId))
{
/* Store PCCH-DLSCH data received in Scheduled slot */
sf->pcch.tb = datReq->pdu;
- RETVALUE(ROK);
+ return ROK;
}
/* Handle lcCb fetch failure */
- RGLOGERROR(inst,ERRCLS_INT_PAR,ERG005,(ErrVal)datReq->lcId,
- "rgROMHndlBcchPcchDatReq(): Invalid Lc Id");
+ DU_LOG("\nERROR --> MAC : rgROMHndlBcchPcchDatReq(): Invalid Lc Id");
err->errCause = RGERR_ROM_INV_LC_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgROMHndlBcchPcchDatReq */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgROMDedStaRsp
-(
-Inst inst,
-RgRguDedStaRsp *staRsp
-)
-#else
-PUBLIC S16 rgROMDedStaRsp(inst,staRsp)
-Inst inst;
-RgRguDedStaRsp *staRsp;
-#endif
+S16 rgROMDedStaRsp(Inst inst, RgRguDedStaRsp *staRsp)
{
RgCellCb *cell;
/* Moving the error variables and assignments to available scope */
- TRC2(rgROMDedStaRsp)
-
/* Avoiding memset, as the variables of this are getting
initialized */
rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
schPst.event = 0;
//TODO: commented for compilation without SCH RgMacSchDedBoUpdt(&schPst, &boRpt);
- RETVALUE(ROK);
+ return ROK;
}
- RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,"Invalid cell for CRNTI:%d LCID:%d ",
+ DU_LOG("\nERROR --> MAC : Invalid cell for CRNTI:%d LCID:%d ",
staRsp->rnti,staRsp->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgROMDedStaRsp */
S16 RgMacSchBrdcmDedBoUpdtReq(
schPst.event = 0;
//TODO: commented for compilation without SCH RgMacSchDedBoUpdtReq (&schPst,&boRpt);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for StaRsp received on RGU for a common logical channel.
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgROMCmnStaRsp
-(
-Inst inst,
-RgRguCmnStaRsp *staRsp
-)
-#else
-PUBLIC S16 rgROMCmnStaRsp(inst,staRsp)
-Inst inst;
-RgRguCmnStaRsp *staRsp;
-#endif
+S16 rgROMCmnStaRsp(Inst inst, RgRguCmnStaRsp *staRsp)
{
RgCellCb *cell;
RgErrInfo err;
- TRC2(rgROMCmnStaRsp)
-
-
if(((cell = rgCb[inst].cell) == NULLP)
|| (cell->cellId != staRsp->cellId))
{
/* Handle Cell fetch failure */
- RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,
- "Invalid cell for CRNTI:%d LCID:%d",staRsp->u.rnti,staRsp->lcId);
+ DU_LOG("\nERROR --> MAC : Invalid cell for CRNTI:%d LCID:%d",staRsp->u.rnti,staRsp->lcId);
err.errType = RGERR_ROM_CMNSTARSP;
err.errCause = RGERR_ROM_INV_CELL_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* handle status response on CCCH */
rgROMHndlBcchPcchStaRsp(cell, staRsp, &err);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgROMCmnStaRsp */
#ifdef LTE_L2_MEAS
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgROML2MUlThrpMeasReq
-(
-Inst inst,
-RgRguL2MUlThrpMeasReq *measReq
-)
-#else
-PUBLIC S16 rgROML2MUlThrpMeasReq(inst,measReq)
-Inst inst;
-RgRguL2MUlThrpMeasReq *measReq;
-#endif
+S16 rgROML2MUlThrpMeasReq(Inst inst, RgRguL2MUlThrpMeasReq *measReq)
{
RgCellCb *cell;
RgUeCb *ue;
- U8 lcgId;
- U8 loop;
- TRC2(rgROML2MUlThrpMeasReq)
-
-
+ uint8_t lcgId;
+ uint8_t loop;
if(((cell = rgCb[inst].cell) != NULLP)
&&(cell->cellId == measReq->cellId))
}
}
}
- RETVALUE(ROK);
+ return ROK;
}
}
- RLOG_ARG1(L_ERROR,DBG_CELLID,measReq->cellId,"Invalid cell CRNTI:%d",
+ DU_LOG("\nERROR --> MAC : Invalid cell CRNTI:%d",
measReq->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
} /* rgROML2MUlThrpMeasReq */
#endif
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlCcchStaRsp
-(
-RgCellCb *cell,
-RgRguCmnStaRsp *staRsp,
-RgErrInfo *err
-)
-#else
-PRIVATE S16 rgROMHndlCcchStaRsp(cell, staRsp, err)
-RgCellCb *cell;
-RgRguCmnStaRsp *staRsp;
-RgErrInfo *err;
-#endif
+static S16 rgROMHndlCcchStaRsp(RgCellCb *cell,RgRguCmnStaRsp *staRsp, RgErrInfo *err)
{
Pst schPst;
Inst macInst = cell->macInst - RG_INST_START;
//RgInfCmnBoRpt boRpt;
- TRC2(rgROMHndlCcchStaRsp);
#ifdef UNUSED_VAR
RgInfCmnBoRpt boRpt;
boRpt.cellSapId = cell->schInstMap.cellSapId;
rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
//TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
- RETVALUE(ROK);
+ return ROK;
} /* rgROMHndlCcchStaRsp */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlBcchPcchStaRsp
-(
-RgCellCb *cell,
-RgRguCmnStaRsp *staRsp,
-RgErrInfo *err
-)
-#else
-PRIVATE S16 rgROMHndlBcchPcchStaRsp(cell, staRsp, err)
-RgCellCb *cell;
-RgRguCmnStaRsp *staRsp;
-RgErrInfo *err;
-#endif
+static S16 rgROMHndlBcchPcchStaRsp(RgCellCb *cell,RgRguCmnStaRsp *staRsp,RgErrInfo *err)
{
Pst schPst;
//RgInfCmnBoRpt boRpt;
Inst macInst = cell->macInst - RG_INST_START;
- TRC2(rgROMHndlBcchPcchStaRsp);
- cmMemset((U8*)&schPst, (U8)0, sizeof(Pst));
+ memset(&schPst, 0, sizeof(Pst));
if (rgDBMChkCmnLcCb(cell, staRsp->lcId) != ROK)
{
/* Handle lcCb fetch failure */
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LCID:%d",staRsp->lcId);
+ DU_LOG("\nERROR --> MAC : Invalid LCID:%d",staRsp->lcId);
err->errCause = RGERR_ROM_INV_LC_ID;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* MS_WORKAROUND : This is to ensure that the queue for BCH is not filled with old BO requests :
This assumes that BO is not received more than 4 frames in advance from the enodeb application */
if (cell->bcchBchInfo.lcId == staRsp->lcId)
{
- U16 nextBchSfn;
+ uint16_t nextBchSfn;
nextBchSfn = (cell->crntTime.sfn + 4 - (cell->crntTime.sfn%4)) % RG_MAX_SFN;
if ((staRsp->u.timeToTx.sfn != nextBchSfn) ||
((staRsp->u.timeToTx.sfn == cell->crntTime.sfn) && (cell->crntTime.slot >= 7)))
{
- RETVALUE(ROK);
+ return ROK;
}
}
/*
rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
//TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
- RETVALUE(ROK);
+ return ROK;
} /* rgROMHndlBcchPcchStaRsp */
/* ADD Changes for Downlink UE Timing Optimization */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PRIVATE S16 rgROMUpdDlSfRemDataCnt
-(
-RgCellCb *cellCb,
-RgDlSf *dlSf
-)
-#else
-PRIVATE S16 rgROMUpdDlSfRemDataCnt(cellCb, dlSf)
-RgCellCb *cellCb;
-RgDlSf *dlSf;
-#endif
+static S16 rgROMUpdDlSfRemDataCnt(RgCellCb *cellCb, RgDlSf *dlSf)
{
RgErrInfo err;
//Inst inst = cellCb->macInst - RG_INST_START;
- TRC2(rgROMUpdDlSfRemDataCnt);
-
-
if(!dlSf->remDatReqCnt)
{
/*This is an error scenario of RLC generating more data
* request than the allocation. Do nothing for this. */
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
- "RX new data while remDatReqCnt is 0 for cell");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : RX new data while remDatReqCnt is 0 for cell");
+ return RFAILED;
}
/*Decrement the remaining data request to be received countter
if (ROK != rgTOMUtlProcDlSf (dlSf, cellCb, &err))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
- "Unable to process downlink slot for cell");
+ DU_LOG("\nERROR --> MAC : Unable to process downlink slot for cell");
err.errType = RGERR_ROM_DEDDATREQ;
}
dlSf->txDone = TRUE;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgROMUpdDlSfRemDataCnt*/
#endif