X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Frg_rom.c;h=cd202098a691bef1dd4e32812c590632c57d26ab;hb=3330932565e15a749fd5dd5039cdea2862ca51cc;hp=f015788baed429d15862ea8b1242fbaf04093f74;hpb=451e626d5ac7c7e7586bab23358161230449af46;p=o-du%2Fl2.git

diff --git a/src/5gnrmac/rg_rom.c b/src/5gnrmac/rg_rom.c
index f015788ba..cd202098a 100755
--- a/src/5gnrmac/rg_rom.c
+++ b/src/5gnrmac/rg_rom.c
@@ -32,24 +32,9 @@
 @brief APIs to handle all the primitives invoked on RGU interface.
 */
 
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=184;
-static int RLOG_MODULE_ID=4096;
 
 /* header include files (.h) */
-#include "envopt.h"        /* environment options */
-#include "envdep.h"        /* environment dependent */
-#include "envind.h"        /* environment independent */
-  
-#include "gen.h"           /* general */
-#include "ssi.h"           /* system services */
-
-#include "cm_tkns.h"       /* Common Token Defines */
-#include "cm_llist.h"      /* Common Link List Defines */
-#include "cm_hash.h"       /* Common Hash List Defines */
-#include "cm_mblk.h"       /* common memory link list library */
-#include "cm_lte.h"        /* Common LTE */
-
+#include "common_def.h"
 #include "rg_env.h"        /* MAC Environment Defines */
 #include "crg.h"           /* CRG Interface defines */
 #include "rgu.h"           /* RGU Interface defines */
@@ -61,15 +46,6 @@ static int RLOG_MODULE_ID=4096;
 #include "rg_err.h"        /* MAC error defines */
 
 /* header/extern include files (.x) */
-#include "gen.x"           /* general */
-#include "ssi.x"           /* system services */
-#include "cm5.x"           /* Timer */
-#include "cm_tkns.x"       /* Common Token Definitions */
-#include "cm_llist.x"      /* Common Link List Definitions */
-#include "cm_lib.x"        /* Common Library Definitions */
-#include "cm_hash.x"       /* Common Hash List Definitions */
-#include "cm_mblk.x"       /* common memory link list library */
-#include "cm_lte.x"        /* Common LTE */
 
 #include "crg.x"           /* CRG Interface includes */
 #include "rgu.x"           /* RGU Interface includes */
@@ -87,20 +63,20 @@ static int RLOG_MODULE_ID=4096;
 /* local typedefs */
  
 S16 RgMacSchBrdcmDedBoUpdtReq ARGS((Inst inst, CmLteCellId cellId, CmLteRnti rnti, CmLteLcId lcId, S32 bo ));
-PRIVATE S16 rgROMHndlCcchDatReq     ARGS((RgCellCb *cell,
+static S16 rgROMHndlCcchDatReq     ARGS((RgCellCb *cell,
                                     RgRguCmnDatReq *datReq, RgErrInfo *err));
-PRIVATE S16 rgROMHndlBcchPcchDatReq ARGS((RgCellCb *cell,
+static S16 rgROMHndlBcchPcchDatReq ARGS((RgCellCb *cell,
                                     RgRguCmnDatReq *datReq, RgErrInfo *err));
-PRIVATE S16 rgROMHndlCcchStaRsp     ARGS((RgCellCb *cell, 
+static S16 rgROMHndlCcchStaRsp     ARGS((RgCellCb *cell, 
                                     RgRguCmnStaRsp *staRsp, RgErrInfo *err));
-PRIVATE S16 rgROMHndlBcchPcchStaRsp ARGS((RgCellCb *cell, 
+static S16 rgROMHndlBcchPcchStaRsp ARGS((RgCellCb *cell, 
                                     RgRguCmnStaRsp *staRsp, RgErrInfo *err));
 
 /* ADD Changes for Downlink UE Timing Optimization */
 #ifdef LTEMAC_DLUE_TMGOPTMZ
-PRIVATE S16 rgROMUpdDlSfRemDataCnt ARGS((RgCellCb  *cellCb,
+static S16 rgROMUpdDlSfRemDataCnt ARGS((RgCellCb  *cellCb,
                                     RgDlSf    *dlSf));
-PUBLIC S16 rgTOMUtlProcDlSf ARGS(( RgDlSf     *dlSf,
+S16 rgTOMUtlProcDlSf ARGS(( RgDlSf     *dlSf,
                                    RgCellCb   *cellCb,
                                    RgErrInfo  *err));
 #endif
@@ -125,24 +101,14 @@ PUBLIC S16 rgTOMUtlProcDlSf ARGS(( RgDlSf     *dlSf,
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PUBLIC S16 rgROMDedDatReq
-(
-Inst      inst,
-RgRguDedDatReq *datReq
-)
-#else
-PUBLIC S16 rgROMDedDatReq(inst,datReq)
-Inst      inst;
-RgRguDedDatReq *datReq;
-#endif
+S16 rgROMDedDatReq(Inst inst,RgRguDedDatReq *datReq)
 {
 #if 0
    RgCellCb     *cell;
    RgUeCb       *ue;
-   U8           idx1,idx2;
+   uint8_t           idx1,idx2;
    RgDlHqProcCb *hqProc;
-   U8           hqPId;
+   uint8_t           hqPId;
    RgErrInfo    err;
    Pst          schPst;
    RgInfDedBoRpt boRpt;
@@ -155,10 +121,8 @@ RgRguDedDatReq *datReq;
 #ifdef LTEMAC_DLUE_TMGOPTMZ
    S16 ret;
 #endif
-   U32 idx;
-   //U8  datReqFailCnt = 0;
-
-   TRC2(rgROMDedDatReq)
+   uint32_t idx;
+   //uint8_t  datReqFailCnt = 0;
 
 
    if (((cell = rgCb[inst].cell) == NULLP) 
@@ -166,8 +130,7 @@ RgRguDedDatReq *datReq;
    {
 #if (ERRCLASS & ERRCLS_INT_PAR)
       /* Handle Cell fetch failure */
-      RGLOGERROR(inst,ERRCLS_INT_PAR,ERG001,(ErrVal)datReq->cellId,
-            "rgROMDedDatReq(): Invalid cell Id");
+      DU_LOG("\nERROR  -->  MAC : rgROMDedDatReq(): Invalid cell Id");
 #endif
       err.errType = RGERR_ROM_DEDDATREQ;
       err.errCause = RGERR_ROM_INV_CELL_ID;
@@ -176,22 +139,22 @@ RgRguDedDatReq *datReq;
          /* Update stats */
          rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
       }
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
 /* Add loop here to scan for all UEs in the consolidated DDatReq*/
    for(idx = 0; idx < datReq->nmbOfUeGrantPerTti; idx++)
    {
 
-      timingInfo.subframe = (U8)((datReq->datReq[idx].transId >> 8) & 0XFF);
-      timingInfo.sfn = (U16)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
-      sf = &cell->subFrms[(timingInfo.subframe % RG_NUM_SUB_FRAMES)];
+      timingInfo.slot = (uint8_t)((datReq->datReq[idx].transId >> 8) & 0XFF);
+      timingInfo.sfn = (uint16_t)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
+      sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
 
       if( (sf->txDone == TRUE) ||
             (!RG_TIMEINFO_SAME(sf->schdTime,timingInfo)))
       {
 #if (ERRCLASS & ERRCLS_DEBUG)
-         /* Transmission is already done for this subframe. This is a delayed
+         /* Transmission is already done for this slot. This is a delayed
           * datReq. So discard */
          rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
          rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
@@ -203,7 +166,7 @@ RgRguDedDatReq *datReq;
          rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
 #ifdef CA_DBG
          {
-            EXTERN U32 dbgDelayedDatReqInMac;
+            uint32_t dbgDelayedDatReqInMac;
             dbgDelayedDatReqInMac++;
          }
 #endif /* CA_DBG */         
@@ -211,15 +174,14 @@ RgRguDedDatReq *datReq;
          RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
 #endif
          continue;
-        // RETVALUE(RFAILED);
+        // return RFAILED;
       }
 
       if ((ue = rgDBMGetUeCb(cell, datReq->datReq[idx].rnti)) == NULLP)
       {
 #if (ERRCLASS & ERRCLS_INT_PAR)
             /* Handle Ue fetch failure */
-            RGLOGERROR(inst,ERRCLS_INT_PAR,ERG002,(ErrVal)datReq->datReq[idx].rnti,
-                  "rgROMDedDatReq(): Invalid ue Id");
+           DU_LOG("\nERROR  -->  MAC : rgROMDedDatReq(): Invalid ue Id");
 #endif
             err.errType = RGERR_ROM_DEDDATREQ;
             err.errCause = RGERR_ROM_INV_UE_ID;
@@ -232,27 +194,26 @@ RgRguDedDatReq *datReq;
             ret = rgROMUpdDlSfRemDataCnt(cell, sf);
             if(ret == RFAILED)
             {
-               RLOG0(L_INFO, "Dropping due to no ue \n");
+               DU_LOG("\nERROR  -->  MAC : Dropping due to no ue \n");
 #ifndef L2_OPTMZ
                RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
 #endif
                /* Return from here as above functions found more datReq than expected*/
-              /* RETVALUE(ret); */
+              /* return (ret); */
             }
 #endif
             /* Conitnue for next UE */
             continue;
       }
 
-      hqPId = (U8)(datReq->datReq[idx].transId);
+      hqPId = (uint8_t)(datReq->datReq[idx].transId);
       hqPId = hqPId >> 2;
       /* get harq process and invoke DHM */
       rgDHMGetHqProcFrmId(ue, hqPId, &hqProc);
 
       if (rgDHMHndlDedDatReq(inst,hqProc, &datReq->datReq[idx], sf, &err) == RFAILED)
       {
-         RLOG_ARG1(L_ERROR,DBG_CELLID,datReq->cellId,
-                   "Handling of Data request in DHM failedi RNTI:%d",
+         DU_LOG("\nERROR  -->  MAC : Handling of Data request in DHM failedi RNTI:%d",
                     datReq->datReq[idx].rnti);
          err.errType = RGERR_ROM_DEDDATREQ;
          /* errcause shall be filled in appropriately by DHM */
@@ -265,12 +226,12 @@ RgRguDedDatReq *datReq;
          ret = rgROMUpdDlSfRemDataCnt(cell, sf);
          if(ret == RFAILED)
          {
-         RLOG0(L_INFO, "Dropping due to no failure of remCnt update");
+            DU_LOG("\nERROR  -->  MAC : Dropping due to no failure of remCnt update");
 #ifndef L2_OPTMZ
             RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
 #endif
             /* Return from here as above functions found more datReq than expected*/
-            //RETVALUE(ret);
+            //return (ret);
          }
 #endif
          continue;
@@ -318,19 +279,19 @@ RgRguDedDatReq *datReq;
       ret = rgROMUpdDlSfRemDataCnt(cell, sf);
       if(ret == RFAILED)
       {
-         RLOG0(L_INFO, "\n Dropping due to no failure of remCnt update(1) \n");
+         DU_LOG("\nERROR  -->  MAC : Dropping due to no failure of remCnt update(1) \n");
 #ifndef L2_OPTMZ
          RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[idx]);
 #endif
          /* Return from here as above functions found more datReq than expected*/
-        // RETVALUE(ret);
+        // return (ret);
       }
 #endif
    } /* for loop for num of Ue per TTI*/
 
 #endif
    /* Data send successfully to PHY. lets retuns ROK*/
-   RETVALUE(ROK);
+   return ROK;
 }  /* rgROMDedDatReq */
 
 
@@ -351,17 +312,7 @@ RgRguDedDatReq *datReq;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PUBLIC S16 rgROMCmnDatReq
-(
-Inst            inst,
-RgRguCmnDatReq *datReq
-)
-#else
-PUBLIC S16 rgROMCmnDatReq(inst,datReq)
-Inst            inst;
-RgRguCmnDatReq *datReq;
-#endif
+S16 rgROMCmnDatReq(Inst inst, RgRguCmnDatReq *datReq)
 {
    RgCellCb    *cell;
    RgErrInfo   err;
@@ -372,8 +323,6 @@ RgRguCmnDatReq *datReq;
    RgDlSf   *sf;
 #endif
 
-   TRC2(rgROMCmnDatReq)
-
    ret = ROK;
    err.errType = RGERR_ROM_CMNDATREQ;
    if(((cell = rgCb[inst].cell) == NULLP)
@@ -381,8 +330,7 @@ RgRguCmnDatReq *datReq;
    {
 #if (ERRCLASS & ERRCLS_INT_PAR)
       /* Handle Cell fetch failure */
-      RGLOGERROR(inst,ERRCLS_INT_PAR,ERG003,(ErrVal)datReq->cellId,
-                            "rgROMCmnDatReq(): Invalid cell Id");
+     DU_LOG("\nERROR  -->  MAC : rgROMCmnDatReq(): Invalid cell Id");
 #endif
       err.errCause = RGERR_ROM_INV_CELL_ID;
       /* Update stats */
@@ -390,7 +338,7 @@ RgRguCmnDatReq *datReq;
       {
          rgUpdtRguCmnSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP);
       }
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    if (datReq->lcId == cell->dlCcchId)
@@ -400,8 +348,8 @@ RgRguCmnDatReq *datReq;
       /*Get the timing Info*/
       /* ADD Changes for Downlink UE Timing Optimization */
 #ifdef LTEMAC_DLUE_TMGOPTMZ
-      timingInfo.subframe = (U8)((datReq->transId >> 8) & 0XFF);
-      timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
+      timingInfo.slot = (uint8_t)((datReq->transId >> 8) & 0XFF);
+      timingInfo.sfn = (uint16_t)((datReq->transId >> 16) & 0xFFFF);
 #endif
    } 
    else
@@ -411,8 +359,8 @@ RgRguCmnDatReq *datReq;
       /*Get the timing Info*/
       /* ADD Changes for Downlink UE Timing Optimization */
 #ifdef LTEMAC_DLUE_TMGOPTMZ
-      timingInfo.subframe = (U8)(datReq->transId & 0XFF);
-      timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
+      timingInfo.slot = (uint8_t)(datReq->transId & 0XFF);
+      timingInfo.sfn = (uint16_t)((datReq->transId >> 8) & 0xFFFF);
 #endif
    }
 
@@ -429,14 +377,14 @@ RgRguCmnDatReq *datReq;
 
    /* ADD Changes for Downlink UE Timing Optimization */
 #ifdef LTEMAC_DLUE_TMGOPTMZ
-   RG_ARRAY_BOUND_CHECK(0, cell->subFrms, (timingInfo.subframe % RG_NUM_SUB_FRAMES));
-   sf = &cell->subFrms[(timingInfo.subframe % RG_NUM_SUB_FRAMES)];
+   RG_ARRAY_BOUND_CHECK(0, cell->subFrms, (timingInfo.slot % RG_NUM_SUB_FRAMES));
+   sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
 
    ret = rgROMUpdDlSfRemDataCnt(cell, sf);
    /*Added check for RFAILED as above function can return RFAILED*/
 #endif
 
-   RETVALUE(ret);
+   return (ret);
 }  /* rgROMCmnDatReq */
 
 /**
@@ -457,23 +405,11 @@ RgRguCmnDatReq *datReq;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlCcchDatReq
-(
-RgCellCb       *cell,
-RgRguCmnDatReq *datReq,
-RgErrInfo      *err
-)
-#else
-PRIVATE S16 rgROMHndlCcchDatReq(cell, datReq, err)
-RgCellCb       *cell;
-RgRguCmnDatReq *datReq;
-RgErrInfo      *err;
-#endif
+static S16 rgROMHndlCcchDatReq(RgCellCb *cell, RgRguCmnDatReq *datReq, RgErrInfo *err)
 {
    Inst     inst = cell->macInst - RG_INST_START;
    RgUeCb   *ue;
-   U8       hqPId;
+   uint8_t   hqPId;
    RgDlHqProcCb *hqProc;
    CmLteTimingInfo timingInfo;
    RgDlSf   *sf;
@@ -481,9 +417,6 @@ RgErrInfo      *err;
    RgUstaDgn   dgn;      /* Alarm diagnostics structure */
 #endif
 
-   TRC2(rgROMHndlCcchDatReq);
-
-
    err->errType = RGERR_ROM_CMNDATREQ;
 
    if ((ue = rgDBMGetUeCb(cell, datReq->u.rnti)) == NULLP)
@@ -492,33 +425,32 @@ RgErrInfo      *err;
       {
    #if (ERRCLASS & ERRCLS_INT_PAR)
          /* Handle Ue fetch failure */
-         RGLOGERROR(inst,ERRCLS_INT_PAR,ERG004,(ErrVal)datReq->u.rnti,
-                              "rgROMHndlCcchDatReq(): Invalid ue Id");
+         DU_LOG("\nERROR  -->  MAC : rgROMHndlCcchDatReq(): Invalid ue Id");
    #endif
          err->errCause = RGERR_ROM_INV_UE_ID;
-         RETVALUE(RFAILED);
+         return RFAILED;
       }
    }
 
-   timingInfo.subframe = (U8)((datReq->transId >> 8) & 0XFF);
-   timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
-   sf = &cell->subFrms[(timingInfo.subframe % RG_NUM_SUB_FRAMES)];
+   timingInfo.slot = (uint8_t)((datReq->transId >> 8) & 0XFF);
+   timingInfo.sfn = (uint16_t)((datReq->transId >> 16) & 0xFFFF);
+   sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
 
    if( (sf->txDone == TRUE) ||
        (!RG_TIMEINFO_SAME(sf->schdTime,timingInfo)))
    {
 #if (ERRCLASS & ERRCLS_DEBUG)
-      /* Transmission is already done for this subframe. This is a delayed
+      /* Transmission is already done for this slot. This is a delayed
        * datReq. So discard */
       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
       rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
                               LRG_CAUSE_DELAYED_DATREQ, &dgn);
 #endif
       err->errCause = RGERR_ROM_DELAYED_DATREQ;
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
-   hqPId = (U8)(datReq->transId);
+   hqPId = (uint8_t)(datReq->transId);
    hqPId = hqPId >> 2;
 
    /* get harq process and invoke DHM */
@@ -528,16 +460,15 @@ RgErrInfo      *err;
    /* invoke DHM to process CCCH data */
    if (rgDHMHndlCmnDatReq(inst,hqProc, datReq, err) == RFAILED)
    {
-      RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
-            "Handling of Data request in DHM failed RNTI:%d LCID:%d",
+      DU_LOG("\nERROR  -->  MAC : Handling of Data request in DHM failed RNTI:%d LCID:%d",
             datReq->u.rnti,datReq->lcId);
       /* Release First TB */
       rgDHMRlsHqProcTB(cell, hqProc, 1);
       /* err shall be filled in appropriately by DHM */
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
  
-   RETVALUE(ROK); 
+   return ROK; 
 } /* rgROMHndlCcchDatReq */
 
 
@@ -558,19 +489,7 @@ RgErrInfo      *err;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlBcchPcchDatReq
-(
-RgCellCb       *cell,
-RgRguCmnDatReq *datReq,
-RgErrInfo      *err
-)
-#else
-PRIVATE S16 rgROMHndlBcchPcchDatReq(cell, datReq, err)
-RgCellCb       *cell;
-RgRguCmnDatReq *datReq;
-RgErrInfo      *err;
-#endif
+static S16 rgROMHndlBcchPcchDatReq(RgCellCb *cell, RgRguCmnDatReq *datReq, RgErrInfo *err)
 {
    Inst            inst = cell->macInst - RG_INST_START;
    RgPcchLcCb      *pcch;
@@ -585,63 +504,60 @@ RgErrInfo      *err;
    RgUstaDgn   dgn;      /* Alarm diagnostics structure */
 #endif
 
-   TRC2(rgROMHndlBcchPcchDatReq);
 
-
-   timingInfo.subframe = (U8)(datReq->transId & 0XFF);
-   timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
-   sf = &cell->subFrms[(timingInfo.subframe % RG_NUM_SUB_FRAMES)];
+   timingInfo.slot = (uint8_t)(datReq->transId & 0XFF);
+   timingInfo.sfn = (uint16_t)((datReq->transId >> 8) & 0xFFFF);
+   sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
 
    if( (sf->txDone == TRUE) ||
        (!RG_TIMEINFO_SAME(sf->schdTime,timingInfo)))
    {
 #if (ERRCLASS & ERRCLS_DEBUG)
-      /* Transmission is already done for this subframe. This is a delayed
+      /* Transmission is already done for this slot. This is a delayed
        * datReq. So discard */
       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
       rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
                               LRG_CAUSE_DELAYED_DATREQ, &dgn);
 #endif
       err->errCause = RGERR_ROM_DELAYED_DATREQ;
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
 #ifndef RGR_SI_SCH
    bcch = rgDBMGetBcchOnDlsch(cell,datReq->lcId);
    if (bcch )
    {
-      /* Store BCCH-DLSCH data received in Scheduled subframe */
+      /* Store BCCH-DLSCH data received in Scheduled slot */
       sf->bcch.tb = datReq->pdu;
 
       SCpyMsgMsg(datReq->pdu, RG_GET_MEM_REGION(rgCb[inst]),
                RG_GET_MEM_POOL(rgCb[inst]), &bcch->tb);
 
-      RETVALUE(ROK);
+      return ROK;
    }
 
    bch = rgDBMGetBcchOnBch(cell);
    if ((bch) && (bch->lcId == datReq->lcId))
    {
-      /* Store BCH data received in Scheduled subframe */
+      /* Store BCH data received in Scheduled slot */
       sf->bch.tb = datReq->pdu;
-      RETVALUE(ROK);
+      return ROK;
    }
 #endif/*RGR_SI_SCH*/
-
+   UNUSED(inst);
    pcch = rgDBMGetPcch(cell);
    if ((pcch) && (pcch->lcId == datReq->lcId))
    {
-      /* Store PCCH-DLSCH data received in Scheduled subframe */
+      /* Store PCCH-DLSCH data received in Scheduled slot */
       sf->pcch.tb = datReq->pdu;
-      RETVALUE(ROK);
+      return ROK;
    }
 
    /* Handle lcCb fetch failure */
-   RGLOGERROR(inst,ERRCLS_INT_PAR,ERG005,(ErrVal)datReq->lcId,
-                  "rgROMHndlBcchPcchDatReq(): Invalid Lc Id");
+   DU_LOG("\nERROR  -->  MAC : rgROMHndlBcchPcchDatReq(): Invalid Lc Id");
    err->errCause = RGERR_ROM_INV_LC_ID;
 
-   RETVALUE(RFAILED);
+   return RFAILED;
 } /* rgROMHndlBcchPcchDatReq */
 
 /**
@@ -661,24 +577,12 @@ RgErrInfo      *err;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PUBLIC S16 rgROMDedStaRsp
-(
-Inst           inst,
-RgRguDedStaRsp *staRsp
-)
-#else
-PUBLIC S16 rgROMDedStaRsp(inst,staRsp)
-Inst           inst;
-RgRguDedStaRsp *staRsp;
-#endif
+S16 rgROMDedStaRsp(Inst inst, RgRguDedStaRsp *staRsp)
 {
    RgCellCb   *cell;
 
    /* Moving the error variables and assignments to available scope */
 
-   TRC2(rgROMDedStaRsp)
-
    /* Avoiding memset, as the variables of this are getting 
       initialized */
 
@@ -686,25 +590,27 @@ RgRguDedStaRsp *staRsp;
    if(((cell = rgCb[inst].cell) != NULLP)
       && (cell->cellId == staRsp->cellId))
    {
-            RgInfDedBoRpt boRpt;
             Pst        schPst;
-            boRpt.cellSapId  = cell->schInstMap.cellSapId;
-            boRpt.cellId  = staRsp->cellId;
-            boRpt.rnti    = staRsp->rnti; 
-            boRpt.lcId    = staRsp->lcId; 
-            boRpt.bo      = staRsp->boReport.bo;
-            boRpt.oldestSduArrTime = staRsp->boReport.oldestSduArrTime;
-            boRpt.staPduBo = staRsp->boReport.staPduBo;
-   			boRpt.oldestSduArrTime = staRsp->boReport.oldestSduArrTime;
-            rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
+#ifdef UNUSED_VAR
+    RgInfDedBoRpt boRpt
+	 boRpt.cellSapId  = cell->schInstMap.cellSapId;
+    boRpt.cellId  = staRsp->cellId;
+	 boRpt.rnti    = staRsp->rnti; 
+    boRpt.lcId    = staRsp->lcId; 
+	 boRpt.bo      = staRsp->boReport.bo;
+    boRpt.oldestSduArrTime = staRsp->boReport.oldestSduArrTime;
+    boRpt.staPduBo = staRsp->boReport.staPduBo;
+    boRpt.oldestSduArrTime = staRsp->boReport.oldestSduArrTime;
+#endif
+				rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
             schPst.event = 0;
             //TODO: commented for compilation without SCH RgMacSchDedBoUpdt(&schPst, &boRpt);
-            RETVALUE(ROK);
+            return ROK;
    }
-   RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,"Invalid cell for CRNTI:%d LCID:%d ",
+   DU_LOG("\nERROR  -->  MAC : Invalid cell for CRNTI:%d LCID:%d ",
              staRsp->rnti,staRsp->lcId);
 
-   RETVALUE(RFAILED);
+   return RFAILED;
 }  /* rgROMDedStaRsp */
 
 S16 RgMacSchBrdcmDedBoUpdtReq(
@@ -715,23 +621,26 @@ CmLteLcId lcId,
 S32 bo 
 )
 {
-  RgInfDedBoRpt  boRpt;
+
   RgCellCb   *cell;
   //if ((cell = rgDBMGetCellCb(cellId)) != NULLP)
   if (((cell = rgCb[inst].cell) != NULLP) &&
         (cell->cellId == cellId))
-  {
+ {
      Pst        schPst;
-     boRpt.cellSapId  = cell->schInstMap.cellSapId;
-     boRpt.cellId     = cellId;
-     boRpt.rnti       = rnti; 
-     boRpt.lcId       = lcId; 
-     boRpt.bo         = bo;
+#ifdef UNUSED_VAR
+    RgInfDedBoRpt  boRpt;
+    boRpt.cellSapId  = cell->schInstMap.cellSapId;
+    boRpt.cellId     = cellId;
+    boRpt.rnti       = rnti; 
+    boRpt.lcId       = lcId; 
+    boRpt.bo         = bo;
+#endif
      rgGetPstToInst(&schPst,inst, cell->schInstMap.schInst);
      schPst.event = 0;
      //TODO: commented for compilation without SCH RgMacSchDedBoUpdtReq (&schPst,&boRpt);
   }
-  RETVALUE(ROK);
+  return ROK;
 }
 /**
  * @brief Handler for StaRsp received on RGU for a common logical channel.
@@ -751,33 +660,19 @@ S32 bo
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PUBLIC S16 rgROMCmnStaRsp
-(
-Inst            inst, 
-RgRguCmnStaRsp *staRsp
-)
-#else
-PUBLIC S16 rgROMCmnStaRsp(inst,staRsp)
-Inst            inst;
-RgRguCmnStaRsp *staRsp;
-#endif
+S16 rgROMCmnStaRsp(Inst inst, RgRguCmnStaRsp *staRsp)
 {
    RgCellCb   *cell;
    RgErrInfo  err;
 
-   TRC2(rgROMCmnStaRsp)
-
-
    if(((cell = rgCb[inst].cell) == NULLP)
       || (cell->cellId != staRsp->cellId))
    {
       /* Handle Cell fetch failure */
-      RLOG_ARG2(L_ERROR,DBG_CELLID,staRsp->cellId,
-                "Invalid cell for CRNTI:%d LCID:%d",staRsp->u.rnti,staRsp->lcId);
+      DU_LOG("\nERROR  -->  MAC : Invalid cell for CRNTI:%d LCID:%d",staRsp->u.rnti,staRsp->lcId);
       err.errType = RGERR_ROM_CMNSTARSP;
       err.errCause = RGERR_ROM_INV_CELL_ID;
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
 
    /* handle status response on CCCH */
@@ -790,7 +685,7 @@ RgRguCmnStaRsp *staRsp;
       rgROMHndlBcchPcchStaRsp(cell, staRsp, &err); 
    }
    
-   RETVALUE(ROK);
+   return ROK;
 }  /* rgROMCmnStaRsp */
 
 #ifdef LTE_L2_MEAS
@@ -813,25 +708,12 @@ RgRguCmnStaRsp *staRsp;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PUBLIC S16 rgROML2MUlThrpMeasReq 
-(
-Inst                  inst,
-RgRguL2MUlThrpMeasReq *measReq
-)
-#else
-PUBLIC S16 rgROML2MUlThrpMeasReq(inst,measReq)
-Inst                  inst;
-RgRguL2MUlThrpMeasReq *measReq;
-#endif
+S16 rgROML2MUlThrpMeasReq(Inst inst, RgRguL2MUlThrpMeasReq *measReq)
 {
    RgCellCb   *cell;
    RgUeCb     *ue;
-   U8         lcgId;
-   U8         loop;
-   TRC2(rgROML2MUlThrpMeasReq)
-
-
+   uint8_t    lcgId;
+   uint8_t    loop;
 
    if(((cell = rgCb[inst].cell) != NULLP)
       &&(cell->cellId == measReq->cellId))
@@ -851,12 +733,12 @@ RgRguL2MUlThrpMeasReq *measReq;
                }
             }
          }
-         RETVALUE(ROK);
+         return ROK;
       }
    }
-   RLOG_ARG1(L_ERROR,DBG_CELLID,measReq->cellId,"Invalid cell CRNTI:%d",
+   DU_LOG("\nERROR  -->  MAC : Invalid cell CRNTI:%d",
              measReq->rnti);
-   RETVALUE(RFAILED);
+   return RFAILED;
 }  /* rgROML2MUlThrpMeasReq */
 
 #endif
@@ -879,37 +761,25 @@ RgRguL2MUlThrpMeasReq *measReq;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlCcchStaRsp
-(
-RgCellCb       *cell,
-RgRguCmnStaRsp *staRsp,
-RgErrInfo      *err
-)
-#else
-PRIVATE S16 rgROMHndlCcchStaRsp(cell, staRsp, err)
-RgCellCb       *cell;
-RgRguCmnStaRsp *staRsp;
-RgErrInfo      *err;
-#endif
+static S16 rgROMHndlCcchStaRsp(RgCellCb *cell,RgRguCmnStaRsp *staRsp, RgErrInfo *err)
 {
    Pst      schPst;
    Inst     macInst = cell->macInst - RG_INST_START;
-   RgInfCmnBoRpt boRpt;
-
-   TRC2(rgROMHndlCcchStaRsp);
-
+   //RgInfCmnBoRpt boRpt;
 
+#ifdef UNUSED_VAR
+   RgInfCmnBoRpt boRpt;
    boRpt.cellSapId  = cell->schInstMap.cellSapId;
    boRpt.cellId  = staRsp->cellId;
    boRpt.u.rnti    = staRsp->u.rnti; 
    boRpt.lcId    = staRsp->lcId; 
    boRpt.lcType  = staRsp->lcType; 
    boRpt.bo      = staRsp->bo;
+#endif
    rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
    //TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* rgROMHndlCcchStaRsp */
 
 
@@ -930,54 +800,41 @@ RgErrInfo      *err;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PRIVATE S16 rgROMHndlBcchPcchStaRsp
-(
-RgCellCb       *cell,
-RgRguCmnStaRsp *staRsp,
-RgErrInfo      *err
-)
-#else
-PRIVATE S16 rgROMHndlBcchPcchStaRsp(cell, staRsp, err)
-RgCellCb       *cell;
-RgRguCmnStaRsp *staRsp;
-RgErrInfo      *err;
-#endif
+static S16 rgROMHndlBcchPcchStaRsp(RgCellCb *cell,RgRguCmnStaRsp *staRsp,RgErrInfo *err)
 {
    Pst      schPst;
-   RgInfCmnBoRpt boRpt;
+   //RgInfCmnBoRpt boRpt;
    Inst     macInst = cell->macInst - RG_INST_START;
 
-   TRC2(rgROMHndlBcchPcchStaRsp);
-   cmMemset((U8*)&schPst, (U8)0, sizeof(Pst));
+   memset(&schPst, 0, sizeof(Pst));
 
    if (rgDBMChkCmnLcCb(cell, staRsp->lcId) != ROK)
    {
       /* Handle lcCb fetch failure */
-      RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LCID:%d",staRsp->lcId);
+      DU_LOG("\nERROR  -->  MAC : Invalid LCID:%d",staRsp->lcId);
       err->errCause = RGERR_ROM_INV_LC_ID;
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    /* MS_WORKAROUND : This is to ensure that the queue for BCH is not filled with old BO requests :
          This assumes that BO is not received more than 4 frames in advance from the enodeb application */
    if (cell->bcchBchInfo.lcId == staRsp->lcId)
    {
-      U16 nextBchSfn;
+      uint16_t nextBchSfn;
 
       nextBchSfn = (cell->crntTime.sfn + 4 - (cell->crntTime.sfn%4)) % RG_MAX_SFN;
       if ((staRsp->u.timeToTx.sfn != nextBchSfn) ||
-         ((staRsp->u.timeToTx.sfn == cell->crntTime.sfn) && (cell->crntTime.subframe >= 7)))
+         ((staRsp->u.timeToTx.sfn == cell->crntTime.sfn) && (cell->crntTime.slot >= 7)))
       {
-        RETVALUE(ROK);
+        return ROK;
       }
    }
-
+/*
    boRpt.cellSapId     = cell->schInstMap.cellSapId;
    boRpt.cellId     = staRsp->cellId;
    boRpt.u.timeToTx = staRsp->u.timeToTx; 
    boRpt.lcId       = staRsp->lcId; 
    boRpt.lcType     = staRsp->lcType; 
-   boRpt.bo         = staRsp->bo;
+   boRpt.bo         = staRsp->bo;*/	
 #ifdef EMTC_ENABLE
   if(cell->emtcEnable)
   {
@@ -991,7 +848,7 @@ RgErrInfo      *err;
    rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
    //TODO: commented for compilation without SCH RgMacSchCmnBoUpdt(&schPst, &boRpt);
 
-   RETVALUE(ROK);
+   return ROK;
 } /* rgROMHndlBcchPcchStaRsp */
 
 /* ADD Changes for Downlink UE Timing Optimization */
@@ -1011,31 +868,17 @@ RgErrInfo      *err;
  *      -# ROK 
  *      -# RFAILED 
  **/
-#ifdef ANSI
-PRIVATE S16 rgROMUpdDlSfRemDataCnt
-(
-RgCellCb       *cellCb,
-RgDlSf         *dlSf
-)
-#else
-PRIVATE S16 rgROMUpdDlSfRemDataCnt(cellCb, dlSf)
-RgCellCb       *cellCb;
-RgDlSf         *dlSf;
-#endif
+static S16 rgROMUpdDlSfRemDataCnt(RgCellCb *cellCb, RgDlSf *dlSf)
 {
    RgErrInfo            err;
    //Inst                 inst = cellCb->macInst - RG_INST_START;
 
-   TRC2(rgROMUpdDlSfRemDataCnt);
-
-
    if(!dlSf->remDatReqCnt)
    {
        /*This is an error scenario of RLC generating more data          
         * request than the allocation. Do nothing for this. */
-      RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
-            "RX new data while remDatReqCnt is 0 for cell");
-      RETVALUE(RFAILED);
+      DU_LOG("\nERROR  -->  MAC : RX new data while remDatReqCnt is 0 for cell");
+      return RFAILED;
    }
 
    /*Decrement the remaining data request to be received countter
@@ -1052,8 +895,7 @@ RgDlSf         *dlSf;
 
       if (ROK != rgTOMUtlProcDlSf (dlSf, cellCb, &err))
       {
-         RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
-               "Unable to process downlink subframe for cell");
+         DU_LOG("\nERROR  -->  MAC : Unable to process downlink slot for cell");
          err.errType = RGERR_ROM_DEDDATREQ;
       }
 
@@ -1061,7 +903,7 @@ RgDlSf         *dlSf;
       dlSf->txDone = TRUE;
    }
 
-   RETVALUE(ROK);
+   return ROK;
 } /* rgROMUpdDlSfRemDataCnt*/
 #endif