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