X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Frg_sch_utl.c;h=0e0e037298f6fa77c262b2c4a0865233eb1343d3;hb=53b8b63c2fff0f2adbf2c66ed182a32bb4682bf7;hp=30a9142b278a11c103effc0f7ac330515a5dc7ef;hpb=27d8d877e837c2879a452538cdbe81afe48bed62;p=o-du%2Fl2.git

diff --git a/src/5gnrsch/rg_sch_utl.c b/src/5gnrsch/rg_sch_utl.c
index 30a9142b2..0e0e03729 100755
--- a/src/5gnrsch/rg_sch_utl.c
+++ b/src/5gnrsch/rg_sch_utl.c
@@ -32,23 +32,19 @@
 @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 */
@@ -313,17 +309,7 @@ for proper NULLP assignment*/
 *       File:  rg_sch_utl.c
 *
 */
-#ifdef ANSI
-F64 rgSCHUtlPower
-(
-F64    x,
-F64    n
-)
-#else
-F64 rgSCHUtlPower(x, n)
-F64    x;
-F64    n;
-#endif
+F64 rgSCHUtlPower(F64 x,F64 n)
 {
  if( n==0 )
  {
@@ -353,21 +339,7 @@ F64    n;
 *       File:  rg_sch_utl.c
 *
 */
-#ifdef ANSI
-uint32_t rgSCHUtlParse
-(
-uint8_t     *buff,
-uint8_t     startPos,
-uint8_t     endPos,
-uint8_t     buffSize
-)
-#else
-uint32_t rgSCHUtlParse(buff, startPos, endPos, buffSize)
-uint8_t     *buff;
-uint8_t     startPos;
-uint8_t     endPos;
-uint8_t     buffSize;
-#endif
+uint32_t rgSCHUtlParse(uint8_t *buff,uint8_t startPos,uint8_t endPos,uint8_t buffSize)
 {
  uint8_t pointToChar,pointToEnd, loop;
  uint8_t size =  endPos - startPos;
@@ -399,17 +371,7 @@ uint8_t     buffSize;
 *       File:  rg_sch_utl.c
 *
 */
-#ifdef ANSI
-uint8_t rgSCHUtlFindDist
-(
-uint16_t    crntTime,
-uint16_t    tempIdx
-)
-#else
-uint8_t rgSCHUtlFindDist(crntTime, tempIdx)
-uint16_t    crntTime;
-uint16_t    tempIdx;
-#endif
+uint8_t rgSCHUtlFindDist(uint16_t crntTime,uint16_t tempIdx)
 {
  uint8_t  dist =0;
  /* ccpu00137113- Distance is not estimated properly if the periodicity is 
@@ -456,21 +418,13 @@ uint16_t    tempIdx;
  *         -#   FALSE otherwise
  *
  **/
-#ifdef ANSI
 Bool rgSCHUtlPdcchAvail
 (
-RgSchCellCb             *cell,
-RgSchPdcchInfo          *pdcchInfo,
-CmLteAggrLvl            aggrLvl,
-RgSchPdcch              **pdcch
+RgSchCellCb    *cell,
+RgSchPdcchInfo *pdcchInfo,
+CmLteAggrLvl   aggrLvl,
+RgSchPdcch     **pdcch
 )
-#else
-Bool rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, pdcch)
-RgSchCellCb             *cell;
-RgSchPdcchInfo          *pdcchInfo;
-CmLteAggrLvl            aggrLvl;
-RgSchPdcch              **pdcch;
-#endif
 {
    uint8_t	       *byte;
    uint16_t		offset;
@@ -581,19 +535,7 @@ RgSchPdcch              **pdcch;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlPdcchPut
-(
-RgSchCellCb                *cell,
-RgSchPdcchInfo             *pdcchInfo,
-RgSchPdcch                 *pdcch
-)
-#else
-Void rgSCHUtlPdcchPut(cell, pdcchInfo, pdcch)
-RgSchCellCb                *cell;
-RgSchPdcchInfo             *pdcchInfo;
-RgSchPdcch                 *pdcch;
-#endif
+Void rgSCHUtlPdcchPut(RgSchCellCb *cell,RgSchPdcchInfo *pdcchInfo,RgSchPdcch *pdcch)
 {
    uint8_t              *byte;
    uint8_t              offset;
@@ -649,19 +591,7 @@ RgSchPdcch                 *pdcch;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlPdcchInit
-(
-RgSchCellCb             *cell,
-RgSchDlSf               *subFrm,
-uint16_t                nCce
-)
-#else
-Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
-RgSchCellCb             *cell;
-RgSchDlSf               *subFrm;
-uint16_t                nCce;
-#endif
+Void rgSCHUtlPdcchInit(RgSchCellCb *cell,RgSchDlSf *subFrm,uint16_t nCce)
 {
    RgSchPdcchInfo       *pdcchInfo;
    RgSchPdcch           *pdcch;
@@ -732,17 +662,7 @@ uint16_t                nCce;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSchSFRTotalPoolFree
-(
- RgSchSFRTotalPoolInfo  *sfrTotalPoolInfo,
- RgSchCellCb             *cell
- )
-#else
-Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
-   RgSchSFRTotalPoolInfo  *sfrTotalPoolInfo;
-   RgSchCellCb             *cell;
-#endif
+Void rgSchSFRTotalPoolFree(RgSchSFRTotalPoolInfo *sfrTotalPoolInfo,RgSchCellCb *cell)
 {
    CmLListCp   *l;
    CmLList     *n;
@@ -793,17 +713,7 @@ Void rgSchSFRTotalPoolFree(sfrTotalPoolInfo, cell)
  *  @return  Void
  *
  **/
-#ifdef ANSI
-S16 rgSchSFRTotalPoolInit
-(
- RgSchCellCb             *cell,
- RgSchDlSf               *sf
- )
-#else
-static Void rgSchSFRTotalPoolInit(cell, sf)
-   RgSchCellCb             *cell;
-   RgSchDlSf               *sf;
-#endif
+S16 rgSchSFRTotalPoolInit(RgSchCellCb *cell,RgSchDlSf *sf)
 {      
    /*  Initialise the variables */
    RgSchSFRPoolInfo *sfrCCPool;
@@ -825,8 +735,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
    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;
    }
@@ -834,8 +743,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
    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;
    }
@@ -868,8 +776,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
    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;
    }
@@ -877,8 +784,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
    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;
    }
@@ -930,8 +836,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
       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;
       }
@@ -939,8 +844,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
       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;
       }
@@ -986,19 +890,7 @@ static Void rgSchSFRTotalPoolInit(cell, sf)
  *  @return  S16
  *
  **/
-#ifdef ANSI
-S16   rgSchDSFRRntpInfoInit 
-(
- TknStrOSXL              *rntpPtr,
- RgSchCellCb             *cell,
- uint16_t                bw
- )
-#else
-static Void rgSchDSFRRntpInfoInit(rntpPtr, cell, bw)
-   TknStrOSXL              *rntpPtr;
-   RgSchCellCb             *cell;
-   uint16_t                bw;
-#endif
+S16   rgSchDSFRRntpInfoInit(TknStrOSXL  *rntpPtr,RgSchCellCb *cell,uint16_t bw)
 {   
    Inst inst = cell->instIdx;
    uint16_t len;
@@ -1013,7 +905,7 @@ static Void rgSchDSFRRntpInfoInit(rntpPtr, cell, bw)
    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;
    }
 
@@ -1033,19 +925,7 @@ static Void rgSchDSFRRntpInfoInit(rntpPtr, cell, bw)
  *  @return  S16
  *
  **/
-#ifdef ANSI
-S16   rgSchDSFRRntpInfoFree 
-(
- TknStrOSXL              *rntpPtr,
- RgSchCellCb             *cell,
- uint16_t                bw
- )
-#else
-static Void rgSchDSFRRntpInfoFree(rntpPtr, cell, bw)
-   TknStrOSXL              *rntpPtr;
-   RgSchCellCb             *cell;
-   uint16_t                bw;
-#endif
+S16   rgSchDSFRRntpInfoFree(TknStrOSXL *rntpPtr,RgSchCellCb *cell,uint16_t bw)
 {   
    Inst inst = cell->instIdx;
    uint16_t len;
@@ -1076,17 +956,7 @@ static Void rgSchDSFRRntpInfoFree(rntpPtr, cell, bw)
  *  @return  Void
  *
  **/
-#ifdef ANSI
-static Void rgSchSFRResetPoolVariables
-(
- RgSchCellCb             *cell,
- RgSchSFRPoolInfo        *pool
- )
-#else
-static Void rgSchSFRResetPoolVariables(cell, pool)
-   RgSchCellCb             *cell;
-   RgSchSFRPoolInfo *pool;
-#endif
+static Void rgSchSFRResetPoolVariables(RgSchCellCb *cell,RgSchSFRPoolInfo *pool)
 {
 
    pool->bwAlloced  = 0;
@@ -1116,17 +986,7 @@ static Void rgSchSFRResetPoolVariables(cell, pool)
  *  @return  Void
  *
  **/
-#ifdef ANSI
-static Void rgSCHSFRUtlTotalPoolReset
-(
- RgSchCellCb             *cell,
- RgSchDlSf               *subFrm
- )
-#else
-static Void rgSCHSFRUtlTotalPoolReset(cell, subFrm)
-   RgSchCellCb             *cell;
-   RgSchDlSf               *subFrm;
-#endif
+static Void rgSCHSFRUtlTotalPoolReset(RgSchCellCb *cell,RgSchDlSf *subFrm)
 {
    RgSchSFRTotalPoolInfo *totalPoolInfo = &subFrm->sfrTotalPoolInfo;
    CmLListCp    *ccPool = &totalPoolInfo->ccPool;
@@ -1188,45 +1048,25 @@ static Void rgSCHSFRUtlTotalPoolReset(cell, subFrm)
  *      -# RFAILED
  **/
 #ifdef LTE_TDD
-#ifdef ANSI
 S16 rgSCHUtlAddPhich
 (
-RgSchCellCb             *cell,
-CmLteTimingInfo         frm,
-uint8_t                      hqFeedBack,
-uint8_t                      nDmrs,
-uint8_t                      rbStart,
-uint8_t                      iPhich
+RgSchCellCb     *cell,
+CmLteTimingInfo frm,
+uint8_t         hqFeedBack,
+uint8_t         nDmrs,
+uint8_t         rbStart,
+uint8_t         iPhich
 )
 #else
-S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
-RgSchCellCb             *cell;
-CmLteTimingInfo         frm;
-uint8_t                      hqFeedBack;
-uint8_t                      nDmrs;
-uint8_t                      rbStart;
-uint8_t                      iPhich;
-#endif
-#else
-#ifdef ANSI
 S16 rgSCHUtlAddPhich
 (
-RgSchCellCb             *cell,
-CmLteTimingInfo         frm,
-uint8_t                 hqFeedBack,
-uint8_t                 nDmrs,
-uint8_t                 rbStart,
-Bool                    isForMsg3
+RgSchCellCb     *cell,
+CmLteTimingInfo frm,
+uint8_t         hqFeedBack,
+uint8_t         nDmrs,
+uint8_t         rbStart,
+Bool            isForMsg3
 )
-#else
-S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
-RgSchCellCb             *cell;
-CmLteTimingInfo         frm;
-uint8_t                 hqFeedBack;
-uint8_t                 nDmrs;
-uint8_t                 rbStart;
-Bool                    isForMsg3;
-#endif
 #endif
 {
    S16                ret;
@@ -1239,7 +1079,7 @@ Bool                    isForMsg3;
 
    if(ret != ROK)
    {
-      RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, " rgSCHUtlAddPhich(): "
+      DU_LOG("\nERROR  -->  SCH : rgSCHUtlAddPhich(): "
                "Allocation of RgSchPhich failed");
       return RFAILED;
    }
@@ -1269,17 +1109,7 @@ Bool                    isForMsg3;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-static Void rgSCHUtlPhichReset
-(
-RgSchCellCb                *cell,
-RgSchDlSf                  *subFrm
-)
-#else
-static Void rgSCHUtlPhichReset(cell, subFrm)
-RgSchCellCb                *cell;
-RgSchDlSf                  *subFrm;
-#endif
+static Void rgSCHUtlPhichReset(RgSchCellCb *cell,RgSchDlSf *subFrm)
 {
    RgSchPhichInfo          *phichInfo;
    RgSchPhich              *phich;
@@ -1313,17 +1143,7 @@ RgSchDlSf                  *subFrm;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-RgSchDlSf* rgSCHUtlSubFrmGet
-(
-RgSchCellCb            *cell,
-CmLteTimingInfo        frm
-)
-#else
-RgSchDlSf* rgSCHUtlSubFrmGet(cell, frm)
-RgSchCellCb            *cell;
-CmLteTimingInfo        frm;
-#endif
+RgSchDlSf* rgSCHUtlSubFrmGet(RgSchCellCb *cell,CmLteTimingInfo frm)
 {
    RgSchDlSf            *sf;
    uint8_t               dlIdx;
@@ -1361,17 +1181,7 @@ CmLteTimingInfo        frm;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlSubFrmPut
-(
-RgSchCellCb            *cell,
-RgSchDlSf              *sf
-)
-#else
-Void rgSCHUtlSubFrmPut(cell, sf)
-RgSchCellCb            *cell;
-RgSchDlSf              *sf;
-#endif
+Void rgSCHUtlSubFrmPut(RgSchCellCb *cell,RgSchDlSf *sf)
 {
    uint8_t                  i;
    uint8_t                  noRaRsps;
@@ -1483,20 +1293,12 @@ RgSchDlSf              *sf;
  *  @return  uint8_t
  *
  **/
-#ifdef ANSI
-uint8_t rgSCHUtlLog32bitNbase2
-(
-uint32_t               n
-)
-#else
-uint8_t rgSCHUtlLog32bitNbase2(n)
-uint32_t               n;
-#endif
+uint8_t rgSCHUtlLog32bitNbase2(uint32_t n)
 {
-   uint32_t            b[] = {0x2, 0xc, 0xf0, 0xff00, 0xffff0000};
-   uint32_t            s[] = {1, 2, 4, 8, 16};
-   S16                 i;
-   uint8_t             ret = 0;
+   uint32_t  b[] = {0x2, 0xc, 0xf0, 0xff00, 0xffff0000};
+   uint32_t  s[] = {1, 2, 4, 8, 16};
+   S16       i;
+   uint8_t   ret = 0;
 
    for (i=4; i >= 0; i--)
    {
@@ -1528,19 +1330,7 @@ uint32_t               n;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlRelPdcchFbk
-(
-RgSchCellCb        *cell,
-RgSchUeCb          *ue,
-uint8_t               isAck
-)
-#else
-Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
-RgSchCellCb        *cell;
-RgSchUeCb          *ue;
-uint8_t               isAck;
-#endif
+Void rgSCHUtlDlRelPdcchFbk(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t isAck)
 {
    cell->sc.apis->rgSCHDlRelPdcchFbk(cell, ue, isAck);
    return;
@@ -1564,17 +1354,7 @@ uint8_t               isAck;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlProcAck
-(
-RgSchCellCb        *cell,
-RgSchDlHqProcCb    *hqP
-)
-#else
-Void rgSCHUtlDlProcAck(cell, hqP)
-RgSchCellCb        *cell;
-RgSchDlHqProcCb    *hqP;
-#endif
+Void rgSCHUtlDlProcAck(RgSchCellCb *cell,RgSchDlHqProcCb *hqP)
 {
    cell->sc.apis->rgSCHDlProcAck(cell, hqP);
    return;
@@ -1595,17 +1375,7 @@ RgSchDlHqProcCb    *hqP;
  *  @param[out] RgSchErrInfo  *err
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlHdlCrntiCE
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue
-)
-#else
-Void rgSCHUtlHdlCrntiCE(cell, ue)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-#endif
+Void rgSCHUtlHdlCrntiCE(RgSchCellCb  *cell,RgSchUeCb *ue)
 {
 
    cell->sc.apis->rgSCHHdlCrntiCE(cell, ue);
@@ -1631,21 +1401,7 @@ RgSchUeCb    *ue;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static uint16_t rgSCHUtlCalcTotalRegs
-(
-uint8_t    bw,
-uint8_t    cfi,
-uint8_t    numAntna,
-Bool  isEcp
-)
-#else
-static uint16_t rgSCHUtlCalcTotalRegs(bw, cfi, numAntna, isEcp)
-uint8_t    bw;
-uint8_t    cfi;
-uint8_t    numAntna;
-Bool  isEcp;
-#endif
+static uint16_t rgSCHUtlCalcTotalRegs(uint8_t bw,uint8_t cfi,uint8_t numAntna,Bool  isEcp)
 {
    uint16_t regs = 0;
 
@@ -1697,17 +1453,7 @@ Bool  isEcp;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static uint16_t rgSCHUtlCalcPhichRegs
-(
-uint8_t bw,
-uint8_t ng6
-)
-#else
-static uint16_t rgSCHUtlCalcPhichRegs(bw, ng6)
-uint8_t bw;
-uint8_t ng6;
-#endif
+static uint16_t rgSCHUtlCalcPhichRegs(uint8_t bw,uint8_t ng6)
 {
    /* ccpu00115330: Corrected the calculation for number of PHICH groups*/
    return (RGSCH_CEIL((bw * ng6) ,(8 * 6)) * RGSCH_NUM_REG_PER_PHICH_GRP);
@@ -1736,30 +1482,12 @@ uint8_t ng6;
  *  @return     N_cce (uint8_t)
  *
  **/
-#ifdef ANSI
-uint8_t rgSCHUtlCalcNCce
-(
-uint8_t            bw,
-RgrPhichNg    ng,
-uint8_t            cfi,
-uint8_t            mPhich,
-uint8_t            numAntna,
-Bool          isEcp
-)
-#else
-uint8_t rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
-uint8_t             bw;
-RgrPhichNg     ng;
-uint8_t             cfi;
-uint8_t             mPhich;
-uint8_t             numAntna;
-Bool           isEcp;
-#endif
+uint8_t rgSCHUtlCalcNCce(uint8_t bw,RgrPhichNg ng,uint8_t cfi,uint8_t mPhich,uint8_t numAntna,Bool isEcp)
 {
-   uint16_t         totalRegs;
-   uint16_t         phichRegs;
-   uint16_t         cceRegs;
-   uint8_t          ng6;
+   uint16_t totalRegs;
+   uint16_t phichRegs;
+   uint16_t cceRegs;
+   uint8_t  ng6;
 
    /*ccpu00116757-  removed check for (ERRCLASS & ERRCLS_DEBUG)*/
 
@@ -1808,28 +1536,12 @@ Bool           isEcp;
  *  @return     N_cce (uint8_t)
  *
  **/
-#ifdef ANSI
-uint8_t rgSCHUtlCalcNCce
-(
-uint8_t       bw,
-RgrPhichNg    ng,
-uint8_t       cfi,
-uint8_t       numAntna,
-Bool          isEcp
-)
-#else
-uint8_t rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
-uint8_t        bw;
-RgrPhichNg     ng;
-uint8_t        cfi;
-uint8_t        numAntna;
-Bool           isEcp;
-#endif
+uint8_t rgSCHUtlCalcNCce(uint8_t bw,RgrPhichNg ng,uint8_t cfi,uint8_t numAntna,Bool isEcp)
 {
-   uint16_t         totalRegs;
-   uint16_t         phichRegs;
-   uint16_t         cceRegs;
-   uint8_t          ng6;
+   uint16_t totalRegs;
+   uint16_t phichRegs;
+   uint16_t cceRegs;
+   uint8_t  ng6;
 
    /*ccpu00116757-  removed check for (ERRCLASS & ERRCLS_DEBUG)*/
 
@@ -1875,35 +1587,9 @@ Bool           isEcp;
  *  @return  S16
  **/
 #ifdef LTE_TDD
-#ifdef ANSI
-S16 rgSCHUtlGetPhichInfo
-(
-RgSchUlHqProcCb   *hqProc,
-uint8_t           *rbStartRef,
-uint8_t           *nDmrsRef,
-uint8_t           *iPhich
-)
-#else
-S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
-RgSchUlHqProcCb   *hqProc;
-uint8_t           *rbStartRef;
-uint8_t           *nDmrsRef;
-uint8_t           *iPhich;
-#endif
-#else
-#ifdef ANSI
-S16 rgSCHUtlGetPhichInfo
-(
-RgSchUlHqProcCb   *hqProc,
-uint8_t           *rbStartRef,
-uint8_t           *nDmrsRef
-)
+S16 rgSCHUtlGetPhichInfo(RgSchUlHqProcCb *hqProc,uint8_t *rbStartRef,uint8_t *nDmrsRef,uint8_t *iPhich)
 #else
-S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
-RgSchUlHqProcCb   *hqProc;
-uint8_t           *rbStartRef;
-uint8_t           *nDmrsRef;
-#endif
+S16 rgSCHUtlGetPhichInfo(RgSchUlHqProcCb *hqProc,uint8_t *rbStartRef,uint8_t *nDmrsRef)
 #endif
 {
 /* ACC-TDD */
@@ -1947,7 +1633,6 @@ uint8_t           *nDmrsRef;
  *  @param[out] uint8_t             *hqPId
  *  @return  S16
  **/
-#ifdef ANSI
 S16 rgSCHUtlAllocRcptInfo
 (
 RgSchUlAlloc   *alloc,
@@ -1963,23 +1648,6 @@ uint8_t        *nDmrs,
 Bool           *ndi,
 uint8_t        *hqPId
 )
-#else
-S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
-                                 rvRef, size, modType, isRtx, nDmrs, ndi,
-                                 hqPId)
-RgSchUlAlloc   *alloc;
-CmLteRnti      *rnti;
-uint8_t        *iMcsRef;
-uint8_t        *rbStartRef;
-uint8_t        *numRbRef;
-uint8_t        *rvRef;
-uint16_t       *size;
-TfuModScheme   *modType;
-Bool           *isRtx;
-uint8_t        *nDmrs;
-Bool           *ndi;
-uint8_t        *hqPId;
-#endif
 {
    /* Modulation order for 16qam UEs would be
     * min(4,modulation order in grant). Please refer to 36.213-8.6.1*/
@@ -1996,8 +1664,7 @@ uint8_t        *hqPId;
    {
       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; 
       }
@@ -2044,21 +1711,7 @@ uint8_t        *hqPId;
  *  @param[out] TfuModScheme   *modType
  *  @return  S16
  **/
-#ifdef ANSI
-S16 rgSCHUtlAllocRcptInfo
-(
-RgSchCellCb             *cell,
-RgSchUlAlloc            *alloc,
-CmLteTimingInfo         *timeInfo,
-TfuUeUlSchRecpInfo      *recpReq
-)
-#else
-S16 rgSCHUtlAllocRcptInfo(cell, alloc, timeInfo, recpReq)
-RgSchCellCb             *cell;
-RgSchUlAlloc            *alloc;
-CmLteTimingInfo         *timeInfo;
-TfuUeUlSchRecpInfo      *recpReq;
-#endif
+S16 rgSCHUtlAllocRcptInfo(RgSchCellCb *cell,RgSchUlAlloc *alloc,CmLteTimingInfo *timeInfo,TfuUeUlSchRecpInfo *recpReq)
 {
 #if (ERRCLASS & ERRCLS_DEBUG)
    if ((alloc == NULLP) || (alloc->hqProc == NULLP))
@@ -2157,17 +1810,7 @@ TfuUeUlSchRecpInfo      *recpReq;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-static Void rgSCHUtlUpdPrachOcc
-(
-RgSchCellCb       *cell,
-RgrTddPrachInfo   *cellCfg
-)
-#else
-static Void rgSCHUtlUpdPrachOcc(cell, cellCfg)
-RgSchCellCb       *cell;
-RgrTddPrachInfo   *cellCfg;
-#endif
+static Void rgSCHUtlUpdPrachOcc(RgSchCellCb *cell,RgrTddPrachInfo *cellCfg)
 {
    uint8_t    idx;
    uint8_t    count = 0;
@@ -2221,17 +1864,7 @@ RgrTddPrachInfo   *cellCfg;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlPrachCfgInit
-(
-RgSchCellCb       *cell,
-RgrCellCfg        *cellCfg
-)
-#else
-Void rgSCHUtlPrachCfgInit(cell, cellCfg)
-RgSchCellCb       *cell;
-RgrCellCfg        *cellCfg;
-#endif
+Void rgSCHUtlPrachCfgInit(RgSchCellCb *cell,RgrCellCfg *cellCfg)
 {
    uint8_t idx;
    uint8_t subfrmIdx;
@@ -2239,7 +1872,7 @@ RgrCellCfg        *cellCfg;
 
    if(cellCfg->prachRscInfo.numRsc <= 0)
    {
-      RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid"
+      DU_LOG("\nERROR  -->  SCH : Invalid"
                   "PRACH resources Configuration ");
       return;
    }
@@ -2297,19 +1930,7 @@ RgrCellCfg        *cellCfg;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrCellCfg
-(
-RgSchCellCb       *cell,
-RgrCellCfg        *cellCfg,
-RgSchErrInfo      *errInfo
-)
-#else
-S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
-RgSchCellCb       *cell;
-RgrCellCfg        *cellCfg;
-RgSchErrInfo      *errInfo;
-#endif
+S16 rgSCHUtlRgrCellCfg(RgSchCellCb *cell,RgrCellCfg *cellCfg,RgSchErrInfo *errInfo)
 {
    uint8_t         i;
    uint8_t         sfn=0;
@@ -2477,19 +2098,7 @@ RgSchErrInfo      *errInfo;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrCellCfg
-(
-RgSchCellCb       *cell,
-RgrCellCfg        *cellCfg,
-RgSchErrInfo      *errInfo
-)
-#else
-S16 rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo)
-RgSchCellCb       *cell;
-RgrCellCfg        *cellCfg;
-RgSchErrInfo      *errInfo;
-#endif
+S16 rgSCHUtlRgrCellCfg(RgSchCellCb *cell,RgrCellCfg *cellCfg,RgSchErrInfo *errInfo)
 {
    uint8_t         i;
    RgSchDlSf       *sf;
@@ -2576,7 +2185,7 @@ RgSchErrInfo      *errInfo;
       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;
@@ -2664,19 +2273,7 @@ RgSchErrInfo      *errInfo;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrCellRecfg
-(
-RgSchCellCb       *cell,
-RgrCellRecfg      *recfg,
-RgSchErrInfo      *err
-)
-#else
-S16 rgSCHUtlRgrCellRecfg(cell, recfg, err)
-RgSchCellCb       *cell;
-RgrCellRecfg      *recfg;
-RgSchErrInfo      *err;
-#endif
+S16 rgSCHUtlRgrCellRecfg(RgSchCellCb *cell,RgrCellRecfg *recfg,RgSchErrInfo *err)
 {
    return (cell->sc.apis->rgSCHRgrCellRecfg(cell, recfg, err));
 }
@@ -2699,15 +2296,7 @@ RgSchErrInfo      *err;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlFreeCell
-(
-RgSchCellCb          *cell
-)
-#else
-S16 rgSCHUtlFreeCell(cell)
-RgSchCellCb          *cell;
-#endif
+S16 rgSCHUtlFreeCell(RgSchCellCb  *cell)
 {
    uint8_t          i;
    CmLListCp        *lst;
@@ -2848,21 +2437,7 @@ RgSchCellCb          *cell;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrUeCfg
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgrUeCfg                   *cfg,
-RgSchErrInfo               *err
-)
-#else
-S16 rgSCHUtlRgrUeCfg(cell, ue, cfg, err)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgrUeCfg                   *cfg;
-RgSchErrInfo               *err;
-#endif
+S16 rgSCHUtlRgrUeCfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeCfg *cfg,RgSchErrInfo *err)
 {
 
    /* Assign TM 1 as UE's default TM */
@@ -2923,23 +2498,7 @@ RgSchErrInfo               *err;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrLcCfg
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgSchDlLcCb                *dlLc,
-RgrLchCfg               *cfg,
-RgSchErrInfo               *errInfo
-)
-#else
-S16 rgSCHUtlRgrLcCfg(cell, ue, dlLc, cfg, errInfo)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgSchDlLcCb                *dlLc;
-RgrLchCfg               *cfg;
-RgSchErrInfo               *errInfo;
-#endif
+S16 rgSCHUtlRgrLcCfg(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlLcCb *dlLc,RgrLchCfg *cfg,RgSchErrInfo *errInfo)
 {
    return (cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
 }
@@ -2965,23 +2524,7 @@ RgSchErrInfo               *errInfo;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrLcRecfg
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgSchDlLcCb                *dlLc,
-RgrLchRecfg                *recfg,
-RgSchErrInfo               *err
-)
-#else
-S16 rgSCHUtlRgrLcRecfg(cell, ue, dlLc, recfg, err)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgSchDlLcCb                *dlLc;
-RgrLchRecfg                *recfg;
-RgSchErrInfo               *err;
-#endif
+S16 rgSCHUtlRgrLcRecfg(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlLcCb *dlLc,RgrLchRecfg *recfg,RgSchErrInfo *err)
 {
    return (cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
 }
@@ -3003,21 +2546,7 @@ RgSchErrInfo               *err;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrLcDel
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-CmLteLcId                  lcId,
-uint8_t                    lcgId
-)
-#else
-S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-CmLteLcId                  lcId;
-uint8_t                    lcgId;
-#endif
+S16 rgSCHUtlRgrLcDel(RgSchCellCb *cell,RgSchUeCb *ue,CmLteLcId lcId,uint8_t lcgId)
 {
    cell->sc.apis->rgSCHRgrLchDel(cell, ue, lcId, lcgId);
 
@@ -3043,21 +2572,7 @@ uint8_t                    lcgId;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrLcgCfg
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgrLcgCfg               *cfg,
-RgSchErrInfo               *errInfo
-)
-#else
-S16 rgSCHUtlRgrLcgCfg(cell, ue, cfg, errInfo)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgrLcgCfg               *cfg;
-RgSchErrInfo               *errInfo;
-#endif
+S16 rgSCHUtlRgrLcgCfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrLcgCfg *cfg,RgSchErrInfo *errInfo)
 {
    return (cell->sc.apis->rgSCHRgrLcgCfg(cell, ue, &(ue->ul.lcgArr[cfg->ulInfo.lcgId]), cfg, errInfo));
 }
@@ -3082,21 +2597,7 @@ RgSchErrInfo               *errInfo;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrLcgRecfg
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgrLcgRecfg                *recfg,
-RgSchErrInfo               *err
-)
-#else
-S16 rgSCHUtlRgrLcgRecfg(cell, ue, recfg, err)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgrLcgRecfg                *recfg;
-RgSchErrInfo               *err;
-#endif
+S16 rgSCHUtlRgrLcgRecfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrLcgRecfg *recfg,RgSchErrInfo *err)
 {
    return (cell->sc.apis->rgSCHRgrLcgRecfg(cell, ue, &(ue->ul.lcgArr[recfg->ulRecfg.lcgId]), recfg, err));
 } /* rgSCHUtlRgrLcRecfg */
@@ -3119,19 +2620,7 @@ RgSchErrInfo               *err;
  *  @return     S16
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlRgrLcgDel
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-uint8_t                    lcgId
-)
-#else
-Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-uint8_t                    lcgId;
-#endif
+Void rgSCHUtlRgrLcgDel(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t lcgId)
 {
    cell->sc.apis->rgSCHFreeLcg(cell, ue, &ue->ul.lcgArr[lcgId]);
 
@@ -3159,19 +2648,7 @@ uint8_t                    lcgId;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void  rgSCHUtlDoaInd
-(
-RgSchCellCb        *cell,
-RgSchUeCb          *ue,
-TfuDoaRpt          *doaRpt
-)
-#else
-Void rgSCHUtlDoaInd(cell, ue, doaRpt)
-RgSchCellCb        *cell;
-RgSchUeCb          *ue;
-TfuDoaRpt          *doaRpt;
-#endif
+Void  rgSCHUtlDoaInd(RgSchCellCb  *cell,RgSchUeCb *ue,TfuDoaRpt *doaRpt)
 {
    ue->mimoInfo.doa.pres = PRSNT_NODEF;
    ue->mimoInfo.doa.val = doaRpt->doa;
@@ -3195,21 +2672,7 @@ TfuDoaRpt          *doaRpt;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlCqiInd
-(
-RgSchCellCb        *cell,
-RgSchUeCb          *ue,
-TfuDlCqiRpt        *dlCqiRpt,
-CmLteTimingInfo    timingInfo
-)
-#else
-Void rgSCHUtlDlCqiInd(cell, ue, dlCqiRpt, timingInfo)
-RgSchCellCb        *cell;
-RgSchUeCb          *ue;
-TfuDlCqiRpt        *dlCqiRpt;
-CmLteTimingInfo    timingInfo;
-#endif
+Void rgSCHUtlDlCqiInd(RgSchCellCb *cell,RgSchUeCb  *ue,TfuDlCqiRpt *dlCqiRpt,CmLteTimingInfo timingInfo)
 {
    RgSchCellCb        *sCellCb = NULLP;
    if (dlCqiRpt->isPucchInfo)
@@ -3250,21 +2713,7 @@ CmLteTimingInfo    timingInfo;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlSrsInd
-(
-RgSchCellCb        *cell,
-RgSchUeCb          *ue,
-TfuSrsRpt          *srsRpt,
-CmLteTimingInfo    timingInfo
-)
-#else
-Void rgSCHUtlSrsInd(cell, ue, srsRpt, timingInfo)
-RgSchCellCb        *cell;
-RgSchUeCb          *ue;
-TfuSrsRpt        *srsRpt;
-CmLteTimingInfo    timingInfo;
-#endif
+Void rgSCHUtlSrsInd(RgSchCellCb *cell,RgSchUeCb *ue,TfuSrsRpt *srsRpt,CmLteTimingInfo timingInfo)
 {
    cell->sc.apis->rgSCHSrsInd(cell, ue, srsRpt, timingInfo);
    return;
@@ -3286,17 +2735,7 @@ CmLteTimingInfo    timingInfo;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlTARpt
-(
-RgSchCellCb        *cell,
-RgSchUeCb          *ue
-)
-#else
-Void rgSCHUtlDlTARpt(cell, ue)
-RgSchCellCb        *cell;
-RgSchUeCb          *ue;
-#endif
+Void rgSCHUtlDlTARpt(RgSchCellCb *cell,RgSchUeCb *ue)
 {
    cell->sc.apis->rgSCHDlTARpt(cell, ue);
    return;
@@ -3318,17 +2757,7 @@ RgSchUeCb          *ue;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlRlsSubFrm
-(
-RgSchCellCb        *cell,
-CmLteTimingInfo    subFrm
-)
-#else
-Void rgSCHUtlDlRlsSubFrm(cell, subFrm)
-RgSchCellCb        *cell;
-CmLteTimingInfo    subFrm;
-#endif
+Void rgSCHUtlDlRlsSubFrm(RgSchCellCb *cell,CmLteTimingInfo subFrm)
 {
    cell->sc.apis->rgSCHDlRlsSubFrm(cell, subFrm);
    return;
@@ -3354,19 +2783,7 @@ CmLteTimingInfo    subFrm;
  *
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSCHUtlUpdACqiTrigWt
-(
-RgSchUeCb       *ue,
-RgSchUeCellInfo *cellInfo,
-uint8_t         isAck 
-)
-#else
-Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
-RgSchUeCb       *ue;
-RgSchUeCellInfo *cellInfo;
-uint8_t          isAck; 
-#endif
+Void rgSCHUtlUpdACqiTrigWt(RgSchUeCb *ue,RgSchUeCellInfo *cellInfo,uint8_t isAck )
 {
 #ifdef LTE_ADV
    uint8_t triggerSet  = 0;
@@ -3435,19 +2852,7 @@ uint8_t          isAck;
  *
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSCHUtlHdlUlTransInd
-(
-RgSchCellCb     *cell,
-RgSchUeCb       *ue,
-CmLteTimingInfo timingInfo
-)
-#else
-Void rgSCHUtlHdlUlTransInd(cell, ue, timingInfo)
-RgSchCellCb     *cell;
-RgSchUeCb       *ue;
-CmLteTimingInfo timingInfo;
-#endif
+Void rgSCHUtlHdlUlTransInd(RgSchCellCb *cell,RgSchUeCb *ue,CmLteTimingInfo timingInfo)
 {
    cell->sc.apis->rgSCHHdlUlTransInd(cell, ue, timingInfo);
    return;
@@ -3467,19 +2872,7 @@ CmLteTimingInfo timingInfo;
  *
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSCHUtlHdlCrcInd
-(
-RgSchCellCb     *cell,
-RgSchUeCb       *ue,
-CmLteTimingInfo timingInfo
-)
-#else
-Void rgSCHUtlHdlCrcInd(cell, ue, timingInfo)
-RgSchCellCb     *cell;
-RgSchUeCb       *ue;
-CmLteTimingInfo timingInfo;
-#endif
+Void rgSCHUtlHdlCrcInd(RgSchCellCb *cell,RgSchUeCb  *ue,CmLteTimingInfo timingInfo)
 {
    cell->sc.apis->rgSCHUlCrcInd(cell, ue, timingInfo);
    return;
@@ -3499,19 +2892,7 @@ CmLteTimingInfo timingInfo;
  *
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSCHUtlHdlCrcFailInd
-(
-RgSchCellCb     *cell,
-RgSchUeCb       *ue,
-CmLteTimingInfo timingInfo
-)
-#else
-Void rgSCHUtlHdlCrcFailInd(cell, ue, timingInfo)
-RgSchCellCb     *cell;
-RgSchUeCb       *ue;
-CmLteTimingInfo timingInfo;
-#endif
+Void rgSCHUtlHdlCrcFailInd(RgSchCellCb *cell,RgSchUeCb  *ue,CmLteTimingInfo timingInfo)
 {
    cell->sc.apis->rgSCHUlCrcFailInd(cell, ue, timingInfo);
    return;
@@ -3536,17 +2917,7 @@ CmLteTimingInfo timingInfo;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlProcAddToRetx
-(
-RgSchCellCb                *cell,
-RgSchDlHqProcCb            *hqP
-)
-#else
-Void rgSCHUtlDlProcAddToRetx(cell, hqP)
-RgSchCellCb                *cell;
-RgSchDlHqProcCb            *hqP;
-#endif
+Void rgSCHUtlDlProcAddToRetx(RgSchCellCb *cell,RgSchDlHqProcCb *hqP)
 {
    cell->sc.apis->rgSCHDlProcAddToRetx(cell, hqP);
    return;
@@ -3570,19 +2941,7 @@ RgSchDlHqProcCb            *hqP;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlHqPTbAddToTx
-(
-RgSchDlSf                  *subFrm,
-RgSchDlHqProcCb            *hqP,
-uint8_t                    tbIdx
-)
-#else
-Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
-RgSchDlSf                  *subFrm;
-RgSchDlHqProcCb            *hqP;
-uint8_t                    tbIdx;
-#endif
+Void rgSCHUtlDlHqPTbAddToTx(RgSchDlSf *subFrm,RgSchDlHqProcCb *hqP,uint8_t tbIdx)
 {
    RgSchUeCb *ue = NULLP;
    RgSchCellCb *cell = hqP->hqE->cell;
@@ -3664,21 +3023,7 @@ uint8_t                    tbIdx;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlDlHqPTbRmvFrmTx
-(
-RgSchDlSf                  *subFrm,
-RgSchDlHqProcCb            *hqP,
-uint8_t                    tbIdx,
-Bool                       isRepeting
-)
-#else
-Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
-RgSchDlSf                  *subFrm;
-RgSchDlHqProcCb            *hqP;
-uint8_t                    tbIdx;
-Bool                       isRepeting;
-#endif
+Void rgSCHUtlDlHqPTbRmvFrmTx(RgSchDlSf *subFrm,RgSchDlHqProcCb  *hqP,uint8_t tbIdx,Bool isRepeting)
 {
    RgSchCellCb *cell = NULLP;
    /* Check with TDD */
@@ -3735,21 +3080,10 @@ Bool                       isRepeting;
  *  @param[in]  ueId
  *  @return  RgSchUeCb*
  **/
-#ifdef ANSI
-RgSchCellCb* rgSchUtlGetCellCb
-(
- Inst         inst,
- uint16_t     cellId
-)
-#else
-RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
- Inst          inst;
- uint16_t      cellId;
-#endif
+RgSchCellCb* rgSchUtlGetCellCb(Inst inst,uint16_t cellId)
 {
-   RgSchCellCb    *cellCb = NULLP; 
-   uint8_t        strtCellId;
-
+   RgSchCellCb  *cellCb = NULLP; 
+   uint8_t      strtCellId;
    strtCellId = rgSchCb[inst].genCfg.startCellId;
    cellCb     = rgSchCb[inst].cells[cellId - strtCellId];
 
@@ -3769,27 +3103,13 @@ RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
  *  @param[in]  RgSchUeCb *ue
  *  @return   uint8_t servCellIdx
  **/
-#ifdef ANSI
-uint8_t rgSchUtlGetServCellIdx
-(
- Inst         inst,
- uint16_t     cellId,
- RgSchUeCb    *ue
-)
-#else
-uint8_t rgSchUtlGetServCellIdx(inst,cellId,ue)
- Inst         inst;
- uint16_t     cellId;
- RgSchUeCb    *ue;
-#endif
+uint8_t rgSchUtlGetServCellIdx(Inst inst, uint16_t cellId, RgSchUeCb *ue)
 {
    uint8_t servCellIdx;
    uint16_t strtCellId;
 
    strtCellId = rgSchCb[inst].genCfg.startCellId;
-
    servCellIdx = ue->cellIdToCellIdxMap[cellId - strtCellId];
-
    return (servCellIdx);
 
 }  /* rgSchUtlGetCellCb */
@@ -3806,17 +3126,7 @@ uint8_t rgSchUtlGetServCellIdx(inst,cellId,ue)
  *  @param[in]  ueId
  *  @return  RgSchUeCb*
  **/
-#ifdef ANSI
-S16 rgSchUtlVldtCellId
-(
- Inst         inst,
- uint16_t          cellId
-)
-#else
-S16 rgSchUtlVldtCellId(inst, cellId)
- Inst          inst;
- uint16_t           cellId;
-#endif
+S16 rgSchUtlVldtCellId(Inst inst,uint16_t cellId)
 {
    uint8_t              strtCellId;
 
@@ -3847,21 +3157,7 @@ S16 rgSchUtlVldtCellId(inst, cellId)
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrUeRecfg
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-RgrUeRecfg   *ueRecfg,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-RgrUeRecfg   *ueRecfg;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHUtlRgrUeRecfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,RgSchErrInfo *err)
 {
 /* Changes for UE Category Reconfiguration feature addition */
    RgSchCmnUe    *ueSch = RG_SCH_CMN_GET_UE(ue, cell);
@@ -3895,7 +3191,7 @@ RgSchErrInfo *err;
             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;
@@ -3943,19 +3239,7 @@ RgSchErrInfo *err;
  *  @param[in]  RgSchDlLcCb*  svc
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlFreeDlLc
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgSchDlLcCb                *svc
-)
-#else
-Void rgSCHUtlFreeDlLc(cell, ue, svc)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgSchDlLcCb                *svc;
-#endif
+Void rgSCHUtlFreeDlLc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlLcCb  *svc)
 {
    cell->sc.apis->rgSCHFreeDlLc(cell, ue, svc);
 
@@ -3978,17 +3262,7 @@ RgSchDlLcCb                *svc;
  *  @param[in]  RgSchUeCb    *ue
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlFreeUe
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue
-)
-#else
-Void rgSCHUtlFreeUe(cell, ue)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-#endif
+Void rgSCHUtlFreeUe(RgSchCellCb *cell,RgSchUeCb *ue)
 {
 #ifdef LTE_TDD
    rgSCHUtlDelUeANFdbkInfo(ue,RGSCH_PCELL_INDEX);
@@ -4016,19 +3290,7 @@ RgSchUeCb    *ue;
  *  @param[in]  RgSchDlLcCb*  lc
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlDlDedBoUpd
-(
-RgSchCellCb                *cell,
-RgSchUeCb                  *ue,
-RgSchDlLcCb                *lc
-)
-#else
-Void rgSCHUtlDlDedBoUpd(cell, ue, lc)
-RgSchCellCb                *cell;
-RgSchUeCb                  *ue;
-RgSchDlLcCb                *lc;
-#endif
+Void rgSCHUtlDlDedBoUpd(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlLcCb *lc)
 {
    cell->sc.apis->rgSCHDlDedBoUpd(cell, ue, lc);
    return;
@@ -4048,19 +3310,7 @@ RgSchDlLcCb                *lc;
  *  @param[in] RgSchRaCb       *raCb
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlRecMsg3Alloc
-(
-RgSchCellCb      *cell,
-RgSchUeCb        *ue,
-RgSchRaCb        *raCb
-)
-#else
-Void rgSCHUtlRecMsg3Alloc(cell, ue, raCb)
-RgSchCellCb      *cell;
-RgSchUeCb        *ue;
-RgSchRaCb        *raCb;
-#endif
+Void rgSCHUtlRecMsg3Alloc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchRaCb *raCb)
 {
    cell->sc.apis->rgSCHUlRecMsg3Alloc(cell, ue, raCb);
    return;
@@ -4086,19 +3336,7 @@ RgSchRaCb        *raCb;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlUpdUlHqProc
-(
-RgSchCellCb      *cell,
-RgSchUlHqProcCb  *curProc,
-RgSchUlHqProcCb  *oldProc
-)
-#else
-S16 rgSCHUtlUpdUlHqProc(cell, curProc, oldProc)
-RgSchCellCb      *cell;
-RgSchUlHqProcCb  *curProc;
-RgSchUlHqProcCb  *oldProc;
-#endif
+S16 rgSCHUtlUpdUlHqProc(RgSchCellCb *cell,RgSchUlHqProcCb  *curProc,RgSchUlHqProcCb  *oldProc)
 {
    return (cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
 }  /* rgSCHUtlUpdUlHqProc */
@@ -4120,23 +3358,10 @@ RgSchUlHqProcCb  *oldProc;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlContResUlGrant
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHUtlContResUlGrant(cell, ue, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHUtlContResUlGrant(RgSchCellCb *cell,RgSchUeCb *ue,RgSchErrInfo *err)
 {
 
    ue->isMsg4PdcchWithCrnti = TRUE; 
-
    return (cell->sc.apis->rgSCHContResUlGrant(cell, ue, err));
 }  /* rgSCHUtlContResUlGrant */
 
@@ -4156,21 +3381,7 @@ RgSchErrInfo *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlSrRcvd
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-CmLteTimingInfo frm,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHUtlSrRcvd(cell, ue, frm, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-CmLteTimingInfo frm;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHUtlSrRcvd(RgSchCellCb  *cell,RgSchUeCb *ue,CmLteTimingInfo frm,RgSchErrInfo *err)
 {
    return (cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
 }  /* rgSCHUtlSrRcvd */
@@ -4193,23 +3404,7 @@ RgSchErrInfo *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-Void rgSCHUtlUpdBsrShort
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-uint8_t           lcgId,
-uint8_t           bsr,
-RgSchErrInfo *err
-)
-#else
-Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-uint8_t           lcgId;
-uint8_t           bsr;
-RgSchErrInfo *err;
-#endif
+Void rgSCHUtlUpdBsrShort(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t lcgId,uint8_t bsr,RgSchErrInfo *err)
 {
    cell->sc.apis->rgSCHUpdBsrShort(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
    return;
@@ -4235,23 +3430,7 @@ RgSchErrInfo *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-Void rgSCHUtlUpdBsrTrunc
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-uint8_t           lcgId,
-uint8_t           bsr,
-RgSchErrInfo *err
-)
-#else
-Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
-RgSchCellCb   *cell;
-RgSchUeCb     *ue;
-uint8_t            lcgId;
-uint8_t            bsr;
-RgSchErrInfo *err;
-#endif
+Void rgSCHUtlUpdBsrTrunc(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t  lcgId,uint8_t bsr,RgSchErrInfo *err)
 {
    cell->sc.apis->rgSCHUpdBsrTrunc(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
    return; 
@@ -4281,30 +3460,9 @@ RgSchErrInfo *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-Void rgSCHUtlUpdBsrLong
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-uint8_t           bsr0,
-uint8_t           bsr1,
-uint8_t           bsr2,
-uint8_t           bsr3,
-RgSchErrInfo *err
-)
-#else
-Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-uint8_t           bsr0;
-uint8_t           bsr1;
-uint8_t           bsr2;
-uint8_t           bsr3;
-RgSchErrInfo *err;
-#endif
+Void rgSCHUtlUpdBsrLong(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t bsr0,uint8_t bsr1,uint8_t bsr2,uint8_t bsr3,RgSchErrInfo *err)
 {
    uint8_t bsArr[4];
-
    bsArr[0] = bsr0;
    bsArr[1] = bsr1;
    bsArr[2] = bsr2;
@@ -4330,21 +3488,7 @@ RgSchErrInfo *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlUpdExtPhr
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-RgInfExtPhrCEInfo * extPhr,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHUtlUpdExtPhr(cell, ue, extPhr, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-RgInfExtPhrCEInfo * extPhr;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHUtlUpdExtPhr(RgSchCellCb *cell,RgSchUeCb *ue,RgInfExtPhrCEInfo *extPhr,RgSchErrInfo *err)
 {
    return (cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
 }  /* rgSCHUtlUpdExtPhr */
@@ -4368,21 +3512,7 @@ RgSchErrInfo *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlUpdPhr
-(
-RgSchCellCb  *cell,
-RgSchUeCb    *ue,
-uint8_t           phr,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
-RgSchCellCb  *cell;
-RgSchUeCb    *ue;
-uint8_t           phr;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHUtlUpdPhr(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t phr,RgSchErrInfo *err)
 {
    return (cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
 }  /* rgSCHUtlUpdPhr */
@@ -4403,19 +3533,7 @@ RgSchErrInfo *err;
  *  @param[in]  TfuUlCqiRpt         *ulCqiInfo
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlUlCqiInd
-(
-RgSchCellCb          *cell,
-RgSchUeCb            *ue,
-TfuUlCqiRpt          *ulCqiInfo
-)
-#else
-Void rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo)
-RgSchCellCb          *cell;
-RgSchUeCb            *ue;
-TfuUlCqiRpt          *ulCqiInfo;
-#endif
+Void rgSCHUtlUlCqiInd(RgSchCellCb *cell,RgSchUeCb *ue,TfuUlCqiRpt *ulCqiInfo)
 {
    cell->sc.apis->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
    return;
@@ -4436,19 +3554,7 @@ TfuUlCqiRpt          *ulCqiInfo;
  *  @param[in]  uint8_t                  delta
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlPucchDeltaPwrInd
-(
-RgSchCellCb          *cell,
-RgSchUeCb            *ue,
-S8                   delta
-)
-#else
-Void rgSCHUtlPucchDeltaPwrInd(cell, ue, delta)
-RgSchCellCb          *cell;
-RgSchUeCb            *ue;
-S8                   delta;
-#endif
+Void rgSCHUtlPucchDeltaPwrInd(RgSchCellCb *cell,RgSchUeCb *ue,S8 delta)
 {
    cell->sc.apis->rgSCHPucchDeltaPwrInd(cell, ue, delta);
    return;
@@ -4467,17 +3573,7 @@ S8                   delta;
  *  @param[in]  RgSchUeCb           *ue
  *  @return  S16
  **/
-#ifdef ANSI
-Void rgSCHUtlUeReset
-(
-RgSchCellCb          *cell,
-RgSchUeCb            *ue
-)
-#else
-Void rgSCHUtlUeReset(cell, ue)
-RgSchCellCb          *cell;
-RgSchUeCb            *ue;
-#endif
+Void rgSCHUtlUeReset(RgSchCellCb *cell,RgSchUeCb *ue)
 {
    ue->remBoCnt = 0;
    cell->sc.apis->rgSCHUeReset(cell, ue);
@@ -4504,21 +3600,7 @@ RgSchUeCb            *ue;
  *  @param[out] RgSchUlHqProcCb     **procRef
  *  @return  Void
  **/
-#ifdef ANSI
-Void rgSCHUtlUlHqProcForUe
-(
-RgSchCellCb         *cell,
-CmLteTimingInfo     frm,
-RgSchUeCb           *ue,
-RgSchUlHqProcCb     **procRef
-)
-#else
-Void rgSCHUtlUlHqProcForUe(cell, frm, ue, procRef)
-RgSchCellCb         *cell;
-CmLteTimingInfo     frm;
-RgSchUeCb           *ue;
-RgSchUlHqProcCb     **procRef;
-#endif
+Void rgSCHUtlUlHqProcForUe(RgSchCellCb *cell,CmLteTimingInfo frm,RgSchUeCb *ue,RgSchUlHqProcCb **procRef)
 {
    cell->sc.apis->rgSCHUlHqProcForUe(cell, frm, ue, procRef);
 
@@ -4544,15 +3626,7 @@ RgSchUlHqProcCb     **procRef;
  *  @param[in]  RgSchCellCb      *cell
  *  @return  RgSchUlAlloc*
  **/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlFirstRcptnReq
-(
-RgSchCellCb      *cell
-)
-#else
-RgSchUlAlloc *rgSCHUtlFirstRcptnReq(cell)
-RgSchCellCb      *cell;
-#endif
+RgSchUlAlloc *rgSCHUtlFirstRcptnReq(RgSchCellCb *cell)
 {
    return (cell->sc.apis->rgSCHFirstRcptnReq(cell));
 }
@@ -4574,17 +3648,7 @@ RgSchCellCb      *cell;
  *  @param[in]  RgSchCellCb      *cell
  *  @return  RgSchUlAlloc*
  **/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlNextRcptnReq
-(
-RgSchCellCb      *cell,
-RgSchUlAlloc     *alloc
-)
-#else
-RgSchUlAlloc *rgSCHUtlNextRcptnReq(cell, alloc)
-RgSchCellCb      *cell;
-RgSchUlAlloc     *alloc;
-#endif
+RgSchUlAlloc *rgSCHUtlNextRcptnReq(RgSchCellCb *cell,RgSchUlAlloc *alloc)
 {
    return (cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
 }
@@ -4607,17 +3671,7 @@ RgSchUlAlloc     *alloc;
  *  @param[in]  uint8_t                idx  
  *  @return  RgSchUlAlloc*
  **/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
-(
-RgSchCellCb      *cell,
-uint8_t               idx
-)
-#else
-RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
-RgSchCellCb      *cell;
-uint8_t               idx;
-#endif
+RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(RgSchCellCb *cell,uint8_t idx)
 {
    return (cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
 }
@@ -4638,19 +3692,7 @@ uint8_t               idx;
  *  @param[in]  RgSchCellCb      *cell
  *  @return  RgSchUlAlloc*
  **/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc
-(
-RgSchCellCb      *cell,
-RgSchUlAlloc     *alloc,
-uint8_t               idx 
-)
-#else
-RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
-RgSchCellCb      *cell;
-RgSchUlAlloc     *alloc;
-uint8_t               idx; 
-#endif
+RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(RgSchCellCb *cell,RgSchUlAlloc *alloc,uint8_t idx)
 {
    return (cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
 }
@@ -4669,19 +3711,7 @@ uint8_t               idx;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlResetSfAlloc
-(
-RgInfSfAlloc *sfAlloc,
-Bool         resetCmnLcInfo,
-Bool         restAlloc
-)
-#else
-S16 rgSCHUtlResetSfAlloc(sfAlloc,resetCmnLcInfo,restAlloc)
-RgInfSfAlloc *sfAlloc;
-Bool         resetCmnLcInfo;
-Bool         restAlloc;
-#endif
+S16 rgSCHUtlResetSfAlloc(RgInfSfAlloc *sfAlloc,Bool resetCmnLcInfo,Bool restAlloc)
 {
    if(TRUE == restAlloc)
    {
@@ -4715,15 +3745,7 @@ Bool         restAlloc;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlGetRlsHqAlloc
-(
-RgSchCellCb *cell
-)
-#else
-S16 rgSCHUtlGetRlsHqAlloc(cell)
-RgSchCellCb *cell;
-#endif
+S16 rgSCHUtlGetRlsHqAlloc(RgSchCellCb *cell)
 {
    uint8_t    idx = 0;
    Inst  inst = cell->instIdx;
@@ -4739,7 +3761,7 @@ RgSchCellCb *cell;
                      (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;
       }
@@ -4763,15 +3785,7 @@ RgSchCellCb *cell;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlPutRlsHqAlloc
-(
-RgSchCellCb *cell
-)
-#else
-S16 rgSCHUtlPutRlsHqAlloc(cell)
-RgSchCellCb *cell;
-#endif
+S16 rgSCHUtlPutRlsHqAlloc(RgSchCellCb *cell)
 {
    uint8_t    idx = 0;
    Inst  inst = cell->instIdx;
@@ -4810,15 +3824,7 @@ RgSchCellCb *cell;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlGetSfAlloc
-(
-RgSchCellCb *cell
-)
-#else
-S16 rgSCHUtlGetSfAlloc(cell)
-RgSchCellCb *cell;
-#endif
+S16 rgSCHUtlGetSfAlloc(RgSchCellCb *cell)
 {
    uint8_t    idx;
    uint8_t    indx;
@@ -4841,7 +3847,7 @@ RgSchCellCb *cell;
                      (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;
       }
@@ -4851,7 +3857,7 @@ RgSchCellCb *cell;
                      (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;
       }
@@ -4861,7 +3867,7 @@ RgSchCellCb *cell;
             (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;
          }
@@ -4891,15 +3897,7 @@ RgSchCellCb *cell;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlPutSfAlloc
-(
-RgSchCellCb *cell
-)
-#else
-S16 rgSCHUtlPutSfAlloc(cell)
-RgSchCellCb *cell;
-#endif
+S16 rgSCHUtlPutSfAlloc(RgSchCellCb *cell)
 {
    uint8_t    idx;
    uint8_t    indx;
@@ -4968,19 +3966,12 @@ RgSchCellCb *cell;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
 S16 rgSCHUtlAllocSBuf
 (
 Inst    inst,               /* Instance of the invoking scheduler */
 Data    **pData,            /* Pointer of the data to be returned */
 Size    size                /* size */
 )
-#else
-S16 rgSCHUtlAllocSBuf(inst, pData, size)
-Inst    inst;              /* Instance of the invoking scheduler */
-Data    **pData;            /* Pointer of the data to be returned */
-Size    size;               /* size */
-#endif
 {
    /* Moving alarm diagnostics to available scope */
 
@@ -4999,8 +3990,8 @@ Size    size;               /* size */
 #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;
@@ -5009,8 +4000,7 @@ Size    size;               /* size */
      /*  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;
    }
 
@@ -5036,23 +4026,14 @@ Size    size;               /* size */
 *       Notes: None
 *       File:  rg_utl.c
 */
-#ifdef ANSI
 Void rgSCHUtlFreeSBuf
 (
 Inst inst,          /* Instance of the invoking scheduler */
 Data **data,         /* pointer to data */
 Size size           /* size */
 )
-#else
-Void rgSCHUtlFreeSBuf(inst, data, size)
-Inst inst;          /* Instance of the invoking scheduler */
-Data **data;         /* pointer to data */
-Size size;          /* size */
-#endif
 {
 
-   S16 ret;
-
    if ((data == NULLP) || (*data == NULLP) || (size == 0))
    {
       return;
@@ -5063,14 +4044,11 @@ Size size;          /* size */
    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;
    }
 
@@ -5094,32 +4072,20 @@ Size size;          /* size */
 *
 *       File:  rg_utl.c
 */
-#ifdef ANSI
-Void rgSCHUtlFreeWarningSiSeg
-(
-Region        reg,
-Pool          pool,
-CmLListCp     *siPduLst          
-)
-#else
-Void rgSCHUtlFreeWarningSiSeg(reg, pool, siPduLst)
-Region        reg;
-Pool          pool;
-CmLListCp     *siPduLst;          
-#endif
+Void rgSCHUtlFreeWarningSiSeg(Region reg,Pool pool,CmLListCp *siPduLst)
 {
    CmLList      *node;
    Buffer       *pdu;
 
-      while (siPduLst->first != NULLP)
-      {
-         node = siPduLst->first;
-         pdu = (Buffer *)node->node;
-         cmLListDelFrm(siPduLst, node);
-         RGSCH_FREE_MSG(pdu);
-         SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
-         node = NULLP;
-      }
+   while (siPduLst->first != NULLP)
+   {
+      node = siPduLst->first;
+      pdu = (Buffer *)node->node;
+      cmLListDelFrm(siPduLst, node);
+      RGSCH_FREE_MSG(pdu);
+      SCH_FREE(node,sizeof(CmLList));
+      node = NULLP;
+   }
 
    return;
 } /* end of rgSCHUtlFreeWarningSiSeg */         
@@ -5137,15 +4103,7 @@ CmLListCp     *siPduLst;
 *
 *       File:  rg_utl.c
 */
-#ifdef ANSI
-Void rgSCHUtlFreeWarningSiPdu
-(
-RgSchCellCb       *cell
-)
-#else
-Void rgSCHUtlFreeWarningSiPdu(cell)
-RgSchCellCb       *cell;
-#endif
+Void rgSCHUtlFreeWarningSiPdu(RgSchCellCb  *cell)
 {
    CmLList            *node;
    Buffer             *pdu;
@@ -5193,15 +4151,7 @@ RgSchCellCb       *cell;
 *
 *       File:  rg_utl.c
 */
-#ifdef ANSI
-Buffer *rgSCHUtlGetWarningSiPdu
-(
-RgSchCellCb             *cell
-)
-#else
-Buffer *rgSCHUtlGetWarningSiPdu(cell)
-RgSchCellCb             *cell;
-#endif
+Buffer *rgSCHUtlGetWarningSiPdu(RgSchCellCb *cell)
 {
    RgSchWarningSiInfo  *warningSi;
    RgSchWarningSiPdu  *warningSiPdu; 
@@ -5237,21 +4187,7 @@ RgSchCellCb             *cell;
 *
 *       File:  rg_utl.c
 */
-#ifdef ANSI
-S16 rgSCHUtlGetMcsAndNPrb
-(
-RgSchCellCb         *cell,
-uint8_t                  *nPrb,
-uint8_t                  *mcs,
-MsgLen              *msgLen
-)
-#else
-S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
-RgSchCellCb         *cell;
-uint8_t                  *nPrb;
-uint8_t                  *mcs;
-MsgLen              *msgLen;
-#endif
+S16 rgSCHUtlGetMcsAndNPrb(RgSchCellCb *cell,uint8_t *nPrb,uint8_t *mcs,MsgLen  *msgLen)
 {
    RgSchWarningSiInfo  *warningSi;
    RgSchWarningSiPdu  *warningSiPdu; 
@@ -5296,21 +4232,7 @@ MsgLen              *msgLen;
 *
 *       File:  rg_utl.c
 */
-#ifdef ANSI
-S16 rgSCHUtlCalMcsAndNPrb
-(
-RgSchCellCb         *cell,
-uint8_t                  cfgType,
-MsgLen              msgLen,
-uint8_t                  siId
-)
-#else
-S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
-RgSchCellCb         *cell;
-uint8_t                  cfgType;
-MsgLen              msgLen;
-uint8_t                  siId;
-#endif
+S16 rgSCHUtlCalMcsAndNPrb(RgSchCellCb *cell,uint8_t cfgType,MsgLen msgLen,uint8_t siId)
 {
    uint8_t mcs = 0;
    uint8_t nPrb = 0;
@@ -5318,7 +4240,7 @@ uint8_t                  siId;
       /*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;
       }
@@ -5383,19 +4305,7 @@ uint8_t                  siId;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlFillDgnParams
-(
-Inst        inst,
-RgUstaDgn   *dgn,
-uint8_t          dgnType
-)
-#else
-Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
-Inst        inst;
-RgUstaDgn   *dgn;
-uint8_t          dgnType;
-#endif
+Void rgSCHUtlFillDgnParams(Inst inst,RgUstaDgn *dgn,uint8_t dgnType)
 {
 
    switch(dgnType)
@@ -5429,19 +4339,7 @@ uint8_t          dgnType;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlGetPstToLyr
-(
-Pst     *pst,
-RgSchCb *schCb,
-Inst    macInst
-)
-#else
-Void rgSCHUtlGetPstToLyr (pst, schCb, macInst)
-Pst     *pst;
-RgSchCb *schCb;
-Inst    macInst;
-#endif
+Void rgSCHUtlGetPstToLyr(Pst  *pst,RgSchCb *schCb,Inst macInst)
 {
 
    /* Only the needed params are filled */
@@ -5476,21 +4374,7 @@ Inst    macInst;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rgSCHUtlFillRgInfCmnLcInfo
-(
-RgSchDlSf       *sf,
-RgInfSfAlloc    *sfAlloc,
-CmLteLcId       lcId,
-Bool            sendInd
-)
-#else
-S16 rgSCHUtlFillRgInfCmnLcInfo(sf, sfAlloc, lcId, sendInd)
-RgSchDlSf       *sf;
-RgInfSfAlloc    *sfAlloc;
-CmLteLcId       lcId;
-Bool            sendInd;
-#endif
+S16 rgSCHUtlFillRgInfCmnLcInfo(RgSchDlSf  *sf,RgInfSfAlloc *sfAlloc,CmLteLcId lcId,Bool sendInd)
 {
 
    if((sf->bch.tbSize)&&
@@ -5538,27 +4422,15 @@ Bool            sendInd;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rgSCHUtlFillRgInfRarInfo
-(
-RgSchDlSf       *sf,
-RgInfSfAlloc    *sfAlloc,
-RgSchCellCb     *cell
-)
-#else
-S16 rgSCHUtlFillRgInfRarInfo(sf, sfAlloc, cell)
-RgSchDlSf       *sf;
-RgInfSfAlloc    *sfAlloc;
-RgSchCellCb     *cell;
-#endif 
+S16 rgSCHUtlFillRgInfRarInfo(RgSchDlSf *sf,RgInfSfAlloc *sfAlloc,RgSchCellCb *cell)
 {
-   uint8_t               idx;
+   uint8_t          idx;
    CmLListCp        *lnkLst;
    CmLList          *tmp;
    RgSchRaCb        *raCb;
    RgSchUeCb        *ue;
    RgInfRaRntiInfo  *raRntiAlloc;
-   uint8_t               noRaRsps;
+   uint8_t          noRaRsps;
    RgSchCmnDlCell   *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
 
 #ifdef LTE_TDD
@@ -5677,17 +4549,7 @@ RgSchCellCb     *cell;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rgSCHUtlFillPdschDciInfo
-(
-TfuPdschDciInfo *pdsch,
-TfuDciInfo      *pdcchDci
-)
-#else
-S16 rgSCHUtlFillPdschDciInfo(pdsch, pdcchDci)
-TfuPdschDciInfo *pdsch;
-TfuDciInfo      *pdcchDci;
-#endif
+S16 rgSCHUtlFillPdschDciInfo(TfuPdschDciInfo *pdsch,TfuDciInfo *pdcchDci)
 {
 
 #ifdef EMTC_ENABLE
@@ -5756,18 +4618,7 @@ TfuDciInfo      *pdcchDci;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-Void rgSchDSFRPwrCheck
-(
- RgSchDlSf               *sf,
- Bool                    *isAllUePwrHigh
- )
-#else
-static Void rgSchDSFRPwrCheck(sf, isAllUePwrHigh)
-   RgSchDlSf               *sf;
-   Bool                    *isAllUePwrHigh;
-
-#endif
+Void rgSchDSFRPwrCheck(RgSchDlSf *sf,Bool *isAllUePwrHigh)
 {     
    RgSchSFRPoolInfo *sfrCCPool;
 
@@ -5811,36 +4662,24 @@ static Void rgSchDSFRPwrCheck(sf, isAllUePwrHigh)
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-static Void rgSCHUtlFillRgInfTbInfo
-(
-RgSchDlHqProcCb *hqP,
-RgInfUeAlloc    *allocInfo,
-RgSchCellCb     *cell
-)
-#else
-static Void rgSCHUtlFillRgInfTbInfo (hqP, allocInfo, cell)
-RgSchDlHqProcCb *hqP;
-RgInfUeAlloc    *allocInfo;
-RgSchCellCb     *cell;
-#endif
+static Void rgSCHUtlFillRgInfTbInfo(RgSchDlHqProcCb *hqP,RgInfUeAlloc *allocInfo,RgSchCellCb *cell)
 {
    RgSchDlSf       *sf;
-   uint8_t              idx;
+   uint8_t         idx;
    RgInfUeTbInfo   *tbInfo;
-   uint8_t              tbCnt;
+   uint8_t         tbCnt;
    /* LTE_ADV_FLAG_REMOVED_START */
 #ifdef TFU_UPGRADE
-   static         uint32_t  tmpCnt = 0;
+   static          uint32_t  tmpCnt = 0;
    Bool            isAllUePwrHigh = FALSE;
 #endif 
    /* LTE_ADV_FLAG_REMOVED_END */
    RgSchDlLcCb    *dlLcCb = NULLP;
-   uint16_t             rlcHdrEstmt;
-   uint8_t              lcId;
+   uint16_t       rlcHdrEstmt;
+   uint8_t        lcId;
    /* RRM_RBC_X */
 #ifdef LTE_L2_MEAS
-   uint8_t              prbUsed = 0;
+   uint8_t        prbUsed = 0;
 #endif
    /* RRM_RBC_Y */
 
@@ -5941,8 +4780,7 @@ RgSchCellCb     *cell;
             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;
             }
          }    
@@ -5956,8 +4794,7 @@ RgSchCellCb     *cell;
                   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;
                   }
 
@@ -5974,8 +4811,7 @@ RgSchCellCb     *cell;
                      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;
                      }
                   }
@@ -6188,24 +5024,7 @@ RgSchCellCb     *cell;
  *
  **********************************************************/
   /* CA dev Start */
-#ifdef ANSI
-Void rgSCHUtlFillRgInfUeInfo
-(
-RgSchDlSf       *sf,
-RgSchCellCb     *cell,
-CmLListCp       *dlDrxInactvTmrLst,
-CmLListCp       *dlInActvLst,
-CmLListCp       *ulInActvLst
-)
-#else
-Void rgSCHUtlFillRgInfUeInfo (sf,cell, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
-{
-RgSchDlSf       *sf;
-RgSchCellCb     *cell;
-CmLListCp       *dlDrxInactvTmrLst;
-CmLListCp       *dlInActvLst;
-CmLListCp       *ulInActvLst;
-#endif
+Void rgSCHUtlFillRgInfUeInfo(RgSchDlSf *sf,RgSchCellCb *cell,CmLListCp *dlDrxInactvTmrLst,CmLListCp *dlInActvLst,CmLListCp  *ulInActvLst)
 {
    RgInfSfAlloc    *sfAlloc;
    CmLListCp       *lnkLst;   /* lnkLst assignment */
@@ -6225,7 +5044,7 @@ CmLListCp       *ulInActvLst;
    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);
 
@@ -6324,27 +5143,10 @@ CmLListCp       *ulInActvLst;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rgSCHUtlUpdSch
-(
-RgInfSfDatInd    *subfrmInfo,
-RgSchCellCb      *cellCb,
-RgSchUeCb        *ueCb,
-RgInfUeDatInd    *pdu,
-RgSchErrInfo     *err
-)
-#else
-S16 rgSCHUtlUpdSch (subfrmInfo, cellCb, ueCb, pdu, err)
-RgInfSfDatInd    *subfrmInfo;
-RgSchCellCb      *cellCb;
-RgSchUeCb        *ueCb;
-RgInfUeDatInd    *pdu;
-RgSchErrInfo     *err;
-#endif
+S16 rgSCHUtlUpdSch(RgInfSfDatInd *subfrmInfo,RgSchCellCb *cellCb,RgSchUeCb *ueCb,RgInfUeDatInd  *pdu,RgSchErrInfo *err)
 {
 
    S16               ret;
-
 #ifdef LTEMAC_SPS
    if (RGSCH_UL_SPS_ACT_PRSENT & pdu->ceInfo.bitMask)
    {
@@ -6429,17 +5231,7 @@ RgSchErrInfo     *err;
  *  @return  S16
  *      -# ROK
  **/
-#ifdef ANSI
-S16 rgSCHUtlAddUeToCcchSduLst
-(
-RgSchCellCb       *cell,
-RgSchUeCb         *ueCb
-)
-#else
-S16 rgSCHUtlAddUeToCcchSduLst(cell, ueCb)
-RgSchCellCb       *cell;
-RgSchUeCb         *ueCb;
-#endif
+S16 rgSCHUtlAddUeToCcchSduLst(RgSchCellCb  *cell,RgSchUeCb *ueCb)
 {
    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb, cell);
    RgSchDlHqProcCb *hqP  = (RgSchDlHqProcCb *)ueDl->proc;
@@ -6451,7 +5243,7 @@ RgSchUeCb         *ueCb;
        ((!(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;
    }
@@ -6474,24 +5266,14 @@ RgSchUeCb         *ueCb;
  *  @return  S16
  *      -# ROK
  **/
-#ifdef ANSI
-S16 rgSCHUtlUpdtBo
-(
-RgSchCellCb       *cell,
-RgInfCmnBoRpt     *staRsp
-)
-#else
-S16 rgSCHUtlUpdtBo(cell, staRsp)
-RgSchCellCb       *cell;
-RgInfCmnBoRpt     *staRsp;
-#endif
+S16 rgSCHUtlUpdtBo(RgSchCellCb  *cell,RgInfCmnBoRpt *staRsp)
 {
    RgSchUeCb *ueCb;
 
    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 */
@@ -6526,17 +5308,7 @@ RgInfCmnBoRpt     *staRsp;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlHndlCcchBoUpdt
-(
-RgSchCellCb    *cell,
-RgInfCmnBoRpt  *boRpt
-)
-#else
-S16 rgSCHUtlHndlCcchBoUpdt(cell, boRpt)
-RgSchCellCb    *cell;
-RgInfCmnBoRpt  *boRpt;
-#endif
+S16 rgSCHUtlHndlCcchBoUpdt(RgSchCellCb *cell,RgInfCmnBoRpt *boRpt)
 {
    RgSchRaCb       *raCb;
    RgSchUeCb *ueCb;
@@ -6549,8 +5321,7 @@ RgInfCmnBoRpt  *boRpt;
       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
    }
@@ -6585,7 +5356,7 @@ RgInfCmnBoRpt  *boRpt;
          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 */
@@ -6618,19 +5389,7 @@ RgInfCmnBoRpt  *boRpt;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S32 rgSCHUtlGetAllwdCchTbSz
-(
-uint32_t bo,
-uint8_t  *nPrb,
-uint8_t  *mcs
-)
-#else
-S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
-uint32_t bo;
-uint8_t  *nPrb;
-uint8_t  *mcs;
-#endif
+S32 rgSCHUtlGetAllwdCchTbSz(uint32_t bo,uint8_t  *nPrb,uint8_t  *mcs)
 {
    S32 lt;
    S32 cn;
@@ -6675,17 +5434,7 @@ uint8_t  *mcs;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlHndlBcchPcchBoUpdt
-(
-RgSchCellCb    *cell,
-RgInfCmnBoRpt  *boUpdt
-)
-#else
-S16 rgSCHUtlHndlBcchPcchBoUpdt(cell, boUpdt)
-RgSchCellCb    *cell;
-RgInfCmnBoRpt  *boUpdt;
-#endif
+S16 rgSCHUtlHndlBcchPcchBoUpdt(RgSchCellCb *cell,RgInfCmnBoRpt *boUpdt)
 {
    RgSchClcDlLcCb *dlLc;
    RgSchClcBoRpt  *boRpt;
@@ -6696,8 +5445,7 @@ RgInfCmnBoRpt  *boUpdt;
    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)
@@ -6709,7 +5457,7 @@ RgInfCmnBoRpt  *boUpdt;
          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;
          }
@@ -6722,14 +5470,13 @@ RgInfCmnBoRpt  *boUpdt;
    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;
    }
@@ -6777,26 +5524,14 @@ RgInfCmnBoRpt  *boUpdt;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrBndCfm
-(
-Inst          instId,
-SuId          suId,
-uint8_t            status
-)
-#else
-S16 rgSCHUtlRgrBndCfm(instId, suId, status)
-Inst          instId;
-SuId          suId;
-uint8_t            status;
-#endif
+S16 rgSCHUtlRgrBndCfm(Inst instId,SuId suId,uint8_t status)
 {
    S16  ret = ROK;
 
    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);
@@ -6819,26 +5554,14 @@ uint8_t            status;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgmBndCfm
-(
-Inst          instId,
-SuId          suId,
-uint8_t            status
-)
-#else
-S16 rgSCHUtlRgmBndCfm(instId, suId, status)
-Inst          instId;
-SuId          suId;
-uint8_t            status;
-#endif
+S16 rgSCHUtlRgmBndCfm(Inst instId,SuId suId,uint8_t status)
 {
    S16  ret = ROK;
 
    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);
@@ -6863,24 +5586,9 @@ uint8_t            status;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 schSendCfgCfm
-(
-Region        reg,
-Pool          pool,
-RgrCfgTransId transId,
-uint8_t            status
-)
-#else
-S16 schSendCfgCfm(reg, pool, transId, status)
-Region        reg;
-Pool          pool;
-RgrCfgTransId transId;
-uint8_t            status;
-#endif
+S16 schSendCfgCfm(Region reg,Pool pool,RgrCfgTransId transId,uint8_t status)
 {
    Pst cfmPst;
-   Inst inst = 0;
 
    memset((&cfmPst), 0, sizeof(Pst));
 
@@ -6896,8 +5604,7 @@ uint8_t            status;
 
    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;
@@ -6919,17 +5626,7 @@ uint8_t            status;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrTtiInd
-(
-RgSchCellCb          *cell,
-RgrTtiIndInfo        *rgrTti
-)
-#else
-S16 rgSCHUtlRgrTtiInd(cell, rgrTti)
-RgSchCellCb          *cell;
-RgrTtiIndInfo        *rgrTti;
-#endif
+S16 rgSCHUtlRgrTtiInd(RgSchCellCb *cell,RgrTtiIndInfo *rgrTti)
 {
    S16           ret = ROK;
    RgSchUpSapCb  *rgrSap;                    /*!< RGR SAP Control Block */
@@ -6941,8 +5638,7 @@ RgrTtiIndInfo        *rgrTti;
    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;
    }
@@ -6981,7 +5677,6 @@ RgrTtiIndInfo        *rgrTti;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
 S16 rgSCHUtlProcMsg3
 (
 RgInfSfDatInd    *subfrmInfo,
@@ -6990,16 +5685,7 @@ RgSchUeCb        *ueCb,
 CmLteRnti        rnti,
 RgInfUeDatInd    *pdu,
 RgSchErrInfo     *err
- )
-#else
-S16 rgSCHUtlProcMsg3 (subfrmInfo, cellCb, ueCb, rnti, pdu, err)
-RgInfSfDatInd    *subfrmInfo;
-RgSchCellCb      *cellCb;
-RgSchUeCb        *ueCb;
-CmLteRnti        rnti;
-RgInfUeDatInd    *pdu;
-RgSchErrInfo     *err;
-#endif
+)
 {
    S16               ret;
    RgSchRaCb         *raCb;
@@ -7008,7 +5694,7 @@ RgSchErrInfo     *err;
    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;
    }
@@ -7018,7 +5704,7 @@ RgSchErrInfo     *err;
    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);
    }
@@ -7049,19 +5735,7 @@ RgSchErrInfo     *err;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rgSCHUtlSpsRelInd
-(
-RgSchCellCb        *cellCb,
-RgSchUeCb          *ueCb,
-Bool               isExplRel
-)
-#else
-S16 rgSCHUtlSpsRelInd (cellCb, ueCb, isExplRel)
-RgSchCellCb        *cellCb;
-RgSchUeCb          *ueCb;
-Bool               isExplRel;
-#endif
+S16 rgSCHUtlSpsRelInd(RgSchCellCb *cellCb,RgSchUeCb *ueCb,Bool isExplRel)
 {
    cellCb->sc.apis->rgSCHUlSpsRelInd(cellCb, ueCb, isExplRel);
    return ROK;
@@ -7086,19 +5760,7 @@ Bool               isExplRel;
  *      -# ROK
  *      -# RFAILED
  */
-#ifdef ANSI
-S16 rgSCHUtlSpsActInd
-(
-RgSchCellCb        *cellCb,
-RgSchUeCb          *ueCb,
-uint16_t                spsSduSize
-)
-#else
-S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
-RgSchCellCb        *cellCb;
-RgSchUeCb          *ueCb;
-uint16_t                spsSduSize;
-#endif
+S16 rgSCHUtlSpsActInd(RgSchCellCb *cellCb,RgSchUeCb *ueCb,uint16_t spsSduSize)
 {
    cellCb->sc.apis->rgSCHUlSpsActInd(cellCb, ueCb, spsSduSize);
    return ROK;
@@ -7124,38 +5786,23 @@ uint16_t                spsSduSize;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlTfuGrpPwrCntrlReq
-(
-Inst                  inst,
-S16                   sapId,
-TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq
-)
-#else
-S16 rgSCHUtlTfuGrpPwrCntrlReq(inst, sapId, grpPwrCntrlReq)
-Inst                  inst;
-S16                   sapId;
-TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq;
-#endif
+S16 rgSCHUtlTfuGrpPwrCntrlReq(Inst inst,S16 sapId,TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq)
 {
    S16             ret;
    RgSchLowSapCb  *tfuSap;
    Pst             pst;
 
-
    /* Get the lower SAP control block from the layer control block. */
    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 */
@@ -7180,17 +5827,7 @@ TfuGrpPwrCntrlReqInfo *grpPwrCntrlReq;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlDlActvtUe
-(
-RgSchCellCb *cell,
-RgSchUeCb   *ue
-)
-#else
-S16 rgSCHUtlDlActvtUe(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb   *ue;
-#endif
+S16 rgSCHUtlDlActvtUe(RgSchCellCb *cell,RgSchUeCb   *ue)
 {
    cell->sc.apis->rgSCHActvtDlUe(cell, ue);
    return ROK;
@@ -7213,17 +5850,7 @@ RgSchUeCb   *ue;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlUlActvtUe
-(
-RgSchCellCb *cell,
-RgSchUeCb   *ue
-)
-#else
-S16 rgSCHUtlUlActvtUe(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb   *ue;
-#endif
+S16 rgSCHUtlUlActvtUe(RgSchCellCb *cell,RgSchUeCb *ue)
 {
    cell->sc.apis->rgSCHActvtUlUe(cell, ue);
    return ROK;
@@ -7240,23 +5867,13 @@ RgSchUeCb   *ue;
   *   -# ROK
   *   -# RFAILED
   */
-#ifdef ANSI
-S16 rgSCHUtlValidateTfuSap
-(
-Inst  inst,
-SuId  suId
-)
-#else
-S16 rgSCHUtlValidateTfuSap(inst, suId)
-Inst  inst;
-SuId  suId;
-#endif
+S16 rgSCHUtlValidateTfuSap(Inst  inst,SuId  suId)
 {
    RgSchLowSapCb  *tfuSap;
 
    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]);
@@ -7264,13 +5881,13 @@ SuId  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;
    }
@@ -7291,22 +5908,10 @@ SuId  suId;
 *       File:  rg_utl.c
 *
 */
-#ifdef ANSI
-S16 rgSCHUtlAllocEventMem
-(
-Inst      inst,
-Ptr       *memPtr,
-Size      memSize
-)
-#else
-S16 rgSCHUtlAllocEventMem(inst, memPtr, memSize)
-Inst      inst;
-Ptr       *memPtr;
-Size      memSize;
-#endif
+S16 rgSCHUtlAllocEventMem(Inst inst,Ptr *memPtr,Size memSize)
 {
-   Mem              sMem;
-   volatile uint32_t     startTime=0;
+   Mem  sMem;
+   volatile uint32_t  startTime=0;
 
 
    sMem.region = rgSchCb[inst].rgSchInit.region;
@@ -7315,8 +5920,7 @@ Size      memSize;
 #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 */
@@ -7332,7 +5936,7 @@ Size      memSize;
    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*/
@@ -7354,19 +5958,7 @@ Size      memSize;
 *       File:  rg_utl.c
 *
 */
-#ifdef ANSI
-S16 rgSCHUtlGetEventMem
-(
-Ptr       *ptr,
-Size      len,
-Ptr       memCp
-)
-#else
-S16 rgSCHUtlGetEventMem(ptr, len, memCp)
-Ptr       *ptr;
-Size      len;
-Ptr       memCp;
-#endif
+S16 rgSCHUtlGetEventMem(Ptr *ptr,Size len,Ptr memCp)
 {
    S16   ret;
 
@@ -7393,23 +5985,13 @@ Ptr       memCp;
  *  @param[in]  RgSchUeCb           *ue
  *  @return     S16
  **/
-#ifdef ANSI
-S16 rgSCHUtlAllocUeANFdbkInfo
-(
-RgSchUeCb            *ue,
-uint8_t                   servCellIdx
-)
-#else
-S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
-RgSchUeCb            *ue;
-uint8_t                   servCellIdx;
-#endif
+S16 rgSCHUtlAllocUeANFdbkInfo(RgSchUeCb *ue,uint8_t servCellIdx)
 {
    uint8_t idx;
 
    if (rgSCHUtlAllocSBuf(ue->cell->instIdx,
                (Data **) &(ue->cellInfo[servCellIdx]->anInfo), sizeof(RgSchTddANInfo) * \
-               ue->cell->ackNackFdbkArrSize) != ROK)
+   ue->cell->ackNackFdbkArrSize) != ROK)
    {
       return RFAILED;
    }
@@ -7436,17 +6018,7 @@ uint8_t                   servCellIdx;
  *  @param[in]  RgSchUeCb           *ue
  *  @return     Void
  **/
-#ifdef ANSI
-Void rgSCHUtlDelUeANFdbkInfo
-(
-RgSchUeCb            *ue,
-uint8_t                   servCellIdx
-)
-#else
-Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
-RgSchUeCb            *ue;
-uint8_t                   servCellIdx;
-#endif
+Void rgSCHUtlDelUeANFdbkInfo(RgSchUeCb *ue,uint8_t servCellIdx)
 {
 
    /* ccpu00117052 - MOD - Passing double pointer
@@ -7470,15 +6042,7 @@ uint8_t                   servCellIdx;
  *  @param[in]  RgSchTddANInfo   *anFdInfo
  *  @return     S16
  **/
-#ifdef ANSI
-S16 rgSCHUtlInitUeANFdbkInfo
-(
-RgSchTddANInfo       *anFdInfo
-)
-#else
-S16 rgSCHUtlInitUeANFdbkInfo(anFdInfo)
-RgSchTddANInfo       *anFdInfo;
-#endif
+S16 rgSCHUtlInitUeANFdbkInfo(RgSchTddANInfo *anFdInfo)
 {
 
    anFdInfo->sfn = RGSCH_MAX_SFN+1; /* defensively setting invalid sfn */
@@ -7504,19 +6068,7 @@ RgSchTddANInfo       *anFdInfo;
  *  @param[in]  CmLteTimingInfo  *time
  *  @return     RgSchTddANInfo*
  **/
-#ifdef ANSI
-RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo
-(
-RgSchUeCb         *ueCb,
-CmLteTimingInfo   *timeInfo,
-uint8_t                servCellIdx
-)
-#else
-RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
-RgSchUeCb         *ueCb;
-CmLteTimingInfo   *timeInfo;
-uint8_t                servCellIdx;
-#endif
+RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(RgSchUeCb *ueCb,CmLteTimingInfo *timeInfo,uint8_t servCellIdx)
 {
    uint8_t idx;
 
@@ -7545,17 +6097,7 @@ uint8_t                servCellIdx;
  *  @return uint8_t
  *
  **/
-#ifdef ANSI
-uint8_t  rgSCHUtlGetDlSfIdx
-(
-RgSchCellCb        *cell,
-CmLteTimingInfo *timeInfo
-)
-#else
-uint8_t  rgSCHUtlGetDlSfIdx(cell, timeInfo)
-RgSchCellCb        *cell;
-CmLteTimingInfo *timeInfo;
-#endif
+uint8_t  rgSCHUtlGetDlSfIdx(RgSchCellCb  *cell,CmLteTimingInfo *timeInfo)
 {
    uint16_t       idx = 0;
 
@@ -7584,23 +6126,7 @@ CmLteTimingInfo *timeInfo;
  *  @return uint8_t
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlGetNxtDlSfInfo
-(
-CmLteTimingInfo   curDlTime,
-RgSchCellCb       *cell,
-RgSchDlSf         *dlSf,
-RgSchDlSf         **nxtDlsf,
-CmLteTimingInfo   *nxtDlTime
-)
-#else
-Void rgSCHUtlGetNxtDlSfInfo(curDlTime, cell, dlSf, nxtDlsf, nxtDlTime)
-CmLteTimingInfo   curDlTime;
-RgSchCellCb       *cell;
-RgSchDlSf         *dlSf;
-RgSchDlSf         **nxtDlsf;
-CmLteTimingInfo   *nxtDlTime;
-#endif
+Void rgSCHUtlGetNxtDlSfInfo(CmLteTimingInfo curDlTime,RgSchCellCb  *cell,RgSchDlSf *dlSf,RgSchDlSf **nxtDlsf,CmLteTimingInfo *nxtDlTime)
 {
    uint16_t  idx = curDlTime.slot;
    uint8_t   count = 0;
@@ -7638,21 +6164,7 @@ CmLteTimingInfo   *nxtDlTime;
  *  @return uint8_t
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlGetPrevDlSfInfo
-(
-RgSchCellCb       *cell,
-CmLteTimingInfo   curDlTime,
-CmLteTimingInfo   *prevDlTime,
-uint8_t                *numSubfrm
-)
-#else
-Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
-RgSchCellCb       *cell;
-CmLteTimingInfo   curDlTime;
-CmLteTimingInfo   *prevDlTime;
-uint8_t                *numSubfrm;
-#endif
+Void rgSCHUtlGetPrevDlSfInfo(RgSchCellCb *cell,CmLteTimingInfo curDlTime,CmLteTimingInfo *prevDlTime,uint8_t *numSubfrm)
 {
    S16 idx = curDlTime.slot;
    uint8_t  count = 0;
@@ -7688,21 +6200,7 @@ uint8_t                *numSubfrm;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlUlSfInit
-(
-RgSchCellCb  *cell,
-RgSchUlSf    *sf,
-uint8_t           idx,
-uint8_t           maxUePerSf
-)
-#else
-S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
-RgSchCellCb  *cell;
-RgSchUlSf    *sf;
-uint8_t           idx;
-uint8_t           maxUePerSf;
-#endif
+S16 rgSCHUtlUlSfInit(RgSchCellCb  *cell,RgSchUlSf *sf,uint8_t idx,uint8_t maxUePerSf)
 {
    S16             ret=ROK;
 
@@ -7794,17 +6292,7 @@ uint8_t           maxUePerSf;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlSfDeinit
-(
-RgSchCellCb  *cell,
-RgSchUlSf    *sf
-)
-#else
-Void rgSCHUtlUlSfDeinit(cell, sf)
-RgSchCellCb  *cell;
-RgSchUlSf    *sf;
-#endif
+Void rgSCHUtlUlSfDeinit(RgSchCellCb  *cell,RgSchUlSf  *sf)
 {
    if (sf->allocDb)
    {
@@ -7840,19 +6328,7 @@ RgSchUlSf    *sf;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static S16 rgSCHUtlUlAllocDbInit
-(
-RgSchCellCb    *cell,
-RgSchUlAllocDb *allocDb,
-uint8_t             maxAllocs
-)
-#else
-static S16 rgSCHUtlUlAllocDbInit(cell, allocDb, maxAllocs)
-RgSchCellCb    *cell;
-RgSchUlAllocDb *allocDb;
-uint8_t             maxAllocs;
-#endif
+static S16 rgSCHUtlUlAllocDbInit(RgSchCellCb *cell,RgSchUlAllocDb *allocDb,uint8_t maxAllocs)
 {
    S16 ret = rgSCHUtlUlAllocMemInit(cell, &allocDb->mem, maxAllocs);
    if (ret != ROK)
@@ -7878,17 +6354,7 @@ uint8_t             maxAllocs;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static Void rgSCHUtlUlAllocDbDeinit
-(
-RgSchCellCb     *cell,
-RgSchUlAllocDb *allocDb
-)
-#else
-static Void rgSCHUtlUlAllocDbDeinit(cell, allocDb)
-RgSchCellCb     *cell;
-RgSchUlAllocDb *allocDb;
-#endif
+static Void rgSCHUtlUlAllocDbDeinit(RgSchCellCb *cell,RgSchUlAllocDb *allocDb)
 {
    rgSCHUtlUlAllocMemDeinit(cell, &allocDb->mem);
    allocDb->count = 0;
@@ -7909,23 +6375,7 @@ RgSchUlAllocDb *allocDb;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static S16 rgSCHUtlUlHoleDbInit
-(
-RgSchCellCb   *cell,
-RgSchUlHoleDb *holeDb,
-uint8_t            maxHoles,
-uint8_t            start,
-uint8_t            num
-)
-#else
-static S16 rgSCHUtlUlHoleDbInit(cell, holeDb, maxHoles, start, num)
-RgSchCellCb   *cell;
-RgSchUlHoleDb *holeDb;
-uint8_t            maxHoles;
-uint8_t            start;
-uint8_t            num;
-#endif
+static S16 rgSCHUtlUlHoleDbInit(RgSchCellCb *cell,RgSchUlHoleDb *holeDb,uint8_t maxHoles,uint8_t start,uint8_t num)
 {
    S16 ret;
    RgSchUlHole *hole = NULLP;
@@ -7956,17 +6406,7 @@ uint8_t            num;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static Void rgSCHUtlUlHoleDbDeinit
-(
-RgSchCellCb   *cell,
-RgSchUlHoleDb *holeDb
-)
-#else
-static Void rgSCHUtlUlHoleDbDeinit(cell, holeDb)
-RgSchCellCb   *cell;
-RgSchUlHoleDb *holeDb;
-#endif
+static Void rgSCHUtlUlHoleDbDeinit(RgSchCellCb   *cell,RgSchUlHoleDb *holeDb)
 {
    rgSCHUtlUlHoleMemDeinit(cell, &holeDb->mem);
    holeDb->count = 0;
@@ -7988,19 +6428,7 @@ RgSchUlHoleDb *holeDb;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocGetHole
-(
-RgSchUlSf   *sf,
-uint8_t       numSb,
-RgSchUlHole *hole
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
-RgSchUlSf   *sf;
-uint8_t       numSb;
-RgSchUlHole *hole;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocGetHole(RgSchUlSf *sf,uint8_t numSb,RgSchUlHole *hole)
 {
    if (numSb < hole->num)
    {
@@ -8026,17 +6454,7 @@ RgSchUlHole *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole
-(
-RgSchUlSf   *sf,
-RgSchUlHole *hole
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(sf, hole)
-RgSchUlSf   *sf;
-RgSchUlHole *hole;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole(RgSchUlSf   *sf,RgSchUlHole *hole)
 {
    RgSchUlAlloc *alloc;
       /* alloc = rgSCHUtlUlAllocGetAndIns(sf->allocDb, hole->prvAlloc, hole->nxtAlloc); */
@@ -8093,19 +6511,7 @@ RgSchUlHole *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
-(
-RgSchUlSf   *sf,
-uint8_t       numSb,
-RgSchUlHole *hole
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
-RgSchUlSf   *sf;
-uint8_t       numSb;
-RgSchUlHole *hole;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(RgSchUlSf *sf,uint8_t numSb,RgSchUlHole *hole)
 {
    RgSchUlAlloc *alloc;
       /* alloc = rgSCHUtlUlAllocGetAndIns(sf->allocDb, hole->prvAlloc, hole->nxtAlloc); */
@@ -8158,15 +6564,7 @@ RgSchUlHole *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocFirst
-(
-RgSchUlSf *sf
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocFirst(sf)
-RgSchUlSf *sf;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocFirst(RgSchUlSf *sf)
 {
    return (sf->allocDb->first);
 }
@@ -8184,17 +6582,7 @@ RgSchUlSf *sf;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocNxt
-(
-RgSchUlSf    *sf,
-RgSchUlAlloc *alloc
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocNxt(sf, alloc)
-RgSchUlSf    *sf;
-RgSchUlAlloc *alloc;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocNxt(RgSchUlSf    *sf,RgSchUlAlloc *alloc)
 {
    UNUSED(sf);
    return (alloc->nxt);
@@ -8219,17 +6607,7 @@ RgSchUlAlloc *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt
-(
-RgSchUlAllocDb *db,
-RgSchUlAlloc   *prv
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(db, prv)
-RgSchUlAllocDb *db;
-RgSchUlAlloc   *prv;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocGetAdjNxt(RgSchUlAllocDb *db,RgSchUlAlloc   *prv)
 {
    RgSchUlAlloc *alloc = rgSCHUtlUlAllocMemGet(&db->mem);
    RgSchUlAlloc *nxt = prv->nxt;
@@ -8271,15 +6649,7 @@ RgSchUlAlloc   *prv;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocGetFirst
-(
-RgSchUlAllocDb *db
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(db)
-RgSchUlAllocDb *db;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocGetFirst(RgSchUlAllocDb *db)
 {
    RgSchUlAlloc *alloc = rgSCHUtlUlAllocMemGet(&db->mem);
    RgSchUlAlloc *nxt = db->first;
@@ -8318,15 +6688,7 @@ RgSchUlAllocDb *db;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleAddAllocation
-(
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHUtlUlHoleAddAllocation(alloc)
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHUtlUlHoleAddAllocation(RgSchUlAlloc *alloc)
 {
    /* Note: rgSchCmnUlHoleUpdAllocLnks function that is used should not exist as
     * one, if such excessive branching is done (AllocNone, AllocNoPrv etc).
@@ -8373,15 +6735,7 @@ RgSchUlAlloc *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlAllocRelease
-(
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHUtlUlAllocRelease(alloc)
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHUtlUlAllocRelease(RgSchUlAlloc *alloc)
 {
    RgSchUlAllocDb *allocDb = alloc->allocDbRef;
    RgSchUlAlloc   *prv = alloc->prv;
@@ -8428,17 +6782,7 @@ RgSchUlAlloc *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlAllocRls
-(
-RgSchUlSf    *sf,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHUtlUlAllocRls(sf, alloc)
-RgSchUlSf    *sf;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHUtlUlAllocRls(RgSchUlSf *sf,RgSchUlAlloc *alloc)
 {
    RgSchUlAllocDb *allocDb = sf->allocDb;
    RgSchUlAlloc   *prv = alloc->prv;
@@ -8473,10 +6817,10 @@ RgSchUlAlloc *alloc;
    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;
 }
@@ -8494,15 +6838,7 @@ RgSchUlAlloc *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlHole *rgSCHUtlUlHoleFirst
-(
-RgSchUlSf *sf
-)
-#else
-RgSchUlHole *rgSCHUtlUlHoleFirst(sf)
-RgSchUlSf *sf;
-#endif
+RgSchUlHole *rgSCHUtlUlHoleFirst(RgSchUlSf *sf)
 {
    return (sf->holeDb->first);
 }
@@ -8520,17 +6856,7 @@ RgSchUlSf *sf;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlHole *rgSCHUtlUlHoleNxt
-(
-RgSchUlSf   *sf,
-RgSchUlHole *hole
-)
-#else
-RgSchUlHole *rgSCHUtlUlHoleNxt(sf, hole)
-RgSchUlSf   *sf;
-RgSchUlHole *hole;
-#endif
+RgSchUlHole *rgSCHUtlUlHoleNxt(RgSchUlSf   *sf,RgSchUlHole *hole)
 {
    UNUSED(sf);
    return (hole->nxt);
@@ -8549,17 +6875,7 @@ RgSchUlHole *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleAddAlloc
-(
-RgSchUlSf    *sf,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHUtlUlHoleAddAlloc(sf, alloc)
-RgSchUlSf    *sf;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHUtlUlHoleAddAlloc(RgSchUlSf *sf,RgSchUlAlloc *alloc)
 {
    /* Note: rgSchCmnUlHoleUpdAllocLnks function that is used should not exist as
     * one, if such excessive branching is done (AllocNone, AllocNoPrv etc).
@@ -8609,21 +6925,7 @@ RgSchUlAlloc *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleJoin
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *prv,
-RgSchUlHole   *nxt,
-RgSchUlAlloc  *alloc
-)
-#else
-Void rgSCHUtlUlHoleJoin(db, prv, nxt, alloc)
-RgSchUlHoleDb *db;
-RgSchUlHole   *prv;
-RgSchUlHole   *nxt;
-RgSchUlAlloc  *alloc;
-#endif
+Void rgSCHUtlUlHoleJoin(RgSchUlHoleDb *db,RgSchUlHole *prv,RgSchUlHole *nxt,RgSchUlAlloc *alloc)
 {
    prv->num += alloc->numSb + nxt->num;
    rgSCHUtlUlHoleRls(db, nxt);
@@ -8647,19 +6949,7 @@ RgSchUlAlloc  *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleExtndRight
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *prv,
-RgSchUlAlloc  *alloc
-)
-#else
-Void rgSCHUtlUlHoleExtndRight(db, prv, alloc)
-RgSchUlHoleDb *db;
-RgSchUlHole   *prv;
-RgSchUlAlloc  *alloc;
-#endif
+Void rgSCHUtlUlHoleExtndRight(RgSchUlHoleDb *db,RgSchUlHole *prv,RgSchUlAlloc *alloc)
 {
    prv->num += alloc->numSb;
    rgSCHUtlUlHoleIncr(db, prv);
@@ -8681,19 +6971,7 @@ RgSchUlAlloc  *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleExtndLeft
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *nxt,
-RgSchUlAlloc  *alloc
-)
-#else
-Void rgSCHUtlUlHoleExtndLeft(db, nxt, alloc)
-RgSchUlHoleDb *db;
-RgSchUlHole   *nxt;
-RgSchUlAlloc  *alloc;
-#endif
+Void rgSCHUtlUlHoleExtndLeft(RgSchUlHoleDb *db,RgSchUlHole   *nxt,RgSchUlAlloc  *alloc)
 {
    nxt->num += alloc->numSb;
    nxt->start = alloc->sbStart;
@@ -8715,17 +6993,7 @@ RgSchUlAlloc  *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleNew
-(
-RgSchUlHoleDb *db,
-RgSchUlAlloc  *alloc
-)
-#else
-Void rgSCHUtlUlHoleNew(db, alloc)
-RgSchUlHoleDb *db;
-RgSchUlAlloc  *alloc;
-#endif
+Void rgSCHUtlUlHoleNew(RgSchUlHoleDb *db,RgSchUlAlloc  *alloc)
 {
    RgSchUlHole *hole = rgSCHUtlUlHoleMemGet(&db->mem);
 #if (ERRCLASS & ERRCLS_DEBUG)
@@ -8755,19 +7023,7 @@ RgSchUlAlloc  *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleUpdAllocLnks
-(
-RgSchUlHole  *hole,
-RgSchUlAlloc *prvAlloc,
-RgSchUlAlloc *nxtAlloc
-)
-#else
-Void rgSCHUtlUlHoleUpdAllocLnks(hole, prvAlloc, nxtAlloc)
-RgSchUlHole  *hole;
-RgSchUlAlloc *prvAlloc;
-RgSchUlAlloc *nxtAlloc;
-#endif
+Void rgSCHUtlUlHoleUpdAllocLnks(RgSchUlHole  *hole,RgSchUlAlloc *prvAlloc,RgSchUlAlloc *nxtAlloc)
 {
    if (prvAlloc)
    {
@@ -8797,17 +7053,7 @@ RgSchUlAlloc *nxtAlloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleIns
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *hole
-)
-#else
-Void rgSCHUtlUlHoleIns(db, hole)
-RgSchUlHoleDb *db;
-RgSchUlHole   *hole;
-#endif
+Void rgSCHUtlUlHoleIns(RgSchUlHoleDb *db,RgSchUlHole   *hole)
 {
    RgSchUlHole *cur;
 
@@ -8866,17 +7112,7 @@ RgSchUlHole   *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleIncr
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *hole
-)
-#else
-Void rgSCHUtlUlHoleIncr(db, hole)
-RgSchUlHoleDb *db;
-RgSchUlHole   *hole;
-#endif
+Void rgSCHUtlUlHoleIncr(RgSchUlHoleDb *db,RgSchUlHole   *hole)
 {
    RgSchUlHole *cur;
 
@@ -8933,17 +7169,7 @@ RgSchUlHole   *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleDecr
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *hole
-)
-#else
-Void rgSCHUtlUlHoleDecr(db, hole)
-RgSchUlHoleDb *db;
-RgSchUlHole   *hole;
-#endif
+Void rgSCHUtlUlHoleDecr(RgSchUlHoleDb *db,RgSchUlHole   *hole)
 {
    RgSchUlHole *cur;
 
@@ -9005,17 +7231,7 @@ RgSchUlHole   *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleRls
-(
-RgSchUlHoleDb *db,
-RgSchUlHole   *hole
-)
-#else
-Void rgSCHUtlUlHoleRls(db, hole)
-RgSchUlHoleDb *db;
-RgSchUlHole   *hole;
-#endif
+Void rgSCHUtlUlHoleRls(RgSchUlHoleDb *db,RgSchUlHole   *hole)
 {
    RgSchUlHole *prv = hole->prv;
    RgSchUlHole *nxt = hole->nxt;
@@ -9056,19 +7272,7 @@ RgSchUlHole   *hole;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlUlAllocMemInit
-(
-RgSchCellCb     *cell,
-RgSchUlAllocMem *mem,
-uint8_t           maxAllocs
-)
-#else
-S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
-RgSchCellCb     *cell;
-RgSchUlAllocMem *mem;
-uint8_t           maxAllocs;
-#endif
+S16 rgSCHUtlUlAllocMemInit(RgSchCellCb *cell,RgSchUlAllocMem *mem,uint8_t maxAllocs)
 {
    S16 ret;
    RgSchUlAlloc *allocs;
@@ -9116,17 +7320,7 @@ uint8_t           maxAllocs;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlAllocMemDeinit
-(
-RgSchCellCb     *cell,
-RgSchUlAllocMem *mem
-)
-#else
-Void rgSCHUtlUlAllocMemDeinit(cell, mem)
-RgSchCellCb     *cell;
-RgSchUlAllocMem *mem;
-#endif
+Void rgSCHUtlUlAllocMemDeinit(RgSchCellCb     *cell,RgSchUlAllocMem *mem)
 {
    /* ccpu00117052 - MOD - Passing double pointer
    for proper NULLP assignment*/
@@ -9151,21 +7345,7 @@ RgSchUlAllocMem *mem;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-S16 rgSCHUtlUlHoleMemInit
-(
-RgSchCellCb    *cell,
-RgSchUlHoleMem *mem,
-uint8_t          maxHoles,
-RgSchUlHole    **holeRef
-)
-#else
-S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
-RgSchCellCb     *cell;
-RgSchUlHoleMem *mem;
-uint8_t          maxHoles;
-RgSchUlHole    **holeRef;
-#endif
+S16 rgSCHUtlUlHoleMemInit(RgSchCellCb  *cell,RgSchUlHoleMem *mem,uint8_t  maxHoles,RgSchUlHole **holeRef)
 {
    S16 ret;
    RgSchUlHole *holes;
@@ -9221,17 +7401,7 @@ RgSchUlHole    **holeRef;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleMemDeinit
-(
-RgSchCellCb    *cell,
-RgSchUlHoleMem *mem
-)
-#else
-Void rgSCHUtlUlHoleMemDeinit(cell, mem)
-RgSchCellCb    *cell;
-RgSchUlHoleMem *mem;
-#endif
+Void rgSCHUtlUlHoleMemDeinit(RgSchCellCb  *cell,RgSchUlHoleMem *mem)
 {
    /* ccpu00117052 - MOD - Passing double pointer
    for proper NULLP assignment*/
@@ -9255,15 +7425,7 @@ RgSchUlHoleMem *mem;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlAllocMemGet
-(
-RgSchUlAllocMem *mem
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlAllocMemGet(mem)
-RgSchUlAllocMem *mem;
-#endif
+RgSchUlAlloc *rgSCHUtlUlAllocMemGet(RgSchUlAllocMem *mem)
 {
    RgSchUlAlloc *alloc;
 
@@ -9295,17 +7457,7 @@ RgSchUlAllocMem *mem;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlAllocMemRls
-(
-RgSchUlAllocMem *mem,
-RgSchUlAlloc    *alloc
-)
-#else
-Void rgSCHUtlUlAllocMemRls(mem, alloc)
-RgSchUlAllocMem *mem;
-RgSchUlAlloc    *alloc;
-#endif
+Void rgSCHUtlUlAllocMemRls(RgSchUlAllocMem *mem,RgSchUlAlloc  *alloc)
 {
    alloc->prv = NULLP;
 
@@ -9331,15 +7483,7 @@ RgSchUlAlloc    *alloc;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-RgSchUlHole *rgSCHUtlUlHoleMemGet
-(
-RgSchUlHoleMem *mem
-)
-#else
-RgSchUlHole *rgSCHUtlUlHoleMemGet(mem)
-RgSchUlHoleMem *mem;
-#endif
+RgSchUlHole *rgSCHUtlUlHoleMemGet(RgSchUlHoleMem *mem)
 {
    RgSchUlHole *hole;
 
@@ -9372,17 +7516,7 @@ RgSchUlHoleMem *mem;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlUlHoleMemRls
-(
-RgSchUlHoleMem *mem,
-RgSchUlHole    *hole
-)
-#else
-Void rgSCHUtlUlHoleMemRls(mem, hole)
-RgSchUlHoleMem *mem;
-RgSchUlHole    *hole;
-#endif
+Void rgSCHUtlUlHoleMemRls(RgSchUlHoleMem *mem,RgSchUlHole    *hole)
 {
    hole->prv = NULLP;
 
@@ -9414,19 +7548,7 @@ RgSchUlHole    *hole;
  *  @param[in]  uint8_t            numSb
  *  @return  RgSchUlAlloc*
  **/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
-(
-RgSchUlSf       *sf,
-uint8_t              startSb,
-uint8_t              numSb
-)
-#else
-RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
-RgSchUlSf       *sf;
-uint8_t              startSb;
-uint8_t              numSb;
-#endif
+RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(RgSchUlSf *sf,uint8_t startSb,uint8_t  numSb)
 {
    RgSchUlHole     *hole, *nxtHole;
    RgSchUlAlloc    *alloc = NULLP;
@@ -9507,24 +7629,11 @@ uint8_t              numSb;
  *           ROK
  *           RFAILED
  **/
-#ifdef ANSI
-static S16 rgSCHUtlValidateQci
-(
-RgSchCellCb  *cellCb,
-uint8_t           numQci,
-uint8_t           *qci
-)
-#else
-static S16 rgSCHUtlValidateQci(cellCb, numQci, qci)
-RgSchCellCb  *cellCb;
-uint8_t           numQci;
-uint8_t           *qci;
-#endif
+static S16 rgSCHUtlValidateQci(RgSchCellCb  *cellCb,uint8_t numQci,uint8_t *qci)
 {
    uint8_t        qciIdx;
    uint8_t        qciVal;
 
-
    for(qciIdx = 0; qciIdx < numQci; qciIdx++)
    {
       qciVal = qci[qciIdx];
@@ -9552,26 +7661,12 @@ uint8_t           *qci;
  *  @param[out] RgSchErrInfo       *err
  *  @return  RgSchUlAlloc*
  **/
-#ifdef ANSI
-S16 rgSCHUtlValidateMeasReq
-(
-RgSchCellCb       *cellCb, 
-LrgSchMeasReqInfo *schL2MeasInfo,
-RgSchErrInfo      *err
-)
-#else
-S16 rgSCHUtlValidateMeasReq(cellCb, schL2MeasInfo, err)
-RgSchCellCb       *cellCb;
-LrgSchMeasReqInfo *schL2MeasInfo;
-RgSchErrInfo      *err;
-#endif
+S16 rgSCHUtlValidateMeasReq(RgSchCellCb *cellCb, LrgSchMeasReqInfo *schL2MeasInfo,RgSchErrInfo *err)
 {
    uint16_t    measType;
    S16   ret;
 
-
    measType = schL2MeasInfo->measType;
-
    if((measType == 0) ||
        measType > 2047)
    {
@@ -9655,34 +7750,17 @@ RgSchErrInfo      *err;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrSiCfgCfm
-(
-Inst          instId,
-SpId          spId,
-RgrCfgTransId transId,
-uint8_t            status
-)
-#else
-S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
-Inst          instId;
-SpId          spId;
-RgrCfgTransId transId;
-uint8_t            status;
-#endif
+S16 rgSCHUtlRgrSiCfgCfm(Inst instId,SpId  spId,RgrCfgTransId transId,uint8_t status)
 {
    uint8_t        prntTrans[RGR_CFG_TRANSID_SIZE+1];
 
-
    memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
    prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
-
-
    if(RgUiRgrSiCfgCfm(&rgSchCb[instId].rgrSap[spId].sapCfg.sapPst,
                     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;
    }
@@ -9709,36 +7787,18 @@ uint8_t            status;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrWarningSiCfgCfm
-(
-Inst          instId,
-SpId          spId,
-uint8_t            siId,
-RgrCfgTransId transId,
-uint8_t            status
-)
-#else
-S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
-Inst          instId;
-SpId          spId;
-uint8_t            siId;
-RgrCfgTransId transId;
-uint8_t            status;
-#endif
+S16 rgSCHUtlRgrWarningSiCfgCfm(Inst instId,SpId spId,uint8_t siId,RgrCfgTransId transId,uint8_t  status)
 {
    uint8_t        prntTrans[RGR_CFG_TRANSID_SIZE+1];
 
-
    memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
    prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
-
-
+   
    if(RgUiRgrWarningSiCfgCfm(&rgSchCb[instId].rgrSap[spId].sapCfg.sapPst,
                     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;
    }
@@ -9759,15 +7819,7 @@ uint8_t            status;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
-Void rgSCHUtlPutSiInfo
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHUtlPutSiInfo(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHUtlPutSiInfo(RgSchCellCb *cell)
 {
    uint8_t    idx = 0;
    uint32_t   sizeOfSiInfo = 0;
@@ -9815,7 +7867,6 @@ RgSchCellCb *cell;
  *     File : rg_utl.c
  *
  **********************************************************/
-#ifdef ANSI
 S16 rgSCHUtlGetDrxSchdUesInDl
 (
 RgSchCellCb     *cellCb,
@@ -9826,25 +7877,12 @@ CmLListCp       *dlDrxInactvTmrLst,
 CmLListCp       *dlInActvLst,
 CmLListCp       *ulInActvLst
 )
-#else
-S16 rgSCHUtlGetDrxSchdUesInDl(cellCb, ueCb, dlHq, allocInfo, dlDrxInactvTmrLst, dlInActvLst, ulInActvLst)
-RgSchCellCb     *cellCb;
-RgSchUeCb       *ueCb;
-RgSchDlHqProcCb *dlHq;
-RgInfUeAlloc    *allocInfo;
-CmLListCp       *dlDrxInactvTmrLst;
-CmLListCp       *dlInActvLst;
-CmLListCp       *ulInActvLst;
-#endif
 {
    Bool                  isNewTx = FALSE;
    uint8_t                    idx;
    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;
@@ -9871,9 +7909,9 @@ CmLListCp       *ulInActvLst;
             /* 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);
@@ -9972,21 +8010,7 @@ CmLListCp       *ulInActvLst;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlFillSndStaInd
-(
-RgSchCellCb        *cell,
-RgSchUeCb          *ue,
-RgrStaIndInfo      *staInfo,
-uint8_t                 numCqiRept
-)
-#else
-S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
-RgSchCellCb        *cell;
-RgSchUeCb          *ue;
-RgrStaIndInfo      *staInfo;
-uint8_t                 numCqiRept;
-#endif
+S16 rgSCHUtlFillSndStaInd(RgSchCellCb *cell,RgSchUeCb *ue,RgrStaIndInfo *staInfo,uint8_t numCqiRept)
 {
    uint8_t idxStart;
 
@@ -10012,7 +8036,7 @@ uint8_t                 numCqiRept;
    /* 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;
    }
@@ -10040,28 +8064,15 @@ uint8_t                 numCqiRept;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrStaInd
-(
-RgSchCellCb          *cell,
-RgrStaIndInfo        *rgrSta
-)
-#else
-S16 rgSCHUtlRgrStaInd(cell, rgrSta)
-RgSchCellCb          *cell;
-RgrStaIndInfo        *rgrSta;
-#endif
+S16 rgSCHUtlRgrStaInd(RgSchCellCb *cell,RgrStaIndInfo *rgrSta)
 {
    S16           ret = ROK;
    RgSchUpSapCb  *rgrSap;                    /*!< RGR SAP Control Block */
-
-
-
+   
    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;
    }
@@ -10091,21 +8102,7 @@ RgrStaIndInfo        *rgrSta;
  *  @return  Void
  *      -# ROK 
  **/
-#ifdef ANSI
-Void rgSCHUtlIndRntiRls2Mac 
-(
-RgSchCellCb    *cell,
-CmLteRnti      rnti,
-Bool           ueIdChng,
-CmLteRnti      newRnti
-)
-#else
-Void rgSCHUtlIndRntiRls2Mac(cell, rnti, ueIdChng, newRnti)
-RgSchCellCb    *cell;
-CmLteRnti      rnti;
-Bool           ueIdChng;
-CmLteRnti      newRnti;
-#endif
+Void rgSCHUtlIndRntiRls2Mac(RgSchCellCb *cell,CmLteRnti  rnti,Bool ueIdChng,CmLteRnti newRnti)
 {
    Pst          pst;
    Inst         inst = cell->instIdx;
@@ -10146,17 +8143,7 @@ CmLteRnti      newRnti;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrLoadInfInd
-(
- RgSchCellCb           *cell,
- RgrLoadInfIndInfo     *rgrLoadInf
- )
-#else
-S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
-   RgSchCellCb           *cell;
-   RgrLoadInfIndInfo     *rgrLoadInf;
-#endif
+S16 rgSCHUtlRgrLoadInfInd(RgSchCellCb *cell,RgrLoadInfIndInfo *rgrLoadInf)
 {
    S16           ret = ROK;
    RgSchUpSapCb  *rgrSap;                    /*!< RGR SAP Control Block */
@@ -10164,8 +8151,7 @@ S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
    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;
    }
@@ -10196,21 +8182,7 @@ S16 rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf)
  *  @return  Void
  **/
 
-#ifdef ANSI
-Void rgSCHUtlRlsRnti
-(
-RgSchCellCb    *cell,
-RgSchRntiLnk   *rntiLnk,
-Bool           ueIdChngd,
-CmLteRnti      newRnti
-)
-#else
-Void rgSCHUtlRlsRnti(cell, rntiLnk, ueIdChngd, newRnti)
-RgSchCellCb    *cell;
-RgSchRntiLnk   *rntiLnk;
-Bool           ueIdChngd;
-CmLteRnti      newRnti;
-#endif
+Void rgSCHUtlRlsRnti(RgSchCellCb *cell,RgSchRntiLnk  *rntiLnk,Bool ueIdChngd,CmLteRnti newRnti)
 {
 
    uint8_t isLegacy = 0;
@@ -10248,19 +8220,7 @@ CmLteRnti      newRnti;
  *  @return  Void
  *
  **/
-#ifdef ANSI
-S16 rgSCHUtlFillSndUeStaInd
-(
-RgSchCellCb          *cell,
-RgSchUeCb            *ue,
-RgrUeStaIndInfo      *ueStaInfo
-)
-#else
-S16 rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInfo)
-RgSchCellCb          *cell;
-RgSchUeCb            *ue;
-RgrUeStaIndInfo      *ueStaInfo;
-#endif
+S16 rgSCHUtlFillSndUeStaInd(RgSchCellCb *cell,RgSchUeCb  *ue,RgrUeStaIndInfo  *ueStaInfo)
 {
 
    ueStaInfo->cellId = cell->cellId;
@@ -10269,7 +8229,7 @@ RgrUeStaIndInfo      *ueStaInfo;
    /* 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;
    }
@@ -10297,17 +8257,7 @@ RgrUeStaIndInfo      *ueStaInfo;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlRgrUeStaInd
-(
-RgSchCellCb          *cell,
-RgrUeStaIndInfo      *rgrUeSta
-)
-#else
-S16 rgSCHUtlRgrUeStaInd(cell, rgrUeSta)
-RgSchCellCb          *cell;
-RgrUeStaIndInfo      *rgrUeSta;
-#endif
+S16 rgSCHUtlRgrUeStaInd(RgSchCellCb *cell,RgrUeStaIndInfo *rgrUeSta)
 {
    S16           ret = ROK;
    RgSchUpSapCb  *rgrSap;                    /*!< RGR SAP Control Block */
@@ -10315,8 +8265,7 @@ RgrUeStaIndInfo      *rgrUeSta;
    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;
    }
@@ -10339,15 +8288,7 @@ RgrUeStaIndInfo      *rgrUeSta;
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlUpdAvgPrbUsage
-(
-RgSchCellCb          *cell
-)
-#else
-S16 rgSCHUtlUpdAvgPrbUsage(cell)
-RgSchCellCb       *cell;
-#endif
+S16 rgSCHUtlUpdAvgPrbUsage(RgSchCellCb  *cell)
 {
    CmLteTimingInfo  frm;
    RgmPrbRprtInd    *prbRprtInd;
@@ -10388,10 +8329,10 @@ RgSchCellCb       *cell;
      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;
    }
 
@@ -10430,10 +8371,10 @@ RgSchCellCb       *cell;
 #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,
@@ -10466,17 +8407,7 @@ RgSchCellCb       *cell;
  *  @return  Void 
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlReTxTa 
-(
-RgSchCellCb       *cellCb,
-RgSchUeCb         *ueCb
-)
-#else
-Void rgSCHUtlReTxTa(cellCb, ueCb)
-RgSchCellCb       *cellCb;
-RgSchUeCb         *ueCb;
-#endif
+Void rgSCHUtlReTxTa(RgSchCellCb *cellCb,RgSchUeCb *ueCb)
 {
 
    /* If TA Timer is running. Stop it */
@@ -10516,17 +8447,7 @@ RgSchUeCb         *ueCb;
  *      -# ROK 
  *      -# RFAILED
  **/
-#ifdef ANSI
-static S16 rgSCHChkBoUpdate
-(
-RgSchCellCb    *cell,
-RgInfCmnBoRpt  *boUpdt
-)
-#else
-static S16 rgSCHChkBoUpdate (cell, boUpdt)
-RgSchCellCb    *cell;
-RgInfCmnBoRpt  *boUpdt;
-#endif
+static S16 rgSCHChkBoUpdate(RgSchCellCb *cell,RgInfCmnBoRpt  *boUpdt)
 {
 
    uint32_t crntTimeInSubFrms = 0;
@@ -10568,19 +8489,7 @@ RgInfCmnBoRpt  *boUpdt;
  *  @param[in]  uint8_t               hqFdbkIdx
  *  @return     uint8_t
  **/
-#ifdef ANSI
-uint8_t rgSchUtlCfg0ReTxIdx
-(
-RgSchCellCb    *cell,
-CmLteTimingInfo phichTime,
-uint8_t              hqFdbkIdx
-)
-#else
-uint8_t rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
-RgSchCellCb    *cell;
-CmLteTimingInfo phichTime;
-uint8_t              hqFdbkIdx;
-#endif
+uint8_t rgSchUtlCfg0ReTxIdx(RgSchCellCb    *cell,CmLteTimingInfo phichTime,uint8_t hqFdbkIdx)
 {
    uint8_t reTxIdx = RGSCH_INVALID_INFO;
    uint8_t iPhich = 0; 
@@ -10641,28 +8550,14 @@ uint8_t              hqFdbkIdx;
  *  @param[out] uint32_t             *prbReqrd 
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSchUtlDlCalc1CwPrb
-(
-RgSchCellCb    *cell,
-RgSchUeCb      *ue,
-uint32_t             bo,
-uint32_t            *prbReqrd
-)
-#else
-Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
-RgSchCellCb   *cell;
-RgSchUeCb     *ue;
-uint32_t            bo;
-uint32_t           *prbReqrd;
-#endif
+Void rgSchUtlDlCalc1CwPrb(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t bo,uint32_t  *prbReqrd)
 {
    RgSchCmnDlCell *dlCell  = RG_SCH_CMN_GET_DL_CELL(cell); 
    RgSchCmnDlUe   *dlUe  = RG_SCH_CMN_GET_DL_UE(ue, cell); 
-   uint32_t            eff;
-   uint32_t            noRes;
-   uint8_t             iTbs;
-   uint8_t             cfi = dlCell->currCfi;               
+   uint32_t       eff;
+   uint32_t       noRes;
+   uint8_t        iTbs;
+   uint8_t        cfi = dlCell->currCfi;               
 
    iTbs  = dlUe->mimoInfo.cwInfo[0].iTbs[0];
    eff   = (*(RgSchCmnTbSzEff *)(dlCell->cqiToEffTbl[0][cfi]))[iTbs];
@@ -10697,21 +8592,7 @@ uint32_t           *prbReqrd;
  *  @param[out] uint32_t             *prbReqrd 
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSchUtlDlCalc2CwPrb
-(
-RgSchCellCb    *cell,
-RgSchUeCb      *ue,
-uint32_t             bo,
-uint32_t            *prbReqrd
-)
-#else
-Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
-RgSchCellCb   *cell;
-RgSchUeCb     *ue;
-uint32_t            bo;
-uint32_t           *prbReqrd;
-#endif
+Void rgSchUtlDlCalc2CwPrb(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t bo,uint32_t *prbReqrd)
 {
    RgSchCmnDlCell *dlCell  = RG_SCH_CMN_GET_DL_CELL(cell); 
    RgSchCmnDlUe   *dlUe  = RG_SCH_CMN_GET_DL_UE(ue, cell); 
@@ -10770,21 +8651,7 @@ uint32_t           *prbReqrd;
  *  @param[out] uint32_t             *prbReqrd 
  *  @return Void
  **/
-#ifdef ANSI
-Void rgSchUtlCalcTotalPrbReq
-(
-RgSchCellCb    *cell,
-RgSchUeCb      *ue,
-uint32_t             bo,
-uint32_t            *prbReqrd
-)
-#else
-Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
-RgSchCellCb   *cell;
-RgSchUeCb     *ue;
-uint32_t            bo;
-uint32_t           *prbReqrd;
-#endif
+Void rgSchUtlCalcTotalPrbReq(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t bo,uint32_t *prbReqrd)
 {
    /* Call TM specific Prb calculation routine */
    (dlCalcPrbFunc[ue->mimoInfo.txMode - 1])(cell, ue, bo, prbReqrd);
@@ -10808,19 +8675,7 @@ uint32_t           *prbReqrd;
  *     File :
  *
  **********************************************************/
-#ifdef ANSI
-static uint8_t rgSCHUtlFetchPcqiBitSz
-(
- RgSchCellCb    *cell,
- RgSchUeCb    *ueCb, 
- uint8_t           numTxAnt
- )
-#else
-static uint8_t rgSCHUtlFetchPcqiBitSz (cell, ueCb, numTxAnt)
-RgSchCellCb   *cell;
-RgSchUeCb     *ueCb;
-uint8_t            numTxAnt;
-#endif
+static uint8_t rgSCHUtlFetchPcqiBitSz(RgSchCellCb *cell, RgSchUeCb *ueCb,uint8_t numTxAnt)
 {
    uint8_t   confRepMode;
    uint8_t   pcqiSz;
@@ -10965,21 +8820,9 @@ uint8_t            numTxAnt;
  *  @param[in]  uint32_t          *numSbs
  *  @return     uint8_t
  **/
-#ifdef ANSI
-uint8_t rgSchUtlGetNumSbs
-(
-RgSchCellCb                  *cell,
-RgSchUeCb                    *ue,
-uint32_t                     *numSbs
-)
-#else
-uint8_t rgSchUtlGetNumSbs (cell, ue, numSbs)
-RgSchCellCb                  *cell;
-RgSchUeCb                    *ue;
-uint32_t                     *numSbs;
-#endif
+uint8_t rgSchUtlGetNumSbs(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t *numSbs)
 {
-   uint32_t                       nPrb;
+   uint32_t  nPrb;
    //Currently hardcoding MAX prb for each UE
    nPrb = ue->ue5gtfCb.maxPrb;
    (*numSbs) = RGSCH_CEIL(nPrb, MAX_5GTF_VRBG_SIZE);
@@ -11002,21 +8845,7 @@ uint32_t                     *numSbs;
  *  @param[in]  RgSchUeCb    *ue
  *  @return     uint8_t
  **/
-#ifdef ANSI
-uint8_t rgSchUtlSortInsUeLst
-(
-RgSchCellCb  *cell,
-CmLListCp    *ueLst,
-CmLList      *node,
-uint8_t      vrbgRequired
-)
-#else
-uint8_t rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
-RgSchCellCb  *cell;
-CmLListCp    *ueLst;
-CmLList      *node;
-uint8_t      vrbgRequired;
-#endif
+uint8_t rgSchUtlSortInsUeLst(RgSchCellCb *cell,CmLListCp *ueLst,CmLList *node,uint8_t vrbgRequired)
 {
    CmLList      *ueInLst;
    CmLList      *firstUeInLst;
@@ -11095,21 +8924,7 @@ uint8_t      vrbgRequired;
  *  @return  S16
  *      -# ROK 
  **/
-#ifdef ANSI
-S16 rgSCHUtlBuildNSendLcgReg
-(
-RgSchCellCb    *cell,
-CmLteRnti      crnti,
-uint8_t        lcgId,
-Bool           isGbr
-)
-#else
-S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
-RgSchCellCb    *cell;
-CmLteRnti      crnti;
-uint8_t        lcgId;
-Bool           isGbr;
-#endif
+S16 rgSCHUtlBuildNSendLcgReg(RgSchCellCb  *cell,CmLteRnti  crnti,uint8_t lcgId,Bool isGbr)
 {
    Pst            pst;
    RgInfLcgRegReq lcgRegReq;
@@ -11146,15 +8961,7 @@ Bool           isGbr;
  *  @return  TfuAckNackMode
  *      -# ROK 
  **/
-#ifdef ANSI
-TfuAckNackMode rgSchUtlGetFdbkMode
-(
-RgrSchFrmt1b3TypEnum fdbkType
-)
-#else
-TfuAckNackMode rgSchUtlGetFdbkMode(fdbkType)
-RgrSchFrmt1b3TypEnum fdbkType;
-#endif
+TfuAckNackMode rgSchUtlGetFdbkMode(RgrSchFrmt1b3TypEnum fdbkType)
 {
 
    TfuAckNackMode mode = TFU_UCI_FORMAT_1A_1B;
@@ -11202,23 +9009,13 @@ RgrSchFrmt1b3TypEnum fdbkType;
  *  @return  Void
  *      -# ROK 
  **/
-#ifdef ANSI
-Void rgSCHUtlSndUeSCellDel2Mac 
-(
-RgSchCellCb    *cell,
-CmLteRnti      rnti
-)
-#else
-Void rgSCHUtlSndUeSCellDel2Mac(cell, rnti)
-RgSchCellCb    *cell;
-CmLteRnti      rnti;
-#endif
+Void rgSCHUtlSndUeSCellDel2Mac(RgSchCellCb *cell,CmLteRnti rnti)
 {
    Pst          pst;
    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;
@@ -11248,15 +9045,7 @@ CmLteRnti      rnti;
  *  @return        uint8_t maxTbCount; 
  *      -# ROK 
  **/
-#ifdef ANSI
-uint8_t rgSCHUtlGetMaxTbSupp
-(
-RgrTxMode txMode
-)
-#else
-uint8_t rgSCHUtlGetMaxTbSupp(txMode)
-RgrTxMode txMode
-#endif
+uint8_t rgSCHUtlGetMaxTbSupp(RgrTxMode txMode)
 {
    uint8_t maxTbCount;
 
@@ -11301,21 +9090,7 @@ RgrTxMode txMode
  *  @return  Void
  *      -# ROK 
  **/
-#ifdef ANSI
-Void rgSCHTomUtlGetTrigSet
-(
-   RgSchCellCb       *cell,
-   RgSchUeCb	     *ueCb,
-   uint8_t           cqiReq,
-   uint8_t           *triggerSet
- )
-#else
-static S16 rgSCHTomUtlGetTrigSet(cell, ueCb, cqiReq, triggerSet)
-   RgSchCellCb       *cell;
-   RgSchUeCb	     *ueCb;
-   uint8_t           cqiReq;
-   uint8_t           *triggerSet;
-#endif
+Void rgSCHTomUtlGetTrigSet(RgSchCellCb *cell,RgSchUeCb	*ueCb,uint8_t cqiReq,uint8_t *triggerSet)
 {
    RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ueCb);
    switch(cqiReq)
@@ -11362,19 +9137,7 @@ static S16 rgSCHTomUtlGetTrigSet(cell, ueCb, cqiReq, triggerSet)
  *  @return     Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlUpdUeDciSize
-(
-RgSchCellCb      *cell,
-RgSchUeCb        *ueCb,
-Bool             isCsi2Bit
-)
-#else
-Void rgSCHUtlUpdUeDciSize(cell, ueCb, isCsi2Bit)
-RgSchCellCb      *cell;
-RgSchUeCb        *ueCb;
-Bool             isCsi2Bit;
-#endif
+Void rgSCHUtlUpdUeDciSize(RgSchCellCb *cell,RgSchUeCb *ueCb,Bool isCsi2Bit)
 {
    uint8_t dci01aCmnSize = cell->dciSize.baseSize[TFU_DCI_FORMAT_0];
    uint8_t dci01aDedSize = cell->dciSize.baseSize[TFU_DCI_FORMAT_0];
@@ -11479,15 +9242,7 @@ Bool             isCsi2Bit;
  *  @return     Void
  *
  **/
-#ifdef ANSI
-Void rgSCHUtlCalcDciSizes
-(
-RgSchCellCb       *cell
-)
-#else
-Void rgSCHUtlCalcDciSizes(cell)
-RgSchCellCb       *cell;
-#endif
+Void rgSCHUtlCalcDciSizes(RgSchCellCb *cell)
 {
    uint8_t dciSize = 0;
    uint8_t dci01aSize = 0;
@@ -11751,15 +9506,7 @@ RgSchCellCb       *cell;
  *  @param[in]  RgSchCellCb *cell
  *  @return  Void 
  **/
-#ifdef ANSI
-Void rgSCHUtlCpuOvrLdAdjItbsCap
-(
- RgSchCellCb *cell
-)
-#else
-Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
- RgSchCellCb *cell
-#endif
+Void rgSCHUtlCpuOvrLdAdjItbsCap( RgSchCellCb *cell)
 {
    uint32_t tptDelta;
 
@@ -11786,7 +9533,7 @@ Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
          }
       }
 #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
    }
@@ -11814,7 +9561,7 @@ Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
          }
       }
 #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
    }
@@ -11837,17 +9584,7 @@ Void rgSCHUtlCpuOvrLdAdjItbsCap(cell)
  *  @param[in]  uint8_t          cnrtCpuOvrLdIns 
  *  @return     Void
  **/
-#ifdef ANSI
-static Void rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr
-(
- RgSchCellCb *cell, 
- uint8_t      crntCpuOvrLdIns
-)
-#else
-static S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
- RgSchCellCb *cell; 
- uint8_t     crntCpuOvrLdIns;
-#endif
+static Void rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(RgSchCellCb *cell,uint8_t crntCpuOvrLdIns)
 {
    RgSchCpuOvrLdCntrlCb    *cpuInstr = &(cell->cpuOvrLdCntrl);
    RgSchCmnCell            *cellSch;
@@ -11884,15 +9621,15 @@ static S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
          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 )
@@ -11908,15 +9645,15 @@ static S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
          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 */
@@ -11934,15 +9671,15 @@ static S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
          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 )
@@ -11958,31 +9695,31 @@ static S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
          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;
@@ -12006,35 +9743,25 @@ static S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
  *      -# ROK
  *      -# RFAILED
  **/
-#ifdef ANSI
-S16 rgSCHUtlResetCpuOvrLdState
-(
- RgSchCellCb *cell, 
- uint8_t     crntCpuOvrLdIns
-)
-#else
-S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
- RgSchCellCb *cell; 
- uint8_t     crntCpuOvrLdIns;
-#endif
+S16 rgSCHUtlResetCpuOvrLdState(RgSchCellCb *cell,uint8_t crntCpuOvrLdIns)
 {
-   uint8_t         crntDlCpuOL=0;
-   uint8_t         crntUlCpuOL=0;
-   RgSchCmnCell    *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
+   uint8_t      crntDlCpuOL=0;
+   uint8_t      crntUlCpuOL=0;
+   RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
    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;
@@ -12099,10 +9826,10 @@ S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
          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
    }
@@ -12119,11 +9846,11 @@ S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
          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
    }
@@ -12158,13 +9885,13 @@ RgSchIotRes *iotRes
       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;
       }
    }