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