JIRA-ID ODUHIGH-275 classification of logs of RLC part -3

[o-du/l2.git] / src / 5gnrrlc / kw_ul_ex_ms.c

diff --git a/src/5gnrrlc/kw_ul_ex_ms.c b/src/5gnrrlc/kw_ul_ex_ms.c
index 72b6301..003ff98 100755 (executable)
--- a/src/5gnrrlc/kw_ul_ex_ms.c
+++ b/src/5gnrrlc/kw_ul_ex_ms.c
@@ -28,9 +28,6 @@
         File:    kw_ul_ex_ms.c
   
 *********************************************************************21*/
-static const char* RLOG_MODULE_NAME="RLC_UL";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=206;
 
 /** @file kw_ul_ex_ms.c
 @brief RLC System Services Interface
@@ -58,13 +55,14 @@ static int RLOG_FILE_ID=206;
 #include "kw_ul.x"
 #include "kw_udx.x"
 
+#include "rlc_mac_inf.h"
 #include "du_app_rlc_inf.h"
 
 #ifdef TENB_STATS 
 #include "l2_tenb_stats.x"   
 #endif
 
-PUBLIC S16 rlcUlInitExt ARGS (( Void ));
+S16 rlcUlInitExt ARGS (( Void ));
 \f
 /**
  *
@@ -80,15 +78,8 @@ PUBLIC S16 rlcUlInitExt ARGS (( Void ));
  *
 */
   
-#ifdef ANSI
-PUBLIC S16 rlcUlInitExt 
-(
-)
-#else
-PUBLIC S16 rlcUlInitExt()
-#endif
+S16 rlcUlInitExt()
 {
-   TRC2(rlcUlInitExt);
 
    return ROK;
 } /* kwInitExt */
@@ -122,24 +113,15 @@ PUBLIC S16 rlcUlInitExt()
  *      -# ROK 
  *
  */
-#ifdef ANSI
-PUBLIC S16 rlcUlActvInit
+S16 rlcUlActvInit
 (
 Ent    ent,                 /* entity */
 Inst   inst,                /* instance */
 Region region,              /* region */
 Reason reason               /* reason */
 )
-#else
-PUBLIC S16 rlcUlActvInit(ent, inst, region, reason)
-Ent    ent;                 /* entity */
-Inst   inst;                /* instance */
-Region region;              /* region */
-Reason reason;              /* reason */
-#endif
 {
    RlcCb    *tRlcCb;
-   TRC3(rlcUlActvInit)
 
    if (inst >= MAX_RLC_INSTANCES)
    {
@@ -171,7 +153,7 @@ Reason reason;              /* reason */
    tRlcCb->init.acnt    = TRUE;          /* enable accounting */
    tRlcCb->init.usta    = TRUE;          /* enable unsolicited status */
    tRlcCb->init.trc     = FALSE;         /* enable trace */
-   tRlcCb->init.procId  = SFndProcId();
+   tRlcCb->init.procId  = ODU_GET_PROCID();
 
    rlcCb[inst] = tRlcCb;
 
@@ -204,21 +186,14 @@ Reason reason;              /* reason */
  *      -# ROK 
  *
  */
-#ifdef ANSI
-PUBLIC S16 rlcUlActvTsk
+S16 rlcUlActvTsk
 (
 Pst *pst,              /* pst structure */
 Buffer *mBuf            /* message buffer */
 )
-#else
-PUBLIC S16 rlcUlActvTsk(pst, mBuf)
-Pst *pst;              /* pst structure */
-Buffer *mBuf;           /* message buffer */
-#endif
 {
    S16 ret = ROK;
 
-   TRC3(kwActvTsk);
 
    switch(pst->srcEnt)
    {
@@ -229,59 +204,64 @@ Buffer *mBuf;           /* message buffer */
 #ifdef LCLKW
                case LKW_EVT_CFG_REQ:
                   {
-                     ret = unpackRlcConfigReq(KwMiRlcConfigReq, pst, mBuf);
+                     ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
                      break;
                   }
 
                case LKW_EVT_CNTRL_REQ:
                   {
-                     ret = cmUnpkLkwCntrlReq(KwMiLkwCntrlReq, pst, mBuf);
+                     ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
                      break;
                   }
                
-               case EVENT_RLC_UL_UE_CREATE_REQ:        /* UE Create Request */
+               case EVENT_RLC_UE_CREATE_REQ:        /* UE Create Request */
+                  {
+                     ret = unpackRlcUeCreateReq(RlcProcUeCreateReq, pst, mBuf);
+                     break;
+                  }
+              case EVENT_RLC_UE_RECONFIG_REQ:      /* UE Reconfig Request */
                   {
-                     ret = unpackRlcUlUeCreateReq(RlcUlProcUeCreateReq, pst, mBuf);
+                     ret = unpackRlcUeReconfigReq(RlcProcUeReconfigReq, pst, mBuf);
                      break;
                   }
 
                case LKW_EVT_STS_REQ:
                   {
-                     ret = cmUnpkLkwStsReq(KwMiLkwStsReq, pst, mBuf);
+                     ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
                      break;
                   }
 
                case LKW_EVT_STA_REQ:
                   {
-                     ret = cmUnpkLkwStaReq(KwMiLkwStaReq, pst, mBuf);
+                     ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
                      break;
                   }
                   /* kw005.201 added support for L2 Measurement */
 #ifdef LTE_L2_MEAS
                case LKW_EVT_L2MEAS_REQ:
                   {
-                     ret = cmUnpkLkwL2MeasReq(KwMiLkwL2MeasReq, pst, mBuf);
+                     ret = cmUnpkLkwL2MeasReq(RlcMiLkwL2MeasReq, pst, mBuf);
                      break;
                   }
                case LKW_EVT_L2MEAS_SEND_REQ:
                  {
 
-                    ret = cmUnpkLkwL2MeasSendReq(KwMiLkwL2MeasSendReq, pst, mBuf); 
+                    ret = cmUnpkLkwL2MeasSendReq(RlcMiLkwL2MeasSendReq, pst, mBuf); 
   
                      break;
                  }
                case LKW_EVT_L2MEAS_STOP_REQ:
                  {
-                     ret = cmUnpkLkwL2MeasStopReq(KwMiLkwL2MeasStopReq, pst, mBuf);
+                     ret = cmUnpkLkwL2MeasStopReq(RlcMiLkwL2MeasStopReq, pst, mBuf);
                      break;
                  }
 #endif
 #endif  /* LCLKW */
                default:
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
-                     RLOG1(L_FATAL,"Received Invalid Event[%d] from SM",
+                     DU_LOG("\nERROR  -->  RLC_UL : Received Invalid Event[%d] from SM",
                             pst->event);
                   }
                   ret = RFAILED;
@@ -291,7 +271,7 @@ Buffer *mBuf;           /* message buffer */
             break;
          }
 
-      case ENTKW:
+      case ENTRLC:
          {
             switch(pst->event)
             {
@@ -323,10 +303,10 @@ Buffer *mBuf;           /* message buffer */
 #endif  /* LCCKW */
 
                default:
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
-                      RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
+                      DU_LOG("\nERROR  -->  RLC_UL : Received Invalid Event[%d] from RLC UL",
                             pst->event);
                   }
                   ret = RFAILED;
@@ -343,19 +323,19 @@ Buffer *mBuf;           /* message buffer */
 #ifdef LCCKW
                case CKW_EVT_BND_REQ:              /* Bind request */
                   {
-                     ret = cmUnpkCkwBndReq(KwUiCkwBndReq, pst, mBuf );
+                     ret = cmUnpkCkwBndReq(RlcUiCkwBndReq, pst, mBuf );
                      break;
                   }
 
                case CKW_EVT_UBND_REQ:             /* Unbind request */
                   {
-                     ret = cmUnpkCkwUbndReq(KwUiCkwUbndReq, pst, mBuf );
+                     ret = cmUnpkCkwUbndReq(RlcUiCkwUbndReq, pst, mBuf );
                      break;
                   }
 
                case CKW_EVT_UEIDCHG_REQ:              /* Configuration request */
                   {
-                     ret = cmUnpkCkwUeIdChgReq(KwUiCkwUeIdChgReq, pst, mBuf);
+                     ret = cmUnpkCkwUeIdChgReq(RlcUiCkwUeIdChgReq, pst, mBuf);
                      break;
                   }
 
@@ -364,21 +344,21 @@ Buffer *mBuf;           /* message buffer */
 #ifdef LCKWU
                case KWU_EVT_BND_REQ:              /* Bind request */
                   {
-                     ret = cmUnpkKwuBndReq(KwUiKwuBndReq, pst, mBuf );
+                     ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
                      break;
                   }
 
                case KWU_EVT_UBND_REQ:             /* Unbind request */
                   {
-                     ret = cmUnpkKwuUbndReq(KwUiKwuUbndReq, pst, mBuf );
+                     ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
                      break;
                   }
 #endif  /* LCKWU */
                default:
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
-                      RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC", 
+                      DU_LOG("\nERROR  -->  RLC_UL : Received Invalid Event[%d] from RRC", 
                             pst->event);
                   }
                   ret = RFAILED;
@@ -395,21 +375,21 @@ Buffer *mBuf;           /* message buffer */
 #ifdef LCKWU
                case KWU_EVT_BND_REQ:              /* Bind request */
                   {
-                     ret = cmUnpkKwuBndReq(KwUiKwuBndReq, pst, mBuf );
+                     ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
                      break;
                   }
 
                case KWU_EVT_UBND_REQ:             /* Unbind request */
                   {
-                     ret = cmUnpkKwuUbndReq(KwUiKwuUbndReq, pst, mBuf );
+                     ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
                      break;
                   }
 
                default:
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
-                      RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP", 
+                      DU_LOG("\nERROR  -->  RLC_UL : Received Invalid Event[%d] from PDCP", 
                             pst->event);
                   }
                   ret = RFAILED;
@@ -419,30 +399,30 @@ Buffer *mBuf;           /* message buffer */
             break;
          }
 
-      case ENTRG:
+      case ENTMAC:
          {
             switch(pst->event)
             {
 #ifdef LCRGU
                case EVTRGUBNDCFM:     /* Bind request */
                   {
-                     ret = cmUnpkRguBndCfm(KwLiRguBndCfm, pst, mBuf );
+                     ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
                      break;
                   }
 
-               case EVTRLCULDAT:    /* Dedicated Channel Data request */
+               case EVENT_UL_DATA_TO_RLC:    /* UL Data request */
                   {
-                     ret = unpackRcvdUlData(RlcProcUlData, pst, mBuf);
+                     ret = unpackRlcUlData(RlcProcUlData, pst, mBuf);
                      break;
                   }
 
 #endif  /* LCRGU */
 
                default:
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
-                      RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
+                      DU_LOG("\nERROR  -->  RLC_UL : Received Invalid Event[%d] from MAC",
                             pst->event);
                   }
                   ret = RFAILED;
@@ -458,7 +438,7 @@ Buffer *mBuf;           /* message buffer */
                case KWU_EVT_TTI_IND:
                   {
                      rlcUlBatchProc();
-                     ODU_PUT_MSG(mBuf);
+                     ODU_PUT_MSG_BUF(mBuf);
                      break;
                   }
             }
@@ -467,7 +447,7 @@ Buffer *mBuf;           /* message buffer */
 #endif/* End for TENB_T2K3K_SPECIFIC_CHANGES and L2_L3_SPLIT */
 #ifndef UL_RLC_NET_CLUSTER
 #ifdef TENB_STATS
-      case ENTTF:
+      case ENTLWRMAC:
          {
             switch(pst->event)
             {
@@ -478,14 +458,14 @@ Buffer *mBuf;           /* message buffer */
                   tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 
                   TSL2SendStatsToApp(&(tRlcCb->genCfg.lmPst), 0);
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   break;
                }
                default:
                {
-                  printf("\n ERROR Invalid Event[%d] from CL to PDCPUL\n", 
+                  DU_LOG("\nERROR  -->  RLC_UL : Invalid Event[%d] from CL to PDCPUL\n", 
                          pst->event);
-                  ODU_PUT_MSG(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   break;
                }
             }
@@ -497,9 +477,9 @@ Buffer *mBuf;           /* message buffer */
          {
           if (pst->dstInst < MAX_RLC_INSTANCES)
            {
-              RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",pst->event);
+              DU_LOG("\nERROR  -->  RLC_UL : Received Invalid Source Entity[%d]",pst->event);
            }
-            ODU_PUT_MSG(mBuf);
+            ODU_PUT_MSG_BUF(mBuf);
             ret = RFAILED;
             break;
          }