src/5gnrrlc/kw_udx_dl.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
  21     Name:   NR RLC layer
  22
  23     Type:   C include file
  24
  25     Desc:   Defines required by LTE MAC
  26
  27     File:   kw_udx_dl.c
  28
  29 **********************************************************************/
  30
  31 /* header include files (.h) */
  32 #include "common_def.h"
  33 #include "lkw.h"           /* LKW defines */
  34 #include "ckw.h"           /* CKW defines */
  35 #include "kwu.h"           /* KWU defines */
  36 #include "rgu.h"           /* RGU defines */
  37 #include "kw_err.h"        /* Err defines */
  38 #include "kw_env.h"        /* RLC environment options */
  39
  40 #include "kw.h"            /* RLC defines */
  41 #include "kw_udx.h"
  42 #include "kw_dl.h"
  43
  44 /* extern (.x) include files */
  45 #include "lkw.x"           /* LKW */
  46 #include "ckw.x"           /* CKW */
  47 #include "kwu.x"           /* KWU */
  48 #include "rgu.x"           /* RGU */
  49
  50 #include "kw.x"
  51 #include "kw_udx.x"
  52 #include "kw_dl.x"
  53
  54
  55 #define RLC_MODULE RLC_DBGMASK_UDX
  56 /* local defines */
  57
  58 S16 rlcDlmHndlStaRsp ARGS (( RlcCb  *gCb,RlcDlRbCb  *rbCb,
  59                 RlcUdxStaPdu *pStaPdu, RlcUdxBufLst  *rlsPduLst));
  60
  61
  62
  63
  64 /**
  65   * @brief
  66   * UDX APIs
  67   */
  68
  69 /**
  70  *
  71  * @brief
  72  *    Handler to bind the DL with UL.
  73  *
  74  * @param[in] pst   Post structure
  75  * @param[in] suId  Service user SAP ID
  76  * @param[in] spId  Service provider ID
  77  *
  78  * @return  S16
  79  *    -# ROK
  80  *    -# RFAILED
  81  */
  82 S16 rlcDlUdxBndReq
  83 (
  84 Pst    *pst,
  85 SuId   suId,
  86 SpId   spId
  87 )
  88 {
  89    RlcUdxDlSapCb   *udxSap;            /* pointer to session SAP */
  90    RlcCb           *tRlcCb;
  91
  92 #if (ERRCLASS & ERRCLS_INT_PAR)
  93    if (pst->dstInst >= MAX_RLC_INSTANCES)
  94    {
  95       return RFAILED;
  96    }
  97 #endif
  98    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
  99
 100    RLCDBGP_BRIEF(tRlcCb, "rlcDlUdxBndReq(spId(%d), suId(%d))\n",
 101                 spId, suId);
 102
 103    udxSap = (tRlcCb->u.dlCb->udxDlSap + spId);
 104
 105    /* Verify CKW SAP State */
 106    switch(udxSap->state)
 107    {
 108       /* SAP is configured but not bound */
 109       case RLC_SAP_CFG:
 110       case RLC_SAP_UBND:
 111       {
 112          /* copy bind configuration parameters in SSAP sap */
 113          udxSap->suId = suId;
 114          udxSap->pst.dstProcId = pst->srcProcId;
 115          udxSap->pst.dstEnt = pst->srcEnt;
 116          udxSap->pst.dstInst = pst->srcInst;
 117
 118          /* Update the State */
 119          udxSap->state = RLC_SAP_BND;
 120
 121          DU_LOG("\nINFO   --> RLC_DL : UDX SAP state [%d]", udxSap->state);
 122          break;
 123       }
 124       /* SAP is already bound */
 125       case RLC_SAP_BND:
 126       {
 127          /*
 128           * Sap is already bound check source, destination Entity and
 129           * Proc Id
 130           */
 131          if (udxSap->pst.dstProcId != pst->srcProcId
 132                || udxSap->pst.dstEnt != pst->srcEnt
 133                || udxSap->pst.dstInst != pst->srcInst
 134                || udxSap->suId != suId)
 135          {
 136             RLC_SEND_SAPID_ALARM(tRlcCb, spId,
 137                                 LKW_EVENT_UDX_BND_REQ, LCM_CAUSE_INV_PAR_VAL);
 138
 139             DU_LOG("\nERROR  --> RLC_DL : UDX SAP already Bound");
 140             rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
 141          }
 142          break;
 143       }
 144
 145      default:
 146       {
 147 #if (ERRCLASS & ERRCLS_INT_PAR)
 148          RLC_SEND_SAPID_ALARM(tRlcCb,spId,
 149                              LKW_EVENT_CKW_BND_REQ, LCM_CAUSE_INV_STATE);
 150 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 151          DU_LOG("\nERROR  --> RLC_DL : Invalid UDX SAP State in Bind Req");
 152          rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_NOK);
 153          break;
 154       }
 155    }
 156    rlcDlUdxBndCfm(&(udxSap->pst), udxSap->suId, CM_BND_OK);
 157    return ROK;
 158 }
 159
 160 \f
 161 /**
 162  * @brief
 163  *    Handler for unbinding the DL from UL.
 164  *
 165  *  @param[in] pst     Post structure
 166  *  @param[in] spId    Service provider SAP ID
 167  *  @param[in] reason  Reason for Unbinding
 168  *
 169  *  @return  S16
 170  *      -# ROK
 171  */
 172 S16 rlcDlUdxUbndReq
 173 (
 174 Pst      *pst,
 175 SpId     spId,
 176 Reason   reason
 177 )
 178 {
 179    RlcUdxDlSapCb   *udxSap;
 180    RlcCb           *tRlcCb;
 181
 182 #if (ERRCLASS & ERRCLS_INT_PAR)
 183    if (pst->dstInst >= MAX_RLC_INSTANCES)
 184    {
 185       return RFAILED;
 186    }
 187 #endif
 188
 189    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 190
 191    DU_LOG("\nDEBUG  --> RLC_DL : Unbind Req for spId[%d], reason[%d]",
 192                 spId, reason);
 193    UNUSED(reason);
 194    /* disable upper sap (CKW) */
 195    udxSap = (tRlcCb->u.dlCb->udxDlSap + spId);
 196
 197 #if (ERRCLASS & ERRCLS_INT_PAR)
 198    RLC_GET_AND_VALIDATE_UDXSAP(tRlcCb,udxSap, EKW208, "KwUiDlUdxndReq");
 199 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 200    udxSap->state = RLC_SAP_CFG;
 201    return ROK;
 202 }
 203
 204 \f
 205 /**
 206  * @brief
 207  *    Handler for configuring RLC entities.
 208  *
 209  * @details
 210  *    This function is used by RRC to configure(add/delete/modify)
 211  *    one or more RLC entities.
 212  *        - CKW_CFG_ADD          => rlcCfgAddRb
 213  *        - CKW_CFG_MODIFY       => rlcCfgReCfgRb
 214  *        - CKW_CFG_DELETE       => rlcCfgDelRb
 215  *        - CKW_CFG_REESTABLISH  => rlcCfgReEstRb
 216  *        - CKW_CFG_DELETE_UE    => rlcCfgDelUe
 217  *
 218  * @param[in] pst   -  Post structure
 219  * @param[in] spId  -  Serive Provider ID
 220  * @param[in] cfg   -  Configuration information for one or more RLC entities.
 221  *
 222  * @return  S16
 223  *    -# ROK
 224  *    -# RFAILED
 225  */
 226 S16 rlcDlUdxCfgReq
 227 (
 228 Pst          *pst,
 229 SpId         spId,
 230 RlcCfgInfo   *cfg
 231 )
 232 {
 233    RlcCfgCfmInfo   *cfgCfm;
 234    uint8_t         idx;
 235    RlcCb           *tRlcCb;
 236    Pst             *pstUdxCfm;
 237
 238 #if (ERRCLASS & ERRCLS_INT_PAR)
 239    if (pst->dstInst >= MAX_RLC_INSTANCES)
 240    {
 241       return RFAILED;
 242    }
 243 #endif
 244
 245    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 246
 247    pstUdxCfm = &(tRlcCb->u.dlCb->udxDlSap[spId].pst);
 248    RLCDBGP_BRIEF(tRlcCb,"spId(%d)\n", spId);
 249    /* Allocate memory and memset to 0 for cfmInfo */
 250    RLC_ALLOC_SHRABL_BUF_WC(pstUdxCfm->region,
 251                           pstUdxCfm->pool,
 252                           cfgCfm,
 253                           sizeof(RlcCfgCfmInfo));
 254
 255 #if (ERRCLASS & ERRCLS_ADD_RES)
 256    if (cfgCfm == NULLP)
 257    {
 258       DU_LOG("\nERROR  --> RLC_DL : Memory Allocation Failed.");
 259       /* kw002.201 Freeing from proper region */
 260       /* RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo)); */
 261       return RFAILED;
 262    }
 263 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 264
 265    /* For every entity configuration process by cfgType */
 266    for (idx = 0; idx < cfg->numEnt; idx++)
 267    {
 268       RlcEntCfgCfmInfo   *entCfgCfm;
 269       RlcEntCfgInfo      *entCfg;
 270
 271       entCfg  = (RlcEntCfgInfo *)&(cfg->entCfg[idx]);
 272       entCfgCfm   = (RlcEntCfgCfmInfo *)&(cfgCfm->entCfgCfm[idx]);
 273
 274       switch (entCfg->cfgType)
 275       {
 276          case CKW_CFG_ADD:
 277             {
 278                if (entCfg->dir & RLC_DIR_DL)
 279                {
 280                   /* Add a new RB entity configuration */
 281                   if (rlcCfgAddDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
 282                               entCfg, entCfgCfm) != ROK)
 283                   {
 284                      DU_LOG("\nERROR  --> RLC_DL : Addition Failed due to[%d]",
 285                            entCfgCfm->status.reason);
 286                   }
 287                }
 288                break;
 289             }
 290          case CKW_CFG_MODIFY:
 291             {
 292                if (entCfg->dir & RLC_DIR_DL)
 293                {
 294                   /* Re-configure the existing RB entity configuration */
 295                   if (rlcCfgReCfgDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
 296                            entCfg, entCfgCfm) != ROK)
 297                   {
 298                      DU_LOG("\nERROR  --> RLC_DL : ReCfg Failed due to[%d]",
 299                            entCfgCfm->status.reason);
 300                   }
 301                }
 302                break;
 303             }
 304
 305          case CKW_CFG_DELETE:
 306             {
 307                if (entCfg->dir & RLC_DIR_DL)
 308                {
 309                   /* Delete the existing RB entity configuration */
 310                   if (rlcCfgDelDlRb(tRlcCb,cfg->ueId, cfg->cellId,\
 311                         entCfg, entCfgCfm) != ROK)
 312                   {
 313                      DU_LOG("\nERROR  --> RLC_DL : Deletion Failed due to[%d]",
 314                            entCfgCfm->status.reason);
 315                   }
 316                }
 317                break;
 318             }
 319
 320          case CKW_CFG_REESTABLISH:
 321             {
 322                if (entCfg->dir & RLC_DIR_DL)
 323                {
 324                   /*if direction is both then, re-establishment end indication
 325                    * should be sent only from the UL instance, only if DIR is
 326                    * DL only then DL instance will send indication.*/
 327                   Bool sndReEst = TRUE;
 328                   if (entCfg->dir & RLC_DIR_UL)
 329                   {
 330                      sndReEst = FALSE;
 331                   }
 332                   /* Re-establish the existing RB entity configuration */
 333                   if (rlcCfgReEstDlRb(tRlcCb,cfg->ueId, cfg->cellId,
 334                                      sndReEst,entCfg, entCfgCfm) != ROK)
 335                   {
 336                      DU_LOG("\nERROR  --> RLC_DL : Reest Failed due to[%d]",
 337                            entCfgCfm->status.reason);
 338                   }
 339                }
 340                break;
 341             }
 342
 343          case CKW_CFG_DELETE_UE:
 344             {
 345                /* Delete all RB entity configuration under UE */
 346                if (rlcCfgDelDlUe(tRlcCb,cfg->ueId, cfg->cellId,
 347                                 entCfg, entCfgCfm) != ROK)
 348                {
 349                   DU_LOG("\nERROR  --> RLC_DL : deletion Failed due to[%d]",
 350                            entCfgCfm->status.reason);
 351                }
 352                break;
 353             }
 354          case CKW_CFG_DELETE_CELL:
 355             {
 356                if (rlcCfgDelDlCell(tRlcCb,cfg->cellId,entCfg,entCfgCfm)
 357                                                                 != ROK )
 358                {
 359                   DU_LOG("\nERROR  --> RLC_DL : deletion Failed due to[%d]",
 360                            entCfgCfm->status.reason);
 361                }
 362                break;
 363             }
 364
 365          default:
 366             {
 367                RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,\
 368                                    CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
 369                DU_LOG("\nERROR  --> RLC_DL : Invalid CfgType");
 370             }
 371       }
 372    }
 373
 374    /* Assign number of entity configuraitons and suId */
 375    cfgCfm->transId = cfg->transId;
 376    cfgCfm->ueId = cfg->ueId;
 377    cfgCfm->cellId = cfg->cellId;
 378    cfgCfm->numEnt = cfg->numEnt;
 379
 380    /* kw002.201 Freeing from proper region */
 381    /* RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo)); */
 382    /* Send Configuration confirm primitive */
 383    rlcDlUdxCfgCfm(&(tRlcCb->u.dlCb->udxDlSap[spId].pst),
 384                  tRlcCb->u.dlCb->udxDlSap[spId].suId,
 385                  cfgCfm);
 386
 387    return ROK;
 388 }
 389
 390 /**
 391  *@brief
 392  *   This primitive is used by RRC to change the UeId for the existing UE
 393  *   context.
 394  *
 395  * @param pst     -  Pointer to the pst structure
 396  * @param spId    -  The ID of the service provider SAP in the RLC layer
 397  * @param transId -  Transaction ID. This field uniquily identifies
 398  *                   transaction between RRC and RLC
 399  * @param ueInfo    -  Old UE Id Info for which the change request has come
 400  * @param newUeInfo -  New UE Id Info for existing UE context
 401  *
 402  * @return
 403  *    -# ROK
 404  *    -# RFAILED
 405  */
 406 S16 rlcDlUdxUeIdChgReq
 407 (
 408 Pst         *pst,
 409 SpId        spId,
 410 uint32_t    transId,
 411 CkwUeInfo   *ueInfo,
 412 CkwUeInfo   *newUeInfo
 413 )
 414 {
 415    CmStatus       status;
 416    RlcCb           *tRlcCb;
 417
 418 #if (ERRCLASS & ERRCLS_INT_PAR)
 419    if (pst->dstInst >= MAX_RLC_INSTANCES)
 420    {
 421       return RFAILED;
 422    }
 423 #endif
 424
 425    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 426 #ifndef ALIGN_64BIT
 427    RLCDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%ld))\n",
 428                 spId, transId);
 429 #else
 430    RLCDBGP_BRIEF(tRlcCb, "(spId(%d), transId(%d))\n",
 431                 spId, transId);
 432 #endif
 433
 434    status.reason = CKW_CFG_REAS_NONE;
 435    status.status = CKW_CFG_CFM_OK;
 436
 437    if (rlcCfgDlUeIdChng(tRlcCb, ueInfo, newUeInfo, &status) != ROK)
 438    {
 439       DU_LOG("\nERROR  --> RLC_DL : Failure due to[%d]",
 440              status.reason);
 441    }
 442    rlcDlUdxUeIdChgCfm(&(tRlcCb->u.dlCb->udxDlSap[spId].pst),
 443                      tRlcCb->u.dlCb->udxDlSap[spId].suId,
 444                      transId,
 445                      status);
 446
 447    return ROK;
 448 }
 449
 450 /**
 451 * @brief
 452 *    Request for status PDU from  ULM to DLM.
 453 *
 454 * @param[in]   pst   -  Post Structure
 455 * @param[in]   spId  -  Service Provider Id
 456 * @param[in]   rlcId -  Rlc Information Id
 457 * @param[in]   pStaPdu - Status PDU
 458 *
 459 * @return   S16
 460 *    -# ROK
 461 *    -# RFAILED
 462 **/
 463 S16  rlcDlUdxStaPduReq
 464 (
 465 Pst             *pst,
 466 SpId            spId,
 467 CmLteRlcId      *rlcId,
 468 RlcUdxDlStaPdu   *pStaPdu
 469 )
 470 {
 471    RlcDlRbCb   *rbCb;
 472    RlcCb       *tRlcCb;
 473
 474    tRlcCb =  RLC_GET_RLCCB (pst->dstInst);
 475
 476    rlcDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb); /* Fetch DBM RbCb */
 477    if (!rbCb)
 478    {
 479       DU_LOG("\nERROR  --> RLC_DL : CellId [%u]:RbId[%d] not found",
 480             rlcId->cellId,rlcId->rbId);
 481       RLC_FREE_SHRABL_BUF(pst->region,
 482                          pst->pool,
 483                          pStaPdu,
 484                          sizeof(RlcUdxDlStaPdu));
 485       return RFAILED;
 486    }
 487
 488    RLC_AMDL.cntrlBo = pStaPdu->controlBo;
 489    /* If there already exists a STAUS PDU, free it and take the new one
 490       into account */
 491    if(RLC_AMDL.pStaPdu)
 492    {
 493       RLC_FREE_SHRABL_BUF(pst->region,
 494                          pst->pool,
 495                          RLC_AMDL.pStaPdu,
 496                          sizeof(RlcUdxDlStaPdu));
 497    }
 498
 499    RLC_AMDL.pStaPdu = pStaPdu;
 500    rlcAmmSendDedLcBoStatus(tRlcCb, rbCb, &RLC_AMDL);
 501
 502    return  (ROK);
 503 }
 504
 505 /**
 506 * @brief
 507 *    It handles the status update recieved from ULM.
 508 *
 509 * @param[in]   pst   -  Post Structure
 510 * @param[in]   spId  -  Service Provider Id
 511 * @param[in]   rlcId -  Rlc Information Id
 512 * @param[in]   pStaPdu - Status PDU
 513 *
 514 * @return   S16
 515 *    -# ROK
 516 *    -# RFAILED
 517 **/
 518 S16  rlcDlUdxStaUpdReq
 519 (
 520 Pst*          pst,
 521 SpId          spId,
 522 CmLteRlcId    *rlcId,
 523 RlcUdxStaPdu   *pStaPdu
 524 )
 525 {
 526    RlcCb          *tRlcCb;
 527    RlcDlRbCb      *rbCb;
 528
 529    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 530
 531    rlcDbmFetchDlRbCbByRbId(tRlcCb, rlcId, &rbCb);
 532    if (!rbCb)
 533    {
 534       DU_LOG("\nERROR  --> RLC_DL : CellId [%u]:RbId[%d] not found",
 535             rlcId->cellId,rlcId->rbId);
 536       return RFAILED;
 537    }
 538
 539    rlcAmmDlHndlStatusPdu(tRlcCb, rbCb, pStaPdu);
 540
 541    RLC_FREE_SHRABL_BUF(pst->region,
 542                       pst->pool,
 543                       pStaPdu,
 544                       sizeof(RlcUdxStaPdu));
 545
 546    return ROK;
 547 }
 548
 549 #ifdef LTE_L2_MEAS
 550 /**
 551 */
 552 S16 rlcDlUdxL2MeasReq
 553 (
 554 Pst            *pst,
 555 RlcL2MeasReqEvt *measReqEvt
 556 )
 557 {
 558    uint32_t  cntr;
 559    uint8_t   measType;
 560    volatile uint32_t     startTime = 0;
 561    RlcCb     *tRlcCb;
 562
 563    /*starting Task*/
 564    SStartTask(&startTime, PID_RLC_MEAS_START);
 565
 566    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
 567
 568    /* Initialize measCfmEvt */
 569
 570   /* validate the received measReqEvt */
 571  /*LTE_L2_MEAS_PHASE2*/
 572
 573    measType = measReqEvt->measReq.measType;
 574
 575    if(measType & LKW_L2MEAS_DL_IP)
 576    {
 577       /* if measurement is for DL IP enable for all QCI */
 578       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
 579       {
 580          tRlcCb->u.dlCb->rlcL2Cb.measOn[cntr] |= LKW_L2MEAS_DL_IP;
 581       }
 582    }
 583    else
 584    {
 585       /* for nonIpThroughput meas, enable only for the sent QCIs */
 586       uint32_t i;
 587       for(i = 0; i < LKW_MAX_QCI; i++)
 588       {
 589          tRlcCb->u.dlCb->rlcL2Cb.measOn[i] |= measType;
 590       }
 591    }
 592
 593    /* We need to copy the transId for sending back confirms later */
 594    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 595    {
 596       RlcL2MeasEvtCb* measEvtCb = &(tRlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
 597       if(measEvtCb->measCb.measType & measType)
 598       {
 599          measEvtCb->transId= measReqEvt->transId;
 600       }
 601    }
 602
 603    /*stopping Task*/
 604    SStopTask(startTime, PID_RLC_MEAS_START);
 605    return ROK;
 606 } /* rlcDlUdxMeasReq */
 607
 608 /**
 609 @brief
 610 This function processes L2 Measurement stop request received from the layer manager.
 611 After receving this request, RLC stops L2 Measurement
 612  *  @param[in] pst      post structure
 613  *  @param[in] measType meas Type
 614  *  @return S16
 615  *      -# Success : ROK
 616  *      -# Failure : RFAILED
 617 */
 618
 619 S16 rlcDlUdxL2MeasStopReq
 620 (
 621 Pst            *pst,
 622 uint8_t         measType
 623 )
 624 {
 625   /* S16 ret = ROK;*/
 626    RlcL2MeasEvtCb *measEvtCb = NULLP;
 627    uint16_t        cntr;
 628    uint8_t         status = ROK;
 629 /*   RlcL2MeasCfmEvt          measCfmEvt;  */
 630    volatile uint32_t     startTime = 0;
 631    RlcCb     *tRlcCb=NULLP;
 632
 633    /*starting Task*/
 634    SStartTask(&startTime, PID_RLC_MEAS_STOP);
 635
 636    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
 637 /*   memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt)); */
 638    /* reset the counters for the measurement type passed */
 639    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 640    {
 641       measEvtCb = &(tRlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
 642       if(measEvtCb->measCb.measType & measType)
 643       {
 644          rlcUtlResetDlL2MeasInRlcRb(tRlcCb, &measEvtCb->measCb, measType);
 645
 646       }
 647    }
 648
 649    /* switch off the measurements for the type passed */
 650    for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
 651    {
 652       tRlcCb->u.dlCb->rlcL2Cb.measOn[cntr] &= ~measType;
 653    }
 654
 655    status = LCM_PRIM_OK;
 656    /* Stop confirm is removed as UL thread is already sending it */
 657
 658    /*stopping Task*/
 659    SStopTask(startTime, PID_RLC_MEAS_STOP);
 660
 661    return ROK;
 662 }
 663 /**
 664 @brief
 665 This function processes L2 Measurement Send request received from the layer manager.
 666 After receving this request, RLC sends L2 Measurement
 667  *  @param[in] pst      post structure
 668  *  @param[in] measType meas Type
 669  *  @return S16
 670  *      -# Success : ROK
 671  *      -# Failure : RFAILED
 672 */
 673
 674 S16 rlcDlUdxL2MeasSendReq
 675 (
 676 Pst            *pst,
 677 uint8_t         measType
 678 )
 679 {
 680    RlcL2MeasEvtCb *measEvtCb;
 681    uint16_t            cntr;
 682    volatile uint32_t     startTime = 0;
 683    RlcCb     *tRlcCb;
 684
 685    tRlcCb =  RLC_GET_RLCCB(pst->dstInst);
 686    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 687    {
 688       measEvtCb = &(tRlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[cntr]);
 689       if(measEvtCb->measCb.measType & measType)
 690       {
 691          /*starting Task*/
 692          SStartTask(&startTime, PID_RLC_MEAS_REPORT);
 693
 694          rlcUtlSndDlL2MeasCfm(tRlcCb, measEvtCb);
 695
 696          /*stopping Task*/
 697          SStopTask(startTime, PID_RLC_MEAS_REPORT);
 698       }
 699    }
 700
 701    return ROK;
 702 }
 703 #endif /* LTE_L2_MEAS */
 704
 705 #ifdef __cplusplus
 706 }
 707 #endif /* __cplusplus */
 708
 709 \f
 710 /**********************************************************************
 711          End of file
 712 **********************************************************************/