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 #ifdef CALL_FLOW_DEBUG_LOG
 192 /*
 193 *
 194 * @brief
 195 *
 196 * Function:
 197 *   name : callFlowRlcDlActvTsk
 198 *
 199 *  @b Description:
 200 *  Function used to print values of src, dest, message
 201 *  received at the layer
 202 *
 203 *  @param[in] pst   - Pst Structure
 204 *
 205 *  @return void
 206 */
 207 void callFlowRlcDlActvTsk(Pst *pst)
 208 {
 209    char sourceTask[50];
 210    char destTask[50]="ENTMAC";
 211    char message[100];
 212    switch(pst->srcEnt)
 213    {
 214       case ENTDUAPP:
 215          {
 216             strcpy(sourceTask,"ENTDUAPP");
 217             switch(pst->event)
 218             {
 219 #ifdef LCLKW
 220                case LKW_EVT_CFG_REQ:
 221                   {
 222                      strcpy(message,"LKW_EVT_CFG_REQ");
 223                      break;
 224                   }
 225
 226                case LKW_EVT_CNTRL_REQ:
 227                   {
 228                      strcpy(message,"LKW_EVT_CNTRL_REQ");
 229                      break;
 230                   }
 231
 232                case LKW_EVT_STS_REQ:
 233                   {
 234                      strcpy(message,"LKW_EVT_STS_REQ");
 235                      break;
 236                   }
 237
 238                case LKW_EVT_STA_REQ:
 239                   {
 240                      strcpy(message,"LKW_EVT_STA_REQ");
 241                      break;
 242                   }
 243                   /* kw005.201 added support for L2 Measurement */
 244 #endif  /* LCLKW */
 245
 246 #ifdef LCKWU
 247                case KWU_EVT_DAT_REQ:              /* Data request */
 248                   {
 249                      strcpy(message,"KWU_EVT_DAT_REQ");
 250                      break;
 251                   }
 252 #endif /* LCKWU */
 253
 254                case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
 255                   {
 256                      strcpy(message,"EVENT_DL_RRC_MSG_TRANS_TO_RLC");
 257                      break;
 258                   }
 259                case EVENT_DL_USER_DATA_TRANS_TO_RLC:
 260                   {
 261                      strcpy(message,"EVENT_DL_USER_DATA_TRANS_TO_RLC");
 262                      break;
 263                   }
 264                default:
 265                   strcpy(message,"Invalid Event");
 266                   break;
 267             }
 268             break;
 269          }
 270
 271       case ENTRLC:
 272          {
 273
 274             strcpy(sourceTask,"ENTRLC");
 275             switch(pst->event)
 276             {
 277 #ifdef LCUDX
 278                case UDX_EVT_BND_REQ:              /* Bind request */
 279                   {
 280                      strcpy(message,"UDX_EVT_BND_REQ");
 281                      break;
 282                   }
 283
 284                case UDX_EVT_UBND_REQ:              /* Bind request */
 285                   {
 286                      strcpy(message,"UDX_EVT_UBND_REQ");
 287                      break;
 288                   }
 289                case UDX_EVT_CFG_REQ:             /* Unbind request */
 290                   {
 291                      strcpy(message,"UDX_EVT_CFG_REQ");
 292                      break;
 293                   }
 294
 295                case UDX_EVT_UEIDCHG_REQ:              /* Configuration request */
 296                   {
 297                      strcpy(message,"UDX_EVT_UEIDCHG_REQ");
 298                      break;
 299                   }
 300
 301                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 302                   {
 303                      strcpy(message,"UDX_EVT_STA_UPD_REQ");
 304                      break;
 305                   }
 306
 307                case UDX_EVT_STA_PDU_REQ:              /* Configuration request */
 308                   {
 309                      strcpy(message,"UDX_EVT_STA_PDU_REQ");
 310                      break;
 311                   }
 312
 313 #endif  /* LCCKW */
 314                case UDX_EVT_DL_CLEANUP_MEM:
 315                   {
 316                   strcpy(message,"UDX_EVT_DL_CLEANUP_MEM");
 317                      break;
 318                   }
 319
 320                default:
 321                   strcpy(message,"Invalid Event");
 322                   break;
 323
 324             }
 325             break;
 326          }
 327
 328       case ENTMAC:
 329          {
 330             strcpy(sourceTask,"ENTMAC");
 331             switch(pst->event)
 332             {
 333 #ifdef LCRGU
 334                case EVTRGUBNDCFM:     /* Bind request */
 335                   {
 336                      strcpy(message,"EVTRGUBNDCFM");
 337                      break;
 338                   }
 339                case EVENT_SCHED_RESULT_TO_RLC:
 340                   {
 341                      strcpy(message,"EVENT_SCHED_RESULT_TO_RLC");
 342                      break;
 343                   }
 344                   /* kw005.201 added support for L2 Measurement */
 345                case EVTRGUFLOWCNTRLIND:
 346                   {
 347                      strcpy(message,"EVTRGUFLOWCNTRLIND");
 348                      break;
 349                   }
 350 #endif  /* LCRGU */
 351 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
 352                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 353                   {
 354                      strcpy(message,"UDX_EVT_STA_UPD_REQ");
 355                      break;
 356                   }
 357 #endif
 358                default:
 359                   strcpy(message,"Invalid Event");
 360                   break;
 361
 362             }
 363             break;
 364          }
 365       default:
 366          {
 367             strcpy(sourceTask,"Invalid Source Entity Id");
 368          }
 369     }
 370    DU_LOG("\nCall Flow: %s -> %s : %s\n", sourceTask, destTask, message);
 371 }
 372 #endif
 373
 374 \f
 375 /**
 376  *
 377  * @brief
 378  *
 379  *  <b> Activation Task </b>
 380  *
 381  *  @b Description:
 382  *  Processes events received for NR RLC layer via System Services from
 383  *  other layers.
 384  *
 385  *  @param[in] pst   - Pst Structure
 386  *  @param[in] mBuf  - Message Buffer
 387  *
 388  *  @return  S16
 389  *      -# ROK
 390  *
 391  */
 392 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
 393 pthread_t gRlcTId = 0;
 394 #endif
 395 S16 rlcDlActvTsk
 396 (
 397 Pst *pst,              /* pst structure */
 398 Buffer *mBuf            /* message buffer */
 399 )
 400 {
 401    S16 ret = ROK;
 402
 403 #ifdef RLC_FREE_RING_BUF
 404    gRlcTId = pthread_self();
 405 #endif
 406
 407 #ifdef CALL_FLOW_DEBUG_LOG
 408    callFlowRlcDlActvTsk(pst);
 409 #endif
 410
 411    switch(pst->srcEnt)
 412    {
 413       case ENTDUAPP:
 414          {
 415             switch(pst->event)
 416             {
 417 #ifdef LCLKW
 418                case LKW_EVT_CFG_REQ:
 419                   {
 420                      ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
 421                      break;
 422                   }
 423
 424                case LKW_EVT_CNTRL_REQ:
 425                   {
 426                      ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
 427                      break;
 428                   }
 429
 430                case LKW_EVT_STS_REQ:
 431                   {
 432                      ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
 433                      break;
 434                   }
 435
 436                case LKW_EVT_STA_REQ:
 437                   {
 438                      ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
 439                      break;
 440                   }
 441                   /* kw005.201 added support for L2 Measurement */
 442 #endif  /* LCLKW */
 443
 444 #ifdef LCKWU
 445                case KWU_EVT_DAT_REQ:              /* Data request */
 446                   {
 447                      //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 448                      break;
 449                   }
 450 #endif /* LCKWU */
 451
 452                case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
 453                   {
 454                      ret = unpackDlRrcMsgToRlc(RlcProcDlRrcMsgTransfer, pst, mBuf);
 455                      break;
 456                   }
 457                case EVENT_DL_USER_DATA_TRANS_TO_RLC:
 458                   {
 459                      ret = unpackRlcDlUserDataToRlc(RlcProcDlUserDataTransfer, pst, mBuf);
 460                      break;
 461                   }
 462                default:
 463                   ODU_PUT_MSG_BUF(mBuf);
 464                   if (pst->dstInst < MAX_RLC_INSTANCES)
 465                   {
 466                       DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from SM",
 467                             pst->event);
 468                   }
 469                   ret = RFAILED;
 470                   break;
 471
 472             }
 473             break;
 474          }
 475
 476       case ENTRLC:
 477          {
 478
 479             switch(pst->event)
 480             {
 481 #ifdef LCUDX
 482                case UDX_EVT_BND_REQ:              /* Bind request */
 483                   {
 484                      ret = cmUnpkUdxBndReq(rlcDlUdxBndReq, pst, mBuf );
 485                      break;
 486                   }
 487
 488                case UDX_EVT_UBND_REQ:              /* Bind request */
 489                   {
 490                      ret = cmUnpkUdxUbndReq(rlcDlUdxUbndReq, pst, mBuf );
 491                      break;
 492                   }
 493                case UDX_EVT_CFG_REQ:             /* Unbind request */
 494                   {
 495                      ret = cmUnpkUdxCfgReq(rlcDlUdxCfgReq, pst, mBuf );
 496                      break;
 497                   }
 498
 499                case UDX_EVT_UEIDCHG_REQ:              /* Configuration request */
 500                   {
 501                      ret = cmUnpkUdxUeIdChgReq(rlcDlUdxUeIdChgReq, pst, mBuf);
 502                      break;
 503                   }
 504
 505                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 506                   {
 507                      ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
 508                      break;
 509                   }
 510
 511                case UDX_EVT_STA_PDU_REQ:              /* Configuration request */
 512                   {
 513                      ret = cmUnpkUdxStaPduReq(rlcDlUdxStaPduReq, pst, mBuf);
 514                      break;
 515                   }
 516
 517 #ifdef LTE_L2_MEAS
 518                case UDX_EVT_L2MEAS_REQ:
 519                   {
 520                      ret = cmUnpkUdxL2MeasReq(rlcDlUdxL2MeasReq, pst, mBuf);
 521                      break;
 522                   }
 523                case UDX_EVT_L2MEAS_SEND_REQ:
 524                  {
 525
 526                     ret = cmUnpkUdxL2MeasSendReq(rlcDlUdxL2MeasSendReq, pst, mBuf);
 527
 528                      break;
 529                  }
 530                case UDX_EVT_L2MEAS_STOP_REQ:
 531                  {
 532                      ret = cmUnpkUdxL2MeasStopReq(rlcDlUdxL2MeasStopReq, pst, mBuf);
 533                      break;
 534                  }
 535 #endif
 536
 537 #endif  /* LCCKW */
 538                case UDX_EVT_DL_CLEANUP_MEM:
 539                   {
 540                      rlcUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
 541                      break;
 542                   }
 543
 544                default:
 545                   ODU_PUT_MSG_BUF(mBuf);
 546                   if (pst->dstInst < MAX_RLC_INSTANCES)
 547                   {
 548                       DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from RLC UL",
 549                             pst->event);
 550                   }
 551                   ret = RFAILED;
 552                   break;
 553
 554             }
 555             break;
 556          }
 557
 558       case ENTNH:
 559          {
 560             switch(pst->event)
 561             {
 562 #ifdef LCKWU
 563                case KWU_EVT_BND_REQ:              /* Bind request */
 564                   {
 565                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 566                      break;
 567                   }
 568
 569                case KWU_EVT_UBND_REQ:             /* Unbind request */
 570                   {
 571                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 572                      break;
 573                   }
 574 #ifdef L2_L3_SPLIT
 575                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
 576                   {
 577                      ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 578                      break;
 579                   }
 580 #else
 581                case KWU_EVT_DAT_REQ:              /* Data request */
 582                   {
 583                      //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 584                      break;
 585                   }
 586 #endif
 587                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
 588                   {
 589                      ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
 590                      break;
 591                   }
 592
 593 #endif  /* LCKWU */
 594                default:
 595                   ODU_PUT_MSG_BUF(mBuf);
 596                   if (pst->dstInst < MAX_RLC_INSTANCES)
 597                   {
 598                      DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from RRC",
 599                             pst->event);
 600                   }
 601                   ret = RFAILED;
 602                   break;
 603
 604             }
 605             break;
 606          }
 607
 608       case ENTPJ:
 609          {
 610             switch(pst->event)
 611             {
 612 #ifdef LCKWU
 613                case KWU_EVT_BND_REQ:              /* Bind request */
 614                   {
 615                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 616                      break;
 617                   }
 618
 619                case KWU_EVT_UBND_REQ:             /* Unbind request */
 620                   {
 621                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 622                      break;
 623                   }
 624 #ifdef L2_L3_SPLIT
 625                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
 626                case KWU_EVT_UPLANE_DAT_REQ:       /* U-Plane Data request */
 627                   {
 628                      ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 629                      break;
 630                   }
 631 #else
 632                case KWU_EVT_DAT_REQ:              /* Data request */
 633                   {
 634                      //ret = cmUnpkKwuDatReq(rlcProcDlData, pst, mBuf);
 635                      break;
 636                   }
 637 #endif
 638                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
 639                   {
 640                      ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
 641                      break;
 642                   }
 643
 644                default:
 645                   ODU_PUT_MSG_BUF(mBuf);
 646                   if (pst->dstInst < MAX_RLC_INSTANCES)
 647                   {
 648                      DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from PDCP",
 649                             pst->event);
 650                   }
 651                   ret = RFAILED;
 652                   break;
 653 #endif  /* LCKWU */
 654             }
 655             break;
 656          }
 657
 658       case ENTMAC:
 659          {
 660             switch(pst->event)
 661             {
 662 #ifdef LCRGU
 663                case EVTRGUBNDCFM:     /* Bind request */
 664                   {
 665                      ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
 666                      break;
 667                   }
 668                case EVENT_SCHED_RESULT_TO_RLC:
 669                   {
 670                      ret = unpackSchedResultRpt(RlcProcSchedResultRpt, pst, mBuf);
 671                      break;
 672                   }
 673                   /* kw005.201 added support for L2 Measurement */
 674 #ifdef LTE_L2_MEAS
 675                case EVTRGUHQSTAIND:    /* Harq status indication */
 676                   {
 677                      ret = cmUnpkRguHqStaInd(RlcLiRguHqStaInd, pst, mBuf);
 678                      break;
 679                   }
 680 #endif
 681                case EVTRGUFLOWCNTRLIND:
 682                   {
 683                      ret = cmUnpkRguFlowCntrlInd(RlcLiRguFlowCntrlInd,pst,mBuf);
 684                      break;
 685                   }
 686 #endif  /* LCRGU */
 687 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
 688                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 689                   {
 690                      ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
 691                      break;
 692                   }
 693 #endif
 694
 695                default:
 696                   ODU_PUT_MSG_BUF(mBuf);
 697                   if (pst->dstInst < MAX_RLC_INSTANCES)
 698                   {
 699                       DU_LOG("\nERROR  --> RLC_DL : Received Invalid Event[%d] from MAC",
 700                             pst->event);
 701                   }
 702                   ret = RFAILED;
 703                   break;
 704             }
 705             break;
 706          }
 707 #ifdef SS_RBUF
 708       case ENTLWRMAC:
 709       {
 710             switch(pst->event)
 711             {
 712                case EVTCTFBTCHPROCTICK:
 713                {
 714                   rlcUtlDlBatchProcPkts();
 715                   break;
 716                }
 717              }
 718          ODU_PUT_MSG_BUF(mBuf);
 719          break;
 720       }
 721 #endif
 722       case ENTYS:
 723          {
 724             switch(pst->event)
 725             {
 726                case KWU_EVT_TTI_IND:
 727                   {
 728 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
 729                      rlcDlBatchProcSplit();
 730 #else
 731 #if defined(PDCP_RLC_DL_RBUF)
 732                      rlcDlBatchProc();
 733 #endif
 734 #endif
 735
 736 #if (defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
 737                      //RlcDlHarqStaBatchProc();
 738                      rlcUtlDlBatchProcHqStaInd();
 739 #endif
 740 #ifndef KWSELFPSTDLCLEAN
 741                      /* Revanth_chg */
 742                      /* Moving Cleanup from self post event to TTI event */
 743                      rlcUtlFreeDlMem();
 744 #endif
 745
 746                      ODU_PUT_MSG_BUF(mBuf);
 747                      break;
 748                   }
 749             }
 750             break;
 751          }
 752
 753
 754       default:
 755          {
 756             if (pst->dstInst < MAX_RLC_INSTANCES)
 757             {
 758                /*RlcCb *tRlcCb = RLC_GET_RLCCB(pst->dstInst);*/
 759                DU_LOG("\nERROR  --> RLC_DL : Received Invalid Source Entity[%d]",
 760                      pst->event);
 761             }
 762             ODU_PUT_MSG_BUF(mBuf);
 763             ret = RFAILED;
 764             break;
 765          }
 766     }
 767    ODU_EXIT_TASK();
 768
 769    return (ret);
 770 } /* kwActvTsk */
 771
 772
 773 \f
 774 /********************************************************************30**
 775          End of file
 776 **********************************************************************/