src/5gnrrlc/kw_ul_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_ul_ex_ms.c
  29
  30 *********************************************************************21*/
  31 static const char* RLOG_MODULE_NAME="RLC_UL";
  32 static int RLOG_MODULE_ID=2048;
  33 static int RLOG_FILE_ID=206;
  34
  35 /** @file kw_ul_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_ul.h"
  50 #include "kw_udx.h"
  51
  52 /* extern (.x) include files */
  53 #include "lkw.x"           /* LKW */
  54 #include "ckw.x"           /* CKW */
  55 #include "kwu.x"           /* KWU */
  56 #include "rgu.x"           /* RGU */
  57 #include "kw.x"
  58 #include "kw_ul.x"
  59 #include "kw_udx.x"
  60
  61 #include "rlc_mac_inf.h"
  62 #include "du_app_rlc_inf.h"
  63
  64 #ifdef TENB_STATS
  65 #include "l2_tenb_stats.x"
  66 #endif
  67
  68 S16 rlcUlInitExt ARGS (( Void ));
  69 \f
  70 /**
  71  *
  72  * @brief
  73  *
  74  *  <b> Initialize External </b>
  75  *
  76  *  @b Description:
  77  *  Initializes variables used to interface with Upper/Lower Layer
  78  *
  79  *  @return  S16
  80  *      -# ROK
  81  *
  82 */
  83
  84 #ifdef ANSI
  85 S16 rlcUlInitExt
  86 (
  87 )
  88 #else
  89 S16 rlcUlInitExt()
  90 #endif
  91 {
  92
  93    return ROK;
  94 } /* kwInitExt */
  95
  96
  97 \f
  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-RLC
 109  *    layer. This is an entry point used by LTE_RLC 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-RLC 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 S16 rlcUlActvInit
 127 (
 128 Ent    ent,                 /* entity */
 129 Inst   inst,                /* instance */
 130 Region region,              /* region */
 131 Reason reason               /* reason */
 132 )
 133 #else
 134 S16 rlcUlActvInit(ent, inst, region, reason)
 135 Ent    ent;                 /* entity */
 136 Inst   inst;                /* instance */
 137 Region region;              /* region */
 138 Reason reason;              /* reason */
 139 #endif
 140 {
 141    RlcCb    *tRlcCb;
 142
 143    if (inst >= MAX_RLC_INSTANCES)
 144    {
 145        /* intance greater than MAX instances */
 146        return RFAILED;
 147    }
 148
 149    if (rlcCb[inst] != NULLP)
 150    {
 151        return  (RFAILED);
 152    }
 153
 154    if (SGetSBuf(region, 0, (Data **)&tRlcCb,
 155                 (Size)sizeof (RlcCb)) != ROK)
 156    {
 157       return RFAILED;
 158    }
 159
 160    /* Initialize rlcCb */
 161    RLC_MEM_SET(tRlcCb, 0, sizeof(RlcCb));
 162
 163    /* Initialize task configuration parameters */
 164    tRlcCb->init.ent     = ent;           /* entity */
 165    tRlcCb->init.inst    = inst;          /* instance */
 166    tRlcCb->init.region  = region;        /* static region */
 167    tRlcCb->init.pool    = 0;             /* static pool */
 168    tRlcCb->init.reason  = reason;        /* reason */
 169    tRlcCb->init.cfgDone = FALSE;         /* configuration done */
 170    tRlcCb->init.acnt    = TRUE;          /* enable accounting */
 171    tRlcCb->init.usta    = TRUE;          /* enable unsolicited status */
 172    tRlcCb->init.trc     = FALSE;         /* enable trace */
 173    tRlcCb->init.procId  = ODU_GET_PROCID();
 174
 175    rlcCb[inst] = tRlcCb;
 176
 177    /* call external function for intialization */
 178    /*
 179    kwInitExt();
 180    */
 181 #ifdef TENB_STATS
 182    TSL2AllocStatsMem(tRlcCb->init.region, tRlcCb->init.pool);
 183 #endif
 184
 185    return ROK;
 186 } /* rlcUlActvInit */
 187
 188 \f
 189 /**
 190  *
 191  * @brief
 192  *
 193  *  <b> Activation Task </b>
 194  *
 195  *  @b Description:
 196  *  Processes events received for MLTE-RLC layer via System Services from
 197  *  other layers.
 198  *
 199  *  @param[in] pst   - Pst Structure
 200  *  @param[in] mBuf  - Message Buffer
 201  *
 202  *  @return  S16
 203  *      -# ROK
 204  *
 205  */
 206 #ifdef ANSI
 207 S16 rlcUlActvTsk
 208 (
 209 Pst *pst,              /* pst structure */
 210 Buffer *mBuf            /* message buffer */
 211 )
 212 #else
 213 S16 rlcUlActvTsk(pst, mBuf)
 214 Pst *pst;              /* pst structure */
 215 Buffer *mBuf;           /* message buffer */
 216 #endif
 217 {
 218    S16 ret = ROK;
 219
 220
 221    switch(pst->srcEnt)
 222    {
 223       case ENTDUAPP:
 224          {
 225             switch(pst->event)
 226             {
 227 #ifdef LCLKW
 228                case LKW_EVT_CFG_REQ:
 229                   {
 230                      ret = unpackRlcConfigReq(RlcMiRlcConfigReq, pst, mBuf);
 231                      break;
 232                   }
 233
 234                case LKW_EVT_CNTRL_REQ:
 235                   {
 236                      ret = cmUnpkLkwCntrlReq(RlcMiLkwCntrlReq, pst, mBuf);
 237                      break;
 238                   }
 239
 240                case EVENT_RLC_UL_UE_CREATE_REQ:        /* UE Create Request */
 241                   {
 242                      ret = unpackRlcUlUeCreateReq(RlcUlProcUeCreateReq, pst, mBuf);
 243                      break;
 244                   }
 245
 246                case LKW_EVT_STS_REQ:
 247                   {
 248                      ret = cmUnpkLkwStsReq(RlcMiLkwStsReq, pst, mBuf);
 249                      break;
 250                   }
 251
 252                case LKW_EVT_STA_REQ:
 253                   {
 254                      ret = cmUnpkLkwStaReq(RlcMiLkwStaReq, pst, mBuf);
 255                      break;
 256                   }
 257                   /* kw005.201 added support for L2 Measurement */
 258 #ifdef LTE_L2_MEAS
 259                case LKW_EVT_L2MEAS_REQ:
 260                   {
 261                      ret = cmUnpkLkwL2MeasReq(RlcMiLkwL2MeasReq, pst, mBuf);
 262                      break;
 263                   }
 264                case LKW_EVT_L2MEAS_SEND_REQ:
 265                  {
 266
 267                     ret = cmUnpkLkwL2MeasSendReq(RlcMiLkwL2MeasSendReq, pst, mBuf);
 268
 269                      break;
 270                  }
 271                case LKW_EVT_L2MEAS_STOP_REQ:
 272                  {
 273                      ret = cmUnpkLkwL2MeasStopReq(RlcMiLkwL2MeasStopReq, pst, mBuf);
 274                      break;
 275                  }
 276 #endif
 277 #endif  /* LCLKW */
 278                default:
 279                   ODU_PUT_MSG_BUF(mBuf);
 280                   if (pst->dstInst < MAX_RLC_INSTANCES)
 281                   {
 282                      RLOG1(L_FATAL,"Received Invalid Event[%d] from SM",
 283                             pst->event);
 284                   }
 285                   ret = RFAILED;
 286                   break;
 287
 288             }
 289             break;
 290          }
 291
 292       case ENTRLC:
 293          {
 294             switch(pst->event)
 295             {
 296 #ifdef LCUDX
 297                case UDX_EVT_BND_CFM:              /* Bind request */
 298                   {
 299                      ret = cmUnpkUdxBndCfm(rlcUlUdxBndCfm, pst, mBuf );
 300                      break;
 301                   }
 302
 303                case UDX_EVT_CFG_CFM:             /* Unbind request */
 304                   {
 305                      ret = cmUnpkUdxCfgCfm(rlcUlUdxCfgCfm, pst, mBuf );
 306                      break;
 307                   }
 308
 309                case UDX_EVT_UEIDCHG_CFM:              /* Configuration request */
 310                   {
 311                      ret = cmUnpkUdxUeIdChgCfm(rlcUlUdxUeIdChgCfm, pst, mBuf);
 312                      break;
 313                   }
 314
 315                case UDX_EVT_STA_PHBT_TMR_START:              /* Status Prohibit Timer Start */
 316                   {
 317                      ret = cmUnpkUdxStaProhTmrStart(rlcUlUdxStaProhTmrStart, pst, mBuf);
 318                      break;
 319                   }
 320
 321 #endif  /* LCCKW */
 322
 323                default:
 324                   ODU_PUT_MSG_BUF(mBuf);
 325                   if (pst->dstInst < MAX_RLC_INSTANCES)
 326                   {
 327                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
 328                             pst->event);
 329                   }
 330                   ret = RFAILED;
 331                   break;
 332
 333             }
 334             break;
 335          }
 336
 337       case ENTNH:
 338          {
 339             switch(pst->event)
 340             {
 341 #ifdef LCCKW
 342                case CKW_EVT_BND_REQ:              /* Bind request */
 343                   {
 344                      ret = cmUnpkCkwBndReq(RlcUiCkwBndReq, pst, mBuf );
 345                      break;
 346                   }
 347
 348                case CKW_EVT_UBND_REQ:             /* Unbind request */
 349                   {
 350                      ret = cmUnpkCkwUbndReq(RlcUiCkwUbndReq, pst, mBuf );
 351                      break;
 352                   }
 353
 354                case CKW_EVT_UEIDCHG_REQ:              /* Configuration request */
 355                   {
 356                      ret = cmUnpkCkwUeIdChgReq(RlcUiCkwUeIdChgReq, pst, mBuf);
 357                      break;
 358                   }
 359
 360 #endif  /* LCCKW */
 361
 362 #ifdef LCKWU
 363                case KWU_EVT_BND_REQ:              /* Bind request */
 364                   {
 365                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 366                      break;
 367                   }
 368
 369                case KWU_EVT_UBND_REQ:             /* Unbind request */
 370                   {
 371                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 372                      break;
 373                   }
 374 #endif  /* LCKWU */
 375                default:
 376                   ODU_PUT_MSG_BUF(mBuf);
 377                   if (pst->dstInst < MAX_RLC_INSTANCES)
 378                   {
 379                       RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
 380                             pst->event);
 381                   }
 382                   ret = RFAILED;
 383                   break;
 384
 385             }
 386             break;
 387          }
 388
 389       case ENTPJ:
 390          {
 391             switch(pst->event)
 392             {
 393 #ifdef LCKWU
 394                case KWU_EVT_BND_REQ:              /* Bind request */
 395                   {
 396                      ret = cmUnpkKwuBndReq(RlcUiKwuBndReq, pst, mBuf );
 397                      break;
 398                   }
 399
 400                case KWU_EVT_UBND_REQ:             /* Unbind request */
 401                   {
 402                      ret = cmUnpkKwuUbndReq(RlcUiKwuUbndReq, pst, mBuf );
 403                      break;
 404                   }
 405
 406                default:
 407                   ODU_PUT_MSG_BUF(mBuf);
 408                   if (pst->dstInst < MAX_RLC_INSTANCES)
 409                   {
 410                       RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
 411                             pst->event);
 412                   }
 413                   ret = RFAILED;
 414                   break;
 415 #endif  /* LCKWU */
 416                }
 417             break;
 418          }
 419
 420       case ENTMAC:
 421          {
 422             switch(pst->event)
 423             {
 424 #ifdef LCRGU
 425                case EVTRGUBNDCFM:     /* Bind request */
 426                   {
 427                      ret = cmUnpkRguBndCfm(RlcLiRguBndCfm, pst, mBuf );
 428                      break;
 429                   }
 430
 431                case EVENT_UL_DATA_TO_RLC:    /* UL Data request */
 432                   {
 433                      ret = unpackRlcUlData(RlcProcUlData, pst, mBuf);
 434                      break;
 435                   }
 436
 437 #endif  /* LCRGU */
 438
 439                default:
 440                   ODU_PUT_MSG_BUF(mBuf);
 441                   if (pst->dstInst < MAX_RLC_INSTANCES)
 442                   {
 443                       RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
 444                             pst->event);
 445                   }
 446                   ret = RFAILED;
 447                   break;
 448             }
 449             break;
 450          }
 451 #if defined(L2_L3_SPLIT) && defined (TENB_T2K3K_SPECIFIC_CHANGES) && defined (MAC_RLC_UL_RBUF)
 452       case ENTYS:
 453          {
 454             switch(pst->event)
 455             {
 456                case KWU_EVT_TTI_IND:
 457                   {
 458                      rlcUlBatchProc();
 459                      ODU_PUT_MSG_BUF(mBuf);
 460                      break;
 461                   }
 462             }
 463             break;
 464          }
 465 #endif/* End for TENB_T2K3K_SPECIFIC_CHANGES and L2_L3_SPLIT */
 466 #ifndef UL_RLC_NET_CLUSTER
 467 #ifdef TENB_STATS
 468       case ENTLWRMAC:
 469          {
 470             switch(pst->event)
 471             {
 472                case TENBSTATSINIT:
 473                {
 474
 475                   RlcCb *tRlcCb;
 476                   tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 477
 478                   TSL2SendStatsToApp(&(tRlcCb->genCfg.lmPst), 0);
 479                   ODU_PUT_MSG_BUF(mBuf);
 480                   break;
 481                }
 482                default:
 483                {
 484                   printf("\n ERROR Invalid Event[%d] from CL to PDCPUL\n",
 485                          pst->event);
 486                   ODU_PUT_MSG_BUF(mBuf);
 487                   break;
 488                }
 489             }
 490             break;
 491          }
 492 #endif
 493 #endif
 494       default:
 495          {
 496           if (pst->dstInst < MAX_RLC_INSTANCES)
 497            {
 498               RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",pst->event);
 499            }
 500             ODU_PUT_MSG_BUF(mBuf);
 501             ret = RFAILED;
 502             break;
 503          }
 504     }
 505    ODU_EXIT_TASK();
 506
 507    return (ret);
 508 } /* kwActvTsk */
 509
 510
 511 \f
 512 /********************************************************************30**
 513          End of file
 514 **********************************************************************/