src/5gnrrlc/rlc_dl_msg_router.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /********************************************************************20**
  20
  21         Name:    NR RLC Layer - System Services Interface Functions
  22
  23         Type:    C file
  24
  25         Desc:    C source code for the interface to System Services
  26                   of NR RLC
  27
  28         File:    rlc_dl_msg_router.c
  29
  30 *********************************************************************21*/
  31
  32 /** @filerlc_dl_msg_router.c
  33 @brief RLC System Services Interface
  34 */
  35
  36 \f
  37 /* header (.h) include files */
  38 #include "common_def.h"
  39 #include "lkw.h"           /* LKW defines */
  40 #include "ckw.h"           /* CKW defines */
  41 #include "kwu.h"           /* KWU defines */
  42 #include "rgu.h"           /* RGU defines */
  43 #include "rlc_err.h"        /* Err defines */
  44 #include "rlc_env.h"        /* RLC environment options */
  45
  46
  47
  48 /* extern (.x) include files */
  49 #include "lkw.x"           /* LKW */
  50 #include "ckw.x"           /* CKW */
  51 #include "kwu.x"           /* KWU */
  52 #include "rgu.x"           /* RGU */
  53
  54 #include "rlc_utils.h"            /* RLC defines */
  55 #include "rlc_dl_ul_inf.h"
  56 #include "rlc_dl.h"
  57 #include "du_app_rlc_inf.h"
  58 #include "rlc_mac_inf.h"
  59
  60 #include "ctf.h"
  61 S16 rlcUtlDlBatchProcPkts(Void);
  62 S16 rlcDlBatchProc(Void);
  63 #if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
  64 uint32_t isDatReqProcessed;
  65 void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
  66 #endif
  67
  68 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
  69 S16 rlcDlBatchProcSplit  ARGS((Void));
  70 #endif
  71 //UDAY
  72 #ifdef L2_OPTMZ
  73 uint32_t rlcAmmStaPduList[512] = {0};
  74 S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
  75 #endif
  76 S16 rlcDlInitExt ARGS (( Void ));
  77 \f
  78 /**
  79  *
  80  * @brief
  81  *
  82  *  <b> Initialize External </b>
  83  *
  84  *  @b Description:
  85  *  Initializes variables used to interface with Upper/Lower Layer
  86  *
  87  *  @return  S16
  88  *      -# ROK
  89  *
  90 */
  91
  92 S16 rlcDlInitExt()
  93 {
  94    return ROK;
  95 } /* kwInitExt */
  96
  97
  98 \f
  99 /***********************************************************************
 100                       System Service Interface Functions
 101  ***********************************************************************/
 102 /**
 103  *
 104  * @brief
 105  *
 106  *    <b> Activates Initialization </b>
 107  *
 108  *    @b Description:
 109  *    This function is invoked by system services to initialize the NR RLC
 110  *    layer. This is an entry point used by LTE_RLC layer to initialize its
 111  *    global variables, before becoming operational.
 112  *
 113  *    Allowable values for parameters are specified in ssi.h.
 114  *
 115  *    @param[in] ent    - Specify the entity id of the NR RLC task.
 116  *    @param[in] inst   - Specify the entity id of the NR RLC task.
 117  *    @param[in] region - Specifies the memory region from which
 118  *                         NR RLC should allocate structures and buffers.
 119  *    @param[in] reason - Specifies the reason for calling this
 120  *                         initialization function.
 121  *
 122  *  @return  S16
 123  *      -# ROK
 124  *
 125  */
 126 S16 rlcDlActvInit
 127 (
 128 Ent    ent,                 /* entity */
 129 Inst   inst,                /* instance */
 130 Region region,              /* region */
 131 Reason reason               /* reason */
 132 )
 133 {
 134    RlcCb    *tRlcCb;
 135
 136    if (inst >= MAX_RLC_INSTANCES)
 137    {
 138        /* intance greater than MAX instances */
 139        return RFAILED;
 140    }
 141
 142    if (rlcCb[inst] != NULLP)
 143    {
 144        return  (RFAILED);
 145    }
 146
 147    if (SGetSBuf(region, 0, (Data **)&tRlcCb,
 148                 (Size)sizeof (RlcCb)) != ROK)
 149    {
 150       return RFAILED;
 151    }
 152    /* Initialize rlcCb */
 153    RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
 154
 155    /* Initialize task configuration parameters */
 156    tRlcCb->init.ent     = ent;           /* entity */
 157    tRlcCb->init.inst    = inst;          /* instance */
 158    tRlcCb->init.region  = region;        /* static region */
 159    tRlcCb->init.pool    = 0;             /* static pool */
 160    tRlcCb->init.reason  = reason;        /* reason */
 161    tRlcCb->init.cfgDone = FALSE;         /* configuration done */
 162    tRlcCb->init.acnt    = TRUE;          /* enable accounting */
 163    tRlcCb->init.usta    = TRUE;          /* enable unsolicited status */
 164    tRlcCb->init.trc     = FALSE;         /* enable trace */
 165    tRlcCb->init.procId  = ODU_GET_PROCID();
 166
 167    rlcCb[inst] = tRlcCb;
 168
 169 //UDAY
 170 #ifdef L2_OPTMZ
 171    for(int i = 0; i < 512; i++)
 172    {
 173       Buffer *mBuf = NULL;
 174       Buffer *bufPtr = NULL;
 175       ODU_GET_MSG_BUF(1, 0 , &mBuf);
 176       ssGetDBufOfSize(1 , 1800, &bufPtr);
 177       SUpdMsg(mBuf, bufPtr, 0);
 178       rlcAmmStaPduList[i] = (uint32_t)mBuf;
 179    }
 180 #endif
 181    /* call external function for intialization */
 182    /*
 183    kwInitExt();
 184    */
 185
 186
 187
 188    return ROK;
 189 } /* kwActvInit */
 190
 191 /*
 192 *
 193 * @brief
 194 *
 195 * Function:
 196 *   name : callFlowRlcDlActvTsk
 197 *
 198 *  @b Description:
 199 *  Function used to print values of src, dest, message
 200 *  received at the layer
 201 *
 202 *  @param[in] pst   - Pst Structure
 203 *
 204 *  @return void
 205 */
 206 void callFlowRlcDlActvTsk(Pst *pst)
 207 {
 208    char sourceTask[50];
 209    char destTask[50]="ENTMAC";
 210    char message[100];
 211    switch(pst->srcEnt)
 212    {
 213       case ENTDUAPP:
 214          {
 215             strcpy(sourceTask,"ENTDUAPP");
 216             switch(pst->event)
 217             {
 218 #ifdef LCLKW
 219                case LKW_EVT_CFG_REQ:
 220                   {
 221                      strcpy(message,"LKW_EVT_CFG_REQ");
 222                      break;
 223                   }
 224
 225                case LKW_EVT_CNTRL_REQ:
 226                   {
 227                      strcpy(message,"LKW_EVT_CNTRL_REQ");
 228                      break;
 229                   }
 230
 231                case LKW_EVT_STS_REQ:
 232                   {
 233                      strcpy(message,"LKW_EVT_STS_REQ");
 234                      break;
 235                   }
 236
 237                case LKW_EVT_STA_REQ:
 238                   {
 239                      strcpy(message,"LKW_EVT_STA_REQ");
 240                      break;
 241                   }
 242                   /* kw005.201 added support for L2 Measurement */
 243 #endif  /* LCLKW */
 244
 245 #ifdef LCKWU
 246                case KWU_EVT_DAT_REQ:              /* Data request */
 247                   {
 248                      strcpy(message,"KWU_EVT_DAT_REQ");
 249                      break;
 250                   }
 251 #endif /* LCKWU */
 252
 253                case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
 254                   {
 255                      strcpy(message,"EVENT_DL_RRC_MSG_TRANS_TO_RLC");
 256                      break;
 257                   }
 258                case EVENT_DL_USER_DATA_TRANS_TO_RLC:
 259                   {
 260                      strcpy(message,"EVENT_DL_USER_DATA_TRANS_TO_RLC");
 261                      break;
 262                   }
 263                default:
 264                   strcpy(message,"Invalid Event");
 265                   break;
 266             }
 267             break;
 268          }
 269
 270       case ENTRLC:
 271          {
 272
 273             strcpy(sourceTask,"ENTRLC");
 274             switch(pst->event)
 275             {
 276 #ifdef LCUDX
 277                case UDX_EVT_BND_REQ:              /* Bind request */
 278                   {
 279                      strcpy(message,"UDX_EVT_BND_REQ");
 280                      break;
 281                   }
 282
 283                case UDX_EVT_UBND_REQ:              /* Bind request */
 284                   {
 285                      strcpy(message,"UDX_EVT_UBND_REQ");
 286                      break;
 287                   }
 288                case UDX_EVT_CFG_REQ:             /* Unbind request */
 289                   {
 290                      strcpy(message,"UDX_EVT_CFG_REQ");
 291                      break;
 292                   }
 293
 294                case UDX_EVT_UEIDCHG_REQ:              /* Configuration request */
 295                   {
 296                      strcpy(message,"UDX_EVT_UEIDCHG_REQ");
 297                      break;
 298                   }
 299
 300                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 301                   {
 302                      strcpy(message,"UDX_EVT_STA_UPD_REQ");
 303                      break;
 304                   }
 305
 306                case UDX_EVT_STA_PDU_REQ:              /* Configuration request */
 307                   {
 308                      strcpy(message,"UDX_EVT_STA_PDU_REQ");
 309                      break;
 310                   }
 311
 312 #endif  /* LCCKW */
 313                case UDX_EVT_DL_CLEANUP_MEM:
 314                   {
 315                   strcpy(message,"UDX_EVT_DL_CLEANUP_MEM");
 316                      break;
 317                   }
 318
 319                default:
 320                   strcpy(message,"Invalid Event");
 321                   break;
 322
 323             }
 324             break;
 325          }
 326
 327       case ENTMAC:
 328          {
 329             strcpy(sourceTask,"ENTMAC");
 330             switch(pst->event)
 331             {
 332 #ifdef LCRGU
 333                case EVTRGUBNDCFM:     /* Bind request */
 334                   {
 335                      strcpy(message,"EVTRGUBNDCFM");
 336                      break;
 337                   }
 338                case EVENT_SCHED_RESULT_TO_RLC:
 339                   {
 340                      strcpy(message,"EVENT_SCHED_RESULT_TO_RLC");
 341                      break;
 342                   }
 343                   /* kw005.201 added support for L2 Measurement */
 344                case EVTRGUFLOWCNTRLIND:
 345                   {
 346                      strcpy(message,"EVTRGUFLOWCNTRLIND");
 347                      break;
 348                   }
 349 #endif  /* LCRGU */
 350 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
 351                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 352                   {
 353                      strcpy(message,"UDX_EVT_STA_UPD_REQ");
 354                      break;
 355                   }
 356 #endif
 357                default:
 358                   strcpy(message,"Invalid Event");
 359                   break;
 360
 361             }
 362             break;
 363          }
 364       default:
 365          {
 366             strcpy(sourceTask,"Invalid Source Entity Id");
 367          }
 368     }
 369    DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
 370 }
 371 \f
 372 /**
 373  *
 374  * @brief
 375  *
 376  *  <b> Activation Task </b>
 377  *
 378  *  @b Description:
 379  *  Processes events received for NR RLC layer via System Services from
 380  *  other layers.
 381  *
 382  *  @param[in] pst   - Pst Structure
 383  *  @param[in] mBuf  - Message Buffer
 384  *
 385  *  @return  S16
 386  *      -# ROK
 387  *
 388  */
 389 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
 390 pthread_t gRlcTId = 0;
 391 #endif
 392 S16 rlcDlActvTsk
 393 (
 394 Pst *pst,              /* pst structure */
 395 Buffer *mBuf            /* message buffer */
 396 )
 397 {
 398    S16 ret = ROK;
 399
 400 #ifdef RLC_FREE_RING_BUF
 401    gRlcTId = pthread_self();
 402 #endif
 403
 404 #ifdef CALL_FLOW_DEBUG_LOG
 405    callFlowRlcDlActvTsk(pst);
 406 #endif
 407
 408    switch(pst->srcEnt)
 409    {
 410       case ENTDUAPP:
 411          {
 412             switch(pst->event)
 413             {
 414 #ifdef LCLKW
 415                case LKW_EVT_CFG_REQ:
 416                   {
 417                      ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
 418                      break;
 419                   }
 420
 421                case LKW_EVT_CNTRL_REQ:
 422                   {
 423                      ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
 424                      break;
 425                   }
 426
 427                case LKW_EVT_STS_REQ:
 428                   {
 429                      ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
 430                      break;
 431                   }
 432
 433                case LKW_EVT_STA_REQ:
 434                   {
 435                      ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
 436                      break;
 437                   }
 438                   /* kw005.201 added support for L2 Measurement */
 439 #endif  /* LCLKW */
 440
 441 #ifdef LCKWU
 442                case KWU_EVT_DAT_REQ:              /* Data request */
 443                   {
 444                      //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 445                      break;
 446                   }
 447 #endif /* LCKWU */
 448
 449                case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
 450                   {
 451                      ret = unpackDlRrcMsgToRlc(RlcProcDlRrcMsgTransfer, pst, mBuf);
 452                      break;
 453                   }
 454                case EVENT_DL_USER_DATA_TRANS_TO_RLC:
 455                   {
 456                      ret = unpackRlcDlUserDataToRlc(RlcProcDlUserDataTransfer, pst, mBuf);
 457                      break;
 458                   }
 459                default:
 460                   ODU_PUT_MSG_BUF(mBuf);
 461                   if (pst->dstInst < MAX_RLC_INSTANCES)
 462                   {
 463                       DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from SM",
 464                             pst->event);
 465                   }
 466                   ret = RFAILED;
 467                   break;
 468
 469             }
 470             break;
 471          }
 472
 473       case ENTRLC:
 474          {
 475
 476             switch(pst->event)
 477             {
 478 #ifdef LCUDX
 479                case UDX_EVT_BND_REQ:              /* Bind request */
 480                   {
 481                      ret = cmUnpkUdxBndReq(rlcDlUdxBndReq, pst, mBuf );
 482                      break;
 483                   }
 484
 485                case UDX_EVT_UBND_REQ:              /* Bind request */
 486                   {
 487                      ret = cmUnpkUdxUbndReq(rlcDlUdxUbndReq, pst, mBuf );
 488                      break;
 489                   }
 490                case UDX_EVT_CFG_REQ:             /* Unbind request */
 491                   {
 492                      ret = cmUnpkUdxCfgReq(rlcDlUdxCfgReq, pst, mBuf );
 493                      break;
 494                   }
 495
 496                case UDX_EVT_UEIDCHG_REQ:              /* Configuration request */
 497                   {
 498                      ret = cmUnpkUdxUeIdChgReq(rlcDlUdxUeIdChgReq, pst, mBuf);
 499                      break;
 500                   }
 501
 502                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 503                   {
 504                      ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
 505                      break;
 506                   }
 507
 508                case UDX_EVT_STA_PDU_REQ:              /* Configuration request */
 509                   {
 510                      ret = cmUnpkUdxStaPduReq(rlcDlUdxStaPduReq, pst, mBuf);
 511                      break;
 512                   }
 513
 514 #ifdef LTE_L2_MEAS
 515                case UDX_EVT_L2MEAS_REQ:
 516                   {
 517                      ret = cmUnpkUdxL2MeasReq(rlcDlUdxL2MeasReq, pst, mBuf);
 518                      break;
 519                   }
 520                case UDX_EVT_L2MEAS_SEND_REQ:
 521                  {
 522
 523                     ret = cmUnpkUdxL2MeasSendReq(rlcDlUdxL2MeasSendReq, pst, mBuf);
 524
 525                      break;
 526                  }
 527                case UDX_EVT_L2MEAS_STOP_REQ:
 528                  {
 529                      ret = cmUnpkUdxL2MeasStopReq(rlcDlUdxL2MeasStopReq, pst, mBuf);
 530                      break;
 531                  }
 532 #endif
 533
 534 #endif  /* LCCKW */
 535                case UDX_EVT_DL_CLEANUP_MEM:
 536                   {
 537                      rlcUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
 538                      break;
 539                   }
 540
 541                default:
 542                   ODU_PUT_MSG_BUF(mBuf);
 543                   if (pst->dstInst < MAX_RLC_INSTANCES)
 544                   {
 545                       DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from RLC UL",
 546                             pst->event);
 547                   }
 548                   ret = RFAILED;
 549                   break;
 550
 551             }
 552             break;
 553          }
 554
 555       case ENTNH:
 556          {
 557             switch(pst->event)
 558             {
 559 #ifdef LCKWU
 560                case KWU_EVT_BND_REQ:              /* Bind request */
 561                   {
 562                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 563                      break;
 564                   }
 565
 566                case KWU_EVT_UBND_REQ:             /* Unbind request */
 567                   {
 568                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 569                      break;
 570                   }
 571 #ifdef L2_L3_SPLIT
 572                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
 573                   {
 574                      ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 575                      break;
 576                   }
 577 #else
 578                case KWU_EVT_DAT_REQ:              /* Data request */
 579                   {
 580                      //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 581                      break;
 582                   }
 583 #endif
 584                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
 585                   {
 586                      ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
 587                      break;
 588                   }
 589
 590 #endif  /* LCKWU */
 591                default:
 592                   ODU_PUT_MSG_BUF(mBuf);
 593                   if (pst->dstInst < MAX_RLC_INSTANCES)
 594                   {
 595                      DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from RRC",
 596                             pst->event);
 597                   }
 598                   ret = RFAILED;
 599                   break;
 600
 601             }
 602             break;
 603          }
 604
 605       case ENTPJ:
 606          {
 607             switch(pst->event)
 608             {
 609 #ifdef LCKWU
 610                case KWU_EVT_BND_REQ:              /* Bind request */
 611                   {
 612                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 613                      break;
 614                   }
 615
 616                case KWU_EVT_UBND_REQ:             /* Unbind request */
 617                   {
 618                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 619                      break;
 620                   }
 621 #ifdef L2_L3_SPLIT
 622                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
 623                case KWU_EVT_UPLANE_DAT_REQ:       /* U-Plane Data request */
 624                   {
 625                      ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 626                      break;
 627                   }
 628 #else
 629                case KWU_EVT_DAT_REQ:              /* Data request */
 630                   {
 631                      //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 632                      break;
 633                   }
 634 #endif
 635                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
 636                   {
 637                      ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
 638                      break;
 639                   }
 640
 641                default:
 642                   ODU_PUT_MSG_BUF(mBuf);
 643                   if (pst->dstInst < MAX_RLC_INSTANCES)
 644                   {
 645                      DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from PDCP",
 646                             pst->event);
 647                   }
 648                   ret = RFAILED;
 649                   break;
 650 #endif  /* LCKWU */
 651             }
 652             break;
 653          }
 654
 655       case ENTMAC:
 656          {
 657             switch(pst->event)
 658             {
 659 #ifdef LCRGU
 660                case EVTRGUBNDCFM:     /* Bind request */
 661                   {
 662                      ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
 663                      break;
 664                   }
 665                case EVENT_SCHED_RESULT_TO_RLC:
 666                   {
 667                      ret = unpackSchedResultRpt(RlcProcSchedResultRpt, pst, mBuf);
 668                      break;
 669                   }
 670                   /* kw005.201 added support for L2 Measurement */
 671 #ifdef LTE_L2_MEAS
 672                case EVTRGUHQSTAIND:    /* Harq status indication */
 673                   {
 674                      ret = cmUnpkRguHqStaInd(RlcLiRguHqStaInd, pst, mBuf);
 675                      break;
 676                   }
 677 #endif
 678                case EVTRGUFLOWCNTRLIND:
 679                   {
 680                      ret = cmUnpkRguFlowCntrlInd(RlcLiRguFlowCntrlInd,pst,mBuf);
 681                      break;
 682                   }
 683 #endif  /* LCRGU */
 684 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
 685                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 686                   {
 687                      ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
 688                      break;
 689                   }
 690 #endif
 691
 692                default:
 693                   ODU_PUT_MSG_BUF(mBuf);
 694                   if (pst->dstInst < MAX_RLC_INSTANCES)
 695                   {
 696                       DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from MAC",
 697                             pst->event);
 698                   }
 699                   ret = RFAILED;
 700                   break;
 701             }
 702             break;
 703          }
 704 #ifdef SS_RBUF
 705       case ENTLWRMAC:
 706       {
 707             switch(pst->event)
 708             {
 709                case EVTCTFBTCHPROCTICK:
 710                {
 711                   rlcUtlDlBatchProcPkts();
 712                   break;
 713                }
 714              }
 715          ODU_PUT_MSG_BUF(mBuf);
 716          break;
 717       }
 718 #endif
 719       case ENTYS:
 720          {
 721             switch(pst->event)
 722             {
 723                case KWU_EVT_TTI_IND:
 724                   {
 725 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
 726                      rlcDlBatchProcSplit();
 727 #else
 728 #if defined(PDCP_RLC_DL_RBUF)
 729                      rlcDlBatchProc();
 730 #endif
 731 #endif
 732
 733 #if (defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
 734                      //RlcDlHarqStaBatchProc();
 735                      rlcUtlDlBatchProcHqStaInd();
 736 #endif
 737 #ifndef KWSELFPSTDLCLEAN
 738                      /* Revanth_chg */
 739                      /* Moving Cleanup from self post event to TTI event */
 740                      rlcUtlFreeDlMem();
 741 #endif
 742
 743                      ODU_PUT_MSG_BUF(mBuf);
 744                      break;
 745                   }
 746             }
 747             break;
 748          }
 749
 750
 751       default:
 752          {
 753             if (pst->dstInst < MAX_RLC_INSTANCES)
 754             {
 755                /*RlcCb *tRlcCb = RLC_GET_RLCCB(pst->dstInst);*/
 756                DU_LOG("\nERROR  --> RLC_DL : Received Invalid Source Entity[%d]",
 757                      pst->event);
 758             }
 759             ODU_PUT_MSG_BUF(mBuf);
 760             ret = RFAILED;
 761             break;
 762          }
 763     }
 764    ODU_EXIT_TASK();
 765
 766    return (ret);
 767 } /* kwActvTsk */
 768
 769
 770 \f
 771 /********************************************************************30**
 772          End of file
 773 **********************************************************************/