src/5gnrrlc/kw_dl_ex_ms.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:    LTE-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 LTE-RLC
  27
  28         File:    kw_dl_ex_ms.c
  29
  30 *********************************************************************21*/
  31 static const char* RLOG_MODULE_NAME="RLC_DL";
  32 static int RLOG_MODULE_ID=2048;
  33 static int RLOG_FILE_ID=195;
  34
  35 /** @filekw_dl_ex_ms.c
  36 @brief RLC System Services Interface
  37 */
  38
  39 \f
  40 /* header (.h) include files */
  41 #include "common_def.h"
  42 #include "lkw.h"           /* LKW defines */
  43 #include "ckw.h"           /* CKW defines */
  44 #include "kwu.h"           /* KWU defines */
  45 #include "rgu.h"           /* RGU defines */
  46 #include "kw_err.h"        /* Err defines */
  47 #include "kw_env.h"        /* RLC environment options */
  48 #include "kw.h"            /* RLC defines */
  49 #include "kw_udx.h"
  50 #include "kw_dl.h"
  51
  52
  53 /* extern (.x) include files */
  54 #include "lkw.x"           /* LKW */
  55 #include "ckw.x"           /* CKW */
  56 #include "kwu.x"           /* KWU */
  57 #include "rgu.x"           /* RGU */
  58 #include "kw.x"
  59 #include "kw_udx.x"
  60 #include "kw_dl.x"
  61 #include "du_app_rlc_inf.h"
  62
  63 #include "ctf.h"
  64 S16 rlcUtlDlBatchProcPkts(Void);
  65 S16 rlcDlBatchProc(Void);
  66 #if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
  67 U32 isDatReqProcessed;
  68 void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
  69 #endif
  70
  71 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
  72 EXTERN S16 rlcDlBatchProcSplit  ARGS((Void));
  73 #endif
  74 //UDAY
  75 #ifdef L2_OPTMZ
  76 U32 rlcAmmStaPduList[512] = {0};
  77 EXTERN S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
  78 #endif
  79 S16 rlcDlInitExt ARGS (( Void ));
  80 \f
  81 /**
  82  *
  83  * @brief
  84  *
  85  *  <b> Initialize External </b>
  86  *
  87  *  @b Description:
  88  *  Initializes variables used to interface with Upper/Lower Layer
  89  *
  90  *  @return  S16
  91  *      -# ROK
  92  *
  93 */
  94
  95 #ifdef ANSI
  96 S16 rlcDlInitExt
  97 (
  98 )
  99 #else
 100 S16 rlcDlInitExt()
 101 #endif
 102 {
 103    TRC2(rlcDlInitExt);
 104
 105    return ROK;
 106 } /* kwInitExt */
 107
 108
 109 \f
 110 /***********************************************************************
 111                       System Service Interface Functions
 112  ***********************************************************************/
 113 /**
 114  *
 115  * @brief
 116  *
 117  *    <b> Activates Initialization </b>
 118  *
 119  *    @b Description:
 120  *    This function is invoked by system services to initialize the LTE-RLC
 121  *    layer. This is an entry point used by LTE_RLC layer to initialize its
 122  *    global variables, before becoming operational.
 123  *
 124  *    Allowable values for parameters are specified in ssi.h.
 125  *
 126  *    @param[in] ent    - Specify the entity id of the LTE-RLC task.
 127  *    @param[in] inst   - Specify the entity id of the LTE-RLC task.
 128  *    @param[in] region - Specifies the memory region from which
 129  *                         LTE-RLC should allocate structures and buffers.
 130  *    @param[in] reason - Specifies the reason for calling this
 131  *                         initialization function.
 132  *
 133  *  @return  S16
 134  *      -# ROK
 135  *
 136  */
 137 #ifdef ANSI
 138 S16 rlcDlActvInit
 139 (
 140 Ent    ent,                 /* entity */
 141 Inst   inst,                /* instance */
 142 Region region,              /* region */
 143 Reason reason               /* reason */
 144 )
 145 #else
 146 S16 rlcDlActvInit(ent, inst, region, reason)
 147 Ent    ent;                 /* entity */
 148 Inst   inst;                /* instance */
 149 Region region;              /* region */
 150 Reason reason;              /* reason */
 151 #endif
 152 {
 153    RlcCb    *tRlcCb;
 154    TRC3(rlcDlActvInit)
 155
 156    if (inst >= MAX_RLC_INSTANCES)
 157    {
 158        /* intance greater than MAX instances */
 159        return RFAILED;
 160    }
 161
 162    if (rlcCb[inst] != NULLP)
 163    {
 164        return  (RFAILED);
 165    }
 166
 167    if (SGetSBuf(region, 0, (Data **)&tRlcCb,
 168                 (Size)sizeof (RlcCb)) != ROK)
 169    {
 170       return RFAILED;
 171    }
 172    /* Initialize rlcCb */
 173    RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
 174
 175    /* Initialize task configuration parameters */
 176    tRlcCb->init.ent     = ent;           /* entity */
 177    tRlcCb->init.inst    = inst;          /* instance */
 178    tRlcCb->init.region  = region;        /* static region */
 179    tRlcCb->init.pool    = 0;             /* static pool */
 180    tRlcCb->init.reason  = reason;        /* reason */
 181    tRlcCb->init.cfgDone = FALSE;         /* configuration done */
 182    tRlcCb->init.acnt    = TRUE;          /* enable accounting */
 183    tRlcCb->init.usta    = TRUE;          /* enable unsolicited status */
 184    tRlcCb->init.trc     = FALSE;         /* enable trace */
 185    tRlcCb->init.procId  = SFndProcId();
 186
 187    rlcCb[inst] = tRlcCb;
 188
 189 //UDAY
 190 #ifdef L2_OPTMZ
 191    for(int i = 0; i < 512; i++)
 192    {
 193       Buffer *mBuf = NULL;
 194       Buffer *bufPtr = NULL;
 195       SGetMsg(1, 0 , &mBuf);
 196       ssGetDBufOfSize(1 , 1800, &bufPtr);
 197       SUpdMsg(mBuf, bufPtr, 0);
 198       rlcAmmStaPduList[i] = (U32)mBuf;
 199    }
 200 #endif
 201    /* call external function for intialization */
 202    /*
 203    kwInitExt();
 204    */
 205
 206
 207
 208    return ROK;
 209 } /* kwActvInit */
 210
 211 \f
 212 /**
 213  *
 214  * @brief
 215  *
 216  *  <b> Activation Task </b>
 217  *
 218  *  @b Description:
 219  *  Processes events received for MLTE-RLC layer via System Services from
 220  *  other layers.
 221  *
 222  *  @param[in] pst   - Pst Structure
 223  *  @param[in] mBuf  - Message Buffer
 224  *
 225  *  @return  S16
 226  *      -# ROK
 227  *
 228  */
 229 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
 230 pthread_t gRlcTId = 0;
 231 #endif
 232 #ifdef ANSI
 233 S16 rlcDlActvTsk
 234 (
 235 Pst *pst,              /* pst structure */
 236 Buffer *mBuf            /* message buffer */
 237 )
 238 #else
 239 S16 rlcDlActvTsk(pst, mBuf)
 240 Pst *pst;              /* pst structure */
 241 Buffer *mBuf;           /* message buffer */
 242 #endif
 243 {
 244    S16 ret = ROK;
 245
 246    TRC3(rlcDlActvTsk);
 247 #ifdef RLC_FREE_RING_BUF
 248    gRlcTId = pthread_self();
 249 #endif
 250
 251    switch(pst->srcEnt)
 252    {
 253       case ENTDUAPP:
 254          {
 255             switch(pst->event)
 256             {
 257 #ifdef LCLKW
 258                case LKW_EVT_CFG_REQ:
 259                   {
 260                      ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
 261                      break;
 262                   }
 263
 264                case LKW_EVT_CNTRL_REQ:
 265                   {
 266                      ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
 267                      break;
 268                   }
 269
 270                case LKW_EVT_STS_REQ:
 271                   {
 272                      ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
 273                      break;
 274                   }
 275
 276                case LKW_EVT_STA_REQ:
 277                   {
 278                      ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
 279                      break;
 280                   }
 281                   /* kw005.201 added support for L2 Measurement */
 282 #endif  /* LCLKW */
 283
 284 #ifdef LCKWU
 285                case KWU_EVT_DAT_REQ:              /* Data request */
 286                   {
 287                      ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
 288                      break;
 289                   }
 290 #endif /* LCKWU */
 291
 292                case EVENT_DL_RRC_MSG_TRANS_TO_RLC:
 293                   {
 294                      ret = unpackDlRrcMsgToRlc(RlcProcDlRrcMsgTransfer, pst, mBuf);
 295                      break;
 296                   }
 297                default:
 298                   ODU_PUT_MSG_BUF(mBuf);
 299                   if (pst->dstInst < MAX_RLC_INSTANCES)
 300                   {
 301                       RLOG1(L_ERROR,"Received Invalid Event[%d] from SM",
 302                             pst->event);
 303                   }
 304                   ret = RFAILED;
 305                   break;
 306
 307             }
 308             break;
 309          }
 310
 311       case ENTRLC:
 312          {
 313
 314             switch(pst->event)
 315             {
 316 #ifdef LCUDX
 317                case UDX_EVT_BND_REQ:              /* Bind request */
 318                   {
 319                      ret = cmUnpkUdxBndReq(rlcDlUdxBndReq, pst, mBuf );
 320                      break;
 321                   }
 322
 323                case UDX_EVT_UBND_REQ:              /* Bind request */
 324                   {
 325                      ret = cmUnpkUdxUbndReq(rlcDlUdxUbndReq, pst, mBuf );
 326                      break;
 327                   }
 328                case UDX_EVT_CFG_REQ:             /* Unbind request */
 329                   {
 330                      ret = cmUnpkUdxCfgReq(rlcDlUdxCfgReq, pst, mBuf );
 331                      break;
 332                   }
 333
 334                case UDX_EVT_UEIDCHG_REQ:              /* Configuration request */
 335                   {
 336                      ret = cmUnpkUdxUeIdChgReq(rlcDlUdxUeIdChgReq, pst, mBuf);
 337                      break;
 338                   }
 339
 340                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 341                   {
 342                      ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
 343                      break;
 344                   }
 345
 346                case UDX_EVT_STA_PDU_REQ:              /* Configuration request */
 347                   {
 348                      ret = cmUnpkUdxStaPduReq(rlcDlUdxStaPduReq, pst, mBuf);
 349                      break;
 350                   }
 351
 352 #ifdef LTE_L2_MEAS
 353                case UDX_EVT_L2MEAS_REQ:
 354                   {
 355                      ret = cmUnpkUdxL2MeasReq(rlcDlUdxL2MeasReq, pst, mBuf);
 356                      break;
 357                   }
 358                case UDX_EVT_L2MEAS_SEND_REQ:
 359                  {
 360
 361                     ret = cmUnpkUdxL2MeasSendReq(rlcDlUdxL2MeasSendReq, pst, mBuf);
 362
 363                      break;
 364                  }
 365                case UDX_EVT_L2MEAS_STOP_REQ:
 366                  {
 367                      ret = cmUnpkUdxL2MeasStopReq(rlcDlUdxL2MeasStopReq, pst, mBuf);
 368                      break;
 369                  }
 370 #endif
 371
 372 #endif  /* LCCKW */
 373                case UDX_EVT_DL_CLEANUP_MEM:
 374                   {
 375                      rlcUtlFreeDlMemory(RLC_GET_RLCCB(pst->dstInst));
 376                      break;
 377                   }
 378
 379                default:
 380                   ODU_PUT_MSG_BUF(mBuf);
 381                   if (pst->dstInst < MAX_RLC_INSTANCES)
 382                   {
 383                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
 384                             pst->event);
 385                   }
 386                   ret = RFAILED;
 387                   break;
 388
 389             }
 390             break;
 391          }
 392
 393       case ENTNH:
 394          {
 395             switch(pst->event)
 396             {
 397 #ifdef LCKWU
 398                case KWU_EVT_BND_REQ:              /* Bind request */
 399                   {
 400                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 401                      break;
 402                   }
 403
 404                case KWU_EVT_UBND_REQ:             /* Unbind request */
 405                   {
 406                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 407                      break;
 408                   }
 409 #ifdef L2_L3_SPLIT
 410                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
 411                   {
 412                      ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
 413                      break;
 414                   }
 415 #else
 416                case KWU_EVT_DAT_REQ:              /* Data request */
 417                   {
 418                      ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
 419                      break;
 420                   }
 421 #endif
 422                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
 423                   {
 424                      ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
 425                      break;
 426                   }
 427
 428 #endif  /* LCKWU */
 429                default:
 430                   ODU_PUT_MSG_BUF(mBuf);
 431                   if (pst->dstInst < MAX_RLC_INSTANCES)
 432                   {
 433                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
 434                             pst->event);
 435                   }
 436                   ret = RFAILED;
 437                   break;
 438
 439             }
 440             break;
 441          }
 442
 443       case ENTPJ:
 444          {
 445             switch(pst->event)
 446             {
 447 #ifdef LCKWU
 448                case KWU_EVT_BND_REQ:              /* Bind request */
 449                   {
 450                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 451                      break;
 452                   }
 453
 454                case KWU_EVT_UBND_REQ:             /* Unbind request */
 455                   {
 456                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 457                      break;
 458                   }
 459 #ifdef L2_L3_SPLIT
 460                case KWU_EVT_CPLANE_DAT_REQ:       /* C-Plane Data request */
 461                case KWU_EVT_UPLANE_DAT_REQ:       /* U-Plane Data request */
 462                   {
 463                      ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
 464                      break;
 465                   }
 466 #else
 467                case KWU_EVT_DAT_REQ:              /* Data request */
 468                   {
 469                      ret = cmUnpkKwuDatReq(RlcUiKwuDatReq, pst, mBuf);
 470                      break;
 471                   }
 472 #endif
 473                case KWU_EVT_DISC_SDU_REQ:         /* Discard SDU request */
 474                   {
 475                      ret = cmUnpkKwuDiscSduReq(RlcUiKwuDiscSduReq, pst, mBuf);
 476                      break;
 477                   }
 478
 479                default:
 480                   ODU_PUT_MSG_BUF(mBuf);
 481                   if (pst->dstInst < MAX_RLC_INSTANCES)
 482                   {
 483                       RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
 484                             pst->event);
 485                   }
 486                   ret = RFAILED;
 487                   break;
 488 #endif  /* LCKWU */
 489             }
 490             break;
 491          }
 492
 493       case ENTMAC:
 494          {
 495             switch(pst->event)
 496             {
 497 #ifdef LCRGU
 498                case EVTRGUBNDCFM:     /* Bind request */
 499                   {
 500                      ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
 501                      break;
 502                   }
 503                case EVTSCHREP:    /* Dedicated Channel Status Response */
 504                   {
 505                      ret = unpackSchedRep(RlcMacProcSchedRep, pst, mBuf);
 506                      break;
 507                   }
 508                   /* kw005.201 added support for L2 Measurement */
 509 #ifdef LTE_L2_MEAS
 510                case EVTRGUHQSTAIND:    /* Harq status indication */
 511                   {
 512                      ret = cmUnpkRguHqStaInd(RlcLiRguHqStaInd, pst, mBuf);
 513                      break;
 514                   }
 515 #endif
 516                case EVTRGUFLOWCNTRLIND:
 517                   {
 518                      ret = cmUnpkRguFlowCntrlInd(RlcLiRguFlowCntrlInd,pst,mBuf);
 519                      break;
 520                   }
 521 #endif  /* LCRGU */
 522 #ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
 523                case UDX_EVT_STA_UPD_REQ:              /* Configuration request */
 524                   {
 525                      ret = cmUnpkUdxStaUpdReq(rlcDlUdxStaUpdReq, pst, mBuf);
 526                      break;
 527                   }
 528 #endif
 529
 530                default:
 531                   ODU_PUT_MSG_BUF(mBuf);
 532                   if (pst->dstInst < MAX_RLC_INSTANCES)
 533                   {
 534                       RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
 535                             pst->event);
 536                   }
 537                   ret = RFAILED;
 538                   break;
 539             }
 540             break;
 541          }
 542 #ifdef SS_RBUF
 543       case ENTLWRMAC:
 544       {
 545             switch(pst->event)
 546             {
 547                case EVTCTFBTCHPROCTICK:
 548                {
 549                   rlcUtlDlBatchProcPkts();
 550                   break;
 551                }
 552              }
 553          ODU_PUT_MSG_BUF(mBuf);
 554          break;
 555       }
 556 #endif
 557       case ENTYS:
 558          {
 559             switch(pst->event)
 560             {
 561                case KWU_EVT_TTI_IND:
 562                   {
 563 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
 564                      rlcDlBatchProcSplit();
 565 #else
 566 #if defined(PDCP_RLC_DL_RBUF)
 567                      rlcDlBatchProc();
 568 #endif
 569 #endif
 570
 571 #if (defined(SPLIT_RLC_DL_TASK) && defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
 572                      //RlcDlHarqStaBatchProc();
 573                      rlcUtlDlBatchProcHqStaInd();
 574 #endif
 575 #ifndef KWSELFPSTDLCLEAN
 576                      /* Revanth_chg */
 577                      /* Moving Cleanup from self post event to TTI event */
 578                      rlcUtlFreeDlMem();
 579 #endif
 580
 581                      ODU_PUT_MSG_BUF(mBuf);
 582                      break;
 583                   }
 584             }
 585             break;
 586          }
 587
 588
 589       default:
 590          {
 591             if (pst->dstInst < MAX_RLC_INSTANCES)
 592             {
 593                /*RlcCb *tRlcCb = RLC_GET_RLCCB(pst->dstInst);*/
 594                RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",
 595                      pst->event);
 596             }
 597             ODU_PUT_MSG_BUF(mBuf);
 598             ret = RFAILED;
 599             break;
 600          }
 601     }
 602    ODU_EXIT_TASK();
 603
 604    return (ret);
 605 } /* kwActvTsk */
 606
 607
 608 \f
 609 /********************************************************************30**
 610          End of file
 611 **********************************************************************/