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