UL data path changes at Phy stub, RLC UL UM and DU APP [Issue-ID: ODUHIGH-262]

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

diff --git a/src/5gnrrlc/kw_dl_ex_ms.c b/src/5gnrrlc/kw_dl_ex_ms.c
index 00351a9..77d3a52 100755 (executable)
--- a/src/5gnrrlc/kw_dl_ex_ms.c
+++ b/src/5gnrrlc/kw_dl_ex_ms.c
@@ -58,24 +58,26 @@ static int RLOG_FILE_ID=195;
 #include "kw.x"
 #include "kw_udx.x"
 #include "kw_dl.x"
+#include "du_app_rlc_inf.h"
+#include "rlc_mac_inf.h"
 
 #include "ctf.h"
-PUBLIC S16 kwUtlDlBatchProcPkts(Void);
-PUBLIC S16 rlcDlBatchProc(Void);
+S16 rlcUtlDlBatchProcPkts(Void);
+S16 rlcDlBatchProc(Void);
 #if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
-U32 isDatReqProcessed;
-PUBLIC void kwUtlDlBatchProcHqStaInd ARGS ((Void));
+uint32_t isDatReqProcessed;
+void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
 #endif
 
 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
-EXTERN S16 rlcDlBatchProcSplit  ARGS((Void));
+S16 rlcDlBatchProcSplit  ARGS((Void));
 #endif
 //UDAY
 #ifdef L2_OPTMZ
-U32 kwAmmStaPduList[512] = {0};
-EXTERN S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
+uint32_t rlcAmmStaPduList[512] = {0};
+S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
 #endif
-PUBLIC S16 rlcDlInitExt ARGS (( Void ));
+S16 rlcDlInitExt ARGS (( Void ));
 \f
 /**
  *
@@ -91,17 +93,9 @@ PUBLIC S16 rlcDlInitExt ARGS (( Void ));
  *
 */
   
-#ifdef ANSI
-PUBLIC S16 rlcDlInitExt 
-(
-)
-#else
-PUBLIC S16 rlcDlInitExt()
-#endif
+S16 rlcDlInitExt()
 {
-   TRC2(rlcDlInitExt);
-
-   RETVALUE(ROK);
+   return ROK;
 } /* kwInitExt */
 
 
@@ -133,40 +127,31 @@ PUBLIC S16 rlcDlInitExt()
  *      -# ROK 
  *
  */
-#ifdef ANSI
-PUBLIC S16 rlcDlActvInit
+S16 rlcDlActvInit
 (
 Ent    ent,                 /* entity */
 Inst   inst,                /* instance */
 Region region,              /* region */
 Reason reason               /* reason */
 )
-#else
-PUBLIC S16 rlcDlActvInit(ent, inst, region, reason)
-Ent    ent;                 /* entity */
-Inst   inst;                /* instance */
-Region region;              /* region */
-Reason reason;              /* reason */
-#endif
 {
    RlcCb    *tRlcCb;
-   TRC3(rlcDlActvInit)
 
    if (inst >= MAX_RLC_INSTANCES)
    {
        /* intance greater than MAX instances */ 
-       RETVALUE(RFAILED); 
+       return RFAILED; 
    }
 
    if (rlcCb[inst] != NULLP)
    {
-       RETVALUE (RFAILED);
+       return  (RFAILED);
    }
   
    if (SGetSBuf(region, 0, (Data **)&tRlcCb,
                 (Size)sizeof (RlcCb)) != ROK)    
    {                     
-      RETVALUE(RFAILED);
+      return RFAILED;
    }
    /* Initialize rlcCb */
    RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
@@ -181,7 +166,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;
 
@@ -194,7 +179,7 @@ Reason reason;              /* reason */
       SGetMsg(1, 0 , &mBuf);
       ssGetDBufOfSize(1 , 1800, &bufPtr);
       SUpdMsg(mBuf, bufPtr, 0);
-      kwAmmStaPduList[i] = (U32)mBuf; 
+      rlcAmmStaPduList[i] = (uint32_t)mBuf; 
    }
 #endif
    /* call external function for intialization */
@@ -204,7 +189,7 @@ Reason reason;              /* reason */
 
    
 
-   RETVALUE(ROK);
+   return ROK;
 } /* kwActvInit */
 
 \f
@@ -228,21 +213,14 @@ Reason reason;              /* reason */
 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
 pthread_t gRlcTId = 0;
 #endif
-#ifdef ANSI
-PUBLIC S16 rlcDlActvTsk
+S16 rlcDlActvTsk
 (
 Pst *pst,              /* pst structure */
 Buffer *mBuf            /* message buffer */
 )
-#else
-PUBLIC S16 rlcDlActvTsk(pst, mBuf)
-Pst *pst;              /* pst structure */
-Buffer *mBuf;           /* message buffer */
-#endif
 {
    S16 ret = ROK;
 
-   TRC3(rlcDlActvTsk);
 #ifdef RLC_FREE_RING_BUF
    gRlcTId = pthread_self();
 #endif
@@ -256,25 +234,25 @@ 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 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 */
@@ -283,12 +261,18 @@ Buffer *mBuf;           /* message buffer */
 #ifdef LCKWU
                case KWU_EVT_DAT_REQ:              /* Data request */
                   {
-                     ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+                     //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
                      break;
                   }
 #endif /* LCKWU */
+               
+               case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
+                 {
+                    ret = unpackDlRrcMsgToRlc(RlcProcDlRrcMsgTransfer, pst, mBuf);
+                    break;
+                 }
                default:
-                  SPutMsg(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
                       RLOG1(L_ERROR,"Received Invalid Event[%d] from SM",
@@ -301,7 +285,7 @@ Buffer *mBuf;           /* message buffer */
             break;
          }
 
-      case ENTKW:
+      case ENTRLC:
          {
 
             switch(pst->event)
@@ -365,12 +349,12 @@ Buffer *mBuf;           /* message buffer */
 #endif  /* LCCKW */
                case UDX_EVT_DL_CLEANUP_MEM:
                   {
-                     kwUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
+                     rlcUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
                      break;
                   }
                
                default:
-                  SPutMsg(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
@@ -390,37 +374,37 @@ 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;
                   }
 #ifdef L2_L3_SPLIT
                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
                   {
-                     ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+                     ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
                      break;
                   }
 #else
                case KWU_EVT_DAT_REQ:              /* Data request */
                   {
-                     ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+                     //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
                      break;
                   }
 #endif
                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
                   {
-                     ret = cmUnpkKwuDiscSduReq(KwUiKwuDiscSduReq, pst, mBuf);
+                     ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
                      break;
                   }
 
 #endif  /* LCKWU */
                default:
-                  SPutMsg(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
@@ -440,37 +424,37 @@ 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;
                   }
 #ifdef L2_L3_SPLIT
                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
                case KWU_EVT_UPLANE_DAT_REQ:       /* U-Plane Data request */
                   {
-                     ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+                     ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
                      break;
                   }
 #else
                case KWU_EVT_DAT_REQ:              /* Data request */
                   {
-                     ret = cmUnpkKwuDatReq(KwUiKwuDatReq, pst, mBuf);
+                     //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
                      break;
                   }
 #endif
                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
                   {
-                     ret = cmUnpkKwuDiscSduReq(KwUiKwuDiscSduReq, pst, mBuf);
+                     ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
                      break;
                   }
 
                default:
-                  SPutMsg(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
                       RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
@@ -483,32 +467,32 @@ 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 EVTSCHREP:    /* Dedicated Channel Status Response */
+               case EVENT_SCHED_RESULT_TO_RLC: 
                   {
-                     ret = unpackSchedRep(RlcMacProcSchedRep, pst, mBuf);
+                     ret = unpackSchedResultRpt(RlcProcSchedResultRpt, pst, mBuf);
                      break;
                   }
                   /* kw005.201 added support for L2 Measurement */
 #ifdef LTE_L2_MEAS
                case EVTRGUHQSTAIND:    /* Harq status indication */
                   {
-                     ret = cmUnpkRguHqStaInd(KwLiRguHqStaInd, pst, mBuf);
+                     ret = cmUnpkRguHqStaInd(RlcLiRguHqStaInd, pst, mBuf);
                      break;
                   }
 #endif
                case EVTRGUFLOWCNTRLIND:
                   {
-                     ret = cmUnpkRguFlowCntrlInd(KwLiRguFlowCntrlInd,pst,mBuf);
+                     ret = cmUnpkRguFlowCntrlInd(RlcLiRguFlowCntrlInd,pst,mBuf);
                      break;
                   }   
 #endif  /* LCRGU */
@@ -521,7 +505,7 @@ Buffer *mBuf;           /* message buffer */
 #endif
 
                default:
-                  SPutMsg(mBuf);
+                  ODU_PUT_MSG_BUF(mBuf);
                   if (pst->dstInst < MAX_RLC_INSTANCES)
                   {
                       RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
@@ -533,17 +517,17 @@ Buffer *mBuf;           /* message buffer */
             break;
          }
 #ifdef SS_RBUF 
-      case ENTTF:
+      case ENTLWRMAC:
       {
             switch(pst->event)
             {
                case EVTCTFBTCHPROCTICK:
                {
-                  kwUtlDlBatchProcPkts();
+                  rlcUtlDlBatchProcPkts();
                   break;
                }
              }
-         SPutMsg(mBuf);
+         ODU_PUT_MSG_BUF(mBuf);
          break;
       }
 #endif
@@ -563,15 +547,15 @@ Buffer *mBuf;           /* message buffer */
 
 #if (defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
                      //RlcDlHarqStaBatchProc();
-                     kwUtlDlBatchProcHqStaInd();
+                     rlcUtlDlBatchProcHqStaInd();
 #endif 
 #ifndef KWSELFPSTDLCLEAN
                      /* Revanth_chg */
                      /* Moving Cleanup from self post event to TTI event */
-                     kwUtlFreeDlMem();
+                     rlcUtlFreeDlMem();
 #endif 
 
-                     SPutMsg(mBuf);
+                     ODU_PUT_MSG_BUF(mBuf);
                      break;
                   }
             }
@@ -587,14 +571,14 @@ Buffer *mBuf;           /* message buffer */
                RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",
                      pst->event);
             }
-            SPutMsg(mBuf);
+            ODU_PUT_MSG_BUF(mBuf);
             ret = RFAILED;
             break;
          }
     }
-   SExitTsk();
+   ODU_EXIT_TASK();
 
-   RETVALUE(ret);
+   return (ret);
 } /* kwActvTsk */