src/5gnrpdcp/pj_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-PDCP Layer - System Services Interface Functions
  22
  23    Type:    C file
  24
  25    Desc:    C source code for the interface to System Services of LTE-PDCP
  26
  27    File:    pj_dl_ex_ms.c
  28
  29 *********************************************************************21*/
  30
  31 static const char* RLOG_MODULE_NAME="PDCP";
  32 static int RLOG_MODULE_ID=1024;
  33 static int RLOG_FILE_ID=217;
  34 /** @file pj_dl_ex_ms.c
  35   @brief PDCP System Services Interface
  36  */
  37
  38 /* header (.h) include files */
  39 #include "envopt.h"        /* environment options */
  40 #include "envdep.h"        /* environment dependent */
  41 #include "envind.h"        /* environment independent */
  42
  43 #include "gen.h"           /* general */
  44 #include "ssi.h"           /* system services */
  45 #include "cm5.h"           /* common timer defines */
  46 #include "cm_tkns.h"       /* common tokens defines */
  47 #include "cm_mblk.h"       /* common memory allocation library defines */
  48 #include "cm_llist.h"      /* common link list  defines  */
  49 #include "cm_hash.h"       /* common hash list  defines */
  50 #include "cm_lte.h"        /* common LTE defines */
  51 #include "kwu.h"           /* KWU defines */
  52 #include "cpj.h"           /* CPJ defines */
  53 #include "ctf.h"           /* CPJ defines */
  54 #include "pju.h"           /* PJU defines */
  55 #include "lpj.h"           /* LPJ defines */
  56 #include "pj_err.h"        /* Err defines */
  57 #include "pj_env.h"        /* RLC environment options */
  58 #include "pj.h"            /* RLC defines */
  59 #include "pj_udx.h"
  60 #include "pj_dl.h"
  61 #include "pj_lib.h"
  62 #include "pj_ptsec.h"
  63
  64 /* extern (.x) include files */
  65 #include "gen.x"           /* general */
  66 #include "ssi.x"           /* system services */
  67
  68 #include "cm5.x"           /* common timer library */
  69 #include "cm_tkns.x"       /* common tokens */
  70 #include "cm_mblk.x"       /* common memory allocation */
  71 #include "cm_llist.x"      /* common link list */
  72 #include "cm_hash.x"       /* common hash list */
  73 #include "cm_lte.x"        /* common LTE includes */
  74 #include "cm_lib.x"        /* common memory allocation library */
  75 #include "kwu.x"           /* KWU */
  76 #include "cpj.x"           /* CPJ defines */
  77 #include "pju.x"           /* PJU defines */
  78 #include "lpj.x"           /* LPJ defines */
  79 #include "pj.x"
  80 #include "pj_udx.x"
  81 #include "pj_dl.x"
  82 #include "pj_ul.x"
  83 #include "pj_lib.x"
  84 #ifdef SS_RBUF
  85 #include "ss_rbuf.h"
  86 #include "ss_rbuf.x"
  87 PUBLIC S16 pjBatchProcTick(Void);
  88 EXTERN S16 pjRBufFreeMsg(void);
  89 #endif
  90 #ifdef LC_EGTP_THREAD
  91 #include "ss_rbuf.h"
  92 #include "ss_rbuf.x"
  93 EXTERN void egWrReadRingBuf(SsRngBufId ringId);
  94 #endif
  95
  96 PUBLIC U32 ysPjPrcTtiInd = 0;   /* UDAY */
  97
  98 /***********************************************************************
  99   System Service Interface Functions
 100  ***********************************************************************/
 101 /**
 102  *
 103  * @brief
 104  *
 105  *    <b> Activates Initialization </b>
 106  *
 107  *    @b Description:
 108  *    This function is invoked by system services to initialize the LTE-PDCP
 109  *    layer. This is an entry point used by LTE_PDCP layer to initialize its
 110  *    global variables, before becoming operational.
 111  *
 112  *    Allowable values for parameters are specified in ssi.h.
 113  *
 114  *    @param[in] ent    - Specify the entity id of the LTE-RLC task.
 115  *    @param[in] inst   - Specify the entity id of the LTE-RLC task.
 116  *    @param[in] region - Specifies the memory region from which
 117  *                         LTE-PDCP should allocate structures and buffers.
 118  *    @param[in] reason - Specifies the reason for calling this
 119  *                         initialization function.
 120  *
 121  *  @return  S16
 122  *      -# ROK
 123  *
 124  */
 125 #ifdef ANSI
 126 PUBLIC S16 pjDlActvInit
 127 (
 128  Ent    ent,                 /* entity */
 129  Inst   inst,                /* instance */
 130  Region region,              /* region */
 131  Reason reason               /* reason */
 132  )
 133 #else
 134 PUBLIC S16 pjDlActvInit(ent, inst, region, reason)
 135   Ent    ent;                 /* entity */
 136   Inst   inst;                /* instance */
 137   Region region;              /* region */
 138   Reason reason;              /* reason */
 139 #endif
 140 {
 141    PjCb   *tPjCb;
 142    TRC3(pjDlActvInit)
 143    if (inst >= PJ_MAX_PDCP_INSTANCES)
 144    {
 145        /* intance greater than MAX instances */
 146        RETVALUE(RFAILED);
 147    }
 148
 149    if (pjCb[inst] != NULLP)
 150    {
 151       RETVALUE (RFAILED);
 152    }
 153
 154    if (SGetSBuf(region, 0, (Data **)&tPjCb,
 155             (Size)sizeof (PjCb)) != ROK)
 156    {
 157       RETVALUE(RFAILED);
 158    }
 159    /* Initialize kwCb */
 160    PJ_MEM_SET(tPjCb, 0, sizeof(PjCb));
 161
 162    /* Initialize task configuration parameters */
 163    /* We will take only entity name */
 164    tPjCb->init.ent     = ent;           /* entity */
 165    tPjCb->init.inst    = inst;          /* instance */
 166    tPjCb->init.region  = region;        /* static region */
 167    tPjCb->init.pool    = 0;             /* static pool */
 168    tPjCb->init.reason  = reason;        /* reason */
 169    tPjCb->init.cfgDone = FALSE;         /* configuration done */
 170    tPjCb->init.acnt    = TRUE;          /* enable accounting */
 171    tPjCb->init.usta    = TRUE;          /* enable unsolicited status */
 172    tPjCb->init.trc     = FALSE;         /* enable trace */
 173 #ifdef DEBUGP
 174    tPjCb->init.dbgMask = 0x00000000;
 175 #endif
 176    tPjCb->init.procId  = SFndProcId();
 177
 178    pjCb[inst] = tPjCb;
 179
 180   RETVALUE(ROK);
 181 } /* pjActvInit */
 182
 183 \f
 184 /**
 185  *
 186  * @brief
 187  *
 188  *  <b> Activation Task </b>
 189  *
 190  *  @b Description:
 191  *  Processes events received for LTE-PDCP layer via System Services from
 192  *  other layers.
 193  *
 194  *  @param[in] pst   - Pst Structure
 195  *  @param[in] mBuf  - Message Buffer
 196  *
 197  *  @return  S16
 198  *      -# ROK
 199  *
 200  */
 201 #ifdef ANSI
 202 PUBLIC S16 pjDlActvTsk
 203 (
 204 Pst *pst,              /* pst structure */
 205 Buffer *mBuf            /* message buffer */
 206 )
 207 #else
 208 PUBLIC S16 pjDlActvTsk(pst, mBuf)
 209 Pst *pst;              /* pst structure */
 210 Buffer *mBuf;           /* message buffer */
 211 #endif
 212 {
 213    S16 ret = ROK;
 214
 215    TRC3(pjDlActvTsk);
 216
 217    switch(pst->srcEnt)
 218    {
 219       case ENTSM:
 220          {
 221             switch(pst->event)
 222             {
 223 #ifdef LCLPJ
 224                case LPJ_EVT_CFG_REQ:
 225                   {
 226                      ret = cmUnpkLpjCfgReq(PjMiLpjCfgReq, pst, mBuf);
 227                      break;
 228                   }
 229
 230                case LPJ_EVT_CNTRL_REQ:
 231                   {
 232                      ret = cmUnpkLpjCntrlReq(PjMiLpjCntrlReq, pst, mBuf);
 233                      break;
 234                   }
 235
 236                case LPJ_EVT_STS_REQ:
 237                   {
 238                      ret = cmUnpkLpjStsReq(PjMiLpjStsReq, pst, mBuf);
 239                      break;
 240                   }
 241
 242                case LPJ_EVT_STA_REQ:
 243                   {
 244                      ret = cmUnpkLpjStaReq(PjMiLpjStaReq, pst, mBuf);
 245                      break;
 246                   }
 247                   /* kw005.201 added support for L2 Measurement */
 248
 249                default:
 250                   {
 251                      RLOG0(L_ERROR, "Received Invalid Event from SM");
 252                      ret = RFAILED;
 253                      break;
 254                   }
 255 #endif  /* LCLPJ */
 256             }
 257             break;
 258          }
 259
 260       case ENTPJ:
 261          {
 262             switch(pst->event)
 263             {
 264 #ifdef LCUDX
 265             case EVTUDXBNDREQ:
 266                   {
 267                      cmUnpkPjUdxBndReq(PjDlUdxBndReq, pst, mBuf);
 268                      break;
 269                   }
 270
 271             case EVTUDXUBNDREQ:
 272                   {
 273                      cmUnpkPjUdxUbndReq(PjDlUdxUbndReq, pst, mBuf);
 274                      break;
 275                   }
 276
 277             case EVTUDXCFGREQ:
 278                   {
 279                      cmUnpkPjUdxCfgReq(PjDlUdxCfgReq, pst, mBuf);
 280                      break;
 281                   }
 282
 283             case EVTUDXULSTAREP:
 284                   {
 285                      cmUnpkPjUdxUlStaRep(PjDlUdxUlStaRep, pst, mBuf);
 286                      break;
 287                   }
 288
 289             case EVTUDXDLSTAREP:
 290                   {
 291                      cmUnpkPjUdxDlStaRep(PjDlUdxDlStaRep, pst, mBuf);
 292                      break;
 293                   }
 294
 295             case EVTUDXULROHCFDB:
 296                   {
 297                       cmUnpkPjUdxUlFdbkPkt(PjDlUdxUlFdbkPktInfo, pst, mBuf);
 298                       break;
 299                   }
 300
 301             case EVTUDXDLROHCFDB:
 302                   {
 303                       cmUnpkPjUdxDlFdbkPkt(PjDlUdxDlFdbkPktInfo, pst, mBuf);
 304                       break;
 305                   }
 306
 307             case EVTUDXREESTREQ:
 308                   {
 309                      cmUnpkPjUdxReEstReq(PjDlUdxReEstReq, pst, mBuf);
 310                      break;
 311                   }
 312
 313             case EVTUDXSECCFGREQ:
 314                   {
 315                      cmUnpkPjUdxSecCfgReq(PjDlUdxSecCfgReq, pst, mBuf);
 316                      break;
 317                   }
 318
 319             case EVTUDXUEIDCHGREQ:
 320                   {
 321                      cmUnpkPjUdxUeIdChgReq(PjDlUdxUeIdChgReq, pst, mBuf);
 322                      break;
 323                   }
 324
 325             case EVTUDXCOUNTREQ:
 326                   {
 327                      cmUnpkPjUdxCountReq(PjDlUdxCountReq, pst, mBuf);
 328                      break;
 329                   }
 330
 331             case EVTUDXSDUSTAREQ:
 332                   {
 333                      cmUnpkPjUdxSduStaReq(PjDlUdxSduStaReq, pst, mBuf);
 334                      break;
 335                   }
 336              case EVTUDXDATRESUME:
 337                   {
 338 #ifdef FLAT_BUFFER_OPT
 339                        cmUnpkPjUdxDatResumeReq(PjDlUdxDatResumeReq, pst, mBuf);
 340 #else
 341                        cmUnpkPjUdxDatResumeReq(PjDlUdxDatResumeReq, pst, mBuf);
 342 #endif
 343                        break;
 344                   }
 345              case EVTUDXDATFRWD:
 346                   {
 347 #ifdef FLAT_BUFFER_OPT
 348                      printf("Received Event EVTUDXDATFRWD at PDCP DL \n");
 349                      cmUnpkPjUdxDatForwardReq(PjDlUdxDatForwardReqFB, pst, mBuf);
 350 #else
 351                      cmUnpkPjUdxDatForwardReq(PjDlUdxDatForwardReq, pst, mBuf);
 352 #endif
 353                      break;
 354                   }
 355 #ifdef LTE_L2_MEAS
 356                case PJ_UDX_EVT_L2MEAS_REQ:
 357                   {
 358                      ret = cmUnpkPjUdxL2MeasReq(PjDlUdxL2MeasReq, pst, mBuf);
 359                      break;
 360                   }
 361                case PJ_UDX_EVT_L2MEAS_SEND_REQ:
 362                  {
 363
 364                     ret = cmUnpkPjUdxL2MeasSendReq(PjDlUdxL2MeasSendReq, pst, mBuf);
 365
 366                      break;
 367                  }
 368                case PJ_UDX_EVT_L2MEAS_STOP_REQ:
 369                  {
 370                      ret = cmUnpkPjUdxL2MeasStopReq(PjDlUdxL2MeasStopReq, pst, mBuf);
 371                      break;
 372                  }
 373 #endif
 374                default:
 375                   {
 376                      RLOG0(L_ERROR, "Received Invalid Event from PDCP UL");
 377                      ret = RFAILED;
 378                      break;
 379                   }
 380 #endif  /* LCLPJ */
 381             }
 382             break;
 383          }
 384
 385
 386       case ENTNH:
 387          {
 388             switch(pst->event)
 389             {
 390 #ifdef LCPJU
 391                case EVTPJUBNDREQ:
 392                   {
 393                      cmUnpkPjuBndReq(PjUiPjuBndReq, pst, mBuf);
 394                      break;
 395                   }
 396
 397                case EVTPJUUBNDREQ:
 398                   {
 399                      cmUnpkPjuUbndReq(PjUiPjuUbndReq, pst, mBuf);
 400                      break;
 401                   }
 402
 403                case EVTPJUDATREQ:
 404                   {
 405                      cmUnpkPjuDatReq(PjUiPjuDatReq, pst, mBuf);
 406                      break;
 407                   }
 408
 409                case EVTPJUDATFWDREQ:
 410                   {
 411                      cmUnpkPjuDatFwdReq(PjUiPjuDatFwdReq, pst, mBuf);
 412                      break;
 413                   }
 414 #endif /* LCPJU */
 415                default:
 416                   SPutMsg(mBuf);
 417                   RLOG0(L_ERROR, " Received Invalid Event From RRC");
 418                   ret = RFAILED;
 419                   break;
 420
 421             }
 422             break;
 423          }
 424
 425       case ENTPX:
 426          {
 427             switch(pst->event)
 428             {
 429 #ifdef LCPJU
 430                case EVTPJUBNDREQ:
 431                   {
 432                      cmUnpkPjuBndReq(PjUiPjuBndReq, pst, mBuf);
 433                      break;
 434                   }
 435
 436                case EVTPJUUBNDREQ:
 437                   {
 438                      cmUnpkPjuUbndReq(PjUiPjuUbndReq, pst, mBuf);
 439                      break;
 440                   }
 441
 442                case EVTPJUDATREQ:
 443                   {
 444 #ifdef SS_RBUF
 445                      cmUnpkFpPjuDatReq(PjUiPjuDatReq, pst, mBuf);
 446 #else
 447                      cmUnpkPjuDatReq(PjUiPjuDatReq, pst, mBuf);
 448 #endif
 449                      break;
 450                   }
 451
 452                case EVTPJUDATFWDREQ:
 453                   {
 454                      cmUnpkPjuDatFwdReq(PjUiPjuDatFwdReq, pst, mBuf);
 455                      break;
 456                   }
 457 #endif
 458 #ifdef PCAP_IP_DATGEN_LOAD_5GTF
 459                case EVTPCAPIPDATIND:
 460                   {
 461                      //printf("ENTPX!!!!EVTPCAPIPDATIND:\n\r ");
 462                      //RLOG0(L_ERROR, " Received Invalid Event from Relay");
 463                      wrDamPcapDatInd(mBuf);
 464                      break;
 465                   }
 466 #endif
 467                default:
 468                   SPutMsg(mBuf);
 469                   RLOG0(L_ERROR, " Received Invalid Event from Relay");
 470                   ret = RFAILED;
 471                   break;
 472             }
 473             break;
 474          }
 475
 476       case ENTOC:
 477          {
 478             switch(pst->event)
 479             {
 480 #ifdef PJ_CMP_ASYNC
 481                /* Compression Confirmations */
 482                case OBD_EVT_CMP_INIT_CFM:
 483                   ret = cmUnpkLibObdCmpInitCfm(PjLibObdCmpInitCfm, pst,mBuf);
 484                   break;
 485
 486                case OBD_EVT_CMP_CFM:
 487                   ret = cmUnpkLibObdCmpCfm(PjLibObdCmpCfm, pst, mBuf);
 488                   break;
 489
 490 #endif /* PJ_CMP_ASYNC */
 491                default:
 492                   SPutMsg(mBuf);
 493                   RLOG0(L_ERROR, "Received Invalid Event from Offboard Ciphering");
 494                   ret = RFAILED;
 495                   break;
 496             }
 497             break;
 498          }
 499
 500       case ENTOS:
 501          {
 502             switch(pst->event)
 503             {
 504 #ifdef PJ_SEC_ASYNC
 505                   /* Integrity Confirmations */
 506                case OBD_EVT_INT_INIT_CFM:
 507                   ret = cmUnpkLibObdIntInitCfm(PjLibObdIntInitCfm, pst, mBuf);
 508                   break;
 509
 510                case OBD_EVT_INT_PROT_CFM:
 511                   ret = cmUnpkLibObdIntProtCfm(PjLibObdIntProtCfm, pst, mBuf);
 512                   break;
 513
 514                   /* Ciphering Confirmations */
 515                case OBD_EVT_CP_INIT_CFM:
 516                   ret = cmUnpkLibObdCpInitCfm(PjLibObdCpInitCfm, pst, mBuf);
 517                   break;
 518
 519                case OBD_EVT_UP_INIT_CFM:
 520                   ret = cmUnpkLibObdUpInitCfm(PjLibObdUpInitCfm, pst, mBuf);
 521                   break;
 522
 523                case OBD_EVT_CIPHER_CFM:
 524                   ret = cmUnpkLibObdCipherCfm(PjLibObdCipherCfm, pst, mBuf);
 525                   break;
 526
 527 #endif /* PJ_SEC_ASYNC */
 528                default:
 529                   SPutMsg(mBuf);
 530                   RLOG0(L_ERROR, "Received Invalid Event from Offboard Security");
 531                   ret = RFAILED;
 532                   break;
 533             }
 534             break;
 535          }
 536       case ENTKW:
 537          {
 538             switch(pst->event)
 539             {
 540 #ifdef LCKWU
 541                case KWU_EVT_BND_CFM:     /* Bind request */
 542                   {
 543                      ret = cmUnpkKwuBndCfm(PjLiKwuBndCfm, pst, mBuf );
 544                      break;
 545                   }
 546
 547                 case KWU_EVT_DAT_CFM:    /* Dedicated Channel Data request */
 548                   {
 549                      ret = cmUnpkKwuDatCfm(PjLiKwuDatCfm, pst, mBuf);
 550                      break;
 551                   }
 552
 553                case KWU_EVT_DISC_SDU_REQ:    /* Coomon Channel Status Response */
 554                   {
 555                      ret = cmUnpkKwuDiscSduReq(PjLiKwuDiscSduReq, pst , mBuf);
 556                      break;
 557                   }
 558
 559                case KWU_EVT_STA_IND:    /* Dedicated Channel Status Response */
 560                   {
 561                      ret = cmUnpkKwuStaInd(PjLiKwuStaInd, pst, mBuf);
 562                      break;
 563                   }
 564                case KWU_EVT_DISC_SDU_CFM:    /* Harq status indication */
 565                   {
 566                      ret = cmUnpkKwuDiscSduCfm(PjLiKwuDiscSduCfm, pst, mBuf);
 567                      break;
 568                   }
 569                case KWU_EVT_FLOW_CNTRL_IND:    /* Flow control indication*/
 570                   {
 571                      ret = cmUnpkKwuFlowCntrlInd(PjLiKwuFlowCntrlInd, pst, mBuf);
 572                      break;
 573                   }
 574                default:
 575                   {
 576                      SPutMsg(mBuf);
 577                      RLOG0(L_ERROR, "Received Invalid Event from RLC");
 578                      ret = RFAILED;
 579                      break;
 580                    }
 581
 582 #endif  /* LCRGU */
 583             }
 584             break;
 585          }
 586 #ifdef TENB_AS_SECURITY
 587       case ENTYS:
 588          {
 589             switch(pst->event)
 590             {
 591                case EVTPJUTTIIND:
 592                {
 593 #ifndef SS_RBUF
 594                   static U32 ttitick = 0;
 595 #endif
 596
 597                   ysPjPrcTtiInd++; /* UDAY */
 598                   SPutMsg(mBuf);
 599                   /*Trigger batching of the packets queued for ciphering
 600                    * and deciphering*/
 601                   /*Note: UL trigger should be posted to UL thread if UL
 602                    * and DL are on different threads.*/
 603 #ifndef L2_L3_SPLIT
 604 #ifdef MAC_RLC_UL_RBUF
 605                         kwUlBatchProc();
 606 #endif
 607 #endif
 608 #ifdef XEON_SPECIFIC_CHANGES
 609 #ifdef INTEL_QAT_DP
 610                         PjCb  *tPjCb = PJ_GET_PJCB(pst->dstInst);
 611                         pjPollQatDat(tPjCb,ttitick);
 612 #endif /* INTEL_QAT_DP */
 613 #else
 614 #ifndef SS_RBUF
 615                   pjProcessSpaccRdWr(ttitick);
 616 #endif
 617 #endif
 618 #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF))
 619 #ifndef UL_RLC_NET_CLUSTER
 620                   pjUlBatchProcSplit();
 621 #endif
 622 #endif
 623 #ifndef SS_RBUF
 624                   ttitick++;
 625 #endif
 626 #ifdef LC_EGTP_THREAD
 627                   egWrReadRingBuf(SS_RNG_BUF_EGTP_FREE_RING);
 628 #endif
 629                   break;
 630                }
 631             }
 632             break;
 633          }
 634 #endif
 635 #ifdef SS_RBUF
 636       case ENTTF:
 637       {
 638             switch(pst->event)
 639             {
 640                case EVTCTFBTCHPROCTICK:
 641                {
 642                   pjBatchProcTick();
 643                   break;
 644                }
 645                case EVTCTFNRTRBUFCLEAN:
 646                {
 647                   pjRBufFreeMsg();
 648                }
 649              }
 650          SPutMsg(mBuf);
 651          break;
 652       }
 653 #endif
 654       default:
 655          {
 656             RLOG0(L_ERROR, "Recieved Invalid Source Entity ");
 657             SPutMsg(mBuf);
 658             ret = RFAILED;
 659             break;
 660          }
 661    }
 662
 663    SExitTsk();
 664
 665    RETVALUE(ret);
 666 } /* pjActvTsk */
 667
 668 \f
 669 /********************************************************************30**
 670          End of file
 671 **********************************************************************/