@brief This file implements the schedulers main access to MAC layer code.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=187;
-static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
#include "common_def.h"
if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
allocInfo->ccchSduAlloc.ccchSduDlSf->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "bw<=bwAssigned for UEID:%d",ueCb->ueId);
+ DU_LOG("\nERROR --> SCH : bw<=bwAssigned for UEID:%d",ueCb->ueId);
return RFAILED;
}
if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
+ DU_LOG("\nERROR --> SCH : rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
return RFAILED;
}
{
/* Fix : syed Minor failure handling, release hqP if Unsuccessful */
rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
+ DU_LOG("\nERROR --> SCH : rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
return RFAILED;
}
cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"ERROR!! THIS SHOULD "
+ DU_LOG("\nERROR --> SCH : THIS SHOULD "
"NEVER HAPPEN for UEID:%d", ueCb->ueId);
continue;
}
#if (ERRCLASS & ERRCLS_DEBUG)
if (bch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
+ DU_LOG("\nERROR --> SCH : BCCH on BCH is not configured");
return;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (bcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
+ DU_LOG("\nERROR --> SCH : BCCH on DLSCH is not configured");
return;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (bcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
+ DU_LOG("\nERROR --> SCH : BCCH on DLSCH is not configured");
return;
}
#endif
#ifdef ERRCLS_KW
if (pcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
+ DU_LOG("\nERROR --> SCH : PCCH on DLSCH is not configured");
return;
}
#endif
* exceeds the available */
if (rb > sf->bw - sf->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
+ DU_LOG("\nERROR --> SCH : BW allocation "
"failed for CRNTI:%d",rnti);
return;
}
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
subFrm->isCceFailure = TRUE;
-
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u",
+ DU_LOG("\nDEBUG --> SCH : PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u",
aggrLvl);
return (NULLP);
}
if (allocInfo->msg4Alloc.msg4DlSf->bw <=
allocInfo->msg4Alloc.msg4DlSf->bwAssigned)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
- "bw<=bwAssigned");
+ DU_LOG("\nERROR --> SCH : bw<=bwAssigned");
return RFAILED;
}
if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHDhmGetMsg4HqProc failed");
+ DU_LOG("\nERROR --> SCH : rgSCHDhmGetMsg4HqProc failed");
return RFAILED;
}
{
/* Fix : syed Minor failure handling, release hqP if Unsuccessful */
rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnMsg4DedAlloc failed.");
+ DU_LOG("\nERROR --> SCH : rgSCHCmnMsg4DedAlloc failed.");
return RFAILED;
}
cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
{
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
subFrm->isCceFailure = TRUE;
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
+ DU_LOG("\nDEBUG --> SCH : PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
return (NULLP);
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
subFrm->isCceFailure = TRUE;
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
+ DU_LOG("\nDEBUG --> SCH : PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
return (NULLP);
}
if (subFrm->bw == subFrm->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "bw == bwAssigned RARNTI:%d",rarnti);
+ DU_LOG("\nERROR --> SCH : bw == bwAssigned RARNTI:%d",rarnti);
return RFAILED;
}
reqLst = &cell->raInfo.raReqLst[raIndex];
if (reqLst->count == 0)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "reqLst Count=0 RARNTI:%d",rarnti);
+ DU_LOG("\nERROR --> SCH : reqLst Count=0 RARNTI:%d",rarnti);
return RFAILED;
}
remNumRapid = reqLst->count;
/* Allocation succeeded for 'remNumRapid' */
isAlloc = TRUE;
tbs = allwdTbSz/8;
- printf("\n!!!RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
+ DU_LOG("\nINFO --> SCH : RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
noBytes,allwdTbSz,tbs,rb);
break;
}
if (!isAlloc)
{
- RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
+ DU_LOG("\nERROR --> SCH : BW alloc Failed");
return RFAILED;
}
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Error! holeDb sanity check failed RNTI:%d",rnti);
+ DU_LOG("\nERROR --> SCH : holeDb sanity check failed RNTI:%d",rnti);
}
}
if (numSb <= hole->num)
alloc->forMsg3 = TRUE;
alloc->hqProc = hqProc;
rgSCHUhmNewTx(hqProc, (uint8_t)(cell->rachCfg.maxMsg3Tx - 1), alloc);
- //RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
- printf(
- "\nRNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
+ DU_LOG("\nDEBUG --> SCH : RNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
alloc->rnti,
((PTR)alloc->hqProc),
alloc->hqProc->procId,
alloc->hqProc->ulSfIdx);
- RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
- "alloc(%p)maxMsg3Tx(%d)",
- ((PTR)alloc),
+ DU_LOG("\nDEBUG --> SCH : alloc(%p)maxMsg3Tx(%d)",
+ ((void *)alloc),
cell->rachCfg.maxMsg3Tx);
}
}
#ifdef RG_5GTF
ue->ue5gtfCb.mcs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
/*
- printf("reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n",
+ DU_LOG("\nINFO --> SCH : reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n",
reportediTbs, ueDl->laCb[cwIdx].cqiBasediTbs, ueDl->laCb[cwIdx].deltaiTbs,
iTbsNew, ue->ue5gtfCb.mcs, cwIdx);
*/
case TFU_DCI_FORMAT_B2:
{
- //printf(" RG_5GTF:: Pdcch filling with DCI format B2\n");
+ //DU_LOG("\nINFO --> SCH : RG_5GTF:: Pdcch filling with DCI format B2\n");
/* ToDo: Anoop */
break; /* case TFU_DCI_FORMAT_B2: */
}
#endif
break;
default:
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Allocator's icorrect "
+ DU_LOG("\nERROR --> SCH : Allocator's icorrect "
"dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
break;
}
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
//Currently hardcoding values here.
- //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
+ //DU_LOG("\nINFO --> SCH : Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
switch(rbAllocInfo->dciFormat)
{
case TFU_DCI_FORMAT_B1:
break;
}
default:
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId," 5GTF_ERROR Allocator's icorrect "
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR Allocator's incorrect "
"dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
break;
}
addedForScell += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
addedForScell1 += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
/*
- printf (" Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
+ DU_LOG("\nINFO --> SCH : Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
hqP->procId,
hqP->hqE->cell->cellId,
addedForScell,
addedForScell += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
addedForScell2 += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
/*
- printf (" Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
+ DU_LOG("\nINFO --> SCH : Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
hqP->procId,
hqP->hqE->cell->cellId,
addedForScell,
(rbAllocInfo->tbInfo[1].bytesAlloc << 3);
}
/*
- printf ("add DL TPT is %lu sfn:sf %d:%d \n", hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt ,
+ DU_LOG("\nINFO --> SCH : add DL TPT is %lu sfn:sf %d:%d \n", hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt ,
cell->crntTime.sfn,
cell->crntTime.slot);
*/
case TFU_DCI_FORMAT_B1:
case TFU_DCI_FORMAT_B2:
{
- // printf(" RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
+ // DU_LOG("\nINFO --> SCH : RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, \
pdcch, tpc);
break;
}
#endif
default:
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
break;
}
return;
{
/* Fixing DAI value - ccpu00109162 */
pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
else
{
pdcch->dci.u.format1bInfo.dai = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
else
{
pdcch->dci.u.format2Info.dai = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
else
{
pdcch->dci.u.format2AInfo.dai = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
cellUl->idx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
#ifdef UL_ADPT_DBG
- printf("idx %d cellUl->idx %d RGSCH_NUM_SUB_FRAMES_5G %d time(%d %d) \n",idx,cellUl->idx ,RGSCH_NUM_SUB_FRAMES_5G,cell->crntTime.sfn,cell->crntTime.slot);
+ DU_LOG("\nDEBUG --> SCH : idx %d cellUl->idx %d RGSCH_NUM_SUB_FRAMES_5G %d time(%d %d) \n",idx,cellUl->idx ,RGSCH_NUM_SUB_FRAMES_5G,cell->crntTime.sfn,cell->crntTime.slot);
#endif
/* Need to scheduler for after SCHED_DELTA */
/* UL allocation has been advanced by 1 subframe
/* take care of getting the correct subframe for feedback */
idx = (cellUl->idx - TFU_CRCIND_ULDELTA + RG_SCH_CMN_UL_NUM_SF);
#ifdef UL_ADPT_DBG
- printf("Finally setting cellUl->hqFdbkIdx[0] = %d TFU_CRCIND_ULDELTA %d RG_SCH_CMN_UL_NUM_SF %d\n",idx,TFU_CRCIND_ULDELTA,RG_SCH_CMN_UL_NUM_SF);
+ DU_LOG("\nDEBUG --> SCH : Finally setting cellUl->hqFdbkIdx[0] = %d TFU_CRCIND_ULDELTA %d RG_SCH_CMN_UL_NUM_SF %d\n",idx,TFU_CRCIND_ULDELTA,RG_SCH_CMN_UL_NUM_SF);
#endif
cellUl->hqFdbkIdx[0] = (idx % (RG_SCH_CMN_UL_NUM_SF));
cellUl->reTxIdx[0] = (uint8_t) idx;
#ifdef UL_ADPT_DBG
- printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
+ DU_LOG("\nDEBUG --> SCH : cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
#endif
/* RACHO: update cmn sched specific RACH variables,
* mainly the prachMaskIndex */
pdcch->dci.dciFormat = alloc->grnt.dciFrmt;
//Currently hardcoding values here.
- //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
+ //DU_LOG("\nINFO --> SCH : Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
switch(pdcch->dci.dciFormat)
{
case TFU_DCI_FORMAT_A1:
break;
}
default:
- RLOG1(L_ERROR," 5GTF_ERROR UL Allocator's icorrect "
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR UL Allocator's icorrect "
"dciForamt Fill RNTI:%d",alloc->rnti);
break;
}
static uint8_t rgSCHCmnGetRefreshDist(RgSchCellCb *cell,RgSchUeCb *ue)
{
uint8_t refOffst;
-#ifdef DEBUGP
- Inst inst = cell->instIdx;
-#endif
for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
{
{
cell->refreshUeCnt[refOffst]++;
ue->refreshOffset = refOffst;
- /* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst, cell->refreshUeCnt[refOffst]); */
+ /* DU_LOG("\nINFO --> SCH : UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst, cell->refreshUeCnt[refOffst]); */
return (refOffst);
}
}
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Allocation of refresh distribution failed\n"));
+ DU_LOG("\nERROR --> SCH : Allocation of refresh distribution failed\n");
/* We should not enter here normally, but incase of failure, allocating from last offset*/
cell->refreshUeCnt[refOffst-1]++;
ue->refreshOffset = refOffst-1;
if((rgSCHUtlAllocSBuf(sCell->instIdx,
(Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED\n");
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
}
if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE CFG FAILED\n");
return RFAILED;
}
{
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
+ DU_LOG("\nERROR --> SCH : DLFS UE config FAILED\n");
return RFAILED;
}
}
ret = rgSCHUhmHqEntInit(sCell, ue);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
+ DU_LOG("\nERROR --> SCH : SCELL UHM HARQ Ent Init "
"Failed for CRNTI:%d", ue->ueId);
return RFAILED;
}
if((rgSCHUtlAllocSBuf(sCell->instIdx,
(Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
+ DU_LOG("\nERROR --> SCH : SCELL Memory allocation FAILED"
"for CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
ret = rgSCHPwrUeSCellCfg(sCell, ue, sCellInfoCfg);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
+ DU_LOG("\nERROR --> SCH : Could not do "
"power config for UE CRNTI:%d",ue->ueId);
return RFAILED;
}
{
if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
return RFAILED;
}
{
if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
return RFAILED;
}
{
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
+ DU_LOG("\nERROR --> SCH : DLFS Scell del FAILED\n");
return RFAILED;
}
}
ue->ue5gtfCb.nxtCqiRiOccn.slot = 0;
ue->ue5gtfCb.rank = 1;
- printf("\nschd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
+ DU_LOG("\nINFO --> SCH : schd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
ue->ue5gtfCb.mcs,ue->ue5gtfCb.maxPrb);
ue5gtfGrp = &(cell->cell5gtfCb.ueGrp5gConf[ue->ue5gtfCb.BeamId]);
scheduling comes into picture */
if(ue5gtfGrp->beamBitMask & (1 << ue->ue5gtfCb.BeamId))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
return RFAILED;
}
ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
if((rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
}
*/
if((ueCfg->ueQosCfg.dlAmbr == 0) && (ueCfg->ueQosCfg.ueBr == 0))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
+ DU_LOG("\nERROR --> SCH : UL Ambr and DL Ambr are"
"configured as 0 for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
{
if ((cellSchd->apisEmtcDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
}
if((rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED"
"for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
(Data**)&(ue->ul.lcgArr[cnt].sch), (sizeof(RgSchCmnLcg)));
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
}
ret = rgSCHPwrUeCfg(cell, ue, ueCfg);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
+ DU_LOG("\nERROR --> SCH : Could not do "
"power config for UE CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
+ DU_LOG("\nERROR --> SCH : Could not do "
"SPS config for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisDlfs->rgSCHDlfsUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
+ DU_LOG("\nERROR --> SCH : DLFS UE config FAILED"
"for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
&& (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD10)
&& (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD20))
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unsupported periodic CQI "
+ DU_LOG("\nERROR --> SCH : Unsupported periodic CQI "
"reporting mode %d for old CRNIT:%d",
(int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
{
if (rgSCHPwrUeRecfg(cell, ue, ueRecfg) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
+ DU_LOG("\nERROR --> SCH : Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
return RFAILED;
}
}
/* Uplink Sched related Initialization */
if ((ueRecfg->ueQosRecfg.dlAmbr == 0) && (ueRecfg->ueQosRecfg.ueBr == 0))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
+ DU_LOG("\nERROR --> SCH : Ul Ambr and DL Ambr "
"configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
{
if ((cellSchCmn->apisEmtcUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
}
{
if ((cellSchCmn->apisUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
}
if ((cellSchCmn->apisDlfs->rgSCHDlfsUeRecfg(cell, ue, \
ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
}
/* Invoke re-configuration on SPS module */
if (rgSCHCmnSpsUeRecfg(cell, ue, ueRecfg, err) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
+ DU_LOG("\nERROR --> SCH : DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
return RFAILED;
}
#endif
/*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "Invalid configuration !: "
+ DU_LOG("\nERROR --> SCH : Invalid configuration !: "
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
/* Fix: MUE_PERTTI_DL syed validating Cell Configuration */
if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
+ DU_LOG("\nERROR --> SCH : FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
cellSch->dl.maxUePerDlSf,
cellSch->dl.maxUeNewTxPerTti);
return RFAILED;
/*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid configuration !: "
+ DU_LOG("\nERROR --> SCH : Invalid configuration !: "
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
/* Num of PUCCH RBs = puschRbStart*2 */
if (puschRbStart * 2 >= ulBw)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
+ DU_LOG("\nERROR --> SCH : No bw available for PUSCH");
return RFAILED;
}
if(gPrntPucchDet)
{
#ifndef ALIGN_64BIT
- printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
+ DU_LOG("\nDEBUG --> SCH : CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
#else
- printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
+ DU_LOG("\nDEBUG --> SCH : CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
#endif
}
if (puschRbStart*2 >= ulBw)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
+ DU_LOG("\nERROR --> SCH : No bw available for PUSCH");
return RFAILED;
}
/* Fix: MUE_PERTTI_UL syed validating Cell Configuration */
if (cellUl->maxAllocPerUlSf < cellUl->maxUeNewTxPerTti)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
+ DU_LOG("\nERROR --> SCH : FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
cellUl->maxAllocPerUlSf,
cellUl->maxUeNewTxPerTti);
return RFAILED;
ulUeInfo.ulAllocInfo), (cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc)));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
+ DU_LOG("\nERROR --> SCH : Memory allocation failed ");
return (ret);
}
}
if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
+ DU_LOG("\nERROR --> SCH : Invalid subband size %d", sbSize);
return RFAILED;
}
//Setting the subband size to 4 which is size of VRBG in 5GTF
maxSbPerUe = maxUlBwPerUe / sbSize;
if (maxSbPerUe == 0)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlCellInit(): "
"maxUlBwPerUe/sbSize is zero");
return RFAILED;
}
if ((!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->ulCmnCodeRate.ccchCqi))
|| (!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->trgUlCqi.trgCqi)))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlCellInit(): "
"Invalid cqi");
return RFAILED;
}
* Refer to 36.213-8.6.1 */
for (i = RG_SCH_CMN_UL_NUM_CQI - 1;i > 0; --i)
{
- RLOG_ARG2(L_INFO,DBG_CELLID,cell->cellId,
- "CQI %u:iTbs %u",
- i,
+ DU_LOG("\nINFO --> SCH : CQI %u:iTbs %u",i,
rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i]);
#ifdef MAC_SCH_STATS
/* ccpu00128489 ADD Update mcs in hqFailStats here instead of at CRC
iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
if (iTbs <= RGSCH_UL_16QAM_MAX_ITBS) /* corresponds to 16QAM */
{
- RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,
- "16 QAM CQI %u", i);
+ DU_LOG("\nINFO --> SCH : 16 QAM CQI %u", i);
cellUl->max16qamCqi = i;
break;
}
if(0 == cell->dynCfiCb.maxCfi)
{
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
- "Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
+ DU_LOG("\nERROR --> SCH : Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi,
cell->pucchCfg.maxPucchRb);
if (((ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(cell->sc.sch), (sizeof(RgSchCmnCell)))) != ROK))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "Memory allocation FAILED");
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
}
if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
{
err->errCause = RGSCHERR_SCH_CFG;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnRgrCellRecfg(): "
"Invalid cqi");
return RFAILED;
}
(Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnRgrLchCfg(): "
"SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
ret = rgSCHCmnValidateDlQos(&lcCfg->dlInfo.dlQos);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
+ DU_LOG("\nERROR --> SCH : rgSchCmnCrgLcCfg(): "
"DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
ret = rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "rgSchCmnRgrLchCfg(): "
+ DU_LOG("\nERROR --> SCH : rgSchCmnRgrLchCfg(): "
"SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
+ DU_LOG("\nERROR --> SCH : DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
}
if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
+ DU_LOG("\nERROR --> SCH : Qci, hence lc Priority change "
"not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
ret = rgSCHCmnSpsDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"SPS re-configuration not "
+ DU_LOG("\nERROR --> SCH : SPS re-configuration not "
"supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
}
}
/* Return the grabbed PDCCH */
rgSCHUtlPdcchPut(cell, &subFrm->pdcchInfo, raRspAlloc->pdcch);
subFrm->raRsp[rarCnt].pdcch = NULLP;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnRaRspAlloc(): "
"Not even one RaReq.");
return;
}
}
- RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
- "RNTI:%d Scheduled RAR @ (%u,%u) ",
+ DU_LOG("\nDEBUG --> SCH : RNTI:%d Scheduled RAR @ (%u,%u) ",
raRspAlloc->rnti,
cell->crntTime.sfn,
cell->crntTime.slot);
pcch = rgSCHDbmGetPcch(cell);
if(pcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnDlBcchPcchFnlz( ): "
"No Pcch Present");
return;
}
rgSCHUhmGetAvlHqProc(cell, ue, &proc);
if (proc == NULLP)
{
- //printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
+ //DU_LOG("\nINFO --> SCH : UE [%d] HQ Proc unavailable\n", ue->ueId);
return RFAILED;
}
#endif
pdcch = rgSCHCmnPdcchAllocCrntSf(cell, ue);
if(pdcch == NULLP)
{
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
+ DU_LOG("\nDEBUG --> SCH : rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
return RFAILED;
}
gUl5gtfPdcchSchd++;
if((sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart > MAX_5GTF_VRBG)
|| (sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated > MAX_5GTF_VRBG))
{
- printf("5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
, sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated);
int *p=NULLP;
*p = 10;
}
if (alloc == NULLP)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
return RFAILED;
}
retxAlloc = rgSCHCmnUlGetUlAlloc(cell, sf, alloc->numSb);
if (retxAlloc == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
alloc->rnti);
return;
}
}
else
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "Error! holeDb sanity check failed");
+ DU_LOG("\nERROR --> SCH : holeDb sanity check failed");
}
}
}
#if (ERRCLASS & ERRCLS_DEBUG)
if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnTmrExpiry(): Invalid "
"timer event CRNTI:%d",ue->ueId);
return RFAILED;
}
if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
{
cellSch->apisEmtcDl->rgSCHDlDedBoUpd(cell, ue, svc);
- //printf("rgSCHEMTCDlDedBoUpd\n");
+ //DU_LOG("\nINFO --> SCH : rgSCHEMTCDlDedBoUpd\n");
}
else
#endif
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode10Info.u.ri,ue->ueId);
return;
}
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode11Info.u.ri,ue->ueId);
return;
}
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode20Info.u.ri,ue->ueId);
return;
}
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode21Info.u.ri,ue->ueId);
return;
}
break;
default:
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unknown CQI Mode %d",
+ DU_LOG("\nERROR --> SCH : Unknown CQI Mode %d of UE %d",
pucchCqi->mode,ue->ueId);
/* ccpu00117452 - MOD - Changed macro name from
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
puschCqi->ri.val,ue->ueId);
return;
}
break;
default:
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Unknown CQI Mode %d CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Unknown CQI Mode %d CRNTI:%d",
puschCqi->mode,ue->ueId);
/* CQI decoding failed revert the RI to previous value */
if ((puschCqi->ri.pres == PRSNT_NODEF) &&
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "<TA>TA duplicate entry attempt failed: UEID:%u",
+ DU_LOG("\nERROR --> SCH : <TA>TA duplicate entry attempt failed: UEID:%u",
ue->ueId);
}
}
hole);
if (alloc == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
return RFAILED;
}
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
/* KWork fix */
if (grnt == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx, "Failed to get"
+ DU_LOG("\nERROR --> SCH : Failed to get"
"the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
return;
}
/* This should never happen */
if (dstAlloc == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
+ DU_LOG("\nERROR --> SCH : CRNTI:%d "
"rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
srcAlloc->rnti);
return;
{
nxtAlloc = rgSCHUtlUlAllocNxt(sf, alloc);
#ifdef UL_ADPT_DBG
- printf("rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.slot,alloc->hqProc->remTx, alloc->grnt.hqProcId);
+ DU_LOG("\nDEBUG --> SCH : rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.slot,alloc->hqProc->remTx, alloc->grnt.hqProcId);
#endif
alloc->hqProc->rcvdCrcInd = TRUE;
if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
alloc->hqProc->alloc = NULLP;
alloc->hqProc->ulSfIdx = RGSCH_INVALID_INFO;
#ifdef UL_ADPT_DBG
- printf("Adding Harq Proc Id in the retx list hqProcId %d \n",alloc->grnt.hqProcId);
+ DU_LOG("\nDEBUG --> SCH : Adding Harq Proc Id in the retx list hqProcId %d \n",alloc->grnt.hqProcId);
#endif
cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
if(alloc == NULLP)
{
rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "UL Alloc fail for msg3 retx for rnti: %d\n",
+ DU_LOG("\nERROR --> SCH : UL Alloc fail for msg3 retx for rnti: %d\n",
proc->reTxAlloc.rnti);
return (FALSE);
}
else /* Intg fix */
{
rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "Num SB not suffiecient for adap retx for rnti: %d",
+ DU_LOG("\nERROR --> SCH : Num SB not suffiecient for adap retx for rnti: %d",
proc->reTxAlloc.rnti);
return (FALSE);
}
if (cellSch->dl.isDlFreqSel)
{
- printf("5GTF_ERROR DLFS SCH Enabled\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR DLFS SCH Enabled\n");
cellSch->apisDlfs->rgSCHDlfsAllocRb(cell, allocInfo);
}
else
RgSchSfBeamInfo *beamInfo = &(dlSf->sfBeamInfo[0]);
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
- printf("5GTF_ERROR vrbg allocated > 25\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR vrbg allocated > 25\n");
return RFAILED;
}
allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
#endif
- printf("\n[%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
+ DU_LOG("\nINFO --> SCH : [%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
__func__,allocInfo->tbInfo[0].bytesAlloc,allocInfo->vrbgReq);
return ROK;
if (dlSf->bw <= dlSf->bwAlloced)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
return FALSE;
}
if (dlSf->sfrTotalPoolInfo.ccBwFull == TRUE)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
return FALSE;
}
if ((dlSf->sfrTotalPoolInfo.ceBwFull == TRUE) && (isUeCellEdge))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
return FALSE;
}
if (dlSf->bw <= dlSf->bwAlloced)
{
- RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : (%d:%d)FAILED CRNTI:%d",
dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
return (FALSE);
}
dlSf->lstRbgDfct = 1;
}
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : FAILED for CRNTI:%d",
allocInfo->rnti);
- printf ("RB Alloc failed for LAA TB type 0\n");
+ DU_LOG("\nERROR --> SCH : RB Alloc failed for LAA TB type 0\n");
return (FALSE);
}
return (TRUE);
}
else
{
- printf ("RB Alloc failed for LAA TB type 2\n");
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : RB Alloc failed for LAA TB type 2\n");
+ DU_LOG("\nERROR --> SCH : FAILED for CRNTI:%d",allocInfo->rnti);
return (FALSE);
}
/* Fix: Number of RBs in case of RETX should be same as
return (TRUE);
}
}
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : FAILED for CRNTI:%d",allocInfo->rnti);
return (FALSE);
}
#endif
/* KWork fix */
if (sfrCCPool1 == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
return RFAILED;
}
if (rntpPtr == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnBuildRntpInfo():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnBuildRntpInfo():"
"rntpPtr can't be NULLP (Memory Allocation Failed)");
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
sizeof(RgrLoadInfIndInfo));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
+ DU_LOG("\nERROR --> SCH : Could not "
"allocate memory for sending LoadInfo");
return;
}
ret = rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf);
if(ret == RFAILED)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsDsfrRntpComp():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsDsfrRntpComp():"
"rgSCHUtlRgrLoadInfInd() returned RFAILED");
}
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
- RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
- "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
ue->ueId);
- printf("5GTF_ERROR vrbg allocated > 25\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR vrbg allocated > 25\n");
return RFAILED;
}
{
/* Returning ROK since PDCCH might be available for another UE and
* further allocations could be done */
- RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
- "5GTF_ERROR : PDCCH allocation failed :ue (%u)",
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR : PDCCH allocation failed :ue (%u)",
ue->ueId);
- printf("5GTF_ERROR PDCCH allocation failed\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR PDCCH allocation failed\n");
return RFAILED;
}
#ifdef RG_5GTF
RgSchSfBeamInfo *beamInfo = &(dlSf->sfBeamInfo[0]);
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
- RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
- "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
raCb->ue->ueId);
- printf("5GTF_ERROR vrbg allocated > 25\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR vrbg allocated > 25\n");
return RFAILED;
}
#endif
cell->tenbStats->sch.dl5gtfRbAllocFail++;
#endif
/* Allocation failed : Add UE to the non-scheduled list */
- printf("5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
}
}
/* Allocate for MSG4 retransmissions */
if (allocInfo->msg4Alloc.msg4RetxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), TRUE);
}
/* Assuming all the nodes in the list need allocations: rbsReq is valid */
if (allocInfo->msg4Alloc.msg4TxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), FALSE);
}
#ifdef RGR_V1
* retransmissions */
if (allocInfo->ccchSduAlloc.ccchSduRetxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), TRUE);
}
/* Allocate for CCCH SDU (received after guard timer expiry) transmissions */
if (allocInfo->ccchSduAlloc.ccchSduTxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), FALSE);
}
#endif
{
break;
}
- printf("5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
// if ((rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo)) != ROK)
if ((rgSCHCmnNonDlfsCmnRbAllocRar(cell, reqAllocInfo)) != ROK)
{
/* Allocate for RETX+TX UEs */
if(allocInfo->dedAlloc.txRetxHqPLst.count)
{
- printf("5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
+ DU_LOG("\nDEBUG --> SCH : 5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
&(allocInfo->dedAlloc.txRetxHqPLst),
&(allocInfo->dedAlloc.schdTxRetxHqPLst),
cmnCell->dl.maxUePerDlSf)
{
#ifndef ALIGN_64BIT
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
+ DU_LOG("\nERROR --> SCH : UEs selected by"
" scheduler exceed maximumUePerDlSf(%u)tx-retx %ld retx %ld tx %ld\n",
cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
allocInfo->dedAlloc.retxHqPLst.count,
- allocInfo->dedAlloc.txHqPLst.count));
+ allocInfo->dedAlloc.txHqPLst.count);
#else
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
+ DU_LOG("\nERROR --> SCH : UEs selected by"
" scheduler exceed maximumUePerDlSf(%u)tx-retx %d retx %d tx %d\n",
cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
allocInfo->dedAlloc.retxHqPLst.count,
- allocInfo->dedAlloc.txHqPLst.count));
+ allocInfo->dedAlloc.txHqPLst.count);
#endif
}
}
/* LTE_ADV_FLAG_REMOVED_START */
if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
{
- printf("5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
rgSCHCmnNonDlfsDsfrRntpComp(cell, allocInfo->dedAlloc.dedDlSf);
}
/* LTE_ADV_FLAG_REMOVED_END */
(proc->tbInfo[1].state == HQ_TB_NACKED))
{
#ifdef LAA_DBG_LOG
- printf ("RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
+ DU_LOG("\nDEBUG --> SCH : RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
#endif
/* Both TBs require RETX allocation */
rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo,\
if (frthrScp)
{
#ifdef LAA_DBG_LOG
- printf ("TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
+ DU_LOG("\nDEBUG --> SCH : TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
#endif
ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
&numRb, effBo);
)
{
#if (ERRCLASS & ERRCLS_DEBUG)
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
return;
}
)
{
#if (ERRCLASS & ERRCLS_DEBUG)
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
return;
}
(allocInfo->tbInfo[1].bytesReq >= ueDl->maxTbSz/8) ||
(allocInfo->rbsReq >= ueDl->maxRb))
{
- RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
- "rgSCHCmnDlAllocRb(): UEs max allocation exceed");
+ DU_LOG("\nDEBUG --> SCH : rgSCHCmnDlAllocRb(): UEs max allocation exceed");
return RFAILED;
}
if(*numRb <= 3)
{
- RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
+ DU_LOG("\nERROR --> SCH : Number of RBs [%d] are less than or equal to 3",*numRb);
return RFAILED;
}
}
if(*numRb <= 3)
{
- RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
+ DU_LOG("\nERROR --> SCH : Number of RBs [%d] are less than or equal to 3",*numRb);
return RFAILED;
}
}
/* LTE_ADV_FLAG_REMOVED_START */
if(cell->siCb.siCtx.retxCntRem)
{
- RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,(ErrVal)cell->siCb.siCtx.siId,
- "rgSCHDlSiSched(): SI not scheduled and window expired");
+ DU_LOG("\nERROR --> SCH : rgSCHDlSiSched(): SI not scheduled and window expired");
}
/* LTE_ADV_FLAG_REMOVED_END */
if(cell->siCb.siCtx.warningSiFlag == TRUE)
* exceeds the available */
if (rb > sf->bw - sf->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDlSiSched(): "
+ DU_LOG("\nERROR --> SCH : rgSCHDlSiSched(): "
"BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
return;
}
sizeof(RgrStaIndInfo));
if (retVal != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
+ DU_LOG("\nERROR --> SCH : Could not "
"allocate memory for sending StaInd CRNTI:%d",ue->ueId);
return (retVal);
}
{
uint32_t idx = 0;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
-#ifdef DEBUGP
- Inst inst = cell->instIdx;
-#endif
for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
{
if (cellSch->apisEmtcUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure");
}
}
{
if (cellSch->apisUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure");
}
}
}
{
ul5gtfsidDlAlreadyMarkUl++;
/*
- printf("ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n",
+ DU_LOG("\nINFO --> SCH : ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n",
ul5gtfsidDlAlreadyMarkUl, cellSch->dl.time.sfn,
cellSch->dl.time.slot);
*/
@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"
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;
}
/* 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;
}
if (ret != ROK)
{
- 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;
}
/*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;
}
#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;
}
}