src/5gnrmac/rg_cfg.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 fucntions
  26
  27      File:     rg_cfg.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_cfg.c
  32 @brief This module handles the configuration of MAC by RRC and RRM.
  33 */
  34
  35 static const char* RLOG_MODULE_NAME="MAC";
  36 static int RLOG_FILE_ID=180;
  37 static int RLOG_MODULE_ID=4096;
  38
  39 /* header include files -- defines (.h) */
  40 #include "common_def.h"
  41 #include "lrg.h"           /* Layer manager interface includes*/
  42 #include "crg.h"           /* CRG interface includes*/
  43 #include "rgu.h"           /* RGU interface includes*/
  44 #include "tfu.h"           /* TFU interface includes */
  45 #include "rg_sch_inf.h"    /* SCH interface includes */
  46 #include "rg_prg.h"       /* PRG (MAC-MAC) interface includes*/
  47 #include "rg_env.h"       /* MAC environmental includes*/
  48 #include "rg.h"           /* MAC includes*/
  49 #include "rg_err.h"       /* MAC error includes*/
  50
  51 /* header/extern include files (.x) */
  52 #include "rgu.x"           /* RGU types */
  53 #include "tfu.x"           /* RGU types */
  54 #include "lrg.x"           /* layer management typedefs for MAC */
  55 #include "crg.x"           /* CRG interface includes */
  56 #include "rg_sch_inf.x"    /* SCH interface typedefs */
  57 #include "rg_prg.x"        /* PRG (MAC-MAC) Interface typedefs */
  58 #include "du_app_mac_inf.h"
  59 #include "rg.x"            /* typedefs for MAC */
  60 #ifdef LTE_ADV
  61 #include "rg_pom_scell.x"
  62 #endif
  63 /* LTE-MAC Control Block Structure */
  64 PUBLIC RgCb rgCb[RG_MAX_INST];
  65
  66 /* local defines */
  67 PRIVATE S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
  68          RgUeCb **ue, RgErrInfo *errInfo));
  69 PRIVATE S16 rgCFGVldtCrgCmnLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
  70          RgErrInfo *errInfo));
  71 PRIVATE S16 rgCFGCrgDedLcCfg ARGS((RgCellCb *cell, RgUeCb *ue,
  72          CrgLchCfg *lcCfg, RgErrInfo *errInfo));
  73 PRIVATE S16 rgCFGCrgCmnLcCfg ARGS((Inst inst,RgCellCb *cell, CrgLchCfg *lcCfg,
  74          RgErrInfo *errInfo));
  75
  76 PRIVATE Void rgCFGFreeCmnLcLst ARGS((RgCellCb *cell));
  77 PRIVATE Void rgCFGFreeUeLst ARGS((RgCellCb *cell));
  78 /* Added support for SPS*/
  79 #ifdef LTEMAC_SPS
  80 PRIVATE Void rgCFGFreeSpsUeLst ARGS((RgCellCb *cell));
  81 #endif /* LTEMAC_SPS */
  82
  83
  84 /* local typedefs */
  85
  86 /* local externs */
  87
  88 /* forward references */
  89
  90
  91
  92
  93 /**
  94  * @brief Validates the cell configuration request from RRC to MAC.
  95  *
  96  * @details
  97  *
  98  *     Function : rgCFGVldtCrgCellCfg
  99  *
 100  *     Processing Steps:
 101  *      - Validate the cell configuration request from RRC to MAC at CFG:
 102  *        validate the value range for the configured values.
 103  *      - If validated successfully,
 104  *        - Return ROK.
 105  *      - Else
 106  *        - Return RFAILED.
 107  *
 108  *  @param[in]  Inst        inst
 109  *  @param[in]  CrgCellCfg  *cellCfg
 110  *  @param[out] RgErrInfo   *errInfo
 111  *  @return  S16
 112  *      -# ROK
 113  *      -# RFAILED
 114  **/
 115 #ifdef ANSI
 116 PUBLIC S16 rgCFGVldtCrgCellCfg
 117 (
 118 Inst        inst,
 119 CrgCellCfg  *cellCfg,
 120 RgErrInfo   *errInfo
 121 )
 122 #else
 123 PUBLIC S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
 124 Inst        inst;
 125 CrgCellCfg  *cellCfg;
 126 RgErrInfo   *errInfo;
 127 #endif
 128 {
 129    TRC2(rgCFGVldtCrgCellCfg);
 130
 131    errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
 132    if ((rgCb[inst].cell != NULLP)
 133          || rgCb[inst].inactiveCell != NULLP)
 134    {
 135       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell already exists");
 136       RETVALUE(RFAILED);
 137    }
 138    if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
 139             || cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
 140          || (cellCfg->bwCfg.ulTotalBw < RG_MIN_UL_BW
 141             || cellCfg->bwCfg.ulTotalBw > RG_MAX_UL_BW))
 142    {
 143       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,
 144             "Invalid Bandwidth configuration: ul %d dl %d",
 145             cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
 146       RETVALUE(RFAILED);
 147    }
 148    if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
 149    {
 150       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,
 151                 "Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
 152       RETVALUE(RFAILED);
 153    }
 154 #ifdef TENB_MULT_CELL_SUPPRT
 155    if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
 156       (cellCfg->rguUlSapId > rgCb[inst].numRguSaps))
 157    {
 158       RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for CellId %d failed\n",
 159                cellCfg->rguDlSapId,
 160                cellCfg->rguUlSapId,
 161                cellCfg->cellId));
 162       RETVALUE(RFAILED);
 163    }
 164 #endif
 165    errInfo->errCause = RGERR_NONE;
 166    RETVALUE(ROK);
 167 }  /* rgCFGVldtCrgCellCfg */
 168
 169
 170 /**
 171  * @brief Validates the UE configuration request from RRC to MAC.
 172  *
 173  * @details
 174  *
 175  *     Function : rgCFGVldtCrgUeCfg
 176  *
 177  *     Processing Steps:
 178  *      - Validate the UE configuration request from RRC to MAC at CFG:
 179  *        validate the value range for the configured values.
 180  *      - If validated successfully,
 181  *        - Return ROK and pointer to the cell of UE.
 182  *      - Else
 183  *        - Return RFAILED.
 184  *
 185  *  @param[in]  Inst        inst
 186  *  @param[in]  CrgUeCfg  *ueCfg
 187  *  @param[out] RgCellCb  **cell
 188  *  @param[out] RgErrInfo *errInfo
 189  *  @return  S16
 190  *      -# ROK
 191  *      -# RFAILED
 192  **/
 193 #ifdef ANSI
 194 PUBLIC S16 rgCFGVldtCrgUeCfg
 195 (
 196 Inst      inst,
 197 CrgUeCfg  *ueCfg,
 198 RgCellCb  **cell,
 199 RgErrInfo *errInfo
 200 )
 201 #else
 202 PUBLIC S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
 203 Inst      inst;
 204 CrgUeCfg  *ueCfg;
 205 RgCellCb  **cell;
 206 RgErrInfo *errInfo;
 207 #endif
 208 {
 209    TRC2(rgCFGVldtCrgUeCfg);
 210
 211    errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
 212    if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
 213        (ueCfg->txMode.tm == CRG_UE_TM_5))
 214    {
 215       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Transmission Mode=%d not supported",
 216             ueCfg->txMode.tm);
 217       RETVALUE(RFAILED);
 218    }
 219
 220    /* Fetch the Active cell */
 221    if(((*cell = rgCb[inst].cell) == NULLP) ||
 222        ((*cell)->cellId != ueCfg->cellId))
 223    {
 224       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Active Cell does not exist for cellId%d",
 225             ueCfg->cellId);
 226       RETVALUE(RFAILED);
 227    }
 228    /* Check if Ue already configured */
 229    if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
 230    {
 231       RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Ue already exists");
 232       RETVALUE(RFAILED);
 233    }
 234
 235    if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
 236    {
 237       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "Invalid Uplink HARQ config %d ",
 238             ueCfg->ueUlHqCfg.maxUlHqTx);
 239       RETVALUE(RFAILED);
 240    }
 241 #ifdef TENB_MULT_CELL_SUPPRT
 242    if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
 243       (ueCfg->rguUlSapId > rgCb[inst].numRguSaps))
 244    {
 245       RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for ueId %d failed\n",
 246                ueCfg->rguDlSapId,
 247                ueCfg->rguUlSapId,
 248                ueCfg->crnti));
 249       RETVALUE(RFAILED);
 250    }
 251 #endif
 252
 253    errInfo->errCause = RGERR_NONE;
 254    RETVALUE(ROK);
 255 }  /* rgCFGVldtCrgUeCfg */
 256
 257
 258 /**
 259  * @brief Validates the logical channel configuration request from RRC to MAC.
 260  *
 261  * @details
 262  *
 263  *     Function : rgCFGVldtCrgLcCfg
 264  *
 265  *     Processing Steps:
 266  *      - Validate the logical channel configuration request from RRC to
 267  *        MAC at CFG: validate if configured values are within the range.
 268  *      - If validated successfully,
 269  *        - Return ROK and pointer to the cell for common channels. Return
 270  *          pointer to cell and UE for dedicated logical channels.
 271  *      - Else
 272  *        - Return RFAILED.
 273  *
 274  *  @param[in]  CrgLchCfg  *lcCfg
 275  *  @param[in]  Inst        inst
 276  *  @param[out] RgCellCb   **cell
 277  *  @param[out] RgUeCb     **ue
 278  *  @param[out] RgErrInfo  *errInfo
 279  *  @return  S16
 280  *      -# ROK
 281  *      -# RFAILED
 282  **/
 283 #ifdef ANSI
 284 PUBLIC S16 rgCFGVldtCrgLcCfg
 285 (
 286 Inst       inst,
 287 CrgLchCfg  *lcCfg,
 288 RgCellCb   **cell,
 289 RgUeCb     **ue,
 290 RgErrInfo  *errInfo
 291 )
 292 #else
 293 PUBLIC S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
 294 Inst       inst;
 295 CrgLchCfg  *lcCfg;
 296 RgCellCb   **cell;
 297 RgUeCb     **ue;
 298 RgErrInfo  *errInfo;
 299 #endif
 300 {
 301
 302    TRC2(rgCFGVldtCrgLcCfg);
 303
 304    if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
 305    {
 306       /* Dedicated logical channels */
 307       if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
 308       {
 309          RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for dedicated LC failed");
 310          RETVALUE(RFAILED);
 311       }
 312    }
 313    else if (lcCfg->lcType == CM_LTE_LCH_BCCH
 314          || lcCfg->lcType == CM_LTE_LCH_PCCH
 315          || lcCfg->lcType == CM_LTE_LCH_CCCH)
 316    {
 317       if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
 318       {
 319          RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for common logical channels failed");
 320          RETVALUE(RFAILED);
 321       }
 322    }
 323    else
 324    {
 325       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel type %d",
 326                 lcCfg->lcType);
 327       RETVALUE(RFAILED);
 328    }
 329 #ifdef LTE_L2_MEAS
 330    if ( lcCfg->qci <  RG_QCI_MIN ||
 331         lcCfg->qci >  RG_QCI_MAX
 332       )
 333    {
 334       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid qci %x",lcCfg->qci);
 335       RETVALUE(RFAILED);
 336    }
 337    /*validate qci */
 338 #endif /*LTE_L2_MEAS */
 339
 340    errInfo->errCause = RGERR_NONE;
 341    RETVALUE(ROK);
 342 }  /* rgCFGVldtCrgLcCfg */
 343
 344
 345 /**
 346  * @brief Validates the cell re-configuration request from RRC to MAC.
 347  *
 348  * @details
 349  *
 350  *     Function : rgCFGVldtCrgCellRecfg
 351  *
 352  *     Processing Steps:
 353  *      - Retrieve the cell control block.
 354  *      - If successful,
 355  *        - Validate the range of re-configured values recieved in
 356  *          re-configuration request.
 357  *        - If validated successfully,
 358  *          - Return ROK and pointer to the cell.
 359  *        - Else
 360  *          - Return RFAILED.
 361  *      - Else return RFAILED.
 362  *
 363  *  @param[in]  Inst        inst
 364  *  @param[in]  CrgCellRecfg  *cellRecfg
 365  *  @param[out] RgCellCb      **cell
 366  *  @param[out] RgErrInfo     *errInfo
 367  *  @return  S16
 368  *      -# ROK
 369  *      -# RFAILED
 370  **/
 371 #ifdef ANSI
 372 PUBLIC S16 rgCFGVldtCrgCellRecfg
 373 (
 374 Inst          inst,
 375 CrgCellRecfg  *cellRecfg,
 376 RgCellCb      **cell,
 377 RgErrInfo     *errInfo
 378 )
 379 #else
 380 PUBLIC S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
 381 Inst          inst;
 382 CrgCellRecfg  *cellRecfg;
 383 RgCellCb      **cell;
 384 RgErrInfo     *errInfo;
 385 #endif
 386 {
 387    TRC2(rgCFGVldtCrgCellRecfg);
 388
 389    errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
 390
 391    if (((*cell = rgCb[inst].cell) == NULLP)
 392          && ((*cell = rgCb[inst].inactiveCell) == NULLP))
 393    {
 394       RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell does not exist");
 395       RETVALUE(RFAILED);
 396    }
 397
 398    if((*cell)->cellId != cellRecfg->cellId)
 399    {
 400       RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId, "Cell does not exist %d\n",cellRecfg->cellId);
 401       RETVALUE(RFAILED);
 402    }
 403    if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
 404    {
 405       RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,
 406                 "Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
 407       RETVALUE(RFAILED);
 408    }
 409    errInfo->errCause = RGERR_NONE;
 410    RETVALUE(ROK);
 411 }  /* rgCFGVldtCrgCellRecfg */
 412
 413
 414 /**
 415  * @brief Validates the UE re-configuration request from RRC to MAC.
 416  *
 417  * @details
 418  *
 419  *     Function : rgCFGVldtCrgUeRecfg
 420  *
 421  *     Processing Steps:
 422  *      - Retrieve the UE control block.
 423  *      - If successful,
 424  *        - Validate the range of re-configured values recieved in
 425  *          re-configuration request.
 426  *        - If validated successfully,
 427  *          - Return ROK and pointer to the cell and ue.
 428  *        - Else
 429  *          - Return RFAILED.
 430  *      - Else return RFAILED.
 431  *
 432  *  @param[in]  Inst        inst
 433  *  @param[in]  CrgUeRecfg *ueRecfg
 434  *  @param[out] RgCellCb   **cell
 435  *  @param[out] RgUeCb     **ue
 436  *  @param[out] RgErrInfo *errInfo
 437  *  @return  S16
 438  *      -# ROK
 439  *      -# RFAILED
 440  **/
 441 #ifdef ANSI
 442 PUBLIC S16 rgCFGVldtCrgUeRecfg
 443 (
 444 Inst        inst,
 445 CrgUeRecfg  *ueRecfg,
 446 RgCellCb    **cell,
 447 RgUeCb      **ue,
 448 RgErrInfo   *errInfo
 449 )
 450 #else
 451 PUBLIC S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
 452 Inst        inst;
 453 CrgUeRecfg  *ueRecfg;
 454 RgCellCb    **cell;
 455 RgUeCb      **ue;
 456 RgErrInfo   *errInfo;
 457 #endif
 458 {
 459    TRC2(rgCFGVldtCrgUeRecfg);
 460
 461    errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
 462
 463    if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
 464        (ueRecfg->txMode.tm == CRG_UE_TM_5))
 465    {
 466       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Transmission Mode=%d not supported",
 467                 ueRecfg->txMode.tm);
 468       RETVALUE(RFAILED);
 469    }
 470
 471     /* Fetch the Active cell */
 472    if (((*cell = rgCb[inst].cell) == NULLP)
 473         || ((*cell)->cellId != ueRecfg->cellId))
 474    {
 475       RLOG_ARG0(L_ERROR,DBG_CELLID,ueRecfg->cellId, "Active Cell does not exist\n");
 476       RETVALUE(RFAILED);
 477    }
 478
 479    /* Fix : syed UE ID change at MAC will now be controlled
 480     * by SCH. */
 481    if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
 482    {
 483       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"[%d]Old Ue does not exist", ueRecfg->oldCrnti);
 484       RETVALUE(RFAILED);
 485    }
 486    if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
 487    {
 488       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config for UE %d",
 489             ueRecfg->ueUlHqRecfg.maxUlHqTx);
 490       RETVALUE(RFAILED);
 491    }
 492    errInfo->errCause = RGERR_NONE;
 493    RETVALUE(ROK);
 494 }  /* rgCFGVldtCrgUeRecfg */
 495
 496
 497 /**
 498  * @brief Validates the logical channel re-configuration request from
 499  * RRC to MAC.
 500  *
 501  * @details
 502  *
 503  *     Function : rgCFGVldtCrgLcRecfg
 504  *
 505  *     Processing Steps:
 506  *      - Retrieve the uplink and downlink logical channel control block.
 507  *      - If successful,
 508  *        - Validate the range of re-configured values recieved in
 509  *          re-configuration request.
 510  *        - If validated successfully,
 511  *          - Return ROK and pointer to the cell, UE and logical channel.
 512  *        - Else
 513  *          - Return RFAILED.
 514  *      - Else return RFAILED.
 515  *
 516  *  @param[in]  Inst        inst
 517  *  @param[in]  CrgLchRecfg  *lcRecfg
 518  *  @param[out] RgCellCb     **cell
 519  *  @param[out] RgUeCb       **ue
 520  *  @param[out] RgUlLcCb     **ulLc
 521  *  @param[out] RgDlLcCb     **dlLc
 522  *  @param[out] RgErrInfo    *errInfo
 523  *  @return  S16
 524  *      -# ROK
 525  *      -# RFAILED
 526  **/
 527 #ifdef ANSI
 528 PUBLIC S16 rgCFGVldtCrgLcRecfg
 529 (
 530 Inst        inst,
 531 CrgLchRecfg *lcRecfg,
 532 RgCellCb    **cell,
 533 RgUeCb      **ue,
 534 RgUlLcCb    **ulLc,
 535 RgErrInfo   *errInfo
 536 )
 537 #else
 538 PUBLIC S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
 539 Inst        inst;
 540 CrgLchRecfg  *lcRecfg;
 541 RgCellCb     **cell;
 542 RgUeCb       **ue;
 543 RgUlLcCb     **ulLc;
 544 RgErrInfo    *errInfo;
 545 #endif
 546 {
 547    TRC2(rgCFGVldtCrgLcRecfg);
 548
 549    errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
 550
 551    /* Fetch the cell */
 552    if ((((*cell = rgCb[inst].cell)) == NULLP)
 553       || ((*cell)->cellId != lcRecfg->cellId))
 554    {
 555       RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
 556       RETVALUE(RFAILED);
 557    }
 558    /* Fetch the Ue for dedicated channels */
 559    if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
 560    {
 561       RLOG_ARG0(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Ue does not exist for dedicated logical channel");
 562       RETVALUE(RFAILED);
 563    }
 564
 565    if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
 566    {
 567       RLOG_ARG1(L_ERROR, DBG_CRNTI,lcRecfg->crnti,"Dedicated UL LC does not exist %d",lcRecfg->lcId);
 568       RETVALUE(RFAILED);
 569    }
 570
 571    if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
 572    {
 573       RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Invalid lcgId for uplink logical channel lcg %d lc %d",
 574                 lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
 575       RETVALUE(RFAILED);
 576    }
 577
 578    errInfo->errCause = RGERR_NONE;
 579    RETVALUE(ROK);
 580 }  /* rgCFGVldtCrgLcRecfg */
 581
 582 /* Start: LTEMAC_2.1_DEV_CFG */
 583 /**
 584  * @brief Validates the UE Reset request from RRC to MAC.
 585  *
 586  * @details
 587  *
 588  *     Function : rgCFGVldtCrgUeReset
 589  *
 590  *     Processing Steps:
 591  *      - Retrieve the CELL control block.
 592  *      - If Failue,
 593  *          - Return RFAILED.
 594  *      - Retrieve the UE control block.
 595  *      - If Failue,
 596  *          - Return RFAILED.
 597  *
 598  *  @param[in]  Inst        inst
 599  *  @param[in]  CrgRst     *reset,
 600  *  @param[out] RgCellCb   **cell
 601  *  @param[out] RgUeCb     **ue
 602  *  @param[out] RgErrInfo *errInfo
 603  *  @return  S16
 604  *      -# ROK
 605  *      -# RFAILED
 606  **/
 607 #ifdef ANSI
 608 PUBLIC S16 rgCFGVldtCrgUeReset
 609 (
 610 Inst       inst,
 611 CrgRst     *reset,
 612 RgCellCb    **cell,
 613 RgUeCb      **ue,
 614 RgErrInfo   *errInfo
 615 )
 616 #else
 617 PUBLIC S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
 618 Inst       inst;
 619 CrgRst     *reset;
 620 RgCellCb    **cell;
 621 RgUeCb      **ue;
 622 RgErrInfo   *errInfo;
 623 #endif
 624 {
 625    TRC2(rgCFGVldtCrgUeReset);
 626
 627    errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
 628
 629    /* Fetch the Active cell */
 630    if (((*cell = rgCb[inst].cell) == NULLP)
 631       || ((*cell)->cellId != reset->cellId))
 632    {
 633       RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",reset->crnti, reset->cellId));
 634       RLOG_ARG1(L_ERROR,DBG_CRNTI,reset->crnti,"Active Cell does not exist %d",reset->cellId);
 635       RETVALUE(RFAILED);
 636    }
 637
 638    /* Fetch the Ue */
 639    if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
 640    {
 641       RLOG_ARG0(L_ERROR,DBG_CRNTI,reset->crnti,"UE does not exist");
 642       RETVALUE(RFAILED);
 643    }
 644
 645    errInfo->errCause = RGERR_NONE;
 646    RETVALUE(ROK);
 647 }  /* rgCFGVldtCrgUeReset*/
 648 /* End: LTEMAC_2.1_DEV_CFG */
 649
 650
 651
 652 /**
 653  * @brief Handler for the cell configuration request from RRC to MAC.
 654  *
 655  * @details
 656  *
 657  *     Function : rgCFGCrgCellCfg
 658  *
 659  *     Processing Steps:
 660  *      - Allocate and create cell control block.
 661  *      - Update cell control block with the values recieved in the
 662  *        configuration.
 663  *      - Add the control block to hash list of cells.
 664  *      - Update the statistics.
 665  *      - If successful, return ROK else return RFAILED.
 666  *
 667  *  @param[in]  Inst        inst
 668  *  @param[in]  CrgCellCfg  *cellCfg
 669  *  @param[out] RgErrInfo   *errInfo
 670  *  @return  S16
 671  *      -# ROK
 672  *      -# RFAILED
 673  **/
 674 #ifdef ANSI
 675 PUBLIC S16 rgCFGCrgCellCfg
 676 (
 677 Inst        inst,
 678 CrgCellCfg  *cellCfg,
 679 RgErrInfo   *errInfo
 680 )
 681 #else
 682 PUBLIC S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
 683 Inst        inst;
 684 CrgCellCfg  *cellCfg;
 685 RgErrInfo   *errInfo;
 686 #endif
 687 {
 688    S16        ret;
 689    RgCellCb   *cell = NULLP;
 690    U8         idx;
 691    SuId       rguUlSapId = 0;
 692    SuId       rguDlSapId = 0;
 693    /* RLC SAP to allocate flowCntrlInd buffer*/
 694    Pst        *pst ;
 695
 696    TRC2(rgCFGCrgCellCfg);
 697
 698    errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
 699
 700    /* Allocate the cell control block */
 701    if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
 702    {
 703       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
 704       RETVALUE(RFAILED);
 705    }
 706    if (cell == NULLP)
 707    {
 708       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Memory allocation FAILED for cell");
 709       RETVALUE(RFAILED);
 710    }
 711
 712    /* Initialize the cell */
 713    cell->cellId  = cellCfg->cellId;
 714    cell->rachCfg = cellCfg->rachCfg;
 715    cell->bwCfg   = cellCfg->bwCfg;
 716 #ifdef EMTC_ENABLE
 717    if(cellCfg->emtcEnable)
 718     {
 719      cell->emtcEnable = cellCfg->emtcEnable;
 720     }
 721 #endif
 722    /* Initialize UL and DL CCCH logical channels */
 723    cell->ulCcchId = RG_INVALID_LC_ID;
 724    cell->dlCcchId = RG_INVALID_LC_ID;
 725
 726
 727    /* Initialize the lists of the cell */
 728    ret = rgDBMInitCell(cell);
 729    if (ret != ROK)
 730    {
 731       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization for cell failed");
 732       rgCFGFreeInactvCellCb(cell);
 733       RETVALUE(RFAILED);
 734    }
 735
 736 #ifdef LTE_ADV
 737    if (RFAILED == RgLaaCellCbInit(cell))
 738    {
 739       rgCFGFreeInactvCellCb(cell);
 740       RETVALUE(RFAILED);
 741    }
 742 #endif
 743
 744    for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
 745    {
 746       cell->subFrms[idx].txDone = TRUE;
 747    }
 748
 749    cell->macInst           = inst + RG_INST_START;
 750    /* Insert cell in the incative cell list */
 751    rgCb[inst].inactiveCell = cell;
 752    rgCb[inst].cell         = NULLP;
 753 #ifdef TENB_MULT_CELL_SUPPRT
 754    rguDlSapId              = cellCfg->rguDlSapId;
 755    rguUlSapId              = cellCfg->rguUlSapId;
 756 #else
 757    if(rgCb[inst].numRguSaps > 1)
 758    {
 759       rguDlSapId              = 1;
 760    }
 761 #endif
 762    cell->rguDlSap          = &(rgCb[inst].rguSap[rguDlSapId]);
 763    cell->rguUlSap          = &(rgCb[inst].rguSap[rguUlSapId]);
 764
 765
 766 #ifdef LTE_L2_MEAS
 767    cmLListInit(&cell->l2mList);
 768    for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
 769    {
 770       cmMemset((U8 *)&cell->ulSf[idx], 0, sizeof(RgUlSf));
 771    }
 772
 773    cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
 774 #endif
 775    /* Update Statistics */
 776    rgUpdtCellCnt(inst,RG_CFG_ADD);
 777    errInfo->errCause = RGERR_NONE;
 778
 779    pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
 780    /* Allocate a buffer for flowCntrlInd.*/
 781    SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
 782               sizeof(RguFlowCntrlInd));
 783    RETVALUE(ROK);
 784 }  /* rgCFGCrgCellCfg */
 785
 786 #ifdef LTE_ADV
 787 /**
 788  * @brief Add SCell Cfg recvd from primary MAC instance.
 789  *
 790  * @details
 791  *
 792  *     Function : rgCfgAddUeSCellCfg
 793  *
 794  *     Processing Steps:
 795  *      - Allocate and create UE control block.
 796  *      - Update UE control block with the values recieved in the
 797  *        configuration.
 798  *      - If successful, add the control block to hash list of UEs for the cell
 799  *        else Rollback and FAIL.
 800  *
 801  *  @param[in]  Inst                 dstMacInst
 802  *  @param[in]  RgPrgUeSCellCfgInfo  *ueSCellCb
 803  *  @param[in]  RgCellCb              cell
 804
 805  *  @return  S16
 806  *      -# ROK
 807  *      -# RFAILED
 808  **/
 809 #ifdef ANSI
 810 PUBLIC S16 rgCfgAddUeSCellCfg
 811 (
 812 Inst        dstMacInst,
 813 RgPrgUeSCellCfgInfo *ueSCellCb,
 814 RgCellCb    *cell
 815 )
 816 #else
 817 PUBLIC S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
 818 Inst        dstMacInst;
 819 RgPrgUeSCellCfgInfo *ueSCellCb;
 820 RgCellCb    *cell;
 821 #endif
 822 {
 823    RgUeCb     *ueCb = NULLP;
 824    SuId       rguUlSapId = 0;
 825    SuId       rguDlSapId = 0;
 826    U8        idx;
 827    RgErrInfo  errInfo;
 828
 829    TRC2(rgCfgAddUeSCellCfg);
 830
 831 #ifdef LTE_ADV
 832    rguDlSapId              = ueSCellCb->rguDlSapId;
 833    rguUlSapId              = ueSCellCb->rguUlSapId;
 834 #endif
 835 #ifndef TENB_MULT_CELL_SUPPRT
 836    if(rgCb[dstMacInst].numRguSaps > 1)
 837    {
 838       rguDlSapId              = 1;
 839    }
 840 #endif
 841
 842    if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
 843    {
 844       RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
 845                "[%d]Ue already exist in scell %d during scell addition\n",
 846                ueSCellCb->ueId,
 847                cell->cellId));
 848       RETVALUE(RFAILED);
 849    }
 850
 851    /* Create UeCb */
 852    if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
 853                FALSE, &errInfo)) == NULLP)
 854    {
 855       RGDBGERRNEW(dstMacInst, (rgPBuf(dstMacInst),
 856                "[%d]UeCb creation failed\n", ueSCellCb->ueId));
 857       RETVALUE(RFAILED);
 858    }
 859
 860    if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
 861             (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
 862    {
 863       RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
 864                "[%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId));
 865       RETVALUE(RFAILED);
 866    }
 867    rgDBMInsUeCb(cell, ueCb);
 868
 869
 870    ueCb->rguDlSap          = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
 871    ueCb->rguUlSap          = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
 872
 873    /* Update satistics */
 874    rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
 875    /*Commit Added SCell info to UeCb */
 876    /*
 877    ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
 878    ueCb->sCelAddInfo[idx].macInst = dstMacInst;
 879    ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
 880    */
 881
 882    ueCb->txMode = ueSCellCb->txMode;
 883    ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
 884
 885    for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
 886    {
 887       ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
 888       ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
 889    }
 890
 891    for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
 892    {
 893       ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
 894       ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
 895       ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
 896    }
 897    RETVALUE(ROK);
 898 }/* rgCfgAddUeSCellCfg */
 899
 900 /**
 901  * @brief SCell Config Filling for added cell from RRC to MAC.
 902  *
 903  * @details
 904  *
 905  *     Function : rgFillAndAddSCellCfg
 906  *
 907  *     Processing Steps:
 908  *      - Update UE control block with the values recieved in the
 909  *        configuration.
 910  *      - Update UE control block with the values present in the
 911  *        CellCb
 912  *      - If successful, add the control block to hash list of UEs for the cell
 913  *        else Rollback and FAIL.
 914  *
 915  *  @param[in]  Inst          inst
 916  *  @param[in]  RgCellCb      *cell
 917  *  @param[in]  CrgUeCfg      *ueCfg
 918  *  @param[in]  CrgCfgTransId transId
 919  *  @return  S16
 920  *      -# ROK
 921  *      -# RFAILED
 922  **/
 923 #ifdef ANSI
 924 PUBLIC S16 rgFillAndAddSCellCfg
 925 (
 926 Inst            inst,
 927 RgCellCb        *cell,
 928 CrgUeRecfg      *ueRecfg,
 929 CrgCfgTransId   transId,
 930 Bool            *isCfmRqrd
 931 )
 932 #else
 933 PUBLIC S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
 934 Inst            inst;
 935 RgCellCb        *cell;
 936 CrgUeRecfg      *ueRecfg;
 937 CrgCfgTransId   transId;
 938 Bool            *isCfmRqrd;
 939 #endif
 940 {
 941    RgUeCb     *ue = NULLP;
 942    U8          idx = 0;
 943    Inst        dstMacInst;
 944    RgPrgUeSCellCfgInfo ueSCellCb;
 945    Pst          dstInstPst;
 946
 947    TRC2(rgFillAndAddSCellCfg);
 948
 949   /* Fetch the Active cell */
 950    if(((cell = rgCb[inst].cell) == NULLP) ||
 951        (cell->cellId != ueRecfg->cellId))
 952    {
 953       RGDBGERRNEW(inst,(rgPBuf(inst),
 954                        "[%d]Active Cell does not exist %d\n",
 955                                   ueRecfg->oldCrnti, ueRecfg->cellId));
 956       RETVALUE(RFAILED);
 957    }
 958
 959    RGDBGPRM(inst,(rgPBuf(inst),
 960             "Filling SCell Config : cellId %d ueId %d\n",
 961             cell->cellId, cell->ueId));
 962
 963    if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
 964    {
 965       RGDBGERRNEW(inst,(rgPBuf(inst),
 966                "[%d]Ue does not exist\n", ueRecfg->oldCrnti));
 967       RETVALUE(RFAILED);
 968    }
 969
 970    /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
 971     *confirmation*/
 972    ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
 973    ue->cfgCfmInfo.cfgCfgCount = 0;
 974    ue->cfgCfmInfo.mask = 0x0;
 975
 976    cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
 977          sizeof(CrgCfgTransId));
 978    ueSCellCb.ueId = ueRecfg->oldCrnti;
 979    ueSCellCb.txMode = ue->txMode;
 980    ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
 981    cmMemcpy((U8 *)ueSCellCb.ulLcInfo, (U8 *)ue->ul.lcCb, sizeof(ue->ul.lcCb));
 982    cmMemcpy((U8 *)ueSCellCb.dlLcInfo, (U8 *)ue->dl.lcCb, sizeof(ue->dl.lcCb));
 983    for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
 984    {
 985       ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
 986       ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
 987       ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
 988    }
 989
 990    for(idx = 0;
 991          idx < ueRecfg->crgSCellCfg.numSCells; idx++)
 992    {
 993       dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
 994       ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
 995       ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
 996       ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
 997
 998       /* Get post structure of the cell to whom ueSCellCb needs to be sent
 999        * And then send the sCell Add based on Mac instances */
1000       rgGetPstToInst(&dstInstPst, inst, dstMacInst);
1001       RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
1002
1003       /*Commit Added SCell info to UeCb is moved to config confirm*/
1004    } /*end of for loop */
1005    *isCfmRqrd = FALSE;
1006
1007    RETVALUE(ROK);
1008 }  /* rgFillAndAddSCellCfg */
1009 #endif /* LTE_ADV */
1010
1011 /**
1012  * @brief Handler for the UE configuration request from RRC to MAC.
1013  *
1014  * @details
1015  *
1016  *     Function : rgCFGCrgUeCfg
1017  *
1018  *     Processing Steps:
1019  *      - Allocate and create UE control block.
1020  *      - Update UE control block with the values recieved in the
1021  *        configuration.
1022  *      - Invoke RAM, SCH, UHM and DHM with created UE control block, to
1023  *        update random access, scheduler, uplink harq and downlink harq
1024  *        specific information respectively.
1025  *      - If successful, add the control block to hash list of UEs for the cell
1026  *        else Rollback and FAIL.
1027  *
1028  *  @param[in]  Inst        inst
1029  *  @param[in]  RgCellCb  *cell
1030  *  @param[in]  CrgUeCfg  *ueCfg
1031  *  @param[out] RgErrInfo *errInfo
1032  *  @return  S16
1033  *      -# ROK
1034  *      -# RFAILED
1035  **/
1036 #ifdef ANSI
1037 PUBLIC S16 rgCFGCrgUeCfg
1038 (
1039 Inst      inst,
1040 RgCellCb  *cell,
1041 CrgUeCfg  *ueCfg,
1042 RgErrInfo *errInfo
1043 )
1044 #else
1045 PUBLIC S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
1046 Inst      inst;
1047 RgCellCb  *cell;
1048 CrgUeCfg  *ueCfg;
1049 RgErrInfo *errInfo;
1050 #endif
1051 {
1052    RgUeCb    *ue = NULLP;
1053    Bool      handover = FALSE;
1054    SuId       rguUlSapId = 0;
1055    SuId       rguDlSapId = 0;
1056
1057    TRC2(rgCFGCrgUeCfg);
1058
1059    errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
1060
1061 /* Start: LTEMAC_2.1_DEV_CFG */
1062    if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
1063    {
1064       /* Create UeCb and Insert in Rach List */
1065       if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
1066       {
1067          RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb creation failed");
1068          RETVALUE(RFAILED);
1069       }
1070       if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
1071       {
1072          RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb Harq Entity Initialization failed");
1073          RETVALUE(RFAILED);
1074       }
1075       handover = TRUE;
1076    }
1077 /* End: LTEMAC_2.1_DEV_CFG */
1078
1079    if(handover == FALSE)
1080    {
1081       /* Remove from the rachLst */
1082       rgDBMDelUeCbFromRachLst(cell, ue);
1083    }
1084
1085
1086    /* Initialize uplink HARQ related information for UE */
1087    rgUHMCrgUeCfg(cell, ue, ueCfg);
1088
1089    rgDBMInsUeCb(cell, ue);
1090
1091 #ifdef TENB_MULT_CELL_SUPPRT
1092    rguDlSapId              = ueCfg->rguDlSapId;
1093    rguUlSapId              = ueCfg->rguUlSapId;
1094 #else
1095    if(rgCb[inst].numRguSaps > 1)
1096    {
1097       rguDlSapId              = 1;
1098    }
1099 #endif
1100
1101    ue->rguDlSap          = &(rgCb[inst].rguSap[rguDlSapId]);
1102    ue->rguUlSap          = &(rgCb[inst].rguSap[rguUlSapId]);
1103
1104
1105    /* Update satistics */
1106    rgUpdtUeCnt(inst,RG_CFG_ADD);
1107    errInfo->errCause = RGERR_NONE;
1108    RETVALUE(ROK);
1109 }  /* rgCFGCrgUeCfg */
1110
1111
1112 /**
1113  * @brief Handler for the logical channel configuration request from
1114  * RRC to MAC.
1115  *
1116  * @details
1117  *
1118  *     Function : rgCFGCrgLcCfg
1119  *
1120  *     Processing Steps:
1121  *      - Check if the configuration is for dedicated or common logical channel.
1122  *      - For Dedicated logical channels:
1123  *        - Update the dedicated logical channel Cb with the configured values.
1124  *        - Invoke SCH will cell, UE and logical channel Cb to update scheduler
1125  *          specific information.
1126  *      - For Common logical channels:
1127  *        - Update the common logical channel Cb with the configured values.
1128  *        - Move cell to active list of cells if cell becomes ACTIVE.
1129  *      - If successful, return ROK else RFAILED.
1130  *
1131  *  @param[in]  Inst        inst
1132  *  @param[in]  RgCellCb    *cell
1133  *  @param[in]  RgUeCb      *ue
1134  *  @param[in]  CrgLchCfg   *lcCfg
1135  *  @param[out] RgErrInfo   *errInfo
1136  *  @param[in]  Bool        *isCfmRqrd
1137  *  @return  S16
1138  *      -# ROK
1139  *      -# RFAILED
1140  **/
1141 #ifdef ANSI
1142 PUBLIC S16 rgCFGCrgLcCfg
1143 (
1144 Inst            inst,
1145 RgCellCb        *cell,
1146 RgUeCb          *ue,
1147 CrgLchCfg       *lcCfg,
1148 RgErrInfo       *errInfo,
1149 Bool            *isCfmRqrd,
1150 CrgCfgTransId   transId
1151 )
1152 #else
1153 PUBLIC S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
1154 Inst        inst;
1155 RgCellCb    *cell;
1156 RgUeCb      *ue;
1157 CrgLchCfg   *lcCfg;
1158 RgErrInfo   *errInfo;
1159 Bool        *isCfmRqrd;
1160 CrgCfgTransId   transId;
1161 #endif
1162 {
1163
1164    TRC2(rgCFGCrgLcCfg);
1165
1166    /* Handle Config for dedicated/common logical channels */
1167    if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1168    {
1169
1170       if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1171       {
1172          RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,
1173                "Dedicated logical channel configuration failed %d",lcCfg->lcId);
1174          RETVALUE(RFAILED);
1175       }
1176 #ifdef LTE_ADV
1177       /*ERAB Multl Cell fix*/
1178        cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
1179             sizeof(CrgCfgTransId));
1180        rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1181 #endif
1182    }
1183    else
1184    {
1185       if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1186       {
1187          RLOG_ARG1(L_ERROR, DBG_CRNTI, lcCfg->crnti, "Common logical channel configuration"
1188                   "failed %d\n", lcCfg->lcId);
1189          RETVALUE(RFAILED);
1190       }
1191    }
1192
1193    errInfo->errCause = RGERR_NONE;
1194    RLOG_ARG1(L_INFO, DBG_CRNTI,lcCfg->crnti, "CRG LC config done for UE: lcId %d\n", lcCfg->lcId);
1195    RETVALUE(ROK);
1196 }  /* rgCFGCrgLcCfg */
1197
1198
1199 /**
1200  * @brief Handler for the cell re-configuration request from RRC to MAC.
1201  *
1202  * @details
1203  *
1204  *     Function : rgCFGCrgCellRecfg
1205  *
1206  *     Processing Steps:
1207  *      - Invoke SCH with updated Cell Cb to update scheduler specific
1208  *        parameters.
1209  *      - Update the cell Cb with the reconfigured values.
1210  *      - If successful, return ROK else RFAILED.
1211  *
1212  *  @param[in]  Inst        inst
1213  *  @param[in]  RgCellCb      *cell
1214  *  @param[in]  CrgCellRecfg  *cellRecfg
1215  *  @param[out] RgErrInfo     *errInfo
1216  *  @return  S16
1217  *      -# ROK
1218  *      -# RFAILED
1219  **/
1220 #ifdef ANSI
1221 PUBLIC S16 rgCFGCrgCellRecfg
1222 (
1223 Inst          inst,
1224 RgCellCb      *cell,
1225 CrgCellRecfg  *cellRecfg,
1226 RgErrInfo     *errInfo
1227 )
1228 #else
1229 PUBLIC S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
1230 Inst          inst;
1231 RgCellCb      *cell;
1232 CrgCellRecfg  *cellRecfg;
1233 RgErrInfo     *errInfo;
1234 #endif
1235 {
1236    TRC2(rgCFGCrgCellRecfg);
1237
1238    /* Store the given rachCfg */
1239    cell->rachCfg = cellRecfg->rachRecfg;
1240
1241    errInfo->errCause = RGERR_NONE;
1242    RETVALUE(ROK);
1243 }  /* rgCFGCrgCellRecfg */
1244
1245
1246 /**
1247  * @brief Handler for the UE re-configuration request from RRC to MAC.
1248  *
1249  * @details
1250  *
1251  *     Function : rgCFGCrgUeRecfg
1252  *
1253  *     Processing Steps:
1254  *      - If rnti changes,
1255  *        - Invoke RAM for UE reconfiguration.
1256  *        - Delete old UE from the list.
1257  *        - Update the new rnti and re-insert the UE in the list.
1258  *      - Update the UE control block with the reconfigured values.
1259  *      - Invoke SCH, UHM and DHM with updated UE control block to
1260  *        update scheduler, uplink HARQ and downlink HARQ specific
1261  *        parameters.
1262  *      - If successful, return ROK else RFAILED.
1263  *
1264  *  @param[in]  Inst        inst
1265  *  @param[in]  RgCellCb    *cell
1266  *  @param[in]  RgUeCb      *ue
1267  *  @param[in]  CrgUeRecfg  *ueRecfg
1268  *  @param[out] RgErrInfo   *errInfo
1269  *  @return  S16
1270  *      -# ROK
1271  *      -# RFAILED
1272  **/
1273 #ifdef ANSI
1274 PUBLIC S16 rgCFGCrgUeRecfg
1275 (
1276 Inst        inst,
1277 RgCellCb    *cell,
1278 RgUeCb      *ue,
1279 CrgUeRecfg  *ueRecfg,
1280 RgErrInfo   *errInfo
1281 )
1282 #else
1283 PUBLIC S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
1284 Inst        inst;
1285 RgCellCb    *cell;
1286 RgUeCb      *ue;
1287 CrgUeRecfg  *ueRecfg;
1288 RgErrInfo   *errInfo;
1289 #endif
1290 {
1291    TRC2(rgCFGCrgUeRecfg);
1292
1293    errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1294
1295    /* Fix : syed UE ID change at MAC will now be controlled
1296     * by SCH. */
1297
1298    /* Update uplink HARQ related information for UE */
1299    rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1300
1301    errInfo->errCause = RGERR_NONE;
1302    RETVALUE(ROK);
1303 }  /* rgCFGCrgUeRecfg */
1304
1305
1306 /**
1307  * @brief Handler for the logical channel re-configuration request from
1308  * RRC to MAC.
1309  *
1310  * @details
1311  *
1312  *     Function : rgCFGCrgLcRecfg
1313  *
1314  *     Processing Steps:
1315  *      - Invoke scheduler to update scheduler specific information.
1316  *      - Update the dedicated logical channel Cb with the re-configured
1317  *        values.
1318  *      - If successful, return ROK else RFAILED.
1319  *
1320  *  @param[in]  Inst        inst
1321  *  @param[in]  RgUlCellCb  *cell
1322  *  @param[in]  RgUlUeCb    *ue
1323  *  @param[in]  RgUlLcCb    *ulLc
1324  *  @param[in]  RgDlLcCb    *dlLc
1325  *  @param[in]  CrgLchRecfg *lcRecfg
1326  *  @param[out] RgErrInfo   *errInfo
1327  *  @return  S16
1328  *      -# ROK
1329  *      -# RFAILED
1330  **/
1331 #ifdef ANSI
1332 PUBLIC S16 rgCFGCrgLcRecfg
1333 (
1334 Inst        inst,
1335 RgCellCb    *cell,
1336 RgUeCb      *ue,
1337 RgUlLcCb    *ulLc,
1338 CrgLchRecfg *lcRecfg,
1339 RgErrInfo   *errInfo,
1340 Bool        *isCfmRqrd
1341 )
1342 #else
1343 PUBLIC S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
1344 Inst        inst;
1345 RgCellCb    *cell;
1346 RgUeCb      *ue;
1347 RgUlLcCb    *ulLc;
1348 CrgLchRecfg *lcRecfg;
1349 RgErrInfo   *errInfo;
1350 Bool        *isCfmRqrd;
1351 #endif
1352 {
1353    TRC2(rgCFGCrgLcRecfg);
1354
1355    if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1356    {
1357       rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1358 #ifdef LTE_ADV
1359       rgPomSndUeSCellLchModToSmac(inst, cell, ue,  lcRecfg,isCfmRqrd);
1360 #endif
1361    }
1362
1363    errInfo->errCause = RGERR_NONE;
1364    RETVALUE(ROK);
1365 }  /* rgCFGCrgLcRecfg */
1366
1367 /* Start: LTEMAC_2.1_DEV_CFG */
1368 /**
1369  * @brief Handler for the logical channel re-configuration request from
1370  * RRC to MAC.
1371  *
1372  * @details
1373  *
1374  *     Function : rgCFGCrgUeReset
1375  *
1376  *     Processing Steps:
1377  *
1378  *  @param[in]  RgUlCellCb  *cell
1379  *  @param[in]  RgUlUeCb    *ue
1380  *  @param[in]  CrgRst     *reset
1381  *  @param[out] RgErrInfo   *errInfo
1382  *  @return  S16
1383  *      -# ROK
1384  *      -# RFAILED
1385  **/
1386 #ifdef ANSI
1387 PUBLIC S16 rgCFGCrgUeReset
1388 (
1389 RgCellCb    *cell,
1390 RgUeCb      *ue,
1391 CrgRst     *reset,
1392 RgErrInfo   *errInfo
1393 )
1394 #else
1395 PUBLIC S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
1396 RgCellCb    *cell;
1397 RgUeCb      *ue;
1398 CrgRst     *reset;
1399 RgErrInfo   *errInfo;
1400 #endif
1401 {
1402    TRC2(rgCFGCrgUeReset);
1403
1404    RLOG_ARG1(L_DEBUG, DBG_CRNTI, ue->ueId, "UE: of cell %d Reset\n", cell->cellId);
1405    rgDHMUeReset(cell, &ue->dl.hqEnt);
1406
1407    errInfo->errCause = RGERR_NONE;
1408
1409    RETVALUE(ROK);
1410 }  /* rgCFGCrgUeReset */
1411 /* End: LTEMAC_2.1_DEV_CFG */
1412
1413 /**
1414  * @brief Handler for the cell delete request from RRC to MAC.
1415  *
1416  * @details
1417  *
1418  *     Function : rgCFGCrgCellDel
1419  *
1420  *     Processing Steps:
1421  *      - Fetch the cell control block.
1422  *      - Remove the cell control block from the hash list of cells.
1423  *      - Free the cell control block.
1424  *      - If successful, return ROK else return RFAILED.
1425  *
1426  *  @param[in]  Inst        inst
1427  *  @param[in]  CrgDel      *cellDelInfo
1428  *  @param[out] RgErrInfo   *errInfo
1429  *  @return  S16
1430  *      -# ROK
1431  *      -# RFAILED
1432  **/
1433 #ifdef ANSI
1434 PUBLIC S16 rgCFGCrgCellDel
1435 (
1436 Inst        inst,
1437 CrgDel      *cellDelInfo,
1438 RgErrInfo   *errInfo
1439 )
1440 #else
1441 PUBLIC S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
1442 Inst        inst,
1443 CrgDel      *cellDelInfo;
1444 RgErrInfo   *errInfo;
1445 #endif
1446 {
1447    RgCellCb      *cell;
1448    U8 idx;
1449
1450    TRC2(rgCFGCrgCellDel);
1451
1452    errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1453    if (((cell = rgCb[inst].cell) == NULLP)
1454        ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1455    {
1456       if(((cell = rgCb[inst].inactiveCell) == NULLP)
1457           ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1458       {
1459
1460
1461          RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,"Cell does not exist");
1462          RETVALUE(RFAILED);
1463       }
1464
1465       /* Delete cell from inactive list */
1466       rgCb[inst].inactiveCell = NULLP ;
1467
1468       /* Free the inactive cell */
1469       rgCFGFreeInactvCellCb(cell);
1470
1471       errInfo->errCause = RGERR_NONE;
1472       RETVALUE(ROK);
1473    }
1474
1475    /* Delete from the cell list */
1476    //rgDBMDelCellCb(cell);
1477    for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1478    {
1479       rgTOMRlsSf(inst,&cell->subFrms[idx]);
1480    }
1481
1482    /* Free the active cell */
1483    rgCFGFreeCellCb(cell);
1484
1485    rgCb[inst].cell = NULLP;
1486
1487    errInfo->errCause    = RGERR_NONE;
1488    RGDBGINFO(inst,(rgPBuf(inst), "Cell %d deleted\n", cellDelInfo->u.cellDel.cellId));
1489    RETVALUE(ROK);
1490 }  /* rgCFGCrgCellDel */
1491
1492
1493 /**
1494  * @brief Handler for the UE delete request from RRC to MAC.
1495  *
1496  * @details
1497  *
1498  *     Function : rgCFGCrgUeDel
1499  *
1500  *     Processing Steps:
1501  *      - Fetch the UE control block.
1502  *      - Remove the UE control block from the hash list of UEs for the cell.
1503  *      - Free the UE control block.
1504  *      - If successful, return ROK else return RFAILED.
1505  *
1506  *  @param[in]  Inst        inst
1507  *  @param[in]  CrgDel      *ueDelInfo
1508  *  @param[out] RgErrInfo   *errInfo
1509  *  @return  S16
1510  *      -# ROK
1511  *      -# RFAILED
1512  **/
1513 #ifdef ANSI
1514 PUBLIC S16 rgCFGCrgUeDel
1515 (
1516 Inst        inst,
1517 CrgDel      *ueDelInfo,
1518 RgErrInfo   *errInfo
1519 )
1520 #else
1521 PUBLIC S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
1522 Inst        inst;
1523 CrgDel      *ueDelInfo;
1524 RgErrInfo   *errInfo;
1525 #endif
1526 {
1527    TRC2(rgCFGCrgUeDel);
1528
1529    errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1530
1531    RLOG_ARG1(L_DEBUG, DBG_CRNTI, ueDelInfo->u.ueDel.crnti, "UE %d Deletion Req at MAC\n", \
1532             ueDelInfo->u.ueDel.crnti);
1533    if ((rgCb[inst].cell == NULLP)
1534        || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1535    {
1536       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueDelInfo->u.ueDel.crnti,"Cell does not exist %d",
1537                 ueDelInfo->u.ueDel.cellId);
1538       RETVALUE(RFAILED);
1539    }
1540
1541    errInfo->errCause = RGERR_NONE;
1542    /* Fix: syed Context Deletion is relied upon SCH indication */
1543    RETVALUE(ROK);
1544 }  /* rgCFGCrgUeDel */
1545
1546
1547 /**
1548  * @brief Handler for the logical channel delete request from
1549  * RRC to MAC.
1550  *
1551  * @details
1552  *
1553  *     Function : rgCFGCrgLcDel
1554  *
1555  *     Processing Steps:
1556  *      - Fetch the logical channel control block.
1557  *      - Free the logical channel control block.
1558  *      - If successful, return ROK else return RFAILED.
1559  *
1560  *  @param[in]  Inst        inst
1561  *  @param[in]  CrgDel      *lcDelInfo
1562  *  @param[out] RgErrInfo   *errInfo
1563  *  @return  S16
1564  *      -# ROK
1565  *      -# RFAILED
1566  **/
1567 #ifdef ANSI
1568 PUBLIC S16 rgCFGCrgLcDel
1569 (
1570 Inst        inst,
1571 CrgDel      *lcDelInfo,
1572 RgErrInfo   *errInfo,
1573 Bool        *isCfmRqrd,
1574 CrgCfgTransId transId
1575 )
1576 #else
1577 PUBLIC S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
1578 Inst        inst;
1579 CrgDel      *lcDelInfo;
1580 RgErrInfo   *errInfo;
1581 CrgCfgTransId transId;
1582 #endif
1583 {
1584    Bool      dirVld = FALSE;
1585    RgCellCb  *cell;
1586    RgUeCb    *ue;
1587    RgUlLcCb  *ulLc;
1588    RgDlLcCb  *dlLc;
1589
1590    TRC2(rgCFGCrgLcDel);
1591
1592    errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1593
1594    /* Fetch the Active cell */
1595    if (((cell = rgCb[inst].cell) == NULLP) ||
1596        (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1597    {
1598       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Cell does not exist %d",
1599                 lcDelInfo->u.lchDel.cellId);
1600       RETVALUE(RFAILED);
1601    }
1602
1603    /* Fetch the Ue */
1604    if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1605    {
1606       RLOG_ARG0(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,
1607                 "UE does not exist for dedicated logical channel");
1608       RETVALUE(RFAILED);
1609    }
1610
1611    /* Validate downlink info */
1612    if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1613    {
1614       if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1615             == NULLP)
1616       {
1617          RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"DL LC %d does not exist",
1618                    lcDelInfo->u.lchDel.lcId);
1619          RETVALUE(RFAILED);
1620       }
1621       rgDBMDelDlDedLcCb(ue, dlLc);
1622       dirVld = TRUE;
1623    }
1624
1625    /* Validate uplink info */
1626    if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1627    {
1628       if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1629             == NULLP)
1630       {
1631          RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"UL LC %d does not exist",
1632                    lcDelInfo->u.lchDel.lcId);
1633          RETVALUE(RFAILED);
1634       }
1635       rgDBMDelUlDedLcCb(ue, ulLc);
1636       dirVld = TRUE;
1637    }
1638
1639    if (!dirVld)
1640    {
1641       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Invalid direction %d for LC Delete",
1642             lcDelInfo->u.lchDel.dir);
1643       RETVALUE(RFAILED);
1644    }
1645 #ifdef LTE_ADV
1646    /*ERAB - multicell fix*/
1647    cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
1648          sizeof(CrgCfgTransId));
1649    rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1650 #endif
1651    errInfo->errCause = RGERR_NONE;
1652    RETVALUE(ROK);
1653 }  /* rgCFGCrgLcDel */
1654
1655 /***********************************************************
1656  *
1657  *     Func : rgCFGVldtCrgDedLcCfg
1658  *
1659  *
1660  *     Desc : Validates dedicated logical channel configuration recieved from RRC.
1661  *
1662  *     Ret  : S16
1663  *            ROK - Success
1664  *            RFAILED - Failed
1665  *
1666  *     Notes:
1667  *
1668  *     File :
1669  *
1670  **********************************************************/
1671 #ifdef ANSI
1672 PRIVATE S16 rgCFGVldtCrgDedLcCfg
1673 (
1674 Inst          inst,
1675 CrgLchCfg     *lcCfg,
1676 RgCellCb      **cell,
1677 RgUeCb        **ue,
1678 RgErrInfo     *errInfo
1679 )
1680 #else
1681 PRIVATE S16 rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)
1682 Inst          inst;
1683 CrgLchCfg     *lcCfg;
1684 RgCellCb      **cell;
1685 RgUeCb        **ue;
1686 RgErrInfo     *errInfo;
1687 #endif
1688 {
1689    U8         dirVld   = FALSE;
1690    TRC2(rgCFGVldtCrgDedLcCfg);
1691
1692    errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1693
1694    /* Fetch the Active cell */
1695    if (((*cell = rgCb[inst].cell) == NULLP)
1696       || ((*cell)->cellId != lcCfg->cellId))
1697    {
1698       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Active Cell does not exist: Cell %d",
1699                 lcCfg->cellId);
1700       RETVALUE(RFAILED);
1701    }
1702
1703    /* Fetch the Ue */
1704    if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1705    {
1706       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE  does not exist for dedicated logical channel %d",
1707                 lcCfg->lcId);
1708       RETVALUE(RFAILED);
1709    }
1710
1711    /* Validate logical channel Id */
1712    if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1713             ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1714    {
1715       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel Id %d",
1716                 lcCfg->lcId);
1717       RETVALUE(RFAILED);
1718    }
1719
1720    /* Validate downlink info */
1721    if (lcCfg->dir & CRG_DIR_TX)
1722    {
1723       if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1724       {
1725          RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated DL LC %d already configured",
1726                     lcCfg->lcId);
1727          RETVALUE(RFAILED);
1728       }
1729       dirVld = TRUE;
1730    }
1731
1732    /* Validate uplink info */
1733    if (lcCfg->dir & CRG_DIR_RX)
1734    {
1735       if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1736       {
1737          RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Invalid lcgId for uplink logical channel %d",
1738                    lcCfg->ulInfo.lcgId);
1739          RETVALUE(RFAILED);
1740       }
1741       if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1742       {
1743          RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated UL LC %d already configured",
1744                    lcCfg->lcId);
1745          RETVALUE(RFAILED);
1746       }
1747       dirVld = TRUE;
1748    }
1749
1750    if (!dirVld)
1751    {
1752       RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid Direction %d",
1753                lcCfg->dir);
1754       RETVALUE(RFAILED);
1755    }
1756
1757    RETVALUE(ROK);
1758 }  /* rgCFGVldtCrgDedLcCfg */
1759
1760
1761 /***********************************************************
1762  *
1763  *     Func : rgCFGVldtCrgCmnLcCfg
1764  *
1765  *
1766  *     Desc : Validates common logical channel configuration recieved from RRC.
1767  *
1768  *     Ret  : S16
1769  *            ROK - Success
1770  *            RFAILED - Failed
1771  *
1772  *     Notes:
1773  *
1774  *     File :
1775  *
1776  **********************************************************/
1777 #ifdef ANSI
1778 PRIVATE S16 rgCFGVldtCrgCmnLcCfg
1779 (
1780 Inst          inst,
1781 CrgLchCfg     *lcCfg,
1782 RgCellCb      **cell,
1783 RgErrInfo     *errInfo
1784 )
1785 #else
1786 PRIVATE S16 rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)
1787 Inst          inst;
1788 CrgLchCfg     *lcCfg;
1789 RgCellCb      **cell;
1790 RgErrInfo     *errInfo;
1791 #endif
1792 {
1793    U8         dirVld  = FALSE;
1794
1795    TRC2(rgCFGVldtCrgCmnLcCfg);
1796
1797    errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1798
1799    /* Ensure cell is not in the active list */
1800    if (((*cell = rgCb[inst].cell) != NULLP)
1801       && ((*cell)->cellId != lcCfg->cellId))
1802    {
1803       RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Active Cell exists for common channels");
1804       RETVALUE(RFAILED);
1805    }
1806
1807    /* Fetch the inactive cell for common logical channels */
1808    if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1809         || ((*cell)->cellId != lcCfg->cellId))
1810    {
1811
1812       RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Inactive Cell does not exist for common channels");
1813       RETVALUE(RFAILED);
1814    }
1815    /* Validate downlink info */
1816    if (lcCfg->dir & CRG_DIR_TX)
1817    {
1818       if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1819       {
1820          if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1821          {
1822             if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1823             {
1824                RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on DLSCH already configured for cell");
1825                RETVALUE(RFAILED);
1826             }
1827          }
1828          else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1829          {
1830             if (rgDBMGetBcchOnBch(*cell) != NULLP)
1831             {
1832                RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on BCH already configured for cell %d");
1833                RETVALUE(RFAILED);
1834             }
1835          }
1836          else
1837          {
1838             RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid transport channel %d for cell",
1839                   lcCfg->dlInfo.dlTrchType);
1840             RETVALUE(RFAILED);
1841          }
1842       }
1843       else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1844       {
1845          if (rgDBMGetPcch(*cell) != NULLP)
1846          {
1847             RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"PCCH already configured for cell");
1848             RETVALUE(RFAILED);
1849          }
1850       }
1851       else if (RG_DLCCCH_ISCFGD(*cell))
1852       {
1853          RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"DL CCCH already configured for cell %d");
1854          RETVALUE(RFAILED);
1855       }
1856       dirVld = TRUE;
1857    }
1858
1859    /* Validate uplink info */
1860    if (lcCfg->dir & CRG_DIR_RX)
1861    {
1862       /* Uplink CCCH */
1863       if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1864       {
1865          RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid UL common lcType %d for cell ",
1866                   lcCfg->lcType);
1867          RETVALUE(RFAILED);
1868       }
1869       if (RG_ULCCCH_ISCFGD(*cell))
1870       {
1871          RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"UL CCCH already configured for cell ");
1872          RETVALUE(RFAILED);
1873       }
1874       dirVld = TRUE;
1875    }
1876
1877    /* Invalid direction */
1878    if (!dirVld)
1879    {
1880       RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid Direction %d", lcCfg->dir);
1881       RETVALUE(RFAILED);
1882    }
1883
1884    RETVALUE(ROK);
1885 }  /* rgCFGVldtCrgCmnLcCfg */
1886
1887 /***********************************************************
1888  *
1889  *     Func : rgCFGCrgDedLcCfg
1890  *
1891  *
1892  *     Desc : Handles dedicated logical channel configuration
1893  *     recieved from RRC.
1894  *
1895  *     Ret  : S16
1896  *            ROK - Success
1897  *            RFAILED - Failed
1898  *
1899  *     Notes:
1900  *
1901  *     File :
1902  *
1903  **********************************************************/
1904 #ifdef ANSI
1905 PRIVATE S16 rgCFGCrgDedLcCfg
1906 (
1907 RgCellCb      *cell,
1908 RgUeCb        *ue,
1909 CrgLchCfg     *lcCfg,
1910 RgErrInfo     *errInfo
1911 )
1912 #else
1913 PRIVATE S16 rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)
1914 RgCellCb      *cell;
1915 RgUeCb        *ue;
1916 CrgLchCfg     *lcCfg;
1917 RgErrInfo     *errInfo;
1918 #endif
1919 {
1920    //Inst     inst = cell->macInst - RG_INST_START;
1921    TRC2(rgCFGCrgDedLcCfg);
1922
1923    errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1924
1925    /* Uplink/Bi-directional logical channel */
1926    if (lcCfg->dir & CRG_DIR_RX)
1927    {
1928 #ifdef LTE_L2_MEAS
1929       rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1930       cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1931       if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1932       {
1933         rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1934       }
1935 #else
1936       rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1937 #endif
1938    }
1939
1940    /* Downlink/Bi-directional logical channel */
1941    if (lcCfg->dir & CRG_DIR_TX)
1942    {
1943       rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1944    }
1945    RETVALUE(ROK);
1946 }  /* rgCFGCrgDedLcCfg */
1947
1948
1949 /***********************************************************
1950  *
1951  *     Func : rgCFGCrgCmnLcCfg
1952  *
1953  *
1954  *     Desc : Handles dedicated logical channel configuration
1955  *     recieved from RRC.
1956  *
1957  *     Ret  : S16
1958  *            ROK - Success
1959  *            RFAILED - Failed
1960  *
1961  *     Notes:
1962  *
1963  *     File :
1964  *
1965  **********************************************************/
1966 #ifdef ANSI
1967 PRIVATE S16 rgCFGCrgCmnLcCfg
1968 (
1969 Inst          inst,
1970 RgCellCb      *cell,
1971 CrgLchCfg     *lcCfg,
1972 RgErrInfo     *errInfo
1973 )
1974 #else
1975 PRIVATE S16 rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)
1976 Inst          inst;
1977 RgCellCb      *cell;
1978 CrgLchCfg     *lcCfg;
1979 RgErrInfo     *errInfo;
1980 #endif
1981 {
1982    TRC2(rgCFGCrgCmnLcCfg);
1983
1984    errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
1985
1986    /* Handle configuration for CCCH/BCCH/PCCH */
1987    if (lcCfg->lcType == CM_LTE_LCH_CCCH)
1988    {
1989       /* UL and DL CCCH configuration */
1990       if (lcCfg->dir & CRG_DIR_TX)
1991       {
1992          cell->dlCcchId = lcCfg->lcId;
1993          cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
1994       }
1995
1996       if (lcCfg->dir & CRG_DIR_RX)
1997       {
1998          cell->ulCcchId = lcCfg->lcId;
1999          cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
2000       }
2001    }
2002    else
2003    {
2004       if (lcCfg->lcType == CM_LTE_LCH_BCCH)
2005       {
2006          /* BCCH on BCH and DLSCH configuration */
2007          if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
2008          {
2009             rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
2010
2011             if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
2012             {
2013                cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
2014             }
2015             else
2016             {
2017                cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
2018             }
2019          }
2020          else
2021          {
2022             rgDBMInsBcchOnBch(cell, lcCfg->lcId);
2023             cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
2024          }
2025       }
2026       else  /* PCCH configuration */
2027       {
2028          rgDBMInsPcch(cell, lcCfg->lcId);
2029          cell->cellActvState |= RG_PCCH_CFG_DONE;
2030       }
2031    }
2032
2033    /* Add to active cell list if cell is active */
2034    if (cell->cellActvState == RG_CELL_ACTIVE)
2035    {
2036       rgCb[inst].cell = cell;
2037       rgCb[inst].inactiveCell = NULLP;
2038       RLOG_ARG1(L_DEBUG, DBG_CELLID, cell->cellId, "Cell %d added to active list after common LC %d\
2039                config\n", lcCfg->lcId);
2040    }
2041
2042    RETVALUE(ROK);
2043 }  /* rgCFGCrgCmnLcCfg */
2044 #ifdef LTE_L2_MEAS
2045 /***********************************************************
2046  *
2047  *     Func : rgCFGFreeUeUlAlloc
2048  *
2049  *
2050  *     Desc :
2051  *     - Processing Steps:
2052  *        - Frees cell control block.
2053  *
2054  *     Ret  : Void
2055  *
2056  *     Notes:
2057  *
2058  *     File :
2059  *
2060  **********************************************************/
2061 #ifdef ANSI
2062 PRIVATE Void rgCFGFreeUeUlAlloc
2063 (
2064 RgCellCb      *cell
2065 )
2066 #else
2067 PRIVATE Void rgCFGFreeUeUlAlloc(cell)
2068 RgCellCb      *cell;
2069 #endif
2070 {
2071    U8    sfIdx;
2072    Inst inst = cell->macInst - RG_INST_START;
2073
2074    TRC2(rgCFGFreeUeUlAlloc);
2075
2076    for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
2077    {
2078       if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
2079       {
2080          /*ccpu00117052 - MOD- Passing double pointer for proper
2081           *                    NULLP assignment */
2082          rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
2083                (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
2084       }
2085    }
2086 }/* rgCFGFreeUeUlAlloc */
2087 #endif
2088 /***********************************************************
2089  *
2090  *     Func : rgCFGFreeCellCb
2091  *
2092  *
2093  *     Desc :
2094  *     - Processing Steps:
2095  *        - Frees cell control block.
2096  *
2097  *     Ret  : Void
2098  *
2099  *     Notes:
2100  *
2101  *     File :
2102  *
2103  **********************************************************/
2104 #ifdef ANSI
2105 PUBLIC Void rgCFGFreeCellCb
2106 (
2107 RgCellCb      *cell
2108 )
2109 #else
2110 PUBLIC Void rgCFGFreeCellCb(cell)
2111 RgCellCb      *cell;
2112 #endif
2113 {
2114    Inst inst = cell->macInst - RG_INST_START;
2115    TRC2(rgCFGFreeCellCb);
2116
2117 #ifdef LTE_ADV
2118    RgLaaCellCbDeInit(cell);
2119 #endif
2120    /* Free lists of the cell */
2121 #ifdef LTEMAC_SPS
2122    rgCFGFreeSpsUeLst(cell);
2123 #endif /* LTEMAC_SPS */
2124    rgCFGFreeUeLst(cell);
2125    rgRAMFreeCell(cell);
2126    rgCFGFreeCmnLcLst(cell);
2127 #ifdef LTE_L2_MEAS
2128    rgCFGFreeUeUlAlloc(cell);
2129 #endif
2130    /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2131                            assignment */
2132    /* Update satistics */
2133    rgUpdtCellCnt(inst,RG_CFG_DEL);
2134    rgDHMFreeAllTbBufs(inst);
2135
2136    rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2137
2138    /* De-allocate the Cell */
2139    rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2140
2141
2142    RGDBGINFO(inst,(rgPBuf(inst), "Cell freed\n"));
2143
2144   /* Stack Crash Problem for TRACE5 Changes. Added return below */
2145   RETVOID;
2146 }  /* rgCFGFreeCellCb */
2147
2148
2149 /***********************************************************
2150  *
2151  *     Func : rgCFGFreeInactvCellCb
2152  *
2153  *
2154  *     Desc :
2155  *     - Processing Steps:
2156  *        - Frees inactive cell control block.
2157  *
2158  *     Ret  : Void
2159  *
2160  *     Notes:
2161  *
2162  *     File :
2163  *
2164  **********************************************************/
2165 #ifdef ANSI
2166 PUBLIC Void rgCFGFreeInactvCellCb
2167 (
2168 RgCellCb      *cell
2169 )
2170 #else
2171 PUBLIC Void rgCFGFreeInactvCellCb(cell)
2172 RgCellCb      *cell;
2173 #endif
2174 {
2175    Inst      inst = cell->macInst - RG_INST_START;
2176    TRC2(rgCFGFreeInactvCellCb);
2177
2178    /* De-initialize the Ue list */
2179    rgDBMDeInitUeCbLst(cell);
2180 #ifdef LTEMAC_SPS
2181    rgDBMDeInitSpsUeCbLst(cell);
2182 #endif
2183
2184    rgCFGFreeCmnLcLst(cell);
2185
2186    rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2187    /*ccpu00117052 - MOD- Passing double pointer for proper
2188                         NULLP assignment */
2189    /* De-allocate the Cell */
2190    rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2191
2192    /* Update satistics */
2193    rgUpdtCellCnt(inst,RG_CFG_DEL);
2194
2195
2196   /* Stack Crash Problem for TRACE5 Changes. Added return below */
2197   RETVOID;
2198 }  /* rgCFGFreeInactvCellCb */
2199
2200
2201 /***********************************************************
2202  *
2203  *     Func : rgCFGFreeUeCb
2204  *
2205  *
2206  *     Desc :
2207  *     - Processing Steps:
2208  *        - Frees UE control block.
2209  *
2210  *     Ret  : Void
2211  *
2212  *     Notes:
2213  *
2214  *     File :
2215  *
2216  **********************************************************/
2217 #ifdef ANSI
2218 PUBLIC Void rgCFGFreeUeCb
2219 (
2220 RgCellCb    *cell,
2221 RgUeCb      *ue
2222 )
2223 #else
2224 PUBLIC Void rgCFGFreeUeCb(cell, ue)
2225 RgCellCb    *cell;
2226 RgUeCb      *ue;
2227 #endif
2228 {
2229    Inst inst = cell->macInst - RG_INST_START;
2230
2231    TRC2(rgCFGFreeUeCb);
2232
2233    rgDHMFreeUe(inst,&ue->dl.hqEnt);
2234
2235    /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2236                           assignment */
2237    /* De-allocate the Ue */
2238    rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
2239
2240    /* Update Statistics */
2241    rgUpdtUeCnt(inst,RG_CFG_DEL);
2242
2243
2244   /* Stack Crash Problem for TRACE5 Changes. Added return below */
2245   RETVOID;
2246 }  /* rgCFGFreeUeCb */
2247
2248 /***********************************************************
2249  *
2250  *     Func : rgCFGFreeCmnLcLst
2251  *
2252  *
2253  *     Desc :
2254  *     - Processing Steps:
2255  *        - Frees common logical channels in cell control block.
2256  *
2257  *     Ret  : Void
2258  *
2259  *     Notes:
2260  *
2261  *     File :
2262  *
2263  **********************************************************/
2264 #ifdef ANSI
2265 PRIVATE Void rgCFGFreeCmnLcLst
2266 (
2267 RgCellCb      *cell
2268 )
2269 #else
2270 PRIVATE Void rgCFGFreeCmnLcLst(cell)
2271 RgCellCb      *cell;
2272 #endif
2273 {
2274    TRC2(rgCFGFreeCmnLcLst);
2275
2276    rgDBMFreeCmnLcLst(cell);
2277
2278
2279   /* Stack Crash Problem for TRACE5 Changes. Added return below */
2280   RETVOID;
2281 }  /* rgCFGFreeCmnLcLst */
2282
2283
2284 /***********************************************************
2285  *
2286  *     Func : rgCFGFreeUeLst
2287  *
2288  *
2289  *     Desc :
2290  *     - Processing Steps:
2291  *        - Frees UE list in cell control block.
2292  *
2293  *     Ret  : Void
2294  *
2295  *     Notes:
2296  *
2297  *     File :
2298  *
2299  **********************************************************/
2300 #ifdef ANSI
2301 PRIVATE Void rgCFGFreeUeLst
2302 (
2303 RgCellCb      *cell
2304 )
2305 #else
2306 PRIVATE Void rgCFGFreeUeLst(cell)
2307 RgCellCb      *cell;
2308 #endif
2309 {
2310    RgUeCb     *ue;
2311
2312    TRC2(rgCFGFreeUeLst);
2313
2314    /* Free Ues in the list */
2315    while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2316    {
2317 #ifdef LTE_ADV
2318       rgDelUeFrmAllSCell(cell,ue);
2319 #endif
2320       rgDBMDelUeCb(cell, ue);
2321       rgCFGFreeUeCb(cell, ue);
2322    }
2323
2324    /* De-initialize the Ue list */
2325    rgDBMDeInitUeCbLst(cell);
2326
2327
2328   /* Stack Crash Problem for TRACE5 Changes. Added return below */
2329   RETVOID;
2330 }  /* rgCFGFreeUeLst */
2331
2332 #ifdef LTEMAC_SPS
2333 /***********************************************************
2334  *
2335  *     Func : rgCFGFreeSpsUeLst
2336  *
2337  *
2338  *     Desc :
2339  *     - Processing Steps:
2340  *        - Frees Sps UE list in cell control block.
2341  *
2342  *     Ret  : Void
2343  *
2344  *     Notes:
2345  *
2346  *     File :
2347  *
2348  **********************************************************/
2349 #ifdef ANSI
2350 PRIVATE Void rgCFGFreeSpsUeLst
2351 (
2352 RgCellCb      *cell
2353 )
2354 #else
2355 PRIVATE Void rgCFGFreeSpsUeLst(cell)
2356 RgCellCb      *cell;
2357 #endif
2358 {
2359    RgUeCb     *ue;
2360
2361    TRC2(rgCFGFreeSpsUeLst);
2362
2363    /* Free Ues in the list */
2364    while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2365    {
2366       rgDBMDelSpsUeCb(cell, ue);
2367    }
2368
2369    /* De-initialize the Ue list */
2370    rgDBMDeInitSpsUeCbLst(cell);
2371
2372 }  /* rgCFGFreeSpsUeLst */
2373
2374 #endif /* LTEMAC_SPS */
2375
2376 /**
2377  * @brief Function for registering cell- scheduler instance mapping
2378  *
2379  * @details
2380  *
2381  *     Function : RgSchMacCellRegReq
2382  *
2383  *     This function shall be invoked whenever scheduler is done with the
2384  *     cell configuration successfully.
2385  *     This shall create a mapping of the cell, scheduler instance that
2386  *     is serving the cell and the unique identifier of the cell on the
2387  *     scheduler at MAC. This mapping shall be used for further
2388  *     communication to the scheduler instance for this cell.
2389  *
2390  *
2391  *  @param[in] Pst*                pst,
2392  *  @param[in] CmLteCellId         cellId,
2393  *  @param[in] RaRespReqInfo       raRespReq
2394  *  @return  S16
2395  *      -# ROK
2396  **/
2397 #ifdef ANSI
2398 PUBLIC S16 RgSchMacCellRegReq
2399 (
2400 Pst*                pst,
2401 RgInfCellReg*       regReq
2402 )
2403 #else
2404 PUBLIC S16 RgSchMacCellRegReq(pst, regReq)
2405 Pst*                pst;
2406 RgInfCellReg*       regReq;
2407 #endif
2408 {
2409    Inst      inst;
2410    RgCellCb *cell = NULLP;
2411
2412    TRC3(RgSchMacCellRegReq)
2413
2414    RG_IS_INST_VALID(pst->dstInst);
2415    inst = pst->dstInst - RG_INST_START;
2416    cell = rgCb[inst].cell;
2417
2418    if(NULLP == regReq)
2419    {
2420       RETVALUE(RFAILED);
2421    }
2422
2423    if((cell  == NULLP) || (cell->cellId != regReq->cellId))
2424    {
2425       RETVALUE(RFAILED);
2426    }
2427    if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2428    {
2429       RETVALUE(RFAILED);
2430    }
2431    /* Initialize */
2432    cell->schInstMap.cellSapId = regReq->cellSapId;
2433    cell->schInstMap.schInst   = pst->srcInst;
2434    cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2435
2436    RETVALUE(ROK);
2437
2438 } /* end of RgSchMacCellRegReq */
2439
2440 /*Added Ue for Onging L2 Meas*/
2441 #ifdef LTE_L2_MEAS
2442 /*LTE_L2_MEAS_PHASE2*/
2443 PUBLIC S16 rgAddToL2MeasPerQci(RgCellCb  *cell,U8 qci)
2444 {
2445  S16      ret = ROK;
2446  CmLList   *lnk;
2447  RgL2MeasCb  *measCb;
2448  U16          idx;
2449
2450  lnk = cell->l2mList.first;
2451   while(lnk != NULLP )
2452    {
2453       measCb = (RgL2MeasCb *)lnk->node;
2454       if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2455       {
2456               for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2457               {
2458                       if(measCb->measReq.t.prbReq.qci[idx] == qci)
2459                       {
2460                               break; /*exit from for loop*/
2461                       }
2462               }
2463               if(idx == measCb->measReq.t.prbReq.numQci)
2464               {
2465                       cell->qciArray[qci].mask = TRUE;
2466                       measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2467               }
2468       }
2469       lnk = lnk->next;
2470    }  /* End of While*/
2471
2472
2473
2474  RETVALUE(ret);
2475 }
2476
2477
2478 #endif
2479
2480 /**********************************************************************
2481
2482          End of file
2483 **********************************************************************/