@brief This module handles the configuration of MAC by RRC and RRM.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=180;
-static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system service interface */
-#include "cm_hash.h" /* common hash list */
-#include "cm_mblk.h" /* common memory link list library */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
+#include "common_def.h"
#include "lrg.h" /* Layer manager interface includes*/
#include "crg.h" /* CRG interface includes*/
#include "rgu.h" /* RGU interface includes*/
#include "rg_env.h" /* MAC environmental includes*/
#include "rg.h" /* MAC includes*/
#include "rg_err.h" /* MAC error includes*/
-
+#include "mac_utils.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
#include "rgu.x" /* RGU types */
#include "tfu.x" /* RGU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "crg.x" /* CRG interface includes */
#include "rg_sch_inf.x" /* SCH interface typedefs */
#include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
-#include "mac_interface.h"
+#include "du_app_mac_inf.h"
#include "rg.x" /* typedefs for MAC */
#ifdef LTE_ADV
#include "rg_pom_scell.x"
#endif
/* LTE-MAC Control Block Structure */
-PUBLIC RgCb rgCb[RG_MAX_INST];
+RgCb rgCb[RG_MAX_INST];
/* local defines */
-PRIVATE S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
+static S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
RgUeCb **ue, RgErrInfo *errInfo));
-PRIVATE S16 rgCFGVldtCrgCmnLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
+static S16 rgCFGVldtCrgCmnLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
RgErrInfo *errInfo));
-PRIVATE S16 rgCFGCrgDedLcCfg ARGS((RgCellCb *cell, RgUeCb *ue,
+static S16 rgCFGCrgDedLcCfg ARGS((RgCellCb *cell, RgUeCb *ue,
CrgLchCfg *lcCfg, RgErrInfo *errInfo));
-PRIVATE S16 rgCFGCrgCmnLcCfg ARGS((Inst inst,RgCellCb *cell, CrgLchCfg *lcCfg,
+static S16 rgCFGCrgCmnLcCfg ARGS((Inst inst,RgCellCb *cell, CrgLchCfg *lcCfg,
RgErrInfo *errInfo));
-PRIVATE Void rgCFGFreeCmnLcLst ARGS((RgCellCb *cell));
-PRIVATE Void rgCFGFreeUeLst ARGS((RgCellCb *cell));
+static Void rgCFGFreeCmnLcLst ARGS((RgCellCb *cell));
+static Void rgCFGFreeUeLst ARGS((RgCellCb *cell));
/* Added support for SPS*/
#ifdef LTEMAC_SPS
-PRIVATE Void rgCFGFreeSpsUeLst ARGS((RgCellCb *cell));
+static Void rgCFGFreeSpsUeLst ARGS((RgCellCb *cell));
#endif /* LTEMAC_SPS */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgCellCfg
+S16 rgCFGVldtCrgCellCfg
(
Inst inst,
CrgCellCfg *cellCfg,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
-Inst inst;
-CrgCellCfg *cellCfg;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgCellCfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
if ((rgCb[inst].cell != NULLP)
|| rgCb[inst].inactiveCell != NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell already exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Cell already exists");
+ return RFAILED;
}
if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
|| cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
|| (cellCfg->bwCfg.ulTotalBw < RG_MIN_UL_BW
|| cellCfg->bwCfg.ulTotalBw > RG_MAX_UL_BW))
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,
- "Invalid Bandwidth configuration: ul %d dl %d",
+ DU_LOG("\nERROR --> MAC : Invalid Bandwidth configuration: ul %d dl %d",
cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,
- "Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
+ return RFAILED;
}
#ifdef TENB_MULT_CELL_SUPPRT
if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
(cellCfg->rguUlSapId > rgCb[inst].numRguSaps))
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for CellId %d failed\n",
+ DU_LOG("\nERROR --> MAC : Invald Sap Id: DL %d UL %d for CellId %d failed\n",
cellCfg->rguDlSapId,
cellCfg->rguUlSapId,
- cellCfg->cellId));
- RETVALUE(RFAILED);
+ cellCfg->cellId);
+ return RFAILED;
}
#endif
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgCellCfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgUeCfg
+S16 rgCFGVldtCrgUeCfg
(
Inst inst,
CrgUeCfg *ueCfg,
RgCellCb **cell,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
-Inst inst;
-CrgUeCfg *ueCfg;
-RgCellCb **cell;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgUeCfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
(ueCfg->txMode.tm == CRG_UE_TM_5))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Transmission Mode=%d not supported",
+ DU_LOG("\nERROR --> MAC : Transmission Mode=%d not supported",
ueCfg->txMode.tm);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Active cell */
if(((*cell = rgCb[inst].cell) == NULLP) ||
((*cell)->cellId != ueCfg->cellId))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Active Cell does not exist for cellId%d",
+ DU_LOG("\nERROR --> MAC : Active Cell does not exist for cellId%d",
ueCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- /* Check if Ue already configured */
+ /* Check if UE already configured */
if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Ue already exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UE already exists");
+ return RFAILED;
}
if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "Invalid Uplink HARQ config %d ",
+ DU_LOG("\nERROR --> MAC : Invalid Uplink HARQ config %d ",
ueCfg->ueUlHqCfg.maxUlHqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef TENB_MULT_CELL_SUPPRT
if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
(ueCfg->rguUlSapId > rgCb[inst].numRguSaps))
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for ueId %d failed\n",
+ DU_LOG("\nERROR --> MAC : Invald Sap Id: DL %d UL %d for ueId %d failed\n",
ueCfg->rguDlSapId,
ueCfg->rguUlSapId,
- ueCfg->crnti));
- RETVALUE(RFAILED);
+ ueCfg->crnti);
+ return RFAILED;
}
#endif
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgUeCfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgLcCfg
+S16 rgCFGVldtCrgLcCfg
(
Inst inst,
CrgLchCfg *lcCfg,
RgUeCb **ue,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
-Inst inst;
-CrgLchCfg *lcCfg;
-RgCellCb **cell;
-RgUeCb **ue;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgLcCfg);
-
if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
{
/* Dedicated logical channels */
if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for dedicated LC failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Validation for dedicated LC failed");
+ return RFAILED;
}
}
else if (lcCfg->lcType == CM_LTE_LCH_BCCH
{
if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for common logical channels failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Validation for common logical channels failed");
+ return RFAILED;
}
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel type %d",
+ DU_LOG("\nERROR --> MAC : Invalid logical channel type %d",
lcCfg->lcType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_L2_MEAS
if ( lcCfg->qci < RG_QCI_MIN ||
lcCfg->qci > RG_QCI_MAX
)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid qci %x",lcCfg->qci);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Invalid qci %x",lcCfg->qci);
+ return RFAILED;
}
/*validate qci */
#endif /*LTE_L2_MEAS */
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgLcCfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgCellRecfg
+S16 rgCFGVldtCrgCellRecfg
(
Inst inst,
CrgCellRecfg *cellRecfg,
RgCellCb **cell,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
-Inst inst;
-CrgCellRecfg *cellRecfg;
-RgCellCb **cell;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgCellRecfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
if (((*cell = rgCb[inst].cell) == NULLP)
&& ((*cell = rgCb[inst].inactiveCell) == NULLP))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell does not exist");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Cell does not exist");
+ return RFAILED;
}
if((*cell)->cellId != cellRecfg->cellId)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId, "Cell does not exist %d\n",cellRecfg->cellId);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Cell does not exist %d\n",cellRecfg->cellId);
+ return RFAILED;
}
if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,
- "Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgCellRecfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgUeRecfg
+S16 rgCFGVldtCrgUeRecfg
(
Inst inst,
CrgUeRecfg *ueRecfg,
RgUeCb **ue,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
-Inst inst;
-CrgUeRecfg *ueRecfg;
-RgCellCb **cell;
-RgUeCb **ue;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgUeRecfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
(ueRecfg->txMode.tm == CRG_UE_TM_5))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Transmission Mode=%d not supported",
+ DU_LOG("\nERROR --> MAC : Transmission Mode=%d not supported",
ueRecfg->txMode.tm);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Active cell */
if (((*cell = rgCb[inst].cell) == NULLP)
|| ((*cell)->cellId != ueRecfg->cellId))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,ueRecfg->cellId, "Active Cell does not exist\n");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Active Cell does not exist\n");
+ return RFAILED;
}
/* Fix : syed UE ID change at MAC will now be controlled
* by SCH. */
if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"[%d]Old Ue does not exist", ueRecfg->oldCrnti);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : [%d]Old UE does not exist", ueRecfg->oldCrnti);
+ return RFAILED;
}
if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config for UE %d",
+ DU_LOG("\nERROR --> MAC : Invalid Uplink HARQ config for UE %d",
ueRecfg->ueUlHqRecfg.maxUlHqTx);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgUeRecfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgLcRecfg
+S16 rgCFGVldtCrgLcRecfg
(
Inst inst,
CrgLchRecfg *lcRecfg,
RgUlLcCb **ulLc,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
-Inst inst;
-CrgLchRecfg *lcRecfg;
-RgCellCb **cell;
-RgUeCb **ue;
-RgUlLcCb **ulLc;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgLcRecfg);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
/* Fetch the cell */
if ((((*cell = rgCb[inst].cell)) == NULLP)
|| ((*cell)->cellId != lcRecfg->cellId))
{
- RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
+ return RFAILED;
}
/* Fetch the Ue for dedicated channels */
if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Ue does not exist for dedicated logical channel");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel");
+ return RFAILED;
}
if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
{
- RLOG_ARG1(L_ERROR, DBG_CRNTI,lcRecfg->crnti,"Dedicated UL LC does not exist %d",lcRecfg->lcId);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Dedicated UL LC does not exist %d",lcRecfg->lcId);
+ return RFAILED;
}
if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
{
- RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Invalid lcgId for uplink logical channel lcg %d lc %d",
+ DU_LOG("\nERROR --> MAC : Invalid lcgId for uplink logical channel lcg %d lc %d",
lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgLcRecfg */
/* Start: LTEMAC_2.1_DEV_CFG */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGVldtCrgUeReset
+S16 rgCFGVldtCrgUeReset
(
-Inst inst,
-CrgRst *reset,
+Inst inst,
+CrgRst *reset,
RgCellCb **cell,
RgUeCb **ue,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
-Inst inst;
-CrgRst *reset;
-RgCellCb **cell;
-RgUeCb **ue;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGVldtCrgUeReset);
-
errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
/* Fetch the Active cell */
if (((*cell = rgCb[inst].cell) == NULLP)
|| ((*cell)->cellId != reset->cellId))
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",reset->crnti, reset->cellId));
- RLOG_ARG1(L_ERROR,DBG_CRNTI,reset->crnti,"Active Cell does not exist %d",reset->cellId);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Active Cell does not exist %d",reset->cellId);
+ return RFAILED;
}
/* Fetch the Ue */
if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,reset->crnti,"UE does not exist");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UE does not exist");
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgUeReset*/
/* End: LTEMAC_2.1_DEV_CFG */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgCellCfg
+S16 rgCFGCrgCellCfg
(
Inst inst,
CrgCellCfg *cellCfg,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
-Inst inst;
-CrgCellCfg *cellCfg;
-RgErrInfo *errInfo;
-#endif
{
S16 ret;
RgCellCb *cell = NULLP;
- U8 idx;
+ uint8_t idx;
SuId rguUlSapId = 0;
SuId rguDlSapId = 0;
/* RLC SAP to allocate flowCntrlInd buffer*/
- Pst *pst ;
-
- TRC2(rgCFGCrgCellCfg);
+ /* Commented below to resolve compilation warning */
+ //Pst *pst ;
errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
/* Allocate the cell control block */
if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Memory allocation FAILED for cell");
+ return RFAILED;
}
if (cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Memory allocation FAILED for cell");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Memory allocation FAILED for cell");
+ return RFAILED;
}
/* Initialize the cell */
ret = rgDBMInitCell(cell);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization for cell failed");
+ DU_LOG("\nERROR --> MAC : DBM initialization for cell failed");
rgCFGFreeInactvCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
if (RFAILED == RgLaaCellCbInit(cell))
{
rgCFGFreeInactvCellCb(cell);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
cmLListInit(&cell->l2mList);
for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
{
- cmMemset((U8 *)&cell->ulSf[idx], 0, sizeof(RgUlSf));
+ memset(&cell->ulSf[idx], 0, sizeof(RgUlSf));
}
- cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
+ cell->ttiCycle = (uint32_t)RG_TTI_CYCLE_INVLD;
#endif
/* Update Statistics */
rgUpdtCellCnt(inst,RG_CFG_ADD);
errInfo->errCause = RGERR_NONE;
- pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
+ /* Commented below to resolve compilation warning */
+ //pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
/* Allocate a buffer for flowCntrlInd.*/
- SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
- sizeof(RguFlowCntrlInd));
- RETVALUE(ROK);
+ MAC_ALLOC(cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
+ if(cell->flowCntrlInd == NULLP)
+ {
+ DU_LOG("ERROR --> MAC : rgCFGCrgCellCfg(): Memory allocation failed");
+ return RFAILED;
+ }
+ return ROK;
} /* rgCFGCrgCellCfg */
#ifdef LTE_ADV
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCfgAddUeSCellCfg
+S16 rgCfgAddUeSCellCfg
(
Inst dstMacInst,
RgPrgUeSCellCfgInfo *ueSCellCb,
RgCellCb *cell
)
-#else
-PUBLIC S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
-Inst dstMacInst;
-RgPrgUeSCellCfgInfo *ueSCellCb;
-RgCellCb *cell;
-#endif
{
RgUeCb *ueCb = NULLP;
SuId rguUlSapId = 0;
SuId rguDlSapId = 0;
- U8 idx;
+ uint8_t idx;
RgErrInfo errInfo;
- TRC2(rgCfgAddUeSCellCfg);
-
#ifdef LTE_ADV
rguDlSapId = ueSCellCb->rguDlSapId;
rguUlSapId = ueSCellCb->rguUlSapId;
if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
{
- RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
- "[%d]Ue already exist in scell %d during scell addition\n",
+ DU_LOG("\nERROR --> MAC : [%d]UE already exist in scell %d during scell addition\n",
ueSCellCb->ueId,
- cell->cellId));
- RETVALUE(RFAILED);
+ cell->cellId);
+ return RFAILED;
}
/* Create UeCb */
if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
FALSE, &errInfo)) == NULLP)
{
- RGDBGERRNEW(dstMacInst, (rgPBuf(dstMacInst),
- "[%d]UeCb creation failed\n", ueSCellCb->ueId));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : [%d]UeCb creation failed\n", ueSCellCb->ueId);
+ return RFAILED;
}
if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
(rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
{
- RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
- "[%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : [%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId);
+ return RFAILED;
}
rgDBMInsUeCb(cell, ueCb);
ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
}
- RETVALUE(ROK);
+ return ROK;
}/* rgCfgAddUeSCellCfg */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgFillAndAddSCellCfg
+S16 rgFillAndAddSCellCfg
(
Inst inst,
RgCellCb *cell,
CrgCfgTransId transId,
Bool *isCfmRqrd
)
-#else
-PUBLIC S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
-Inst inst;
-RgCellCb *cell;
-CrgUeRecfg *ueRecfg;
-CrgCfgTransId transId;
-Bool *isCfmRqrd;
-#endif
{
RgUeCb *ue = NULLP;
- U8 idx = 0;
+ uint8_t idx = 0;
Inst dstMacInst;
RgPrgUeSCellCfgInfo ueSCellCb;
Pst dstInstPst;
- TRC2(rgFillAndAddSCellCfg);
-
/* Fetch the Active cell */
if(((cell = rgCb[inst].cell) == NULLP) ||
(cell->cellId != ueRecfg->cellId))
{
- RGDBGERRNEW(inst,(rgPBuf(inst),
- "[%d]Active Cell does not exist %d\n",
- ueRecfg->oldCrnti, ueRecfg->cellId));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : [%d]Active Cell does not exist %d\n",
+ ueRecfg->oldCrnti, ueRecfg->cellId);
+ return RFAILED;
}
- RGDBGPRM(inst,(rgPBuf(inst),
- "Filling SCell Config : cellId %d ueId %d\n",
- cell->cellId, cell->ueId));
+ DU_LOG("\nINFO --> MAC : Filling SCell Config : cellId %d ueId %d\n",
+ cell->cellId, cell->ueId);
if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
{
- RGDBGERRNEW(inst,(rgPBuf(inst),
- "[%d]Ue does not exist\n", ueRecfg->oldCrnti));
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : [%d]UE does not exist\n", ueRecfg->oldCrnti);
+ return RFAILED;
}
/* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
ue->cfgCfmInfo.cfgCfgCount = 0;
ue->cfgCfmInfo.mask = 0x0;
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy(&(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
ueSCellCb.ueId = ueRecfg->oldCrnti;
ueSCellCb.txMode = ue->txMode;
ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
- cmMemcpy((U8 *)ueSCellCb.ulLcInfo, (U8 *)ue->ul.lcCb, sizeof(ue->ul.lcCb));
- cmMemcpy((U8 *)ueSCellCb.dlLcInfo, (U8 *)ue->dl.lcCb, sizeof(ue->dl.lcCb));
+ memcpy(ueSCellCb.ulLcInfo, ue->ul.lcCb, sizeof(ue->ul.lcCb));
+ memcpy(ueSCellCb.dlLcInfo, ue->dl.lcCb, sizeof(ue->dl.lcCb));
for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
{
ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
} /*end of for loop */
*isCfmRqrd = FALSE;
- RETVALUE(ROK);
+ return ROK;
} /* rgFillAndAddSCellCfg */
#endif /* LTE_ADV */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeCfg
+S16 rgCFGCrgUeCfg
(
Inst inst,
RgCellCb *cell,
CrgUeCfg *ueCfg,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
-Inst inst;
-RgCellCb *cell;
-CrgUeCfg *ueCfg;
-RgErrInfo *errInfo;
-#endif
{
RgUeCb *ue = NULLP;
Bool handover = FALSE;
SuId rguUlSapId = 0;
SuId rguDlSapId = 0;
- TRC2(rgCFGCrgUeCfg);
-
errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
/* Start: LTEMAC_2.1_DEV_CFG */
/* Create UeCb and Insert in Rach List */
if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb creation failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UeCb creation failed");
+ return RFAILED;
}
if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb Harq Entity Initialization failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UeCb Harq Entity Initialization failed");
+ return RFAILED;
}
handover = TRUE;
}
/* Update satistics */
rgUpdtUeCnt(inst,RG_CFG_ADD);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeCfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgLcCfg
+S16 rgCFGCrgLcCfg
(
Inst inst,
RgCellCb *cell,
Bool *isCfmRqrd,
CrgCfgTransId transId
)
-#else
-PUBLIC S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
-Inst inst;
-RgCellCb *cell;
-RgUeCb *ue;
-CrgLchCfg *lcCfg;
-RgErrInfo *errInfo;
-Bool *isCfmRqrd;
-CrgCfgTransId transId;
-#endif
{
- TRC2(rgCFGCrgLcCfg);
-
/* Handle Config for dedicated/common logical channels */
if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
{
if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,
- "Dedicated logical channel configuration failed %d",lcCfg->lcId);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Dedicated logical channel configuration failed %d",lcCfg->lcId);
+ return RFAILED;
}
#ifdef LTE_ADV
/*ERAB Multl Cell fix*/
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy(&(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
#endif
{
if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
{
- RLOG_ARG1(L_ERROR, DBG_CRNTI, lcCfg->crnti, "Common logical channel configuration"
+ DU_LOG("\nERROR --> MAC : Common logical channel configuration"
"failed %d\n", lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
errInfo->errCause = RGERR_NONE;
- RLOG_ARG1(L_INFO, DBG_CRNTI,lcCfg->crnti, "CRG LC config done for UE: lcId %d\n", lcCfg->lcId);
- RETVALUE(ROK);
+ DU_LOG("\nINFO --> MAC : CRG LC config done for UE lcId %d\n", lcCfg->lcId);
+ return ROK;
} /* rgCFGCrgLcCfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgCellRecfg
+S16 rgCFGCrgCellRecfg
(
Inst inst,
RgCellCb *cell,
CrgCellRecfg *cellRecfg,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
-Inst inst;
-RgCellCb *cell;
-CrgCellRecfg *cellRecfg;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGCrgCellRecfg);
-
/* Store the given rachCfg */
cell->rachCfg = cellRecfg->rachRecfg;
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgCellRecfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeRecfg
+S16 rgCFGCrgUeRecfg
(
Inst inst,
RgCellCb *cell,
CrgUeRecfg *ueRecfg,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
-Inst inst;
-RgCellCb *cell;
-RgUeCb *ue;
-CrgUeRecfg *ueRecfg;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGCrgUeRecfg);
-
errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
/* Fix : syed UE ID change at MAC will now be controlled
rgUHMCrgUeRecfg(cell, ue, ueRecfg);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeRecfg */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgLcRecfg
+S16 rgCFGCrgLcRecfg
(
Inst inst,
RgCellCb *cell,
RgErrInfo *errInfo,
Bool *isCfmRqrd
)
-#else
-PUBLIC S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
-Inst inst;
-RgCellCb *cell;
-RgUeCb *ue;
-RgUlLcCb *ulLc;
-CrgLchRecfg *lcRecfg;
-RgErrInfo *errInfo;
-Bool *isCfmRqrd;
-#endif
{
- TRC2(rgCFGCrgLcRecfg);
if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
{
}
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgLcRecfg */
/* Start: LTEMAC_2.1_DEV_CFG */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeReset
+S16 rgCFGCrgUeReset
(
RgCellCb *cell,
RgUeCb *ue,
-CrgRst *reset,
+CrgRst *reset,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
-RgCellCb *cell;
-RgUeCb *ue;
-CrgRst *reset;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGCrgUeReset);
- RLOG_ARG1(L_DEBUG, DBG_CRNTI, ue->ueId, "UE: of cell %d Reset\n", cell->cellId);
+ DU_LOG("\nDEBUG --> MAC : UE of cell %d Reset\n", cell->cellId);
rgDHMUeReset(cell, &ue->dl.hqEnt);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeReset */
/* End: LTEMAC_2.1_DEV_CFG */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgCellDel
+S16 rgCFGCrgCellDel
(
Inst inst,
CrgDel *cellDelInfo,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
-Inst inst,
-CrgDel *cellDelInfo;
-RgErrInfo *errInfo;
-#endif
{
- RgCellCb *cell;
- U8 idx;
+ RgCellCb *cell;
+ uint8_t idx;
- TRC2(rgCFGCrgCellDel);
errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
if (((cell = rgCb[inst].cell) == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,"Cell does not exist");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Cell does not exist");
+ return RFAILED;
}
/* Delete cell from inactive list */
rgCFGFreeInactvCellCb(cell);
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
}
/* Delete from the cell list */
rgCb[inst].cell = NULLP;
errInfo->errCause = RGERR_NONE;
- RGDBGINFO(inst,(rgPBuf(inst), "Cell %d deleted\n", cellDelInfo->u.cellDel.cellId));
- RETVALUE(ROK);
+ DU_LOG("\nINFO --> MAC : Cell %d deleted\n", cellDelInfo->u.cellDel.cellId);
+ return ROK;
} /* rgCFGCrgCellDel */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgUeDel
+S16 rgCFGCrgUeDel
(
Inst inst,
CrgDel *ueDelInfo,
RgErrInfo *errInfo
)
-#else
-PUBLIC S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
-Inst inst;
-CrgDel *ueDelInfo;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGCrgUeDel);
errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
- RLOG_ARG1(L_DEBUG, DBG_CRNTI, ueDelInfo->u.ueDel.crnti, "UE %d Deletion Req at MAC\n", \
+ DU_LOG("\nDEBUG --> MAC : UE %d Deletion Req at MAC\n", \
ueDelInfo->u.ueDel.crnti);
if ((rgCb[inst].cell == NULLP)
|| (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,ueDelInfo->u.ueDel.crnti,"Cell does not exist %d",
+ DU_LOG("\nERROR --> MAC : Cell does not exist %d",
ueDelInfo->u.ueDel.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
errInfo->errCause = RGERR_NONE;
/* Fix: syed Context Deletion is relied upon SCH indication */
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgUeDel */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 rgCFGCrgLcDel
+S16 rgCFGCrgLcDel
(
Inst inst,
CrgDel *lcDelInfo,
Bool *isCfmRqrd,
CrgCfgTransId transId
)
-#else
-PUBLIC S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
-Inst inst;
-CrgDel *lcDelInfo;
-RgErrInfo *errInfo;
-CrgCfgTransId transId;
-#endif
{
Bool dirVld = FALSE;
RgCellCb *cell;
RgUlLcCb *ulLc;
RgDlLcCb *dlLc;
- TRC2(rgCFGCrgLcDel);
-
errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
/* Fetch the Active cell */
if (((cell = rgCb[inst].cell) == NULLP) ||
(rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Cell does not exist %d",
+ DU_LOG("\nERROR --> MAC : Cell does not exist %d",
lcDelInfo->u.lchDel.cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,
- "UE does not exist for dedicated logical channel");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel");
+ return RFAILED;
}
/* Validate downlink info */
if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
== NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"DL LC %d does not exist",
+ DU_LOG("\nERROR --> MAC : DL LC %d does not exist",
lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDBMDelDlDedLcCb(ue, dlLc);
dirVld = TRUE;
if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
== NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"UL LC %d does not exist",
+ DU_LOG("\nERROR --> MAC : UL LC %d does not exist",
lcDelInfo->u.lchDel.lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDBMDelUlDedLcCb(ue, ulLc);
dirVld = TRUE;
if (!dirVld)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Invalid direction %d for LC Delete",
+ DU_LOG("\nERROR --> MAC : Invalid direction %d for LC Delete",
lcDelInfo->u.lchDel.dir);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTE_ADV
/*ERAB - multicell fix*/
- cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
+ memcpy( &(ue->cfgCfmInfo.transId), &transId,
sizeof(CrgCfgTransId));
rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
#endif
errInfo->errCause = RGERR_NONE;
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgLcDel */
/***********************************************************
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE S16 rgCFGVldtCrgDedLcCfg
+static S16 rgCFGVldtCrgDedLcCfg
(
Inst inst,
CrgLchCfg *lcCfg,
RgUeCb **ue,
RgErrInfo *errInfo
)
-#else
-PRIVATE S16 rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)
-Inst inst;
-CrgLchCfg *lcCfg;
-RgCellCb **cell;
-RgUeCb **ue;
-RgErrInfo *errInfo;
-#endif
{
- U8 dirVld = FALSE;
- TRC2(rgCFGVldtCrgDedLcCfg);
+ uint8_t dirVld = FALSE;
errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
if (((*cell = rgCb[inst].cell) == NULLP)
|| ((*cell)->cellId != lcCfg->cellId))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Active Cell does not exist: Cell %d",
+ DU_LOG("\nERROR --> MAC : Active Cell does not exist: Cell %d",
lcCfg->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fetch the Ue */
if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE does not exist for dedicated logical channel %d",
+ DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel %d",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate logical channel Id */
if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel Id %d",
+ DU_LOG("\nERROR --> MAC : Invalid logical channel Id %d",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Validate downlink info */
{
if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated DL LC %d already configured",
+ DU_LOG("\nERROR --> MAC : UE Dedicated DL LC %d already configured",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
dirVld = TRUE;
}
{
if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Invalid lcgId for uplink logical channel %d",
+ DU_LOG("\nERROR --> MAC : UE Invalid lcgId for uplink logical channel %d",
lcCfg->ulInfo.lcgId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated UL LC %d already configured",
+ DU_LOG("\nERROR --> MAC : UE Dedicated UL LC %d already configured",
lcCfg->lcId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
dirVld = TRUE;
}
if (!dirVld)
{
- RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid Direction %d",
+ DU_LOG("\nERROR --> MAC : Invalid Direction %d",
lcCfg->dir);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgDedLcCfg */
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE S16 rgCFGVldtCrgCmnLcCfg
+static S16 rgCFGVldtCrgCmnLcCfg
(
Inst inst,
CrgLchCfg *lcCfg,
RgCellCb **cell,
RgErrInfo *errInfo
)
-#else
-PRIVATE S16 rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)
-Inst inst;
-CrgLchCfg *lcCfg;
-RgCellCb **cell;
-RgErrInfo *errInfo;
-#endif
{
- U8 dirVld = FALSE;
-
- TRC2(rgCFGVldtCrgCmnLcCfg);
+ uint8_t dirVld = FALSE;
errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
if (((*cell = rgCb[inst].cell) != NULLP)
&& ((*cell)->cellId != lcCfg->cellId))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Active Cell exists for common channels");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Active Cell exists for common channels");
+ return RFAILED;
}
/* Fetch the inactive cell for common logical channels */
|| ((*cell)->cellId != lcCfg->cellId))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Inactive Cell does not exist for common channels");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Inactive Cell does not exist for common channels");
+ return RFAILED;
}
/* Validate downlink info */
if (lcCfg->dir & CRG_DIR_TX)
{
if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on DLSCH already configured for cell");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : BCCH on DLSCH already configured for cell");
+ return RFAILED;
}
}
else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
{
if (rgDBMGetBcchOnBch(*cell) != NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on BCH already configured for cell %d");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : BCCH on BCH already configured for cell ");
+ return RFAILED;
}
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid transport channel %d for cell",
+ DU_LOG("\nERROR --> MAC : Invalid transport channel %d for cell",
lcCfg->dlInfo.dlTrchType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
{
if (rgDBMGetPcch(*cell) != NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"PCCH already configured for cell");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : PCCH already configured for cell");
+ return RFAILED;
}
}
else if (RG_DLCCCH_ISCFGD(*cell))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"DL CCCH already configured for cell %d");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : DL CCCH already configured for cell ");
+ return RFAILED;
}
dirVld = TRUE;
}
/* Uplink CCCH */
if (lcCfg->lcType != CM_LTE_LCH_CCCH)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid UL common lcType %d for cell ",
+ DU_LOG("\nERROR --> MAC : Invalid UL common lcType %d for cell ",
lcCfg->lcType);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (RG_ULCCCH_ISCFGD(*cell))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"UL CCCH already configured for cell ");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : UL CCCH already configured for cell ");
+ return RFAILED;
}
dirVld = TRUE;
}
/* Invalid direction */
if (!dirVld)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid Direction %d", lcCfg->dir);
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> MAC : Invalid Direction %d", lcCfg->dir);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGVldtCrgCmnLcCfg */
/***********************************************************
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE S16 rgCFGCrgDedLcCfg
+static S16 rgCFGCrgDedLcCfg
(
RgCellCb *cell,
RgUeCb *ue,
CrgLchCfg *lcCfg,
RgErrInfo *errInfo
)
-#else
-PRIVATE S16 rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)
-RgCellCb *cell;
-RgUeCb *ue;
-CrgLchCfg *lcCfg;
-RgErrInfo *errInfo;
-#endif
{
//Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGCrgDedLcCfg);
-
errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
/* Uplink/Bi-directional logical channel */
{
rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgDedLcCfg */
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE S16 rgCFGCrgCmnLcCfg
+static S16 rgCFGCrgCmnLcCfg
(
Inst inst,
RgCellCb *cell,
CrgLchCfg *lcCfg,
RgErrInfo *errInfo
)
-#else
-PRIVATE S16 rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)
-Inst inst;
-RgCellCb *cell;
-CrgLchCfg *lcCfg;
-RgErrInfo *errInfo;
-#endif
{
- TRC2(rgCFGCrgCmnLcCfg);
-
errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
/* Handle configuration for CCCH/BCCH/PCCH */
{
rgCb[inst].cell = cell;
rgCb[inst].inactiveCell = NULLP;
- RLOG_ARG1(L_DEBUG, DBG_CELLID, cell->cellId, "Cell %d added to active list after common LC %d\
+ DU_LOG("\nDEBUG --> MAC : Cell added to active list after common LC %d\
config\n", lcCfg->lcId);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgCFGCrgCmnLcCfg */
#ifdef LTE_L2_MEAS
/***********************************************************
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE Void rgCFGFreeUeUlAlloc
-(
-RgCellCb *cell
-)
-#else
-PRIVATE Void rgCFGFreeUeUlAlloc(cell)
-RgCellCb *cell;
-#endif
+static Void rgCFGFreeUeUlAlloc(RgCellCb *cell)
{
- U8 sfIdx;
+ uint8_t sfIdx;
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeUeUlAlloc);
-
for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
{
if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
* File :
*
**********************************************************/
-#ifdef ANSI
-PUBLIC Void rgCFGFreeCellCb
-(
-RgCellCb *cell
-)
-#else
-PUBLIC Void rgCFGFreeCellCb(cell)
-RgCellCb *cell;
-#endif
+Void rgCFGFreeCellCb(RgCellCb *cell)
{
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeCellCb);
#ifdef LTE_ADV
RgLaaCellCbDeInit(cell);
rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
- RGDBGINFO(inst,(rgPBuf(inst), "Cell freed\n"));
+ DU_LOG("\nINFO --> MAC : Cell freed\n");
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeCellCb */
* File :
*
**********************************************************/
-#ifdef ANSI
-PUBLIC Void rgCFGFreeInactvCellCb
-(
-RgCellCb *cell
-)
-#else
-PUBLIC Void rgCFGFreeInactvCellCb(cell)
-RgCellCb *cell;
-#endif
+Void rgCFGFreeInactvCellCb(RgCellCb *cell)
{
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeInactvCellCb);
-
/* De-initialize the Ue list */
rgDBMDeInitUeCbLst(cell);
#ifdef LTEMAC_SPS
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeInactvCellCb */
* File :
*
**********************************************************/
-#ifdef ANSI
-PUBLIC Void rgCFGFreeUeCb
-(
-RgCellCb *cell,
-RgUeCb *ue
-)
-#else
-PUBLIC Void rgCFGFreeUeCb(cell, ue)
-RgCellCb *cell;
-RgUeCb *ue;
-#endif
+Void rgCFGFreeUeCb(RgCellCb *cell,RgUeCb *ue)
{
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgCFGFreeUeCb);
-
rgDHMFreeUe(inst,&ue->dl.hqEnt);
/* ccpu00117052 - MOD - Passing double pointer for proper NULLP
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeUeCb */
/***********************************************************
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE Void rgCFGFreeCmnLcLst
-(
-RgCellCb *cell
-)
-#else
-PRIVATE Void rgCFGFreeCmnLcLst(cell)
-RgCellCb *cell;
-#endif
+static Void rgCFGFreeCmnLcLst(RgCellCb *cell)
{
- TRC2(rgCFGFreeCmnLcLst);
-
rgDBMFreeCmnLcLst(cell);
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeCmnLcLst */
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE Void rgCFGFreeUeLst
-(
-RgCellCb *cell
-)
-#else
-PRIVATE Void rgCFGFreeUeLst(cell)
-RgCellCb *cell;
-#endif
+static Void rgCFGFreeUeLst(RgCellCb *cell)
{
RgUeCb *ue;
- TRC2(rgCFGFreeUeLst);
-
/* Free Ues in the list */
while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
{
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeUeLst */
#ifdef LTEMAC_SPS
* File :
*
**********************************************************/
-#ifdef ANSI
-PRIVATE Void rgCFGFreeSpsUeLst
-(
-RgCellCb *cell
-)
-#else
-PRIVATE Void rgCFGFreeSpsUeLst(cell)
-RgCellCb *cell;
-#endif
+static Void rgCFGFreeSpsUeLst(RgCellCb *cell)
{
RgUeCb *ue;
- TRC2(rgCFGFreeSpsUeLst);
-
/* Free Ues in the list */
while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
{
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgSchMacCellRegReq
-(
-Pst* pst,
-RgInfCellReg* regReq
-)
-#else
-PUBLIC S16 RgSchMacCellRegReq(pst, regReq)
-Pst* pst;
-RgInfCellReg* regReq;
-#endif
+S16 RgSchMacCellRegReq(Pst* pst,RgInfCellReg* regReq)
{
Inst inst;
RgCellCb *cell = NULLP;
- TRC3(RgSchMacCellRegReq)
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
cell = rgCb[inst].cell;
if(NULLP == regReq)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell == NULLP) || (cell->cellId != regReq->cellId))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Initialize */
cell->schInstMap.cellSapId = regReq->cellSapId;
cell->schInstMap.schInst = pst->srcInst;
cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacCellRegReq */
/*Added Ue for Onging L2 Meas*/
#ifdef LTE_L2_MEAS
/*LTE_L2_MEAS_PHASE2*/
-PUBLIC S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
+S16 rgAddToL2MeasPerQci(RgCellCb *cell,uint8_t qci)
{
- S16 ret = ROK;
- CmLList *lnk;
- RgL2MeasCb *measCb;
- U16 idx;
-
- lnk = cell->l2mList.first;
- while(lnk != NULLP )
+ S16 ret = ROK;
+ CmLList *lnk;
+ RgL2MeasCb *measCb;
+ uint16_t idx;
+
+ lnk = cell->l2mList.first;
+ while(lnk != NULLP )
{
measCb = (RgL2MeasCb *)lnk->node;
if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
{
- for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
- {
- if(measCb->measReq.t.prbReq.qci[idx] == qci)
- {
- break; /*exit from for loop*/
- }
- }
- if(idx == measCb->measReq.t.prbReq.numQci)
- {
- cell->qciArray[qci].mask = TRUE;
- measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
- }
+ for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
+ {
+ if(measCb->measReq.t.prbReq.qci[idx] == qci)
+ {
+ break; /*exit from for loop*/
+ }
+ }
+ if(idx == measCb->measReq.t.prbReq.numQci)
+ {
+ cell->qciArray[qci].mask = TRUE;
+ measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
+ }
}
lnk = lnk->next;
} /* End of While*/
-
-
-
- RETVALUE(ret);
+
+
+
+ return (ret);
}
Code Review / o-du / l2.git / blobdiff