@brief This file implements the schedulers main access to MAC layer code.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_MODULE_ID=4096;
-static int RLOG_FILE_ID=177;
/* header include files -- defines (.h) */
#include "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "tfu.h"
+#include "sch_utils.h"
#include "rg_env.h"
#include "rg_sch_err.h"
#include "rg_sch_inf.h"
#include "rg_sch.h"
#include "rg_sch_cmn.h"
#include "rgm.h"
-#include "rl_interface.h"
-#include "rl_common.h"
/* header/extern include files (.x) */
#include "tfu.x" /* TFU types */
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp, sizeof(CmLList));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "CE Pool memory allocation FAILED for cell");
+ DU_LOG("\nERROR --> SCH : CE Pool memory allocation FAILED for cell");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo, cell);
return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp->node, sizeof(RgSchSFRPoolInfo));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "CE Pool memory allocation FAILED for cell ");
+ DU_LOG("\nERROR --> SCH : CE Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp, sizeof(CmLList));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "CC Pool memory allocation FAILED for cell ");
+ DU_LOG("\nERROR --> SCH : CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp->node, sizeof(RgSchSFRPoolInfo));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "CC Pool memory allocation FAILED for cell ");
+ DU_LOG("\nERROR --> SCH : CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp, sizeof(CmLList));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "CC Pool memory allocation FAILED for cell ");
+ DU_LOG("\nERROR --> SCH : CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
return RFAILED;
}
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&temp->node, sizeof(RgSchSFRPoolInfo));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "CC Pool memory allocation FAILED for cell ");
+ DU_LOG("\nERROR --> SCH : CC Pool memory allocation FAILED for cell ");
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo,cell);
return RFAILED;
}
if((rgSCHUtlAllocSBuf(inst, (Data**)&(rntpPtr->val),
(len * sizeof(uint8_t)))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for RNTP Alloc");
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for RNTP Alloc");
return RFAILED;
}
if(ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, " rgSCHUtlAddPhich(): "
+ DU_LOG("\nERROR --> SCH : rgSCHUtlAddPhich(): "
"Allocation of RgSchPhich failed");
return RFAILED;
}
{
if ( ((alloc->ue) == NULLP) || (RG_SCH_CMN_GET_UE(alloc->ue, alloc->ue->cell) == NULLP))
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,alloc->ue->cell->cellId,
- "Failed: ue->sch is null RNTI:%d,isRetx=%d",
+ DU_LOG("\nERROR --> SCH : Failed: ue->sch is null RNTI:%d,isRetx=%d",
alloc->rnti, alloc->grnt.isRtx);
return RFAILED;
}
if(cellCfg->prachRscInfo.numRsc <= 0)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid"
+ DU_LOG("\nERROR --> SCH : Invalid"
"PRACH resources Configuration ");
return;
}
if((rgSCHUtlAllocSBuf(inst, (Data**)&(cell->rntpAggrInfo.val),
(len * sizeof(uint8_t)))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for RNTP Alloc");
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for RNTP Alloc");
return RFAILED;
}
cell->rntpAggrInfo.pres = PRSNT_NODEF;
ue->f1bCsAVal += rgSCHUtlGetMaxTbSupp(ueRecfg->txMode.txModeEnum);
- RLOG1(L_INFO,"UeReCfg A valie is %d\n",ue->f1bCsAVal);
+ DU_LOG("\nINFO --> SCH : UeReCfg A valie is %d\n",ue->f1bCsAVal);
}
#endif
ue->mimoInfo.txMode = ueRecfg->txMode.txModeEnum;
(Data**)&(cell->rlsHqArr[idx].ueHqInfo),
(sizeof(RgInfUeHqInfo)*RGSCH_MAX_UE_PER_DL_SF))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for "
"UE Alloc");
return RFAILED;
}
(Data**)&(cell->sfAllocArr[idx].ueInfo.allocInfo),
(sizeof(RgInfUeAlloc)*RGSCH_MAX_UE_PER_DL_SF))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for "
"UE Alloc");
return RFAILED;
}
(Data**)&(cell->sfAllocArr[idx].rarInfo.raRntiInfo),
(sizeof(RgInfRaRntiInfo)*RGSCH_MAX_RARNTI_PER_DL_SF))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for "
"RARNTI");
return RFAILED;
}
(Data**)&(cell->sfAllocArr[idx].rarInfo.raRntiInfo[indx].crntiInfo),
(sizeof(RgInfCrntiInfo)* (cellUl->maxMsg3PerUlSf)))) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for "
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for "
"RNTI");
return RFAILED;
}
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
MS_BUF_ADD_ALLOC_CALLER();
#endif /* */
- if (SGetSBuf(rgSchCb[inst].rgSchInit.region, rgSchCb[inst].rgSchInit.pool,
- pData, size) != ROK)
+ SCH_ALLOC(pData, size);
+ if(pData == NULLP)
{
RgUstaDgn dgn; /* Alarm diagnostics structure */
dgn.type = LRG_USTA_DGNVAL_MEM;
/* Send an alarm to Layer Manager */
rgSCHLmmStaInd(inst, LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
- RGSCHLOGERROR(inst, ERRCLS_DEBUG, ERG015, 0, "Unable to Allocate Buffer");
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Unable to Allocate the Buffer");
+ DU_LOG("\nERROR --> SCH : Unable to Allocate the Buffer");
return RFAILED;
}
)
{
- S16 ret;
-
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
return;
MS_BUF_ADD_CALLER();
#endif /* */
/* Deallocate buffer */
- ret = SPutSBuf(rgSchCb[inst].rgSchInit.region,
- rgSchCb[inst].rgSchInit.pool, (*data), size);
+ SCH_FREE((*data), size);
- if (ret != ROK)
+ if (data ==NULLP)
{
- RGSCHLOGERROR(inst, ERRCLS_DEBUG, ERG016, (ErrVal) 0,
- "rgSCHUtlFreeSBuf failed.\n");
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHUtlFreeSBuf failed");
+ DU_LOG("\nERROR --> SCH : rgSCHUtlFreeSBuf failed");
return;
}
pdu = (Buffer *)node->node;
cmLListDelFrm(siPduLst, node);
RGSCH_FREE_MSG(pdu);
- SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
+ SCH_FREE(node,sizeof(CmLList));
node = NULLP;
}
/*Get the nPrb and mcs parametr values */
if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "msgLen does "
+ DU_LOG("\nERROR --> SCH : msgLen does "
"not match any valid TB Size");
return RFAILED;
}
allocInfo->pa = (uint8_t)ue->cell->lteAdvCb.sfrCfg.pwrThreshold.pHigh; /* KW fix for LTE_ADV */
if(tmpCnt++ == 100000)
{
- RLOG_ARG2(L_DEBUG,DBG_CELLID,ue->cell->cellId,
- "DSFR::ll UEs can go HIGH, PHigh(%d) for UE(%d)",allocInfo->pa, ue->ueId);
+ DU_LOG("\nDEBUG --> SCH : DSFR::ll UEs can go HIGH, PHigh(%d) for UE(%d)",allocInfo->pa, ue->ueId);
tmpCnt = 0;
}
}
allocInfo->pa = ue->cell->lteAdvCb.sfrCfg.pwrThreshold.pHigh;
if(tmpCnt++ == 100000)
{
- RLOG_ARG2(L_DEBUG,DBG_CELLID,ue->cell->cellId,
- "SFR::UE is CELL EDGE, PHigh(%d) for UE(%d)",allocInfo->pa, ue->ueId);
+ DU_LOG("\nDEBUG --> SCH : SFR::UE is CELL EDGE, PHigh(%d) for UE(%d)",allocInfo->pa, ue->ueId);
tmpCnt = 0;
}
allocInfo->pa = ue->cell->lteAdvCb.sfrCfg.pwrThreshold.pLow;
if(tmpCnt++ == 100000)
{
- RLOG_ARG2(L_DEBUG,DBG_CELLID,ue->cell->cellId,
- "SFR::UE is CELL CENTRE, PLow(%d) for UE(%d)\n",allocInfo->pa, ue->ueId);
+ DU_LOG("\nDEBUG --> SCH : SFR::UE is CELL CENTRE, PLow(%d) for UE(%d)\n",allocInfo->pa, ue->ueId);
tmpCnt = 0;
}
}
CM_LLIST_FIRST_NODE(lnkLst, tmp);
while(NULLP != tmp)
{
- printf("5GTF_ERROR MSG4 Consolidation\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR MSG4 Consolidation\n");
hqCb = (RgSchDlHqProcCb *)(tmp->node);
CM_LLIST_NEXT_NODE(lnkLst, tmp);
((!(ueCb->dl.dlInactvMask & RG_HQENT_INACTIVE)) &&
((hqP != NULLP) && (hqP->hqE->ccchSduProc))))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d Unexpected CCCH SDU BO",
+ DU_LOG("\nINFO --> SCH : RNTI:%d Unexpected CCCH SDU BO",
ueCb->ueId);
return ROK;
}
if ((ueCb = rgSCHDbmGetUeCb(cell, staRsp->u.rnti)) == NULLP)
{
/* Handle Ue fetch failure */
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid UEID:%d",staRsp->u.rnti);
+ DU_LOG("\nERROR --> SCH : Invalid UEID:%d",staRsp->u.rnti);
return RFAILED;
}
/* Update Bo in ueCb */
return (rgSCHUtlUpdtBo(cell, boRpt));
#else
/* Handle RaCb fetch failure */
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Invalid RNTI:%d to fetch raCb",boRpt->u.rnti);
+ DU_LOG("\nERROR --> SCH : Invalid RNTI:%d to fetch raCb",boRpt->u.rnti);
return RFAILED;
#endif
}
if ((ueCb = rgSCHDbmGetUeCb(cell, boRpt->u.rnti)) == NULLP)
{
/* Handle Ue fetch failure */
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RNTI:%d",boRpt->u.rnti);
+ DU_LOG("\nERROR --> SCH : Invalid RNTI:%d",boRpt->u.rnti);
return RFAILED;
}
/* Update Bo in ueCb */
dlLc = rgSCHDbmGetBcchOnBch(cell);
if (dlLc == NULLP)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "No Logical Channel dlLc is NULLP for RNTI:%d LCID:%d",boUpdt->u.rnti,boUpdt->lcId);
+ DU_LOG("\nERROR --> SCH : No Logical Channel dlLc is NULLP for RNTI:%d LCID:%d",boUpdt->u.rnti,boUpdt->lcId);
return RFAILED;
}
if (boUpdt->lcId != dlLc->lcId)
if (rgSCHUtlGetAllwdCchTbSz(boUpdt->bo*8, &nPrb, &mcs)
!= (boUpdt->bo*8))
{
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"[%ld]BO: does not match any "
+ DU_LOG("\nERROR --> SCH : [%d]BO: does not match any "
"valid TB Size RNTI:%d LCID:%d", boUpdt->bo,boUpdt->u.rnti,boUpdt->lcId);
return RFAILED;
}
if ((dlLc = rgSCHDbmGetCmnLcCb(cell, boUpdt->lcId)) == NULLP)
{
/* Handle lcCb fetch failure */
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "LCID:%d Invalid for RNTI:%d",boUpdt->lcId,boUpdt->u.rnti);
+ DU_LOG("\nERROR --> SCH : LCID:%d Invalid for RNTI:%d",boUpdt->lcId,boUpdt->u.rnti);
}
if (((rgSCHUtlAllocSBuf(inst, (Data **)(&boRpt), sizeof(RgSchClcBoRpt))) ==RFAILED) ||
(!boRpt))
{
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId, "Allocation of common bo %dreport "
+ DU_LOG("\nERROR --> SCH : Allocation of common bo %dreport "
"failed RNTI:%d LCID:%d", boUpdt->bo,boUpdt->u.rnti,boUpdt->lcId);
return RFAILED;
}
ret = RgUiRgrBndCfm(&rgSchCb[instId].rgrSap[suId].sapCfg.sapPst, rgSchCb[instId].rgrSap[suId].sapCfg.suId, status);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrBndCfm: RgUiRgrBndCfm Failed ");
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrBndCfm: RgUiRgrBndCfm Failed ");
return (ret);
}
return (ret);
ret = RgUiRgmBndCfm(&rgSchCb[instId].rgmSap[suId].sapCfg.sapPst, rgSchCb[instId].rgmSap[suId].sapCfg.suId, status);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgmBndCfm: RgUiRgrBndCfm Failed ");
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgmBndCfm: RgUiRgrBndCfm Failed ");
return (ret);
}
return (ret);
S16 schSendCfgCfm(Region reg,Pool pool,RgrCfgTransId transId,uint8_t status)
{
Pst cfmPst;
- Inst inst = 0;
memset((&cfmPst), 0, sizeof(Pst));
if(RgUiRgrCfgCfm(&cfmPst,transId, status) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"schSendCfgCfm: RgUiRgrCfgCfm Failed");
- printf("\nschSendCfgCfm: RgUiRgrCfgCfm Failed ");
+ DU_LOG("\nERROR --> SCH : schSendCfgCfm: RgUiRgrCfgCfm Failed ");
return RFAILED;
}
return ROK;
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHUtlRgrTtiInd() Upper SAP not bound (%d) ",
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrTtiInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
return RFAILED;
}
raCb = rgSCHDbmGetRaCb (cellCb, rnti);
if (raCb == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId, "RNTI:%d Received MSG3, unable to "
+ DU_LOG("\nERROR --> SCH : RNTI:%d Received MSG3, unable to "
"find raCb",rnti);
return RFAILED;
}
ret = rgSCHRamProcMsg3 (cellCb, ueCb, raCb, pdu, err);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Processing failed in the RAM "
+ DU_LOG("\nERROR --> SCH : Processing failed in the RAM "
"RNTI:%d ",rnti);
return (ret);
}
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
if (tfuSap->sapSta.sapState != LRG_BND)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,grpPwrCntrlReq->cellId,
- "rgSCHUtlTfuGrpPwrCntrlReq() Lower SAP not bound (%d) ",tfuSap->sapSta.sapState);
+ DU_LOG("\nERROR --> SCH : rgSCHUtlTfuGrpPwrCntrlReq() Lower SAP not bound (%d) ",tfuSap->sapSta.sapState);
return RFAILED;
}
memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuGrpPwrCntrlReq (&pst, tfuSap->sapCfg.spId, grpPwrCntrlReq)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,grpPwrCntrlReq->cellId,
- "rgSCHUtlTfuGrpPwrCntrlReq() Call to RgLiTfuGrpPwrCntrlReq() failed");
+ DU_LOG("\nERROR --> SCH : rgSCHUtlTfuGrpPwrCntrlReq() Call to RgLiTfuGrpPwrCntrlReq() failed");
}
return (ret);
} /* rgSCHUtlTfuGrpPwrCntrlReq */
if(suId >= rgSchCb[inst].numSaps)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Incorrect SuId");
+ DU_LOG("\nERROR --> SCH : Incorrect SuId");
return RFAILED;
}
tfuSap = &(rgSchCb[inst].tfuSap[suId]);
/* First lets check the suId */
if( suId != tfuSap->sapCfg.suId)
{
- RLOG_ARG2(L_ERROR,DBG_INSTID,inst,"Incorrect SuId. Configured (%d) Recieved (%d)",
+ DU_LOG("\nERROR --> SCH : Incorrect SuId. Configured (%d) Recieved (%d)",
tfuSap->sapCfg.suId, suId);
return RFAILED;
}
if (tfuSap->sapSta.sapState != LRG_BND)
{
- RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"Lower SAP not enabled SuId (%d)",
+ DU_LOG("\nERROR --> SCH : Lower SAP not enabled SuId (%d)",
tfuSap->sapCfg.suId);
return RFAILED;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if (memSize<= 0)
{
- RGSCHLOGERROR(inst, ERRCLS_INT_PAR, ERG022, memSize,
- "rgAllocEventMem(): memSize invalid\n");
+ DU_LOG("\nERROR --> SCH : rgAllocEventMem(): memSize invalid\n");
return (RFAILED);
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
if(ROK != cmAllocEvnt(memSize, TFU_MAX_MEMBLK_SIZE, &sMem, memPtr))
#endif /* */
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"cmAllocEvnt Failed.");
+ DU_LOG("\nERROR --> SCH : cmAllocEvnt Failed.");
return RFAILED;
}
/*stoping Task*/
else
{
- printf("\nError: allocDb->count is ZERO ====\n");
+ DU_LOG("\nERROR --> SCH : allocDb->count is ZERO ");
}
- //printf("\nallocDb->count:%u\n",allocDb->count);
+ //DU_LOG("\nallocDb->count:%u\n",allocDb->count);
return;
}
rgSchCb[instId].rgrSap[spId].sapCfg.suId,
transId, status) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrSiCfgCfm: "
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrSiCfgCfm: "
"RgUiRgrSiCfgCfm Failed ");
return RFAILED;
}
rgSchCb[instId].rgrSap[spId].sapCfg.suId,
transId, siId, status) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlRgrSiCfgCfm: "
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrSiCfgCfm: "
"RgUiRgrSiCfgCfm Failed ");
return RFAILED;
}
RgSchDrxDlHqProcCb *drxHq;
RgSchDRXCellCb *drxCell = cellCb->drxCb;
RgSchDrxUeCb *drxUe;
-#ifdef DEBUGP
- Inst inst = cellCb->instIdx;
-#endif
uint8_t cellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(dlHq->hqE->cell)];
uint32_t dlInactvMask;
uint32_t ulInactvMask;
/* This condition should never occur */
if(drxHq->reTxIndx >= RG_SCH_MAX_DRXQ_SIZE)
{
- RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"[%d]UE:DRXUE RETX IDX[%d]"
+ DU_LOG("\nERROR --> SCH : [%d]UE:DRXUE RETX IDX[%d]"
"is out of bound,dlInactvMask %d,procId %d\n", ueCb->ueId,
- drxHq->reTxIndx,ueCb->dl.dlInactvMask, dlHq->procId));
+ drxHq->reTxIndx,ueCb->dl.dlInactvMask, dlHq->procId);
}
drxUe->drxDlInactvMaskPerCell[cellIdx] |= (RG_SCH_DRX_DLHQ_BITMASK << dlHq->procId);
/* Call utility function (rgSCHUtlRgrStaInd) to send rpts to RRM */
if(rgSCHUtlRgrStaInd(cell, staInfo) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Could not send "
+ DU_LOG("\nERROR --> SCH : Could not send "
"CQI reports for RNTI:%d",ue->ueId);
return RFAILED;
}
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHUtlRgrStaInd() Upper SAP not bound (%d) ",
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrStaInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
return RFAILED;
}
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHUtlRgrLoadInfInd() Upper SAP not bound (%d) ",
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrLoadInfInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
return RFAILED;
}
/* Call utility function (rgSCHUtlRgrUeStaInd) to send rpts to RRM */
if(rgSCHUtlRgrUeStaInd(cell, ueStaInfo) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Could not send "
+ DU_LOG("\nERROR --> SCH : Could not send "
"UE Sta reports CRNTI:%d",ue->ueId);
return RFAILED;
}
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHUtlRgrUeStaInd() Upper SAP not bound (%d) ",
+ DU_LOG("\nERROR --> SCH : rgSCHUtlRgrUeStaInd() Upper SAP not bound (%d) ",
rgrSap->sapSta.sapState);
return RFAILED;
}
numUlSf = cell->prbUsage.rprtPeriod;
#endif
- if(SGetSBuf(cell->rgmSap->sapCfg.sapPst.region,
- cell->rgmSap->sapCfg.sapPst.pool, (Data**)&prbRprtInd,
- sizeof(RgmPrbRprtInd)) != ROK)
+ SCH_ALLOC(prbRprtInd, sizeof(RgmPrbRprtInd));
+ if(prbRprtInd == NULLP)
{
+ DU_LOG("\nERROR --> SCH : Failed to allocate memory for prbRprtInd");
return RFAILED;
}
#ifdef DBG_MAC_RRM_PRB_PRINT
if((count % reprotForEvery20Sec) == 0 )
{
- printf("\n====================================================================");
- printf("\nMAC: QCI-1[DL:UL] | QCI-2[DL:UL] | QCI-3[DL:UL] | QCI-4[DL:UL] \n");
- printf("======================================================================\n");
- printf(" [%d: %d]\t | [%d: %d]\t | [%d: %d]\t| [%d: %d]\t\n",
+ DU_LOG("\n====================================================================");
+ DU_LOG("\nINFO --> SCH : QCI-1[DL:UL] | QCI-2[DL:UL] | QCI-3[DL:UL] | QCI-4[DL:UL] \n");
+ DU_LOG("======================================================================\n");
+ DU_LOG(" [%d: %d]\t | [%d: %d]\t | [%d: %d]\t| [%d: %d]\t\n",
prbRprtInd->stQciPrbRpts[0].bAvgPrbDlUsage,
prbRprtInd->stQciPrbRpts[0].bAvgPrbUlUsage,
prbRprtInd->stQciPrbRpts[1].bAvgPrbDlUsage,
Inst inst = cell->instIdx;
RgInfRlsRnti rntiInfo;
- RGSCHDBGINFONEW(inst,(rgSchPBuf(inst),"RNTI Release IND for UE(%d)\n", rnti));
+ DU_LOG("\nINFO --> SCH : RNTI Release IND for UE(%d)\n", rnti);
/* Copy the info to rntiInfo */
rntiInfo.cellId = cell->cellId;
rntiInfo.rnti = rnti;
}
}
#ifdef CPU_OL_DBG_PRINTS
- printf("\n DL CPU OL ADJ = %lu, %lu, %d\n", cell->measurements.dlTpt, cell->cpuOvrLdCntrl.tgtDlTpt,
+ DU_LOG("\nINFO --> SCH : DL CPU OL ADJ = %lu, %lu, %d\n", cell->measurements.dlTpt, cell->cpuOvrLdCntrl.tgtDlTpt,
cell->thresholds.maxDlItbs);
#endif
}
}
}
#ifdef CPU_OL_DBG_PRINTS
- printf("\n UL CPU OL ADJ = %lu, %lu, %d\n", cell->measurements.ulTpt, cell->cpuOvrLdCntrl.tgtUlTpt,
+ DU_LOG("\nDEBUG --> SCH : UL CPU OL ADJ = %lu, %lu, %d\n", cell->measurements.ulTpt, cell->cpuOvrLdCntrl.tgtUlTpt,
cell->thresholds.maxUlItbs);
#endif
}
else
{
#ifdef CPU_OL_DBG_PRINTS
- printf("CPU_OL_TTI__ERROR\n");
+ DU_LOG("\nERROR --> SCH : CPU_OL_TTI__ERROR\n");
#endif
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid CPU OL");
+ DU_LOG("\nERROR --> SCH : Invalid CPU OL");
}
}
#ifdef CPU_OL_DBG_PRINTS
- printf("dlNxtIndxDecNumUeTti = %d\n", cpuInstr->dlNxtIndxDecNumUeTti);
+ DU_LOG("\nDEBUG --> SCH : dlNxtIndxDecNumUeTti = %d\n", cpuInstr->dlNxtIndxDecNumUeTti);
#endif
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,"dlNxtIndxDecNumUeTti = %d",
+ DU_LOG("\nDEBUG --> SCH : dlNxtIndxDecNumUeTti = %d",
cpuInstr->dlNxtIndxDecNumUeTti);
}
else if ( crntCpuOvrLdIns & RGR_CPU_OVRLD_DL_INC_NUM_UE_PER_TTI )
else
{
#ifdef CPU_OL_DBG_PRINTS
- printf("CPU_OL_TTI__ERROR\n");
+ DU_LOG("\nERROR --> SCH : CPU_OL_TTI__ERROR\n");
#endif
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid CPU OL");
+ DU_LOG("\nERROR --> SCH : Invalid CPU OL");
}
}
#ifdef CPU_OL_DBG_PRINTS
- printf("dlNxtIndxDecNumUeTti = %d\n", cpuInstr->dlNxtIndxDecNumUeTti);
+ DU_LOG("\nDEBUG --> SCH : dlNxtIndxDecNumUeTti = %d\n", cpuInstr->dlNxtIndxDecNumUeTti);
#endif
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,"dlNxtIndxDecNumUeTti = %d",
+ DU_LOG("\nERROR --> SCH : dlNxtIndxDecNumUeTti = %d",
cpuInstr->dlNxtIndxDecNumUeTti);
}
/* Check for UL CPU commands */
else
{
#ifdef CPU_OL_DBG_PRINTS
- printf("CPU_OL_TTI__ERROR\n");
+ DU_LOG("\nERROR --> SCH : CPU_OL_TTI__ERROR\n");
#endif
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid CPU OL");
+ DU_LOG("\nERROR --> SCH : Invalid CPU OL");
}
}
#ifdef CPU_OL_DBG_PRINTS
- printf("ulNxtIndxDecNumUeTti = %d\n", cpuInstr->ulNxtIndxDecNumUeTti);
+ DU_LOG("\nDEBUG --> SCH : ulNxtIndxDecNumUeTti = %d\n", cpuInstr->ulNxtIndxDecNumUeTti);
#endif
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,"dlNxtIndxDecNumUeTti = %d",
+ DU_LOG("\nDEBUG --> SCH : dlNxtIndxDecNumUeTti = %d",
cpuInstr->dlNxtIndxDecNumUeTti);
}
else if ( crntCpuOvrLdIns & RGR_CPU_OVRLD_UL_INC_NUM_UE_PER_TTI )
else
{
#ifdef CPU_OL_DBG_PRINTS
- printf("CPU_OL_TTI__ERROR\n");
+ DU_LOG("\nERROR --> SCH : CPU_OL_TTI__ERROR\n");
#endif
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid CPU OL");
+ DU_LOG("\nERROR --> SCH : Invalid CPU OL");
}
}
#ifdef CPU_OL_DBG_PRINTS
- printf("ulNxtIndxDecNumUeTti = %d\n", cpuInstr->ulNxtIndxDecNumUeTti);
+ DU_LOG("\nDEBUG --> SCH : ulNxtIndxDecNumUeTti = %d\n", cpuInstr->ulNxtIndxDecNumUeTti);
#endif
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,"dlNxtIndxDecNumUeTti = %d",
+ DU_LOG("\nDEBUG --> SCH : dlNxtIndxDecNumUeTti = %d",
cpuInstr->dlNxtIndxDecNumUeTti);
}
#ifdef CPU_OL_DBG_PRINTS
/* TODO: Debug Information - Shall be moved under CPU_OL_DBG_PRINTS */
- printf("maxUeNewDlTxPerTti = %d, maxUeNewUlTxPerTti = %d\n", maxUeNewDlTxPerTti, maxUeNewUlTxPerTti);
- printf("DL Sf numUePerTti:");
+ DU_LOG("\nDEBUG --> SCH : maxUeNewDlTxPerTti = %d, maxUeNewUlTxPerTti = %d\n", maxUeNewDlTxPerTti, maxUeNewUlTxPerTti);
+ DU_LOG("\nINFO --> SCH : DL Sf numUePerTti:");
for ( idx = 0; idx < 10 ; idx ++ )
{
- printf(" %d", cpuInstr->maxUeNewTxPerTti[idx]);
+ DU_LOG(" %d", cpuInstr->maxUeNewTxPerTti[idx]);
}
- printf("\nUL Sf numUePerTti:");
+ DU_LOG("\nINFO --> SCH : UL Sf numUePerTti:");
for ( idx = 0; idx < 10 ; idx ++ )
{
- printf(" %d", cpuInstr->maxUeNewRxPerTti[idx]);
+ DU_LOG(" %d", cpuInstr->maxUeNewRxPerTti[idx]);
}
- printf("\n");
+ DU_LOG("\n");
#endif
return;
uint8_t idx;
#ifdef CPU_OL_DBG_PRINTS
- printf("\n CPU OVR LD Ins Rcvd = %d\n", (int)crntCpuOvrLdIns);
+ DU_LOG("\nDEBUG --> SCH : CPU OVR LD Ins Rcvd = %d\n", (int)crntCpuOvrLdIns);
#endif
- RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"CPU OVR LD Ins Rcvd");
+ DU_LOG("\nINFO --> SCH : CPU OVR LD Ins Rcvd");
if ( RGR_CPU_OVRLD_RESET == crntCpuOvrLdIns )
{
/* The CPU OL instruction received with RESET (0), hence reset it */
#ifdef CPU_OL_DBG_PRINTS
- printf("rgSCHUtlResetCpuOvrLdState: RESET CPU OL instr\n");
+ DU_LOG("\nDEBUG --> SCH : rgSCHUtlResetCpuOvrLdState: RESET CPU OL instr\n");
#endif
- RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"RESET CPU OVR LD");
+ DU_LOG("\nINFO --> SCH : RESET CPU OVR LD");
cell->cpuOvrLdCntrl.cpuOvrLdIns = 0;
/* Reset the max UL and DL itbs to 26 */
cell->thresholds.maxUlItbs = RG_SCH_UL_MAX_ITBS;
cell->cpuOvrLdCntrl.tgtUlTpt = cell->measurements.ulTpt + \
(cell->measurements.ulTpt * 2 )/100;
}
- RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,"CPU OVR LD UL Reset to "
- "%d, %lu, %lu", (int)crntUlCpuOL, cell->cpuOvrLdCntrl.tgtUlTpt,cell->measurements.ulTpt);
+ DU_LOG("\nDEBUG --> SCH : CPU OVR LD UL Reset to "
+ "%d, %u, %u", (int)crntUlCpuOL, cell->cpuOvrLdCntrl.tgtUlTpt,cell->measurements.ulTpt);
#ifdef CPU_OL_DBG_PRINTS
- printf("\n CPU OVR LD UL Reset to= %d, %lu, %lu\n", (int)crntUlCpuOL, cell->cpuOvrLdCntrl.tgtUlTpt,
+ DU_LOG("\nDEBUG --> SCH : CPU OVR LD UL Reset to= %d, %u, %u\n", (int)crntUlCpuOL, cell->cpuOvrLdCntrl.tgtUlTpt,
cell->measurements.ulTpt);
#endif
}
cell->cpuOvrLdCntrl.tgtDlTpt = cell->measurements.dlTpt + \
(cell->measurements.dlTpt * 1 )/100;
}
- RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,"CPU OVR LD DL Reset to "
- "%d, %lu, %lu", (int)crntDlCpuOL, cell->cpuOvrLdCntrl.tgtDlTpt,cell->measurements.dlTpt);
+ DU_LOG("\nDEBUG --> SCH : CPU OVR LD DL Reset to "
+ "%d, %u, %u", (int)crntDlCpuOL, cell->cpuOvrLdCntrl.tgtDlTpt,cell->measurements.dlTpt);
#ifdef CPU_OL_DBG_PRINTS
- printf("\n CPU OVR LD DL Reset to= %d, %lu, %lu\n", (int)crntDlCpuOL, cell->cpuOvrLdCntrl.tgtDlTpt,
+ DU_LOG("\nDEBUG --> SCH : CPU OVR LD DL Reset to= %d, %lu, %lu\n", (int)crntDlCpuOL, cell->cpuOvrLdCntrl.tgtDlTpt,
cell->measurements.dlTpt);
#endif
}
cp = &emtcUe->dlResLst;
}else
{
- RLOG0(L_INFO, "*****restype mismatch");
+ DU_LOG("\nINFO --> SCH : *****restype mismatch");
}
if(cp != NULLP )
{
if(cp->count == 0)
{
- RLOG0(L_INFO,"****error count*****\n");
+ DU_LOG("\nINFO --> SCH : ****error count*****\n");
return ROK;
}
}
Code Review / o-du / l2.git / blobdiff