src/5gnrmac/rg_pom_scell.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:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point functions
  26
  27      File:     rg_pom_scell.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_pom_scell.c
  32 @brief This module does processing related to handling of SCell related function.
  33 */
  34
  35 /* header include files -- defines (.h) */
  36 #include "envopt.h"        /* environment options */
  37 #include "envdep.h"        /* environment dependent */
  38 #include "envind.h"        /* environment independent */
  39 #include "gen.h"           /* general layer */
  40 #include "ssi.h"           /* system service interface */
  41 #include "cm_hash.h"       /* common hash list */
  42 #include "cm_mblk.h"       /* common memory link list library */
  43 #include "cm_llist.h"      /* common linked list library */
  44 #include "cm_err.h"        /* common error */
  45 #include "cm_lte.h"        /* common LTE */
  46 #include "lrg.h"
  47 #include "crg.h"
  48 #include "rgu.h"
  49 #include "tfu.h"
  50 #include "rg_sch_inf.h"
  51 #include "rg_prg.h"       /* PRG interface includes*/
  52 #include "rg_env.h"
  53 #include "rg.h"
  54 #include "rg_err.h"
  55
  56 /* header/extern include files (.x) */
  57 #include "gen.x"           /* general layer */
  58 #include "ssi.x"           /* system service interface */
  59 #include "cm5.x"           /* common timers */
  60 #include "cm_lib.x"        /* common library */
  61 #include "cm_hash.x"       /* common hash list */
  62 #include "cm_mblk.x"       /* common memory link list library */
  63 #include "cm_llist.x"      /* common linked list library */
  64 #include "cm_tkns.x"       /* common tokens */
  65 #include "cm_lte.x"        /* common LTE */
  66 #include "lrg.x"
  67 #include "crg.x"
  68 #include "rgu.x"
  69 #include "tfu.x"
  70 #include "rg_sch_inf.x"
  71 #include "rg_prg.x"       /* PRG interface typedefs*/
  72 #include "rg.x"
  73 #ifdef LTE_ADV
  74 #include "rg_pom_scell.x"
  75 PRIVATE S16 rgPomVldtSCellDedLchCfg ARGS((
  76             Inst                       inst,
  77             RgPrgUeSCellLchAddInfo     *lcCfg,
  78             RgCellCb                   **cell,
  79             RgUeCb                     **ue
  80           ));
  81 PRIVATE S16 rgPomUeSCellDedLcCfg ARGS((RgCellCb                   *cell,
  82                                        RgUeCb                     *ue,
  83                                        RgPrgUeSCellLchAddInfo     *lcCfg
  84                                      ));
  85 /**
  86  * @brief Handler for the Lch reconfiguration request from PMAC to SMAC.
  87  *
  88  * @details
  89  *
  90  *     Function : RgPrgPMacSMacUeSCellLchModReq
  91  *
  92  *     Processing Steps:
  93  *      - calls the function for validating cell, uecb and lch sent by PMAC
  94  *      - Updates the lch recfg into ueCb.
  95  *      - If successful, add the control block to hash list of UEs for the cell
  96  *        else Rollback and FAIL.
  97  *
  98  *  @param[in]  Pst                    *pst
  99  *  @param[in]  RgPrgUeSCellLchModInfo *lchCfgCb
 100  *  @return  S16
 101  *      -# ROK
 102  *      -# RFAILED
 103  **/
 104 #ifdef ANSI
 105 PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq
 106 (
 107 Pst                      *pst,
 108 RgPrgUeSCellLchModInfo   *lchCfgCb
 109 )
 110 #else
 111 PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq(pst, lchCfgCb)
 112 Pst                      *pst;
 113 RgPrgUeSCellLchModInfo   *lchCfgCb;
 114 #endif
 115 {
 116    RgPrgCfgCfmInfo  cfgCfm;
 117    Inst             inst = pst->dstInst;
 118    RgCellCb         *cell;
 119    S16              ret;
 120    Pst              cfmPst;
 121    RgUeCb           *ue;
 122    RgUlLcCb         *ulLc;
 123
 124    TRC2(RgPrgPMacSMacUeSCellLchModReq);
 125
 126    RGDBGPRM(inst,(rgPBuf(inst),
 127             "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d lcId %d lcgId %d\n",
 128          lchCfgCb->cellId, lchCfgCb->crnti,lchCfgCb->lcId,lchCfgCb->ulLchRecfg.lcgId));
 129
 130    cfgCfm.ueId = lchCfgCb->crnti;
 131    cfgCfm.sCellId = lchCfgCb->cellId;
 132    cfgCfm.status = PRG_CFG_CFM_OK;
 133    cfgCfm.event = EVTPRGUESCELLLCHMODCFM;
 134    rgGetPstToInst(&cfmPst, inst, pst->srcInst);
 135
 136    ret = rgPomVltdModLch(inst,lchCfgCb, &cell, &ue,&ulLc);
 137   if(ret != ROK)
 138   {
 139      RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
 140               cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
 141      /* Set status as Not OK*/
 142      cfgCfm.status = PRG_CFG_CFM_NOK;
 143   }
 144   else
 145   {
 146      ret = rgPomUeSCellLcMod(inst, ue, ulLc, lchCfgCb);
 147      if(ret != ROK)
 148      {
 149         RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
 150                  cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
 151         /* Set status as Not OK*/
 152         cfgCfm.status = PRG_CFG_CFM_NOK;
 153      }
 154   }
 155
 156   RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
 157            cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
 158
 159   /* Send positive confirmation to primary cell*/
 160   RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
 161   RETVALUE(ROK);
 162 }  /* RgPrgPMacSMacUeSCellLchModReq */
 163
 164
 165 /**
 166  * @brief A wrapper class to send the LCH Del req from PMAC to SMAC
 167  *
 168  * @details
 169  *
 170  *     Function : rgPomSndUeSCellLchDelToSmac
 171  *
 172  *     Processing Steps:
 173  *      - Retrieve the cell control block.
 174  *      - If successful,
 175  *        - Validate the range of values received in
 176  *          delete request.
 177  *        - Checks if the Ue has any scell added.
 178  *        - If validated successfully,
 179  *          - if SCells have been added ,then
 180  *            send the lchDel structure to update the same values to SMAC.
 181  *        - Return ROK.
 182  *      - Else return RFAILED.
 183  *
 184  *  @param[in]  Inst          inst
 185  *  @param[in]  CrgDel        *lcDel
 186  *  @param[in]  Bool          *isCfmRqrd
 187  *  @return  S16
 188  *      -# ROK
 189  *      -# RFAILED
 190  **/
 191 #ifdef ANSI
 192 PUBLIC S16 rgPomSndUeSCellLchDelToSmac
 193 (
 194 Inst            inst,
 195 CrgDel          *lcDel,
 196 Bool            *isCfmRqrd
 197 )
 198 #else
 199 PUBLIC S16 rgPomSndUeSCellLchDelToSmac(inst,lcDel,isCfmRqrd)
 200 Inst            inst;
 201 CrgDel          *lcDel;
 202 Bool            *isCfmRqrd;
 203 #endif
 204 {
 205    U8                         idx = 0;
 206    Inst                       dstMacInst;
 207    Pst                        dstInstPst;
 208    RgPrgUeSCellLchDelInfo     delLcCb;
 209    RgCellCb                   *cell;
 210    RgUeCb                     *ue;
 211
 212    TRC2(rgPomSndUeSCellLchDelToSmac);
 213
 214   /* Fetch the Active cell */
 215    if(((cell = rgCb[inst].cell) == NULLP) ||
 216        (cell->cellId != lcDel->u.lchDel.cellId))
 217    {
 218       RGDBGERRNEW(inst,(rgPBuf(inst),
 219                        "[%d]Active Cell does not exist %d\n",
 220                                   lcDel->u.lchDel.crnti, lcDel->u.lchDel.cellId));
 221       RETVALUE(RFAILED);
 222    }
 223
 224    RGDBGPRM(inst,(rgPBuf(inst),
 225             "Filling SCell LCh Config : cellId %d ueId %d\n",
 226             cell->cellId, cell->ueId));
 227
 228    if ((ue = rgDBMGetUeCb(cell, lcDel->u.lchDel.crnti)) == NULLP)
 229    {
 230       RGDBGERRNEW(inst,(rgPBuf(inst),
 231                "[%d]Ue does not exist\n", lcDel->u.lchDel.crnti));
 232       RETVALUE(RFAILED);
 233    }
 234    for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
 235    {
 236       if(TRUE == ue->sCelInfo[idx].isSCellAdded)
 237       {
 238          dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
 239          delLcCb.cellId = ue->sCelInfo[idx].sCellId;
 240          delLcCb.crnti = lcDel->u.lchDel.crnti;
 241          delLcCb.lcId = lcDel->u.lchDel.lcId;
 242          delLcCb.dir = lcDel->u.lchDel.dir;
 243
 244       /* Get post structure of the cell to whom delLcCb needs to be sent
 245        * And then send the lch recfg based on Mac instances */
 246          rgGetPstToInst(&dstInstPst, inst, dstMacInst);
 247          RgPrgPMacSMacUeScellLchDel(&dstInstPst, &delLcCb);
 248          *isCfmRqrd = FALSE;
 249       }
 250    }
 251    RETVALUE(ROK);
 252 }
 253
 254
 255 /**
 256  * @brief A wrapper class to send the LCH reconfig req from PMAC to SMAC
 257  *
 258  * @details
 259  *
 260  *     Function : rgPomSndUeSCellLchModToSmac
 261  *
 262  *     Processing Steps:
 263  *      - Retrieve the cell control block.
 264  *      - If successful,
 265  *        - Validate the range of re-configured values recieved in
 266  *          re-configuration request.
 267  *        - Checks if the Ue has any scell added.
 268  *        - If validated successfully,
 269  *          - if SCells have been added ,then
 270  *            send the lchRecfg structure to update the same values to SMAC.
 271  *        - Return ROK.
 272  *      - Else return RFAILED.
 273  *
 274  *  @param[in]  Inst          inst
 275  *  @param[in]  RgCellCb      *cell
 276     @param[in]  RgUeCb        *ue,
 277     @param[in]  CrgLchRecfg   *lchRecfg,
 278     @param[in]  Bool          *isCfmRqrd
 279  *  @return  S16
 280  *      -# ROK
 281  *      -# RFAILED
 282  **/
 283 #ifdef ANSI
 284 PUBLIC S16 rgPomSndUeSCellLchModToSmac
 285 (
 286 Inst           inst,
 287 RgCellCb       *cell,
 288 RgUeCb         *ue,
 289 CrgLchRecfg    *lchRecfg,
 290 Bool           *isCfmRqrd
 291 )
 292 #else
 293 PUBLIC S16 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lchRecfg, isCfmRqrd)
 294 Inst           inst;
 295 RgCellCb       *cell;
 296 RgUeCb         *ue;
 297 CrgLchRecfg    *lchRecfg;
 298 Bool           *isCfmRqrd;
 299 #endif
 300 {
 301    U8                        idx = 0;
 302    Inst                      dstMacInst;
 303    RgPrgUeSCellLchModInfo    lchCfgCb;
 304    Pst                       dstInstPst;
 305
 306    TRC2(rgPomSndUeSCellLchModToSmac);
 307
 308    for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
 309    {
 310       if(TRUE == ue->sCelInfo[idx].isSCellAdded)
 311       {
 312          dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
 313          lchCfgCb.cellId = ue->sCelInfo[idx].sCellId;
 314          lchCfgCb.crnti = lchRecfg->crnti;
 315          lchCfgCb.lcId = lchRecfg->lcId;
 316          lchCfgCb.ulLchRecfg.lcgId = lchRecfg->ulRecfg.lcgId;
 317
 318       /* Get post structure of the cell to whom lchCfgCb needs to be sent
 319        * And then send the lch recfg based on Mac instances */
 320          rgGetPstToInst(&dstInstPst, inst, dstMacInst);
 321          RgPrgPMacSMacUeScellLchMod(&dstInstPst, &lchCfgCb);
 322          *isCfmRqrd = FALSE;
 323       }
 324    }
 325    RETVALUE(ROK);
 326 }
 327
 328 /**
 329  * @brief A wrapper class to send the LCH config req from PMAC to SMAC
 330  *
 331  * @details
 332  *
 333  *     Function : rgPomSndUeSCellLchAddToSmac
 334  *
 335  *     Processing Steps:
 336  *        - Checks if the Ue has any scell added.
 337  *          - if SCells have been added ,then
 338  *            send the lchCfgCb structure to update the same values to SMAC.
 339  *        - Return ROK.
 340  *      - Else return RFAILED.
 341  *
 342  *  @param[in]  Inst          insg
 343  *
 344  *  @param[in]  RgCellCb      *cell
 345  *  @paran[in]  RgUeCb        *ue
 346  *  @paran[in]  CrgLchCfg     *lchCfg
 347  *  @paran[in]   Bool         *isCfmRqrd
 348  *  @return  S16
 349  *      -# ROK
 350  *      -# RFAILED
 351  **/
 352 #ifdef ANSI
 353 PUBLIC S16 rgPomSndUeSCellLchAddToSmac
 354 (
 355 Inst           inst,
 356 RgCellCb       *cell,
 357 RgUeCb         *ue,
 358 CrgLchCfg      *lchCfg,
 359 Bool           *isCfmRqrd
 360 )
 361 #else
 362 PUBLIC S16 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lchCfg, isCfmRqrd)
 363 Inst           inst;
 364 RgCellCb       *cell;
 365 RgUeCb         *ue;
 366 CrgLchCfg      *lchCfg;
 367 Bool           *isCfmRqrd;
 368 #endif
 369 {
 370    U8                        idx = 0;
 371    Inst                      dstMacInst;
 372    RgPrgUeSCellLchAddInfo    lchCfgCb;
 373    Pst                       dstInstPst;
 374
 375    TRC2(rgPomSndUeSCellLchAddToSmac);
 376
 377    for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
 378    {
 379       if(TRUE == ue->sCelInfo[idx].isSCellAdded)
 380       {
 381          dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
 382          lchCfgCb.cellId = ue->sCelInfo[idx].sCellId;
 383          lchCfgCb.crnti =  lchCfg->crnti;
 384          lchCfgCb.lcId = lchCfg->lcId;
 385          lchCfgCb.lcType = lchCfg->lcType;
 386          lchCfgCb.dir = lchCfg->dir;
 387          lchCfgCb.dlInfo.dlTrchType = lchCfg->dlInfo.dlTrchType;
 388          lchCfgCb.ulInfo.ulTrchType = lchCfg->ulInfo.ulTrchType;
 389          lchCfgCb.ulInfo.lcgId = lchCfg->ulInfo.lcgId;
 390 #ifdef LTE_L2_MEAS
 391          lchCfgCb.qci = lchCfg->qci;
 392 #endif /* LTE_L2_MEAS */
 393
 394       /* Get post structure of the cell to whom lchCfgCb needs to be sent
 395        * And then send the lch recfg based on Mac instances */
 396          rgGetPstToInst(&dstInstPst, inst, dstMacInst);
 397          RgPrgPMacSMacUeScellLchAdd(&dstInstPst, &lchCfgCb);
 398          *isCfmRqrd = FALSE;
 399       }
 400    }
 401    RETVALUE(ROK);
 402 } /* rgPomSndUeSCellLchAddToSmac */
 403
 404 /**
 405  * @brief Handler for the Lch delete request from PMAC to SMAC.
 406  *
 407  * @details
 408  *
 409  *     Function : RgPrgPMacSMacUeSCellLchDelReq
 410  *
 411  *     Processing Steps:
 412  *      - calls the function for validating cell, uecb and Lch sent by PMAC
 413  *      - If successful, delete the logical channel
 414  *        else Rollback and FAIL.
 415  *
 416  *  @param[in]  Pst                    *pst
 417  *  @param[in]  RgPrgUeSCellLchDelInfo *lchCfgCb
 418  *  @return  S16
 419  *      -# ROK
 420  *      -# RFAILED
 421  **/
 422 #ifdef ANSI
 423 PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq
 424 (
 425 Pst                       *pst,
 426 RgPrgUeSCellLchDelInfo    *delLcCb
 427 )
 428 #else
 429 PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
 430 Pst                       *pst;
 431 RgPrgUeSCellLchDelInfo    *delLcCb;
 432 #endif
 433 {
 434    RgPrgCfgCfmInfo  cfgCfm;
 435    Inst             inst = pst->dstInst;
 436    RgCellCb         *cell;
 437    S16              ret;
 438    Pst              cfmPst;
 439    RgUeCb           *ue;
 440    RgUlLcCb         *ulLc;
 441    RgDlLcCb         *dlLc;
 442
 443    TRC2(RgPrgPMacSMacUeSCellLchDelReq);
 444
 445    RGDBGPRM(inst,(rgPBuf(inst),
 446             "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d\n",
 447          lchCfgCb->cellId, lchCfgCb->crnti));
 448
 449    cfgCfm.ueId = delLcCb->crnti;
 450    cfgCfm.sCellId = delLcCb->cellId;
 451    cfgCfm.status = PRG_CFG_CFM_OK;
 452    cfgCfm.event = EVTPRGUESCELLLCHDELCFM;
 453    rgGetPstToInst(&cfmPst, inst, pst->srcInst);
 454
 455    ret = rgPomVltdDelLch(inst,delLcCb, &cell, &ue,&ulLc,&dlLc);
 456   if(ret != ROK)
 457   {
 458      RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
 459               cellId %d\n", delLcCb->crnti, delLcCb->cellId));
 460      /* Set status as Not OK*/
 461      cfgCfm.status = PRG_CFG_CFM_NOK;
 462   }
 463   else
 464   {
 465      ret = rgPomUeSCellLcDel(inst, delLcCb, ue, ulLc,dlLc);
 466      if(ret != ROK)
 467      {
 468         RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
 469                  cellId %d\n", delLcCb->crnti, delLcCb->cellId));
 470         /* Set status as Not OK*/
 471         cfgCfm.status = PRG_CFG_CFM_NOK;
 472      }
 473   }
 474
 475   RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
 476            cellId %d\n", delLcCb->crnti, delLcCb->cellId));
 477
 478   /* Send positive confirmation to primary cell*/
 479   RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
 480   RETVALUE(ROK);
 481 }  /* RgPrgPMacSMacUeSCellLchDelReq */
 482
 483
 484 /**
 485  * @brief Handler for the Lch configuration request from PMAC to SMAC.
 486  *
 487  * @details
 488  *
 489  *     Function : RgPrgPMacSMacUeSCellLchAddReq
 490  *
 491  *     Processing Steps:
 492  *      - calls the function for validating cell, uecb and Lch sent by PMAC
 493  *      - Updates the lch recfg into ueCb.
 494  *      - If successful, add the control block to hash list of UEs for the cell
 495  *        else Rollback and FAIL.
 496  *
 497  *  @param[in]  Pst                 *pst
 498  *  @param[in]  RgPrgLchRecfgInfo   *lchCfgCb
 499  *  @return  S16
 500  *      -# ROK
 501  *      -# RFAILED
 502  **/
 503 #ifdef ANSI
 504 PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq
 505 (
 506 Pst                      *pst,
 507 RgPrgUeSCellLchAddInfo   *lchCfgCb
 508 )
 509 #else
 510 PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq(pst, lchCfgCb)
 511 Pst                      *pst;
 512 RgPrgUeSCellLchAddInfo   *lchCfgCb;
 513 #endif
 514 {
 515    RgPrgCfgCfmInfo   cfgCfm;
 516    Inst              inst = pst->dstInst;
 517    RgCellCb          *cell;
 518    S16               ret;
 519    Pst               cfmPst;
 520    RgUeCb            *ue;
 521
 522    TRC2(RgPrgPMacSMacUeSCellLchAddReq);
 523
 524    RGDBGPRM(inst,(rgPBuf(inst),
 525             "APPLYING UE SCELL CONFIG AT SMAC : cellId %d ueId %d\n",
 526          lchCfgCb->cellId, lchCfgCb->crnti));
 527
 528    cfgCfm.ueId = lchCfgCb->crnti;
 529    cfgCfm.sCellId = lchCfgCb->cellId;
 530    cfgCfm.status = PRG_CFG_CFM_OK;
 531    cfgCfm.event = EVTPRGUESCELLLCHADDCFM;
 532    rgGetPstToInst(&cfmPst, inst, pst->srcInst);
 533
 534    ret = rgPomVldtAddLch(inst,lchCfgCb, &cell, &ue);
 535   if(ret != ROK)
 536   {
 537      RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
 538               cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
 539      /* Set status as Not OK*/
 540      cfgCfm.status = PRG_CFG_CFM_NOK;
 541   }
 542   else
 543   {
 544      ret = rgPomUeSCellLcAdd(inst, cell, ue, lchCfgCb);
 545      if(ret != ROK)
 546      {
 547         RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
 548                  cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
 549         /* Set status as Not OK*/
 550         cfgCfm.status = PRG_CFG_CFM_NOK;
 551      }
 552   }
 553
 554   RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
 555            cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
 556
 557   /* Send positive confirmation to primary cell*/
 558   RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
 559   RETVALUE(ROK);
 560 }  /* RgPrgPMacSMacUeSCellLchAddReq */
 561 /**
 562  * @brief Validates the logical channel configuration request from PMAC to SMAC.
 563  *
 564  * @details
 565  *
 566  *     Function : rPommVldtAddLch
 567  *
 568  *     Processing Steps:
 569  *      - Validate the logical channel configuration request from PMAC to
 570  *        SMAC : validate if configured values are within the range.
 571  *      - If validated successfully,
 572  *        - Return ROK and pointer to cell and UE for dedicated logical channels.
 573  *      - Else
 574  *        - Return RFAILED.
 575  *
 576  *  @param[in]  Inst                     inst
 577  *  @param[in]  RgPrgUeSCellLchAddInfo   *lcCfg
 578  *  @param[out] RgCellCb                 **cell
 579  *  @param[out] RgUeCb                   **ue
 580  *  @return  S16
 581  *      -# ROK
 582  *      -# RFAILED
 583  **/
 584 #ifdef ANSI
 585 PUBLIC S16 rgPomVldtAddLch
 586 (
 587 Inst                    inst,
 588 RgPrgUeSCellLchAddInfo  *lcCfg,
 589 RgCellCb                **cell,
 590 RgUeCb                  **ue
 591 )
 592 #else
 593 PUBLIC S16 rgPomVldtAddLch(inst,lcCfg, cell, ue)
 594 Inst                    inst;
 595 RgPrgUeSCellLchAddInfo  *lcCfg;
 596 RgCellCb                **cell;
 597 RgUeCb                  **ue;
 598 #endif
 599 {
 600
 601    TRC2(rgPomVldtAddLch);
 602    RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC CONFIG: cellId %d ueId %d lcId %d\
 603             cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti, lcCfg->lcId,
 604             (void*)*cell, (void*)*ue));
 605
 606    if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
 607    {
 608       /* Dedicated logical channels */
 609       if ((rgPomVldtSCellDedLchCfg(inst,lcCfg, cell, ue)) != ROK)
 610       {
 611          RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Validation for dedicated LC failed\n",
 612                   lcCfg->crnti));
 613          RETVALUE(RFAILED);
 614       }
 615    }
 616    else
 617    {
 618       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid logical channel type %d\n",\
 619                lcCfg->crnti, lcCfg->lcType));
 620       RETVALUE(RFAILED);
 621    }
 622 #ifdef LTE_L2_MEAS
 623    if ( lcCfg->qci <  RG_QCI_MIN ||
 624         lcCfg->qci >  RG_QCI_MAX
 625       )
 626    {
 627       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid qci %x\n",
 628                lcCfg->crnti, lcCfg->qci));
 629       RETVALUE(RFAILED);
 630    }
 631    /*validate qci */
 632 #endif /*LTE_L2_MEAS */
 633
 634    RGDBGINFONEW(inst,(rgPBuf(inst),"[%d]UEID CRG LCconfig validation done:cellId:%d lcId:%d\n",
 635             lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
 636    RETVALUE(ROK);
 637 }
 638 /**
 639  * @brief Handler for the logical channel configuration request from
 640  * PMAC to SMAC.
 641  *
 642  * @details
 643  *
 644  *     Function : rgPomUeSCellLcAdd
 645  *
 646  *     Processing Steps:
 647  *      - Update the dedicated logical channel Cb with the configured values.
 648  *      - If successful, return ROK else RFAILED.
 649  *
 650  *  @param[in]  Inst        inst
 651  *  @param[in]  RgCellCb    *cell
 652  *  @param[in]  RgUeCb      *ue
 653  *  @param[in]  CrgLchCfg   *lcCfg
 654  *  @param[out] RgErrInfo   *errInfo
 655  *  @return  S16
 656  *      -# ROK
 657  *      -# RFAILED
 658  **/
 659 #ifdef ANSI
 660 PUBLIC S16 rgPomUeSCellLcAdd
 661 (
 662 Inst                     inst,
 663 RgCellCb                 *cell,
 664 RgUeCb                   *ue,
 665 RgPrgUeSCellLchAddInfo   *lcCfg
 666 )
 667 #else
 668 PUBLIC S16 rgPomUeSCellLcAdd(inst,cell, ue, lcCfg)
 669 Inst                     inst;
 670 RgCellCb                 *cell;
 671 RgUeCb                   *ue;
 672 RgPrgUeSCellLchAddInfo   *lcCfg;
 673 #endif
 674 {
 675
 676    TRC2(rgPomUeSCellLcAdd);
 677    RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC CONFIG: cellId %d ueId %d\
 678             lcId %d dir %d cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti,
 679             lcCfg->lcId, lcCfg->dir, (void*)cell, (void*)ue));
 680
 681       if ((rgPomUeSCellDedLcCfg(cell, ue, lcCfg)) != ROK)
 682       {
 683          RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel configuration"
 684                   "failed in SCell%d\n", lcCfg->crnti, lcCfg->lcId));
 685          RETVALUE(RFAILED);
 686       }
 687
 688    RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]SCell LC config done: cellId %d lcId %d\n",
 689           lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
 690    RETVALUE(ROK);
 691 }  /* rgPomUeSCellLcAdd */
 692
 693 /***********************************************************
 694  *
 695  *     Func : rgPomVldtSCellDedLchCfg
 696  *
 697  *
 698  *     Desc : Validates dedicated logical channel configuration received from PMAC.
 699  *
 700  *     @param[in] Inst                     inst
 701  *     @param[in] RgPrgUeScellLchAddInfo   *lcCfg
 702  *     @param[in] RgCellCb                 **cell
 703  *     @param[in] RgUeCb                   **ue
 704  *
 705  *     Ret  : S16
 706  *            ROK - Success
 707  *            RFAILED - Failed
 708  *
 709  *     Notes:
 710  *
 711  *     File :
 712  *
 713  **********************************************************/
 714 #ifdef ANSI
 715 PRIVATE S16 rgPomVldtSCellDedLchCfg
 716 (
 717 Inst                       inst,
 718 RgPrgUeSCellLchAddInfo     *lcCfg,
 719 RgCellCb                   **cell,
 720 RgUeCb                     **ue
 721 )
 722 #else
 723 PRIVATE S16 rgPomVldtSCellDedLchCfg(inst,lcCfg, cell, ue)
 724 Inst                       inst;
 725 RgPrgUeSCellLchAddInfo     *lcCfg;
 726 RgCellCb                   **cell;
 727 RgUeCb                     **ue;
 728 #endif
 729 {
 730    TRC2(rgPomVldtSCellDedLchCfg);
 731    RGDBGPRM(inst,(rgPBuf(inst), "VALIDATING CRG DEDICATED LC CONFIG \n"));
 732
 733
 734    /* Fetch the Active cell */
 735    if (((*cell = rgCb[inst].cell) == NULLP)
 736       || ((*cell)->cellId != lcCfg->cellId))
 737    {
 738       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist: Cell %d\n",
 739                lcCfg->crnti, lcCfg->cellId));
 740       RETVALUE(RFAILED);
 741    }
 742
 743    /* Fetch the Ue */
 744    if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
 745    {
 746       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE  does not exist for dedicated logical"
 747                "channel %d\n", lcCfg->crnti, lcCfg->lcId));
 748       RETVALUE(RFAILED);
 749    }
 750
 751    /* Validate logical channel Id */
 752    /*if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
 753             ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
 754    {
 755       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid logical channel Id %d\n",
 756                 lcCfg->crnti, lcCfg->lcId));
 757       RETVALUE(RFAILED);
 758    }*/
 759    /* Validate downlink info */
 760    if (lcCfg->dir & PRG_DIR_TX)
 761    {
 762       if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
 763       {
 764          RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated DL LC %d already configured\n",
 765                    lcCfg->crnti, lcCfg->lcId));
 766          RETVALUE(RFAILED);
 767       }
 768 /*      dirVld = TRUE;*/
 769    }
 770
 771    /* Validate uplink info */
 772    if (lcCfg->dir & PRG_DIR_RX)
 773    {
 774       if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
 775       {
 776          RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Invalid lcgId for uplink logical"
 777                   "channel %d\n", lcCfg->crnti, lcCfg->ulInfo.lcgId));
 778          RETVALUE(RFAILED);
 779       }
 780       if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
 781       {
 782          RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated UL LC %d already configured\n",
 783                    lcCfg->crnti, lcCfg->lcId));
 784          RETVALUE(RFAILED);
 785       }
 786 /*      dirVld = TRUE;*/
 787    }
 788 /*
 789    if (!dirVld)
 790    {
 791       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid Direction %d \n",
 792                lcCfg->crnti, lcCfg->dir));
 793       RETVALUE(RFAILED);
 794    }
 795 */
 796    RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel %d validated"
 797             "for cell %d\n", lcCfg->crnti, lcCfg->lcId, lcCfg->cellId));
 798    RETVALUE(ROK);
 799 }  /* rgPomVldtSCellDedLchCfg */
 800 /***********************************************************
 801  *
 802  *     Func : rgPomUeSCellDedLcCfg
 803  *
 804  *
 805  *     Desc : Validates dedicated logical channel configuration received from PMAC.
 806  *
 807  *     @param[in] RgCellCb                 *cell
 808  *     @param[in] RgUeCb                   *ue
 809  *     @param[in] RgPrgUeSCellLchAddInfo   *lcCfg
 810  *
 811  *     Ret  : S16
 812  *            ROK - Success
 813  *            RFAILED - Failed
 814  *
 815  *     Notes:
 816  *
 817  *     File :
 818  *
 819  **********************************************************/
 820 #ifdef ANSI
 821 PRIVATE S16 rgPomUeSCellDedLcCfg
 822 (
 823 RgCellCb                   *cell,
 824 RgUeCb                     *ue,
 825 RgPrgUeSCellLchAddInfo     *lcCfg
 826 )
 827 #else
 828 PRIVATE S16 rgPomUeSCellDedLcCfg(cell, ue, lcCfg)
 829 RgCellCb                   *cell;
 830 RgUeCb                     *ue;
 831 RgPrgUeSCellLchAddInfo     *lcCfg;
 832 #endif
 833 {
 834    //Inst     inst = cell->macInst - RG_INST_START;
 835    TRC2(rgPomUeSCellDedLcCfg);
 836    //RGDBGPRM(inst,(rgPBuf(inst), "APPLYING DEDICATED LC CONFIG\n"));
 837
 838    /* Uplink/Bi-directional logical channel */
 839    if (lcCfg->dir & PRG_DIR_RX)
 840    {
 841 #ifdef LTE_L2_MEAS
 842       rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
 843       cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
 844       if(lcCfg->lcType == CM_LTE_LCH_DTCH)
 845       {
 846         rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
 847       }
 848 #else
 849       rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
 850 #endif
 851    }
 852
 853    /* Downlink/Bi-directional logical channel */
 854    if (lcCfg->dir & PRG_DIR_TX)
 855    {
 856       rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
 857    }
 858    RGDBGINFO(inst,(rgPBuf(inst), "Dedicated LC config done\n"));
 859    RETVALUE(ROK);
 860
 861   }  /* rgPomUeSCellDedLcCfg */
 862 /**
 863  * @brief Function to validate SCellLchReCfg.
 864  *
 865  * @details
 866  *
 867  *     Function : rgPomVltdModLch
 868  *
 869  *
 870  *  @param[in] inst        instance number to fetch rgCb instance
 871  *  @param[in] lchCfg Cb   lchCfg CB for validation
 872  *  @param[out] cell        cell control block
 873  *  @param[out] RgCellCb     **cell
 874  *  @param[out] RgUeCb       **ue
 875  *  @param[out] RgUlLcCb     **ulLc
 876  *  @return  S16
 877  *      -# ROK
 878  **/
 879 #ifdef ANSI
 880 PUBLIC S16 rgPomVltdModLch
 881 (
 882  Inst                     inst,
 883  RgPrgUeSCellLchModInfo   *lchCfgCb,
 884  RgCellCb                 **cell,
 885  RgUeCb                   **ue,
 886  RgUlLcCb                 **ulLc
 887 )
 888 #else
 889 PUBLIC S16 rgPomVltdModLch(inst, lchCfgCb, cell, ue, ulLc)
 890  Inst                     inst;
 891  RgPrgUeSCellLchModInfo   *lchCfgCb;
 892  RgCellCb                 **cell;
 893  RgUeCb                   **ue;
 894  RgUlLcCb                 **ulLc;
 895 #endif
 896 {
 897    TRC2(rgPomVltdModLch);
 898    RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
 899             lcId %d cell %p ue %p ulLc %p\n",lchCfgCb->cellId,
 900             lchCfgCb->crnti,lchCfgCb->lcId, (void*)*cell, (void*)*ue,
 901             (void*)*ulLc));
 902    /* Fetch the cell */
 903    if ((((*cell = rgCb[inst].cell)) == NULLP)
 904          || ((*cell)->cellId != lchCfgCb->cellId))
 905    {
 906       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",lchCfgCb->crnti, lchCfgCb->cellId));
 907       RETVALUE(RFAILED);
 908    }
 909    /* Fetch the Ue for dedicated channels */
 910    if ((*ue = rgDBMGetUeCb(*cell, lchCfgCb->crnti)) == NULLP)
 911    {
 912       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
 913                lchCfgCb->crnti));
 914       RETVALUE(RFAILED);
 915    }
 916    if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lchCfgCb->lcId)) == NULLP)
 917    {
 918       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
 919                lchCfgCb->crnti, lchCfgCb->lcId));
 920       RETVALUE(RFAILED);
 921    }
 922   /* if (lchCfgCb->ulLchRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
 923    {
 924       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid lcgId for uplink logical channel: lcg %d"
 925                "lc %d\n",lchCfgCb->crnti, lchCfgCb->ulLchRecfg.lcgId, lchCfgCb->lcId));
 926       RETVALUE(RFAILED);
 927    }*/
 928    RETVALUE(ROK);
 929 } /*rgPomVltdModLch*/
 930 /**
 931  * @brief Handler for the logical channel re-configuration request from
 932  * PMAC to SMAC.
 933  *
 934  * @details
 935  *
 936  *     Function : rgPomUeSCellLcMod
 937  *
 938  *     Processing Steps:
 939  *      - Update the dedicated logical channel Cb with the re-configured
 940  *        values.
 941  *      - If successful, return ROK else RFAILED.
 942  *
 943  *  @param[in]  Inst              inst
 944  *  @param[in]  RgUlUeCb          *ue
 945  *  @param[in]  RgUlLcCb          *ulLc
 946  *  @param[in]  RgPrgLchRecfgInfo *lchCfgCb
 947  *  @return  S16
 948  *      -# ROK
 949  *      -# RFAILED
 950  **/
 951 #ifdef ANSI
 952 PUBLIC S16 rgPomUeSCellLcMod
 953 (
 954 Inst                    inst,
 955 RgUeCb                  *ue,
 956 RgUlLcCb                *ulLc,
 957 RgPrgUeSCellLchModInfo  *lchCfgCb
 958 )
 959 #else
 960 PUBLIC S16 rgPomUeSCellLcMod(inst,cell, ue, ulLc, lchCfgCb)
 961 Inst                    inst;
 962 RgUeCb                  *ue;
 963 RgUlLcCb                *ulLc;
 964 RgPrgUeSCellLchModInfo  *lchCfgCb;
 965 #endif
 966 {
 967    TRC2(rgPomUeSCellLcMod);
 968    RGDBGPRM(inst,(rgPBuf(inst), "APPLYING SMAC LC RECONFIG: cellId %d ueId %d\
 969             lcId %d  \n",
 970             lchCfgCb->cellId, lchCfgCb->crnti, lchCfgCb->lcId));
 971
 972    if (ulLc->lcgId != lchCfgCb->ulLchRecfg.lcgId)
 973    {
 974       rgDBMUpdUlDedLcCb(ue, ulLc, lchCfgCb->ulLchRecfg.lcgId);
 975    }
 976
 977    RGDBGINFO(inst,(rgPBuf(inst), "LC %d of Ue %d of cell %d Reconfigured\n",
 978             lchCfgCb->lcId, ue->ueId, cell->cellId));
 979    RETVALUE(ROK);
 980 }  /* rgPomUeSCellLcMod */
 981 /**
 982  * @brief Function to validate SCellLchDel.
 983  *
 984  * @details
 985  *
 986  *     Function : rgPomVltdDelLch
 987  *
 988  *
 989  *  @param[in] inst        instance number to fetch rgCb instance
 990  *  @param[in] lchCfg Cb   lchCfg CB for validation
 991  *  @param[out] cell        cell control block
 992  *  @param[out] RgCellCb     **cell
 993  *  @param[out] RgUeCb       **ue
 994  *  @param[out] RgUlLcCb     **ulLc
 995  *  @return  S16
 996  *      -# ROK
 997  **/
 998 #ifdef ANSI
 999 PUBLIC S16 rgPomVltdDelLch
1000 (
1001  Inst                      inst,
1002  RgPrgUeSCellLchDelInfo    *delLcCb,
1003  RgCellCb                  **cell,
1004  RgUeCb                    **ue,
1005  RgUlLcCb                  **ulLc,
1006  RgDlLcCb                  **dlLc
1007 )
1008 #else
1009 PUBLIC S16 rgPomVltdDelLch(inst, delLcCb, cell, ue, ulLc, dlLc)
1010  Inst                      inst;
1011  RgPrgUeSCellLchDelInfo    *delLcCb;
1012  RgCellCb                  **cell;
1013  RgUeCb                    **ue;
1014  RgUlLcCb                  **ulLc;
1015  RgDlLcCb                  **dlLc;
1016 #endif
1017 {
1018    TRC2(rgPomVltdDelLch);
1019    RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
1020             lcId %d cell %p ue %p ulLc %p\n",delLcCb->cellId,
1021             delLcCb->crnti,delLcCb->lcId, (void*)*cell, (void*)*ue,
1022             (void*)*ulLc));
1023    /* Fetch the cell */
1024    if ((((*cell = rgCb[inst].cell)) == NULLP)
1025          || ((*cell)->cellId != delLcCb->cellId))
1026    {
1027       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",delLcCb->crnti, delLcCb->cellId));
1028       RETVALUE(RFAILED);
1029    }
1030    /* Fetch the Ue for dedicated channels */
1031    if ((*ue = rgDBMGetUeCb(*cell, delLcCb->crnti)) == NULLP)
1032    {
1033       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
1034                delLcCb->crnti));
1035       RETVALUE(RFAILED);
1036    }
1037    if ((*ulLc = rgDBMGetUlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
1038    {
1039       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
1040                delLcCb->crnti, delLcCb->lcId));
1041       RETVALUE(RFAILED);
1042    }
1043    if ((*dlLc = rgDBMGetDlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
1044    {
1045          RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]DL LC %d does not exist\n",
1046                delLcCb->crnti, delLcCb->lcId));
1047          RETVALUE(RFAILED);
1048    }
1049    RETVALUE(ROK);
1050 } /*rgPomVltdDelLch*/
1051 /**
1052  * @brief Handler for the logical channel delete request from
1053  * PMAC to SMAC.
1054  *
1055  * @details
1056  *
1057  *     Function : rgPomUeSCellLcDel
1058  *
1059  *     Processing Steps:
1060  *      - Fetch the logical channel control block.
1061  *      - Free the logical channel control block.
1062  *      - If successful, return ROK else return RFAILED.
1063  *
1064  *  @param[in]  Inst                      inst
1065  *  @param[in]  RgPrgUeSCellLchDelInfo    *delLcCb
1066  *  @param[in]  RgUeCb                    *ue
1067  *  @param[in]  RgUlLcCb                  *ulLc
1068  *  @return  S16
1069  *      -# ROK
1070  *      -# RFAILED
1071  **/
1072 #ifdef ANSI
1073 PUBLIC S16 rgPomUeSCellLcDel
1074 (
1075 Inst                      inst,
1076 RgPrgUeSCellLchDelInfo    *delLcCb,
1077 RgUeCb                    *ue,
1078 RgUlLcCb                  *ulLc,
1079 RgDlLcCb                  *dlLc
1080 )
1081 #else
1082 PUBLIC S16 rgPomUeSCellLcDel(inst,delLcCb,ue,ulLc,dlLc)
1083 Inst                      inst;
1084 RgPrgUeSCellLchDelInfo    *delLcCb;
1085 RgUeCb                    *ue;
1086 RgUlLcCb                  *ulLc;
1087 RgDlLcCb                  *dlLc;
1088 #endif
1089 {
1090
1091    TRC2(rgPomUeSCellLcDel);
1092    RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC DELETE: cellId %d ueId %d\
1093             lcId %d dir %d\n", delLcCb->cellId,
1094             delLcCb->crnti, delLcCb->lcId,
1095             delLcCb->dir));
1096
1097
1098    /* Validate downlink info */
1099    if (delLcCb->dir & PRG_DIR_TX)
1100    {
1101       rgDBMDelDlDedLcCb(ue, dlLc);
1102 /*      dirVld = TRUE;*/
1103    }
1104
1105    /* Validate uplink info */
1106    if (delLcCb->dir & PRG_DIR_RX)
1107    {
1108       rgDBMDelUlDedLcCb(ue, ulLc);
1109 /*      dirVld = TRUE;*/
1110    }
1111
1112    /*if (!dirVld)
1113    {
1114       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid direction %d for LC Delete\n",
1115             delLcCb->crnti, delLcCb->dir));
1116       RETVALUE(RFAILED);
1117    }*/
1118    RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]UE's Logical channel %d deleted from cell %d\n",
1119          delLcCb->crnti, delLcCb->lcId,
1120          delLcCb->cellId));
1121    RETVALUE(ROK);
1122 }  /* rgPomUeSCellLcDel */
1123 #endif /*LTE_ADV */
1124 /**********************************************************************
1125
1126          End of file
1127 **********************************************************************/