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