src/5gnrsch/rg_sch_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 functions.
  26
  27      File:     rg_sch_cfg.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_cfg.c
  32 @brief This module handles the configuration of SCH by RRC and RRM.
  33 */
  34
  35 static const char* RLOG_MODULE_NAME="MAC";
  36 static int RLOG_FILE_ID=186;
  37 static int RLOG_MODULE_ID=4096;
  38
  39 /* header include files -- defines (.h) */
  40 #include "common_def.h"
  41 #include "lrg.h"
  42 #include "rgr.h"
  43 #include "rgm.h"
  44 #include "tfu.h"
  45 #include "rg_env.h"
  46 #include "rg_sch_inf.h"
  47 #include "rg_sch.h"
  48 #include "rg_sch_err.h"
  49 #include "rg_sch_cmn.h"
  50 #include "rl_interface.h"
  51 #include "rl_common.h"
  52
  53 /* header/extern include files (.x) */
  54 #include "tfu.x"           /* TFU types */
  55 #include "lrg.x"           /* layer management typedefs for MAC */
  56 #include "rgr.x"           /* layer management typedefs for MAC */
  57 #include "rgm.x"           /* layer management typedefs for MAC */
  58 #include "rg_sch_inf.x"            /* typedefs for MAC */
  59 #include "rg_sch.x"            /* typedefs for MAC */
  60 /* [ccpu00124018]-MOD- Retrieving CQI value from cell config*/
  61 #include "rg_sch_cmn.x"
  62 #include "rg_sch_clist.x"
  63
  64
  65 /* LTE-MAC Scheduler instance control block structures */
  66 RgSchCb rgSchCb[RGSCH_MAX_INST];
  67
  68 #ifdef PHY_ERROR_LOGING
  69 RgSchUlAllocCntr rgSchUlAllocCntr;
  70 #endif
  71
  72 #ifdef EMTC_ENABLE
  73 Void rgSCHEmtcPOTrigger ARGS ((
  74 RgSchCellCb   *cell,
  75 RgSchUeCb     *ue
  76 ));
  77
  78 S16 rgSchEmtcUpdSiCfg ARGS ((
  79 RgSchCellCb   *cell,
  80 RgrCellRecfg  *cellRecfg
  81 ));
  82
  83 S16 rgSCHEmtcCfgVldtDrxReTxCfg ARGS((
  84 uint16_t       reTxTmr
  85 ));
  86
  87 S16 rgSCHEmtcCfgVldtDrxUlReTxCfg ARGS((
  88 uint16_t       reTxTmr
  89 ));
  90 #endif
  91
  92 S16 rgSCHEnbPfsDlCfg ARGS((
  93          Inst                instIdx,
  94          RgSchErrInfo       *err
  95          ));
  96 /* local defines */
  97 static S16 rgSCHCfgRgrUeRecfgRntiChg ARGS (( RgSchCellCb *cell,
  98       RgSchUeCb *ue, RgrUeRecfg *ueRecfg, RgSchErrInfo *errInfo));
  99 static S16 rgSCHCfgVldtUePwrCfg ARGS((RgSchCellCb *cell,
 100          RgrUeUlPwrCfg *pwrCfg));
 101 static S16 rgSCHCfgVldtUeGrpPwrCfg ARGS((RgSchCellCb *cell,
 102          RgrUeGrpPwrCfg *grpPwrCfg));
 103 #ifdef LTEMAC_SPS
 104 static S16 rgSCHCfgVldtUeDlSpsCfg ARGS((RgSchCellCb *cell,
 105          RgrUeSpsDlCfg *dlSpsCfg));
 106 static S16 rgSCHCfgVldtSpsReCfg ARGS ((RgSchCellCb *cell,
 107          RgSchUeCb *ue, RgrUeRecfg *ueRecfg));
 108 #endif /*LTEMAC_SPS*/
 109 static S16 rgSCHCfgVldtUeCqiModeCfg ARGS((RgSchCellCb *cell,RgrUeDlCqiCfg *ueDlCqiCfg));
 110 static S16 rgSCHCfgVldtUeMeasGapAckNakRepCfg ARGS ((RgSchCellCb *cell,
 111          RgrUeCfg *ueCfg));
 112 static S16 rgSCHCfgVldtUeMeasGapAckNakRepRecfg ARGS ((RgSchCellCb *cell,
 113          RgrUeRecfg *ueRecfg));
 114 static Void rgSCHCfgFreeDlDedLcCb ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
 115          RgSchDlLcCb *dlLc));
 116 static Void rgSCHCfgFreeDlCmnLcCb ARGS((RgSchClcDlLcCb *cmnDlLc));
 117 static Void rgSCHCfgFreeUeCb ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
 118 static Void rgSCHCfgFreeRgrCfgLst ARGS((RgSchCellCb *cell));
 119 static Void rgSCHCfgFreeCmnLcLst ARGS((RgSchCellCb *cell));
 120 static Void rgSCHCfgFreeUeLst ARGS((RgSchCellCb *cell));
 121 #ifdef LTEMAC_SPS
 122 static Void rgSCHCfgFreeSpsUeLst ARGS((RgSchCellCb *cell));
 123 #endif
 124 static S16 rgSCHCfgVldtRgrCmnLcCfg ARGS((Inst inst, RgrCellCfg *cellCfg,
 125                          RgSchErrInfo *errInfo));
 126 static S16 rgSCHCfgVldtRgrCellPwrCfg ARGS((Inst inst, RgrCellCfg *cellCfg,
 127          RgSchErrInfo *errInfo));
 128 static S16 rgSCHCfgVldtRgrCellSchCfg ARGS((Inst inst, RgrCellCfg *cellCfg));
 129 static S16 rgSCHCfgVldtRgrSchCfg ARGS((Inst inst, RgrSchedEnbCfg *schedEnbCfg));
 130 static S16 rgSCHCfgVldtRgrCellRACfg ARGS((Inst inst, RgrCellCfg *cellCfg));
 131 static Void rgSCHCfgRgrUePhrMsg3 ARGS(( RgSchCellCb *cell,
 132              RgSchRaCb *raCb,RgSchUeCb *ue, RgSchErrInfo *errInfo));
 133 static S16 rgSCHCfgRgrCmnLcCfg ARGS((RgSchCellCb *cell, RgrCmnLchCfg *lcCfg,
 134                          RgSchErrInfo *errInfo));
 135 Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,uint8_t idx));
 136 #ifdef RGR_SI_SCH
 137 static S16 rgSCHCfgVldtRgrCellSiCfg ARGS(( Inst inst, RgrSiCfg  *siCfg));
 138 #endif/*RGR_SI_SCH */
 139
 140 /* LTE_ADV_FLAG_REMOVED_START */
 141 static S16 rgSCHCfgVldtRgrCellLteAdvCfg ARGS(( Inst inst,
 142                                  RgrLteAdvancedCellConfig *lteAdvCfg, uint8_t dlTotalBw));
 143 /* LTE_ADV_FLAG_REMOVED_END */
 144
 145 static S16 rgSCHCfgVldtDrxUeCfg ARGS ((RgSchCellCb *cell,
 146                                        RgrUeDrxCfg *ueDrxCfg));
 147 static S16 rgSCHCfgVldtDrxOnDurCfg ARGS((uint8_t onDurTmr));
 148 static S16 rgSCHCfgVldtDrxInActvCfg ARGS((uint16_t inActvTmr));
 149 static S16 rgSCHCfgVldtDrxReTxCfg ARGS((uint8_t reTxTmr));
 150 static S16 rgSCHCfgVldtDrxLngCycCfg ARGS((RgrDrxLongCycleOffst lngCycleOffst));
 151 static S16 rgSCHCfgVldtDrxLngCyclTmrs ARGS((uint16_t val));
 152 static S16 rgSCHCfgVldtDrxShrtCycCfg ARGS((RgrDrxShortDrx shrtCycCfg));
 153 static S16 rgSCHCfgVldtRgrCellCsgParamCfg ARGS((Inst inst,
 154                           RgrCellCsgParamCfg   *csgParam));
 155 #ifdef TFU_UPGRADE
 156
 157 S16 rgSCHCfgACqiUeCfg ARGS(( RgSchCellCb *cellCb,RgSchUeCb *ue, RgSchUeACqiCb *aCqiCb,
 158                      RgrTxMode ueTxMode,RgrUeAprdDlCqiCfg *aCqiCfg, CmLteUeCategory ueCat ));
 159
 160 S16 rgSCHCfgAcqiUeReCfg ARGS(( RgSchCellCb *cellCb, RgSchUeCb *ueCb,
 161  RgrUeAprdDlCqiCfg   *acqiCfg, CmLteUeCategory  ueCat ));
 162
 163 S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, uint16_t  cfgIdx,
 164          uint16_t *peri, uint16_t *offset ));
 165
 166 S16 rgSCHCfgRiUeCfg ARGS((RgSchCellCb  *cellCb, RgSchUeCb    *ueCb,
 167                    RgrUePrdDlCqiCfg *cqiCfg, CmLteUeCategory ueCat ));
 168
 169 S16 rgSCHCfgPCqiUeCfg ARGS((RgSchCellCb  *cellCb, RgSchUeCb    *ueCb,
 170                      RgrUePrdDlCqiCfg *cqiCfg,CmLteUeCategory ueCat ));
 171
 172 S16 rgSCHCfgSrsUeCfg ARGS((RgSchCellCb   *cellCb,RgSchUeCb     *ueCb,
 173                      RgrUeUlSrsCfg *srsCfg ));
 174
 175 S16 rgSCHCfgSrUeCfg ARGS((RgSchCellCb   *cellCb,RgSchUeCb     *ueCb,
 176                      RgrUeSrCfg    *srCfg));
 177
 178 S16 rgSCHCfgPCqiUeReCfg ARGS((RgSchCellCb  *cellCb, RgSchUeCb *ueCb,
 179                      RgrUePrdDlCqiCfg *cqiCfg,CmLteUeCategory ueCat));
 180
 181 S16 rgSCHCfgSrsUeReCfg ARGS((RgSchCellCb  *cellCb, RgSchUeCb *ueCb,
 182                      RgrUeUlSrsCfg *srsCfg));
 183
 184 S16 rgSCHCfgSrUeReCfg ARGS((RgSchCellCb  *cellCb, RgSchUeCb *ueCb,
 185                       RgrUeSrCfg   *srCfg));
 186
 187 S16 rgSCHCfgVldtRgrTxmodePuschMode ARGS((RgSchCellCb  *cellCb,
 188          RgrTxMode  txMde, RgrAprdCqiMode puschMode,RgSchErrInfo *errInfo));
 189
 190 S16 rgSCHCfgVldtRgrUeACqiCfg ARGS(( RgSchCellCb *cellCb,
 191          CmLteRnti  crnti, RgrUeAprdDlCqiCfg *acqiCfg, RgrUeTxModeCfg txMode,
 192          RgSchErrInfo  *errInfo ));
 193
 194 S16 rgSCHCfgVldtRgrTxmodePucchMode ARGS((RgSchCellCb  *cellCb,
 195          RgrTxMode  txMde, RgrPrdCqiMode pucchMode,RgSchErrInfo *errInfo));
 196
 197 #ifdef LTEMAC_HDFDD
 198 S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
 199          CmLteRnti  crnti, RgrUePrdDlCqiCfg *cqiCfg, Bool hdFdd,
 200          RgrUeTxModeCfg txMode, RgSchErrInfo *errInfo));
 201 #else
 202 S16 rgSCHCfgVldtRgrUePCqiCfg ARGS(( RgSchCellCb *cellCb,
 203          CmLteRnti  crnti, RgrUePrdDlCqiCfg *cqiCfg, RgrUeTxModeCfg txMode,
 204          RgSchErrInfo *errInfo));
 205 #endif
 206 #ifdef LTEMAC_HDFDD
 207 S16 rgSCHCfgVldtRgrUeUlSrsCfg  ARGS ((RgSchCellCb *cellCb,
 208              CmLteRnti crnti, RgrUeUlSrsCfg *srsCfg, Bool hdFdd,
 209              RgSchErrInfo *errInfo));
 210 #else
 211 S16 rgSCHCfgVldtRgrUeUlSrsCfg  ARGS ((RgSchCellCb *cellCb,
 212          CmLteRnti crnti, RgrUeUlSrsCfg *srsCfg,
 213          RgSchErrInfo *errInfo));
 214 #endif
 215
 216 #ifdef LTEMAC_HDFDD
 217 S16 rgSCHCfgVldtRgrUeSrCfg  ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
 218          RgrUeSrCfg *srCfg, Bool hdFdd, RgSchErrInfo *errInfo));
 219 #else
 220 S16 rgSCHCfgVldtRgrUeSrCfg  ARGS((RgSchCellCb *cellCb, CmLteRnti crnti,
 221          RgrUeSrCfg *srCfg, RgSchErrInfo *errInfo));
 222 #endif
 223 static S16 rgSCHCfgVldtCqiSrSrsUeCfg ARGS (( RgSchCellCb       *cellCb,
 224                                              RgrUeCfg          *ueCfg,
 225                                              RgSchErrInfo      *errInfo));
 226
 227 static S16 rgSCHCfgVldtCqiSrSrsUeReCfg ARGS (( RgSchCellCb  *cellCb,
 228                                                RgSchUeCb    *ueCb,
 229                                                RgrUeRecfg   *ueReCfg,
 230                                                RgSchErrInfo *errInfo ));
 231
 232 S16 rgSCHCfgPCqiSrsSrUeDel ARGS ((RgSchCellCb *cellCb,
 233                                          RgSchUeCb *ueCb));
 234
 235 static Void rgSCHCfgUtlFetchAcqiBitSz ARGS (( RgSchUeACqiCb *acqiCb,uint8_t  numTxAnt,
 236                      uint8_t* cqiPmiSzR1,uint8_t* cqiPmiSzRn1 ));
 237
 238 /*  Added the function to be used instead of the
 239  *  MACRO RG_SCH_GET_PERIODICITY_TBL */
 240 static const RgSchUePCqiSrsSrCfgIdxTbl*  rgSCHCfgUtlGetPcqiSrsSrRiTbl ARGS ((
 241                                            RgSchPerTbl tblType,
 242                                            uint8_t * min,
 243                                            uint8_t * max));
 244
 245 #endif /* TFU_UPGRADE */
 246 static Void rgSCHCfgUeTaRecfg ARGS (( RgSchCellCb  *cellCb,
 247                                                RgSchUeCb    *ueCb,
 248                                                RgrUeRecfg   *ueReCfg,
 249                                                RgSchErrInfo *errInfo ));
 250 #ifdef LTE_ADV
 251 S16 rgSCHSCellCfgUeCfg ARGS((
 252 RgSchCellCb  *cell,
 253 RgSchUeCb    *ue,
 254 RgrUeRecfg   *ueRecfg,
 255 RgSchErrInfo *err
 256 ));
 257
 258 S16 rgSCHSCellCfgUePucchReCfg ARGS((
 259 RgSchCellCb  *cell,
 260 RgSchUeCb    *ue,
 261 RgrUeRecfg   *ueRecfg,
 262 RgSchErrInfo *err
 263 ));
 264 S16 rgSCHCfgVldtRgrUeSCellRecfg ARGS((
 265 RgrUeRecfg     *ueRecfg,
 266 RgSchCellCb    *cell,
 267 RgSchUeCb      *ue,
 268 RgSchErrInfo   *errInfo
 269 ));
 270 static S16 rgSCHSCellCfgUeCfgRollBack ARGS((
 271 RgSchCellCb  *cell,
 272 RgSchUeCb    *ue,
 273 RgrUeRecfg   *ueRecfg
 274 ));
 275 #endif
 276
 277 /* ccpu00117452 - MOD - Changed macro name from
 278    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
 279 #if ((defined (RGR_CQI_REPT)) && (defined (RGR_V2)))
 280 static S16 rgSCHCfgUeCqiReptReCfg ARGS ((
 281 RgSchCellCb    *cell,
 282 RgSchUeCb      *ue,
 283 RgrUeRecfg     *ueRecfg
 284 ));
 285
 286 static S16 rgSCHCfgVldtCqiReptReCfg ARGS ((
 287 RgSchCellCb       *cell,
 288 RgrUeRecfg     *ueRecfg
 289 ));
 290 #endif
 291 /*LTE_L2_MEAS_PHASE2*/
 292 #ifdef LTE_L2_MEAS
 293 static S16 rgSchAddToL2Meas ARGS ((RgSchCellCb *cellCb,RgSchDlLcCb *dlLc));
 294 #endif
 295 #ifdef EMTC_ENABLE
 296 S16 rgSCHEmtcCfgVldtDrxOnDurCfg
 297 (
 298 uint16_t      onDurTmr
 299 );
 300 Void rgSCHUtlUpdEmtcY
 301 (
 302 RgSchUeCb                  *ue
 303 );
 304 Void rgSCHEmtcHqPAlloc
 305 (
 306 RgSchCellCb       *cell,
 307 RgSchDlHqEnt      *hqEnt
 308 );
 309 #endif
 310
 311 /* local typedefs */
 312 const RgSchSrsTxOffst rgSrsTxOffstTbl[RGSCH_MAX_SRS_SFCFG_IDX+1]=
 313                                   {{1,{0,0,0,0,0,0,0,0}},
 314                                    {1,{0,0,0,0,0,0,0,0}},
 315                                    {1,{1,0,0,0,0,0,0,0}},
 316                                    {1,{0,0,0,0,0,0,0,0}},
 317                                    {1,{1,0,0,0,0,0,0,0}},
 318                                    {1,{2,0,0,0,0,0,0,0}},
 319                                    {1,{3,0,0,0,0,0,0,0}},
 320                                    {2,{0,1,0,0,0,0,0,0}},
 321                                    {2,{2,3,0,0,0,0,0,0}},
 322                                    {1,{0,0,0,0,0,0,0,0}},
 323                                    {1,{1,0,0,0,0,0,0,0}},
 324                                    {1,{2,0,0,0,0,0,0,0}},
 325                                    {1,{3,0,0,0,0,0,0,0}},
 326                                    {7,{0,1,2,3,4,6,8,0}},
 327                                    {8,{0,1,2,3,4,5,6,8}},
 328                                    {0,{0,0,0,0,0,0,0,0}}};
 329
 330 /* local externs */
 331
 332 #ifdef TFU_UPGRADE
 333 /* SRSCfg Table: Ref 36.213, Table: 8.2.1  */
 334 const RgSchUePCqiSrsSrCfgIdxTbl
 335 rgSchUeSrsCfgIdxFddTbl[RG_SCH_SRS_ISRS_INDX_MAX_FDD]=
 336 {
 337  { 0,1,    2,  0 },
 338  { 2,6,    5,  2 },
 339  { 7,16,   10, 7 },
 340  { 17,36,  20, 17},
 341  { 37,76,  40, 37},
 342  { 77,156, 80, 77},
 343  { 157,316,160,157},
 344  { 317,636,320,317 }
 345 };
 346
 347 /* Reference : 36.213 Table 8.2-2 */
 348 const RgSchUePCqiSrsSrCfgIdxTbl
 349 rgSchUeSrsCfgIdxTddTbl[RG_SCH_SRS_ISRS_INDX_MAX_TDD]=
 350 {
 351  { 10,14,  5,  10 },
 352  { 15,24,  10, 15 },
 353  { 25,44,  20, 25 },
 354  { 45,84,  40, 45 },
 355  { 85,164, 80, 85 },
 356  { 165,324,160, 165 },
 357  { 325,644,320, 325 }
 358  /* RESERVED: Configuration Module should not allow Res values */
 359 };
 360
 361 /*Reference: 36.213 Table:7.2.2-1A */
 362 const RgSchUePCqiSrsSrCfgIdxTbl
 363 rgSchUePCqiCfgIdxFddTbl[RG_SCH_CQIPMI_CFGIDX_MAX_FDD]=
 364 {
 365  { 0,1,   2, 0 },
 366  { 2,6,   5, 2 },
 367  { 7,16,  10,7 },
 368  {17,36,  20,17},
 369  {37,76,  40, 37},
 370  {77,156, 80, 77},
 371  {157,316,160,157},
 372  {318,349,32,318},
 373  {350,413,64, 350},
 374  {414,541,128,414 }
 375  /* RESERVED: Configuration should not allow Res values */
 376 };
 377
 378 /* Reference: 36.213 Table:7.2.2-1C */
 379 const RgSchUePCqiSrsSrCfgIdxTbl
 380 rgSchUeCqiPmiCfgIdxTddTbl[RG_SCH_CQIPMI_CFGIDX_MAX_TDD]=
 381 {
 382  { 0,0,   1, 0 },
 383  { 1,5,   5, 1 },
 384  { 6,15,  10,6 },
 385  {16,35,  20,16},
 386  {36,75,  40,36},
 387  {76,155, 80,76},
 388  {156,315,160,156}
 389  /* RESERVED: Configuration should not allow Res values */
 390 };
 391
 392 /* Note: RI table is same for FDD and TDD */
 393 /*Reference: 36.213 Table:7.2.2-1B */
 394 const RgSchUePCqiSrsSrCfgIdxTbl
 395 rgSchUeRiCfgIdxTbl[RG_SCH_RI_CFGIDX_MAX]=
 396 {
 397  { 0,160,    1, 0 },
 398  { 161,321,  2, 161 },
 399  { 322,482,  4, 322 },
 400  { 483,643,  8, 483},
 401  { 644,804,  16,644},
 402  { 805,965,  32,805 }
 403  /* RESERVED: Configuration should not allow Res values */
 404 };
 405
 406 /*Reference: 36.213 Table:7.2.2-2 */
 407 const RgSchUeBwSubSzBwParts
 408 rgSchUeBwSubSzBwPartsTbl[RG_SCH_BW_SUBSZ_BWPARTS_MAX]=
 409 {
 410  {6,7, 0, 0},  /*TODO: 6,7, NA, NA */
 411  {8, 10, 4,1},
 412  {11, 26, 4,2},
 413  {27, 63, 6,3},
 414  {64, 110, 8,4}
 415 };
 416
 417
 418 /* Reference : 36.213 Table 10.1-5 */
 419 /* Note: SR is same table for TDD and FDD */
 420 const RgSchUePCqiSrsSrCfgIdxTbl rgSchUeSrCfgIdxTbl[RG_SCH_ISR_INDX_MAX]=
 421 {
 422  { 0,4,   5, 0 },
 423  { 5,14,   10, 5 },
 424  { 15,34,  20,15 },
 425  { 35,74, 40,35},
 426  { 75,154, 80, 75}
 427  /* RESERVED: Configuration should not allow Res values */
 428 };
 429
 430 /*Reference:36.213: Derived from Table: 7.2.1-5 for Label L.
 431  The Label L is CEIL(log2(BinCoe(N and M)))*/
 432 const uint8_t RgSCHUeAcqi2022LBitWidth[6][28] ={
 433 {0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5},
 434 {0,0,2,3,4,4,5,5,6,6,6,7,7,7,7,7,8,8,8,8,8,8,8,9,9,9,9,9},
 435 {0,0,0,2,4,5,6,6,7,7,8,8,9,9,9,10,10,10,10,11,11,11,11,11,12,12,12,12},
 436 {0,0,0,0,3,4,6,7,7,8,9,9,10,10,11,11,12,12,12,13,13,13,14,14,14,14,15,15},
 437 {0,0,0,0,0,3,5,6,7,8,9,10,11,11,12,13,13,14,14,14,15,15,16,16,16,17,17,17},
 438 {0,0,0,0,0,0,3,5,7,8,9,10,11,12,13,13,14,15,15,16,16,17,17,18,18,18,19,19}
 439 };
 440
 441 #endif
 442
 443 extern uint8_t rgSchCmnHarqRtt[];
 444 #ifdef EMTC_ENABLE
 445 S16 rgSCHEmtcCellAlloc ARGS((RgSchCellCb *cel));
 446 Void rgSCHEmtcCellFree ARGS((RgSchCellCb *cel));
 447 Void rgSCHEmtcUeInfoFree ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
 448 uint8_t rgSchfillPucchSrRepNumCountemtc ARGS((RgSchUeCb *ueCb));
 449 uint8_t rgSchfillPucchCqiRepNumCountemtc ARGS((RgSchUePCqiCb *cqiCb, RgSchUeCb *ueCb));
 450 S16 rgEmtcvalidateSiCfg ARGS((RgrSiCfgReqInfo *siCfg,RgSchCellCb  *cell));
 451 #endif
 452 /* forward references */
 453
 454
 455 /**
 456  * @brief Validates the SCH EndoeB configuration request from RRM to SCH.
 457  *
 458  * @details
 459  *
 460  *     Function : rgSCHCfgVldtRgrSchedEnbCfg
 461  *
 462  **     Processing Steps:
 463  *      - Retrieve the cell control block.
 464  *      - If successful,
 465  *        - Validate the range of configured values recieved in
 466  *          configuration request.
 467  *        - If validated successfully,
 468  *          - Return ROK and pointer to the cell.
 469  *        - Else
 470  *          - Return RFAILED.
 471  *      - Else return RFAILED.
 472  *  @param[in]  Inst               inst
 473  *  @param[in]  RgrSchedEnbCfg    *schedEnbCfg
 474  *  @param[out] RgSchCellCb      **cell
 475  *  @param[out] RgSchErrInfo      *errInfo
 476  *  @return  S16
 477  *      -# ROK
 478  *      -# RFAILED
 479  **/
 480 #ifdef ANSI
 481 S16 rgSCHCfgVldtRgrSchedEnbCfg
 482 (
 483 Inst              inst,
 484 RgrSchedEnbCfg   *schedEnbCfg,
 485 RgSchErrInfo     *errInfo
 486 )
 487 #else
 488 S16 rgSCHCfgVldtRgrSchedEnbCfg(inst, schedEnbCfg, errInfo)
 489 Inst              inst;
 490 RgrSchedEnbCfg   *schedEnbCfg;
 491 RgSchErrInfo     *errInfo;
 492 #endif
 493 {
 494    RGSCHDBGPRM(inst, (rgSchPBuf(inst), "VALIDATE RGR SCH ENB CONFIG: \n"));
 495
 496    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_ENB_CFG;
 497
 498    // TODO
 499    if ((rgSCHCfgVldtRgrSchCfg(inst, schedEnbCfg)) != ROK)
 500    {
 501       RGSCHDBGERR(inst, (rgSchPBuf(inst), "Validation for scheduler related "
 502                           "config failed\n"));
 503       return RFAILED;
 504    }
 505
 506    RLOG1(L_INFO, "MIMO_DBG:: SCH:: numAntPorts=%d\n",schedEnbCfg->numTxAntPorts);
 507
 508    /* Validation for the ENB parameters */
 509    if ((schedEnbCfg->numTxAntPorts == 0) || (schedEnbCfg->numTxAntPorts > 4))
 510    {
 511       RGSCHDBGERR(inst, (rgSchPBuf(inst),"Invalid number of transmit antenna"
 512             " ports %d\n", schedEnbCfg->numTxAntPorts));
 513       return RFAILED;
 514    }
 515
 516    /* Validate csg access mode */
 517    if((schedEnbCfg->accsMode < RGR_CELL_ACCS_OPEN) ||
 518       (schedEnbCfg->accsMode > RGR_CELL_ACCS_HYBRID))
 519    {
 520       RGSCHDBGERR(inst, (rgSchPBuf(inst), "Invalid CSG Access mode\n"));
 521       return RFAILED;
 522    }
 523
 524    errInfo->errCause = RGSCHERR_NONE;
 525    RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR SCHED ENB config validation done:"\n));
 526
 527    return ROK;
 528 }  /* rgSCHCfgVldtRgrSchedEnbCfg */
 529
 530 /**
 531  * @brief Validates the cell configuration request from RRM to MAC.
 532  *
 533  * @details
 534  *
 535  *     Function : rgSCHCfgVldtRgrCellCfg
 536  *
 537  *     Processing Steps:
 538  *      - Retrieve the cell control block.
 539  *      - If successful,
 540  *        - Validate the range of configured values recieved in
 541  *          configuration request.
 542  *        - If validated successfully,
 543  *          - Return ROK and pointer to the cell.
 544  *        - Else
 545  *          - Return RFAILED.
 546  *      - Else return RFAILED.
 547  *  @param[in]  Inst         inst
 548  *  @param[in]  RgrCellCfg   *cellCfg
 549  *  @param[out] RgSchCellCb  **cell
 550  *  @param[out] RgSchErrInfo *errInfo
 551  *  @return  S16
 552  *      -# ROK
 553  *      -# RFAILED
 554  **/
 555 #ifdef ANSI
 556 S16 rgSCHCfgVldtRgrCellCfg
 557 (
 558 Inst         inst,
 559 RgrCellCfg   *cellCfg,
 560 RgSchCellCb  *cell,
 561 RgSchErrInfo *errInfo
 562 )
 563 #else
 564 S16 rgSCHCfgVldtRgrCellCfg(inst, cellCfg, cell, errInfo)
 565 Inst         inst;
 566 RgrCellCfg   *cellCfg;
 567 RgSchCellCb  *cell;
 568 RgSchErrInfo *errInfo;
 569 #endif
 570 {
 571    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_CFG;
 572
 573    /* check if cell exists already */
 574    if ((uint8_t *)cell != NULLP)
 575    {
 576       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell Id already exists");
 577       return RFAILED;
 578    }
 579
 580    if(cellCfg->macInst >= SCH_INST_START)
 581    {
 582       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid MAC Instance %d ",
 583                cellCfg->macInst);
 584       return RFAILED;
 585    }
 586
 587    if (cellCfg->macRnti.startRnti < RGSCH_MIN_MAC_RNTI )
 588    {
 589       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid start RNTI %d for cell ",
 590                cellCfg->macRnti.startRnti);
 591       return RFAILED;
 592    }
 593
 594    if ((rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)) != ROK)
 595    {
 596       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for scheduler related "
 597                           "config failed");
 598       return RFAILED;
 599    }
 600
 601    if ((cellCfg->dlHqCfg.maxDlHqTx < RGSCH_MIN_HQ_TX) ||
 602          (cellCfg->dlHqCfg.maxMsg4HqTx < RGSCH_MIN_HQ_TX))
 603    {
 604       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid Downlink HARQ configuration:"
 605                " maxDlHqTx %d maxMsg4HqTx %d", cellCfg->dlHqCfg.maxDlHqTx,
 606                cellCfg->dlHqCfg.maxMsg4HqTx);
 607       return RFAILED;
 608    }
 609    if ((cellCfg->cfiCfg.cfi < RGSCH_MIN_CFI_VAL) ||
 610          (cellCfg->cfiCfg.cfi > RGSCH_MAX_CFI_VAL))
 611    {
 612       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid CFI configuration %d",
 613            cellCfg->cfiCfg.cfi);
 614       return RFAILED;
 615    }
 616    if (((cellCfg->puschSubBand.subbandStart) +
 617         ((cellCfg->puschSubBand.numSubbands -1) * cellCfg->puschSubBand.size))
 618          > (cellCfg->bwCfg.ulTotalBw - 1))
 619    {
 620       RLOG_ARG4(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid PUSCH subband configuration:"
 621                " subBandStart %d numSubBands %d subBandSize %d ulTotBw %d",
 622                cellCfg->puschSubBand.subbandStart,
 623                cellCfg->puschSubBand.numSubbands, cellCfg->puschSubBand.size,
 624                cellCfg->bwCfg.ulTotalBw);
 625       return RFAILED;
 626    }
 627
 628    if (((cellCfg->bwCfg.dlTotalBw < RGSCH_MIN_DL_BW) ||
 629             (cellCfg->bwCfg.dlTotalBw > RGSCH_MAX_DL_BW)) ||
 630          ((cellCfg->bwCfg.ulTotalBw < RGSCH_MIN_UL_BW) ||
 631           (cellCfg->bwCfg.ulTotalBw > RGSCH_MAX_UL_BW)))
 632    {
 633       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid Bandwidth configuration:"
 634             " ul %d dl %d",cellCfg->bwCfg.ulTotalBw,
 635             cellCfg->bwCfg.dlTotalBw);
 636       return RFAILED;
 637    }
 638    if (cellCfg->phichCfg.ngEnum > RGR_NG_TWO)
 639    {
 640       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid PHICH Ng configuration %d",
 641                (uint8_t)cellCfg->phichCfg.ngEnum);
 642       return RFAILED;
 643    }
 644    /* Validation for extended PHICH Duration */
 645    if ((cellCfg->phichCfg.isDurExtend == TRUE) &&
 646          (cellCfg->bwCfg.dlTotalBw <= 10) && (cellCfg->cfiCfg.cfi < 2))
 647    {
 648       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid cfi value for"
 649                "Extended PHICH duration cfi:%d dlBw:%d",
 650                (uint8_t)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
 651       return RFAILED;
 652    }
 653    if ((cellCfg->phichCfg.isDurExtend == TRUE) &&
 654          (cellCfg->bwCfg.dlTotalBw > 10) && (cellCfg->cfiCfg.cfi < 3))
 655    {
 656       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid cfi value for"
 657                "Extended PHICH duration cfi:%d dlBw:%d",
 658                (uint8_t)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
 659       return RFAILED;
 660    }
 661    RLOG4(L_INFO,"CA_DBG:: PUCCH configuration:"
 662          " N2_RB %d N1_PUCCH %d deltaShift %d cyclicShift %d",
 663          cellCfg->pucchCfg.resourceSize,
 664          cellCfg->pucchCfg.n1PucchAn,
 665          cellCfg->pucchCfg.deltaShift,
 666          cellCfg->pucchCfg.cyclicShift);
 667
 668    /* ccpu00138567- Removing validation check for resourceSize as 0.
 669     * From the spec, n2RB value 0 is a valid config. */
 670    if ((cellCfg->pucchCfg.resourceSize >= cellCfg->bwCfg.ulTotalBw/2) ||
 671          (cellCfg->pucchCfg.n1PucchAn == 0) ||
 672          (cellCfg->pucchCfg.deltaShift < RGSCH_PUCCH_MINVAL_DS) ||
 673          (cellCfg->pucchCfg.deltaShift > RGSCH_PUCCH_MAXVAL_DS) ||
 674          (cellCfg->pucchCfg.cyclicShift > RGSCH_PUCCH_MAXVAL_CS))
 675    {
 676       RLOG_ARG4(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid PUCCH configuration:"
 677               " N2_RB %d N1_PUCCH %d deltaShift %d cyclicShift %d",
 678                cellCfg->pucchCfg.resourceSize,
 679                cellCfg->pucchCfg.n1PucchAn,
 680                cellCfg->pucchCfg.deltaShift,
 681                cellCfg->pucchCfg.cyclicShift);
 682       return RFAILED;
 683    }
 684    if (cellCfg->srsCfg.isSrsCfgSetup && cellCfg->srsCfg.srsBwEnum > RGR_SRS_BWCFG_7)
 685    {
 686       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid SRS configuration: "
 687                " srsBw %d", (uint8_t)cellCfg->srsCfg.srsBwEnum);
 688       return RFAILED;
 689    }
 690
 691    if ((rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)) != ROK)
 692    {
 693       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for Random access related"
 694                           "config failed");
 695       return RFAILED;
 696    }
 697
 698    if ((rgSCHCfgVldtRgrCellPwrCfg(inst, cellCfg, errInfo)) != ROK)
 699    {
 700       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for cell power "
 701                           "config failed");
 702       return RFAILED;
 703    }
 704
 705    /* Validate the common logical channel configuration */
 706    if( (cellCfg->numCmnLcs < RGR_MIN_CMN_LC_PER_CELL)||
 707        (cellCfg->numCmnLcs > RGR_MAX_CMN_LC_PER_CELL))
 708    {
 709       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid number(%d) of common logical"
 710               "channels in cell config", cellCfg->numCmnLcs);
 711       return RFAILED;
 712    }
 713    if ((rgSCHCfgVldtRgrCmnLcCfg(inst, cellCfg, errInfo)) != ROK)
 714    {
 715       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for common logical"
 716                           "channels failed");
 717       return RFAILED;
 718    }
 719
 720    /* Added 0 as a valid value for number of TICKs RRM
 721     * 0 implies no ticks i.e. shutting off the feature.*/
 722
 723 #ifdef RGR_SI_SCH
 724    if ((rgSCHCfgVldtRgrCellSiCfg(inst, &(cellCfg->siCfg))) != ROK)
 725    {
 726       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for SI"
 727                           "configuration failed");
 728       return RFAILED;
 729    }
 730 #endif /*RGR_SI_SCH */
 731
 732    /*ccpu00116923 - ADD - Srs Present support - Start*/
 733 #ifdef TFU_UPGRADE
 734 #ifdef LTE_TDD
 735    if(cellCfg->srsCfg.isSrsCfgSetup && cellCfg->srsCfg.srsSubFrameCfg > 13)
 736 #else
 737       if(cellCfg->srsCfg.isSrsCfgSetup && cellCfg->srsCfg.srsSubFrameCfg > 14)
 738 #endif
 739       {
 740          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid"
 741                   "Subframe configuration");
 742          return RFAILED;
 743       }
 744 #endif
 745    /*ccpu00116923 - ADD - Srs Present support - End*/
 746
 747   if ((cellCfg->bcchTxPwrOffset > 10000) ||
 748        (cellCfg->pcchTxPwrOffset > 10000) ||
 749        (cellCfg->rarTxPwrOffset > 10000) ||
 750        (cellCfg->phichTxPwrOffset > 10000)
 751       )
 752    {
 753       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
 754             "Invalid txPower offset ");
 755       return RFAILED;
 756    }
 757
 758 /* LTE_ADV_FLAG_REMOVED_START */
 759    /* Checking Whether DSFR is enabled without enabling SFR */
 760    if(((cellCfg->rgrLteAdvCfg.pres & RGR_DSFR) &&
 761        (RGR_ENABLE == cellCfg->rgrLteAdvCfg.dsfrCfg.status)) &&
 762       (!((cellCfg->rgrLteAdvCfg.pres & RGR_SFR) &&
 763          (RGR_ENABLE == cellCfg->rgrLteAdvCfg.sfrCfg.status))))
 764    {
 765       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "DSFR is enbaled"
 766                "Without enabling SFR");
 767       return RFAILED;
 768    }
 769
 770    if ((rgSCHCfgVldtRgrCellLteAdvCfg(inst, &(cellCfg->rgrLteAdvCfg),
 771                                       cellCfg->bwCfg.dlTotalBw)) != ROK)
 772    {
 773       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for LTE Adv"
 774                "configuration failed");
 775       return RFAILED;
 776    }
 777 #ifdef LTE_ADV
 778    if ((rgSCHCfgVldtRgrCellLteLAACfg(inst, cellCfg)) != ROK)
 779    {
 780       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Validation for LTE LAA"
 781                "configuration failed");
 782       return RFAILED;
 783    }
 784 #endif
 785 /* LTE_ADV_FLAG_REMOVED_END */
 786    if (cellCfg->msg4pAVal > RGRUE_DLPWRCNTRL_PA_DB3)
 787    {
 788       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,  "Invalid"
 789                "msg4pAVal %u", cellCfg->msg4pAVal);
 790       return RFAILED;
 791    }
 792
 793    /* Validate RgrCellCsgParamCfg */
 794    if(rgSchCb[inst].rgrSchedEnbCfg.accsMode == RGR_CELL_ACCS_HYBRID)
 795    {
 796       if((rgSCHCfgVldtRgrCellCsgParamCfg(inst,
 797                   &(cellCfg->csgParamCfg)) != ROK))
 798       {
 799          RGSCHDBGERR(inst, (rgSchPBuf(inst), "Validation failed for \n"
 800                   "Access CSG parameter failed\n"));
 801          return RFAILED;
 802       }
 803    }
 804 #ifdef EMTC_ENABLE
 805           if (cellCfg->emtcEnable)
 806           {
 807              if(ROK != rgSCHCfgVldtRgrEmtcCellCfg(cellCfg))
 808              {
 809                          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid EMTC cell Configuration %d for cell" ,cellCfg->cellId);
 810                          return RFAILED;
 811              }
 812           }
 813 #endif
 814    errInfo->errCause = RGSCHERR_NONE;
 815    return ROK;
 816 }  /* rgSCHCfgVldtRgrCellCfg */
 817
 818 /**
 819  * @brief Validates the scheduler related configuration request from RRM to MAC.
 820  *
 821  * @details
 822  *
 823  *     Function : rgSCHCfgVldtRgrSchCfg
 824  *
 825  *     Processing Steps:
 826  *      - Validate the scheduler related configuration request from RRC to MAC at CFG:
 827  *        validate the value range for the configured values.
 828  *      - If validated successfully,
 829  *        - Return ROK .
 830  *      - Else
 831  *        - Return RFAILED.
 832  *
 833  *  @param[in]  Inst         inst
 834  *  @param[out] RgSchedCfg  *rgSchedCfg
 835  *  @return  S16
 836  *      -# ROK
 837  *      -# RFAILED
 838  **/
 839 #ifdef ANSI
 840 S16 rgSCHCfgVldtRgrSchCfg
 841 (
 842 Inst         inst,
 843 RgrSchedEnbCfg   *rgSchedCfg
 844 )
 845 #else
 846 S16 rgSCHCfgVldtRgrSchCfg(inst, rgSchedCfg)
 847 Inst         inst;
 848 RgrSchedCfg   *rgSchedCfg;
 849 #endif
 850 {
 851    RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Validating \
 852                scheduler related Configuration"));
 853    if (rgSchedCfg->ulSchdType > (RGSCH_NUM_SCHEDULERS - 1))
 854    {
 855       RGSCHDBGERR(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Invalid \
 856                   UL scheduler type %d \n", rgSchedCfg->ulSchdType));
 857       return RFAILED;
 858    }
 859    if (rgSchedCfg->dlSchdType > (RGSCH_NUM_SCHEDULERS - 1))
 860    {
 861       RGSCHDBGERR(inst, (rgSchPBuf(inst), "rgSCHCfgVldtRgrSchCfg:Invalid \
 862                   DL scheduler type %d \n", rgSchedCfg->dlSchdType));
 863       return RFAILED;
 864    }
 865    return ROK;
 866 }
 867 /**
 868  * @brief Validates the scheduler related configuration request from RRM to MAC.
 869  *
 870  * @details
 871  *
 872  *     Function : rgSCHCfgVldtRgrCellSchCfg
 873  *
 874  *     Processing Steps:
 875  *      - Validate the scheduler related configuration request from RRC to MAC at CFG:
 876  *        validate the value range for the configured values.
 877  *      - If validated successfully,
 878  *        - Return ROK and pointer to the cell of UE.
 879  *      - Else
 880  *        - Return RFAILED.
 881  *
 882  *  @param[in]  Inst         inst
 883  *  @param[out] RgSchCellCfg  *cellCfg
 884  *  @return  S16
 885  *      -# ROK
 886  *      -# RFAILED
 887  **/
 888 #ifdef ANSI
 889 S16 rgSCHCfgVldtRgrCellSchCfg
 890 (
 891 Inst         inst,
 892 RgrCellCfg   *cellCfg
 893 )
 894 #else
 895 S16 rgSCHCfgVldtRgrCellSchCfg(inst, cellCfg)
 896 Inst         inst;
 897 RgrCellCfg   *cellCfg;
 898 #endif
 899 {
 900
 901 #if RGSCH_NUM_DLFS_SCHEDULERS
 902    if (cellCfg->dlfsSchdType > RGSCH_NUM_DLFS_SCHEDULERS - 1)
 903    {
 904       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid dlfs scheduler type %d for cell",
 905                 cellCfg->dlfsSchdType);
 906       return RFAILED;
 907    }
 908 #endif
 909    return ROK;
 910 }
 911 /**
 912  * @brief Validates the RACH related configuration request from RRM to MAC.
 913  *
 914  * @details
 915  *
 916  *     Function : rgSCHCfgVldtRgrCellRACfg
 917  *
 918  *     Processing Steps:
 919  *      - Validate the RA configuration request from RRC to MAC at CFG:
 920  *        validate the value range for the configured values.
 921  *      - If validated successfully,
 922  *        - Return ROK and pointer to the cell of UE.
 923  *      - Else
 924  *        - Return RFAILED.
 925  *
 926  *  @param[in]  Inst         inst
 927  *  @param[out] RgSchCellCfg  *cellCfg
 928  *  @return  S16
 929  *      -# ROK
 930  *      -# RFAILED
 931  **/
 932 #ifdef ANSI
 933 S16 rgSCHCfgVldtRgrCellRACfg
 934 (
 935 Inst         inst,
 936 RgrCellCfg   *cellCfg
 937 )
 938 #else
 939 S16 rgSCHCfgVldtRgrCellRACfg(inst, cellCfg)
 940 Inst         inst;
 941 RgrCellCfg   *cellCfg;
 942 #endif
 943 {
 944
 945 #ifdef LTE_TDD
 946    if ((cellCfg->rachCfg.preambleFormat > RGSCH_MAX_TDD_RA_PREAMBLE_FMT) ||
 947 #else
 948    if ((cellCfg->rachCfg.preambleFormat > RGSCH_MAX_RA_PREAMBLE_FMT) ||
 949 #endif
 950          (cellCfg->rachCfg.raWinSize < RGSCH_MIN_RA_WINSIZE)  ||
 951          (cellCfg->rachCfg.raWinSize > RGSCH_MAX_RA_WINSIZE) ||
 952          (cellCfg->rachCfg.maxMsg3Tx < RGSCH_MIN_HQ_TX) ||
 953          (cellCfg->rachCfg.numRaPreamble < RGSCH_MIN_NUM_RA_PREAMBLE) ||
 954          (cellCfg->rachCfg.numRaPreamble > RGSCH_MAX_NUM_RA_PREAMBLE) ||
 955          (cellCfg->rachCfg.sizeRaPreambleGrpA >
 956           cellCfg->rachCfg.numRaPreamble) ||
 957          (cellCfg->rachCfg.prachResource >
 958           (cellCfg->bwCfg.ulTotalBw - RGSCH_NUM_RA_RB)))
 959    {
 960       RLOG_ARG3(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid RACH configuration:"
 961                 "preamble Fmt %d raWinSize %d maxMsg3Tx %d",
 962                 cellCfg->rachCfg.preambleFormat, cellCfg->rachCfg.raWinSize,
 963                 cellCfg->rachCfg.maxMsg3Tx);
 964       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid numRaPreamble %d sizeRaPreambleGrpA %d",
 965                 cellCfg->rachCfg.numRaPreamble,
 966                 cellCfg->rachCfg.sizeRaPreambleGrpA);
 967       return RFAILED;
 968    }
 969    /* RACHO */
 970    /* verify that the ded Preambles cfgd for Pdcch Order
 971     * do not collide with that of non-dedicated  and validates against
 972     * the configuration index and number of RACH
 973     * ded-preambles. For non-zero ded preamble cfg,
 974     * the config index is expected to be != NA.*/
 975    if ((cellCfg->macPreambleSet.pres) &&
 976        ((cellCfg->macPreambleSet.start < cellCfg->rachCfg.numRaPreamble) ||
 977        (cellCfg->macPreambleSet.start >= RGSCH_MAX_NUM_RA_PREAMBLE) ||
 978        (cellCfg->macPreambleSet.size < 1) ||
 979        (cellCfg->macPreambleSet.size > RGSCH_MAX_NUM_RA_PREAMBLE-
 980                                        cellCfg->rachCfg.numRaPreamble) ||
 981        (cellCfg->rachCfg.raOccasion.sfnEnum == RGR_SFN_NA)))
 982    {
 983       RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,"Invalid RACH Preambleset conf:"
 984                 "preambleSet Start %d preambleSet Size %d",
 985                 cellCfg->macPreambleSet.start, cellCfg->macPreambleSet.size);
 986       return RFAILED;
 987    }
 988 #ifdef RGR_V1
 989    if(cellCfg->rachCfg.contResTmr)
 990    {
 991       uint8_t idx;
 992 #ifdef LTE_TDD
 993       idx = cellCfg->ulDlCfgIdx;
 994 #else
 995       idx = 7; /* FDD */
 996 #endif
 997       /* maxMsg4TxDelay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  +
 998          3 TTI (MAX L1+L2 processing delay at the UE) */
 999       uint8_t maxMsg4TxDelay = (cellCfg->dlHqCfg.maxMsg4HqTx-1) *
1000          rgSchCmnHarqRtt[idx] + 3;
1001
1002
1003       if(maxMsg4TxDelay >= cellCfg->rachCfg.contResTmr)
1004       {
1005          RLOG_ARG2(L_WARNING,DBG_CELLID,cellCfg->cellId ,
1006                "Warining !: Contention Resolution timer not greater than the "
1007                "guard timer. Conte Res timer %d Guard timer %d",
1008                cellCfg->rachCfg.contResTmr,
1009                maxMsg4TxDelay );
1010          /* [ccpu00138532]-DEL- removed return fail here as it is ok if the
1011             max Msg4 Tx delay is more than the contension Resolution timer.
1012             In such case, the CRI CE will be scheduled immediately once
1013             msg3 is received */
1014       }
1015    }
1016    else
1017    {
1018       /* ccpu00128575 ADD - If contention resolution timer is configured as 0,
1019          Then return fail*/
1020       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
1021                "Contention Resolution timer is configured as '0'");
1022       return RFAILED;
1023    }
1024 #endif
1025
1026    return ROK;
1027 }
1028
1029 /**
1030  * @brief Validates the UE configuration request from RRM to MAC.
1031  *
1032  * @details
1033  *
1034  *     Function : rgSCHCfgVldtRgrUeCfg
1035  *
1036  *     Processing Steps:
1037  *      - Validate the UE configuration request from RRC to MAC at CFG:
1038  *        validate the value range for the configured values.
1039  *      - If validated successfully,
1040  *        - Return ROK and pointer to the cell of UE.
1041  *      - Else
1042  *        - Return RFAILED.
1043  *
1044  *  @param[in]  Inst         inst
1045  *  @param[in]  RgrUeCfg     *ueCfg
1046  *  @param[out] RgSchCellCb  **cell
1047  *  @param[out] RgSchErrInfo *errInfo
1048  *  @return  S16
1049  *      -# ROK
1050  *      -# RFAILED
1051  **/
1052 #ifdef ANSI
1053 S16 rgSCHCfgVldtRgrUeCfg
1054 (
1055 Inst         inst,
1056 RgrUeCfg     *ueCfg,
1057 RgSchCellCb  **cell,
1058 RgSchErrInfo *errInfo
1059 )
1060 #else
1061 S16 rgSCHCfgVldtRgrUeCfg(inst, ueCfg, cell, errInfo)
1062 Inst         inst;
1063 RgrUeCfg     *ueCfg;
1064 RgSchCellCb  **cell;
1065 RgSchErrInfo *errInfo;
1066 #endif
1067 {
1068    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_CFG;
1069
1070    if (((*cell) == NULLP) ||
1071        ((*cell)->cellId != ueCfg->cellId))
1072    {
1073       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Cell does not exist %d",
1074            ueCfg->cellId);
1075       return RFAILED;
1076    }
1077    /* RACHO:
1078     * Check configured preamble id not colliding with non dedicated or PDCCH
1079     * order preamble sets. When valid preamble id given check that C-RNTI given
1080     * in configuration is not amongst the C-RNTI'smanaged by scheduler */
1081    if ((rgSCHRamVldtUeCfg(*cell, ueCfg)) != ROK)
1082    {
1083       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Preamble Id configuration"
1084                "failed ",ueCfg->cellId);
1085       return RFAILED;
1086    }
1087    /* Check if Ue already configured */
1088    if (rgSCHDbmGetUeCb(*cell, ueCfg->crnti) != NULLP)
1089    {
1090       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d UEID already exists",
1091              ueCfg->cellId);
1092       return RFAILED;
1093    }
1094    /* Validate Transmission UE modes  */
1095    if ((ueCfg->txMode.pres == TRUE) && ((ueCfg->txMode.txModeEnum < RGR_UE_TM_1)
1096             || (ueCfg->txMode.txModeEnum > RGR_UE_TM_7)))
1097    {
1098       RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid transmission mode for"
1099                " UE is %d", ueCfg->cellId,(uint8_t)ueCfg->txMode.txModeEnum);
1100       return RFAILED;
1101    }
1102
1103    /* Validate UE Category */
1104    if (ueCfg->ueCatEnum > CM_LTE_UE_CAT_8)
1105    {
1106       RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid category for UE %d",
1107                ueCfg->cellId,(uint8_t)ueCfg->ueCatEnum);
1108       return RFAILED;
1109    }
1110
1111    /* Validate UE Access Stratum Release */
1112    if (ueCfg->accessStratumRls > RGR_REL_10)
1113    {
1114       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid Access Stratum Release %u for UE\n",
1115                ueCfg->accessStratumRls));
1116       return RFAILED;
1117    }
1118    RGSCHDBGINFONEW(inst, (rgSchPBuf(inst), "Configured Access Stratum Release %u\n", \
1119             ueCfg->accessStratumRls));
1120
1121    if ((*cell)->numTxAntPorts == 1)
1122    {
1123       if ((ueCfg->txMode.pres == TRUE) &&
1124             (ueCfg->txMode.txModeEnum > RGR_UE_TM_1))
1125       {
1126          RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid transmission mode for"
1127                   " UE (%d) for the configured Cell Antenna Ports",ueCfg->cellId,
1128                   (uint8_t)ueCfg->txMode.txModeEnum);
1129          return RFAILED;
1130       }
1131    }
1132
1133    if ((rgSCHCfgVldtUeCqiModeCfg(*cell, &ueCfg->ueDlCqiCfg)) != ROK)
1134    {
1135       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "CELLID:%d Invalid CQI Mode configuration",
1136                 ueCfg->cellId);
1137       return RFAILED;
1138    }
1139
1140    /* Validate Max Uplink HARQ transmission value */
1141    if (ueCfg->ueUlHqCfg.maxUlHqTx < RGSCH_MIN_HQ_TX)
1142    {
1143       RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid Uplink HARQ config for "
1144             "UE %d",ueCfg->cellId,ueCfg->ueUlHqCfg.maxUlHqTx);
1145       return RFAILED;
1146    }
1147
1148    if (rgSCHCfgVldtUePwrCfg(*cell, &ueCfg->ueUlPwrCfg) != ROK)
1149    {
1150       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid PUSCH Group power"
1151            " configuration",ueCfg->cellId);
1152       return RFAILED;
1153    }
1154
1155    if (rgSCHCfgVldtUeMeasGapAckNakRepCfg(*cell, ueCfg) != ROK)
1156    {
1157       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid MeasGap/AckNackRep"
1158             " configuration",ueCfg->cellId);
1159       return RFAILED;
1160    }
1161
1162 #ifdef LTEMAC_SPS
1163    /* Validating SPS RNTI */
1164    if (((ueCfg->ueSpsCfg.spsRnti >=  (*cell)->rntiDb.rntiStart) &&
1165        (ueCfg->ueSpsCfg.spsRnti<=((*cell)->rntiDb.rntiStart+(*cell)->rntiDb.maxRntis)))
1166        ||(ueCfg->ueSpsCfg.spsRnti == RGSCH_SI_RNTI)
1167        ||(ueCfg->ueSpsCfg.spsRnti == RGSCH_P_RNTI))
1168    {
1169       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid SPS RNTI "
1170                " in DL SPS Config",ueCfg->cellId);
1171       return RFAILED;
1172    }
1173
1174    if (ueCfg->ueSpsCfg.dlSpsCfg.isDlSpsEnabled)
1175    {
1176       if (rgSCHCfgVldtUeDlSpsCfg(*cell, &ueCfg->ueSpsCfg.dlSpsCfg) != ROK)
1177       {
1178          RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid DL SPS configuration"
1179                   " for the UE",ueCfg->cellId);
1180          return RFAILED;
1181       }
1182    }
1183 #endif
1184 #ifdef TFU_UPGRADE
1185    /* Validated Periodic CQI/PMI, RI , SRS and SR related UeCfg */
1186    if ( ROK != rgSCHCfgVldtCqiSrSrsUeCfg(*cell, ueCfg, errInfo))
1187    {
1188       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid Periodic CQI/SR/SRS"
1189                "configuration",ueCfg->cellId);
1190       return RFAILED;
1191    }
1192 #endif
1193
1194    /* Validate DRX specific parameters */
1195    if ( ROK != rgSCHCfgVldtDrxUeCfg(*cell, &(ueCfg->ueDrxCfg)))
1196    {
1197       RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid DRX configuration",
1198                 ueCfg->cellId);
1199       return RFAILED;
1200    }
1201
1202 /* ccpu00117452 - MOD - Changed macro name from
1203    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
1204 #ifdef RGR_CQI_REPT
1205    if (ueCfg->ueCqiReptCfg.numColltdCqiRept > RGR_CQIRPTS_MAXN)
1206    {
1207       RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid numColltdCqiRept,"
1208                "MAX supported %d",RGR_CQIRPTS_MAXN,ueCfg->cellId);
1209       return RFAILED;
1210    }
1211 #endif /* End of RGR_CQI_REPT */
1212
1213 #ifdef EMTC_ENABLE
1214 /*This is to validate the EMTC related configuration if a UE is an EMTC UE*/
1215           if(TRUE == ueCfg->emtcUeCfg.pres)
1216           {
1217              if ( ROK != rgSCHCfgVldtEmtcUeCfg(*cell, &(ueCfg->emtcUeCfg)))
1218              {
1219                          RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid EMTC UE configurationfor crnti:%d",
1220                                   ueCfg->cellId, ueCfg->crnti);
1221                          return RFAILED;
1222              }
1223           }
1224 #endif
1225    errInfo->errCause = RGSCHERR_NONE;
1226    return ROK;
1227 }  /* rgSCHCfgVldtRgrUeCfg */
1228
1229
1230 /**
1231  * @brief Validates the cell reconfiguration request from RRM to MAC.
1232  *
1233  * @details
1234  *
1235  *     Function : rgSCHCfgVldtRgrCellRecfg
1236  *
1237  *     Processing Steps:
1238  *      - Retrieve the cell control block.
1239  *      - If successful,
1240  *        - Validate the range of reconfigured values recieved in
1241  *          re-configuration request.
1242  *        - If validated successfully,
1243  *          - Return ROK and pointer to the cell.
1244  *        - Else
1245  *          - Return RFAILED.
1246  *      - Else return RFAILED.
1247  *
1248  *  @param[in]  Inst          inst
1249  *  @param[in]  RgrCellRecfg  *cellRecfg
1250  *  @param[out] RgSchCellCb   **cell
1251  *  @param[out] RgSchErrInfo  *errInfo
1252  *  @return  S16
1253  *      -# ROK
1254  *      -# RFAILED
1255  **/
1256 #ifdef ANSI
1257 S16 rgSCHCfgVldtRgrCellRecfg
1258 (
1259 Inst          inst,
1260 RgrCellRecfg  *cellRecfg,
1261 RgSchCellCb   **cell,
1262 RgSchErrInfo  *errInfo
1263 )
1264 #else
1265 S16 rgSCHCfgVldtRgrCellRecfg(inst, cellRecfg, cell, errInfo)
1266 Inst          inst;
1267 RgrCellRecfg  *cellRecfg;
1268 RgSchCellCb   **cell;
1269 RgSchErrInfo  *errInfo;
1270 #endif
1271 {
1272
1273    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_RECFG;
1274
1275    /* Fetch cell and validate cell Id with the cell control block*/
1276    if (((*cell) == NULLP) ||
1277        ((*cell)->cellId != cellRecfg->cellId))
1278    {
1279       RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell control block does not exist");
1280       return RFAILED;
1281    }
1282
1283    /* Validate recieved values */
1284    if ((cellRecfg->recfgTypes & RGR_CELL_DL_HARQ_RECFG) &&
1285          ((cellRecfg->dlHqRecfg.maxDlHqTx < RGSCH_MIN_HQ_TX) ||
1286           (cellRecfg->dlHqRecfg.maxMsg4HqTx < RGSCH_MIN_HQ_TX)))
1287    {
1288       RLOG_ARG2(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Downlink HARQ configuration:"
1289            " maxDlHqTx %d maxMsg4HqTx %d", cellRecfg->dlHqRecfg.maxDlHqTx,
1290             cellRecfg->dlHqRecfg.maxMsg4HqTx);
1291       return RFAILED;
1292    }
1293    if ((cellRecfg->recfgTypes & RGR_CELL_CFI_RECFG) &&
1294          ((cellRecfg->cfiRecfg.cfi < RGSCH_MIN_CFI_VAL) ||
1295           (cellRecfg->cfiRecfg.cfi > RGSCH_MAX_CFI_VAL)))
1296    {
1297       RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid CFI configuration %d",
1298                cellRecfg->cfiRecfg.cfi);
1299       return RFAILED;
1300    }
1301    if (cellRecfg->recfgTypes & RGR_CELL_PUCCH_RECFG)
1302    {
1303       /* ccpu00138567- Removing validation check for resourceSize as 0.
1304        * From the spec, n2RB value 0 is a valid config. */
1305       if ((cellRecfg->pucchRecfg.n1PucchAn == 0) ||
1306           (cellRecfg->pucchRecfg.resourceSize >= (*cell)->bwCfg.ulTotalBw/2)||
1307           ((cellRecfg->pucchRecfg.deltaShift < RGSCH_PUCCH_MINVAL_DS) ||
1308            (cellRecfg->pucchRecfg.deltaShift > RGSCH_PUCCH_MAXVAL_DS)) ||
1309           (cellRecfg->pucchRecfg.cyclicShift > RGSCH_PUCCH_MAXVAL_CS))
1310       {
1311          RLOG_ARG4(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid PUCCH configuration: "
1312                "N2_RB %d N1_PUCCH %d deltaShift %d cyclicShift %d",
1313                cellRecfg->pucchRecfg.resourceSize,
1314                cellRecfg->pucchRecfg.n1PucchAn,
1315                cellRecfg->pucchRecfg.deltaShift,
1316                cellRecfg->pucchRecfg.cyclicShift);
1317          return RFAILED;
1318       }
1319    }
1320    if (cellRecfg->recfgTypes & RGR_CELL_SRS_RECFG)
1321    {
1322       if (cellRecfg->srsRecfg.isSrsCfgSetup && cellRecfg->srsRecfg.srsBwEnum > RGR_SRS_BWCFG_7)
1323       {
1324          RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid SRS configuration: "
1325                "srsBw %d", (uint8_t)cellRecfg->srsRecfg.srsBwEnum);
1326          return RFAILED;
1327       }
1328
1329       /*ccpu00116923 - ADD - Srs Present support - Start*/
1330 #ifdef TFU_UPGRADE
1331 #ifdef LTE_TDD
1332       if(cellRecfg->srsRecfg.isSrsCfgSetup && cellRecfg->srsRecfg.srsSubFrameCfg > 13)
1333 #else
1334          if(cellRecfg->srsRecfg.isSrsCfgSetup && cellRecfg->srsRecfg.srsSubFrameCfg > 14)
1335 #endif
1336          {
1337             RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Subframe configuration ");
1338             return RFAILED;
1339          }
1340 #endif
1341       /*ccpu00116923 - ADD - Srs Present support - End*/
1342    }
1343    if (cellRecfg->recfgTypes & RGR_CELL_RACH_RECFG)
1344    {
1345       if ((cellRecfg->rachRecfg.preambleFormat > RGSCH_MAX_RA_PREAMBLE_FMT) ||
1346             ((cellRecfg->rachRecfg.raWinSize < RGSCH_MIN_RA_WINSIZE) ||
1347              (cellRecfg->rachRecfg.raWinSize > RGSCH_MAX_RA_WINSIZE)) ||
1348             (cellRecfg->rachRecfg.maxMsg3Tx < RGSCH_MIN_HQ_TX) ||
1349             ((cellRecfg->rachRecfg.numRaPreamble < RGSCH_MIN_NUM_RA_PREAMBLE)
1350             || (cellRecfg->rachRecfg.numRaPreamble > RGSCH_MAX_NUM_RA_PREAMBLE))
1351             || (cellRecfg->rachRecfg.sizeRaPreambleGrpA >
1352                cellRecfg->rachRecfg.numRaPreamble) ||
1353             (cellRecfg->rachRecfg.prachResource >
1354                (*cell)->bwCfg.ulTotalBw - RGSCH_NUM_RA_RB))
1355       {
1356          RLOG_ARG3(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid RACH configuration:"
1357                " preamble Fmt %d raWinSize %d maxMsg3Tx %d",
1358                cellRecfg->rachRecfg.preambleFormat,
1359                cellRecfg->rachRecfg.raWinSize,
1360                cellRecfg->rachRecfg.maxMsg3Tx);
1361          RLOG_ARG2(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid RACH configuration:"
1362                "numRaPreamble %d sizeRaPreambleGrpA %d",
1363                cellRecfg->rachRecfg.numRaPreamble,
1364                cellRecfg->rachRecfg.sizeRaPreambleGrpA);
1365          return RFAILED;
1366       }
1367    }
1368
1369 #ifdef RGR_SI_SCH
1370    if (cellRecfg->recfgTypes & RGR_CELL_SI_RECFG)
1371    {
1372       if ((rgSCHCfgVldtRgrCellSiCfg(inst, &(cellRecfg->siReCfg))) != ROK)
1373       {
1374          RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Validation for SI"
1375                           "Re-configuration failed");
1376          return RFAILED;
1377       }
1378    }
1379 #endif /*RGR_SI_SCH */
1380
1381 /* LTE_ADV_FLAG_REMOVED_START */
1382    if (cellRecfg->recfgTypes & RGR_CELL_LTEA_FEATURE_RECFG)
1383    {
1384       /* Checkin whether DSFR is enbaled without enabling SFR.
1385        * So we need to check if SFR is enabled along with DSFR
1386        * in the same reconfiguration or it is already enabled earlier*/
1387       if((cellRecfg->rgrLteAdvCfg.pres & RGR_DSFR) &&
1388          (RGR_ENABLE == cellRecfg->rgrLteAdvCfg.dsfrCfg.status))
1389       {
1390          if(!(((cellRecfg->rgrLteAdvCfg.pres & RGR_SFR) &&
1391                (RGR_ENABLE == cellRecfg->rgrLteAdvCfg.sfrCfg.status)) ||
1392                ((*cell)->lteAdvCb.sfrCfg.status == RGR_ENABLE)))
1393          {
1394             RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"DSFR is enbaled"
1395                      "Without enabling SFR");
1396             return RFAILED;
1397          }
1398       }
1399       if ((rgSCHCfgVldtRgrCellLteAdvCfg(inst, &(cellRecfg->rgrLteAdvCfg),
1400                                        (*cell)->bwCfg.dlTotalBw)) != ROK)
1401       {
1402          RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Validation for Lte Adv"
1403                   "Re-configuration failed");
1404          return RFAILED;
1405       }
1406    }
1407 /* LTE_ADV_FLAG_REMOVED_END */
1408
1409    /* Validating minimum resource for non-CSG users */
1410    if (cellRecfg->recfgTypes & RGR_CELL_CSG_PARAM_RECFG)
1411    {
1412      if (cellRecfg->csgParamCfg.minDlResNonCsg > 100)
1413      {
1414          RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Configuration "
1415                "of minimum DL resources for NON-CSG");
1416          return RFAILED;
1417      }
1418      if (cellRecfg->csgParamCfg.minUlResNonCsg > 100)
1419      {
1420          RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid Configuration "
1421                "of minimum UL resources for NON-CSG");
1422          return RFAILED;
1423      }
1424    }
1425    errInfo->errCause = RGSCHERR_NONE;
1426    return ROK;
1427 }  /* rgSCHCfgVldtRgrCellRecfg */
1428
1429 #ifdef LTE_ADV
1430 /**
1431  * @brief Ue SCell configuration for scheduler. It is invoked during first time
1432  *        Scell configuration. It is not for reconfiguration
1433  *
1434  * @details
1435  *
1436  *     Function : rgSCHSCellCfgUeCfg
1437  *
1438  *     This functions updates UE specific scheduler
1439  *     information upon UE SCell first time Scell configuration
1440  *
1441  *  @param[in]  RgSchCellCb  *cell
1442  *  @param[in]  RgSchUeCb    *ue
1443  *  @param[int] RgrUeRecfg   *ueRecfg
1444  *  @param[out] RgSchErrInfo *err
1445  *  @return  S16
1446  *      -# ROK
1447  *      -# RFAILED
1448  **/
1449 #ifdef ANSI
1450 S16 rgSCHSCellCfgUeCfg
1451 (
1452 RgSchCellCb  *cell,
1453 RgSchUeCb    *ue,
1454 RgrUeRecfg   *ueRecfg,
1455 RgSchErrInfo *err
1456 )
1457 #else
1458 S16 rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, err)
1459 RgSchCellCb  *cell;
1460 RgSchUeCb    *ue;
1461 RgrUeRecfg   *ueRecfg;
1462 RgSchErrInfo *err;
1463 #endif
1464 {
1465    uint8_t                  idx;
1466    Inst                inst = cell->instIdx;
1467    RgSchCellCb         *secCellCb = NULLP;
1468    uint8_t                  sCellidx = 0;
1469    RgSchUeCellInfo     *sCellInfo = NULLP;
1470    RgrUeSecCellCfg  *sCellInfoCfg = NULLP;
1471 #ifdef TFU_UPGRADE
1472    RgrUeAprdDlCqiCfg   *aCqiCfg;
1473    RgrUePrdDlCqiCfg    *pCqiCfg;
1474 #endif
1475
1476    RLOG0(L_INFO, "SCELL recfg received from APP \n");
1477
1478    RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
1479      "--------------------------------------------------------------------\n"
1480      "UE SCell ReConfiguration at SCH: rnti (%u) cell(%u)\n"
1481      "--------------------------------------------------------------------\n",
1482      ue->ueId, cell->cellId));
1483
1484
1485    for(idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
1486    {
1487      /* Allocate the Ue control block */
1488       if (((rgSCHUtlAllocSBuf(inst, (Data **)&sCellInfo,
1489                     sizeof(RgSchUeCellInfo))) != ROK))
1490       {
1491          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx :Memomy allocation "
1492                   "Failed while Adding SCell Information\n", idx));
1493          return RFAILED;
1494       }
1495
1496
1497       sCellInfoCfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[idx];
1498
1499
1500       sCellInfo->sCellIdx  = sCellInfoCfg->sCellIdx;
1501       sCellInfo->sCellId   = sCellInfoCfg->sCellId;
1502
1503       if(PRSNT_NODEF == sCellInfoCfg->sCellDeActTmr.pres)
1504       {
1505          /* Configure implicit release */
1506          ue->sCellDeactTmrVal.val = sCellInfoCfg->sCellDeActTmr.val;
1507          ue->isScellExplicitDeAct = FALSE;
1508          ue->sCellDeactTmrVal.pres = PRSNT_NODEF;
1509       }
1510       else if (rgSchCb[cell->instIdx].genCfg.isSCellActDeactAlgoEnable == TRUE)
1511       {
1512          /* Configure explicit release */
1513          ue->sCellDeactTmrVal.val = RGSCH_SCELL_DEACT_TMR_INFINITY_VAL;
1514          ue->isScellExplicitDeAct = TRUE;
1515          ue->sCellDeactTmrVal.pres = PRSNT_NODEF;
1516       }
1517       else
1518       {
1519          ue->sCellDeactTmrVal.val  = 0;
1520          ue->isScellExplicitDeAct  = FALSE;
1521          ue->sCellDeactTmrVal.pres = NOTPRSNT;
1522       }
1523
1524       sCellInfo->sCellState = RG_SCH_SCELL_INACTIVE;
1525
1526       sCellInfo->ue = ue;
1527       ue->cellInfo[(sCellInfoCfg->sCellIdx)] = sCellInfo;
1528       sCellidx = ((sCellInfo->sCellId -
1529                rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
1530       ue->cellIdToCellIdxMap[sCellidx] = sCellInfo->sCellIdx;
1531
1532       /* For for time one Scell got added, setting allocCmnUlPdcch flag to TRUE, So that
1533          we will allocate PDCCH from common search space and the csiRequest field in DCI0 will
1534          be one bit (spec 36.213 sec 7.2.1)*/
1535 #ifdef LTE_ADV
1536       if ( ue->numSCells == 0)
1537       {
1538          ue->allocCmnUlPdcch = TRUE;
1539       }
1540 #endif
1541       ue->numSCells++;
1542 #ifdef CA_DBG
1543       printf("\n SCell added for ue %d numScells %d\n",ue->ueId,ue->numSCells);
1544 #endif
1545       /* retrieve teh sec cell Cb */
1546       if((secCellCb = (RgSchCellCb *)rgSchUtlGetCellCb(inst, sCellInfo->sCellId)) == NULLP)
1547       {
1548          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCell doesnt exists"));
1549          rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
1550          return RFAILED;
1551       }
1552
1553       if(TRUE == sCellInfoCfg->txMode.pres)
1554       {
1555          sCellInfo->txMode = sCellInfoCfg->txMode;
1556       }
1557       else
1558       {
1559          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx Tx mode not present ",idx));
1560          sCellInfoCfg->txMode.pres = TRUE;
1561          sCellInfoCfg->txMode.txModeEnum = RGR_UE_TM_1;
1562
1563          sCellInfo->txMode = sCellInfoCfg->txMode;
1564       }
1565       cmInitTimers (&sCellInfo->actDelayTmr, 1);
1566       cmInitTimers (&sCellInfo->deactTmr, 1);
1567
1568       ue->f1bCsAVal += rgSCHUtlGetMaxTbSupp(sCellInfo->txMode.txModeEnum);
1569
1570 #ifdef TFU_UPGRADE
1571       if(TRUE == sCellInfoCfg->ueSCellDlCqiCfg.aprdCqiCfg.pres)
1572       {
1573          sCellInfo->acqiCb.aCqiCfg.aprdModeEnum =
1574             sCellInfoCfg->ueSCellDlCqiCfg.aprdCqiCfg.aprdModeEnum;
1575       }
1576
1577       if(TRUE == sCellInfoCfg->uePdschDedCfg.uepACfg.pAPrsnt)
1578       {
1579          sCellInfo->pA.pres = TRUE;
1580          sCellInfo->pA.val = sCellInfoCfg->uePdschDedCfg.uepACfg.pA;
1581       }
1582       else
1583       {
1584          sCellInfo->pA.pres = FALSE;
1585       }
1586
1587       aCqiCfg = &sCellInfoCfg->ueSCellDlCqiCfg.aprdCqiCfg;
1588       RGSCHDBGPRM(cell->instIdx, (rgSchPBuf(cell->instIdx),
1589             "rgSCHCfgACqiUeCfg cellId =%d,Config Presence =%d for \
1590             Sec Cell Id = %d\n",
1591             cellCb->cellId,  aCqiCfg->pres,sCellInfo->sCellId));
1592
1593       /* if aperiodic cqi is present then only call the below function as it is
1594        * not mandatory*/
1595       if(aCqiCfg->pres)
1596       {
1597          if( ROK != rgSCHCfgACqiUeCfg(secCellCb,ue, &sCellInfo->acqiCb,
1598                   sCellInfo->txMode.txModeEnum, aCqiCfg, ue->ueCatEnum))
1599          {
1600             RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx ACQI Cfg"
1601                      "failed..n\n", idx));
1602             rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
1603             return RFAILED;
1604          }
1605       }
1606       /* Configuring PCQI */
1607       /* Scell needs to be added to the
1608        * pcqi list only after activation */
1609       pCqiCfg = &sCellInfoCfg->ueSCellDlCqiCfg.prdCqiCfg;
1610
1611       if(ROK != rgSCHSCellPCqiCfg(cell,secCellCb,ue,pCqiCfg,
1612             ue->ueCatEnum,sCellInfoCfg->sCellIdx))
1613       {
1614          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]SCellIdx PCQI Cfg failed..n\n", idx));
1615          rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
1616          return RFAILED;
1617       }
1618 #endif
1619
1620       /* Configuring ACQI */
1621
1622       /* Stroing the secCell for easy access */
1623       sCellInfo->cell   = secCellCb;
1624
1625
1626 #ifdef LTE_ADV
1627       if (ROK != rgSCHLaaInitDlRbAllocCb(secCellCb,
1628                &sCellInfo->dlAllocCb))
1629       {
1630          return RFAILED;
1631       }
1632 #endif
1633       /* Initialize Harq entity */
1634
1635       sCellInfo->hqEnt = rgSCHDhmHqEntInit(secCellCb);
1636       if (sCellInfo->hqEnt == NULLP)
1637       {
1638          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UEID:Hq Entity Initialization "
1639                   "failed in config\n", ue->ueId));
1640          rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
1641          return RFAILED;
1642       }
1643 #ifdef EMTC_ENABLE
1644       rgSCHEmtcHqPAlloc(secCellCb, sCellInfo->hqEnt);
1645 #endif
1646       rgSCHCmnDlInitHqEnt(secCellCb, sCellInfo->hqEnt);
1647
1648       sCellInfo->hqEnt->ue = ue;
1649       /* Init SCell Specific Sched Spfc UE DL CB */
1650       if ((secCellCb->sc.apis->rgSCHRgrSCellUeCfg(secCellCb, ue, sCellInfoCfg, err)) != ROK)
1651       {
1652          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
1653          rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
1654          return RFAILED;
1655       }
1656
1657 #ifdef LTE_TDD
1658      if((rgSCHUtlAllocUeANFdbkInfo(ue,sCellInfoCfg->sCellIdx)) != ROK)
1659      {
1660         RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UEID:Memomy allocation "
1661                  "Failed while UE related Ack Nack Information\n",
1662                  ue->ueId));
1663         rgSCHSCellFreeBuf (inst,ue,ueRecfg,idx);
1664         return RFAILED;
1665      }
1666 #endif /* LTE_TDD */
1667
1668 #ifdef LTE_ADV
1669      sCellInfo->sCellLnk.node = (PTR)sCellInfo;
1670      cmLListAdd2Tail(&secCellCb->sCellUeLst, &sCellInfo->sCellLnk);
1671 #endif
1672
1673       /* Inserting UECB into SCELL DBM */
1674      rgSCHDbmInsUeCb(secCellCb, ue);
1675    }
1676
1677 #ifndef MAC_5GTF_UPDATE
1678    ue->ul.useExtBSRSizes = ueRecfg->ueSCellCfgInfo.useExtBSRSizes;
1679 #else
1680    ue->ul.useExtBSRSizes = TRUE;
1681 #endif
1682
1683    for (idx = 0; idx < RGSCH_ULCTRL_RECP_DIST; idx++)
1684    {
1685       ue->ul.ctrlOnServCellIdx[idx] = 0xFF;
1686    }
1687    /* Trigger SCell addition to primary MAC */
1688    return ROK;
1689
1690 }  /* rgSCHSCellCfgUeCfg */
1691 /*f1b_Sprint */
1692 /**
1693  * @brief UE SCell PUCCH reconfiguration for scheduler
1694  *
1695  * @details
1696  *
1697  *     Function : rgSCHSCellCfgUePucchReCfg
1698  *
1699  *     This functions updates UE specific scheduler
1700  *     information upon UE SCell PUCCH reconfiguration
1701  *
1702  *  @param[in]  RgSchCellCb  *cell
1703  *  @param[in]  RgSchUeCb    *ue
1704  *  @param[int] RgrUeRecfg   *ueRecfg
1705  *  @param[out] RgSchErrInfo *err
1706  *  @return  S16
1707  *      -# ROK
1708  *      -# RFAILED
1709  **/
1710 #ifdef ANSI
1711 S16 rgSCHSCellCfgUePucchReCfg
1712 (
1713 RgSchCellCb  *cell,
1714 RgSchUeCb    *ue,
1715 RgrUeRecfg   *ueRecfg,
1716 RgSchErrInfo *err
1717 )
1718 #else
1719 S16 rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, err)
1720 RgSchCellCb  *cell;
1721 RgSchUeCb    *ue;
1722 RgrUeRecfg   *ueRecfg;
1723 RgSchErrInfo *err;
1724 #endif
1725 {
1726    Inst         inst = cell->instIdx;
1727    RgrUeSCellAckPucchCfg *sCellPucchRecfg = NULLP;
1728    uint8_t idx;
1729
1730    RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
1731      "--------------------------------------------------------------------\n"
1732      "UE SCell PUCCH ReConfiguration at SCH: rnti (%u) cell(%u)\n"
1733      "--------------------------------------------------------------------\n",
1734      ue->ueId, cell->cellId));
1735
1736
1737    sCellPucchRecfg = &ueRecfg->sCellAckN1ResCfg;
1738    /* Copy the UCI format type suported/configured for UE */
1739    ue->uciFrmtTyp = sCellPucchRecfg->pucchFormatType;
1740
1741    if (ue->uciFrmtTyp == RG_SCH_UCI_FORMAT1B_CS)
1742    {
1743       ue->n1PucchF1bResCb.cw1N1ResCount = sCellPucchRecfg->u.format1Bcs.sCellAckN1ResTb1Count;
1744       ue->n1PucchF1bResCb.cw2N1ResCount = sCellPucchRecfg->u.format1Bcs.sCellAckN1ResTb2Count;
1745
1746       for(idx = 0; idx < sCellPucchRecfg->u.format1Bcs.sCellAckN1ResTb1Count; idx++)
1747       {
1748          ue->n1PucchF1bResCb.cw1N1Res[idx].n1PucchIdx = sCellPucchRecfg->u.format1Bcs.sCellAckN1ResTb1[idx];
1749       }
1750
1751       for(idx = 0; idx < sCellPucchRecfg->u.format1Bcs.sCellAckN1ResTb2Count; idx++)
1752       {
1753          ue->n1PucchF1bResCb.cw2N1Res[idx].n1PucchIdx = sCellPucchRecfg->u.format1Bcs.sCellAckN1ResTb2[idx];
1754       }
1755    }
1756 #ifdef LTE_ADV
1757    else if (ue->uciFrmtTyp == RG_SCH_UCI_FORMAT3)
1758    {
1759       ue->n3PucchResCb.antP0N3ResCount = sCellPucchRecfg->u.format3.sCellAckN3ResAntP0Count;
1760       ue->n3PucchResCb.antP1N3ResCount = sCellPucchRecfg->u.format3.sCellAckN3ResAntP1Count;
1761       for (idx = 0;idx < ue->n3PucchResCb.antP0N3ResCount; idx++ )
1762       {
1763          ue->n3PucchResCb.antP0N3Res[idx].n3PucchIdx
1764                         = sCellPucchRecfg->u.format3.sCellAckN3ResAntP0[idx];
1765          ue->n3PucchResCb.antP0N3Res[idx].n3Lnk.node = NULLP;
1766          ue->n3PucchResCb.antP0N3Res[idx].sCellIdx = RGSCH_INVALID_CELL_IDX;
1767       }
1768       for (idx = 0;idx < ue->n3PucchResCb.antP1N3ResCount; idx++ )
1769       {
1770          ue->n3PucchResCb.antP1N3Res[idx].n3PucchIdx
1771                         = sCellPucchRecfg->u.format3.sCellAckN3ResAntP1[idx];
1772          ue->n3PucchResCb.antP1N3Res[idx].n3Lnk.node = NULLP;
1773          ue->n3PucchResCb.antP1N3Res[idx].sCellIdx = RGSCH_INVALID_CELL_IDX;
1774       }
1775       ue->simulAckNackCQIFormat3 = ueRecfg->simulAckNackCQIFormat3;
1776    }
1777 #endif
1778    else
1779    {
1780       RLOG1(L_ERROR,"Wrong PUCCH Format:%d configured for CA",ue->uciFrmtTyp);
1781    }
1782
1783    return ROK;
1784
1785 }  /* rgSCHSCellCfgUePucchReCfg */
1786 /**
1787  * @brief Validates the UE SCell Reconfiguration request from APP to SCH.
1788  *
1789  * @details
1790  *
1791  *     Function : rgSCHCfgVldtRgrUeSCellRecfg
1792  *
1793  *     Processing Steps:
1794  *      - Validate Number of SCells
1795  *        - If validated successfully,
1796  *          - Process Number of SCells
1797  *        - Else
1798  *          - Return RFAILED.
1799  *      - Validate SCellIdx value,
1800  *        - If validated successfully,
1801  *          - Process Number of RgrUeSecCellCfg
1802  *        - Else
1803  *          - Return RFAILED.
1804  *
1805  *  @param[in]  RgrUeRecfg    *ueRecfg
1806  *  @param[out] RgSchCellCb   *cell
1807  *  @param[out] RgSchUeCb     *ue
1808  *  @param[out] RgSchErrInfo  *errInfo
1809  *  @return  S16
1810  *      -# ROK
1811  *      -# RFAILED
1812  **/
1813 #ifdef ANSI
1814 S16 rgSCHCfgVldtRgrUeSCellRecfg
1815 (
1816 RgrUeRecfg     *ueRecfg,
1817 RgSchCellCb    *cell,
1818 RgSchUeCb      *ue,
1819 RgSchErrInfo   *errInfo
1820 )
1821 #else
1822 S16 rgSCHCfgVldtRgrUeSCellRecfg(inst, ueRecfg, cell, ue, errInfo)
1823 RgrUeRecfg     *ueRecfg;
1824 RgSchCellCb    *cell;
1825 RgSchUeCb      *ue;
1826 RgSchErrInfo   *errInfo;
1827 #endif
1828 {
1829    RgrUeSecCellCfg   *ueSCellDedCfg = NULLP;
1830    RgSchCellCb          *sCell = NULLP;
1831    Inst    inst = cell->instIdx;
1832
1833
1834    RGSCHDBGPRM(inst, (rgSchPBuf(inst), "VALIDATE RGR UE SCELL RECONFIG: cellId %d "
1835             "oldUeId %d cell %p \n", ueRecfg->cellId, ueRecfg->oldCrnti));
1836    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_SCELL_RECFG;
1837
1838    if((ueRecfg->ueSCellCfgInfo.numSCells > RGR_MAX_SCELL_PER_UE) ||
1839          (ueRecfg->ueSCellCfgInfo.numSCells < 1))
1840    {
1841       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid number of SCELL "
1842                " in SCELL Recfg\n"));
1843       return RFAILED;
1844    }
1845
1846    for(uint8_t idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
1847    {
1848       ueSCellDedCfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[idx];
1849       if(ROK != rgSchUtlVldtCellId(inst, ueSCellDedCfg->sCellId))
1850       {
1851          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCellId is out of range"));
1852          return RFAILED;
1853       }
1854       /* Validate existence of sec cell */
1855       sCell = rgSchUtlGetCellCb(inst, ueSCellDedCfg->sCellId);
1856       if(NULLP == sCell )
1857       {
1858          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCell doesnt exists"));
1859          return RFAILED;
1860       }
1861
1862       /* validate the range of serv cell index */
1863       if((ueSCellDedCfg->sCellIdx < 1) ||
1864             (ueSCellDedCfg->sCellIdx > RGR_MAX_SCELL_PER_UE))
1865       {
1866          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Invalid Serv Cell Idx %d\n",
1867                   ueSCellDedCfg->sCellIdx));
1868          return RFAILED;
1869       }
1870
1871       /* Is this sec cell alredy confiured */
1872       if(NULLP != ue->cellInfo[ueSCellDedCfg->sCellIdx])
1873       {
1874          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Secll with id %d already added\n",
1875                   ueSCellDedCfg->sCellIdx));
1876          return RFAILED;
1877       }
1878
1879       /* Validate CQI config  params */
1880       if((rgSCHCfgVldtUeCqiModeCfg(sCell, &ueSCellDedCfg->ueSCellDlCqiCfg)) != ROK)
1881       {
1882          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid CQI Mode "
1883                   " configuration for Ue %d\n",ue->ueId));
1884          return RFAILED;
1885       }
1886 #ifdef TFU_UPGRADE
1887       /*  1. Validate UE Aperiodic CQI related parameters */
1888       if( ROK != rgSCHCfgVldtRgrUeACqiCfg (sCell, ue->ueId,
1889                &ueSCellDedCfg->ueSCellDlCqiCfg.aprdCqiCfg, ueSCellDedCfg->txMode,
1890                errInfo ))
1891       {
1892          RGSCHDBGERR(sCell->instIdx, (rgSchPBuf(sCell->instIdx),
1893                   "rgSCHCfgVldtCqiSrSrsUeCfg: Invalid Aperiodic CQI configuration\n"));
1894          return RFAILED;
1895       }
1896
1897 #ifdef LTEMAC_HDFDD
1898       if( ROK != rgSCHCfgVldtRgrUePCqiCfg (sCell, ue->ueId,
1899                &ueSCellDedCfg->ueSCellDlCqiCfg.prdCqiCfg, ueRecfg->isHdFddEnbld,
1900                ueSCellDedCfg->txMode, errInfo ))
1901 #else
1902       if( ROK != rgSCHCfgVldtRgrUePCqiCfg (sCell, ue->ueId,
1903                &ueSCellDedCfg->ueSCellDlCqiCfg.prdCqiCfg,
1904                ueSCellDedCfg->txMode,
1905                errInfo ))
1906 #endif
1907       {
1908          RGSCHDBGERR(sCell->instIdx, (rgSchPBuf(sCell->instIdx),
1909                      "rgSCHCfgVldtCqiSrSrsUeCfg: Invalid Periodic CQI configuration\n"));
1910          return RFAILED;
1911       }
1912
1913       if((ueSCellDedCfg->txMode.txModeEnum < RGR_UE_TM_1) ||
1914             (ueSCellDedCfg->txMode.txModeEnum > RGR_UE_TM_9))
1915       {
1916          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCELL Invalid transmission mode for"
1917                   " UE %d\n", (uint8_t)ueSCellDedCfg->txMode.txModeEnum));
1918          return RFAILED;
1919       }
1920 #endif
1921    }
1922
1923    errInfo->errCause = RGSCHERR_NONE;
1924    RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR Ue SCell Reconfig validation done: "
1925             "cellId %d oldUeId %d\n", ueRecfg->cellId, ue->ueId));
1926    return ROK;
1927 }  /* rgSCHCfgVldtRgrUeSCellRecfg */
1928
1929 /**
1930  * @brief Ue SCell configuration roll back due to failure during configuration
1931  *        of any scell
1932  *
1933  * @details
1934  *
1935  *     Function : rgSCHSCellCfgUeCfgRollBack
1936  *
1937  *     This functions roll backs the configuration of successfully added Scell
1938  *
1939  *  @param[in]  RgSchCellCb  *cell
1940  *  @param[in]  RgSchUeCb    *ue
1941  *  @param[int] RgrUeRecfg   *ueRecfg
1942  *  @param[out] RgSchErrInfo *err
1943  *  @return  S16
1944  *      -# ROK
1945  *      -# RFAILED
1946  **/
1947 #ifdef ANSI
1948 static S16 rgSCHSCellCfgUeCfgRollBack
1949 (
1950 RgSchCellCb  *cell,
1951 RgSchUeCb    *ue,
1952 RgrUeRecfg   *ueRecfg
1953 )
1954 #else
1955 static S16 rgSCHSCellCfgUeCfgRollBack(cell, ue, ueRecfg)
1956 RgSchCellCb  *cell;
1957 RgSchUeCb    *ue;
1958 RgrUeRecfg   *ueRecfg;
1959 #endif
1960 {
1961    Inst                inst = cell->instIdx;
1962    RgrUeSecCellCfg  *sCellInfoCfg = NULLP;
1963    RgSchUeCellInfo     *sCellInfo = NULLP;
1964    RgSchCmnCell        *cellSch   = NULLP;
1965
1966    RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
1967      "--------------------------------------------------------------------\n"
1968      "UE SCell config roll back at SCH: rnti (%u) cell(%u)\n"
1969      "--------------------------------------------------------------------\n",
1970      ue->ueId, cell->cellId));
1971
1972   /* Free all Added scell in this transaction */
1973    for(uint8_t idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
1974    {
1975       sCellInfoCfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[idx];
1976       sCellInfo =  ue->cellInfo[(sCellInfoCfg->sCellIdx)];
1977
1978       /* if sCellInfo is not NULLP that means this Scell is added hence
1979        * delte it*/
1980       if (NULLP != sCellInfo)
1981       {
1982          /* Clear Scheduler specific list for this UE from the
1983           * corresponding CELL */
1984          cellSch = RG_SCH_CMN_GET_CELL(sCellInfo->cell);
1985          cellSch->apisDl->rgSCHDlUeReset(sCellInfo->cell, sCellInfo->ue);
1986
1987          /* Delete harq Entity of Scell*/
1988          rgSCHDhmDelHqEnt(cell, &(sCellInfo->hqEnt));
1989
1990          rgSCHUtlFreeSBuf(inst, (Data**)&(sCellInfo),
1991                sizeof(RgSchUeCellInfo));
1992
1993          ue->cellInfo[(sCellInfoCfg->sCellIdx)] = NULLP;
1994          ue->numSCells--;
1995 #ifdef LTE_ADV
1996          if (ue->numSCells == 0)
1997          {
1998             ue->allocCmnUlPdcch = TRUE;
1999             /* As there is no SCell left so DCI 0 size at UE specific search space
2000              * will be recalculated as the CSI is reduced to 1 bit */
2001             rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
2002          }
2003 #endif
2004       }
2005    }
2006    return ROK;
2007 }
2008 #endif /* LTE_ADV */
2009 /**
2010  * @brief Validates the UE reconfiguration request from RRC to MAC.
2011  *
2012  * @details
2013  *
2014  *     Function : rgSCHCfgVldtRgrUeRecfg
2015  *
2016  *     Processing Steps:
2017  *      - Retrieve the UE control block.
2018  *      - If successful,
2019  *        - Validate the range of reconfigured values recieved in
2020  *          re-configuration request.
2021  *        - If validated successfully,
2022  *          - Return ROK and pointer to the cell and ue.
2023  *        - Else
2024  *          - Return RFAILED.
2025  *      - Else return RFAILED.
2026  *
2027  *  @param[in]  Inst          inst
2028  *  @param[in]  RgrUeRecfg    *ueRecfg
2029  *  @param[out] RgSchCellCb   **cell
2030  *  @param[out] RgSchUeCb     **ue
2031  *  @param[out] RgSchErrInfo  *errInfo
2032  *  @return  S16
2033  *      -# ROK
2034  *      -# RFAILED
2035  **/
2036 #ifdef ANSI
2037 S16 rgSCHCfgVldtRgrUeRecfg
2038 (
2039 Inst           inst,
2040 RgrUeRecfg     *ueRecfg,
2041 RgSchCellCb    **cell,
2042 RgSchUeCb      **ue,
2043 RgSchErrInfo   *errInfo
2044 )
2045 #else
2046 S16 rgSCHCfgVldtRgrUeRecfg(inst, ueRecfg, cell, ue, errInfo)
2047 Inst           inst;
2048 RgrUeRecfg     *ueRecfg;
2049 RgSchCellCb    **cell;
2050 RgSchUeCb      **ue;
2051 RgSchErrInfo   *errInfo;
2052 #endif
2053 {
2054
2055    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_RECFG;
2056
2057    if (((*cell) == NULLP) ||
2058        ((*cell)->cellId != ueRecfg->cellId))
2059    {
2060       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,
2061                 "Cell does not exist for OLD CRNTI:%d",ueRecfg->oldCrnti);
2062       return RFAILED;
2063    }
2064
2065    /* Fetch the Old Ue */
2066    if ((*ue = rgSCHDbmGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
2067    {
2068       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"OLD CRNTI:%d does not exist",
2069             ueRecfg->oldCrnti);
2070       return RFAILED;
2071    }
2072
2073 #ifdef LTE_ADV
2074    if(RGR_UE_SCELL_ADD_RECFG & ueRecfg->ueRecfgTypes)
2075    {
2076       S16 ret = rgSCHCfgVldtRgrUeSCellRecfg(ueRecfg,*cell, *ue, errInfo);
2077       if ( ret != ROK)
2078       {
2079          RGSCHDBGERR(inst,(rgSchPBuf(inst), "Ue SCell Recfg Validation FAILED\n"));
2080          return RFAILED;
2081       }
2082       errInfo->errCause = RGSCHERR_NONE;
2083       return ROK;
2084    }
2085 #endif
2086
2087    if (ueRecfg->oldCrnti != ueRecfg->newCrnti)
2088    {
2089       if (rgSCHDbmGetUeCb(*cell, ueRecfg->newCrnti) != NULLP)
2090       {
2091          RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"NEW CRNTI:%d already exists",
2092               ueRecfg->newCrnti);
2093          return RFAILED;
2094       }
2095    }
2096
2097    if ((ueRecfg->ueRecfgTypes & RGR_UE_CSG_PARAM_RECFG) &&\
2098        ((*ue)->csgMmbrSta == ueRecfg->csgMmbrSta))
2099    {
2100       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE ID [%d] invalid CSG Membership reconfig :%d ",
2101               ueRecfg->newCrnti, (uint8_t)ueRecfg->csgMmbrSta);
2102       return RFAILED;
2103    }
2104    /* Validate values */
2105    if ((ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG) &&
2106          (ueRecfg->txMode.pres == TRUE) &&
2107          ((ueRecfg->txMode.txModeEnum < RGR_UE_TM_1) ||
2108           (ueRecfg->txMode.txModeEnum > RGR_UE_TM_7)))
2109    {
2110       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid transmission mode %d"
2111             "for NEW CRNTI:%d", (uint8_t)ueRecfg->txMode.txModeEnum,ueRecfg->newCrnti);
2112       return RFAILED;
2113    }
2114 #ifndef TFU_UPGRADE
2115    if ((ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG) &&
2116          (((ueRecfg->prdDlCqiRecfg.k < 1) || (ueRecfg->prdDlCqiRecfg.k > 4)) ||
2117          ((ueRecfg->prdDlCqiRecfg.cqiPmiCfgIdx < 1) ||
2118          (ueRecfg->prdDlCqiRecfg.cqiPmiCfgIdx > 1024))))
2119    {
2120       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Periodic CQI INFO"
2121                "OLD CRNTI:%d NEW CRNTI:%d",(uint8_t)ueRecfg->oldCrnti,ueRecfg->newCrnti);
2122       return RFAILED;
2123    }
2124 #endif
2125    if ((ueRecfg->ueRecfgTypes & RGR_UE_ULHARQ_RECFG) &&
2126          (ueRecfg->ueUlHqRecfg.maxUlHqTx < RGSCH_MIN_HQ_TX))
2127    {
2128       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config %d"
2129           "for NEW CRNTI:%d", ueRecfg->ueUlHqRecfg.maxUlHqTx,ueRecfg->newCrnti);
2130       return RFAILED;
2131    }
2132 #ifndef TFU_UPGRADE
2133    if ((ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG) &&
2134          (ueRecfg->prdDlCqiRecfg.prdModeEnum > RGR_PRD_CQI_MOD21))
2135    {
2136       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid periodic mode config for"
2137           " DL CQI %d NEW CRNTI:%d", (uint8_t)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->newCrnti);
2138       return RFAILED;
2139    }
2140 #else
2141    if ((ueRecfg->ueRecfgTypes & RGR_UE_PCQI_RECFG) &&
2142        (ueRecfg->cqiCfg.cqiSetup.prdModeEnum > RGR_PRD_CQI_MOD21))
2143    {
2144      RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid periodic mode config for "
2145             "DL CQI %d for NEW CRNTI:%d",(uint8_t)ueRecfg->cqiCfg.cqiSetup.prdModeEnum,ueRecfg->newCrnti);
2146      return RFAILED;
2147    }
2148 #endif /* TFU_UPGRADE */
2149    /* Validate UE Category */
2150    if (ueRecfg->ueCatEnum > CM_LTE_UE_CAT_8)
2151    {
2152       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid category %d for NEW CRNTI:%d",
2153                (uint8_t)ueRecfg->ueCatEnum,ueRecfg->newCrnti);
2154       return RFAILED;
2155    }
2156
2157    /* Validate UE Access Stratum Release */
2158    if ((ueRecfg->ueRecfgTypes & RGR_UE_UE_ACCESS_STRATUM_REL_RECFG) && \
2159          (ueRecfg->accessStratumRls > RGR_REL_11))
2160    {
2161       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Invalid Access Stratum Release %u for UE\n",
2162                ueRecfg->accessStratumRls));
2163       return RFAILED;
2164    }
2165    RGSCHDBGINFONEW(inst, (rgSchPBuf(inst), "Configured Access Stratum Release %u\n", \
2166             ueRecfg->accessStratumRls));
2167
2168    if ((ueRecfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG) &&
2169          ((ueRecfg->aprdDlCqiRecfg.pres == TRUE) &&
2170           ((ueRecfg->aprdDlCqiRecfg.aprdModeEnum > RGR_APRD_CQI_MOD31) ||
2171           (*cell)->bwCfg.dlTotalBw <= 7)))
2172    {
2173       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid aperiodic mode config for"
2174           " DL CQI %d for NEW CRNTI:%d", (uint8_t)ueRecfg->aprdDlCqiRecfg.aprdModeEnum,ueRecfg->newCrnti);
2175       return RFAILED;
2176    }
2177    if ((ueRecfg->ueRecfgTypes & RGR_UE_ULPWR_RECFG) &&
2178          (rgSCHCfgVldtUePwrCfg(*cell, &ueRecfg->ueUlPwrRecfg) != ROK))
2179    {
2180       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid PUSCH Group power"
2181            " Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
2182       return RFAILED;
2183    }
2184
2185
2186    if ((ueRecfg->ueRecfgTypes & RGR_UE_ACKNACK_MEASGAP_RECFG) &&
2187       (rgSCHCfgVldtUeMeasGapAckNakRepRecfg(*cell, ueRecfg) != ROK))
2188    {
2189       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid MeasGap/AckNackRep"
2190             " Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
2191       return RFAILED;
2192    }
2193 #ifdef LTEMAC_SPS
2194    if(rgSCHCfgVldtSpsReCfg(*cell, *ue, ueRecfg)!= ROK)
2195    {
2196       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid SPS"
2197            " Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
2198       return RFAILED;
2199    }
2200 #endif
2201 #ifdef TFU_UPGRADE
2202    /* Validated Periodic CQI/PMI, RI , SRS and SR related UeCfg */
2203    if ( ROK != rgSCHCfgVldtCqiSrSrsUeReCfg(*cell, *ue, ueRecfg,  errInfo))
2204    {
2205       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid ACQI, PCQI/SR/SRS "
2206                "Re-configuration for NEW CRNTI:%d",ueRecfg->newCrnti);
2207       return RFAILED;
2208    }
2209 #endif
2210    if ((ueRecfg->ueRecfgTypes & RGR_UE_DRX_RECFG) &&
2211       (rgSCHCfgVldtDrxUeCfg(*cell, &(ueRecfg->ueDrxRecfg)) != ROK))
2212    {
2213       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid drxParams"
2214             " Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
2215       return RFAILED;
2216    }
2217
2218 /* ccpu00117452 - MOD - Changed macro name from
2219    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
2220 #ifdef RGR_CQI_REPT
2221    /* Validate DL Power Control Config parameters */
2222    if(rgSCHCfgVldtCqiReptReCfg(*cell, ueRecfg)!= ROK)
2223    {
2224       RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid DL Power Control"
2225            " Reconfiguration for NEW CRNTI:%d",ueRecfg->newCrnti);
2226       return RFAILED;
2227    }
2228 #endif /* End of RGR_CQI_REPT */
2229    errInfo->errCause = RGSCHERR_NONE;
2230    return ROK;
2231 }  /* rgSCHCfgVldtRgrUeRecfg */
2232
2233
2234 /**
2235  * @brief Validates the logical channel reconfiguration request from
2236  * RRC to MAC.
2237  *
2238  * @details
2239  *
2240  *     Function : rgSCHCfgVldtRgrLchRecfg
2241  *
2242  *     Processing Steps:
2243  *      - Retrieve the uplink and downlink logical channel control block.
2244  *      - If successful,
2245  *        - Validate the range of reconfigured values recieved in
2246  *          re-configuration request.
2247  *        - If validated successfully,
2248  *          - Return ROK and pointer to the cell, UE and logical channel.
2249  *        - Else
2250  *          - Return RFAILED.
2251  *      - Else return RFAILED.
2252  *
2253  *  @param[in]  RgrLchRecfg     *lcRecfg
2254  *  @param[out] RgSchCellCb     **cell
2255  *  @param[out] RgSchUeCb       **ue
2256  *  @param[out] RgSchUlLcCb     **ulLc
2257  *  @param[out] RgSchDlLcCb     **dlLc
2258  *  @param[out] RgSchErrInfo       *errInfo
2259  *  @return  S16
2260  *      -# ROK
2261  *      -# RFAILED
2262  **/
2263 #ifdef ANSI
2264 S16 rgSCHCfgVldtRgrLchRecfg
2265 (
2266 Inst           inst,
2267 RgrLchRecfg    *lcRecfg,
2268 RgSchCellCb    **cell,
2269 RgSchUeCb      **ue,
2270 RgSchDlLcCb    **dlLc,
2271 RgSchErrInfo   *errInfo
2272 )
2273 #else
2274 S16 rgSCHCfgVldtRgrLchRecfg(inst, lcRecfg, cell, ue, dlLc, errInfo)
2275 Inst            inst;
2276 RgrLchRecfg     *lcRecfg;
2277 RgSchCellCb     **cell;
2278 RgSchUeCb       **ue;
2279 RgSchDlLcCb     **dlLc;
2280 RgSchErrInfo    *errInfo;
2281 #endif
2282 {
2283    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LC_RECFG;
2284
2285    if (((*cell) == NULLP) ||
2286        ((*cell)->cellId != lcRecfg->cellId))
2287    {
2288       RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Cell does not exist "
2289                 "for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
2290       return RFAILED;
2291    }
2292
2293    /* Fetch the Ue for dedicated channels */
2294    if ((*ue = rgSCHDbmGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
2295    {
2296       RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"UEID does not exist"
2297          "dedicated logical channel for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
2298       return RFAILED;
2299    }
2300
2301    if ((*dlLc = rgSCHDbmGetDlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
2302    {
2303       RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Dedicated DL LC does not "
2304                "exist for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
2305       return RFAILED;
2306    }
2307
2308    errInfo->errCause = RGSCHERR_NONE;
2309    return ROK;
2310 }  /* rgSCHCfgVldtRgrLchRecfg */
2311
2312 /**
2313  * @brief Validates the UE Reset request from RRM to MAC.
2314  *
2315  * @details
2316  *
2317  *     Function : rgSCHCfgVldtRgrUeReset
2318  *
2319  *     Processing Steps:
2320  *      - Retrieve the CELL control block
2321  *      - If cell does not exist return RFAILED
2322  *      - Retrieve UE Control block
2323  *      - If UE does not exist return RFAILED
2324  *      - Return ROK
2325  *
2326  *  @param[in]  Inst        inst
2327  *  @param[in]  RgrRst      *reset
2328  *  @param[out] RgSchCellCb **cell
2329  *  @param[out] RgSchUeCb      **ue
2330  *  @param[out] RgErrInfo   *errInfo
2331  *  @return  S16
2332  *      -# ROK
2333  *      -# RFAILED
2334  **/
2335 #ifdef ANSI
2336 S16 rgSCHCfgVldtRgrUeReset
2337 (
2338 Inst         inst,
2339 RgrRst       *reset,
2340 RgSchCellCb  *cell,
2341 RgSchUeCb    **ue,
2342 RgSchErrInfo *errInfo
2343 )
2344 #else
2345 S16 rgSCHCfgVldtRgrUeReset(inst, reset, cell, ue, errInfo)
2346 Inst         inst;
2347 RgrRst       *reset;
2348 RgSchCellCb  *cell;
2349 RgSchUeCb    **ue;
2350 RgSchErrInfo *errInfo;
2351 #endif
2352 {
2353
2354    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_RESET;
2355
2356    if ((cell == NULLP) || (cell->cellId != reset->cellId))
2357    {
2358       RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"CELL does not exist for CRNTI:%d",
2359                reset->crnti);
2360       return RFAILED;
2361    }
2362    /* Fetch the Ue  */
2363    if ((*ue = rgSCHDbmGetUeCb(&(*cell), reset->crnti)) == NULLP)
2364    {
2365       RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"UE does not exist for CRNTI:%d",
2366                reset->crnti);
2367       return RFAILED;
2368    }
2369
2370    errInfo->errCause = RGSCHERR_NONE;
2371
2372    return ROK;
2373 }  /* rgSCHCfgVldtRgrUeReset */
2374
2375
2376 /**
2377  * @brief Validates the logical channel reconfiguration request from
2378  * RRC to MAC.
2379  *
2380  * @details
2381  *
2382  *     Function : rgSCHCfgVldtRgrLcgRecfg
2383  *
2384  *     Processing Steps:
2385  *      - Retrieve the uplink and downlink logical channel control block.
2386  *      - If successful,
2387  *        - Validate the range of reconfigured values recieved in
2388  *          re-configuration request.
2389  *        - If validated successfully,
2390  *          - Return ROK and pointer to the cell, UE and logical channel.
2391  *        - Else
2392  *          - Return RFAILED.
2393  *      - Else return RFAILED.
2394  *
2395  *  @param[in]  RgrLchRecfg     *lcRecfg
2396  *  @param[out] RgSchCellCb     **cell
2397  *  @param[out] RgSchUeCb       **ue
2398  *  @param[out] RgSchErrInfo    *errInfo
2399  *  @return  S16
2400  *      -# ROK
2401  *      -# RFAILED
2402  **/
2403 #ifdef ANSI
2404 S16 rgSCHCfgVldtRgrLcgRecfg
2405 (
2406 Inst           inst,
2407 RgrLcgRecfg    *lcgRecfg,
2408 RgSchCellCb    *cell,
2409 RgSchUeCb      **ue,
2410 RgSchErrInfo   *errInfo
2411 )
2412 #else
2413 S16 rgSCHCfgVldtRgrLcgRecfg(inst, lcgRecfg, cell, ue, errInfo)
2414 Inst            inst;
2415 RgrLcgRecfg     *lcgRecfg;
2416 RgSchCellCb     *cell;
2417 RgSchUeCb       **ue;
2418 RgSchErrInfo    *errInfo;
2419 #endif
2420 {
2421    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LCG_RECFG;
2422
2423    if (((cell) == NULLP) ||
2424        ((cell)->cellId != lcgRecfg->cellId))
2425    {
2426       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Cell does not exist for"
2427                 "CRNTI:%d LCGID:%d",lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
2428       return RFAILED;
2429    }
2430
2431    /* Fetch the Ue for dedicated channels */
2432    if ((*ue = rgSCHDbmGetUeCb(&(*cell), lcgRecfg->crnti)) == NULLP)
2433    {
2434       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"UE does not exist for "
2435                 "dedicated logical channel group CRNTI:%d LCGID:%d",
2436                 lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
2437       return RFAILED;
2438    }
2439    if (lcgRecfg->ulRecfg.lcgId > (RGSCH_MAX_LCG_PER_UE - 1))
2440    {
2441       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Invalid lcgId for uplink logical"
2442                 "channel CRNTI:%d LCGID:%d",
2443                 lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
2444       return RFAILED;
2445    }
2446
2447    if ((lcgRecfg->ulRecfg.gbr != 0) && (lcgRecfg->ulRecfg.mbr < lcgRecfg->ulRecfg.gbr))
2448    {
2449       RGSCHDBGINFO(inst, (rgSchPBuf(inst), "Dedicated Logical Group %d validation failed"
2450                " for ue %d for cell %d\n", lcgCfg->ulInfo.lcgId, lcgCfg->crnti, lcgCfg->cellId));
2451       return RFAILED;
2452    }
2453    errInfo->errCause = RGSCHERR_NONE;
2454    return ROK;
2455 }  /* rgSCHCfgVldtRgrLcgRecfg */
2456
2457 /**
2458  *
2459  * @details
2460  *
2461  *     Function : rgSCHDynCfiCfg
2462  *
2463  *  @param[in]  RgSchCellCb   *cell
2464  *              RgrCellCfg    *cellCfg
2465  *  @return  S16
2466  *      -# ROK
2467  *      -# RFAILED
2468  **/
2469 #ifdef ANSI
2470 static S16 rgSCHDynCfiCfg
2471 (
2472 RgSchCellCb   *cell,
2473 RgrCellCfg    *cellCfg
2474 )
2475 #else
2476 static S16 rgSCHDynCfiCfg(cell, cellCfg)
2477 RgSchCellCb   *cell;
2478 RgrCellCfg    *cellCfg;
2479 #endif
2480 {
2481    uint8_t        cfi;
2482 #ifdef LTE_TDD
2483    uint8_t        ulDlCfgIdx = cellCfg->ulDlCfgIdx;
2484    uint8_t        mphIdx;
2485    uint8_t        maxMPhich;
2486    uint16_t       numDlSf;
2487 #endif
2488
2489    cell->dynCfiCb.isDynCfiEnb = cellCfg->isDynCfiEnb;
2490
2491    /* Initializing Failure Sample Period */
2492    cell->dynCfiCb.failSamplePrd = (RGSCH_CFI_TTI_MON_INTRVL *
2493                      RGSCH_CFI_STEP_UP_TTI_PRCNTG)/100;
2494    /* Initializing Number of Failure Samples */
2495    cell->dynCfiCb.numFailSamples = (RGSCH_CFI_TTI_MON_INTRVL/
2496                                     cell->dynCfiCb.failSamplePrd);
2497    cell->dynCfiCb.maxCfi = RGSCH_MAX_CFI_VAL;
2498    /* Allocating memory for CCE failure average array based on
2499     * monitoring interval and CCE failure sample period */
2500    if((rgSCHUtlAllocSBuf(cell->instIdx, (Data**)&(cell->dynCfiCb.cceFailSamples),
2501                (cell->dynCfiCb.numFailSamples * sizeof(uint16_t)))) != ROK)
2502    {
2503       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
2504       return RFAILED;
2505    }
2506
2507    /* Setting the Invalid value 0xFF to pdcchSfIdx, it will be assigned
2508     * a valid value during CFI swithing is done */
2509    cell->dynCfiCb.pdcchSfIdx = 0xFF;
2510
2511 #ifdef LTE_TDD
2512    /* In case of config index 0, the mphich index can be upto 2
2513     * in other config index cases, it will always be set as 1*/
2514    if(ulDlCfgIdx == 0)
2515    {
2516       maxMPhich = RG_SCH_MAX_MPHICH;
2517    }
2518    else
2519    {
2520       maxMPhich = RG_SCH_MAX_MPHICH -1;
2521    }
2522    /* Calculate the number of CCEs in the cell */
2523    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++)
2524    {
2525       for(mphIdx = 0; mphIdx < maxMPhich; mphIdx++)
2526       {
2527          cell->dynCfiCb.cfi2NCceTbl[mphIdx][cfi] =
2528             rgSCHUtlCalcNCce(cell->bwCfg.dlTotalBw,
2529                cell->phichCfg.ngEnum, cfi, mphIdx,
2530                cell->numTxAntPorts,
2531                cell->isCpDlExtend);
2532       }
2533    }
2534 #else
2535    /* Calculate the number of CCEs in the cell */
2536    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++)
2537    {
2538       /* CFI Index starts from 1 so that there can be a direct mapping from
2539          actual CFI value to cfi Index. mPhich index will always be set
2540          as 0 for FDD */
2541       cell->dynCfiCb.cfi2NCceTbl[0][cfi] =
2542             rgSCHUtlCalcNCce(cell->bwCfg.dlTotalBw, cell->phichCfg.ngEnum,
2543                   cfi, cell->numTxAntPorts, cell->isCpDlExtend);
2544    }
2545
2546    /* Calculate the number of CCEs in the cell */
2547    if(cell->dynCfiCb.isDynCfiEnb == TRUE)
2548    {
2549       /* In case if Dynamic CFI feature is enabled, default CFI
2550        * value 1 is used  */
2551       cell->nCce = cell->dynCfiCb.cfi2NCceTbl[0][1];
2552    }
2553    else
2554    {
2555       cell->nCce = cell->dynCfiCb.cfi2NCceTbl[0][cellCfg->cfiCfg.cfi];
2556    }
2557 #endif
2558
2559 #ifdef LTE_TDD
2560    numDlSf = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][9] *
2561                (RGSCH_CFI_TTI_MON_INTRVL/10);
2562    cell->dynCfiCb.cfiStepUpTtiCnt =
2563                (RGSCH_CFI_STEP_UP_TTI_PRCNTG * numDlSf)/100;
2564    cell->dynCfiCb.cfiStepDownTtiCnt =
2565                (RGSCH_CFI_STEP_DOWN_TTI_PERCNTG * numDlSf)/100;
2566 #else
2567    cell->dynCfiCb.cfiStepUpTtiCnt = (RGSCH_CFI_STEP_UP_TTI_PRCNTG *
2568                                      RGSCH_CFI_TTI_MON_INTRVL)/100;
2569    cell->dynCfiCb.cfiStepDownTtiCnt = (RGSCH_CFI_STEP_DOWN_TTI_PERCNTG *
2570                                      RGSCH_CFI_TTI_MON_INTRVL)/100;
2571 #endif
2572
2573    return ROK;
2574 }
2575
2576 /**
2577  * @brief Handler for the SCHED Enb configuration request from RRM to MAC.
2578  *
2579  * @details
2580  *
2581  *     Function : rgSCHCfgRgrSchedEnbCfg
2582  *
2583  *     Processing Steps:
2584  *      - Invoke SCH with SCHEDULER control block to update
2585  *        scheduler specific information.
2586  *      - Update rgSch control block with the values recieved in the
2587  *        configuration.
2588  *      - If successful, return ROK else RFAILED.
2589  *
2590  *  @param[in]  RgSchCb      *instCb
2591  *  @param[in]  SpId         spId
2592  *  @param[in]  RgSchSchedEnbCfg    *schedEnbCfg
2593  *  @param[out] RgSchErrInfo *errInfo
2594  *  @return  S16
2595  *      -# ROK
2596  *      -# RFAILED
2597  **/
2598 #ifdef ANSI
2599 S16 rgSCHCfgRgrSchedEnbCfg
2600 (
2601 Inst            inst,
2602 SpId            spId,
2603 RgrSchedEnbCfg *schedEnbCfg,
2604 RgSchErrInfo   *errInfo
2605 )
2606 #else
2607 S16 rgSCHCfgRgrSchedEnbCfg(inst, spId, schedEnbCfg, errInfo)
2608 Inst             inst,
2609 SpId             spId;
2610 RgrSchedEnbCfg  *schedEnbCfg;
2611 RgSchErrInfo    *errInfo;
2612 #endif
2613 {
2614
2615    RGSCHDBGPRM(inst, (rgSchPBuf(inst), "APPLYING RGR SCH ENB CONFIG: \n"));
2616    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_ENB_CFG;
2617
2618    rgSchCb[inst].rgrSchedEnbCfg = *schedEnbCfg;
2619    RGSCHDBGPRM(inst, (rgSchPBuf(inst),"\ndlSchdType %d ulSchdType %d dlTptCoeffi %d"
2620            "dlFairCoeffi %d  ulTptCoeffi %d ulFairCoeffi %d\n",
2621          schedEnbCfg->dlSchdType, schedEnbCfg->ulSchdType, schedEnbCfg->dlSchInfo.dlPfs.tptCoeffi,
2622          schedEnbCfg->dlSchInfo.dlPfs.fairCoeffi, schedEnbCfg->ulSchInfo.ulPfs.tptCoeffi,
2623          schedEnbCfg->ulSchInfo.ulPfs.fairCoeffi));
2624
2625 #ifdef RG_5GTF
2626    rgSchCb[inst].rgSchDynTdd.isDynTddEnbld = schedEnbCfg->isDynTddEnbld;
2627 #endif
2628 # if 0
2629    if(RGR_SCH_TYPE_PFS == schedEnbCfg->dlSchdType)
2630    {
2631      rgSCHEnbPfsDlCfg(inst, errInfo);
2632    }
2633 #endif
2634    errInfo->errCause = RGSCHERR_NONE;
2635    RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR SCH ENBconfig done: \n"));
2636    return ROK;
2637 }  /* rgSCHCfgRgrSchedEnbCfg */
2638
2639 #ifdef RG_5GTF
2640 /**
2641  * @brief Handler for the cell configuration of 5gtf.
2642  *
2643  * @details
2644  *
2645  *     Function : rgSCH5gtfCellCfg
2646  *
2647  *  @param[in]  RgSchCellCb   *cell
2648  *  @param[in]  RgSchCellCfg    *cellCfg
2649  *  @return  S16
2650  *      -# ROK
2651  *      -# RFAILED
2652  **/
2653 #ifdef ANSI
2654 S16 rgSCH5gtfCellCfg
2655 (
2656 RgSchCellCb   *cell,
2657 RgrCellCfg    *cellCfg
2658 )
2659 #else
2660 S16 rgSCH5gtfCellCfg(cell, cellCfg)
2661 RgSchCellCb   *cell;
2662 RgrCellCfg    *cellCfg;
2663 #endif
2664 {
2665    uint8_t           idx;
2666
2667    for(idx = 0; idx < MAX_5GTF_GROUP; idx++)
2668    {
2669       cell->cell5gtfCb.ueGrp5gConf[idx].beamBitMask = 0;
2670    }
2671
2672    for(idx = 0 ; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
2673    {
2674       cell->cell5gtfCb.dynConfig[idx] = cellCfg->Cell5gtfCfg.dynConfig[idx];
2675    }
2676    cell->cell5gtfCb.numUes = cellCfg->Cell5gtfCfg.numUes;
2677    cell->cell5gtfCb.uePerGrpPerTti = cellCfg->Cell5gtfCfg.uePerGrp;
2678    cell->cell5gtfCb.ueGrpPerTti = cellCfg->Cell5gtfCfg.ueGrpPerTti;
2679    cell->cell5gtfCb.numCCs = cellCfg->Cell5gtfCfg.numOfCC;
2680    cell->cell5gtfCb.bwPerCC = cellCfg->Cell5gtfCfg.bwPerCC;
2681    printf("\ncell cfg at schd,numUes:%u,uepergrp:%u,uegrppertti:%u,numCC:%u,bwPerc:%u cfi %u\n",
2682          cell->cell5gtfCb.numUes,cell->cell5gtfCb.uePerGrpPerTti,cell->cell5gtfCb.ueGrpPerTti,
2683          cell->cell5gtfCb.numCCs,cell->cell5gtfCb.bwPerCC, cell->cell5gtfCb.cfi);
2684    return ROK;
2685 }
2686 #endif
2687
2688 #ifdef XEON_LMT_ITBS
2689 uint16_t gWrMaxDlItbs;
2690 uint16_t gWrMaxUlItbs;
2691 #endif
2692 /**
2693  * @brief Handler for the cell configuration request from RRM to MAC.
2694  *
2695  * @details
2696  *
2697  *     Function : rgSCHCfgRgrCellCfg
2698  *
2699  *     Processing Steps:
2700  *      - Invoke SCH with cell control block to update
2701  *        scheduler specific information.
2702  *      - Update cell control block with the values recieved in the
2703  *        configuration.
2704  *      - Add to the active list of cells if cell becomes ACTIVE.
2705  *      - If successful, return ROK else RFAILED.
2706  *
2707  *  @param[in]  RgSchCb      *instCb
2708  *  @param[in]  SpId         spId
2709  *  @param[in]  RgSchCellCfg    *cellCfg
2710  *  @param[out] RgSchErrInfo *errInfo
2711  *  @return  S16
2712  *      -# ROK
2713  *      -# RFAILED
2714  **/
2715 #ifdef ANSI
2716 S16 rgSCHCfgRgrCellCfg
2717 (
2718 RgSchCb       *instCb,
2719 SpId          spId,
2720 RgrCellCfg    *cellCfg,
2721 RgSchErrInfo  *errInfo
2722 )
2723 #else
2724 S16 rgSCHCfgRgrCellCfg(instCb, spId, cellCfg, errInfo)
2725 RgSchCb       *instCb;
2726 SpId           spId;
2727 RgrCellCfg    *cellCfg;
2728 RgSchErrInfo  *errInfo;
2729 #endif
2730 {
2731    S16          ret;
2732    uint8_t           idx;
2733    Pst          pst;
2734    RgInfCellReg cellRegReq;
2735    RgSchCellCb  *cell = NULLP;
2736    Inst         inst = instCb->rgSchInit.inst;
2737    uint32_t          Idx1 = (uint8_t)((cellCfg->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
2738
2739    errInfo->errCause = RGSCHERR_CFG_RGR_CELL_CFG;
2740
2741    memset(&pst, 0, sizeof(Pst));
2742
2743    /* Allocate the scheduler's cell control block */
2744    if((ret = rgSCHUtlAllocSBuf(inst, (Data**)&cell, sizeof(RgSchCellCb)))
2745          != ROK)
2746    {
2747       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
2748       return RFAILED;
2749    }
2750 #ifdef EMTC_ENABLE
2751    if(cellCfg->emtcEnable)
2752    {
2753       if((ret = rgSCHEmtcCellAlloc(cell))
2754             != ROK)
2755       {
2756          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for emtc cell");
2757          return RFAILED;
2758       }
2759    }
2760 #endif
2761    if ((uint8_t *)cell == NULLP)
2762    {
2763       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
2764       return RFAILED;
2765    }
2766    /* Initialize the lists of the cell */
2767    ret = rgSCHDbmInitCell(cell);
2768    if (ret != ROK)
2769    {
2770       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization FAILED for cell");
2771       rgSCHCfgFreeCellCb(cell);
2772       return RFAILED;
2773    }
2774 /* LTE_ADV_FLAG_REMOVED_START */
2775    if(cellCfg->rgrLteAdvCfg.pres & RGR_ABS)
2776    {
2777       cell->lteAdvCb.absCfg =
2778          cellCfg->rgrLteAdvCfg.absCfg;
2779       memset(cell->lteAdvCb.absLoadInfo, 0, sizeof(uint32_t)*RGR_ABS_PATTERN_LEN);
2780       cell->lteAdvCb.absLoadTtiCnt = 0;
2781    }
2782
2783    if(cellCfg->rgrLteAdvCfg.pres & RGR_SFR)
2784    {
2785       cell->lteAdvCb.sfrCfg =
2786          cellCfg->rgrLteAdvCfg.sfrCfg;
2787    }
2788    if(cellCfg->rgrLteAdvCfg.pres & RGR_DSFR)
2789    {
2790       cell->lteAdvCb.dsfrCfg =
2791          cellCfg->rgrLteAdvCfg.dsfrCfg;
2792    }
2793 /* LTE_ADV_FLAG_REMOVED_END */
2794
2795 #ifdef EMTC_ENABLE
2796    cell->emtcEnable = cellCfg->emtcEnable;
2797 #endif
2798    /* Initialize the cell */
2799    cell->cellId = cellCfg->cellId;
2800    cell->instIdx = inst;
2801    cell->macInst = cellCfg->macInst;
2802    cell->isCpUlExtend = cellCfg->isCpUlExtend;
2803    cell->isCpDlExtend = cellCfg->isCpDlExtend;
2804
2805    cell->numTxAntPorts = rgSchCb[inst].rgrSchedEnbCfg.numTxAntPorts;
2806    if(cell->numTxAntPorts == 1)
2807    {
2808       cell->numCellRSPerSf = RGSCH_NUM_CELL_RS_ONE_ANT_PORT;
2809    }
2810    else if(cell->numTxAntPorts == 2)
2811    {
2812       cell->numCellRSPerSf = RGSCH_NUM_CELL_RS_TWO_ANT_PORT;
2813    }
2814    else
2815    {
2816       cell->numCellRSPerSf = RGSCH_NUM_CELL_RS_FOUR_ANT_PORT;
2817    }
2818    cell->bwCfg = cellCfg->bwCfg;
2819    cell->pbchRbStart = ((((cell->bwCfg.dlTotalBw * 12)/2) - 36)/12); /* Ref section 6.6 in 36.211 */
2820    cell->pbchRbEnd = cell->pbchRbStart + 5;
2821    cell->pucchCfg = cellCfg->pucchCfg;
2822    cell->rachCfg = cellCfg->rachCfg;
2823    cell->siCfg = cellCfg->siCfg;
2824    cell->t300TmrVal = cellCfg->t300TmrVal;
2825 #ifdef RGR_SI_SCH
2826    /*Initialize the SI CB in Cell CB */
2827    memset(&cell->siCb, 0, sizeof(RgSchSiCb));
2828 #endif
2829    /*Fix: Added Guard Pool for RNTI which will contain RNTIs
2830        *for UEs deleted from Scheduler but not yet from MAC*/
2831    cmLListInit(&cell->rntiDb.rntiGuardPool);
2832
2833    /* Initialize the inWindow to sync with scheduler time when ticks starts */
2834 #ifdef LTEMAC_HDFDD
2835       cell->siCb.inWindow = (cellCfg->siCfg.siWinSize -
2836             (RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL));
2837 #else
2838       cell->siCb.inWindow = (cellCfg->siCfg.siWinSize -
2839             (RG_SCH_CMN_DL_DELTA));
2840 #endif
2841
2842       if(cell->siCb.inWindow < 0)
2843       {
2844          cell->siCb.inWindow = 0;
2845       }
2846    cell->macPreambleSet = cellCfg->macPreambleSet;
2847    cell->phichCfg = cellCfg->phichCfg;
2848
2849    /* Initialize UL and DL CCCH logical channels */
2850    cell->ulCcchId = RGSCH_INVALID_LC_ID;
2851    cell->dlCcchId = RGSCH_INVALID_LC_ID;
2852
2853    /* Update SRS configuration */
2854    cell->srsCfg.isSrsCfgPres = cellCfg->srsCfg.isSrsCfgSetup;
2855    if(cellCfg->srsCfg.isSrsCfgSetup)
2856    {
2857       cell->srsCfg.srsCfgPrdEnum = cellCfg->srsCfg.srsCfgPrdEnum;
2858       cell->srsCfg.srsBwEnum = cellCfg->srsCfg.srsBwEnum;
2859       cell->srsCfg.srsTxOffst =
2860          rgSrsTxOffstTbl[cellCfg->srsCfg.srsSubFrameCfg];
2861       /*ccpu00116923 - ADD - Srs Present support */
2862 #ifdef TFU_UPGRADE
2863       cell->srsCfg.srsSubFrameCfg = cellCfg->srsCfg.srsSubFrameCfg;
2864 #endif
2865    }
2866
2867    /* Configure all the common logical channels for the cell */
2868    for(idx = 0; idx < cellCfg->numCmnLcs; idx++)
2869    {
2870       /* This never returns failure and hence not checked for */
2871       rgSCHCfgRgrCmnLcCfg(cell, &(cellCfg->cmnLcCfg[idx]), errInfo);
2872    }
2873
2874    /* Invoke the MeasGap and ACK NACK Rep handler for cell cfg */
2875
2876    /* Dynamic CFI cell configuration */
2877    ret = rgSCHDynCfiCfg(cell, cellCfg);
2878    if(ret != ROK)
2879    {
2880       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr cell Config failed at "
2881        "Scheduler for cell");
2882       rgSCHCfgFreeCellCb(cell);
2883       return RFAILED;
2884    }
2885    /* Updating Auto TM Mode enable/diable flag */
2886    cell->isAutoCfgModeEnb = cellCfg->isAutoCfgModeEnb;
2887    {
2888      if(cell->isAutoCfgModeEnb)
2889      {
2890         RLOG0(L_INFO,"Auto Mode Cfg enabled durint cell cfg\n");
2891      }
2892    }
2893    /* CPU OvrLoad State Initialization */
2894 #ifdef XEON_LMT_ITBS
2895    cell->thresholds.maxDlItbs = gWrMaxDlItbs;
2896    cell->thresholds.maxUlItbs = gWrMaxUlItbs;
2897    RLOG2(L_INFO,"LIMIT DL and UL ITBS %d:%d \n",gWrMaxDlItbs,gWrMaxUlItbs);
2898 #else
2899    cell->thresholds.maxDlItbs = RG_SCH_DL_MAX_ITBS;
2900    cell->thresholds.maxUlItbs = RG_SCH_UL_MAX_ITBS;
2901 #endif
2902    cell->measurements.dlTpt = 0;
2903    cell->measurements.ulTpt = 0;
2904    cell->measurements.dlBytesCnt = 0;
2905    cell->measurements.ulBytesCnt = 0;
2906    cell->cpuOvrLdCntrl.cpuOvrLdIns = 0; /* 0 - No command */
2907    cell->cpuOvrLdCntrl.dlNxtIndxDecNumUeTti = 0;
2908    cell->cpuOvrLdCntrl.ulNxtIndxDecNumUeTti = 0;
2909    for ( idx = 0; idx < 10; idx++ )
2910    {
2911       cell->cpuOvrLdCntrl.maxUeNewTxPerTti[idx] = cellCfg->maxDlUeNewTxPerTti;
2912       cell->cpuOvrLdCntrl.maxUeNewRxPerTti[idx] = cellCfg->maxUlUeNewTxPerTti;
2913    }
2914
2915    /* Invoke scheduler to update scheduler specific information */
2916    ret =  rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo);
2917    if (ret != ROK)
2918    {
2919       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr cell Config failed at "
2920        "Scheduler for cell ");
2921       rgSCHCfgFreeCellCb(cell);
2922       return RFAILED;
2923    }
2924
2925    /* Invoke DHM to update DHM specific information */
2926    rgSCHDhmRgrCellCfg(cell, cellCfg, errInfo);
2927
2928
2929    /* Initialize RNTI DB */
2930    ret = rgSCHDbmRntiDbInit(cell, cellCfg->macRnti.startRnti,
2931          cellCfg->macRnti.size);
2932    if (ret != ROK)
2933    {
2934       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr Cell Config failed at"
2935           " RNTI DB init for cell");
2936       rgSCHCfgFreeCellCb(cell);
2937       return RFAILED;
2938    }
2939
2940    /* Update the cell with recieved configuration */
2941    cell->dlHqCfg  =  cellCfg->dlHqCfg;
2942
2943    RLOG1(L_INFO,"Config DL HQTX = %d\n",cell->dlHqCfg.maxDlHqTx);
2944
2945    cell->crntSfIdx = 0;
2946    /* Allocate the subframe allocation information */
2947    if((ret = rgSCHUtlGetSfAlloc(cell)) != ROK)
2948    {
2949       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for "
2950                "cell");
2951       rgSCHCfgFreeCellCb(cell);
2952       return RFAILED;
2953    }
2954    /* Update RACH Related information
2955     * XXX: Below function yet to be written in RAM
2956     * To store the preambles given in  the configuration for PDCCH order in the
2957     * scheduler cell control block. Initialize the PRACH Mask Index allocated
2958     * for these preambles to invalid values */
2959
2960    cell->crntHqIdx = 0;
2961    /* Allocate the subframe allocation information */
2962    if((ret = rgSCHUtlGetRlsHqAlloc(cell)) != ROK)
2963    {
2964       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for"
2965                "cell");
2966       rgSCHCfgFreeCellCb(cell);
2967       return RFAILED;
2968    }
2969
2970    /* Associate a pair of upper and lower sapCbs with this cell */
2971    instCb->rgrSap[spId].cell = cell;
2972    instCb->tfuSap[spId].cell = cell;
2973    instCb->rgmSap[spId].cell = cell;
2974    cell->tfuSap = &(instCb->tfuSap[spId]);
2975
2976    /* CaDev Start */
2977       instCb->cells[Idx1] = cell;
2978    /* CaDev End */
2979
2980    /* rg001.201: Added for sending TTI tick to RRM */
2981 #if (defined(RGR_RRM_TICK) || defined(RGR_CQI_REPT))
2982    /* Associate the RGR SAP as well utilized while sending TTI
2983     * Ticks to RGR User. */
2984    cell->rgrSap = &(instCb->rgrSap[spId]);
2985 #endif
2986    cell->rgmSap = &(instCb->rgmSap[spId]);
2987 #ifdef RGR_RRM_TICK
2988    /* Store the periodicity configured */
2989    cell->rrmTtiIndPrd = cellCfg->rrmTtiIndPrd;
2990 #endif
2991
2992 #ifdef LTE_L2_MEAS
2993    cmLListInit(&cell->l2mList);
2994 #endif
2995
2996    if (rgSCHDrxCellCfg(cell,cellCfg) != ROK)
2997    {
2998       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Drx Memory allocation FAILED for"
2999          " cell");
3000       rgSCHCfgFreeCellCb(cell);
3001       return RFAILED;
3002    }
3003    cell->overLoadBackOffEnab = FALSE;/* Disabling RachOverload by default */
3004    /* Updating CSG Parameters */
3005    cell->minDlResNonCsg = cellCfg->csgParamCfg.minDlResNonCsg;
3006    cell->minUlResNonCsg = cellCfg->csgParamCfg.minUlResNonCsg;
3007
3008    /* Register the cell with MAC */
3009    rgSCHUtlGetPstToLyr(&pst, instCb, cell->macInst);
3010    cellRegReq.cellId = cell->cellId;
3011    cellRegReq.cellSapId = spId;
3012 #ifdef LTE_TDD
3013    cellRegReq.maxDlHqProcPerUe = rgSchTddDlNumHarqProcTbl[cellCfg->ulDlCfgIdx];
3014 #else
3015    cellRegReq.maxDlHqProcPerUe = RGSCH_MAX_DL_HQ_PROC;
3016 #endif
3017    RgSchMacCellReg(&pst, &cellRegReq);
3018
3019 #ifdef TENB_STATS
3020    cell->tenbStats = TSL2AllocCellStatsBlk(cell->cellId);
3021    cell->tenbStats->cellId = cell->cellId;
3022 #endif
3023
3024    rgSCHUtlCalcDciSizes(cell);
3025
3026 #ifdef LTE_ADV
3027    /* Initilalization of the list of UE for which this cell is secondary cell*/
3028    cmLListInit(&cell->sCellUeLst);
3029 #endif
3030
3031
3032 #ifdef LTE_ADV
3033    ret = rgSCHLaaSCellCbInit(cell, cellCfg);
3034    if (ret != ROK)
3035    {
3036       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr Cell Config failed at"
3037           " Initializing the LAA Cell Control Cb");
3038       rgSCHCfgFreeCellCb(cell);
3039       return RFAILED;
3040    }
3041    cell->isPucchFormat3Sptd = cellCfg->isPucchFormat3Sptd;
3042    RLOG_ARG0(L_INFO,DBG_CELLID,cellCfg->cellId,"Format 3 is Enabled");
3043    printf ("\n Format 3 is Enabled for CELL:%d",cell->cellId);
3044 #endif
3045
3046
3047 #ifdef EMTC_ENABLE
3048
3049         if(cell->emtcEnable)
3050         {
3051           if (rgSCHCfgEmtcCellCfg(cell,&(cellCfg->emtcCellCfg)) != ROK)
3052           {
3053                  RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"EMTC Config Failed"
3054                                           " cell");
3055                  return RFAILED;
3056           }
3057         }
3058 #endif
3059
3060 #ifdef RG_5GTF
3061    ret = rgSCH5gtfCellCfg(cell, cellCfg);
3062    if (ret != ROK)
3063    {
3064       RLOG_ARG0(L_ERROR, DBG_CELLID,cellCfg->cellId,"5GTF Rgr Cell Config failed");
3065       rgSCHCfgFreeCellCb(cell);
3066       return RFAILED;
3067    }
3068 #endif
3069    errInfo->errCause = RGSCHERR_NONE;
3070    return ROK;
3071 }  /* rgSCHCfgRgrCellCfg */
3072
3073 /**
3074  * @brief Handler for the UE configuration request from RRC to MAC.
3075  *
3076  * @details
3077  *
3078  *     Function : rgSCHCfgRgrUeCfg
3079  *
3080  *     Processing Steps:
3081  *      - Allocate and create UE control block.
3082  *      - Update UE control block with the values recieved in the
3083  *        configuration.
3084  *      - Invoke RAM, SCH, UHM and DHM with created UE control block, to
3085  *        update random access, scheduler, uplink harq and downlink harq
3086  *        specific information respectively.
3087  *      - If successful, add the control block to hash list of UEs for the cell
3088  *        else Rollback and FAIL.
3089  *
3090  *  @param[in]  RgSchCellCb  *cell
3091  *  @param[in]  RgrUeCfg     *ueCfg
3092  *  @param[out] RgSchErrInfo *errInfo
3093  *  @return  S16
3094  *      -# ROK
3095  *      -# RFAILED
3096  **/
3097 #ifdef ANSI
3098 S16 rgSCHCfgRgrUeCfg
3099 (
3100 RgSchCellCb  *cell,
3101 RgrUeCfg     *ueCfg,
3102 RgSchErrInfo *errInfo
3103 )
3104 #else
3105 S16 rgSCHCfgRgrUeCfg(cell, ueCfg, errInfo)
3106 RgSchCellCb  *cell;
3107 RgrUeCfg     *ueCfg;
3108 RgSchErrInfo *errInfo;
3109 #endif
3110 {
3111    S16          ret;
3112    RgSchRaCb    *raCb=NULLP;
3113    RgSchUeCb    *ue = NULLP;
3114    Inst         inst = cell->instIdx;
3115    uint32_t          lcgCnt;
3116    RgSchDlHqEnt *hqEnt = NULLP;
3117 #ifdef LTE_TDD
3118    uint8_t           ulDlCfgIdx = cell->ulDlCfgIdx;
3119    uint8_t           maxSubframes ;
3120    uint8_t           maxDlSubframes;
3121 #endif
3122    uint32_t          idx = 0;
3123 #ifdef TFU_UPGRADE
3124    RgSchUePCqiCb *cqiCb = NULLP;
3125 #endif
3126
3127   do {
3128      errInfo->errCause = RGSCHERR_CFG_RGR_UE_CFG;
3129      /* RACHO : Check for raCb only if preamble Id not provded */
3130 #ifndef PRE_DEF_UE_CTX
3131      if (ueCfg->dedPreambleId.pres == NOTPRSNT)
3132      {
3133         if ((raCb = rgSCHDbmGetRaCb(cell, ueCfg->crnti)) == NULLP)
3134         {
3135            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"No RaCb exists for"
3136                     "CRNTI:%d ",ueCfg->crnti);
3137            break;
3138         }
3139      }
3140 #endif
3141
3142      /* Allocate the Ue control block */
3143      if (((rgSCHUtlAllocSBuf(inst, (Data **)&ue, sizeof(RgSchUeCb))) != ROK) ||
3144             ((uint8_t *)ue == NULLP))
3145      {
3146         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId, "Memory allocation"
3147            " FAILED for CRNTI:%d", ueCfg->crnti);
3148         break;
3149      }
3150
3151      /* Inititialize Ue control block */
3152      ue->ueId = ueCfg->crnti;
3153      ue->cell = cell;
3154      /*ccpu00117778- Initialize Transmission Indices upon UE CB creation */
3155 #ifdef LA
3156    ue->lastRprdAckNackTime.sfn = cell->crntTime.sfn;
3157    ue->lastRprdAckNackTime.subframe = cell->crntTime.slot;
3158    ue->ueIdle = FALSE;
3159 #endif
3160
3161    /* Allocate the Ue control block */
3162    if (((rgSCHUtlAllocSBuf(inst, (Data **)&(ue->cellInfo[RGSCH_PCELL_INDEX]),
3163                   sizeof(RgSchUeCellInfo))) != ROK))
3164    {
3165 #ifndef ALIGN_64BIT
3166       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%lu]SCellIdx :Memomy allocation "
3167                "Failed while Adding SCell Information\n", idx));
3168 #else
3169       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%u]SCellIdx :Memomy allocation "
3170                "Failed while Adding SCell Information\n", idx));
3171 #endif
3172       return RFAILED;
3173    }
3174
3175    ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)] = RGSCH_PCELL_INDEX;
3176    ue->cellInfo[RGSCH_PCELL_INDEX]->cell = cell;
3177    ue->cellInfo[RGSCH_PCELL_INDEX]->ue = ue;
3178 #ifdef LTE_ADV
3179    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellState = RG_SCH_SCELL_ACTIVE;
3180    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellIdx = RGSCH_PCELL_INDEX;
3181    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellId = cell->cellId;
3182
3183    if (ROK != rgSCHLaaInitDlRbAllocCb(cell,
3184             &ue->cellInfo[RGSCH_PCELL_INDEX]->dlAllocCb))
3185    {
3186       return RFAILED;
3187    }
3188 #endif
3189 #ifdef TFU_UPGRADE
3190      cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
3191      cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
3192      cqiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
3193      ue->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
3194      ue->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
3195 #endif
3196    /* LTE_ADV_FLAG_REMOVED_START */
3197    /* While doing UE configuration for SFR at SCH, by default
3198     * CC UE power is configured as LOW */
3199    ue->lteAdvUeCb.isCCUePHigh = FALSE;
3200    /* LTE_ADV_FLAG_REMOVED_END */
3201
3202      /* Initialize the lists of the UE */
3203      if((rgSCHDbmInitUe(ue)) != ROK)
3204      {
3205         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"DBM initialization "
3206            "failed for CRNTI:%d", ueCfg->crnti);
3207         break;
3208      }
3209 #ifdef EMTC_ENABLE
3210      if(raCb != NULLP)
3211      {
3212         if(TRUE == raCb->isEmtcRaCb)
3213         {
3214            ue->isEmtcUe = TRUE;
3215            if (rgSCHUtlUpdUeEmtcInfo(cell, ueCfg, ue) != ROK)
3216            {
3217               RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"EMTC UE Cfg"
3218                     "failed for CRNTI:%d", ueCfg->crnti);
3219               break;
3220            }
3221         }
3222      }
3223 #endif
3224
3225      /* Initialize scheduler related information for UE */
3226      if(rgSCHUtlRgrUeCfg(cell, ue, ueCfg, errInfo) != ROK)
3227      {
3228         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Scheduler handling "
3229                  "failed in config for CRNTI:%d", ueCfg->crnti);
3230         break;
3231      }
3232
3233      ret = rgSCHUhmHqEntInit(cell, ue);
3234      if (ret != ROK)
3235      {
3236         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"UHM HARQ Ent Init "
3237            "Failed for CRNTI:%d", ueCfg->crnti);
3238         break;
3239      }
3240
3241      /* Initialize RAM related information for UE
3242       * RACHO: if preamble Id is present in ueCfg then raCb will be NULL
3243       * so rgSCHRamRgrUeCfg should take care of creating raCb */
3244    if ((ueCfg->dedPreambleId.pres == NOTPRSNT) && (NULLP != raCb) )
3245      {
3246         if((rgSCHRamRgrUeCfg(cell, ue, raCb, errInfo)) != ROK)
3247         {
3248            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Random access "
3249               "handling config failed for CRNTI:%d", ueCfg->crnti);
3250            break;
3251         }
3252      }
3253      else /* if HO Ue */
3254      {
3255         RG_SCH_CMN_GET_UE_HQE(ue, cell) = rgSCHDhmHqEntInit(cell);
3256         hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
3257         if (hqEnt == NULLP)
3258         {
3259            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Hq Entity Initialization "
3260                     "failed in config for CRNTI:%d", ueCfg->crnti);
3261            break;
3262         }
3263 #ifdef EMTC_ENABLE
3264         rgSCHEmtcHqPAlloc(cell, hqEnt);
3265 #endif
3266         hqEnt->ue = ue;
3267         /* Fix : syed Assign hqEnt to UE only if msg4 is done */
3268
3269         rgSCHCmnDlInitHqEnt(cell, hqEnt);
3270
3271         /* For Hand-In UE Request Aper CQI report
3272          * immediately */
3273         if (ueCfg->ueDlCqiCfg.aprdCqiCfg.pres)
3274         {
3275            /* Set APCQI for Pcell only*/
3276            ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
3277         }
3278      }
3279      /* CA dev Start */
3280 #ifdef LTE_TDD
3281      maxDlSubframes = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
3282      maxSubframes = 2 * maxDlSubframes;
3283      ue->dl.numHqDlSfInfo = maxSubframes;
3284      rgSCHUtlAllocSBuf(cell->instIdx,
3285            (Data **)&ue->dl.dlSfHqInfo, sizeof(RgSchDlHqInfo) * (ue->dl.numHqDlSfInfo));
3286
3287 #else
3288      ue->dl.numHqDlSfInfo = RGSCH_NUM_DL_slotS;
3289 #endif
3290 #ifndef RG_5GTF
3291      for (idx =0;idx < ue->dl.numHqDlSfInfo; idx++)
3292      {
3293         cmLListInit(&ue->dl.dlSfHqInfo[idx].hqPLst);
3294         ue->dl.dlSfHqInfo[idx].dlSfUeLnk.node = NULLP;
3295
3296      }
3297 #else
3298      {
3299         uint8_t cellIdx=0;
3300         for (cellIdx = 0;cellIdx < MAX_5GTF_CELL ; cellIdx++)
3301         {
3302            for (idx =0;idx < ue->dl.numHqDlSfInfo; idx++)
3303            {
3304               cmLListInit(&ue->dl.dlSfHqInfo[cellIdx][idx].hqPLst);
3305               ue->dl.dlSfHqInfo[cellIdx][idx].dlSfUeLnk.node = NULLP;
3306            }
3307         }
3308      }
3309 #endif
3310 #ifdef LTE_ADV
3311      rgSCHLaaInitDlHqInfo(cell, ue);
3312 #endif
3313      /* CA dev End */
3314
3315      /* Initialize lcgIds to Invalid */
3316      for (lcgCnt = 0; lcgCnt < RGSCH_MAX_LCG_PER_UE; lcgCnt++)
3317      {
3318         ue->ul.lcgArr[lcgCnt].lcgId = RGSCH_INVALID_LCG_ID;
3319      }
3320      if(raCb != NULLP)
3321      {
3322         rgSCHCfgRgrUePhrMsg3(cell,raCb,ue,errInfo);
3323         /* Moved this code out of rgSCHCfgRgrUePhrMsg3()
3324          * as it was not the appropriate place to
3325          * do this. */
3326         if (raCb->raState == RGSCH_RA_MSG4_DONE)
3327         {
3328            RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
3329                  "RNTI:%d RaCb deleted as Msg4 transmission is done",
3330                  raCb->tmpCrnti);
3331            rgSCHRamDelRaCb(cell, raCb, FALSE);
3332         }
3333      }
3334      /* Initialize uplink HARQ related information for UE */
3335      rgSCHUhmRgrUeCfg(cell, ue, ueCfg);
3336      cmInitTimers(&ue->bsrTmr, 1);
3337 #ifdef RGR_V1
3338      /* Added periodic BSR timer */
3339      cmInitTimers(&ue->bsrTmr, 1);
3340
3341      /* Fix - Added proper configuration from U-ARM */
3342      if(ueCfg->ueBsrTmrCfg.isPrdBsrTmrPres == TRUE)
3343      {
3344         ue->ul.bsrTmrCfg.isPrdBsrTmrPres = TRUE;
3345         ue->ul.bsrTmrCfg.prdBsrTmr       = ueCfg->ueBsrTmrCfg.prdBsrTmr;
3346         ue->ul.bsrTmrCfg.retxBsrTmr      = ueCfg->ueBsrTmrCfg.retxBsrTmr;
3347      }
3348
3349 #endif
3350      /* Initialize downlink HARQ related information for UE */
3351      rgSCHDhmRgrUeCfg(cell, ue, ueCfg, errInfo);
3352
3353      /* Initialize MeasureGap and Acknack Rep Information for UE */
3354      if((rgSCHMeasGapANRepUeCfg(cell, ue, ueCfg)) != ROK)
3355      {
3356         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Measurement Gap and"
3357                  " AckNack Rep failed in Config for CRNTI:%d", ueCfg->crnti);
3358         break;
3359      }
3360
3361
3362 #ifdef LTE_TDD
3363      if((rgSCHUtlAllocUeANFdbkInfo(ue,RGSCH_PCELL_INDEX)) != ROK)
3364      {
3365         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Memomy allocation "
3366                  "Failed while UE related Ack Nack Information for CRNTI:%d",
3367                  ueCfg->crnti);
3368         break;
3369      }
3370      ue->dl.ackNackMode = ueCfg->ackNackModeEnum;
3371 #endif /* LTE_TDD */
3372
3373      /* Insert Ue */
3374      rgSCHDbmInsUeCb(cell, ue);
3375
3376 #ifdef TFU_UPGRADE
3377      /*  Int ialize APeriodic CQI/PMI/RI Information for UE */
3378
3379    RGSCHDBGPRM(cell->instIdx,(rgSchPBuf(cell->instIdx),
3380             "\n rgSCHCfgRgrUeCfg : CellID=%d  UeId =%d  AcqiCfg Pres =%d",
3381             cell->cellId, ue->ueId, ueCfg->ueDlCqiCfg.aprdCqiCfg.pres));
3382
3383       /*Store Trigger Set Bit String to UE */
3384
3385       ret = rgSCHCfgACqiUeCfg(cell,ue, (RG_SCH_CMN_GET_ACQICB(ue,cell)),ue->mimoInfo.txMode,
3386            &ueCfg->ueDlCqiCfg.aprdCqiCfg, ue->ueCatEnum);
3387
3388      ue->cqiRiWritIdx = 0;
3389      ue->cqiRiReadIdx = 0;
3390      /*   Initialize Periodic CQI/PMI, RI Information for UE  */
3391      ret = rgSCHCfgPCqiUeCfg(cell, ue, &ueCfg->ueDlCqiCfg.prdCqiCfg,
3392            ue->ueCatEnum);
3393
3394      /*   Initialize UL SRS Information for UE  */
3395      ret = rgSCHCfgSrsUeCfg(cell, ue, &ueCfg->srsCfg);
3396
3397      /*   Initialize SR Information for UE  */
3398      ret = rgSCHCfgSrUeCfg(cell, ue, &ueCfg->srCfg);
3399 #endif
3400
3401 #ifdef LTEMAC_HDFDD
3402      if (rgSCHHdFddUeCfg(cell, ue, ueCfg->isHdFddEnbld) != ROK)
3403      {
3404         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,
3405                  "Could not do HD-FDD config for CRNTI:%d",ueCfg->crnti);
3406         break;
3407      }
3408
3409 #endif /* LTEMAC_HDFDD */
3410      /* ccpu00117452 - MOD - Changed macro name from
3411         RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
3412 #ifdef RGR_CQI_REPT
3413      ue->cqiReptCfgInfo.numColltdCqiRept =
3414         ueCfg->ueCqiReptCfg.numColltdCqiRept;
3415 #endif /* End of RGR_CQI_REPT */
3416 #ifdef TFU_UPGRADE
3417      RG_SCH_CMN_GET_PA(ue,cell).pres = FALSE;
3418      if (RG_SCH_UE_CFG_ISPAPRSNT(ueCfg->uePdschDedCfg.uepACfg))
3419      {
3420         RG_SCH_CMN_GET_PA(ue,cell).pres = TRUE;
3421         RG_SCH_CMN_GET_PA(ue,cell).val = ueCfg->uePdschDedCfg.uepACfg.pA;
3422      }
3423 #endif
3424      ue->isDrxEnabled = ueCfg->ueDrxCfg.isDrxEnabled;
3425
3426      if ( ue->isDrxEnabled )
3427      {
3428         if((rgSCHDrxUeCfg(cell,ue,ueCfg)) != ROK )
3429         {
3430            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"DRX configuration failed",
3431                      ueCfg->crnti);
3432            break;
3433         }
3434      }
3435
3436      /* LTE_ADV_FLAG_REMOVED_START */
3437      if ((cell->lteAdvCb.sfrCfg.status == RGR_ENABLE) ||    \
3438         (cell->lteAdvCb.absCfg.status == RGR_ENABLE))
3439      {
3440         ue->lteAdvUeCb.rgrLteAdvUeCfg = ueCfg->ueLteAdvCfg;
3441      }
3442      /* LTE_ADV_FLAG_REMOVED_END */
3443
3444 #ifdef TENB_STATS
3445      ue->tenbStats = TSL2AllocUeStatsBlk(ue->ueId);
3446      ue->tenbStats->stats.rnti = ue->ueId;
3447 #endif
3448 #ifdef LTE_ADV
3449      /*Update A Value for PCell TBs*/
3450      ue->f1bCsAVal = rgSCHUtlGetMaxTbSupp(ue->mimoInfo.txMode);
3451      RLOG_ARG1(L_ERROR,DBG_CELLID, ueCfg->cellId,
3452             "\n UeCfg A value is %d\n",ue->f1bCsAVal);
3453 #endif
3454      errInfo->errCause = RGSCHERR_NONE;
3455
3456      ue->accessStratumRls = ueCfg->accessStratumRls;
3457      if (ue->numSCells > 0)
3458      {
3459         /* 2 bit CSI */
3460         rgSCHUtlUpdUeDciSize(cell, ue, TRUE);
3461      }
3462      else
3463      {
3464         /* 1 bit CSI Access Stratum Release Change */
3465         rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
3466      }
3467
3468      return ROK;
3469   }while(0);
3470
3471   if (ue)
3472   {
3473      rgSCHCfgFreeUeCb(cell, ue);
3474   }
3475   return RFAILED;
3476 }  /* rgSCHCfgRgrUeCfg */
3477
3478 /**
3479  * @brief Handler for PHR for MSG3.
3480  *
3481  * @details
3482  *
3483  *     Function : rgSCHCfgRgrUePhrMsg3
3484  *
3485  *     Processing Steps:
3486  *       Handle PHR related config for MSG3
3487  *
3488  *  @param[in]  RgSchCellCb  *cell
3489  *  @param[in]  RgrUeCb     *ueCb
3490  *  @param[in]  RgSchRaCb    *raCb
3491  *  @param[out] RgSchErrInfo *errInfo
3492  **/
3493 #ifdef ANSI
3494 static Void rgSCHCfgRgrUePhrMsg3
3495 (
3496 RgSchCellCb  *cell,
3497 RgSchRaCb    *raCb,
3498 RgSchUeCb    *ue,
3499 RgSchErrInfo *errInfo
3500 )
3501 #else
3502 static Void rgSCHCfgRgrUePhrMsg3(cell, raCb, ue, errInfo)
3503 RgSchCellCb  *cell;
3504 RgSchRaCb    *raCb;
3505 RgSchUeCb    *ue;
3506 RgSchErrInfo *errInfo;
3507 #endif
3508 {
3509
3510    /* Record msg3 allocation in the UE */
3511    rgSCHUtlRecMsg3Alloc(cell, ue, raCb);
3512
3513    /* If raCb received PHR, update scheduler */
3514    if(raCb->phr.pres == TRUE)
3515    {
3516       ue->macCeRptTime = raCb->msg3AllocTime;
3517       rgSCHUtlUpdPhr(cell, ue, raCb->phr.val, errInfo);
3518    }
3519
3520    return;
3521 }
3522
3523 /**
3524  *
3525  * @details
3526  *
3527  *     Function : rgSCHDynCfiReCfg
3528  *
3529  *  @param[in]  RgSchCellCb   *cell
3530  *              Bool          isDynCfiEnb
3531  *  @return  S16
3532  *      -# ROK
3533  *      -# RFAILED
3534  **/
3535 #ifdef ANSI
3536 Void rgSCHDynCfiReCfg
3537 (
3538 RgSchCellCb   *cell,
3539 Bool          isDynCfiEnb
3540 )
3541 #else
3542 Void rgSCHDynCfiReCfg(cell, isDynCfiEnb)
3543 RgSchCellCb   *cell;
3544 Bool          isDynCfiEnb;
3545 #endif
3546 {
3547    uint8_t                idx;
3548    RgSchCmnDlCell    *cellSchDl = RG_SCH_CMN_GET_DL_CELL(cell);
3549
3550    if(isDynCfiEnb)
3551    {
3552       cell->dynCfiCb.ttiCnt = 0;
3553       cellSchDl->newCfi = cellSchDl->currCfi;
3554    }
3555    else
3556    {
3557       /* Resetting the parameters*/
3558       cell->dynCfiCb.cceFailCnt          = 0;
3559       cell->dynCfiCb.cceFailSum          = 0;
3560       cell->dynCfiCb.prevCceFailIdx      = 0;
3561
3562       for(idx = 0; idx < cell->dynCfiCb.numFailSamples; idx++)
3563       {
3564          cell->dynCfiCb.cceFailSamples[idx] = 0;
3565       }
3566
3567       cell->dynCfiCb.cceUsed             = 0;
3568       cell->dynCfiCb.lowCceCnt           = 0;
3569       cell->dynCfiCb.ttiCnt = 0;
3570    }
3571 }
3572 /**
3573  * @brief Handler for the cell reconfiguration request from RRM to MAC.
3574  *
3575  * @details
3576  *
3577  *     Function : rgSCHCfgRgrCellRecfg
3578  *
3579  *     Processing Steps:
3580  *      - Invoke SCH with cell control block to update
3581  *        scheduler specific information.
3582  *      - Update cell control block with the values recieved in the
3583  *        configuration.
3584  *      - If successful, return ROK else RFAILED.
3585  *
3586  *  @param[in]  RgSchCellCb   *cell
3587  *  @param[in]  RgrCellRecfg  *cellRecfg
3588  *  @param[out] RgSchErrInfo  *errInfo
3589  *  @return  S16
3590  *      -# ROK
3591  *      -# RFAILED
3592  **/
3593 #ifdef ANSI
3594 S16 rgSCHCfgRgrCellRecfg
3595 (
3596 RgSchCellCb   *cell,
3597 RgrCellRecfg  *cellRecfg,
3598 RgSchErrInfo  *errInfo
3599 )
3600 #else
3601 S16 rgSCHCfgRgrCellRecfg(cell, cellRecfg, errInfo)
3602 RgSchCellCb   *cell;
3603 RgrCellRecfg  *cellRecfg;
3604 RgSchErrInfo  *errInfo;
3605 #endif
3606 {
3607    S16      ret;
3608    Inst    inst = cell->instIdx;
3609 /* LTE_ADV_FLAG_REMOVED_START */
3610    uint8_t      i = 0;
3611    uint16_t     len; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
3612 /* LTE_ADV_FLAG_REMOVED_END */
3613
3614    errInfo->errCause = RGSCHERR_CFG_RGR_CELL_RECFG;
3615
3616    /* Invoke scheduler to update scheduler specific information */
3617    ret =  rgSCHUtlRgrCellRecfg(cell, cellRecfg, errInfo);
3618    if (ret != ROK)
3619    {
3620      RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId, "RGR Cell re-configuration failed "
3621           "at Scheduler ");
3622       return RFAILED;
3623    }
3624
3625    /* Invoke DHM to update DHM specific information */
3626    rgSCHDhmRgrCellRecfg(cell, cellRecfg, errInfo);
3627
3628       /* PUCCH Reconfiguration */
3629    if (cellRecfg->recfgTypes & RGR_CELL_PUCCH_RECFG)
3630    {
3631       cell->pucchCfg = cellRecfg->pucchRecfg;
3632    }
3633
3634    /* SRS Reconfiguration */
3635    if (cellRecfg->recfgTypes & RGR_CELL_SRS_RECFG)
3636    {
3637       cell->srsCfg.isSrsCfgPres = cellRecfg->srsRecfg.isSrsCfgSetup;
3638       if(cellRecfg->srsRecfg.isSrsCfgSetup)
3639       {
3640          cell->srsCfg.srsCfgPrdEnum = cellRecfg->srsRecfg.srsCfgPrdEnum;
3641          cell->srsCfg.srsBwEnum = cellRecfg->srsRecfg.srsBwEnum;
3642          cell->srsCfg.srsTxOffst =
3643             rgSrsTxOffstTbl[cellRecfg->srsRecfg.srsSubFrameCfg];
3644          /*ccpu00116923 - ADD - Srs Present support */
3645 #ifdef TFU_UPGRADE
3646          cell->srsCfg.srsSubFrameCfg = cellRecfg->srsRecfg.srsSubFrameCfg;
3647 #endif
3648       }
3649    }
3650
3651    /* RACH Reconfiguration */
3652    if (cellRecfg->recfgTypes & RGR_CELL_RACH_RECFG)
3653    {
3654       cell->rachCfg = cellRecfg->rachRecfg;
3655    }
3656
3657    /* ccpu00132256:MOD: Moved this assignment from Validation to here.*/
3658    if (cellRecfg->recfgTypes & RGR_CELL_TMRS_RECFG)
3659    {
3660       cell->t300TmrVal = cellRecfg->t300TmrVal;
3661    }
3662 #ifdef RGR_SI_SCH
3663    /* SI Reconfiguration */
3664    if (cellRecfg->recfgTypes & RGR_CELL_SI_RECFG)
3665    {
3666       /*Set the specified SI configuration. */
3667       cell->siCb.newSiCfg = cellRecfg->siReCfg;
3668       /* Set the Bit mask for SI re-configuration */
3669       cell->siCb.siBitMask |= RGSCH_SI_SICFG_UPD;
3670 #ifdef EMTC_ENABLE
3671       if(cell->emtcEnable)
3672       {
3673       rgSchEmtcUpdSiCfg(cell, cellRecfg);
3674       }
3675 #endif
3676    }
3677 #endif /*RGR_SI_SCH */
3678
3679    /* Overload RACH Control changes */
3680    if (cellRecfg->recfgTypes & RGR_CELL_CNTRL_CMD_RECFG)
3681    {
3682       if (cellRecfg->cntrlCmdCfg.cmdType == RGR_CNTRL_CMD_RACH_OVRLD)
3683       {
3684          cell->overLoadBackOffEnab = cellRecfg->cntrlCmdCfg.cmdDesc.rachOvrLd.backOffEnb;
3685          cell->overLoadBackOffval = cellRecfg->cntrlCmdCfg.cmdDesc.rachOvrLd.backOffVal;
3686       }
3687       else if (cellRecfg->cntrlCmdCfg.cmdType == RGR_CNTRL_CMD_CPU_OVRLD)
3688       {
3689          if( ROK != rgSCHUtlResetCpuOvrLdState(cell, cellRecfg->cntrlCmdCfg.cmdDesc.\
3690                                           cpuOvrLd.instruction))
3691          {
3692             RLOG_ARG1(L_ERROR,DBG_CELLID, cellRecfg->cellId,
3693                "Invalid CPU OvrLd Ins %d for cell",
3694                cellRecfg->cntrlCmdCfg.cmdDesc.cpuOvrLd.instruction);
3695             return RFAILED;
3696          }
3697       }
3698    }
3699
3700 /* LTE_ADV_FLAG_REMOVED_START */
3701    if (cellRecfg->recfgTypes & RGR_CELL_LTEA_FEATURE_RECFG)
3702    {
3703       if(cellRecfg->rgrLteAdvCfg.pres & RGR_ABS)
3704       {
3705          cell->lteAdvCb.absCfg =
3706             cellRecfg->rgrLteAdvCfg.absCfg;
3707       }
3708       if(cellRecfg->rgrLteAdvCfg.pres & RGR_SFR)
3709       {
3710          memcpy(&cell->lteAdvCb.sfrCfg, &cellRecfg->rgrLteAdvCfg.sfrCfg,
3711                sizeof(RgrSfrConfig));
3712          /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
3713          if (cellRecfg->rgrLteAdvCfg.sfrCfg.status == RGR_ENABLE)
3714          {
3715             for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
3716             {
3717                /*initialise the pools of CC and CE*/
3718                if(rgSchSFRTotalPoolInit(cell, cell->subFrms[i]))
3719                {
3720                   return RFAILED;
3721                }
3722             }
3723          }
3724          else
3725          {
3726             for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
3727             {
3728                /*initialise the pools of CC and CE*/
3729                rgSchSFRTotalPoolFree(&cell->subFrms[i]->sfrTotalPoolInfo, cell);
3730             }
3731
3732             if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
3733             {
3734                /* releasing rntp info val from each subframe */
3735                for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
3736                {
3737                   rgSchDSFRRntpInfoFree(&cell->subFrms[i]->rntpInfo, cell, cell->bwCfg.dlTotalBw);
3738                }
3739
3740                /* releasing RNTP Aggregation Info from CellCb*/
3741                rgSchDSFRRntpInfoFree(&cell->rntpAggrInfo, cell, cell->bwCfg.dlTotalBw);
3742
3743                cell->lteAdvCb.dsfrCfg.status = RGR_DISABLE;
3744             }
3745          }
3746       }
3747       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Start */
3748       if(cellRecfg->rgrLteAdvCfg.pres & RGR_DSFR)
3749       {
3750          cell->lteAdvCb.dsfrCfg =
3751             cellRecfg->rgrLteAdvCfg.dsfrCfg;
3752          if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
3753          {
3754             for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
3755             {
3756                /*initialise the pools of CC and CE*/
3757                if(rgSchDSFRRntpInfoInit(&cell->subFrms[i]->rntpInfo,cell,cell->bwCfg.dlTotalBw))
3758                {
3759                   return RFAILED;
3760                }
3761             }
3762             /*Calculating the length of RNTP array based on Dl Bandwidth */
3763             len = (uint16_t)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /* KW fix for LTE_ADV */
3764             if(cell->rntpAggrInfo.pres == NOTPRSNT)
3765             {
3766                if((rgSCHUtlAllocSBuf(inst, (Data**)&(cell->rntpAggrInfo.val),
3767                            (len * sizeof(uint8_t)))) != ROK)
3768                {
3769                   RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,
3770                             "Memory allocation FAILED for RNTP Alloc");
3771                   return RFAILED;
3772                }
3773                cell->rntpAggrInfo.pres = PRSNT_NODEF;
3774                cell->rntpAggrInfo.len  = len;
3775             }
3776          }
3777          /* in case if DSFR is disabled, need to free RNTP pattern val*/
3778          else
3779          {
3780             /* releasing rntp info val from each subframe */
3781             for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
3782             {
3783                rgSchDSFRRntpInfoFree(&cell->subFrms[i]->rntpInfo, cell, cell->bwCfg.dlTotalBw);
3784             }
3785
3786             /* releasing RNTP Aggregation Info from CellCb*/
3787             rgSchDSFRRntpInfoFree(&cell->rntpAggrInfo, cell, cell->bwCfg.dlTotalBw);
3788          }
3789       }
3790       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** End */
3791    }
3792 /* LTE_ADV_FLAG_REMOVED_END */
3793
3794    /* Dynamic CFI cell Reconfiguration */
3795    if(cellRecfg->recfgTypes & RGR_CELL_DYN_CFI_RECFG)
3796    {
3797       if(cell->dynCfiCb.isDynCfiEnb != cellRecfg->isDynCfiEnb)
3798       {
3799          if(cell->dynCfiCb.switchOvrInProgress)
3800          {
3801             cell->dynCfiCb.dynCfiRecfgPend = TRUE;
3802          }
3803          else
3804          {
3805             cell->dynCfiCb.isDynCfiEnb = cellRecfg->isDynCfiEnb;
3806             rgSCHDynCfiReCfg(cell, cellRecfg->isDynCfiEnb);
3807          }
3808       }
3809       else
3810       {
3811          /* To hanlde the case where reconfiguration comes for disabling
3812           * and then enabling before switchover period expires */
3813          cell->dynCfiCb.dynCfiRecfgPend = FALSE;
3814       }
3815    }
3816    /* Dynamic config of AUTO chnage flag */
3817    if(cellRecfg->recfgTypes & RGR_CELL_AUTO_CFG_MODE_RECFG)
3818    {
3819       if(cell->isAutoCfgModeEnb != cellRecfg->isAutoCfgModeEnb)
3820       {
3821          cell->isAutoCfgModeEnb = cellRecfg->isAutoCfgModeEnb;
3822       }
3823    }
3824    {
3825      if(cell->isAutoCfgModeEnb)
3826      {
3827         RLOG0(L_INFO,"Auto Mode Cfg enabled durint cell recfg\n");
3828      }
3829    }
3830
3831    if (cellRecfg->recfgTypes & RGR_CELL_CSG_PARAM_RECFG)
3832    {
3833       cell->minDlResNonCsg = cellRecfg->csgParamCfg.minDlResNonCsg;
3834       cell->minUlResNonCsg = cellRecfg->csgParamCfg.minUlResNonCsg;
3835    }
3836
3837    errInfo->errCause = RGSCHERR_NONE;
3838    return ROK;
3839 }  /* rgSCHCfgRgrCellRecfg */
3840
3841 /**
3842  * @brief Handler for the UE reconfiguration request from RRC to MAC.
3843  *
3844  * @details
3845  *
3846  *     Function : rgSCHCfgRgrUeRecfgRntiChg
3847  *
3848  *     Processing Steps:
3849  *      - If rnti changes,
3850  *        - Invoke RAM for UE reconfiguration.
3851  *        - Delete old UE from the list.
3852  *        - Update the new rnti and re-insert the UE in the list.
3853  *      - If successful, return ROK else RFAILED.
3854  *
3855  *  @param[in]  RgSchCellCb  *cell
3856  *  @param[in]  RgSchUeCb    *ue
3857  *  @param[in]  RgrUeRecfg   *ueRecfg
3858  *  @param[out] RgSchErrInfo *errInfo
3859  *  @return  S16
3860  *      -# ROK
3861  *      -# RFAILED
3862  **/
3863 #ifdef ANSI
3864 static S16 rgSCHCfgRgrUeRecfgRntiChg
3865 (
3866 RgSchCellCb    *cell,
3867 RgSchUeCb      *ue,
3868 RgrUeRecfg     *ueRecfg,
3869 RgSchErrInfo   *errInfo
3870 )
3871 #else
3872 static S16 rgSCHCfgRgrUeRecfgRntiChg(cell, ue, ueRecfg, errInfo)
3873 RgSchCellCb    *cell;
3874 RgSchUeCb      *ue;
3875 RgrUeRecfg     *ueRecfg;
3876 RgSchErrInfo   *errInfo;
3877 #endif
3878 {
3879 #ifdef LTE_ADV
3880    uint8_t          sCellIdx;
3881 #endif
3882    S16          ret;
3883    RgSchRaCb    *raCb;
3884    RgSchRaCb    *oldRaCb;
3885    RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
3886    uint8_t           idx;
3887
3888    /* Handle CRNTI change in reconfiguration */
3889    if (ueRecfg->oldCrnti != ueRecfg->newCrnti)
3890    {
3891       RgSchRntiLnk   *oldRntiLnk=NULLP;
3892       CmLteRnti      oldRnti = 0;
3893       if ((raCb = rgSCHDbmGetRaCb(cell, ueRecfg->newCrnti)) == NULLP)
3894       {
3895          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UEID:No RaCb exists while"
3896               "Reconfig for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
3897          return RFAILED;
3898       }
3899
3900       /* rntiLnk does not exist for a HandIn UE. Hence this check. */
3901       if(ue->rntiLnk)
3902       {
3903          oldRntiLnk = ue->rntiLnk;
3904       }
3905       else
3906       {
3907          /* Fix : syed HO UE does not have a valid ue->rntiLnk */
3908          oldRnti = ue->ueId;
3909       }
3910
3911       RLOG2(L_INFO,"UE ID CHNG OLD %d new %d",ueRecfg->oldCrnti, ueRecfg->newCrnti);
3912
3913       /* Fix : syed Deleting Old DL HqEnt. It would be assigned after
3914        * reest RACH(msg4) is completed. */
3915       rgSCHDhmDelHqEnt(cell, hqEnt);
3916
3917       /* Initialize RAM related information for UE */
3918       ret = rgSCHRamRgrUeCfg(cell, ue, raCb, errInfo);
3919       if (ret != ROK)
3920       {
3921          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"RAM Handling for UE Reconfig failed"
3922               "for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
3923          return RFAILED;
3924       }
3925       /* Delete Ue from the ue list */
3926       rgSCHDbmDelUeCb(cell, ue);
3927
3928 #ifdef LTE_ADV
3929       if (ue->numSCells)
3930       {
3931          for ( sCellIdx = 1; sCellIdx < CM_LTE_MAX_CELLS; sCellIdx++)
3932          {
3933             if(ue->cellInfo[sCellIdx] != NULLP)
3934             {
3935                rgSCHDbmDelUeCb(ue->cellInfo[sCellIdx]->cell, ue);
3936             }
3937          }
3938       }
3939 #endif
3940
3941       /* Inititialize Ue control block */
3942       ue->ueId = ueRecfg->newCrnti;
3943       RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
3944             "Changing RNTI from %d to %d",
3945             ueRecfg->oldCrnti,
3946             ueRecfg->newCrnti);
3947 #ifdef EMTC_ENABLE
3948       if(ue->isEmtcUe)
3949       {
3950          rgSCHUtlUpdEmtcY(ue);
3951       }
3952 #endif
3953
3954       /* Fix ccpu00122631: PCell_Reest: Updating new Rnti in all the cells
3955        * dlAllocCb
3956        */
3957       for(idx = 0; idx < CM_LTE_MAX_CELLS; idx++)
3958       {
3959          if(ue->cellInfo[idx])
3960          {
3961             ue->cellInfo[idx]->dlAllocCb.rnti = ueRecfg->newCrnti;
3962          }
3963       }
3964
3965       rgSCHUtlRecMsg3Alloc(cell, ue, raCb);
3966
3967       /* If raCb received PHR, update scheduler */
3968       if(raCb->phr.pres == TRUE)
3969       {
3970          ue->macCeRptTime = raCb->msg3AllocTime;
3971          rgSCHUtlUpdPhr(cell, ue, raCb->phr.val, errInfo);
3972       }
3973
3974 #ifdef RGR_V2  /* Acc Fix */
3975      if(TRUE == ue->isDrxEnabled)
3976      {
3977          ueRecfg->ueDrxRecfg.isDrxEnabled = TRUE;
3978          ret = rgSCHDrxUeReCfg(cell,ue,ueRecfg);
3979
3980          if ( ret != ROK )
3981          {
3982              RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE DRX re-est failed"
3983               "for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
3984              return RFAILED;
3985          }
3986      }
3987 #endif /* Acc Fix */
3988
3989       /* Re-insert updated Ue */
3990       rgSCHDbmInsUeCb(cell, ue);
3991
3992 #ifdef LTE_ADV
3993       if (ue->numSCells)
3994       {
3995          for ( sCellIdx = 1; sCellIdx < CM_LTE_MAX_CELLS; sCellIdx++)
3996          {
3997             if(ue->cellInfo[sCellIdx] != NULLP)
3998             {
3999                rgSCHDbmInsUeCb(ue->cellInfo[sCellIdx]->cell, ue);
4000             }
4001          }
4002       }
4003 #endif
4004
4005
4006 #ifdef TENB_STATS
4007       ue->tenbStats->stats.rnti = ue->ueId;
4008 #endif
4009
4010       /* Fix : syed If MSG4 is done, since corresponding ueCb
4011        * is ready, the raCb should be cleared immediately.
4012        * Otherwise it would remain in the cell until timed out
4013        * and till then the hq Feedbacks will be assumed to be
4014        * for msg4 */
4015       if (raCb->raState == RGSCH_RA_MSG4_DONE)
4016       {
4017          RLOG_ARG1(L_DEBUG,DBG_CELLID,ueRecfg->cellId,
4018                "RNTI:%d with RaCb deleted as Msg4 transmission is done",
4019                raCb->tmpCrnti);
4020          rgSCHRamDelRaCb(cell, raCb, FALSE);
4021       }
4022       /* Fix : syed moving the UL CQI initialization to UERESET */
4023
4024       /* Release Older rnti */
4025       if(oldRntiLnk)
4026       {
4027          /* This is the rare case in which back to back reestablishment is
4028           * happening and previous re-est was not done completely (MSG4 was
4029           * not done) for an UE, and again re-est is triggered for the same
4030           * UE. We are deleting the old RA CB for the previous re-est which
4031           * still exist due to MSG4 not transmitted successfully */
4032          if ((oldRaCb = rgSCHDbmGetRaCb(cell, oldRntiLnk->rnti)) != NULLP)
4033          {
4034             rgSCHRamDelRaCb(cell, oldRaCb, FALSE);
4035          }
4036
4037          rgSCHUtlRlsRnti(cell, oldRntiLnk, TRUE, ueRecfg->newCrnti);
4038       }
4039       else
4040       {
4041          /* Fix : syed HO UE does not have a valid ue->rntiLnk */
4042              /* Just indicate to MAC, no need to release at SCH */
4043          RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
4044                "HO OldRnti:%d RLS and NewRnti:%d CHNG IND TO MAC",
4045                oldRnti, ueRecfg->newCrnti);
4046          rgSCHUtlIndRntiRls2Mac(cell, oldRnti, TRUE, ueRecfg->newCrnti);
4047       }
4048    }
4049    return ROK;
4050 }
4051 /**
4052  * @brief Handler for the UE reconfiguration request from RRC to MAC.
4053  *
4054  * @details
4055  *
4056  *     Function : rgSCHCfgRgrUeRecfg
4057  *
4058  *     Processing Steps:
4059  *      - If rnti changes,
4060  *        - Invoke RAM for UE reconfiguration.
4061  *        - Delete old UE from the list.
4062  *        - Update the new rnti and re-insert the UE in the list.
4063  *      - Update the UE control block with the reconfigured values.
4064  *      - Invoke SCH, UHM and DHM with updated UE control block to
4065  *        update scheduler, uplink HARQ and downlink HARQ specific
4066  *        parameters.
4067  *      - If successful, return ROK else RFAILED.
4068  *
4069  *  @param[in]  RgSchCellCb  *cell
4070  *  @param[in]  RgSchUeCb    *ue
4071  *  @param[in]  RgrUeRecfg   *ueRecfg
4072  *  @param[out] RgSchErrInfo *errInfo
4073  *  @return  S16
4074  *      -# ROK
4075  *      -# RFAILED
4076  **/
4077 #ifdef ANSI
4078 S16 rgSCHCfgRgrUeRecfg
4079 (
4080 RgSchCellCb    *cell,
4081 RgSchUeCb      *ue,
4082 RgrUeRecfg     *ueRecfg,
4083 RgSchErrInfo   *errInfo
4084 )
4085 #else
4086 S16 rgSCHCfgRgrUeRecfg(cell, ue, ueRecfg, errInfo)
4087 RgSchCellCb    *cell;
4088 RgSchUeCb      *ue;
4089 RgrUeRecfg     *ueRecfg;
4090 RgSchErrInfo   *errInfo;
4091 #endif
4092 {
4093    S16          ret;
4094 #ifdef LTE_ADV
4095    Bool dciChange = TRUE;
4096 #endif
4097
4098    errInfo->errCause = RGSCHERR_CFG_RGR_UE_RECFG;
4099
4100 #ifdef LTE_ADV
4101    if (ue->numSCells > 0)
4102    {
4103       dciChange = FALSE;
4104    }
4105    if ((ueRecfg->ueRecfgTypes & RGR_UE_UE_ACCESS_STRATUM_REL_RECFG) && \
4106          (ue->accessStratumRls != ueRecfg->accessStratumRls))
4107    {
4108       ue->accessStratumRls = ueRecfg->accessStratumRls;
4109       dciChange = TRUE;
4110    }
4111
4112    /* if SCELL_RECFG is present , no other
4113     * type will be present. Process Scell addition
4114     * and return
4115     * */
4116    if (ueRecfg->ueRecfgTypes & RGR_UE_SCELL_ADD_RECFG)
4117    {
4118       ret = rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, errInfo);
4119       if( ret != ROK)
4120       {
4121          errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_SCELL_RECFG;
4122          /*FH: SCell config failed for a scell index hence revert all successful
4123           * Scell config and send negative confirmation to APP*/
4124          rgSCHSCellCfgUeCfgRollBack(cell, ue, ueRecfg);
4125          return RFAILED;
4126       }
4127    }
4128    if (dciChange == TRUE)
4129    {
4130       if (ue->numSCells > 0)
4131       {
4132          /* 2 bit CSI */
4133          rgSCHUtlUpdUeDciSize(cell, ue, TRUE);
4134       }
4135       else
4136       {
4137          /* 1 bit CSI Access Stratum Release Change */
4138          rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
4139       }
4140    }
4141    if (ueRecfg->ueRecfgTypes & RGR_UE_SCELL_PUCCH_RECFG)
4142    {
4143       ret = rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, errInfo);
4144       if( ret != ROK)
4145       {
4146          errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_SCELL_PUCCH_RECFG;
4147          return RFAILED;
4148       }
4149    }
4150 #else
4151    if ((ueRecfg->ueRecfgTypes & RGR_UE_UE_ACCESS_STRATUM_REL_RECFG) && \
4152          (ue->accessStratumRls != ueRecfg->accessStratumRls))
4153    {
4154       ue->accessStratumRls = ueRecfg->accessStratumRls;
4155       rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
4156    }
4157 #endif /* LTE_ADV */
4158
4159    if (ueRecfg->ueRecfgTypes)
4160    {
4161       /* Update scheduler related information for UE */
4162       ret = rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, errInfo);
4163       if (ret != ROK)
4164       {
4165          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
4166              "Scheduler handling while reconfig failed"
4167               "for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
4168          return RFAILED;
4169       }
4170
4171       /* Update uplink HARQ related information for UE */
4172       rgSCHUhmRgrUeRecfg(cell, ue, ueRecfg);
4173
4174       /* Update TA related information for UE */
4175       if (ueRecfg->ueRecfgTypes & RGR_UE_TATMR_RECFG)
4176       {
4177          rgSCHCfgUeTaRecfg(cell, ue, ueRecfg, errInfo);
4178       }
4179
4180       /*Update Measurement Gap and AckNack Details */
4181       /* After merging from 2.2 */
4182       if (ueRecfg->ueRecfgTypes & RGR_UE_ACKNACK_MEASGAP_RECFG)
4183       {
4184          ret = rgSCHMeasGapANRepUeRecfg(cell, ue, ueRecfg);
4185          if (ret != ROK)
4186          {
4187             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Measurement Gap and"
4188                      "AckNack Rep Recfg failed for OLD CRNTI:%d NEW CRNTI:%d",
4189                       ueRecfg->oldCrnti,ueRecfg->newCrnti);
4190             return RFAILED;
4191          }
4192       }
4193       if (ueRecfg->ueRecfgTypes & RGR_UE_BSRTMR_RECFG)
4194       {
4195          cmInitTimers(&ue->bsrTmr, 1);
4196          ue->ul.bsrTmrCfg = ueRecfg->ueBsrTmrRecfg;
4197          if ((ue->ul.bsrTmrCfg.isPrdBsrTmrPres) &&
4198                (ue->ul.bsrTmrCfg.prdBsrTmr == 0xFFFF))
4199          {
4200             ue->ul.bsrTmrCfg.isPrdBsrTmrPres = FALSE;
4201          }
4202       }
4203    }
4204
4205    if (RFAILED == rgSCHCfgRgrUeRecfgRntiChg (cell, ue, ueRecfg, errInfo))
4206    {
4207        RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"RNTI change "
4208                "failed for OLD CRNTI:%d NEW CRNTI:%d",
4209                 ueRecfg->oldCrnti,ueRecfg->newCrnti);
4210        return RFAILED;
4211    }
4212
4213 #ifdef TFU_UPGRADE
4214    /* Re-Initialize Aperiodic CQI Information for UE*/
4215    if ( ueRecfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG )
4216    {
4217       ret = rgSCHCfgAcqiUeReCfg(cell, ue, &ueRecfg->aprdDlCqiRecfg,
4218             ue->ueCatEnum);
4219    }
4220    /*   Re-Initialize Periodic CQI/PMI, RI Information for UE  */
4221    if ( ueRecfg->ueRecfgTypes & RGR_UE_PCQI_RECFG)
4222    {
4223       ret = rgSCHCfgPCqiUeReCfg(cell, ue, &ueRecfg->cqiCfg,
4224             ue->ueCatEnum);
4225    }
4226    /*   Re-Initialize UL SRS Information for UE  */
4227    if ( ueRecfg->ueRecfgTypes & RGR_UE_SRS_RECFG)
4228    {
4229       ret = rgSCHCfgSrsUeReCfg(cell, ue, &ueRecfg->srsCfg);
4230    }
4231    /*   Re-Initialize SR Information for UE  */
4232    if ( ueRecfg->ueRecfgTypes & RGR_UE_SR_RECFG)
4233    {
4234       ret = rgSCHCfgSrUeReCfg(cell, ue, &ueRecfg->srCfg);
4235    }
4236 #endif
4237
4238 #ifdef LTEMAC_HDFDD
4239    if(ueRecfg->isHdFddEnbld)
4240    {
4241         ret = rgSCHHdFddUeCfg(cell, ue, ueRecfg->isHdFddEnbld);
4242         if (ret != ROK)
4243         {
4244            errInfo->errCause = RGSCHERR_HDFDD_SPSCFGRD;
4245            return (ret);
4246         }
4247    }
4248 #endif /* LTEMAC_HDFDD */
4249 #ifdef RGR_V2
4250   if ( ueRecfg->ueRecfgTypes & RGR_UE_DRX_RECFG)
4251   {
4252      ret = rgSCHDrxUeReCfg(cell,ue,ueRecfg);
4253
4254      if ( ret != ROK )
4255      {
4256         RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE DRX reconfig failed"
4257                "failed for OLD CRNTI:%d NEW CRNTI:%d",
4258                 ueRecfg->oldCrnti,ueRecfg->newCrnti);
4259         return RFAILED;
4260      }
4261   }
4262 #endif
4263 /* ccpu00117452 - MOD - Changed macro name from
4264    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
4265 #ifdef RGR_CQI_REPT
4266    /* CQI Reporting (N)  Re-configuration */
4267    if(ueRecfg->ueRecfgTypes & RGR_UE_CQIREPT_RECFG)
4268    {
4269       ret = rgSCHCfgUeCqiReptReCfg(cell, ue, ueRecfg);
4270       if(ret != OK)
4271       {
4272          errInfo->errCause = RGSCHERR_CQIREPT;
4273          return (ret);
4274       }
4275    }
4276 #endif /* End of RGR_CQI_REPT */
4277 #ifdef TFU_UPGRADE
4278    /* pA Re-configuration */
4279    if((ueRecfg->ueRecfgTypes & RGR_UE_PA_RECFG) &&
4280          RG_SCH_UE_CFG_ISPAPRSNT(ueRecfg->uePdschDedCfg.uepACfg))
4281    {
4282       RG_SCH_CMN_GET_PA(ue,cell).pres = TRUE;
4283       RG_SCH_CMN_GET_PA(ue,cell).val = ueRecfg->uePdschDedCfg.uepACfg.pA;
4284    }
4285 #endif
4286
4287 /* LTE_ADV_FLAG_REMOVED_START */
4288    if(ueRecfg->ueRecfgTypes & RGR_UE_LTEA_RECFG)
4289    {
4290       if(ueRecfg->ueLteAdvCfg.pres & RGR_ABS)
4291       {
4292          ue->lteAdvUeCb.rgrLteAdvUeCfg.isAbsUe = ueRecfg->ueLteAdvCfg.isAbsUe;
4293       }
4294
4295       if(ueRecfg->ueLteAdvCfg.pres & RGR_SFR)
4296       {
4297          ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge = ueRecfg->ueLteAdvCfg.isUeCellEdge;
4298       }
4299    }
4300 /* LTE_ADV_FLAG_REMOVED_END */
4301 #ifdef EMTC_ENABLE
4302    if(ueRecfg->ueRecfgTypes & RGR_UE_EMTC_DPLXMODE_RECFG)
4303    {
4304       rgSCHEmtcHdFddUeCfg (cell, ue,
4305                ueRecfg->emtcUeRecfg.isHdFddEnbld);
4306    }
4307    if(ueRecfg->ueRecfgTypes & RGR_UE_EMTC_PO_TRIGGER)
4308    {
4309       rgSCHEmtcPOTrigger(cell, ue);
4310    }
4311 #endif
4312    errInfo->errCause = RGSCHERR_NONE;
4313
4314    return ROK;
4315 }  /* rgSCHCfgRgrUeRecfg */
4316
4317
4318 /**
4319  * @brief Handler for the logical channel reconfiguration request from
4320  * RRC to MAC.
4321  *
4322  * @details
4323  *
4324  *     Function : rgSCHCfgRgrLchRecfg
4325  *
4326  *     Processing Steps:
4327  *      - Invoke scheduler to update scheduler specific information.
4328  *      - Update the dedicated logical channel Cb with the reconfigured
4329  *        values.
4330  *      - If successful, return ROK else RFAILED.
4331  *
4332  *  @param[in]  RgUlCellCb  *cell
4333  *  @param[in]  RgUlUeCb    *ue
4334  *  @param[in]  RgSchUlLcCb    *ulLc
4335  *  @param[in]  RgSchDlLcCb    *dlLc
4336  *  @param[in]  RgrLchRecfg *lcRecfg
4337  *  @param[out] RgSchErrInfo   *errInfo
4338  *  @return  S16
4339  *      -# ROK
4340  *      -# RFAILED
4341  **/
4342 #ifdef ANSI
4343 S16 rgSCHCfgRgrLchRecfg
4344 (
4345 RgSchCellCb    *cell,
4346 RgSchUeCb      *ue,
4347 RgSchDlLcCb    *dlLc,
4348 RgrLchRecfg    *lcRecfg,
4349 RgSchErrInfo   *errInfo
4350 )
4351 #else
4352 S16 rgSCHCfgRgrLchRecfg(cell, ue, dlLc, lcRecfg, errInfo)
4353 RgSchCellCb    *cell;
4354 RgSchUeCb      *ue;
4355 RgSchDlLcCb    *dlLc;
4356 RgrLchRecfg    *lcRecfg;
4357 RgSchErrInfo   *errInfo;
4358 #endif
4359 {
4360    S16     ret = ROK;
4361
4362    errInfo->errCause = RGSCHERR_CFG_RGR_LC_RECFG;
4363    /* Invoke Scheduler to update the new configuration */
4364    ret = rgSCHUtlRgrLcRecfg(cell, ue, dlLc, lcRecfg, errInfo);
4365    if (ret != ROK)
4366    {
4367       RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Scheduler handling for LC Recfg"
4368               " failed for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
4369       return RFAILED;
4370    }
4371
4372    errInfo->errCause = RGSCHERR_NONE;
4373    return ROK;
4374 }  /* rgSCHCfgRgrLchRecfg */
4375 /**
4376  * @brief Handler for the logical channel reconfiguration request from
4377  * RRC to MAC.
4378  *
4379  * @details
4380  *
4381  *     Function : rgSCHCfgRgrLcgRecfg
4382  *
4383  *     Processing Steps:
4384  *      - Invoke scheduler to update scheduler specific information.
4385  *      - Update the dedicated logical channel Cb with the re-configured
4386  *        values.
4387  *      - If successful, return ROK else RFAILED.
4388  *
4389  *  @param[in]  RgUlCellCb   *cell
4390  *  @param[in]  RgUlUeCb     *ue
4391  *  @param[in]  RgrLcgRecfg  *lcgRecfg
4392  *  @param[out] RgSchErrInfo *errInfo
4393  *  @return  S16
4394  *      -# ROK
4395  *      -# RFAILED
4396  **/
4397 #ifdef ANSI
4398 S16 rgSCHCfgRgrLcgRecfg
4399 (
4400 RgSchCellCb    *cell,
4401 RgSchUeCb      *ue,
4402 RgrLcgRecfg    *lcgRecfg,
4403 RgSchErrInfo   *errInfo
4404 )
4405 #else
4406 S16 rgSCHCfgRgrLcgRecfg(cell, ue, lcgRecfg, errInfo)
4407 RgSchCellCb    *cell;
4408 RgSchUeCb      *ue;
4409 RgrLcgRecfg    *lcgRecfg;
4410 RgSchErrInfo   *errInfo;
4411 #endif
4412 {
4413    S16     ret = ROK;
4414
4415    errInfo->errCause = RGSCHERR_CFG_RGR_LCG_RECFG;
4416
4417    /*Added for handling LCG ReConfig if the LCG was deleted */
4418    ue->ul.lcgArr[lcgRecfg->ulRecfg.lcgId].lcgId = lcgRecfg->ulRecfg.lcgId;
4419
4420    /* Invoke Scheduler to update the new configuration */
4421    ret = rgSCHUtlRgrLcgRecfg(cell, ue, lcgRecfg, errInfo);
4422    if (ret != ROK)
4423    {
4424       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Scheduler handling for LCG Recfg"
4425               " failed for CRNTI:%d LCGID:%d",lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
4426       return RFAILED;
4427    }
4428
4429    errInfo->errCause = RGSCHERR_NONE;
4430    return ROK;
4431 }  /* rgSCHCfgRgrLcgRecfg */
4432
4433 /**
4434  * @brief Handler for the UE Reset request from RRM to MAC.
4435  *
4436  * @details
4437  *
4438  *     Function : rgSCHCfgRgrUeReset
4439  *
4440  *     Processing Steps:
4441  *     - Call Measument Gap Module and Ack/Nack Module for resetting UE.
4442  *     - Call Common Schduler UE rest API which inturn will call scheduler
4443  *     specific UE Reset APis to reset UE.
4444  *
4445  *  @param[in]  RgSchCellCb    *cell
4446  *  @param[in]  RgSchUeCb      *ue
4447  *  @param[in]  RgrRst         *reset
4448  *  @param[out] RgSchErrInfo   *errInfo
4449  *  @return  S16
4450  *      -# ROK
4451  *      -# RFAILED
4452  **/
4453 #ifdef ANSI
4454 S16 rgSCHCfgRgrUeReset
4455 (
4456 RgSchCellCb    *cell,
4457 RgSchUeCb      *ue,
4458 RgrRst         *reset,
4459 RgSchErrInfo   *errInfo
4460 )
4461 #else
4462 S16 rgSCHCfgRgrUeReset(cell, ue, reset, errInfo)
4463 RgSchCellCb    *cell;
4464 RgSchUeCb      *ue;
4465 RgrRst         *reset;
4466 RgSchErrInfo   *errInfo;
4467 #endif
4468 {
4469    uint32_t     idx;
4470    RgSchRaCb *raCb;
4471
4472    errInfo->errCause = RGSCHERR_CFG_RGR_UE_RESET;
4473
4474    /* Setting BO of Each Logical Channel of the UE to 0 */
4475    for (idx = 0; idx < RGSCH_MAX_LC_PER_UE; idx++)
4476    {
4477       if(ue->dl.lcCb[idx] != NULLP)
4478          ue->dl.lcCb[idx]->bo = 0;
4479    }
4480
4481    /* Reset the totalBo */
4482    ue->totalBo = 0;
4483    /* Call DRX module to stop all DRX timers */
4484    /* ccpu00129899 */
4485    if(ue->drxCb != NULLP)
4486    {
4487      (Void)rgSCHDrxUeDel(cell,ue);
4488    }
4489
4490    /* ccpu00140894- Stop TXMode transiition timer if it is running*/
4491    if (ue->txModeTransTmr.tmrEvnt != TMR_NONE)
4492    {
4493       rgSCHTmrStopTmr(cell, RG_SCH_TMR_TXMODE_TRNSTN, ue);
4494       ue->txModeTransCmplt =TRUE;
4495    }
4496
4497    /* ccpu00133470- Meas Gap should be released during RRC re-establishment */
4498    rgSCHMeasGapANRepUeDel(cell, ue, FALSE);
4499
4500    /* Call Common scheduler which in turn will call specific scheduler for UE
4501     * Reset*/
4502    rgSCHUtlUeReset(cell, ue);
4503 #ifdef LTE_ADV
4504    /*PCell which is at idx 0 is always active. Adding a line after the loop
4505     *setting RGSCH_PCELL_INDEX to SCELL ACTIVE*/
4506    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellState = RG_SCH_SCELL_ACTIVE;
4507 #endif
4508
4509    /* In case of back to back reestablishments, when this UE's
4510     * previous ReEst is still in progress and has got RESET
4511     * as part of new ReEst */
4512    if((raCb = rgSCHDbmGetRaCb(cell, ue->ueId)) != NULLP)
4513    {
4514       rgSCHRamDelRaCb(cell, raCb, FALSE);
4515    }
4516    /* Fix : syed set UE inactive in DL until UE is reinitialization completed */
4517    ue->dl.dlInactvMask |= RG_HQENT_INACTIVE;
4518    ue->ul.ulInactvMask |= RG_HQENT_INACTIVE;
4519    /* [ccpu00127141] Resetting TA related parameters */
4520    ue->dl.taCb.ta = RGSCH_NO_TA_RQD;
4521    ue->dl.taCb.state = RGSCH_TA_IDLE;
4522
4523    /*[ccpu00121813]-ADD-Initializing outstanding TA value */
4524    ue->dl.taCb.outStndngTa = FALSE;
4525    ue->dl.taCb.outStndngTaval = RGSCH_NO_TA_RQD;
4526
4527    if (ue->dl.taCb.cfgTaTmr)
4528    {
4529       rgSCHTmrStartTmr (cell, ue, RG_SCH_TMR_TA, ue->dl.taCb.cfgTaTmr);
4530    }
4531
4532 #ifdef DL_LA
4533    /* Resetting the Tx mode change factor on UE reset */
4534    ue->mimoInfo.txModUpChgFactor = 0;
4535    ue->mimoInfo.txModDownChgFactor = 0;
4536 #endif
4537
4538    errInfo->errCause = RGSCHERR_NONE;
4539    return ROK;
4540 }  /* rgSCHCfgRgrUeReset */
4541
4542 /**
4543  * @brief Handler for the cell delete request from RRM to MAC.
4544  *
4545  * @details
4546  *
4547  *     Function : rgSCHCfgRgrCellDel
4548  *
4549  *     Processing Steps:
4550  *      - Fetch the cell control block.
4551  *      - Remove the cell control block from the hash list of cells.
4552  *      - Free the cell control block.
4553  *      - If successful, return ROK else return RFAILED.
4554  *
4555  *  @param[in]  RgSchCellCb    *cell
4556  *  @param[in]  RgrDel         *cellDelInfo
4557  *  @param[out] RgSchErrInfo   *errInfo
4558  *  @return  S16
4559  *      -# ROK
4560  *      -# RFAILED
4561  **/
4562 #ifdef ANSI
4563 S16 rgSCHCfgRgrCellDel
4564 (
4565 RgSchCellCb    *cell,
4566 RgrDel         *cellDelInfo,
4567 RgSchErrInfo   *errInfo
4568 )
4569 #else
4570 S16 rgSCHCfgRgrCellDel(cell, cellDelInfo, errInfo)
4571 RgSchCellCb    *cell;
4572 RgrDel         *cellDelInfo;
4573 RgSchErrInfo   *errInfo;
4574 #endif
4575 {
4576
4577    errInfo->errCause = RGSCHERR_CFG_RGR_CELL_DEL;
4578
4579    if (cell->cellId != cellDelInfo->u.cellDel.cellId)
4580    {
4581       RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,
4582                 "Cell does not exist");
4583       return RFAILED;
4584    }
4585
4586    /* Free the active cell */
4587    rgSCHCfgFreeCellCb(cell);
4588
4589    errInfo->errCause = RGSCHERR_NONE;
4590    return ROK;
4591 }  /* rgSCHCfgRgrCellDel */
4592
4593
4594 /**
4595  * @brief Handler for the UE delete request from RRM to MAC.
4596  *
4597  * @details
4598  *
4599  *     Function : rgSCHCfgRgrUeDel
4600  *
4601  *     Processing Steps:
4602  *      - Fetch the UE control block.
4603  *      - Remove the UE control block from the hash list of UEs for the cell.
4604  *      - Free the UE control block.
4605  *      - If successful, return ROK else return RFAILED.
4606  *
4607  *  @param[in]  RgSchCellCb    *cell
4608  *  @param[in]  RgrDel         *ueDelInfo
4609  *  @param[out] RgSchErrInfo   *errInfo
4610  *  @return  S16
4611  *      -# ROK
4612  *      -# RFAILED
4613  **/
4614 #ifdef ANSI
4615 S16 rgSCHCfgRgrUeDel
4616 (
4617 RgSchCellCb         *cell,
4618 RgrDel              *ueDelInfo,
4619 RgSchErrInfo        *errInfo
4620 )
4621 #else
4622 S16 rgSCHCfgRgrUeDel(cell, ueDelInfo, errInfo)
4623 RgSchCellCb         *cell;
4624 RgrDel              *ueDelInfo;
4625 RgSchErrInfo        *errInfo;
4626 #endif
4627 {
4628    RgSchUeCb        *ue;
4629    RgSchRaCb        *raCb;
4630 #ifdef LTE_ADV
4631    Inst    inst = cell->instIdx;
4632    RgSchCellCb      *secCellCb = NULLP;
4633 #endif
4634
4635    errInfo->errCause = RGSCHERR_CFG_RGR_UE_DEL;
4636
4637    if (cell->cellId != ueDelInfo->u.ueDel.cellId)
4638    {
4639       RLOG_ARG1(L_ERROR,DBG_CELLID,ueDelInfo->u.ueDel.cellId,
4640                 "Cell does not exist CRNTI:%d",
4641                 ueDelInfo->u.ueDel.crnti);
4642       return RFAILED;
4643    }
4644    if ((ue = rgSCHDbmGetUeCb(cell, ueDelInfo->u.ueDel.crnti)) == NULLP)
4645    {
4646       if((raCb = rgSCHDbmGetRaCb(cell, ueDelInfo->u.ueDel.crnti)) == NULLP)
4647       {
4648          RLOG_ARG1(L_ERROR,DBG_CELLID,ueDelInfo->u.ueDel.cellId,
4649                   "RaCb does not exist for CRNTI:%d",ueDelInfo->u.ueDel.crnti);
4650          return RFAILED;
4651       }
4652       else
4653       {
4654          /* This happens in case of Msg4 rejection */
4655          raCb->toDel = TRUE;
4656          return ROK;
4657       }
4658    }
4659    else
4660    {
4661 #ifdef LTE_ADV
4662       if(ueDelInfo->u.ueScellRel.ueDelTypes & RGR_UE_SCELL_DEL_RECFG)
4663       {
4664          for(uint8_t idx = 0; idx < ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.numSCells; idx++)
4665          {
4666             if(NULLP != (secCellCb = (RgSchCellCb *)rgSchUtlGetCellCb(inst, \
4667                         ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.ueSCellRelDedCfg[idx].sCellId)))
4668             {
4669                rgSCHUtlSndUeSCellDel2Mac(secCellCb, ue->ueId);
4670                rgSCHSCellDelUeSCell(cell,ue,ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.ueSCellRelDedCfg[idx].sCellIdx);
4671                ue->numSCells--;
4672                if ( ue->numSCells == 0)
4673                {
4674                   ue->allocCmnUlPdcch = TRUE;
4675                }
4676             }
4677          }
4678          if (ue->numSCells == 0)
4679          {
4680             /* As there is no SCell left so DCI 0 size at UE specific search space
4681              * will be recalculated as the CSI is reduced to 1 bit */
4682             rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
4683          }
4684       }
4685       else
4686 #endif
4687       {
4688          /* Delete Ue from the UE list of CELL*/
4689          rgSCHDbmDelUeCb(cell, ue);
4690
4691 #ifdef LTE_L2_MEAS
4692          rgSCHDbmDelL2MUe(cell, ue);
4693 #endif
4694
4695          /* Call MeasGap and AckNakRep processing module */
4696          rgSCHMeasGapANRepUeDel(cell, ue, TRUE);
4697
4698          /* ccpu00140894- Stop TXMode transiition timer if it is running*/
4699          if (ue->txModeTransTmr.tmrEvnt != TMR_NONE)
4700          {
4701             rgSCHTmrStopTmr(cell, RG_SCH_TMR_TXMODE_TRNSTN, ue);
4702          }
4703
4704          /* Call DRX module to remove UEs from various
4705           * lists it maintain
4706           */
4707          /* ccpu00129899 */
4708          if(ue->drxCb != NULLP)
4709          {
4710             (Void)rgSCHDrxUeDel(cell,ue);
4711             /* Free Ue */
4712          }
4713          /*Fix: If RA CB exists, delete it*/
4714          if((raCb = rgSCHDbmGetRaCb(cell, ueDelInfo->u.ueDel.crnti)) != NULLP)
4715          {
4716             /* Fix : syed RNTI was getting released twice, once by racb del
4717              * and subsequently by ueDel. Let it get released by ueDel alone */
4718             rgSCHRamDelRaCb(cell, raCb, FALSE);
4719          }
4720 #ifdef EMTC_ENABLE
4721          if(ue->isEmtcUe)
4722          {
4723             rgSCHEmtcUeDel(cell, ue);
4724          }
4725 #endif
4726
4727          rgSCHCfgFreeUeCb(cell, ue);
4728
4729          errInfo->errCause = RGSCHERR_NONE;
4730
4731       }
4732       return ROK;
4733    }
4734 }  /* rgSCHCfgRgrUeDel */
4735
4736
4737 /**
4738  * @brief Handler for the logical channel delete request from
4739  * RRM to MAC.
4740  *
4741  * @details
4742  *
4743  *     Function : rgSCHCfgRgrLcDel
4744  *
4745  *     Processing Steps:
4746  *      - Fetch the logical channel control block.
4747  *      - Free the logical channel control block.
4748  *      - If successful, return ROK else return RFAILED.
4749  *
4750  *  @param[in]  RgrDel      *lcDelInfo
4751  *  @param[out] RgSchErrInfo   *errInfo
4752  *  @return  S16
4753  *      -# ROK
4754  *      -# RFAILED
4755  **/
4756 #ifdef ANSI
4757 S16 rgSCHCfgRgrLcDel
4758 (
4759 RgSchCellCb    *cell,
4760 RgrDel         *lcDelInfo,
4761 RgSchErrInfo   *errInfo
4762 )
4763 #else
4764 S16 rgSCHCfgRgrLcDel(cell, lcDelInfo, errInfo)
4765 RgSchCellCb    *cell;
4766 RgrDel         *lcDelInfo;
4767 RgSchErrInfo   *errInfo;
4768 #endif
4769 {
4770    RgSchUeCb    *ue;
4771    RgSchDlLcCb  *dlLc;
4772 #ifdef LTE_L2_MEAS
4773    uint8_t          lcId;
4774    uint8_t          idx;
4775    RgSchUlLcCb  *ulLc;
4776 #endif
4777
4778    errInfo->errCause = RGSCHERR_CFG_RGR_LC_DEL;
4779
4780    /* Fetch the Active cell */
4781    if (cell->cellId != lcDelInfo->u.lchDel.cellId)
4782    {
4783       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "Cell does not exist %d",
4784                   lcDelInfo->u.lchDel.cellId);
4785       return RFAILED;
4786    }
4787
4788    /* Fetch the Ue */
4789    if ((ue = rgSCHDbmGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
4790    {
4791       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4792                 "UE does not exist for CRNTI:%d LCID:%d",
4793                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
4794       return RFAILED;
4795    }
4796    if (lcDelInfo->u.lchDel.lcgId > 3)
4797    {
4798       RLOG_ARG3(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4799                 "[%d]UEID:For LC %d, LCGid %d is invalid",
4800                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId,
4801                lcDelInfo->u.lchDel.lcgId);
4802       return RFAILED;
4803    }
4804    if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
4805          == NULLP)
4806    {
4807       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4808                 "LC does not exist for CRNTI:%d LCID:%d",
4809                lcDelInfo->u.lchDel.crnti, lcDelInfo->u.lchDel.lcId);
4810       return RFAILED;
4811    }
4812    rgSCHUtlRgrLcDel(cell, ue, lcDelInfo->u.lchDel.lcId,lcDelInfo->u.lchDel.lcgId);
4813
4814    /* Reduce any pending bo from this LC(if any)
4815     * from the UE's total BO */
4816    if(dlLc->bo)
4817    {
4818       if(ue->totalBo >= dlLc->bo)
4819       {
4820          ue->totalBo -= dlLc->bo;
4821       }
4822       else
4823       {
4824         ue->totalBo = 0; /* this scenario should not occur */
4825       }
4826    }
4827    rgSCHDbmDelDlDedLcCb(ue, dlLc);
4828    rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
4829
4830 #ifdef LTE_L2_MEAS
4831    lcId = lcDelInfo->u.lchDel.lcId;
4832    if (TRUE == ue->ul.lcCb[lcId -1].isValid)
4833    {
4834       ulLc = &(ue->ul.lcCb[lcId -1]);
4835       ue->ul.lcCb[lcId -1].isValid = FALSE;
4836
4837       if((ulLc->qciCb->ulUeCount) &&
4838             (ue->ulActiveLCs & (1 << (ulLc->qciCb->qci -1))))
4839       {
4840          ulLc->qciCb->ulUeCount--;
4841          ue->ulActiveLCs &= ~(1 << (ulLc->qciCb->qci -1));
4842       }
4843       /* Shifting LCs in LCG Array because of LC deletion */
4844       for (idx = ulLc->lcgArrIdx +1; idx < ulLc->lcg->numLch;
4845                idx++)
4846       {
4847          ulLc->lcg->lcArray[idx -1] =
4848             ulLc->lcg->lcArray[idx];
4849          ulLc->lcg->lcArray[idx -1]->lcgArrIdx = idx -1;
4850       }
4851       ulLc->lcg->numLch--;
4852       ulLc->lcg->lcArray[idx -1] = NULLP;
4853    }
4854 #endif /* LTE_L2_MEAS */
4855
4856
4857    errInfo->errCause = RGSCHERR_NONE;
4858    return ROK;
4859 }  /* rgSCHCfgRgrLcDel */
4860
4861
4862
4863 /**
4864  * @brief Handler for the logical channel delete request from
4865  * RRM to MAC.
4866  *
4867  * @details
4868  *
4869  *     Function : rgSCHCfgRgrLcgDel
4870  *
4871  *     Processing Steps:
4872  *      - Fetch the logical channel control block.
4873  *      - Free the logical channel control block.
4874  *      - If successful, return ROK else return RFAILED.
4875  *
4876  *  @param[in]  RgrDel      *lcDelInfo
4877  *  @param[out] RgSchErrInfo   *errInfo
4878  *  @return  S16
4879  *      -# ROK
4880  *      -# RFAILED
4881  **/
4882 #ifdef ANSI
4883 S16 rgSCHCfgRgrLcgDel
4884 (
4885 RgSchCellCb    *cell,
4886 RgrDel         *lcDelInfo,
4887 RgSchErrInfo   *errInfo
4888 )
4889 #else
4890 S16 rgSCHCfgRgrLcgDel(cell, lcDelInfo, errInfo)
4891 RgSchCellCb    *cell;
4892 RgrDel         *lcDelInfo;
4893 RgSchErrInfo   *errInfo;
4894 #endif
4895 {
4896    RgSchUeCb    *ue = NULLP;
4897 #ifdef LTE_L2_MEAS
4898    uint8_t           lcCount = 0;
4899 #endif
4900    uint8_t           lcgId = 0;
4901
4902    lcgId = lcDelInfo->u.lcgDel.lcgId;
4903
4904    errInfo->errCause = RGSCHERR_CFG_RGR_LCG_DEL;
4905
4906    /* Fetch the Active cell */
4907    if (cell->cellId != lcDelInfo->u.lcgDel.cellId)
4908    {
4909       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4910                 "CELL does not exist for CRNTI:%d LCGID:%d",
4911                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
4912       return RFAILED;
4913    }
4914
4915    /* Fetch the Ue */
4916    if ((ue = rgSCHDbmGetUeCb(cell, lcDelInfo->u.lcgDel.crnti)) == NULLP)
4917    {
4918       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4919                 "UE does not exist for CRNTI:%d LCGID:%d",
4920                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
4921       return RFAILED;
4922    }
4923
4924    /* set lcgId in UEs lcg cntrl blk to invalid */
4925    rgSCHUtlRgrLcgDel(cell, ue, lcgId);
4926    ue->ul.lcgArr[lcgId].lcgId = RGSCH_INVALID_LCG_ID;
4927
4928 #ifdef LTE_L2_MEAS
4929    /* Since LCs are being deleted, if any of them are contributing
4930       to Active UE count for a QCI, decrease the count */
4931    for (lcCount =0; (lcCount < RGSCH_MAX_LC_PER_UE) &&
4932          (lcCount < ue->ul.lcgArr[lcgId].numLch) ; lcCount++)
4933    {
4934       if (ue->ul.lcgArr[lcgId].lcArray[lcCount])
4935       {
4936          if((ue->ul.lcgArr[lcgId].
4937                   lcArray[lcCount]->qciCb->ulUeCount) &&
4938             (ue->ulActiveLCs &
4939              (1 << ((ue->ul.lcgArr[lcgId].
4940                     lcArray[lcCount])->qciCb->qci -1))))
4941             {
4942                /* L2_COUNTERS */
4943                ue->ul.lcgArr[lcgId].
4944                   lcArray[lcCount]->qciCb->ulUeCount--;
4945                ue->ulActiveLCs &= ~(1 <<
4946                      (ue->ul.lcgArr[lcgId].
4947                       lcArray[lcCount]->qciCb->qci -1));
4948             }
4949       }
4950    }
4951 #endif
4952
4953    errInfo->errCause = RGSCHERR_NONE;
4954    return ROK;
4955 }  /* rgSCHCfgRgrLcgDel */
4956
4957
4958
4959 /***********************************************************
4960  *
4961  *     Func : rgSCHCfgVldtRgrLcCfg
4962  *
4963  *
4964  *     Desc : Validates dedicated logical channel configuration recieved from RRM.
4965  *
4966  *     Ret  : S16
4967  *            ROK - Success
4968  *            RFAILED - Failed
4969  *
4970  *     Notes:
4971  *
4972  *     File :
4973  *
4974  **********************************************************/
4975 #ifdef ANSI
4976 S16 rgSCHCfgVldtRgrLcCfg
4977 (
4978 Inst             inst,
4979 RgrLchCfg     *lcCfg,
4980 RgSchCellCb      **cell,
4981 RgSchUeCb        **ue,
4982 RgSchErrInfo     *errInfo
4983 )
4984 #else
4985 S16 rgSCHCfgVldtRgrLcCfg(inst, lcCfg, cell, ue, errInfo)
4986 Inst             inst;
4987 RgrLchCfg     *lcCfg;
4988 RgSchCellCb      **cell;
4989 RgSchUeCb        **ue;
4990 RgSchErrInfo     *errInfo;
4991 #endif
4992 {
4993
4994    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LC_CFG;
4995
4996    if (((*cell) == NULLP) ||
4997        ((*cell)->cellId != lcCfg->cellId))
4998    {
4999       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Cell does not existi for "
5000                "CRNTI:%d LCID:%d",lcCfg->crnti, lcCfg->lcId);
5001       return RFAILED;
5002    }
5003
5004    /* Fetch the Ue */
5005    if ((*ue = rgSCHDbmGetUeCb(*cell, lcCfg->crnti)) == NULLP)
5006    {
5007       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"UE does not exist for dedicated"
5008          " logical channel CRNTI:%d LCID:%d", lcCfg->crnti, lcCfg->lcId);
5009       return RFAILED;
5010    }
5011
5012    /* Validate logical channel Id */
5013    if ((lcCfg->lcId < RGSCH_DEDLC_MIN_LCID)
5014             ||(lcCfg->lcId > RGSCH_DEDLC_MAX_LCID))
5015    {
5016       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid logical channel Id:%d"
5017                "for CRNTI:%d",lcCfg->lcId,lcCfg->crnti);
5018       return RFAILED;
5019    }
5020
5021    if (lcCfg->lcType != CM_LTE_LCH_DTCH && lcCfg->lcType != CM_LTE_LCH_DCCH)
5022    {
5023       RLOG_ARG3(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid logical channel Type %d"
5024                "CRNTI:%d LCID:%d",lcCfg->lcType,lcCfg->crnti, lcCfg->lcId);
5025       return RFAILED;
5026    }
5027
5028    return ROK;
5029 }  /* rgSCHCfgVldtRgrLcCfg */
5030
5031 /***********************************************************
5032  *
5033  *     Func : rgSCHCfgVldtRgrLcgCfg
5034  *
5035  *
5036  *     Desc : Validates dedicated logical channel group configuration recieved from RRM.
5037  *
5038  *     Ret  : S16
5039  *            ROK - Success
5040  *            RFAILED - Failed
5041  *
5042  *     Notes:
5043  *
5044  *     File :
5045  *
5046  **********************************************************/
5047 #ifdef ANSI
5048 S16 rgSCHCfgVldtRgrLcgCfg
5049 (
5050 Inst             inst,
5051 RgrLcgCfg        *lcgCfg,
5052 RgSchCellCb      **cell,
5053 RgSchUeCb        **ue,
5054 RgSchErrInfo     *errInfo
5055 )
5056 #else
5057 S16 rgSCHCfgVldtRgrLcgCfg(inst, lcgCfg, cell, ue, errInfo)
5058 Inst             inst;
5059 RgrLcgCfg        *lcgCfg;
5060 RgSchCellCb      **cell;
5061 RgSchUeCb        **ue;
5062 RgSchErrInfo     *errInfo;
5063 #endif
5064 {
5065
5066    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LCG_CFG;
5067
5068    if (((*cell) == NULLP) ||
5069        ((*cell)->cellId != lcgCfg->cellId))
5070    {
5071       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgCfg->cellId,"Cell does not exist for"
5072                "CRNTI:%d LCGID:%d",lcgCfg->crnti,lcgCfg->ulInfo.lcgId);
5073       return RFAILED;
5074    }
5075
5076    /* Fetch the Ue */
5077    if ((*ue = rgSCHDbmGetUeCb(*cell, lcgCfg->crnti)) == NULLP)
5078    {
5079       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgCfg->cellId,"UE does not exist for "
5080         "dedicated logical channel CRNTI:%d LCGID:%d", lcgCfg->crnti, lcgCfg->ulInfo.lcgId);
5081       return RFAILED;
5082    }
5083
5084    if ((lcgCfg->ulInfo.gbr != 0) && (lcgCfg->ulInfo.mbr < lcgCfg->ulInfo.gbr))
5085    {
5086      return RFAILED;
5087    }
5088
5089    return ROK;
5090 }  /* rgSCHCfgVldtRgrLcgCfg */
5091
5092
5093 /***********************************************************
5094  *
5095  *     Func : rgSCHCfgVldtRgrCellPwrCfg
5096  *
5097  *     Desc : Validates cell power configuration.
5098  *
5099  *     Ret  : S16
5100  *            ROK - Success
5101  *            RFAILED - Failed
5102  *
5103  *     Notes:
5104  *
5105  *     File :
5106  *
5107  **********************************************************/
5108 #ifdef ANSI
5109 static S16 rgSCHCfgVldtRgrCellPwrCfg
5110 (
5111 Inst             inst,
5112 RgrCellCfg       *cellCfg,
5113 RgSchErrInfo     *errInfo
5114 )
5115 #else
5116 static S16 rgSCHCfgVldtRgrCellPwrCfg(inst, cellCfg, errInfo)
5117 Inst             inst;
5118 RgrCellCfg       *cellCfg;
5119 RgSchErrInfo     *errInfo;
5120 #endif
5121 {
5122    UNUSED(inst);
5123    UNUSED(cellCfg);
5124    UNUSED(errInfo);
5125
5126    /* This function does nothing now, placeholder for
5127     * subsequent power config validations that may be needed */
5128
5129
5130    return ROK;
5131 }  /* rgSCHCfgVldtRgrCellPwrCfg */
5132
5133
5134 /***********************************************************
5135  *
5136  *     Func : rgSCHCfgVldtRgrCmnLcCfg
5137  *
5138  *
5139  *     Desc : Validates common logical channel configuration recieved from RRM.
5140  *
5141  *  @param[in]  Inst         inst
5142  *  @param[in]  RgrCellCfg   *cellCfg
5143  *  @param[out] RgSchErrInfo *errInfo
5144  *     Ret  : S16
5145  *            ROK - Success
5146  *            RFAILED - Failed
5147  *
5148  *     Notes:
5149  *
5150  *     File :
5151  *
5152  **********************************************************/
5153 #ifdef ANSI
5154 static S16 rgSCHCfgVldtRgrCmnLcCfg
5155 (
5156 Inst             inst,
5157 RgrCellCfg       *cellCfg,
5158 RgSchErrInfo     *errInfo
5159 )
5160 #else
5161 static S16 rgSCHCfgVldtRgrCmnLcCfg(inst, cellCfg, errInfo)
5162 Inst             inst;
5163 RgrCellCfg       *cellCfg;
5164 RgSchErrInfo     *errInfo;
5165 #endif
5166 {
5167    uint8_t            idx;
5168    RgrCmnLchCfg  *lcCfg;
5169    uint8_t            dirVld  = FALSE;
5170    uint8_t            bitMask = 0x00;
5171    uint8_t            cnt=0;
5172
5173    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CMN_LC_CFG;
5174
5175    for (idx = 0; idx < cellCfg->numCmnLcs; idx++)
5176    {
5177       lcCfg = &(cellCfg->cmnLcCfg[idx]);
5178       /* Validate downlink info */
5179       if (lcCfg->dir & RGR_DIR_TX)
5180       {
5181          if (lcCfg->lcType == CM_LTE_LCH_BCCH)
5182          {
5183             if (lcCfg->dlTrchType == CM_LTE_TRCH_DL_SCH)
5184             {
5185                if(cnt == 0)
5186                {
5187                   bitMask |= RGSCH_BCCH_DLSCH_CFG1;
5188                   cnt++;
5189                }
5190                else
5191                {
5192
5193                   if((
5194                      (cellCfg->siCfg.siWinSize == 1)  ||
5195                      (cellCfg->siCfg.siWinSize == 2)  ||
5196                      (cellCfg->siCfg.siWinSize == 5)  ||
5197                      (cellCfg->siCfg.siWinSize == 10) ||
5198                      (cellCfg->siCfg.siWinSize == 15) ||
5199                      (cellCfg->siCfg.siWinSize == 20) ||
5200                      (cellCfg->siCfg.siWinSize == 40)) &&
5201                      (cellCfg->siCfg.retxCnt>0)
5202                     )
5203                   {
5204                      bitMask |= RGSCH_BCCH_DLSCH_CFG2;
5205                   }
5206                   else
5207                   {
5208                      RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
5209                            "Invalid si config for cell");
5210                      return RFAILED;
5211                   }
5212                }
5213             }
5214             else if (lcCfg->dlTrchType == CM_LTE_TRCH_BCH)
5215             {
5216                bitMask |= RGSCH_BCCH_BCH_CFG;
5217             }
5218             else
5219             {
5220                RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,
5221                      "Invalid transport channel %d for cell", lcCfg->dlTrchType);
5222                return RFAILED;
5223             }
5224          }
5225          else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
5226          {
5227             bitMask |= RGSCH_PCCH_CFG;
5228          }
5229          else if (lcCfg->lcType == CM_LTE_LCH_CCCH)
5230          {
5231             bitMask |= RGSCH_DL_CCCH_CFG;
5232          }
5233          dirVld = TRUE;
5234       }
5235
5236       /* Validate uplink info */
5237       if (lcCfg->dir & RGR_DIR_RX)
5238       {
5239          /* Uplink CCCH */
5240          if (lcCfg->lcType != CM_LTE_LCH_CCCH)
5241          {
5242             RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,"Invalid UL common lcType %d "
5243              "for cell", lcCfg->lcType);
5244             return RFAILED;
5245          }
5246          else
5247          {
5248             bitMask |= RGSCH_UL_CCCH_CFG;
5249          }
5250          dirVld = TRUE;
5251       }
5252
5253       /* Invalid direction */
5254       if (!dirVld)
5255       {
5256          RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,"Invalid Direction %d",
5257             lcCfg->dir);
5258          return RFAILED;
5259       }
5260    }
5261    if (bitMask != RGSCH_CELL_ACTIVE_CFG)
5262    {
5263       RLOG_ARG0(L_ERROR,DBG_CELLID, cellCfg->cellId,
5264                 "Invalid Common channel config for cell");
5265       return RFAILED;
5266    }
5267
5268    return ROK;
5269 }  /* rgSCHCfgVldtRgrCmnLcCfg */
5270
5271
5272 /***********************************************************
5273  *
5274  *     Func : rgSCHCfgVldtUeCqiModeCfg
5275  *
5276  *
5277  *     Desc : Validates UE CQI modes Configuration recieved from RRC.
5278  *
5279  *     Ret  : S16
5280  *            ROK - Success
5281  *            RFAILED - Failed
5282  *
5283  *     Notes:
5284  *
5285  *     File :
5286  *
5287  **********************************************************/
5288 #ifdef ANSI
5289 static S16 rgSCHCfgVldtUeCqiModeCfg
5290 (
5291 RgSchCellCb       *cell,
5292 RgrUeDlCqiCfg     *ueDlCqiCfg
5293 )
5294 #else
5295 static S16 rgSCHCfgVldtUeCqiModeCfg(cell, ueDlCqiCfg)
5296 RgSchCellCb       *cell;
5297 RgrUeDlCqiCfg     *ueDlCqiCfg;
5298 #endif
5299 {
5300
5301 #ifndef TFU_UPGRADE
5302    if((ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx < 1) ||
5303          (ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx > 1024))
5304    {
5305       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
5306                   "Invalid Periodic CQI Info");
5307       return RFAILED;
5308    }
5309 #endif
5310    /* Validate UE Aperiodic CQI mode */
5311    if ((ueDlCqiCfg->aprdCqiCfg.pres == TRUE) &&
5312        ((ueDlCqiCfg->aprdCqiCfg.aprdModeEnum > RGR_APRD_CQI_MOD31) ||
5313         (cell->bwCfg.dlTotalBw <= 7)))
5314    {
5315       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
5316                   "Invalid Aperiodic mode config for DL CQI",
5317             ueDlCqiCfg->aprdCqiCfg.aprdModeEnum);
5318       return RFAILED;
5319    }
5320 #ifndef TFU_UPGRADE
5321    /* Validate UE Periodic CQI mode */
5322    if (ueDlCqiCfg->prdCqiCfg.prdModeEnum > RGR_PRD_CQI_MOD21)
5323    {
5324       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
5325                   "Invalid periodic mode config for DL CQI",
5326                   ueDlCqiCfg->prdCqiCfg.prdModeEnum);
5327       return RFAILED;
5328    }
5329    /* Validate K value in periodic CQI Config */
5330    if(((ueDlCqiCfg->prdCqiCfg.prdModeEnum == RGR_PRD_CQI_MOD20) ||
5331             (ueDlCqiCfg->prdCqiCfg.prdModeEnum == RGR_PRD_CQI_MOD21)) &&
5332          ((ueDlCqiCfg->prdCqiCfg.k < 1)||
5333             (ueDlCqiCfg->prdCqiCfg.k > 4)))
5334    {
5335       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
5336                   "Invalid K for Subband CQI reporting");
5337       return RFAILED;
5338    }
5339 #else
5340    if ((ueDlCqiCfg->prdCqiCfg.type == 1) &&
5341        (ueDlCqiCfg->prdCqiCfg.cqiSetup.prdModeEnum > RGR_PRD_CQI_MOD21))
5342    {
5343      RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
5344                  "Invalid periodic mode config for DL CQI",
5345                  ueDlCqiCfg->prdCqiCfg.cqiSetup.prdModeEnum);
5346      return RFAILED;
5347    }
5348
5349 #endif
5350
5351    return ROK;
5352
5353 }
5354 /***********************************************************
5355  *
5356  *     Func : rgSCHCfgVldtUeMeasGapAckNakRepCfg
5357  *
5358  *
5359  *     Desc : Validates UE Measurement Gap and Ack Nack Repetition Configuration recieved from RRC.
5360  *
5361  *     Ret  : S16
5362  *            ROK - Success
5363  *            RFAILED - Failed
5364  *
5365  *     Notes:
5366  *
5367  *     File :
5368  *
5369  **********************************************************/
5370 #ifdef ANSI
5371 static S16 rgSCHCfgVldtUeMeasGapAckNakRepCfg
5372 (
5373 RgSchCellCb       *cell,
5374 RgrUeCfg          *ueCfg
5375 )
5376 #else
5377 static S16 rgSCHCfgVldtUeMeasGapAckNakRepCfg(cell, ueCfg)
5378 RgSchCellCb       *cell;
5379 RgrUeCfg          *ueCfg;
5380 #endif
5381 {
5382
5383 #ifdef LTE_TDD
5384    if ((ueCfg->ackNackModeEnum == RGR_TDD_ACKNACK_MODE_MULT) &&
5385          (ueCfg->ueAckNackCfg.isAckNackEnabled == TRUE))
5386    {
5387       RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"TDD ACK NACK Multiplexing Mode"
5388       "is not allowed when Ack/Nack is Enabled: %d CRNTI:%d",
5389        ueCfg->ueAckNackCfg.ackNackRepFactor,ueCfg->crnti);
5390       return RFAILED;
5391    }
5392 #endif /* LTE_TDD */
5393    /* Validate AckNackRep Factor */
5394    if((ueCfg->ueAckNackCfg.isAckNackEnabled == FALSE) &&
5395          (!ueCfg->ueMesGapCfg.isMesGapEnabled))
5396    {
5397       return ROK;
5398    }
5399
5400    if(ueCfg->ueAckNackCfg.isAckNackEnabled)
5401    {
5402    if ( (ueCfg->ueAckNackCfg.ackNackRepFactor < RGR_ACKNACK_REPFACT_N2)
5403          || (ueCfg->ueAckNackCfg.ackNackRepFactor > RGR_ACKNACK_REPFACT_N6))
5404    {
5405       RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId, "Invalid ACK NACK REP Factor:%d CRNTI:%d",
5406                ueCfg->ueAckNackCfg.ackNackRepFactor,ueCfg->crnti);
5407       return RFAILED;
5408    }
5409    }
5410    if(ueCfg->ueMesGapCfg.isMesGapEnabled)
5411    {
5412    switch(ueCfg->ueMesGapCfg.gapPrd)
5413    {
5414       case RG_MEAS_GAPPRD_40:
5415          if(ueCfg->ueMesGapCfg.gapOffst >= RG_MEAS_GAPPRD_40)
5416          {
5417             RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Offset:%d CRNTI:%d",
5418                      ueCfg->ueMesGapCfg.gapOffst,ueCfg->crnti);
5419             return RFAILED;
5420          }
5421          break;
5422       case RG_MEAS_GAPPRD_80:
5423          if(ueCfg->ueMesGapCfg.gapOffst >= RG_MEAS_GAPPRD_80)
5424          {
5425             RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Offset:%d CRNTI:%d",
5426                      ueCfg->ueMesGapCfg.gapOffst,ueCfg->crnti);
5427             return RFAILED;
5428          }
5429          break;
5430          default:
5431          {
5432             RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Periodicity Settings:%d"
5433                       "CRNTI:%d", ueCfg->ueMesGapCfg.gapPrd,ueCfg->crnti);
5434             return RFAILED;
5435          }
5436       }
5437    }
5438
5439    return ROK;
5440 }  /* rgSCHCfgVldtUeMeasGapAckNakRepCfg*/
5441
5442
5443 /***********************************************************
5444  *
5445  *     Func : rgSCHCfgVldtUeMeasGapAckNakRepRecfg
5446  *
5447  *
5448  *     Desc : Validates UE Measurement Gap and Ack Nack Repetition Configuration recieved from RRC.
5449  *
5450  *     Ret  : S16
5451  *            ROK - Success
5452  *            RFAILED - Failed
5453  *
5454  *     Notes:
5455  *
5456  *     File :
5457  *
5458  **********************************************************/
5459 #ifdef ANSI
5460 static S16 rgSCHCfgVldtUeMeasGapAckNakRepRecfg
5461 (
5462 RgSchCellCb       *cell,
5463 RgrUeRecfg        *ueRecfg
5464 )
5465 #else
5466 static S16 rgSCHCfgVldtUeMeasGapAckNakRepRecfg(cell, ueRecfg)
5467 RgSchCellCb       *cell;
5468 RgrUeRecfg        *ueRecfg;
5469 #endif
5470 {
5471
5472    if((ueRecfg->ueAckNackRecfg.isAckNackEnabled == FALSE) &&
5473           (!ueRecfg->ueMeasGapRecfg.isMesGapEnabled))
5474    {
5475       return ROK;
5476    }
5477
5478    if(ueRecfg->ueAckNackRecfg.isAckNackEnabled )
5479    {
5480    /* Validate AckNackRep Factor */
5481    if ( (ueRecfg->ueAckNackRecfg.ackNackRepFactor < RGR_ACKNACK_REPFACT_N2)
5482          || (ueRecfg->ueAckNackRecfg.ackNackRepFactor > RGR_ACKNACK_REPFACT_N6))
5483    {
5484       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid ACK NACK REP Factor:%d"
5485                "NEW CRNTI:%d",ueRecfg->ueAckNackRecfg.ackNackRepFactor,ueRecfg->newCrnti);
5486       return RFAILED;
5487    }
5488    }
5489    if(ueRecfg->ueMeasGapRecfg.isMesGapEnabled)
5490    {
5491    switch(ueRecfg->ueMeasGapRecfg.gapPrd)
5492    {
5493       case RG_MEAS_GAPPRD_40:
5494          if(ueRecfg->ueMeasGapRecfg.gapOffst >= RG_MEAS_GAPPRD_40)
5495          {
5496             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Offset:%d"
5497                      "NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapOffst,ueRecfg->newCrnti);
5498             return RFAILED;
5499          }
5500          break;
5501       case RG_MEAS_GAPPRD_80:
5502          if(ueRecfg->ueMeasGapRecfg.gapOffst >= RG_MEAS_GAPPRD_80)
5503          {
5504             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Offset:%d"
5505                      "NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapOffst,ueRecfg->newCrnti);
5506             return RFAILED;
5507          }
5508          break;
5509          default:
5510          {
5511             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Periodicity Settings:%d"
5512                      "NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapPrd,ueRecfg->newCrnti);
5513             return RFAILED;
5514          }
5515       }
5516    }
5517
5518    return ROK;
5519 }  /* rgSCHCfgVldtUeMeasGapAckNakRepRecfg*/
5520
5521 #ifdef LTEMAC_SPS
5522 /***********************************************************
5523  *
5524  *     Func : rgSCHCfgVldtUeDlSpsCfg
5525  *
5526  *
5527  *     Desc : Validates UE's DL SPS configuration recieved from RRC.
5528  *
5529  *     Ret  : S16
5530  *            ROK - Success
5531  *            RFAILED - Failed
5532  *
5533  *     Notes:
5534  *
5535  *     File :
5536  *
5537  **********************************************************/
5538 #ifdef ANSI
5539 static S16 rgSCHCfgVldtUeDlSpsCfg
5540 (
5541 RgSchCellCb       *cell,
5542 RgrUeSpsDlCfg     *dlSpsCfg
5543 )
5544 #else
5545 static S16 rgSCHCfgVldtUeDlSpsCfg(cell, dlSpsCfg)
5546 RgSchCellCb       *cell;
5547 RgrUeSpsDlCfg     *dlSpsCfg;
5548 #endif
5549 {
5550
5551    uint8_t                 idx = 0;
5552
5553    /* peridicity validation done in SPS module */
5554    if ((dlSpsCfg->numPucchVal > RG_SCH_MAX_NUM_N1PUCCH_PER_UE) ||
5555          (dlSpsCfg->numPucchVal == 0))
5556    {
5557       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid number of n1Pucch values"
5558                " in DL SPS Config");
5559       return RFAILED;
5560    }
5561
5562    for (idx = 0; idx < dlSpsCfg->numPucchVal; ++idx)
5563    {
5564       if (dlSpsCfg->n1PucchVal[idx] > RG_SCH_MAX_N1PUCCH_VAL)
5565       {
5566 #ifdef ALIGN_64BIT
5567          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid N1Pucch value"
5568                   " in DL SPS Config %u", dlSpsCfg->n1PucchVal[idx]);
5569 #else
5570          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid N1Pucch value"
5571                   " in DL SPS Config %lu", dlSpsCfg->n1PucchVal[idx]);
5572 #endif
5573          return RFAILED;
5574       }
5575    }
5576    /* SPS_TODO: check will change for TDD */
5577    if ((dlSpsCfg->numSpsHqProc == 0) ||
5578          (dlSpsCfg->numSpsHqProc > RGSCH_MAX_DL_HQ_PROC))
5579    {
5580       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid number of SPS HARQ procs"
5581                " in DL SPS Config");
5582       return RFAILED;
5583    }
5584
5585    return ROK;
5586 }  /* rgSCHCfgVldtDlSpsCfg */
5587 #endif /* LTEMAC_SPS */
5588
5589 /***********************************************************
5590  *
5591  *     Func : rgSCHCfgVldtUePwrCfg
5592  *
5593  *
5594  *     Desc : Validates UE Group power configuration recieved from RRC.
5595  *
5596  *     Ret  : S16
5597  *            ROK - Success
5598  *            RFAILED - Failed
5599  *
5600  *     Notes:
5601  *
5602  *     File :
5603  *
5604  **********************************************************/
5605 #ifdef ANSI
5606 static S16 rgSCHCfgVldtUePwrCfg
5607 (
5608 RgSchCellCb       *cell,
5609 RgrUeUlPwrCfg     *pwrCfg
5610 )
5611 #else
5612 static S16 rgSCHCfgVldtUePwrCfg(cell, pwrCfg)
5613 RgSchCellCb       *cell;
5614 RgrUeUlPwrCfg     *pwrCfg;
5615 #endif
5616 {
5617
5618    /* Group power control works only in accumulated mode */
5619    if (!pwrCfg->isAccumulated)
5620    {
5621       /* Fix */
5622       if (pwrCfg->uePuschPwr.pres)
5623       {
5624          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Accumulation configutation"
5625               " not in sync with group power configuration");
5626          return RFAILED;
5627       }
5628    }
5629
5630    if (rgSCHCfgVldtUeGrpPwrCfg(cell, &pwrCfg->uePuschPwr) != ROK)
5631    {
5632       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid PUSCH Group power"
5633            " configuration");
5634       return RFAILED;
5635    }
5636    if (rgSCHCfgVldtUeGrpPwrCfg(cell, &pwrCfg->uePucchPwr) != ROK)
5637    {
5638       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid PUSCH Group power"
5639            " configuration");
5640       return RFAILED;
5641    }
5642
5643    return ROK;
5644 }  /* rgSCHCfgVldtUePwrCfg */
5645
5646 /***********************************************************
5647  *
5648  *     Func : rgSCHCfgVldtUeGrpPwrCfg
5649  *
5650  *
5651  *     Desc : Validates UE Group power configuration recieved from RRC.
5652  *
5653  *     Ret  : S16
5654  *            ROK - Success
5655  *            RFAILED - Failed
5656  *
5657  *     Notes:
5658  *
5659  *     File :
5660  *
5661  **********************************************************/
5662 #ifdef ANSI
5663 static S16 rgSCHCfgVldtUeGrpPwrCfg
5664 (
5665 RgSchCellCb       *cell,
5666 RgrUeGrpPwrCfg *grpPwrCfg
5667 )
5668 #else
5669 static S16 rgSCHCfgVldtUeGrpPwrCfg(cell, grpPwrCfg)
5670 RgSchCellCb       *cell;
5671 RgrUeGrpPwrCfg *grpPwrCfg;
5672 #endif
5673 {
5674
5675    if ((grpPwrCfg->pres) &&
5676        (((grpPwrCfg->tpcRnti > cell->rntiDb.rntiStart) &&
5677         ((grpPwrCfg->tpcRnti <
5678                      (cell->rntiDb.rntiStart + cell->rntiDb.maxRntis))))))
5679    {
5680       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Uplink Group power "
5681              "configuration");
5682       return RFAILED;
5683    }
5684
5685    return ROK;
5686 }  /* rgSCHCfgVldtUeGrpPwrCfg */
5687
5688 #ifdef LTEMAC_SPS
5689 /***********************************************************
5690  *
5691  *     Func : rgSCHCfgVldtSpsReCfg
5692  *
5693  *
5694  *     Desc : Validates UE SPS and other SPS dependent
5695  *     configuration recieved from RRC.
5696  *
5697  *     Ret  : S16
5698  *            ROK - Success
5699  *            RFAILED - Failed
5700  *
5701  *     Notes:
5702  *
5703  *     File :
5704  *
5705  **********************************************************/
5706 #ifdef ANSI
5707 static S16 rgSCHCfgVldtSpsReCfg
5708 (
5709 RgSchCellCb       *cell,
5710 RgSchUeCb         *ue,
5711 RgrUeRecfg        *ueRecfg
5712 )
5713 #else
5714 static S16 rgSCHCfgVldtSpsReCfg(cell, ue, ueRecfg)
5715 RgSchCellCb       *cell;
5716 RgSchUeCb         *ue;
5717 RgrUeRecfg     *ueRecfg;
5718 #endif
5719 {
5720
5721    if ((ueRecfg->ueRecfgTypes & RGR_UE_DLSPS_RECFG) &&
5722          (ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled))
5723    {
5724       /* Validating SPS RNTI */
5725       if (((ueRecfg->ueSpsRecfg.spsRnti >=  cell->rntiDb.rntiStart) &&
5726           (ueRecfg->ueSpsRecfg.spsRnti<=
5727           (cell->rntiDb.rntiStart+cell->rntiDb.maxRntis)))||
5728           (ueRecfg->ueSpsRecfg.spsRnti == RGSCH_SI_RNTI) ||
5729           (ueRecfg->ueSpsRecfg.spsRnti == RGSCH_P_RNTI))
5730       {
5731          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid SPS RNTI "
5732                   " in DL SPS Recfg OLD CRNTI:%d NEW CCRNTI:%d",
5733                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5734          return RFAILED;
5735       }
5736       if (rgSCHCfgVldtUeDlSpsCfg(cell, &ueRecfg->ueSpsRecfg.dlSpsCfg) != ROK)
5737       {
5738          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid DL SPS configuration"
5739                   " for the OLD CRNTI:%d NEW CRNTI:%d",
5740                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5741          return RFAILED;
5742       }
5743    }
5744
5745 #if RG_SPS_UNUSED
5746    if(ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled)
5747    {
5748      if (ueRecfg->ueRecfgTypes & RGR_UE_DRX_RECFG)
5749      {
5750      /* ccpu00117035 - MOD - changed instIdx to inst */
5751      /* ccpu00117035 - MOD - changed ueID to oldCrnti*/
5752       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
5753                " DRX reconfig not supported DL SPS enabled for OLD CRNTI:%d NEW CRNTI:%d",
5754                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5755       return RFAILED;
5756      }
5757    }
5758 #endif
5759 /* ccpu00117627 - ADD - SPS recfg validation against HDFDD */
5760 #ifdef LTEMAC_HDFDD
5761    if(ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled)
5762    {
5763       if(ue->hdFddEnbld == TRUE)
5764       {
5765          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
5766                   "DL SPS is not supported for HDFDD enabled for OLD CRNTI:%d NEW CRNTI:%d",
5767                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5768          return RFAILED;
5769       }
5770    }
5771    if(ueRecfg->ueSpsRecfg.ulSpsCfg.isUlSpsEnabled)
5772    {
5773       if(ue->hdFddEnbld == TRUE)
5774       {
5775          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
5776                   "UL SPS is not supported for HDFDD enabled for OLD CRNTI:%d NEW CRNTI:%d",
5777                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5778          return RFAILED;
5779       }
5780    }
5781 #endif
5782
5783    return ROK;
5784 }  /*rgSCHCfgVldtSpsReCfg*/
5785 #endif
5786
5787 #if ((defined (RGR_CQI_REPT)) && (defined (RGR_V2)))
5788 /***********************************************************
5789  *
5790  *     Func : rgSCHCfgVldtCqiReptReCfg
5791  *
5792  *
5793  *     Desc : Validates UE CQI report for DL Power control
5794  *     configuration recieved from RRC.
5795  *
5796  *     Ret  : S16
5797  *            ROK - Success
5798  *            RFAILED - Failed
5799  *
5800  *     Notes:
5801  *
5802  *     File :
5803  *
5804  **********************************************************/
5805 #ifdef ANSI
5806 static S16 rgSCHCfgVldtCqiReptReCfg
5807 (
5808 RgSchCellCb       *cell,
5809 RgrUeRecfg     *ueRecfg
5810 )
5811 #else
5812 static S16 rgSCHCfgVldtCqiReptReCfg(cell, ueRecfg)
5813 RgSchCellCb       *cell;
5814 RgrUeRecfg     *ueRecfg;
5815 #endif
5816 {
5817
5818    /* Validate DL Power Control Config parameters */
5819    if (ueRecfg->ueCqiReptCfg.numColltdCqiRept > RGR_CQIRPTS_MAXN)
5820    {
5821       RLOG_ARG3(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalide numColltdCqiRept,"
5822                "MAX supported %d for OLD CRNTI:%d NEW CRNTI:%d",RGR_CQIRPTS_MAXN,
5823                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5824       return RFAILED;
5825    }
5826
5827    return ROK;
5828 }  /*rgSCHCfgVldtCqiReptReCfg*/
5829 #endif
5830
5831 /***********************************************************
5832  *
5833  *     Func : rgSCHCfgRgrLcChfg
5834  *
5835  *
5836  *     Desc : Handles dedicated logical channel configuration
5837  *     recieved from RRC.
5838  *
5839  *     Ret  : S16
5840  *            ROK - Success
5841  *            RFAILED - Failed
5842  *
5843  *     Notes:
5844  *
5845  *     File :
5846  *
5847  **********************************************************/
5848 #ifdef ANSI
5849 S16 rgSCHCfgRgrLchCfg
5850 (
5851 RgSchCellCb      *cell,
5852 RgSchUeCb        *ue,
5853 RgrLchCfg     *lcCfg,
5854 RgSchErrInfo     *errInfo
5855 )
5856 #else
5857 S16 rgSCHCfgRgrLchCfg(cell, ue, lcCfg, errInfo)
5858 RgSchCellCb      *cell;
5859 RgSchUeCb        *ue;
5860 RgrLchCfg     *lcCfg;
5861 RgSchErrInfo     *errInfo;
5862 #endif
5863 {
5864    S16       ret;
5865    RgSchDlLcCb  *dlLc = NULLP;
5866    Inst    inst = cell->instIdx;
5867 #ifdef LTE_L2_MEAS
5868    RgSchUlLcCb  *ulLc;
5869 #endif
5870
5871    errInfo->errCause = RGSCHERR_CFG_RGR_DED_LC_CFG;
5872
5873    /* Allocate the downlink logical channel control block */
5874    if((ret = rgSCHUtlAllocSBuf(inst, (Data**)&dlLc,
5875                sizeof(RgSchDlLcCb))) != ROK)
5876    {
5877       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
5878                "Downlink LCId:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
5879       return RFAILED;
5880    }
5881    if ((uint8_t *)dlLc == NULLP)
5882    {
5883       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
5884                "Downlink LCID:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
5885       return RFAILED;
5886    }
5887    dlLc->lcId   = lcCfg->lcId;
5888 #ifdef LTE_ADV
5889    rgSCHLaaLcCfg(cell, dlLc, lcCfg);
5890 #endif
5891
5892    rgSCHDbmInsDlDedLcCb(ue, dlLc);
5893
5894    ret = rgSCHUtlRgrLcCfg(cell, ue, dlLc, lcCfg, errInfo);
5895
5896    if (ret != ROK)
5897    {
5898       /* ROLLBACK */
5899       if (dlLc)
5900       {
5901          rgSCHDbmDelDlDedLcCb(ue, dlLc);
5902          rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
5903       }
5904
5905       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
5906         "configuration failed at SCH:UEID:%d LCID:%d CRNTI:%d",
5907         ue->ueId, lcCfg->lcId,lcCfg->crnti);
5908       return RFAILED;
5909    }
5910 #ifdef LTE_L2_MEAS
5911    RGSCH_ARRAY_BOUND_CHECK(inst, ue->ul.lcCb, (lcCfg->lcId -1));
5912    if ( !lcCfg->lcId ||
5913          (TRUE == ue->ul.lcCb[lcCfg->lcId -1].isValid))
5914    {
5915       /* ROLLBACK */
5916       if (dlLc)
5917       {
5918          rgSCHDbmDelDlDedLcCb(ue, dlLc);
5919          rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
5920       }
5921
5922       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
5923         "configuration failed at SCH: UL LC CB already existing"
5924         " UEID:%d LCID:%d CRNTI:%d",
5925         ue->ueId, lcCfg->lcId,lcCfg->crnti);
5926       return RFAILED;
5927    }
5928
5929    /* Create UL LC context to maintain LCG to LC mapping and
5930       LC and QCI mapping, this is for L2 Counters :UL ACTIVE UE
5931       PER QCI */
5932    ue->ul.lcCb[lcCfg->lcId -1].isValid = TRUE;
5933    ulLc = &(ue->ul.lcCb[lcCfg->lcId -1]);
5934
5935    ulLc->lcId = lcCfg->lcId;
5936    ulLc->qciCb = &(cell->qciArray[lcCfg->dlInfo.dlQos.qci]);
5937    ulLc->qciCb->qci = lcCfg->dlInfo.dlQos.qci;
5938    ue->ul.lcgArr[lcCfg->lcgId].lcArray[ue->ul.lcgArr[lcCfg->lcgId].numLch] = ulLc;
5939    ulLc->lcg = &ue->ul.lcgArr[lcCfg->lcgId];
5940    ulLc->lcgArrIdx = ue->ul.lcgArr[lcCfg->lcgId].numLch;
5941    ue->ul.lcgArr[lcCfg->lcgId].numLch++;
5942
5943    dlLc->qciCb = &(cell->qciArray[lcCfg->dlInfo.dlQos.qci]);
5944    dlLc->qciCb->qci = lcCfg->dlInfo.dlQos.qci;
5945    if(lcCfg->lcType == CM_LTE_LCH_DTCH)
5946    {
5947      rgSchAddToL2Meas(cell,dlLc); /*LTE_L2_MEAS_PHASE2*/
5948    }
5949 #endif /* LTE_L2_MEAS */
5950
5951    return ROK;
5952 }  /* rgSCHCfgRgrLchCfg */
5953
5954 /***********************************************************
5955  *
5956  *     Func : rgSCHCfgRgrLcgCfg
5957  *
5958  *
5959  *     Desc : Handles dedicated logical channel group configuration
5960  *     recieved from RRM.
5961  *
5962  *     Ret  : S16
5963  *            ROK - Success
5964  *            RFAILED - Failed
5965  *
5966  *     Notes:
5967  *
5968  *     File :
5969  *
5970  **********************************************************/
5971 #ifdef ANSI
5972 S16 rgSCHCfgRgrLcgCfg
5973 (
5974 RgSchCellCb      *cell,
5975 RgSchUeCb        *ue,
5976 RgrLcgCfg        *lcgCfg,
5977 RgSchErrInfo     *errInfo
5978 )
5979 #else
5980 S16 rgSCHCfgRgrLcgCfg(cell, ue, lcgCfg, errInfo)
5981 RgSchCellCb      *cell;
5982 RgSchUeCb        *ue;
5983 RgrLcgCfg        *lcgCfg;
5984 RgSchErrInfo     *errInfo;
5985 #endif
5986 {
5987    S16          ret = ROK;
5988
5989 #ifdef RG_UNUSED
5990 //#ifdef LTE_L2_MEAS
5991    uint32_t          idx;
5992    RgSchUlLcCb  *ulLc;
5993 #endif
5994
5995    errInfo->errCause = RGSCHERR_CFG_RGR_DED_LCG_CFG;
5996
5997    ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcgId = lcgCfg->ulInfo.lcgId;
5998
5999    ret = rgSCHUtlRgrLcgCfg(cell, ue, lcgCfg, errInfo);
6000    if (ret != ROK)
6001    {
6002       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
6003         "configuration failed at SCH: UEID:%d LCGID:%d CRNTI:%d",
6004         ue->ueId, lcgCfg->ulInfo.lcgId,lcgCfg->crnti);
6005       /* Roll back lcgCfg */
6006       ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcgId = RGSCH_INVALID_LCG_ID;
6007       rgSCHUtlRgrLcgDel(cell, ue, lcgCfg->ulInfo.lcgId);
6008       return RFAILED;
6009    }
6010 #ifdef RG_UNUSED
6011 //#ifdef LTE_L2_MEAS
6012    /* Copy all info of UL LCH in cfg to ulLcgCb */
6013    for (idx = 0; idx < lcgCfg->ulInfo.numLch; idx++)
6014    {
6015       /* Allocate the uplink logical channel control block */
6016       if((ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data**)&ulLc,
6017                   sizeof(RgSchUlLcCb))) != ROK)
6018       {
6019          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Memory allocation FAILED for ");
6020          return RFAILED;
6021       }
6022       if ((uint8_t *)ulLc == NULLP)
6023       {
6024          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Memory allocation FAILED for ");
6025          return RFAILED;
6026       }
6027       /* Create UL LC context to maintain LCG to LC mapping and
6028          LC and QCI mapping, this is for L2 Counters :UL ACTIVE UE
6029          PER QCI */
6030       ulLc->lcId = lcgCfg->ulInfo.lchUlCfg[idx].lcId;
6031       ulLc->qciCb = &(cell->qciArray[lcgCfg->ulInfo.lchUlCfg[idx].qci]);
6032       ulLc->qciCb->qci = lcgCfg->ulInfo.lchUlCfg[idx].qci;
6033       ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcArray[idx] = ulLc;
6034       /* L2_COUNTERS */
6035       ue->ul.lcCb[ulLc->lcId -1] = ulLc;
6036       ulLc->lcg = &ue->ul.lcgArr[lcgCfg->ulInfo.lcgId];
6037       ulLc->lcgArrIdx = idx;
6038    }
6039    ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].numLch = lcgCfg->ulInfo.numLch;
6040 #endif /* LTE_L2_MEAS */
6041
6042    return ROK;
6043 }  /* rgSCHCfgRgrLcgCfg */
6044
6045
6046
6047 /***********************************************************
6048  *
6049  *     Func : rgSCHCfgRgrCmnLcCfg
6050  *
6051  *
6052  *     Desc : Handles dedicated logical channel configuration
6053  *     recieved from RRC.
6054  *
6055  *     Ret  : S16
6056  *            ROK - Success
6057  *            RFAILED - Failed
6058  *
6059  *     Notes:
6060  *
6061  *     File :
6062  *
6063  **********************************************************/
6064 #ifdef ANSI
6065 static S16 rgSCHCfgRgrCmnLcCfg
6066 (
6067 RgSchCellCb           *cell,
6068 RgrCmnLchCfg          *lcCfg,
6069 RgSchErrInfo          *errInfo
6070 )
6071 #else
6072 static S16 rgSCHCfgRgrCmnLcCfg(cell, lcCfg, errInfo)
6073 RgSchCellCb         *cell;
6074 RgrCmnLchCfg        *lcCfg;
6075 RgSchErrInfo        *errInfo;
6076 #endif
6077 {
6078    RgSchClcDlLcCb cmnLcCb;
6079
6080    errInfo->errCause = RGSCHERR_CFG_RGR_CMN_LC_CFG;
6081
6082    memset(&cmnLcCb, 0, sizeof(cmnLcCb));
6083
6084    /* Handle configuration for CCCH/BCCH/PCCH */
6085    if (lcCfg->lcType == CM_LTE_LCH_CCCH)
6086    {
6087       /* UL and DL CCCH configuration */
6088       if (lcCfg->dir & RGR_DIR_TX)
6089       {
6090          cell->dlCcchId = lcCfg->lcId;
6091       }
6092
6093       if (lcCfg->dir & RGR_DIR_RX)
6094       {
6095          cell->ulCcchId = lcCfg->lcId;
6096       }
6097    }
6098    else
6099    {
6100       cmnLcCb.lcId = lcCfg->lcId;
6101       rgSCHDbmInitCmnLcBoLst(&cmnLcCb);
6102       if (lcCfg->lcType == CM_LTE_LCH_BCCH)
6103       {
6104          /* BCCH on BCH and DLSCH configuration */
6105          if (lcCfg->dlTrchType == CM_LTE_TRCH_DL_SCH)
6106          {
6107             rgSCHDbmInsBcchOnDlsch(cell, &cmnLcCb);
6108          }
6109          else
6110          {
6111             rgSCHDbmInsBcchOnBch(cell, &cmnLcCb);
6112          }
6113       }
6114       else  /* PCCH configuration */
6115       {
6116          rgSCHDbmInsPcch(cell, &cmnLcCb);
6117       }
6118    }
6119
6120    return ROK;
6121 }  /* rgSCHCfgRgrCmnLcCfg */
6122
6123
6124
6125 /***********************************************************
6126  *
6127  *     Func : rgSCHCfgFreeDlDedLcCb
6128  *
6129  *
6130  *     Desc :
6131  *     - Processing Steps:
6132  *        - Frees downlink dedicated logical channel control block.
6133  *
6134  *     Ret  : Void
6135  *
6136  *     Notes:
6137  *
6138  *     File :
6139  *
6140  **********************************************************/
6141 #ifdef ANSI
6142 static Void rgSCHCfgFreeDlDedLcCb
6143 (
6144 RgSchCellCb      *cell,
6145 RgSchUeCb        *ue,
6146 RgSchDlLcCb      *dlLc
6147 )
6148 #else
6149 static Void rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc)
6150 RgSchCellCb      *cell;
6151 RgSchUeCb        *ue;
6152 RgSchDlLcCb      *dlLc;
6153 #endif
6154 {
6155    Inst    inst = cell->instIdx;
6156
6157    rgSCHUtlFreeDlLc(cell, ue, dlLc);
6158
6159    /* De-allocate the Cb */
6160    /* ccpu00117052 - MOD - Passing double pointer
6161       for proper NULLP assignment*/
6162    rgSCHUtlFreeSBuf(inst, (Data **)&dlLc, sizeof(*dlLc));
6163
6164
6165   /* Stack Crash problem for TRACE5 changes. Added the return below */
6166   return;
6167
6168 }  /* rgSCHCfgFreeDlDedLcCb */
6169
6170
6171 /***********************************************************
6172  *
6173  *     Func : rgSCHCfgFreeDlCmnLcCb
6174  *
6175  *
6176  *     Desc :
6177  *     - Processing Steps:
6178  *        - Frees downlink common logical channel control block.
6179  *
6180  *     Ret  : Void
6181  *
6182  *     Notes:
6183  *
6184  *     File :
6185  *
6186  **********************************************************/
6187 #ifdef ANSI
6188 static Void rgSCHCfgFreeDlCmnLcCb
6189 (
6190 RgSchClcDlLcCb   *cmnDlLc
6191 )
6192 #else
6193 static Void rgSCHCfgFreeDlCmnLcCb(cmnDlLc)
6194 RgSchClcDlLcCb      *cmnDlLc;
6195 #endif
6196 {
6197
6198    memset(cmnDlLc, 0, sizeof(*cmnDlLc));
6199    cmnDlLc->lcId = RGSCH_INVALID_LC_ID;
6200    return;
6201 }  /* rgSCHCfgFreeDlCmnLcCb */
6202
6203
6204 /***********************************************************
6205  *
6206  *     Func : rgSCHCfgFreeCellCb
6207  *
6208  *
6209  *     Desc :
6210  *     - Processing Steps:
6211  *        - Frees scheduler cell control block.
6212  *
6213  *     Ret  : Void
6214  *
6215  *     Notes:
6216  *
6217  *     File :
6218  *
6219  **********************************************************/
6220 #ifdef ANSI
6221 Void rgSCHCfgFreeCellCb
6222 (
6223 RgSchCellCb      *cell
6224 )
6225 #else
6226 Void rgSCHCfgFreeCellCb(cell)
6227 RgSchCellCb      *cell;
6228 #endif
6229 {
6230    Inst    inst = cell->instIdx;
6231    CmLList            *node;
6232    Buffer             *pdu;
6233    RgSchWarningSiInfo *warningSi;
6234    RgSchWarningSiPdu  *warningSiPdu;
6235    uint8_t                  idx;
6236
6237    /* ccpu00132385- SI Warning PDUs which are not processed need to be deleted */
6238    /* Search for used index in WarningSi */
6239    for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
6240    {
6241       if(cell->siCb.warningSi[idx].siId == 0)
6242         continue;
6243       cell->siCb.siCtx.siId = cell->siCb.warningSi[idx].siId;
6244       warningSi = (RgSchWarningSiInfo *) cell->siCb.
6245                   siArray[cell->siCb.siCtx.siId-1].si;
6246       if(warningSi != NULLP)
6247       {
6248          /* ccpu00136659: CMAS ETWS design change */
6249          while (CM_LLIST_FIRST_NODE(&warningSi->warningSiMsg.segLstCp, node))
6250          {
6251             warningSiPdu = (RgSchWarningSiPdu *)node->node;
6252             pdu = warningSiPdu->pdu;
6253             /* ccpu00136659: CMAS ETWS design change */
6254             cmLListDelFrm(&warningSi->warningSiMsg.segLstCp, node);
6255             RGSCH_FREE_MSG(pdu);
6256          }
6257          cell->siCb.siArray[cell->siCb.siCtx.siId-1].si = NULLP;
6258       }
6259    }
6260    /* Free lists of the cell */
6261    rgSCHCfgFreeUeLst(cell);
6262 #ifdef LTEMAC_SPS
6263    rgSCHCfgFreeSpsUeLst(cell);
6264 #endif /* LTEMAC_SPS */
6265 #ifdef EMTC_ENABLE
6266       if ( TRUE == cell->emtcEnable )
6267       {
6268          rgSCHEmtcCellDel(cell);
6269       }
6270 #endif
6271    rgSCHRamFreeCell(cell);
6272
6273    rgSCHDbmRntiDbDeInit(cell);
6274    /* Deallocate the subframe allocation information */
6275    rgSCHUtlPutSfAlloc(cell);
6276    rgSCHUtlFreeCell(cell);
6277
6278    rgSCHCfgFreeRgrCfgLst(cell);
6279    rgSCHCfgFreeCmnLcLst(cell);
6280
6281    rgSCHUtlPutRlsHqAlloc(cell);
6282
6283 #ifdef LTE_TDD
6284    rgSCHDbmDeInitUeTfuPendLst(cell);
6285 #endif /* LTE_TDD */
6286
6287 #ifdef RGR_SI_SCH
6288    rgSCHUtlPutSiInfo(cell);
6289 #endif/*RGR_SI_SCH*/
6290
6291    (Void)rgSCHDrxCellDel(cell);
6292
6293    rgSCHUtlFreeSBuf(inst, (Data**)&(cell->dynCfiCb.cceFailSamples),
6294                (cell->dynCfiCb.numFailSamples * sizeof(uint16_t)));
6295
6296 #ifdef TENB_STATS
6297    TSL2DeallocCellStatsBlk(cell->cellId);
6298 #endif
6299
6300 #ifdef LTE_ADV
6301    /* LAA_SCELL: Trigger the De-Init function for the LAA Module */
6302    rgSCHLaaSCellCbDeInit(cell);
6303 #endif
6304
6305 #ifdef EMTC_ENABLE
6306    if(cell->emtcEnable)
6307    {
6308       rgSCHEmtcCellFree(cell);
6309    }
6310 #endif
6311    /* De-allocate the Cell */
6312    /* ccpu00117052 - MOD - Passing double pointer
6313    for proper NULLP assignment*/
6314    rgSCHUtlFreeSBuf(inst, (Data **)&cell, sizeof(*cell));
6315
6316
6317
6318   /* Stack Crash problem for TRACE5 changes. Added the return below */
6319   return;
6320
6321 }  /* rgSCHCfgFreeCellCb */
6322
6323
6324 /***********************************************************
6325  *
6326  *     Func : rgSCHCfgFreeUeCb
6327  *
6328  *
6329  *     Desc :
6330  *     - Processing Steps:
6331  *        - Frees UE control block.
6332  *
6333  *     Ret  : Void
6334  *
6335  *     Notes:
6336  *
6337  *     File :
6338  *
6339  **********************************************************/
6340 #ifdef ANSI
6341 static Void rgSCHCfgFreeUeCb
6342 (
6343 RgSchCellCb    *cell,
6344 RgSchUeCb      *ue
6345 )
6346 #else
6347 static Void rgSCHCfgFreeUeCb(cell, ue)
6348 RgSchCellCb    *cell;
6349 RgSchUeCb      *ue;
6350 #endif
6351 {
6352    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
6353    RgUeUlHqCb       *ulHqEnt;
6354    RgSchDlLcCb       *dlLc;
6355    Inst    inst = cell->instIdx;
6356    uint8_t lcCnt;
6357    uint8_t lcgId;
6358
6359    /* Free all logical channel info per UE */
6360    while((dlLc = rgSCHDbmGetNextDlDedLcCb(ue, NULLP)) != NULLP)
6361    {
6362       rgSCHDbmDelDlDedLcCb(ue, dlLc);
6363       rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
6364    }
6365    for (lcCnt =0; lcCnt<RGSCH_MAX_LC_PER_UE; lcCnt++)
6366    {
6367       if(ue->ul.lcCb[lcCnt].isValid == TRUE)
6368       {
6369          lcgId = ue->ul.lcCb[lcCnt].lcg->lcgId;
6370          if (lcgId <=3)
6371          {
6372             rgSCHUtlRgrLcDel(cell, ue, ue->ul.lcCb[lcCnt].lcId,lcgId);
6373             ue->ul.lcCb[lcCnt].isValid = FALSE;
6374          }
6375       }
6376    }
6377
6378    ulHqEnt = &(ueUl->hqEnt);
6379    /* Free Scheduler specific information per UE */
6380    rgSCHUtlFreeUe(cell, ue);
6381
6382    /* Free Uplink HARQ specific information per UE */
6383    rgSCHUhmFreeUe(cell, ulHqEnt);
6384
6385    if ( ue->drxCb != NULLP)
6386    {
6387       /* free drxCb */
6388    /* ccpu00117052 - MOD - Passing double pointer
6389    for proper NULLP assignment*/
6390       rgSCHUtlFreeSBuf(cell->instIdx,
6391             (Data**)(&(ue->drxCb)),
6392             sizeof(RgSchDrxUeCb));
6393    }
6394
6395    ue->drxCb = (RgSchDrxUeCb *)NULLP;
6396    /* Free Downlink HARQ specific information per UE */
6397    rgSCHDhmFreeUe(ue);
6398    /* Release the RNTI */
6399    if (ue->rntiLnk)
6400    {
6401       rgSCHUtlRlsRnti(cell, ue->rntiLnk, FALSE, 0);
6402    }
6403    else
6404    {
6405       /* Fix : syed HO UE does not have a valid ue->rntiLnk */
6406       /* Just indicate to MAC, no need to release at SCH */
6407       rgSCHUtlIndRntiRls2Mac(cell, ue->ueId, FALSE, 0);
6408    }
6409 /* rg009.201. Added changes of TFU_UPGRADE */
6410 #ifdef TFU_UPGRADE
6411     rgSCHCfgPCqiSrsSrUeDel(cell,ue);
6412 #endif
6413 #ifdef LTEMAC_HDFDD
6414     rgSCHHdFddUeDel(cell, ue);
6415 #endif
6416 #ifdef TENB_STATS
6417     if (ue->tenbStats)
6418     {
6419        TSL2DeallocUeStatsBlk(ue->ueId, ue->tenbStats);
6420     }
6421 #endif
6422
6423    /* CA TODO Some handling needed while SCell Delete*/
6424 #ifdef LTE_ADV
6425    /* Delete the UE from the PCell secCellActCeLst*/
6426    rgSCHSCellRmvFrmActLst(cell, ue);
6427    rgSCHSCellDelUe(cell,ue);
6428 #endif
6429
6430 #ifdef LTE_ADV
6431    rgSCHLaaDeInitDlRbAllocCb(cell, &ue->cellInfo[RGSCH_PCELL_INDEX]->dlAllocCb);
6432 #endif
6433
6434    rgSCHUtlFreeSBuf(inst, (Data **)&ue->cellInfo[0], sizeof(RgSchUeCellInfo));
6435    /* De-allocate the Ue */
6436    /* ccpu00117052 - MOD - Passing double pointer
6437    for proper NULLP assignment*/
6438 #ifdef EMTC_ENABLE
6439    if(ue->isEmtcUe)
6440    {
6441       rgSCHEmtcUeInfoFree(cell, ue);
6442    }
6443 #endif
6444    rgSCHUtlFreeSBuf(inst, (Data **)&ue, sizeof(*ue));
6445
6446   /* Stack Crash problem for TRACE5 changes. Added the return below */
6447   return;
6448
6449 }  /* rgSCHCfgFreeUeCb */
6450
6451 /***********************************************************
6452  *
6453  *     Func : rgSCHCfgFreeRgrCfgLst
6454  *
6455  *
6456  *     Desc :
6457  *     - Processing Steps:
6458  *        - Frees configuration lists in cell control block.
6459  *
6460  *     Ret  : Void
6461  *
6462  *     Notes:
6463  *
6464  *     File :
6465  *
6466  **********************************************************/
6467 #ifdef ANSI
6468 static Void rgSCHCfgFreeRgrCfgLst
6469 (
6470 RgSchCellCb      *cell
6471 )
6472 #else
6473 static Void rgSCHCfgFreeRgrCfgLst(cell)
6474 RgSchCellCb      *cell;
6475 #endif
6476 {
6477    RgSchCfgElem  *rgCfgElem;
6478    Inst    inst = cell->instIdx;
6479
6480    /* Free CURRENT RGR cfg list */
6481    while ((rgCfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
6482    {
6483       rgSCHDbmDelCrntRgrCfgElem(cell, rgCfgElem);
6484    /* ccpu00117052 - MOD - Passing double pointer
6485    for proper NULLP assignment*/
6486       rgSCHUtlFreeSBuf(inst, (Data **)&rgCfgElem, sizeof(*rgCfgElem));
6487    }
6488
6489    /* Free PENDING RGR cfg list */
6490    while ((rgCfgElem = rgSCHDbmGetNextPndngRgrCfgElem(cell, NULLP)) != NULLP)
6491    {
6492       rgSCHDbmDelPndngRgrCfgElem(cell, rgCfgElem);
6493    /* ccpu00117052 - MOD - Passing double pointer
6494    for proper NULLP assignment*/
6495       rgSCHUtlFreeSBuf(inst, (Data **)&rgCfgElem, sizeof(*rgCfgElem));
6496    }
6497
6498
6499   /* Stack Crash problem for TRACE5 changes. Added the return below */
6500   return;
6501
6502 }  /* rgSCHCfgFreeRgrCfgLst */
6503
6504
6505 /***********************************************************
6506  *
6507  *     Func : rgSCHCfgFreeCmnLcLst
6508  *
6509  *
6510  *     Desc :
6511  *     - Processing Steps:
6512  *        - Frees common logical channels in cell control block.
6513  *
6514  *     Ret  : Void
6515  *
6516  *     Notes:
6517  *
6518  *     File :
6519  *
6520  **********************************************************/
6521 #ifdef ANSI
6522 static Void rgSCHCfgFreeCmnLcLst
6523 (
6524 RgSchCellCb      *cell
6525 )
6526 #else
6527 static Void rgSCHCfgFreeCmnLcLst(cell)
6528 RgSchCellCb      *cell;
6529 #endif
6530 {
6531    RgSchClcDlLcCb *dlCmnLc;
6532
6533
6534    if ((dlCmnLc = rgSCHDbmGetBcchOnBch(cell)) != NULLP)
6535    {
6536       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6537    }
6538    if ((dlCmnLc = rgSCHDbmGetFirstBcchOnDlsch(cell)) != NULLP)
6539    {
6540       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6541    }
6542    if ((dlCmnLc = rgSCHDbmGetSecondBcchOnDlsch(cell)) != NULLP)
6543    {
6544       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6545    }
6546    if ((dlCmnLc = rgSCHDbmGetPcch(cell)) != NULLP)
6547    {
6548       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6549    }
6550
6551
6552   /* Stack Crash problem for TRACE5 changes. Added the return below */
6553   return;
6554
6555 }  /* rgSCHCfgFreeCmnLcLst */
6556
6557
6558 /***********************************************************
6559  *
6560  *     Func : rgSCHCfgFreeUeLst
6561  *
6562  *
6563  *     Desc :
6564  *     - Processing Steps:
6565  *        - Frees UE list in cell control block.
6566  *
6567  *     Ret  : Void
6568  *
6569  *     Notes:
6570  *
6571  *     File :
6572  *
6573  **********************************************************/
6574 #ifdef ANSI
6575 static Void rgSCHCfgFreeUeLst
6576 (
6577 RgSchCellCb      *cell
6578 )
6579 #else
6580 static Void rgSCHCfgFreeUeLst(cell)
6581 RgSchCellCb      *cell;
6582 #endif
6583 {
6584    RgSchUeCb     *ue;
6585 #ifdef LTE_ADV
6586    RgSchUeCellInfo *sCellInfo;
6587    CmLList         *node;
6588 #endif
6589
6590    /* Free Ues in the list */
6591    while ((ue = rgSCHDbmGetNextUeCb(cell, NULLP)) != NULLP)
6592    {
6593       rgSCHDbmDelUeCb(cell, ue);
6594
6595 #ifdef LTE_ADV
6596       if(ue->cell != cell)
6597       {
6598          continue;
6599       }
6600 #endif
6601
6602       /* Call MeasGap and AckNakRep processing module */
6603       rgSCHMeasGapANRepUeDel(cell, ue, TRUE);
6604
6605       rgSCHCfgFreeUeCb(cell, ue);
6606    }
6607
6608    /* De-initialize the Ue list */
6609    rgSCHDbmDeInitUeCbLst(cell);
6610
6611
6612 #ifdef LTE_ADV
6613    node = cell->sCellUeLst.first;
6614    while(node)
6615    {
6616       sCellInfo = (RgSchUeCellInfo *)node->node;
6617       node = node->next;
6618       rgSCHSCellDelUeSCell(sCellInfo->ue->cell, sCellInfo->ue, sCellInfo->sCellIdx);
6619    }
6620 #endif
6621
6622   /* Stack Crash problem for TRACE5 changes. Added the return below */
6623   return;
6624
6625 }  /* rgSCHCfgFreeUeLst */
6626
6627 #ifdef LTEMAC_SPS
6628 /***********************************************************
6629  *
6630  *     Func : rgSCHCfgFreeSpsUeLst
6631  *
6632  *
6633  *     Desc :
6634  *     - Processing Steps:
6635  *        - Frees Sps UE list in cell control block.
6636  *
6637  *     Ret  : Void
6638  *
6639  *     Notes:
6640  *
6641  *     File :
6642  *
6643  **********************************************************/
6644 #ifdef ANSI
6645 static Void rgSCHCfgFreeSpsUeLst
6646 (
6647 RgSchCellCb      *cell
6648 )
6649 #else
6650 static Void rgSCHCfgFreeSpsUeLst(cell)
6651 RgSchCellCb      *cell;
6652 #endif
6653 {
6654    RgSchUeCb     *ue;
6655
6656    /* Free Ues in the list */
6657    while ((ue = rgSCHDbmGetNextSpsUeCb(cell, NULLP)))
6658    {
6659       rgSCHDbmDelSpsUeCb(cell, ue);
6660    }
6661
6662    /* De-initialize the Ue list */
6663    rgSCHDbmDeInitSpsUeCbLst(cell);
6664
6665 }  /* rgSCHCfgFreeSpsUeLst */
6666
6667 #endif /* LTEMAC_SPS */
6668
6669 #ifdef RGR_SI_SCH
6670 /***********************************************************
6671  *
6672  *     Func : rgSCHCfgVldtRgrCellSiCfg
6673  *
6674  *     Desc : Validates SI Configuration for SI
6675  *
6676  *     Ret  : S16
6677  *            ROK - Success
6678  *            RFAILED - Failed
6679  *
6680  *     Notes:
6681  *
6682  *     File :
6683  *
6684  **********************************************************/
6685 #ifdef ANSI
6686 static S16 rgSCHCfgVldtRgrCellSiCfg
6687 (
6688 Inst             inst,
6689 RgrSiCfg         *siCfg
6690 )
6691 #else
6692 static S16 rgSCHCfgVldtRgrCellSiCfg(inst, siCfg)
6693 Inst             inst;
6694 RgrSiCfg       *siCfg;
6695 #endif
6696 {
6697    uint8_t   idx; /* idx for iteration */
6698
6699    UNUSED(inst);
6700
6701 #ifndef LTE_TDD
6702    /* Check that retxCnt value should be <= value of siWinSize.
6703    This validation is only applicable for FDD mode. */
6704    if(siCfg->retxCnt > siCfg->siWinSize)
6705    {
6706       RLOG0(L_ERROR,"retxCnt is greater than siWinSize, validation failed");
6707       return RFAILED;
6708    }
6709 #endif
6710
6711    /* Validate that a valid value for numSi has been specified */
6712    if(siCfg->numSi > RGR_MAX_NUM_SI)
6713    {
6714       RLOG0(L_ERROR,"Validation for numSi in SI CFG failed");
6715       return RFAILED;
6716    }
6717
6718    /* MinPeriodicity will have the least configured periodicity
6719     * Hence initializing with Max periodicity */
6720    siCfg->minPeriodicity = RGR_SI_PERD_512;
6721
6722    /*Validate the value of periodicity specified for SIs */
6723    for(idx = 0;idx < siCfg->numSi;idx++)
6724    {
6725       siCfg->minPeriodicity =     RGSCH_MIN(siCfg->minPeriodicity,
6726             siCfg->siPeriodicity[idx]);
6727          /* Set the siPeriodicity as a multiple of 80 subframes */
6728          switch(siCfg->siPeriodicity[idx])
6729          {
6730             case RGR_SI_PERD_8:
6731             case RGR_SI_PERD_16:
6732             case RGR_SI_PERD_32:
6733             case RGR_SI_PERD_64:
6734             case RGR_SI_PERD_128:
6735             case RGR_SI_PERD_256:
6736             case RGR_SI_PERD_512:
6737                continue;
6738
6739          default:
6740             RLOG0(L_ERROR,"Validation for SI Periodicity in SI-CFG failed");
6741             return RFAILED;
6742       }
6743    }
6744
6745    return ROK;
6746 }  /* rgSCHCfgVldtRgrCellSiCfg */
6747
6748 /* LTE_ADV_FLAG_REMOVED_START */
6749 /***********************************************************
6750  *
6751  *     Func : rgSCHCfgVldtRgrCellLtrAdvCfg
6752  *
6753  *     Desc : Validates Lte Adv Configuration
6754  *
6755  *     Ret  : S16
6756  *            ROK - Success
6757  *            RFAILED - Failed
6758  *
6759  *     Notes:
6760  *
6761  *     File :
6762  *
6763  **********************************************************/
6764 #ifdef ANSI
6765 static S16 rgSCHCfgVldtRgrCellLteAdvCfg
6766 (
6767  Inst                     inst,
6768  RgrLteAdvancedCellConfig *lteAdvCfg,
6769  uint8_t                       dlTotalBw
6770  )
6771 #else
6772 static S16 rgSCHCfgVldtRgrCellLteAdvCfg(inst, lteAdvCfg, dlTotalBw)
6773    Inst                     inst;
6774    RgrLteAdvancedCellConfig *lteAdvCfg;
6775    uint8_t                       dlTotalBw;
6776 #endif
6777 {
6778    uint8_t temp[RGR_ABS_PATTERN_LEN];
6779    uint32_t idx;
6780    UNUSED(inst);
6781
6782    if((lteAdvCfg->pres & RGR_SFR) && (RGR_ENABLE == lteAdvCfg->sfrCfg.status))
6783    {
6784       if(lteAdvCfg->sfrCfg.cellEdgeRbRange.startRb > lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb)
6785       {
6786          RLOG0(L_ERROR,"Invalid configuration of cell edge bandwidth for SFR feature");
6787          return RFAILED;
6788       }
6789
6790       if(lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb >= dlTotalBw)
6791       {
6792          RLOG0(L_ERROR,"Invalid configuration of cell edge end RB for SFR feature");
6793          return RFAILED;
6794       }
6795
6796 #ifdef TFU_UPGRADE
6797       if(lteAdvCfg->sfrCfg.pwrThreshold.pLow >= lteAdvCfg->sfrCfg.pwrThreshold.pHigh)
6798       {
6799          RLOG0(L_ERROR,"Invalid configuration of power threshold for SFR feature");
6800          return RFAILED;
6801       }
6802 #endif
6803    }
6804
6805    if((lteAdvCfg->pres & RGR_ABS) && (RGR_ENABLE == lteAdvCfg->absCfg.status))
6806    {
6807       if((RGR_ABS_MUTE != lteAdvCfg->absCfg.absPatternType) &&
6808             (RGR_ABS_TRANSMIT != lteAdvCfg->absCfg.absPatternType))
6809       {
6810          RLOG0(L_ERROR,"Invalid configuration of ABS pattern type");
6811          return RFAILED;
6812       }
6813
6814        memcpy(temp, lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
6815
6816        /* Added validation for ABS pattern len */
6817       for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
6818       {
6819          if((temp[idx] != 1) && (temp[idx] != 0))
6820         {
6821          RLOG0(L_ERROR,"Invalid configuration of ABS pattern type");
6822          return RFAILED;
6823         }
6824       }
6825    }
6826
6827    return ROK;
6828 }
6829 /* LTE_ADV_FLAG_REMOVED_END */
6830
6831
6832 /***********************************************************
6833  *
6834  *     Func : rgSCHCfgVldtRgrCellCsgParamCfg
6835  *
6836  *     Desc : Validates CSG Parameter Configuration
6837  *
6838  *     Ret  : S16
6839  *            ROK - Success
6840  *            RFAILED - Failed
6841  *
6842  *     Notes:
6843  *
6844  *     File :
6845  *
6846  **********************************************************/
6847 #ifdef ANSI
6848 static S16 rgSCHCfgVldtRgrCellCsgParamCfg
6849 (
6850 Inst                     inst,
6851 RgrCellCsgParamCfg       *csgParam
6852 )
6853 #else
6854 static S16 rgSCHCfgVldtRgrCellCsgParamCfg(inst, csgParam)
6855 Inst                     inst;
6856 RgrCellCsgParamCfg       *csgParam;
6857 #endif
6858 {
6859
6860    RGSCHDBGPRM(inst, (rgSchPBuf(inst), "Validating CSG Parameters \n"));
6861
6862    if(csgParam->minDlResNonCsg > 100)
6863    {
6864       RLOG0(L_ERROR,"Invalid Configuration of minimum DL resources "
6865             "for NON-CSG");
6866       return RFAILED;
6867    }
6868    if(csgParam->minUlResNonCsg > 100)
6869    {
6870       RLOG0(L_ERROR,"Invalid Configuration of minimum UL resources "
6871             "for NON-CSG");
6872       return RFAILED;
6873    }
6874    return ROK;
6875 }
6876
6877 /**
6878  * @brief Validates the SI configuration request from RRM to MAC.
6879  *
6880  * @details
6881  *
6882  *     Function : rgSCHCfgVldtRgrSiCfg
6883  *
6884  *     Processing Steps:
6885  *        - Validate the range of configured values recieved in
6886  *          configuration request.
6887  *        - If validated successfully,
6888  *          - Return ROK
6889  *        - Else
6890  *          - Return RFAILED.
6891  *      - Else return RFAILED.
6892  *  @param[in]  Inst         inst
6893  *  @param[in]  RgrCellCfg   *siCfg
6894  *  @param[out] RgSchCellCb  *cell
6895  *  @param[out] RgSchErrInfo *errInfo
6896  *  @return  S16
6897  *      -# ROK
6898  *      -# RFAILED
6899  **/
6900 #ifdef ANSI
6901 S16 rgSCHCfgVldtRgrSiCfg
6902 (
6903 Inst         inst,
6904 RgrSiCfgReqInfo *siCfg,
6905 RgSchCellCb      *cell,
6906 RgSchErrInfo *errInfo
6907 )
6908 #else
6909 S16 rgSCHCfgVldtRgrSiCfg(inst, siCfg, cell, errInfo)
6910 Inst         inst;
6911 RgrSiCfgReqInfo *siCfg;
6912 RgSchCellCb      *cell;
6913 RgSchErrInfo *errInfo;
6914 #endif
6915 {
6916    MsgLen  msgLen = 0;
6917    uint8_t      numSi;
6918
6919    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_SI_CFG;
6920
6921    /*Validate the cfgType parameter */
6922    switch(siCfg->cfgType)
6923    {
6924       /*ccpu00140789*/
6925       case RGR_SI_STOP:
6926          numSi = (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) ?
6927               cell->siCb.newSiCfg.numSi : cell->siCfg.numSi;
6928          if((siCfg->siId < RGSCH_SI_SIID_LOWER_LMT) ||
6929                  (siCfg->siId > numSi))
6930          {
6931             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid SI Id value"
6932                      " specified");
6933             return RFAILED;
6934          }
6935          errInfo->errCause = RGSCHERR_NONE;
6936          return ROK;
6937       break;
6938       case RGR_SI_CFG_TYPE_MIB:      /* SI CFG Type MIB */
6939       case RGR_SI_CFG_TYPE_SIB1:     /* SI CFG TYPE SIB1 */
6940       case RGR_SI_CFG_TYPE_SIB1_PWS: /* SI CFG TYPE SIB1_PWS */
6941       case RGR_SI_CFG_TYPE_SIB8_CDMA:    /* SI CFG TYPE SIB 8 CDMA */
6942 #ifdef EMTC_ENABLE
6943       case RGR_SI_CFG_EMTC_TYPE_SIB1_BR:
6944       case RGR_SI_CFG_EMTC_TYPE_SIB1_BR_PER:
6945 #endif
6946          break;
6947
6948       case RGR_SI_CFG_TYPE_SI:    /* SI CFG TYPE SI */
6949          /*Check that value of SI should be less than equal
6950            to configured numSi parameter value */
6951          /* Added siId validation for lower limit */
6952          numSi = (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) ?
6953             cell->siCb.newSiCfg.numSi : cell->siCfg.numSi;
6954          if((siCfg->siId < RGSCH_SI_SIID_LOWER_LMT) ||
6955                (siCfg->siId > numSi))
6956          {
6957             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid SI Id value"
6958                      " specified");
6959             return RFAILED;
6960          }
6961
6962          if(siCfg->siId > ((cell->siCfg.minPeriodicity * 10)/cell->siCfg.siWinSize))
6963          {
6964             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "SiId can not be scheduled ");
6965             return RFAILED;
6966          }
6967          break;
6968
6969 #ifdef EMTC_ENABLE
6970       case RGR_SI_CFG_EMTC_TYPE_SI:
6971       case RGR_SI_CFG_EMTC_TYPE_SI_PER:
6972          if(ROK != rgEmtcvalidateSiCfg(siCfg,cell))
6973          {
6974             return RFAILED;
6975          }
6976          break;
6977 #endif
6978       default:
6979          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid cfgType "
6980                       "parameter value");
6981          return RFAILED;
6982    }
6983
6984    /*Validate the specified pdu */
6985    if(NULLP == siCfg->pdu)
6986    {
6987       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid NULLP pdu "
6988                    "specified");
6989       return RFAILED;
6990    }
6991
6992    /*Check if PDU is of 0 length*/
6993    SFndLenMsg(siCfg->pdu, &msgLen);
6994    if(0 == msgLen)
6995    {
6996       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid pdu "
6997                    "specified");
6998       return RFAILED;
6999    }
7000
7001    errInfo->errCause = RGSCHERR_NONE;
7002
7003
7004    return ROK;
7005 }  /* rgSCHCfgVldtRgrSiCfg */
7006 #endif /*RGR_SI_SCH*/
7007
7008 /* LTE_ADV_FLAG_REMOVED_START */
7009 /**
7010  * @brief Validates the RNTP INF request from RRM to MAC.
7011  *
7012  * @details
7013  *
7014  *     Function : rgSCHCfgVldtRgrLoadInf
7015  *
7016  *     Processing Steps:
7017  *        - Validate the range of configured values recieved in
7018  *          LOAD INF request.
7019  *        - If validated successfully,
7020  *          - Return ROK
7021  *        - Else
7022  *          - Return RFAILED.
7023  *      - Else return RFAILED.
7024  *  @param[in]  Inst                inst
7025  *  @param[in]  RgrLoadInfReqInfo   *loadInfReq
7026  *  @param[out] RgSchCellCb         *cell
7027  *  @param[out] RgSchErrInfo        *errInfo
7028  *  @return  S16
7029  *      -# ROK
7030  *      -# RFAILED
7031  **/
7032 #ifdef ANSI
7033 S16 rgSCHCfgVldtRgrLoadInf
7034 (
7035  Inst              inst,
7036  RgrLoadInfReqInfo *loadInfReq,
7037  RgSchCellCb       *cell,
7038  RgSchErrInfo      *errInfo
7039  )
7040 #else
7041 S16 rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, errInfo)
7042    Inst              inst;
7043    RgrLoadInfReqInfo *loadInfReq;
7044    RgSchCellCb       *cell;
7045    RgSchErrInfo      *errInfo;
7046 #endif
7047 {
7048
7049    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LOAD_INF;
7050
7051    /* Validate if the CC startRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
7052    if((loadInfReq->rgrCcPHighStartRb >= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.startRb) &&
7053          (loadInfReq->rgrCcPHighStartRb <= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.endRb))
7054    {
7055       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid rgrCcPHighStartRb received specified");
7056       return RFAILED;
7057    }
7058
7059    /* Validate if the CC endRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
7060    if((loadInfReq->rgrCcPHighEndRb >= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.startRb) &&
7061          (loadInfReq->rgrCcPHighEndRb <= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.endRb))
7062    {
7063       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid rgrCcPHighEndRb received specified");
7064       return RFAILED;
7065    }
7066
7067    errInfo->errCause = RGSCHERR_NONE;
7068
7069
7070    return ROK;
7071 }  /* rgSCHCfgVldtRgrLoadInf */
7072 /* LTE_ADV_FLAG_REMOVED_END */
7073
7074 #ifdef TFU_UPGRADE
7075
7076 /********************************************************************
7077  *   UE ACQI, PCQI, RI, SRS and SR Re/Configuration  Validation Functions  *
7078  *                                                                   *
7079  *********************************************************************/
7080
7081  /*
7082  * @brief Validates the Tx Mode and PUSCH Mode configuration.
7083  *
7084  * @details
7085  *
7086  *     Function : rgSCHCfgVldtRgrTxmodePuschMode
7087  *
7088  *     Processing Steps:
7089  *      - Validate whether the configured PUSCH Mode and the
7090  *         Configured Tx Mode are in the right combination
7091  *      - If validated successfully,
7092  *        - Return ROK.
7093  *      - Else
7094  *        - Return RFAILED.
7095  *
7096  *  @param[in]  RgSchCellCb     *cellCb
7097  *  @param[in]  RgrTxMode     txMde
7098  *  @param[in]  RgrAprdCqiMode puschMode
7099  *  @param[out] RgSchErrInfo *errInfo
7100  *  @return  S16
7101  *      -# ROK
7102  *      -# RFAILED
7103  */
7104 #ifdef ANSI
7105 S16 rgSCHCfgVldtRgrTxmodePuschMode
7106 (
7107  RgSchCellCb     *cellCb,
7108  RgrTxMode       txMde,
7109  RgrAprdCqiMode  puschMode,
7110  RgSchErrInfo    *errInfo
7111  )
7112 #else
7113 S16 rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde, puschMode,errInfo)
7114    RgSchCellCb     *cellCb;
7115    RgrTxMode       txMde;
7116    RgrAprdCqiMode  puschMode;
7117    RgSchErrInfo    *errInfo;
7118 #endif
7119 {
7120
7121    if (txMde == RGR_UE_TM_1 ||  txMde == RGR_UE_TM_2 ||
7122          txMde == RGR_UE_TM_3 || txMde == RGR_UE_TM_7)
7123    {
7124       if (puschMode == RGR_APRD_CQI_MOD12 ||
7125             puschMode == RGR_APRD_CQI_MOD22  ||
7126             puschMode == RGR_APRD_CQI_MOD31)
7127       {
7128          return RFAILED;
7129       }
7130    }
7131
7132    if (txMde == RGR_UE_TM_4 ||  txMde == RGR_UE_TM_6)
7133    {
7134       if (puschMode == RGR_APRD_CQI_MOD20 ||
7135             puschMode == RGR_APRD_CQI_MOD30)
7136       {
7137          return RFAILED;
7138       }
7139    }
7140
7141    if (txMde == RGR_UE_TM_5 )
7142    {
7143       if (puschMode != RGR_APRD_CQI_MOD31)
7144       {
7145          return RFAILED;
7146       }
7147    }
7148 #ifdef LTE_ADV
7149    /* TOODO:: Tm8 and TM9 validation has to
7150     * be changed as mentioned inthe commented
7151     * code below*/
7152    /* TM8 and TM9 supports all modes
7153     * Mode 1-2, 2-2, 3-1 if pmi/ri reporting enabled
7154     * 2-0,3-0 of pmi/ri reporitng isdisabled *
7155     * if pmi/ri is enabled
7156     * Mode 1-2, 2-2, 3-1 if with pmi/ri and csi-rs ports > 1
7157     * 2-0,3-0 of pmi/ri reporitng isdisabled and csi-rs ports == 1*/
7158
7159 #endif
7160    return ROK;
7161 }/*rgSCHCfgVldtRgrTxmodePuschMode ends*/
7162
7163  /*
7164  * @brief Validates the UE ACQI configuration request from RRM to MAC.
7165  *
7166  * @details
7167  *
7168  *     Function : rgSCHCfgVldtRgrUeACqiCfg
7169  *
7170  *     Processing Steps:
7171  *      - Validate the UE configuration request from RRC to MAC at CFG:
7172  *        validate the ACQI Configuration
7173  *      - If validated successfully,
7174  *        - Return ROK.
7175  *      - Else
7176  *        - Return RFAILED.
7177  *
7178  *  @param[in] RgSchCellCb        *cellCb,
7179  *  @param[in] CmLteRnti          crnti,
7180  *  @param[in] RgrUeAprdDlCqiCfg   *acqiCfg,
7181  *  @param[in] RgrUeTxModeCfg     txMode,
7182  *  @param[out] RgSchErrInfo       *errInfo
7183
7184  *  @return  S16
7185  *      -# ROK
7186  *      -# RFAILED
7187  */
7188 #ifdef ANSI
7189 S16 rgSCHCfgVldtRgrUeACqiCfg
7190 (
7191  RgSchCellCb        *cellCb,
7192  CmLteRnti          crnti,
7193  RgrUeAprdDlCqiCfg  *acqiCfg,
7194  RgrUeTxModeCfg     txMode,
7195  RgSchErrInfo       *errInfo
7196  )
7197 #else
7198 S16 rgSCHCfgVldtRgrUeACqiCfg(cellCb, crnti, acqiCfg,txMode, errInfo)
7199    RgSchCellCb        *cellCb;
7200    CmLteRnti          crnti;
7201    RgrUeAprdDlCqiCfg  *acqiCfg;
7202    RgrUeTxModeCfg     txMode;
7203    RgSchErrInfo       *errInfo;
7204 #endif
7205 {
7206    RgrTxMode      txMde;
7207    RgrAprdCqiMode puschMode;
7208
7209    if(acqiCfg->pres)
7210    {
7211       if(txMode.pres == TRUE)
7212       {
7213          txMde = txMode.txModeEnum;
7214          puschMode = acqiCfg->aprdModeEnum;
7215          if ( ROK != rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde,
7216                   puschMode, errInfo))
7217          {
7218             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7219                      "Invalid Aperiodic CQI configuration CRNTI:%d",crnti);
7220             return RFAILED;
7221          }
7222       }
7223    }
7224    return ROK;
7225 }
7226
7227  /*
7228  * @brief Validates the Tx Mode and PUCCH Mode configuration.
7229  *
7230  * @details
7231  *
7232  *     Function : rgSCHCfgVldtRgrTxmodePucchMode
7233  *
7234  *     Processing Steps:
7235  *      - Validate whether the configured PUCCH Mode and the
7236  *         Configured Tx Mode are in the right combination
7237  *      - If validated successfully,
7238  *        - Return ROK.
7239  *      - Else
7240  *        - Return RFAILED.
7241  *
7242  *  @param[in]  RgSchCellCb     *cellCb
7243  *  @param[in]  RgrTxMode     txMde
7244  *  @param[in]  RgrPrdCqiMode     pucchMode
7245  *  @param[out] RgSchErrInfo *errInfo
7246  *  @return  S16
7247  *      -# ROK
7248  *      -# RFAILED
7249  */
7250 #ifdef ANSI
7251 S16 rgSCHCfgVldtRgrTxmodePucchMode
7252 (
7253    RgSchCellCb     *cellCb,
7254    RgrTxMode       txMde,
7255    RgrPrdCqiMode   pucchMode,
7256    RgSchErrInfo    *errInfo
7257  )
7258 #else
7259 S16 rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde, pucchMode,errInfo)
7260    RgSchCellCb     *cellCb;
7261    RgrTxMode       txMde;
7262    RgrPrdCqiMode   pucchMode;
7263    RgSchErrInfo    *errInfo;
7264 #endif
7265 {
7266
7267   if (pucchMode == RGR_PRD_CQI_MOD10 || pucchMode == RGR_PRD_CQI_MOD20 )
7268   {
7269    if (txMde ==RGR_UE_TM_4 || txMde ==RGR_UE_TM_5 || txMde ==RGR_UE_TM_6)
7270    {
7271       return RFAILED;
7272    }
7273   }
7274   else if (pucchMode == RGR_PRD_CQI_MOD11 || pucchMode == RGR_PRD_CQI_MOD21)
7275   {
7276      if (txMde ==RGR_UE_TM_1 || txMde ==RGR_UE_TM_2 || txMde ==RGR_UE_TM_3 \
7277              || txMde ==RGR_UE_TM_7)
7278    {
7279       return RFAILED;
7280    }
7281   }
7282   /* TODO:: Tm8 and TM9 validation needs to be added */
7283    return ROK;
7284 }
7285
7286 /*
7287  * @brief Validates the UE Periodic CQI, PMI, RI, re/configuration request from RRM to MAC.
7288  *
7289  * @details
7290  *
7291  *     Function : rgSCHCfgVldtRgrUePCqiCfg
7292  *
7293  *     Processing Steps:
7294  *      - Validate the UE configuration request from RRC to MAC at CFG:
7295  *        validate the value range for Periodic CQI, PMI, RI values.
7296  *      - If validated successfully,
7297  *        - Return ROK.
7298  *      - Else
7299  *        - Return RFAILED.
7300  *
7301  *  @param[in] RgSchCellCb        *cellCb,
7302  *  @param[in] CmLteRnti          crnti,
7303  *  @param[in] RgrUePrdDlCqiCfg   *cqiCfg,
7304  *  @param[in] RgrUeTxModeCfg     txMode,
7305  *  @param[out] RgSchErrInfo       *errInfo
7306  *  @return  S16
7307  *      -# ROK
7308  *      -# RFAILED
7309  */
7310 #ifdef LTEMAC_HDFDD
7311 #ifdef ANSI
7312 S16 rgSCHCfgVldtRgrUePCqiCfg
7313 (
7314  RgSchCellCb        *cellCb,
7315  CmLteRnti          crnti,
7316  RgrUePrdDlCqiCfg   *cqiCfg,
7317  Bool               hdFdd,
7318  RgrUeTxModeCfg     txMode,
7319  RgSchErrInfo       *errInfo
7320  )
7321 #else
7322 S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, hdFdd,
7323        txMode, errInfo)
7324    RgSchCellCb        *cellCb;
7325    CmLteRnti          crnti;
7326    RgrUePrdDlCqiCfg   *cqiCfg;
7327    Bool               hdFdd;
7328    RgrUeTxModeCfg     txMode;
7329    RgSchErrInfo       *errInfo;
7330 #endif
7331 #else
7332 #ifdef ANSI
7333 S16 rgSCHCfgVldtRgrUePCqiCfg
7334    (
7335     RgSchCellCb        *cellCb,
7336     CmLteRnti          crnti,
7337     RgrUePrdDlCqiCfg   *cqiCfg,
7338     RgrUeTxModeCfg     txMode,
7339     RgSchErrInfo       *errInfo
7340    )
7341 #else
7342 S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg,  txMode, errInfo)
7343    RgSchCellCb        *cellCb;
7344    CmLteRnti          crnti;
7345    RgrUePrdDlCqiCfg   *cqiCfg;
7346    RgrUeTxModeCfg     txMode;
7347    RgSchErrInfo       *errInfo;
7348 #endif
7349 #endif
7350 {
7351    RgrTxMode     txMde;
7352    RgrPrdCqiMode pucchMode;
7353
7354    txMde = RGR_UE_TM_1;
7355    pucchMode = RGR_PRD_CQI_MOD20;
7356    if ( RGR_SCH_PCQI_SETUP == cqiCfg->type )
7357    {
7358       /*1. Validate for Tx Mode and PUCCH Mode combination*/
7359       if(txMode.pres == TRUE)
7360       {
7361          txMde = txMode.txModeEnum;
7362          pucchMode = cqiCfg->cqiSetup.prdModeEnum;
7363          if ( ROK != rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde,
7364                   pucchMode, errInfo))
7365          {
7366             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7367                      "Invalid Tx Mode-PUCCH Mode combination CRNTI:%d",crnti);
7368             return RFAILED;
7369          }
7370       }
7371
7372       /*2. Validate for PCQI Reporting Type and PUCCH Mode combination*/
7373       if((cqiCfg->cqiSetup.cqiRepType==1) &&
7374               ((pucchMode == RGR_PRD_CQI_MOD20) ||
7375                (pucchMode == RGR_PRD_CQI_MOD21)))
7376       {
7377             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7378                      "Invalid Reporting Type-PUCCH Mode combination CRNTI:%d",crnti);
7379             return RFAILED;
7380       }
7381
7382       if((cqiCfg->cqiSetup.cqiRepType==2) &&
7383               ((pucchMode == RGR_PRD_CQI_MOD10) ||
7384                (pucchMode == RGR_PRD_CQI_MOD11)))
7385       {
7386             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7387                      "Invalid Reporting Type-PUCCH Mode combination CRNTI:%d",crnti);
7388             return RFAILED;
7389       }
7390
7391       /*3. Validate CQI/PMI and RI Configuration related parameter values */
7392       /*TODO- To be compared with configured n2Pucch Index*/
7393       if (cqiCfg->cqiSetup.cqiPResIdx > RG_SCH_PUCCH_RES_MAX_SUPP )
7394       {
7395          RLOG_ARG3(L_ERROR,DBG_CELLID,cellCb->cellId,
7396                   "Not Supported or Invalid CQI-PUCCH resourceIndex=%d Cfg Val=%d CRNTI:%d",
7397                   RG_SCH_PUCCH_RES_MAX_SUPP, cqiCfg->type,crnti);
7398          return RFAILED;
7399       }
7400
7401 #ifdef LTEMAC_HDFDD
7402       if(hdFdd)
7403       {
7404          if((cqiCfg->cqiSetup.cqiPCfgIdx > RG_SCH_ICQI_MAX_SUPP)||
7405                (cqiCfg->cqiSetup.cqiPCfgIdx < 7) ||
7406                (cqiCfg->cqiSetup.cqiPCfgIdx == 317))
7407          {
7408             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7409                      "Not Supported or Invalid Cfg CQI Min Index Sup =%d"
7410                      "Max Index Sup=%d  Cfg Val=%d CRNTI:%d", RG_SCH_ICQI_MIN_SUPP,
7411                      RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
7412             return RFAILED;
7413          }
7414       }
7415       else
7416       {
7417          if((cqiCfg->cqiSetup.cqiPCfgIdx > RG_SCH_ICQI_MAX_SUPP)||
7418                (cqiCfg->cqiSetup.cqiPCfgIdx == 317))
7419          {
7420             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7421                      "Not Supported or Invalid Cfg CQI Min Index Sup =%d "
7422                      "Max Index Sup=%d  Cfg Val=%d CRNTI:%d", RG_SCH_ICQI_MIN_SUPP,
7423                      RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
7424             return RFAILED;
7425          }
7426       }
7427 #else
7428       if((cqiCfg->cqiSetup.cqiPCfgIdx > RG_SCH_ICQI_MAX_SUPP)||
7429             (cqiCfg->cqiSetup.cqiPCfgIdx == 317))
7430       {
7431          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7432                   "Not Supported or Invalid Cfg CQI Min Index Sup =%d"
7433                   "Max Index Sup=%d  Cfg Val=%d CRNTI;%d", RG_SCH_ICQI_MIN_SUPP,
7434                   RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
7435          return RFAILED;
7436       }
7437 #endif
7438
7439       if((cqiCfg->cqiSetup.cqiRepType < RGR_UE_PCQI_WB_REP) ||
7440             (cqiCfg->cqiSetup.cqiRepType > RGR_UE_PCQI_SB_REP))
7441       {
7442          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7443                   "Invalid Cfg CQI Report"
7444                   "ModeCfg Val=%d CRNTI:%d", cqiCfg->type,crnti);
7445          return RFAILED;
7446       }
7447
7448       if((cqiCfg->cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP) &&
7449             ((cqiCfg->cqiSetup.k < RG_SCH_CQI_K_MIN) ||
7450             (cqiCfg->cqiSetup.k > RG_SCH_CQI_K_MAX)))
7451       {
7452          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7453                   "Invalid CQI Cfg K Cfg Val=%d CRNTI:%d", cqiCfg->type,crnti);
7454          return RFAILED;
7455       }
7456
7457       if((cqiCfg->cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP) &&
7458             (cellCb->bwCfg.dlTotalBw <= 7))
7459       {
7460          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7461                   "Invalid Periodic CQI mode Cfg for dlTotalBw (%d) for CRNTI:%d",
7462                   cellCb->bwCfg.dlTotalBw, crnti);
7463          return RFAILED;
7464       }
7465
7466 #ifndef LTE_TDD
7467       if (cqiCfg->cqiSetup.cqiPCfgIdx == RG_SCH_ICQI_RESV_FDD )
7468       {
7469          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7470                   "Reserved value Cfg =%d CRNTI:%d",
7471                   cqiCfg->cqiSetup.cqiPResIdx,crnti);
7472          return RFAILED;
7473       }
7474 #endif
7475
7476       /* 4. Check RI Configuration values */
7477        if(cqiCfg->cqiSetup.riEna == TRUE)
7478       {
7479          if(txMode.pres == TRUE)
7480          {
7481             if((txMde != RGR_UE_TM_3)
7482             && (txMde != RGR_UE_TM_4)
7483             && (txMde != RGR_UE_TM_8)
7484 #ifdef LTE_ADV
7485             && (txMde != RGR_UE_TM_9)
7486 #endif
7487              )
7488             {
7489                RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7490                   "Invalid Transmission Mode =%d CRNTI:%d",
7491                   txMde,crnti);
7492                return RFAILED;
7493             }
7494          }
7495
7496          if(cqiCfg->cqiSetup.riCfgIdx > RG_SCH_IRI_MAX_SUPP)
7497          {
7498           RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7499                   "Invalid Index RI value Cfg =%d CRNTI:%d",
7500                   cqiCfg->cqiSetup.riCfgIdx,crnti);
7501           return RFAILED;
7502          }
7503       }
7504    }
7505
7506
7507    return ROK;
7508 }
7509
7510 /*
7511  * @brief Validates the UE SRS Re/Configuation request from RRM to MAC.
7512  *
7513  * @details
7514  *
7515  *     Function : rgSCHCfgVldtRgrUeUlSrsCfg
7516  *
7517  *     Processing Steps:
7518  *      - Validate the UE configuration request from RRC to MAC at CFG:
7519  *        validate the value range for SRS values.
7520  *      - If validated successfully,
7521  *        - Return ROK.
7522  *      - Else
7523  *        - Return RFAILED.
7524  *
7525  *  @param[in] RgSchCellCb       *cellCb,
7526  *  @param[in] CmLteRnti         crnti,
7527  *  @param[in] RgrUeUlSrsCfg     *srsCfg,
7528  *  @param[out] RgSchErrInfo     *errInfo
7529  *  @return  S16
7530  *      -# ROK
7531  *      -# RFAILED
7532  */
7533 #ifdef LTEMAC_HDFDD
7534 #ifdef ANSI
7535 S16 rgSCHCfgVldtRgrUeUlSrsCfg
7536 (
7537  RgSchCellCb       *cellCb,
7538  CmLteRnti         crnti,
7539  RgrUeUlSrsCfg     *srsCfg,
7540  Bool              hdFdd,
7541  RgSchErrInfo      *errInfo
7542  )
7543 #else
7544 S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, hdFdd, errInfo)
7545    RgSchCellCb     *cellCb;
7546    CmLteRnti       crnti;
7547    RgrUeUlSrsCfg   *srsCfg;
7548    Bool            hdFdd;
7549    RgSchErrInfo    *errInfo;
7550 #endif
7551 #else
7552 #ifdef ANSI
7553 S16 rgSCHCfgVldtRgrUeUlSrsCfg
7554 (
7555  RgSchCellCb       *cellCb,
7556  CmLteRnti         crnti,
7557  RgrUeUlSrsCfg     *srsCfg,
7558  RgSchErrInfo      *errInfo
7559  )
7560 #else
7561 S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg,  errInfo)
7562    RgSchCellCb     *cellCb;
7563    CmLteRnti       crnti;
7564    RgrUeUlSrsCfg   *srsCfg;
7565    RgSchErrInfo    *errInfo;
7566 #endif
7567 #endif
7568 {
7569    uint16_t    srsPeri=0;
7570    uint16_t    srsOffset=0;
7571    uint8_t     srsSubframe=0;
7572
7573    if ( RGR_SCH_SRS_SETUP == srsCfg->type )
7574    {
7575
7576       /*ccpu00130768 - ADD - if cell specific SRS is not configured*/
7577       if(cellCb->srsCfg.isSrsCfgPres == FALSE)
7578       {
7579          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7580               "Cell specific SRS is not configured CRNTI:%d",crnti);
7581          return RFAILED;
7582       }
7583
7584       /*  1. Validate SRS Configuration related parameter values  */
7585       /* 1.1 iSRS should be 0-636; Ref: 36.213. Table 8.2-1 */
7586 #ifdef LTEMAC_HDFDD
7587       if(hdFdd)
7588       {
7589          if ( (srsCfg->srsSetup.srsCfgIdx < 7) ||
7590                (srsCfg->srsSetup.srsCfgIdx > RG_SCH_ISRS_MAX_SUPP) )
7591          {
7592             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7593                      "Not Supported or Invalid Cfg "
7594                      "SRS Min Index Sup =%d   Max Index Sup=%d  Cfg Val=%d CRNTI:%d",
7595                      RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
7596                      srsCfg->srsSetup.srsCfgIdx,crnti);
7597             return RFAILED;
7598          }
7599       }
7600       else
7601       {
7602          if ( srsCfg->srsSetup.srsCfgIdx > RG_SCH_ISRS_MAX_SUPP )
7603          {
7604             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7605                      "Not Supported or Invalid Cfg"
7606                      "SRS Min Index Sup =%d   Max Index Sup=%d  Cfg Val=%d CRNTI:%d",
7607                      RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
7608                      srsCfg->srsSetup.srsCfgIdx,crnti);
7609             return RFAILED;
7610          }
7611
7612       }
7613 #else
7614       if ( srsCfg->srsSetup.srsCfgIdx > RG_SCH_ISRS_MAX_SUPP )
7615       {
7616          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7617                   "Not Supported or Invalid Cfg"
7618                   "SRS Min Index Sup =%d   Max Index Sup=%d  Cfg Val=%d CRNTI:%d",
7619                   RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
7620                   srsCfg->srsSetup.srsCfgIdx,crnti);
7621          return RFAILED;
7622       }
7623 #endif
7624 #ifdef LTE_TDD
7625       /* Compute SRS Offset and Periodicity */
7626       rgSCHUtlGetCfgPerOff( RG_SCH_TDD_SRS_TBL,
7627             srsCfg->srsSetup.srsCfgIdx,
7628             &srsPeri, &srsOffset);
7629 #else
7630       rgSCHUtlGetCfgPerOff( RG_SCH_FDD_SRS_TBL,
7631             srsCfg->srsSetup.srsCfgIdx,
7632             &srsPeri, &srsOffset);
7633 #endif
7634        srsSubframe = srsOffset%RGSCH_NUM_SUB_FRAMES;
7635 #ifdef LTE_TDD
7636       if(rgSchTddCellSpSrsSubfrmTbl[cellCb->srsCfg.srsSubFrameCfg][srsSubframe] == FALSE)   {
7637 #else
7638       if(rgSchFddCellSpSrsSubfrmTbl[cellCb->srsCfg.srsSubFrameCfg][srsSubframe] == FALSE)   {
7639 #endif
7640          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7641                "UE specific SRS is not occuring in Cell specific SRS subframe"
7642                "srs Cfg Idx =%d CRNTI:%d",
7643                srsCfg->srsSetup.srsCfgIdx,crnti);
7644          return RFAILED;
7645       }
7646
7647
7648       if ( srsCfg->srsSetup.fDomPosi > RG_SCH_SRS_FREQDOM_POS_MAX )
7649       {
7650          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7651                   "Not Supported or Invalid Cfg"
7652                   "SRS Min Freq Domain Position =%d"
7653                   "Max Freq Domain Position =%d  Cfg Val=%d CRNTI:%d",
7654                   RG_SCH_SRS_FREQDOM_POS_MIN, RG_SCH_SRS_FREQDOM_POS_MAX,
7655                   srsCfg->srsSetup.srsCfgIdx,crnti);
7656          return RFAILED;
7657       }
7658
7659       if ( srsCfg->srsSetup.txComb > RG_SCH_SRS_TXCOMB_MAX )
7660       {
7661          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7662                   "Not Supported or Invalid Cfg"
7663                   "SRS Min TX Comb =%d   Max TX Comb =%d  Cfg Val=%d CRNTI:%d",
7664                   RG_SCH_SRS_TXCOMB_MIN, RG_SCH_SRS_TXCOMB_MAX,
7665                   srsCfg->srsSetup.srsCfgIdx,crnti);
7666          return RFAILED;
7667       }
7668    }
7669    return ROK;
7670 }
7671
7672 /*
7673  * @brief Validates the UE SR Re/configuration request from RRM to MAC.
7674  *
7675  * @details
7676  *
7677  *     Function : rgSCHCfgVldtRgrUeSrCfg
7678  *
7679  *     Processing Steps:
7680  *      - Validate the UE re/configuration request from RRC to MAC at CFG:
7681  *        validate the value range for SR values.
7682  *      - If validated successfully,
7683  *        - Return ROK.
7684  *      - Else
7685  *        - Return RFAILED.
7686  *
7687  *  @param[in] RgSchCellCb      *cellCb,
7688  *  @param[in] CmLteRnti        crnti,
7689  *  @param[in] RgrUeSrCfg       *srCfg,
7690  *  @param[out] RgSchErrInfo    *errInfo
7691  *  @return  S16
7692  *      -# ROK
7693  *      -# RFAILED
7694  */
7695 #ifdef LTEMAC_HDFDD
7696 #ifdef ANSI
7697 S16 rgSCHCfgVldtRgrUeSrCfg
7698 (
7699  RgSchCellCb      *cellCb,
7700  CmLteRnti        crnti,
7701  RgrUeSrCfg       *srCfg,
7702  Bool             hdFdd,
7703  RgSchErrInfo     *errInfo
7704  )
7705 #else
7706 S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, hdFdd, errInfo)
7707    RgSchCellCb    *cellCb;
7708    CmLteRnti      crnti;
7709    RgrUeSrCfg     *srCfg;
7710    Bool           hdFdd;
7711    RgSchErrInfo   *errInfo;
7712 #endif
7713 #else
7714 #ifdef ANSI
7715 S16 rgSCHCfgVldtRgrUeSrCfg
7716 (
7717  RgSchCellCb      *cellCb,
7718  CmLteRnti        crnti,
7719  RgrUeSrCfg       *srCfg,
7720  RgSchErrInfo     *errInfo
7721  )
7722 #else
7723 S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, errInfo)
7724    RgSchCellCb    *cellCb;
7725    CmLteRnti      crnti;
7726    RgrUeSrCfg     *srCfg;
7727    RgSchErrInfo   *errInfo;
7728 #endif
7729 #endif
7730 {
7731
7732    if ( RGR_SCH_SR_SETUP == srCfg->type )
7733    {
7734       /* 1. Validate SR Configuration related parameter values  */
7735 #ifdef LTEMAC_HDFDD
7736       if(hdFdd)
7737       {
7738          if (( srCfg->srSetup.srResIdx > RG_SCH_SR_RES_IDX   ) ||
7739                ( srCfg->srSetup.srCfgIdx < 5 ) ||
7740                ( srCfg->srSetup.srCfgIdx > RG_SCH_ISR_MAX_SUPP ))
7741          {
7742             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7743                      "Invalid SR Index Cfg =%d"
7744                       "Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
7745                      RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
7746
7747             return RFAILED;
7748          }
7749       }
7750       else
7751       {
7752          if (( srCfg->srSetup.srResIdx > RG_SCH_SR_RES_IDX   ) ||
7753                ( srCfg->srSetup.srCfgIdx > RG_SCH_ISR_MAX_SUPP ))
7754          {
7755             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7756                      "Invalid SR Index Cfg =%d"
7757                       "Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
7758                      RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
7759
7760             return RFAILED;
7761          }
7762       }
7763 #else
7764       if (( srCfg->srSetup.srResIdx > RG_SCH_SR_RES_IDX   ) ||
7765             ( srCfg->srSetup.srCfgIdx > RG_SCH_ISR_MAX_SUPP ))
7766       {
7767          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7768                   "Invalid SR Index Cfg =%d"
7769                   "Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
7770                   RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
7771
7772          return RFAILED;
7773       }
7774 #endif
7775    }
7776    return ROK;
7777 }
7778
7779
7780 /*
7781  * @brief Validates the UE Aperiodic & Periodic  CQI, PMI, RI, SRS and SR Configuration
7782  *             request from RRM to MAC.
7783  *
7784  * @details
7785  *
7786  *     Function :rgSCHCfgVldtCqiSrSrsUeCfg
7787  *
7788  *     Processing Steps:
7789  *      - Validate the UE configuration request from RRC to MAC at CFG:
7790  *        validate the value range for Aperiodic & Periodic CQI, PMI, RI , SRS and SR values.
7791  *      - If validated successfully,
7792  *        - Return ROK.
7793  *      - Else
7794  *        - Return RFAILED.
7795  *
7796  *  @param[in]  RgSchCellCb  *cellCb
7797  *  @param[in]  RgrUeCfg     *ueCfg
7798  *  @param[out] RgSchErrInfo *errInfo
7799  *  @return  S16
7800  *      -# ROK
7801  *      -# RFAILED
7802  */
7803 #ifdef ANSI
7804 static S16 rgSCHCfgVldtCqiSrSrsUeCfg
7805 (
7806  RgSchCellCb       *cellCb,
7807  RgrUeCfg          *ueCfg,
7808  RgSchErrInfo      *errInfo
7809  )
7810 #else
7811 static S16  rgSCHCfgVldtCqiSrSrsUeCfg(cellCb, ueCfg,  errInfo)
7812    RgSchCellCb     *cellCb;
7813    RgrUeCfg        *ueCfg;
7814    RgSchErrInfo    *errInfo;
7815 #endif
7816 {
7817
7818    /*  1. Validate UE Aperiodic CQI related parameters */
7819    if ( ROK != rgSCHCfgVldtRgrUeACqiCfg (cellCb, ueCfg->crnti,
7820             &ueCfg->ueDlCqiCfg.aprdCqiCfg, ueCfg->txMode, errInfo ))
7821    {
7822       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7823        "Invalid Aperiodic CQI configuration CRNTI:%d",ueCfg->crnti);
7824       return RFAILED;
7825    }
7826
7827    /*  1. Validate UE Periodic CQI/PMI, SRS and SR related parameters */
7828 #ifdef LTEMAC_HDFDD
7829    if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueCfg->crnti,
7830             &ueCfg->ueDlCqiCfg.prdCqiCfg, ueCfg->isHdFddEnbld,
7831             ueCfg->txMode, errInfo ))
7832 #else
7833       if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueCfg->crnti,
7834              &ueCfg->ueDlCqiCfg.prdCqiCfg, ueCfg->txMode, errInfo ))
7835 #endif
7836       {
7837          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7838           "Invalid Periodic CQI configuration CRNTI:%d",ueCfg->crnti);
7839          return RFAILED;
7840       }
7841
7842    /*  2. Validate SRS Configuration related parameter values  */
7843 #ifdef LTEMAC_HDFDD
7844    if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueCfg->crnti, &ueCfg->srsCfg,
7845             ueCfg->isHdFddEnbld, errInfo ))
7846 #else
7847       if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueCfg->crnti,
7848                   &ueCfg->srsCfg, errInfo ))
7849 #endif
7850       {
7851          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7852            "Invalid SRS  configuration CRNTI:%d",ueCfg->crnti);
7853          return RFAILED;
7854       }
7855
7856    /*  3. Validate SR Configuration related parameter values  */
7857 #ifdef LTEMAC_HDFDD
7858    if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueCfg->crnti, &ueCfg->srCfg,
7859             ueCfg->isHdFddEnbld, errInfo))
7860 #else
7861       if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueCfg->crnti,
7862                   &ueCfg->srCfg, errInfo))
7863 #endif
7864       {
7865          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7866             "Invalid SR  configuration CRNTI:%d",ueCfg->crnti);
7867          return RFAILED;
7868       }
7869
7870    return ROK;
7871
7872 }
7873
7874
7875
7876 /*****************************************************************
7877  *   UE PCQI, RI, SRS and SR Re Configuration  Validation Functions  *
7878  *                                                                *
7879  ******************************************************************/
7880 /*
7881  * @brief Validates the UE Periodic CQI, PMI, RI, SRS and SR
7882  * Re-configuration request from RRM to MAC.
7883  *
7884  * @details
7885  *
7886  *     Function : rgSCHCfgVldtCqiSrSrsUeReCfg
7887  *
7888  *     Processing Steps:
7889  *      - Validate the UE Re configuration request from RRC to MAC at CFG:
7890  *        validate the value range for Periodic CQI, PMI, RI, SRS and SR values.
7891  *      - If validated successfully,
7892  *        - Return ROK.
7893  *      - Else
7894  *        - Return RFAILED.
7895  *
7896  *  @param[in]   RgSchCellCb *cellCb
7897  *  @param[in]   RgSchUeCb   *ueCb
7898  *  @param[in]  RgrUeCfg     *ueCfg
7899  *  @param[out] RgSchErrInfo *errInfo
7900  *  @return  S16
7901  *      -# ROK
7902  *      -# RFAILED
7903  */
7904 #ifdef ANSI
7905 static S16 rgSCHCfgVldtCqiSrSrsUeReCfg
7906 (
7907  RgSchCellCb          *cellCb,
7908  RgSchUeCb            *ueCb,
7909  RgrUeRecfg           *ueReCfg,
7910  RgSchErrInfo         *errInfo
7911  )
7912 #else
7913 static S16 rgSCHCfgVldtCqiSrSrsUeReCfg(cellCb, ueCb, ueReCfg, errInfo)
7914    RgSchCellCb          *cellCb;
7915    RgSchUeCb            *ueCb;
7916    RgrUeRecfg           *ueReCfg;
7917    RgSchErrInfo         *errInfo;
7918 #endif
7919 {
7920    RgrUeTxModeCfg     txMode;
7921
7922    txMode.pres = TRUE;
7923    txMode.tmTrnstnState = RGR_TXMODE_RECFG_CMPLT;
7924    if ((ueReCfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG) &&
7925        (ueReCfg->txMode.pres == TRUE))
7926    {
7927       txMode.txModeEnum = ueReCfg->txMode.txModeEnum;
7928    }
7929    else
7930    {
7931       txMode.txModeEnum = ueCb->mimoInfo.txMode;
7932    }
7933
7934    /*    1. Validate UE CQI/PMI, SRS and SR related parameters */
7935
7936    if ( ueReCfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG )
7937    {
7938       if ( ROK != rgSCHCfgVldtRgrUeACqiCfg (cellCb, ueReCfg->oldCrnti,
7939                &ueReCfg->aprdDlCqiRecfg, txMode, errInfo ))
7940       {
7941          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7942          "Invalid Aperiodic CQI configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
7943          return RFAILED;
7944       }
7945    }
7946
7947
7948    /*    2. Validate UE CQI/PMI, SRS and SR related parameters */
7949
7950    if ( ueReCfg->ueRecfgTypes & RGR_UE_PCQI_RECFG )
7951    {
7952 #ifdef LTEMAC_HDFDD
7953       if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueReCfg->oldCrnti,
7954                &ueReCfg->cqiCfg, ueReCfg->isHdFddEnbld, txMode, errInfo ))
7955 #else
7956          if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueReCfg->oldCrnti,
7957                   &ueReCfg->cqiCfg, txMode, errInfo ))
7958 #endif
7959
7960          {
7961             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7962             "Invalid Periodic CQI configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
7963             return RFAILED;
7964          }
7965    }
7966
7967    if(ueReCfg->ueRecfgTypes & RGR_UE_SRS_RECFG )
7968    {
7969 #ifdef LTEMAC_HDFDD
7970       if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueReCfg->oldCrnti,
7971                &ueReCfg->srsCfg, ueReCfg->isHdFddEnbld, errInfo ))
7972 #else
7973          if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueReCfg->oldCrnti,
7974                   &ueReCfg->srsCfg, errInfo ))
7975 #endif
7976          {
7977             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7978               "Invalid SRS  configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
7979             return RFAILED;
7980          }
7981
7982    }
7983
7984    if ( ueReCfg->ueRecfgTypes & RGR_UE_SR_RECFG )
7985    {
7986 #ifdef LTEMAC_HDFDD
7987       if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueReCfg->oldCrnti,
7988             &ueReCfg->srCfg, ueReCfg->isHdFddEnbld, errInfo))
7989 #else
7990          if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueReCfg->oldCrnti,
7991             &ueReCfg->srCfg, errInfo))
7992 #endif
7993          {
7994             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7995                      "Invalid SR configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
7996             return RFAILED;
7997          }
7998    }
7999
8000    return ROK;
8001 }
8002
8003
8004 /*****************************************************************
8005  *   UE ACQI, PCQI, RI, SRS SR Configuration Functions      *
8006  *                                                                *
8007  ******************************************************************/
8008    /**
8009     * @brief Handles Aperiodic CQI , PMI, RI  configuration for a UE.
8010     *
8011     * @details
8012     *
8013     *     Function : rgSCHCfgACqiUeCfg
8014     *
8015     *     Invoking Module Processing:
8016     *      - This shall be invoked by SCH_GOM at UE configuration. It
8017     *      shall do the validations for the spec-defined values.
8018     *
8019     *     Processing Steps:
8020     *
8021     *     - Return ROK
8022     *
8023     *  @param[in]  RgSchCellCb  *cell
8024     *  @param[in]  RgrTxMode    txMode
8025     *  @param[in]  RgrUeAprdDlCqiCfg *aCqiCfg
8026     *  @param[in]  CmLteUeCategory        ueCat
8027     *  @return  S16
8028     *      -# ROK
8029     *
8030     **/
8031 #ifdef ANSI
8032 S16 rgSCHCfgACqiUeCfg
8033 (
8034 RgSchCellCb        *cellCb,
8035 RgSchUeCb          *ue,
8036 RgSchUeACqiCb      *acqiCb,
8037 RgrTxMode           ueTxMode,
8038 RgrUeAprdDlCqiCfg  *aCqiCfg,
8039 CmLteUeCategory     ueCat
8040 )
8041 #else
8042 S16 rgSCHCfgACqiUeCfg(cellCb,ue,acqiCb ueTxMode, aCqiCfg, ueCat)
8043 RgSchCellCb       *cellCb;
8044 RgSchUeCb          *ue;
8045 RgSchUeACqiCb     *acqiCb;
8046 RgrTxMode          ueTxMode;
8047 RgrUeAprdDlCqiCfg *aCqiCfg;
8048 CmLteUeCategory   ueCat;
8049 #endif
8050 {
8051    uint8_t     M;  /*Num of Subbands -- Applicable only for Mode 2-0 and 2-2*/
8052    uint8_t     k;  /*SubBand Size (RB)  --
8053               Holds different values depending on Mode*/
8054    uint8_t     cqiPmiSzR1;   /*CQIPMI Size for Rank =1*/
8055    uint8_t     cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
8056
8057    cqiPmiSzR1 = 0;
8058    cqiPmiSzRn1 = 0;
8059
8060    acqiCb->aCqiCfg.pres = aCqiCfg->pres;
8061    acqiCb->aCqiCfg.aprdModeEnum = aCqiCfg->aprdModeEnum;
8062
8063    if(aCqiCfg->pres)
8064    {
8065 #ifdef LTE_ADV
8066       /*Store Trigger Set Bit String to UE */
8067       RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
8068       pCellInfo->acqiCb.aCqiCfg.triggerSet1 = aCqiCfg->triggerSet1;
8069       pCellInfo->acqiCb.aCqiCfg.triggerSet2 = aCqiCfg->triggerSet2;
8070 #endif
8071
8072
8073       switch(aCqiCfg->aprdModeEnum)
8074       {
8075          case RGR_APRD_CQI_MOD12:
8076          case RGR_APRD_CQI_MOD30:
8077          case RGR_APRD_CQI_MOD31:
8078             RG_SCH_GET_CQI_K_VAL(cellCb->bwCfg.dlTotalBw, k);
8079             acqiCb->N = RGSCH_CEIL(cellCb->bwCfg.dlTotalBw, k);
8080             acqiCb->k = k;
8081             break;
8082
8083          case RGR_APRD_CQI_MOD20:
8084          case RGR_APRD_CQI_MOD22:
8085             RG_SCH_GET_SBCQI_M_K_VAL(cellCb->bwCfg.dlTotalBw, M, k);
8086             acqiCb->N = RGSCH_CEIL(cellCb->bwCfg.dlTotalBw, k);
8087             acqiCb->k = k;
8088             acqiCb->M = M;
8089             acqiCb->L = RgSCHUeAcqi2022LBitWidth[M-1][acqiCb->N-1];
8090             break;
8091
8092          default:
8093             break;
8094       }
8095       if((ueTxMode == RGR_UE_TM_3) ||
8096          (ueTxMode == RGR_UE_TM_4))
8097       {
8098          if(cellCb->numTxAntPorts ==2)
8099          {
8100             acqiCb->riNumBits = 1;
8101          }
8102          else if(cellCb->numTxAntPorts ==4)
8103          {
8104             if(ueCat == CM_LTE_UE_CAT_8)
8105             {
8106                acqiCb->riNumBits = 3;
8107             }
8108             else if(ueCat >= CM_LTE_UE_CAT_5)
8109             {
8110                acqiCb->riNumBits = 2;
8111             }
8112             else
8113             {
8114                acqiCb->riNumBits = 1;
8115             }
8116          }
8117       }
8118       rgSCHCfgUtlFetchAcqiBitSz(acqiCb, cellCb->numTxAntPorts,
8119             &cqiPmiSzR1, &cqiPmiSzRn1);
8120       acqiCb->cqiPmiSzR1  = cqiPmiSzR1;
8121       acqiCb->cqiPmiSzRn1 = cqiPmiSzRn1;
8122    }
8123    acqiCb->cqiReqField = TRUE;
8124 #ifdef LTE_ADV
8125    rgSchCmnSetCqiReqField(RG_SCH_CMN_GET_SCELL_INFO(ue, cellCb),ue,&acqiCb->cqiReqField);
8126 #endif
8127
8128    return ROK;
8129 }
8130
8131 /**
8132  * @brief Handles Periodic CQI , PMI, RI  configuration for a UE.
8133  *
8134  * @details
8135  *
8136  *     Function : rgSCHCfgPCqiUeCfg
8137  *
8138  *     Invoking Module Processing:
8139  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8140  *      validations for the spec-defined values.
8141  *
8142  *     Processing Steps:
8143  *     - For UE-specific Periodic CQI  related configuration,
8144  *      - If Periodic CQI/PMI is configured,
8145  *        - Update UE with the configured values.
8146  - Compute and Update next occurance of CQI/PMI or RI Tranmission instance.
8147  - Update the CQI offset and CQI perodicity information
8148  - Add Ue to cell's list
8149  *
8150  *
8151  *     - For UE-specific Periodic RI  related configuration,
8152  *      - If Periodic RI is configured,
8153  *        - Update UE with the configured values.
8154  - Compute and Update next occurance of RI Tranmission instance.
8155  - Update the  RI offset and RI perodicity information
8156  *
8157  *
8158  *     - Return ROK
8159  *
8160  *  @param[in]  RgSchCellCb  *cell
8161  *  @param[in]  RgSchUeCb    *ue
8162  *  @param[in]  RgrUePrdDlCqiCfg *cqiCfg
8163  *  @param[in]  CmLteUeCategory   ueCat
8164  *  @return  S16
8165  *      -# ROK
8166  *
8167  **/
8168 #ifdef ANSI
8169 S16 rgSCHCfgPCqiUeCfg
8170 (
8171  RgSchCellCb         *cellCb,
8172  RgSchUeCb           *ueCb,
8173  RgrUePrdDlCqiCfg    *cqiCfg,
8174  CmLteUeCategory     ueCat
8175  )
8176 #else
8177 S16 rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
8178    RgSchCellCb       *cellCb;
8179    RgSchUeCb         *ueCb;
8180    RgrUePrdDlCqiCfg  *cqiCfg;
8181    CmLteUeCategory   ueCat;
8182 #endif
8183 {
8184    CmLteTimingInfo timingInfo;
8185    uint16_t    crntTime;
8186    uint16_t    cqiTrInstTime;
8187    uint8_t     j;  /*Bandwidth Parts*/
8188    uint8_t     temp;
8189    uint8_t     loop;
8190    RgSchUePCqiCb *cqiCb = NULLP;
8191
8192    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)+
8193                   (cellCb->crntTime.slot);
8194    cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
8195    cqiCb->servCellInfo = ueCb->cellInfo[0];
8196    /* Periodic CQI is setup  */
8197    if (cqiCfg->type == RGR_SCH_PCQI_SETUP)
8198    {
8199       for(loop = 0; loop < MAX_CQI_RI_RPT_BUFF;loop++)
8200       {
8201          ueCb->rawCqiBitW[loop].type = TFU_RECP_REQ_INVLD; /* setting invalid  type*/
8202       }
8203       /*  1. Copy the Received CQI Cfg parameters to ueCb  */
8204       memcpy(&cqiCb->cqiCfg, cqiCfg,
8205             sizeof(RgrUePrdDlCqiCfg));
8206
8207       /*  2. Compute Periodic CQI Periodicity and subframe offset   */
8208 #ifndef LTE_TDD
8209       rgSCHUtlGetCfgPerOff(RG_SCH_FDD_PCQI_TBL, cqiCfg->cqiSetup.cqiPCfgIdx,
8210             &cqiCb->cqiPeri, &cqiCb->cqiOffset);
8211 #else
8212       rgSCHUtlGetCfgPerOff( RG_SCH_TDD_PCQI_TBL,
8213             cqiCfg->cqiSetup.cqiPCfgIdx,
8214             &cqiCb->cqiPeri, &cqiCb->cqiOffset);
8215 #endif
8216       RLOG_ARG3(L_DEBUG,DBG_CELLID,cellCb->cellId,
8217             "rgSCHCfgPCqiUeCfg(): UEID:%d CQI Peri=%d, CQI Offset=%d",
8218             ueCb->ueId,
8219             cqiCb->cqiPeri,
8220             cqiCb->cqiOffset);
8221
8222
8223       cqiTrInstTime = ((cqiCb->cqiPeri+crntTime) - cqiCb->cqiOffset)
8224          %cqiCb->cqiPeri;
8225       cqiCb->nCqiTrIdx = (crntTime +
8226             (cqiCb->cqiPeri - cqiTrInstTime));
8227       /* Introduced timing delta for reception req
8228        * in FDD*/
8229       if(cqiCb->nCqiTrIdx  <= (crntTime + TFU_RECPREQ_DLDELTA))
8230       {
8231          cqiCb->nCqiTrIdx = cqiCb->nCqiTrIdx + cqiCb->cqiPeri;
8232       }
8233
8234       /* To handle the SFN wrap around case */
8235       cqiCb->nCqiTrIdx = cqiCb->nCqiTrIdx % (RGSCH_MAX_SFN * RGSCH_NUM_SUB_FRAMES_5G);
8236
8237       timingInfo.sfn =  cqiCb->nCqiTrIdx/RGSCH_NUM_SUB_FRAMES_5G;
8238       timingInfo.slot =  cqiCb->nCqiTrIdx % RGSCH_NUM_SUB_FRAMES_5G;
8239
8240       cqiCb->nCqiTrIdx = cqiCb->nCqiTrIdx
8241            %RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
8242
8243 #ifdef EMTC_ENABLE
8244           /*CQI Repetition configuration*/
8245       if(ueCb->isEmtcUe)
8246       {
8247           rgSchfillPucchCqiRepNumCountemtc(cqiCb, ueCb);
8248       }
8249 #endif
8250
8251       if(RGR_UE_PCQI_SB_REP == cqiCfg->cqiSetup.cqiRepType)
8252       {
8253          uint8_t     k;  /*SubBand Size (RB) */
8254          RG_SCH_GET_CQI_J_VAL(cellCb->bwCfg.dlTotalBw, j);
8255          RG_SCH_GET_CQI_K_VAL(cellCb->bwCfg.dlTotalBw, k);
8256          cqiCb->J = j; /*Number of Bandwidth Parts*/
8257          /*h: reporting instances required for a complete CQI/PMI report */
8258          /*j:Number of bandwidth parts; k: Subband Size*/
8259          cqiCb->h = (cqiCb->cqiCfg.cqiSetup.k *j )+1;
8260          /* ccpu00140905- L-size is coming as 3 for 100Rbs where it should be 2*/
8261          temp = RGSCH_CEIL(cellCb->bwCfg.dlTotalBw, (j*k));
8262          cqiCb->label = (temp & (temp-1)) ?
8263             (1+ rgSCHUtlLog32bitNbase2(temp)) : rgSCHUtlLog32bitNbase2(temp);
8264
8265          rgSCHTomUtlPcqiSbCalcBpIdx(timingInfo,ueCb, cqiCb);
8266       }
8267 #ifdef LTE_ADV
8268       else
8269       {
8270          cqiCb->prioLvl = RG_SCH_CQI_PRIO_LVL_1;
8271       }
8272 #endif
8273
8274       /*    Place the UE in cellCb->tIUeLstCp  */
8275       cqiCb->cqiLstEnt.node=(PTR) cqiCb;
8276 #ifdef LTE_ADV
8277       cqiCb->isCqiIgnoByCollsn = FALSE;
8278       cqiCb->isRiIgnoByCollsn = FALSE;
8279 #endif
8280
8281
8282       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,
8283             &cqiCb->cqiLstEnt);
8284
8285
8286       /* 4. Rank Indicator Cfg handler */
8287       rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
8288    }
8289    else
8290    {
8291       cqiCb->cqiCfg.type =  RGR_SCH_PCQI_REL;
8292       if(cqiCb->nCqiTrIdx != RG_SCH_INVALID_IDX)
8293       {
8294          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,\
8295                &cqiCb->cqiLstEnt);
8296       }
8297       if(cqiCb->nRiTrIdx != RG_SCH_INVALID_IDX)
8298       {
8299          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst, \
8300                &cqiCb->riLstEnt);
8301           RG_SCH_RECORD(&cqiCb->histElem,RGSCH_ACTION_DEL,
8302             &cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst);
8303       }
8304       cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
8305       cqiCb->nRiTrIdx   = RG_SCH_INVALID_IDX;
8306       cqiCb->riDist   = RG_SCH_INVALID_IDX;
8307    }
8308    ueCb->nPCqiCb = cqiCb;
8309    ueCb->nPRiCb = cqiCb;
8310    return ROK;
8311 }
8312
8313 /**
8314  * @brief Handles Periodic  RI  configuration for a UE.
8315  *
8316  * @details
8317  *
8318  *     Function : rgSCHCfgRiUeCfg
8319  *
8320  *     Invoking Module Processing:
8321  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8322  *      validations for the spec-defined values.
8323  *
8324  *     Processing Steps:
8325  *     - For UE-specific Periodic RI  related configuration,
8326  *      - If Periodic RI is configured,
8327  *        - Update UE with the configured values.
8328  - Compute and Update next occurance of RI Tranmission instance.
8329  - Update the  RI offset and RI perodicity information
8330  *
8331  *     - Return ROK
8332  *
8333  *  @param[in]  RgSchCellCb  *cell
8334  *  @param[in]  RgSchUeCb    *ue
8335  *  @param[in]  RgrUePrdDlCqiCfg *cqiCfg
8336  *  @param[in]  CmLteUeCategory   ueCat
8337  *  @return  S16
8338  *      -# ROK
8339  *
8340  **/
8341 #ifdef ANSI
8342 S16 rgSCHCfgRiUeCfg
8343 (
8344  RgSchCellCb        *cellCb,
8345  RgSchUeCb          *ueCb,
8346  RgrUePrdDlCqiCfg   *cqiCfg,
8347  CmLteUeCategory    ueCat
8348  )
8349 #else
8350 S16 rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
8351    RgSchCellCb       *cellCb;
8352    RgSchUeCb         *ueCb;
8353    RgrUePrdDlCqiCfg  *cqiCfg;
8354    CmLteUeCategory   ueCat;
8355 #endif
8356 {
8357    uint16_t     crntTime;
8358    uint16_t     riTrInsTime;
8359    uint8_t      j; /*Bandwidth parts. Valid for Modes 2-0, 2-1*/
8360    uint16_t     periodicity;
8361    uint16_t    tempIdx;
8362    RgSchUePCqiCb *cqiCb = NULLP;
8363
8364    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
8365       +(cellCb->crntTime.slot);
8366    cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
8367    /* 1. Rank Indicator is enabled  */
8368    if(cqiCfg->cqiSetup.riEna)
8369    {
8370
8371       rgSCHUtlGetCfgPerOff(RG_SCH_RI_TBL,
8372             cqiCfg->cqiSetup.riCfgIdx,
8373             &cqiCb->riPeri, &cqiCb->riOffset);
8374
8375       RLOG_ARG3(L_DEBUG,DBG_CELLID,cellCb->cellId,
8376             "rgSCHCfgRiUeCfg(): RI Peri=%d, RI Offset=%d UEID:%d",
8377             cqiCb->riPeri, cqiCb->riOffset,ueCb->ueId);
8378
8379       cqiCb->perRiVal = 1;
8380       cqiCb->invalidateCqi = FALSE;
8381
8382       if(RGR_UE_PCQI_WB_REP == cqiCfg->cqiSetup.cqiRepType)
8383       {
8384          /*
8385             1. wideband RI reporting is configured
8386             (Mode 1-0 or 1-1)
8387             (10*sfn+floor(subframe)-Noffsetcqi-NoffsetRI )Mod(NCqiperiod
8388           *MriPeriod)=0
8389           */
8390          periodicity = cqiCb->cqiPeri * cqiCb->riPeri;
8391       }
8392       else
8393       {
8394          /*
8395          *  Where Widesband and Subband RI reporting is configured
8396          *   (Mode 2-0 or 2-1 )
8397          *   (10*sfn+floor(subframe)-Noffsetcqi-NoffsetRI )
8398          *   Mod(H. NCqiperiod *MriPeriod )=0
8399          *   where H= J * K +1;  J=Number of bandwidth parts(BW/subsize).
8400          *   K is RGR interf input
8401          */
8402
8403          RG_SCH_GET_CQI_J_VAL(cellCb->bwCfg.dlTotalBw, j);
8404          cqiCb->h = (cqiCb->cqiCfg.cqiSetup.k *j )+1;
8405          periodicity = cqiCb->h * cqiCb->cqiPeri *
8406                                   cqiCb->riPeri;
8407       }
8408
8409       /* In case of SFN wraparound, the SB CQI reporting cycle breaks
8410        * and RI->WB CQI->SBCQI.. should resume. RI is repositioned
8411        * accordingly. WBCQI handling is naturally accomplished */
8412       if (periodicity >= RGSCH_MAX_SUBFRM_5G)
8413       {
8414          periodicity = cqiCb->cqiOffset - cqiCb->riOffset +
8415                        RGSCH_MAX_SUBFRM_5G - (crntTime);
8416          tempIdx = crntTime + periodicity;
8417                         printf("CHECK_SID - periodicity %d tempIdx %d\n", periodicity, tempIdx);
8418       }
8419       else
8420       {
8421          if ((crntTime + TFU_RECPREQ_DLDELTA + periodicity) >
8422                             (RGSCH_MAX_SUBFRM_5G - 1))
8423          {
8424             riTrInsTime = (periodicity - cqiCb->cqiOffset + cqiCb->riOffset) % periodicity;
8425             tempIdx = RGSCH_MAX_SUBFRM_5G + (periodicity - riTrInsTime);
8426          }
8427          else
8428          {
8429             riTrInsTime = ((periodicity +crntTime )- \
8430                cqiCb->cqiOffset + cqiCb->riOffset)\
8431                        % periodicity;
8432             tempIdx = (crntTime + (periodicity -riTrInsTime));
8433          }
8434       }
8435       if (tempIdx <= (crntTime + TFU_RECPREQ_DLDELTA))
8436       {
8437          tempIdx = tempIdx + periodicity;
8438       }
8439       cqiCb->nRiTrIdx = tempIdx
8440          % RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
8441       if(periodicity >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
8442       {
8443          cqiCb->riDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
8444                 (uint16_t) tempIdx);
8445       }
8446       else
8447       {
8448          cqiCb->riDist =0;
8449       }
8450       if(ueCb->mimoInfo.txMode == RGR_UE_TM_3
8451             || ueCb->mimoInfo.txMode == RGR_UE_TM_4)
8452       {
8453          if (cellCb->numTxAntPorts ==2)
8454          {
8455             cqiCb->riNumBits = 1;
8456          }
8457          else if(cellCb->numTxAntPorts ==4)
8458          {
8459             if(ueCat == CM_LTE_UE_CAT_8)
8460             {
8461                cqiCb->riNumBits = 3;
8462             }
8463             else if(ueCat >= CM_LTE_UE_CAT_5)
8464             {
8465                cqiCb->riNumBits = 2;
8466             }
8467             else
8468             {
8469                cqiCb->riNumBits = 1;
8470             }
8471          }
8472       }
8473       /*    Place the UE in cellCb->tIUeLstCp  */
8474       cqiCb->riLstEnt.node=(PTR) cqiCb;
8475
8476       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst,
8477             &cqiCb->riLstEnt);
8478       RG_SCH_RECORD(&cqiCb->histElem,RGSCH_ACTION_ADD,
8479          &cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst);
8480
8481
8482    }
8483    else
8484    {
8485       cqiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
8486       cqiCb->riDist   = RG_SCH_INVALID_IDX;
8487    }
8488
8489    return ROK;
8490
8491 }
8492
8493 /* @brief Handles SRS configuration for a UE.
8494  *
8495  * @details
8496  *
8497  *     Function : rgSCHCfgSrsUeCfg
8498  *
8499  *     Invoking Module Processing:
8500  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8501  *      validations for the spec-defined values.
8502  *
8503  *     Processing Steps:
8504  *     - For UE-specific SRS  related configuration,
8505  *      - If SRS is configured,
8506  *        - Update UE with the configured values.
8507  - Compute and Update next occurance of SRS Tranmission instance.
8508  - Update the  SRS offset and SRS perodicity information
8509  - Add Ue to cell's srs list
8510  *      - else
8511  *        - next occurance transmission instance of SRS  = RG_SCH_INVALID_IDX
8512  *
8513  *     - Return ROK
8514  *
8515  *  @param[in]  RgSchCellCb  *cell
8516  *  @param[in]  RgSchUeCb    *ue
8517  *  @param[in]  RgrUeUlSrsCfg   *srsCfg
8518  *
8519  *  @return  S16
8520  *      -# ROK
8521  *      -# RFAILED
8522  */
8523 #ifdef ANSI
8524 S16 rgSCHCfgSrsUeCfg
8525 (
8526  RgSchCellCb     *cellCb,
8527  RgSchUeCb       *ueCb,
8528  RgrUeUlSrsCfg   *srsCfg
8529  )
8530 #else
8531 S16 rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg)
8532    RgSchCellCb     *cellCb;
8533    RgSchUeCb       *ueCb;
8534    RgrUeUlSrsCfg   *srsCfg;
8535 #endif
8536 {
8537    uint16_t      srsTrInsTime;
8538    uint16_t      crntTime;
8539    uint16_t      tempIdx;
8540
8541    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
8542       +(cellCb->crntTime.slot);
8543
8544    if(RGR_SCH_SRS_SETUP == srsCfg->type)
8545    {
8546       /*  1. Copy the Received Cfg parameters to local cb  */
8547       memcpy(&ueCb->srsCb.srsCfg, srsCfg, sizeof(RgrUeUlSrsCfg));
8548
8549 #ifndef LTE_TDD
8550       /* 2.  Compute SRS Offset and Periodicity */
8551       rgSCHUtlGetCfgPerOff( RG_SCH_FDD_SRS_TBL,
8552             srsCfg->srsSetup.srsCfgIdx,
8553             &ueCb->srsCb.peri, &ueCb->srsCb.offset);
8554 #else
8555       rgSCHUtlGetCfgPerOff( RG_SCH_TDD_SRS_TBL,
8556             srsCfg->srsSetup.srsCfgIdx,
8557             &ueCb->srsCb.peri, &ueCb->srsCb.offset);
8558 #endif
8559
8560       RLOG_ARG3(L_DEBUG,DBG_CELLID,cellCb->cellId,
8561             "rgSCHCfgSrsUeCfg(): SRS Peri=%d, SRS Offset=%d UEID:%d",
8562             ueCb->srsCb.peri,ueCb->srsCb.offset,ueCb->ueId);
8563
8564       /*  3. Compute next Tranmission index for SRS */
8565       /*     Referenence: 36.213 Section:8.2
8566              i. SRS transmission instances for TDD with  period > 2 and for FDD are
8567              ((10*sfn +Ksrs-suframeoffset))/mod(periodicity))
8568              FDD: Ksrs is 0...9
8569              TDD: Ksrs Table 8.2-3:
8570              ii.The SRS transmission instances for TDD (periodicity == 2)
8571              (Ksrs-Toffset)mod(5)==0.  Note: This is not supported now
8572       */
8573
8574       srsTrInsTime = ((ueCb->srsCb.peri+crntTime) - ueCb->srsCb.offset)
8575          %ueCb->srsCb.peri;
8576      tempIdx = (crntTime + (ueCb->srsCb.peri - srsTrInsTime));
8577 #ifdef LTE_TDD
8578       if (tempIdx  <=  (crntTime + TFU_DELTA))
8579 #else
8580       if (tempIdx  <=  (crntTime + TFU_RECPREQ_DLDELTA))
8581 #endif
8582       {
8583          tempIdx = tempIdx + ueCb->srsCb.peri;
8584       }
8585       ueCb->srsCb.nSrsTrIdx =(uint16_t) (tempIdx
8586          % RG_SCH_PCQI_SRS_SR_TRINS_SIZE);
8587       if(ueCb->srsCb.peri >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
8588       {
8589 #ifdef LTE_TDD
8590          ueCb->srsCb.srsDist = rgSCHUtlFindDist((uint8_t)(crntTime+TFU_DELTA),
8591                                                     (uint16_t)tempIdx);
8592 #else
8593          ueCb->srsCb.srsDist = rgSCHUtlFindDist((uint8_t)(crntTime + TFU_RECPREQ_DLDELTA),
8594                                                     (uint16_t)tempIdx);
8595 #endif
8596       }
8597       else
8598       {
8599          ueCb->srsCb.srsDist = 0;
8600       }
8601
8602       /*UE Tx Antenna Selection - START*/
8603       if(ueCb->ul.ulTxAntSel.pres == TRUE )
8604       {
8605           /*for both partial and full sounding bandwidth,
8606            and when frequency hopping is disabled */
8607          ueCb->srsCb.selectedAnt = (crntTime/ueCb->srsCb.peri)%2;
8608       }
8609       else
8610       {
8611          /* TS 36.213 specifies that if Tx Antenna Selection is
8612             disabled/not supported then its Port 0*/
8613          ueCb->srsCb.selectedAnt=0;
8614       }
8615       ueCb->validTxAnt = ueCb->srsCb.selectedAnt;
8616       /*UE Tx Antenna Selection - ENDS*/
8617
8618       ueCb->srsCb.srsLstEnt.node=(PTR)ueCb;
8619       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
8620             &ueCb->srsCb.srsLstEnt);
8621
8622
8623    }
8624    else
8625    {
8626       /*  SRS Release / Not configured */
8627       ueCb->srsCb.srsCfg.type = RGR_SCH_SRS_REL;
8628       if(ueCb->srsCb.nSrsTrIdx != RG_SCH_INVALID_IDX)
8629       {
8630          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
8631                &ueCb->srsCb.srsLstEnt);
8632       }
8633       ueCb->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
8634       ueCb->srsCb.srsLstEnt.node =(PTR) NULLP;
8635    }
8636
8637    return ROK;
8638 }
8639
8640
8641 /* * @brief Handles SR configuration for a UE.
8642  *
8643  * @details
8644  *
8645  *     Function : rgSCHCfgSrUeCfg
8646  *
8647  *     Invoking Module Processing:
8648  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8649  *      validations for the spec-defined values.
8650  *
8651  *      - If SR is configured,
8652  *        - Update UE with the configured values.
8653  - Compute and Update next occurance of SR Tranmission instance.
8654  - Update the  SR offset and SR perodicity information
8655  - Add Ue to cell->tIUeLstCp[n]
8656  *      - else
8657  *        - next occurance transmission instance of SR = RG_INVALID_SR_ID
8658  *
8659  *
8660  *     - Return ROK
8661  *
8662  *  @param[in]  RgSchCellCb  *cell
8663  *  @param[in]  RgSchUeCb    *ue
8664  *  @param[in]  RgrUeSrCfg       *srCfg
8665  *
8666  *  @return  S16
8667  *      -# ROK
8668  *      -# RFAILED
8669  */
8670 #ifdef ANSI
8671 S16 rgSCHCfgSrUeCfg
8672 (
8673  RgSchCellCb      *cellCb,
8674  RgSchUeCb        *ueCb,
8675  RgrUeSrCfg       *srCfg
8676  )
8677 #else
8678 S16 rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg)
8679    RgSchCellCb    *cellCb;
8680    RgSchUeCb      *ueCb;
8681    RgrUeSrCfg     *srCfg;
8682 #endif
8683 {
8684    uint16_t     srTrInsTime;
8685    uint16_t     crntTime;
8686
8687
8688    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
8689       +(cellCb->crntTime.slot);
8690    if(srCfg->type == RGR_SCH_SR_SETUP)
8691    {
8692       /*  1. Copy the Received Cfg parameters to local cb  */
8693       memcpy(&ueCb->srCb.srCfg, srCfg, sizeof(RgrUeSrCfg));
8694
8695
8696       /*  2. Compute SR periodicity and offset */
8697       rgSCHUtlGetCfgPerOff( RG_SCH_SR_TBL,
8698             srCfg->srSetup.srCfgIdx,
8699             &ueCb->srCb.peri, &ueCb->srCb.offset);
8700
8701       RLOG_ARG4(L_DEBUG,DBG_CELLID,cellCb->cellId ,
8702             "SR Config: idx(%u), period (%u) offset (%u) UEID:%d",
8703             srCfg->srSetup.srCfgIdx,
8704             ueCb->srCb.peri,
8705             ueCb->srCb.offset,
8706             ueCb->ueId);
8707 #ifdef EMTC_ENABLE
8708       if(ueCb->isEmtcUe)
8709       {
8710          rgSchfillPucchSrRepNumCountemtc(ueCb);
8711       }
8712 #endif
8713       /*   3. Compute Next Transmission Instance */
8714
8715       srTrInsTime = ((ueCb->srCb.peri+crntTime) - ueCb->srCb.offset)
8716          %ueCb->srCb.peri;
8717       ueCb->srCb.nSrTrIdx = (crntTime + (ueCb->srCb.peri- srTrInsTime));
8718 #ifdef LTE_TDD
8719       if (ueCb->srCb.nSrTrIdx  <= (crntTime + TFU_DELTA))
8720 #else
8721       if (ueCb->srCb.nSrTrIdx  <= (crntTime + TFU_RECPREQ_DLDELTA))
8722 #endif
8723       {
8724          ueCb->srCb.nSrTrIdx = ueCb->srCb.nSrTrIdx +  ueCb->srCb.peri;
8725       }
8726       ueCb->srCb.nSrTrIdx = ueCb->srCb.nSrTrIdx
8727          % RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
8728       ueCb->srCb.srLstEnt.node= (PTR) ueCb;
8729
8730       /* 4. Place UE in Cell SR Tranmisison Instance List  */
8731       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
8732             &ueCb->srCb.srLstEnt);
8733    }
8734    else
8735    {
8736       ueCb->srCb.srCfg.type =  RGR_SCH_SR_REL;
8737
8738       if(ueCb->srCb.nSrTrIdx != RG_SCH_INVALID_IDX)
8739       {
8740          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
8741                &ueCb->srCb.srLstEnt);
8742       }
8743       ueCb->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
8744       ueCb->srCb.srLstEnt.node = (PTR)NULLP;
8745    }
8746
8747    return ROK;
8748 }
8749
8750
8751 /*****************************************************************
8752  *    UE PCQI, RI, SRS and SR       Re Configuration Functions    *
8753  *                                                                *
8754  ******************************************************************/
8755
8756
8757 /* * @brief Handles Periodic CQI, PMI, RI  Re-configuration for a UE.
8758  *
8759  * @details
8760  *
8761  *     Function : rgSCHCfgPCqiUeReCfg
8762  *
8763  *     Invoking Module Processing:
8764  *      - This shall be invoked by SCH_GOM at UE Re configuration. It shall do the
8765  *      validations for the spec-defined values.
8766  *
8767  *     Processing Steps:
8768  *     - For UE-specific Periodic CQI  related configuration,
8769  *      - If Periodic CQI/PMI is re configured(first time enabled),
8770  *          - Update UE with the configured values.
8771  *         - Compute and Update next occurance of CQI/PMI or RI Tranmission
8772  *         instance.
8773  *         - Update the CQI offset and CQI perodicity information
8774  *         - Add Ue to cell's list
8775  *      - If Periodic CQI/PMI is re configured(modify),
8776  *         - Update UE with the configured values.
8777  *         - Del Ue from cell->tIUeLstCp list
8778  *          - Compute and Update next occurance of CQI/PMI or RI Tranmission
8779  *          instance.
8780  *         - Update the CQI offset and CQI perodicity information
8781  *         - Add Ue to cell's list
8782  *      - If Periodic CQI/PMI is re configured(disabled),
8783  *        - Update UE with the configured values.
8784  *         - Del Ue from cell's list
8785  *         - Update next occurance of CQI/PMI or RI Tranmission instance.
8786  *        - next occurance of CQI/PMI = RG_INVALID_CQIPMI_ID
8787  *
8788  *     - For UE-specific Periodic RI  related configuration,
8789  *      - If Periodic RI is configured(first time enabled),
8790  *        - Update UE with the configured values.
8791  *          - Compute and Update next occurance of RI Tranmission instance.
8792  *         - Update the  RI offset and RI perodicity information
8793  *      - If Periodic RI is configured(modify),
8794  *        - Update UE with the configured values.
8795  *         - Compute and Update next occurance of RI Tranmission instance.
8796  *         - Update the  RI offset and RI perodicity information
8797  *      - else
8798  *        - next occurance of RI  = RG_INVALID_CQIPMI_ID
8799  *
8800  *     - Return ROK
8801  *
8802  *  @param[in]  RgSchCellCb  *cell
8803  *  @param[in]  RgSchUeCb    *ue
8804  *  @param[in]  RgrUeCfg     *ueCfg
8805  *
8806  *  @return  S16
8807  *      -# ROK
8808  *
8809  */
8810 #ifdef ANSI
8811 S16 rgSCHCfgPCqiUeReCfg
8812 (
8813  RgSchCellCb        *cellCb,
8814  RgSchUeCb          *ueCb,
8815  RgrUePrdDlCqiCfg   *cqiCfg,
8816  CmLteUeCategory      ueCat
8817  )
8818 #else
8819 S16  rgSCHCfgPCqiUeReCfg(cellCb, ueCb, cqiCfg, ueCat)
8820    RgSchCellCb       *cellCb;
8821    RgSchUeCb         *ueCb;
8822    RgrUePrdDlCqiCfg  *cqiCfg;
8823    CmLteUeCategory  ueCat;
8824 #endif
8825 {
8826
8827    RgSchUePCqiCb *cqiCb = NULLP;
8828
8829    cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
8830    /* Fix: ccpu00124008 Fix for incorrect check causing missed CQI reception instance */
8831    if((cqiCfg->type == RGR_SCH_PCQI_SETUP) &&
8832          (cqiCb->cqiCfg.type != RGR_SCH_PCQI_SETUP))
8833    {
8834       /* 1. cqi is in Release (Disable) state,  Recfg is allowing Setup (Enable)
8835       */
8836       rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
8837
8838    }
8839    else if((cqiCfg->type == RGR_SCH_PCQI_SETUP) &&
8840          (cqiCb->cqiCfg.type == RGR_SCH_PCQI_SETUP ))
8841    {
8842
8843       /*
8844          2. Present is SETUP(Enable) state,  Recfg is modifying SETUP(Enable)
8845
8846          2.1 Delete UE from the cqiList
8847          2.2 Set next occurance Transmission instace to "INVALID"
8848          2.3 Compute Next occurance Transmission instace
8849          2.4 Placed ue in Transmission instance list.
8850          */
8851       if(cqiCb->nCqiTrIdx != RG_SCH_INVALID_IDX )
8852          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,
8853                &cqiCb->cqiLstEnt);
8854
8855       if(cqiCb->nRiTrIdx != RG_SCH_INVALID_IDX )
8856       {
8857          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst,
8858                &cqiCb->riLstEnt);
8859          RG_SCH_RECORD(&cqiCb->histElem,RGSCH_ACTION_DEL,
8860             &cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst);
8861       }
8862
8863
8864       cqiCb->cqiLstEnt.next = NULLP;
8865       cqiCb->cqiLstEnt.prev  = NULLP;
8866       cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
8867       cqiCb->nRiTrIdx  = RG_SCH_INVALID_IDX;
8868       cqiCb->riDist    = RG_SCH_INVALID_IDX;
8869
8870       rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
8871    }
8872    else
8873    {
8874       /* Present is SETUP(Enable) state,  Recfg is Release(Disable)  */
8875       rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
8876    }
8877
8878    /* ccpu00140578:: */
8879    cqiCb->riRecpPrcsd = FALSE;
8880    return ROK;
8881 }
8882
8883
8884 /* * @brief Handles SRS  Re-configuration for a UE.
8885  *
8886  * @details
8887  *
8888  *     Function : rgSCHCfgSrsUeReCfg
8889  *
8890  *     Invoking Module Processing:
8891  *      - This shall be invoked by SCH_GOM at UE Re configuration. It shall do the
8892  *      validations for the spec-defined values.
8893  *
8894  *     Processing Steps:
8895  *     - For UE-specific SRS  related re configuration,
8896  *      - If SRS is configured modified(First time Enabled),
8897  *        - Update UE with the configured values.
8898  *         - Compute and Update next occurance of SRS Tranmission instance.
8899  *        - Update the  SRS offset and SRS perodicity information
8900  *        - Add Ue to cell's list
8901  *      - If SRS is configured modified(Changed offset or index ),
8902  *      - Delete UE from cell->tIUeLstCp[n] if present
8903  *      - Update UE with the configured values.
8904  *      - Compute and Update next occurance of SRS Tranmission instance.
8905  *      - Update the  SRS offset and SRS perodicity information
8906  *      - Add Ue to cell's list
8907  *      - If SRS is configured modified(disabled),
8908  *      - Delete UE from cell->tIUeLstCp[n] if present
8909  *        - Update next occurance of SRS Tranmission instance to "INVALID".
8910  *        - Update the  SRS offset and SRS perodicity information "INVALID"
8911  *      - else
8912  *        - ROK
8913  *
8914  *     - Return ROK
8915  *
8916  *  @param[in]  RgSchCellCb  *cell
8917  *  @param[in]  RgSchUeCb    *ue
8918  *  @param[in]  RgrUeUlSrsCfg    *srsCfg
8919  *
8920  *  @return  S16
8921  *      -# ROK
8922  *      -# RFAILED
8923  */
8924 #ifdef ANSI
8925 S16 rgSCHCfgSrsUeReCfg
8926 (
8927  RgSchCellCb        *cellCb,
8928  RgSchUeCb          *ueCb,
8929  RgrUeUlSrsCfg      *srsCfg
8930  )
8931 #else
8932 S16 rgSCHCfgSrsUeReCfg(cellCb, ueCb, srsCfg)
8933    RgSchCellCb      *cellCb;
8934    RgSchUeCb        *ueCb;
8935    RgrUeUlSrsCfg    *srsCfg;
8936 #endif
8937 {
8938
8939
8940    if(( RGR_SCH_SRS_SETUP == srsCfg->type) ||
8941          ( RGR_SCH_SRS_SETUP != ueCb->srsCb.srsCfg.type ))
8942    {
8943       /*     1. Present is Release(Disable) state,  Recfg is allowing
8944        *     SETUP(Enable)  */
8945       rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg);
8946    }
8947    else if (( RGR_SCH_SRS_SETUP == srsCfg->type ) &&
8948          ( RGR_SCH_SRS_SETUP  == ueCb->srsCb.srsCfg.type))
8949    {
8950
8951       /*     2. Present is SETUP(Eanble) state,  Recfg is modifying SETUP(Enable)
8952
8953              2.1 Delete UE from the cqiList
8954              2.2 Set next occurance Transmission instance to "INVALID"
8955              2.3 Compute Next occurance Transmission instance
8956              2.4 Placed ue in Transmission instance list.
8957              */
8958       if (ueCb->srsCb.nSrsTrIdx != RG_SCH_INVALID_IDX)
8959       {
8960          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
8961                &ueCb->srsCb.srsLstEnt);
8962          ueCb->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
8963       }
8964
8965       rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg);
8966    }
8967    else
8968    {
8969       /* 3. Present is SETUP(Enable) state,  Recfg is Release(Disable)*/
8970       rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg);
8971    }
8972    /* ccpu00140578:: */
8973    ueCb->srsCb.srsRecpPrcsd = FALSE;
8974
8975    return ROK;
8976 }
8977
8978 /* @brief Handles  SR Re-configuration for a UE.
8979  *
8980  * @details
8981  *
8982  *     Function : rgSCHCfgSrUeReCfg
8983  *
8984  *     Invoking Module Processing:
8985  *      - This shall be invoked by SCH_GOM at UE Re configuration.
8986  *      It shall do the validations for the spec-defined values.
8987  *
8988  *     Processing Steps:
8989  *     - For UE-specific SR  related re configuration,
8990  *      - If SR is configured modified(First time Enabled),
8991  *        - Update UE with the configured values.
8992  *          - Compute and Update next occurance of SR Tranmission instance.
8993  *         - Update the  SR offset and SR perodicity information
8994  *         - Add Ue to cell->tIUeLstCp[n]
8995  *      - If SR is configured modified(Changed offset or index ),
8996  *      - Delete UE from cell->tIUeLstCp[n] if present
8997  *       - Update UE with the configured values.
8998  *       - Compute and Update next occurance of SR Tranmission instance.
8999  *       - Update the  SR offset and SR perodicity information
9000  *       - Add Ue to cell->tIUeLstCp[n]
9001  *      - If SR is configured modified(disabled),
9002  *      - Delete UE from cell->tIUeLstCp[n] if present
9003  *         - Update next occurance of SR Tranmission instance to "INVALID".
9004  *         - Update the  SR offset and SR perodicity information "INVALID"
9005  *      - else
9006  *        - ROK
9007  *
9008  *
9009  *
9010  *     - Return ROK
9011  *
9012  *  @param[in]  RgSchCellCb  *cell
9013  *  @param[in]  RgSchUeCb    *ue
9014  *  @param[in]  RgrUeCfg     *ueCfg
9015  *
9016  *  @return  S16
9017  *      -# ROK
9018  *      -# RFAILED
9019  */
9020 #ifdef ANSI
9021 S16 rgSCHCfgSrUeReCfg
9022 (
9023  RgSchCellCb    *cellCb,
9024  RgSchUeCb      *ueCb,
9025  RgrUeSrCfg     *srCfg
9026  )
9027 #else
9028 S16 rgSCHCfgSrUeReCfg(cellCb, ueCb, srCfg)
9029    RgSchCellCb   *cellCb;
9030    RgSchUeCb     *ueCb;
9031    RgrUeSrCfg    *srCfg;
9032 #endif
9033 {
9034
9035    /* Fix : syed Incorrect check for SR RECFG */
9036    if((srCfg->type == RGR_SCH_SR_SETUP) &&
9037          (ueCb->srCb.srCfg.type != RGR_SCH_SR_SETUP))
9038    {
9039       /*
9040          1. Present is Release(Disable) state,  Recfg is allowing SETUP(Enable)
9041          */
9042       rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
9043    }
9044    else if((srCfg->type == RGR_SCH_SR_SETUP) &&
9045          (ueCb->srCb.srCfg.type == RGR_SCH_SR_SETUP))
9046    {
9047
9048       /*   2. Present is SETUP(Eanble) state,  Recfg is modifying SETUP(Enable)
9049
9050            2.1 Delete UE from the cqiList
9051            2.2 Compute Next occurance Transmission instace
9052            */
9053       if(ueCb->srCb.nSrTrIdx != RG_SCH_INVALID_IDX )
9054       {
9055          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
9056                &ueCb->srCb.srLstEnt);
9057          ueCb->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
9058       }
9059       rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
9060
9061    }
9062    else
9063    {
9064       /* 3. Present is SETUP(Enable) state,  Recfg is Release(Disable) */
9065       rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
9066    }
9067
9068    return ROK;
9069 }
9070
9071 /* @brief Handles  ACQI Re-configuration for a UE.
9072  *
9073  * @details
9074  *
9075  *     Function : rgSCHCfgAcqiUeReCfg
9076  *
9077  *     Invoking Module Processing:
9078  *      - This shall be invoked by SCH_GOM at UE Re configuration.
9079  *      It shall do the validations for the spec-defined values.
9080  *
9081  *     Processing Steps:
9082  *     - For UE-specific ACQI  related re configuration,
9083  *          - Check if the ACQI Mode has been changed from the
9084  *             existing Configuration.
9085  *     - If the configuration has been changed,
9086  *          - Call Aperiodic Config function to change the config
9087  *      - else
9088  *        - ROK
9089  *
9090  *
9091  *     - Return ROK
9092  *
9093  *  @param[in]  RgSchCellCb  *cell
9094  *  @param[in]  RgSchUeCb    *ue
9095  *  @param[in]  RgrUeAprdDlCqiCfg   *acqiCfg
9096  *
9097  *  @return  S16
9098  *      -# ROK
9099  *      -# RFAILED
9100  */
9101 #ifdef ANSI
9102 S16 rgSCHCfgAcqiUeReCfg
9103 (
9104  RgSchCellCb    *cellCb,
9105  RgSchUeCb      *ueCb,
9106  RgrUeAprdDlCqiCfg   *acqiCfg,
9107  CmLteUeCategory   ueCat
9108  )
9109 #else
9110 S16 rgSCHCfgAcqiUeReCfg(cellCb, ueCb, acqiCfg, ueCat)
9111    RgSchCellCb   *cellCb;
9112    RgSchUeCb     *ueCb;
9113    RgrUeAprdDlCqiCfg   *acqiCfg;
9114    CmLteUeCategory   ueCat;
9115 #endif
9116 {
9117
9118    return (rgSCHCfgACqiUeCfg(cellCb,ueCb,(RG_SCH_CMN_GET_ACQICB(ueCb,cellCb))
9119                                     ,ueCb->mimoInfo.txMode, acqiCfg, ueCat));
9120
9121 }
9122
9123 /*****************************************************************
9124  *   UE PCQI, RI, SRS and SR Configuration  Delete                *
9125  *                                                                *
9126  *****************************************************************/
9127
9128 /* @brief Free Periodic CQI/PMI/RI, SRS and SR transmission instance
9129  * related data structures of this UE from CellCb
9130  *
9131  * @details
9132  *
9133  *     Function : rgSCHCfgPCqiSrsSrUeDel
9134  *
9135  *     Invoking Module Processing:
9136  *      - This shall be invoked by SCH_GOM at Ue deletion.
9137  *
9138  *     Processing Steps:
9139  *      - For SRS Transmission Instance
9140  *       - if (srsTxInst!= RG_INVALID)
9141  *        - Remove from the cellCb->tIUeLstCp[srsTxInst*3+2]
9142  *       - else
9143  *        - Nothing to do
9144  *      - For SR Transmission Instance
9145  *       - if (srTxInst!= RG_INVALID)
9146  *        - Remove from the cellCb->tIUeLstCp[srTxInst*3+1]
9147  *       - else
9148  *        - Nothing to do
9149  *      - For Periodic CQI/PMI RI  Transmission Instance
9150  *       - if (pCqiTxInst!= RG_INVALID)
9151  *        - Remove from the cellCb->tIUeLstCp[srTxInst*3+0]
9152  *       - else
9153  *        - Nothing to do
9154  *      - Return ROK
9155  *  @param[in]  RgSchCellCb  *cell
9156  *  @param[in]  RgSchUeCb    *ue
9157  *
9158  *  @return  S16
9159  *      -# ROK
9160  */
9161 #ifdef ANSI
9162 S16 rgSCHCfgPCqiSrsSrUeDel
9163 (
9164  RgSchCellCb      *cellCb,
9165  RgSchUeCb        *ueCb
9166  )
9167 #else
9168 S16 rgSCHCfgPCqiSrsSrUeDel(cellCb, ueCb)
9169    RgSchCellCb    *cellCb;
9170    RgSchUeCb      *ueCb;
9171 #endif
9172 {
9173 #ifdef LTE_ADV
9174    uint32_t cellIdx;
9175    uint32_t sCellCnt = 0;
9176 #endif
9177    RgSchUePCqiCb *cqiRiCb = NULLP;
9178
9179    cqiRiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
9180
9181
9182
9183    /* Delete SRS Transmission Instance  */
9184    if (ueCb->srsCb.nSrsTrIdx != RG_SCH_INVALID_IDX)
9185    {
9186       cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
9187             &ueCb->srsCb.srsLstEnt);
9188       ueCb->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
9189    }
9190
9191    /* Delete SR Transmission Instance  */
9192    if (ueCb->srCb.nSrTrIdx != RG_SCH_INVALID_IDX)
9193    {
9194       cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
9195             &ueCb->srCb.srLstEnt);
9196       ueCb->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
9197    }
9198
9199    /* Delete Periodic CQI/PMI  Transmission Instance  */
9200    if (cqiRiCb->nCqiTrIdx != RG_SCH_INVALID_IDX)
9201    {
9202       cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nCqiTrIdx].cqiLst,
9203             &cqiRiCb->cqiLstEnt);
9204       cqiRiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
9205
9206       /* Delete Periodic  RI  Transmission Instance  */
9207
9208       if (cqiRiCb->nRiTrIdx != RG_SCH_INVALID_IDX)
9209       {
9210          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst,
9211                &cqiRiCb->riLstEnt);
9212          RG_SCH_RECORD(&cqiRiCb->histElem,RGSCH_ACTION_DEL,
9213             &cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst);
9214          cqiRiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
9215       }
9216    }
9217
9218 #ifdef LTE_ADV
9219    for (cellIdx =1; cellIdx <= RG_SCH_MAX_SCELL; cellIdx++)
9220    {
9221       /* If a serving cell is configured */
9222       if(ueCb->cellInfo[cellIdx] != NULLP)
9223       {
9224          /* If the serving cell is in ACTIVE state and
9225             If it is not the same serving cell as cqiRiCb for which
9226             collision is being checked */
9227          cqiRiCb = &ueCb->cellInfo[cellIdx]->cqiCb;
9228          /* Delete Periodic CQI/PMI  Transmission Instance  */
9229          if (cqiRiCb->nCqiTrIdx != RG_SCH_INVALID_IDX)
9230          {
9231             cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nCqiTrIdx].cqiLst,
9232                   &cqiRiCb->cqiLstEnt);
9233             cqiRiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
9234
9235             /* Delete Periodic  RI  Transmission Instance  */
9236
9237             if (cqiRiCb->nRiTrIdx != RG_SCH_INVALID_IDX)
9238             {
9239                cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst,
9240                      &cqiRiCb->riLstEnt);
9241                RG_SCH_RECORD(&cqiRiCb->histElem,RGSCH_ACTION_DEL,
9242                   &cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst);
9243                cqiRiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
9244             }
9245          }
9246          sCellCnt++;
9247          /* If all of the num of configured scells are checked then break */
9248          if (sCellCnt == ueCb->numSCells)
9249          {
9250             break;
9251          }
9252       }
9253    }
9254 #endif
9255
9256    return ROK;
9257 }
9258
9259
9260 /* @brief Search the cfgIdx in given table and retrive periodicity & offset
9261  * @details
9262  *
9263  *     Function : rgSCHUtlGetCfgPerOff
9264  *
9265  *     Invoking Module Processing:
9266  *      - This shall be invoked by Cfg Module
9267  *
9268  *     Processing Steps:
9269  *          binary search for given entry in table
9270  *          find the periodicty, offset for a given config index from the table
9271  *      - Return ROK
9272  *  @param[in]  RgSchPerTbl tbl
9273  *  @param[in]  uint16_t      cfgIdx
9274  *  @param[out] uint16_t     *peri
9275  *  @param[out] uint16_t     *offset
9276  *
9277  *  @return  S16
9278  *      -# ROK
9279  *
9280  */
9281 #ifdef ANSI
9282 S16 rgSCHUtlGetCfgPerOff
9283 (
9284  RgSchPerTbl     tbl,
9285  uint16_t             cfgIdx,
9286  uint16_t             *peri,
9287  uint16_t             *offset
9288  )
9289 #else
9290 S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
9291    RgSchPerTbl   tbl;
9292    uint16_t           cfgIdx;
9293    uint16_t           *peri;
9294    uint16_t           *offset;
9295 #endif
9296 {
9297    uint8_t     mid;
9298    uint8_t     min = 0;
9299    uint8_t     max = 0;
9300    const RgSchUePCqiSrsSrCfgIdxTbl* table;
9301
9302    /* Added the function instead of the MACRO to get the
9303     * periodicity table */
9304    table = rgSCHCfgUtlGetPcqiSrsSrRiTbl ( tbl,&min,&max );
9305    do{
9306       mid = (min+max)/2;
9307       if (( cfgIdx >= table[mid].min) &&
9308             ( cfgIdx <= table[mid].max))
9309       {
9310          *peri = table[mid].peri;
9311          *offset = cfgIdx - table[mid].offset;
9312          break;
9313       }
9314
9315       if ( cfgIdx > table[mid].min)
9316       {
9317          min = mid+1;
9318       }
9319       else
9320       {
9321          max = mid-1;
9322       }
9323
9324    }while( min <= max );
9325
9326    return ROK;
9327 }
9328
9329
9330 /***********************************************************
9331  *
9332  *     Func : rgSCHCfgUtlFetchAcqiBitSz
9333  *
9334  *
9335  *     Desc : Fetch the CQI/PMI bits for a UE based on the mode and store them
9336  *                for decoding.
9337  *
9338  *     Ret  : Void
9339  *            ROK - void
9340  *
9341  *     Notes:
9342  *
9343  *     File :
9344  *
9345  **********************************************************/
9346 #ifdef ANSI
9347 static Void rgSCHCfgUtlFetchAcqiBitSz
9348 (
9349  RgSchUeACqiCb      *acqiCb,
9350  uint8_t                numTxAnt,
9351  uint8_t*               cqiPmiSzR1,
9352  uint8_t*               cqiPmiSzRn1
9353  )
9354 #else
9355 static  Void rgSCHCfgUtlFetchAcqiBitSz(acqiCb, numTxAnt, cqiPmiSzR1, cqiPmiSzRn1)
9356  RgSchUeACqiCb      *acqiCb;
9357  uint8_t                numTxAnt;
9358  uint8_t*               cqiPmiSzR1;
9359  uint8_t*               cqiPmiSzRn1;
9360 #endif
9361 {
9362
9363    uint32_t               confRepMode;
9364
9365    confRepMode = acqiCb->aCqiCfg.aprdModeEnum;
9366    switch(confRepMode)
9367    {
9368       case RGR_APRD_CQI_MOD12:
9369          {
9370             if(numTxAnt == 2)
9371             {
9372                *cqiPmiSzR1 = 4 + 2*acqiCb->N;
9373                *cqiPmiSzRn1 = 8+ acqiCb->N;
9374             }
9375             else if(numTxAnt == 4)
9376             {
9377                *cqiPmiSzR1 = 4 + 4*acqiCb->N;
9378                *cqiPmiSzRn1 = 8 + 4*acqiCb->N;
9379             }
9380          }
9381          break;
9382
9383       case RGR_APRD_CQI_MOD20:
9384          {
9385             *cqiPmiSzR1 = 6 + acqiCb->L;
9386             *cqiPmiSzRn1 = 6  + acqiCb->L;
9387          }
9388          break;
9389
9390       case RGR_APRD_CQI_MOD22:
9391          {
9392             if(numTxAnt == 2)
9393             {
9394                *cqiPmiSzR1 = 10 + acqiCb->L;
9395                *cqiPmiSzRn1 = 14 + acqiCb->L;
9396             }
9397             else if(numTxAnt == 4)
9398             {
9399                *cqiPmiSzR1 = 14 + acqiCb->L;
9400                *cqiPmiSzRn1 = 20 + acqiCb->L;
9401             }
9402          }
9403          break;
9404
9405       case RGR_APRD_CQI_MOD30:
9406          {
9407             *cqiPmiSzR1 = 4 + 2*acqiCb->N;
9408             *cqiPmiSzRn1 = 4 + 2*acqiCb->N;
9409          }
9410          break;
9411
9412       case RGR_APRD_CQI_MOD31:
9413          {
9414             if(numTxAnt == 2)
9415             {
9416                *cqiPmiSzR1 = 6 + 2*acqiCb->N;
9417                *cqiPmiSzRn1 = 9 + 4*acqiCb->N;
9418             }
9419             else if(numTxAnt == 4)
9420             {
9421                *cqiPmiSzR1 = 8 + 2*acqiCb->N;
9422                *cqiPmiSzRn1 = 12 + 4*acqiCb->N;
9423             }
9424          }
9425          break;
9426       default:
9427          break;
9428    }
9429    return;
9430 }
9431 /* Added the function rgSCHCfgUtlGetPcqiCrsSrRiTbl to be used
9432  * instead of the MACRO RG_SCH_GET_PERIODICITY_TBL */
9433 /***********************************************************
9434  *
9435  *     Func : rgSCHCfgUtlGetPcqiCrsSrRiTbl
9436  *
9437  *
9438  *     Desc :  Get the Srs Cqi Crs Ri Table
9439  *
9440  *     Ret  : Void
9441  *            ROK - void
9442  *
9443  *     Notes:
9444  *
9445  *     File :
9446  *
9447  **********************************************************/
9448
9449 #ifdef ANSI
9450 static const RgSchUePCqiSrsSrCfgIdxTbl *  rgSCHCfgUtlGetPcqiSrsSrRiTbl
9451 (
9452    RgSchPerTbl tblType,
9453    uint8_t* min,
9454    uint8_t* max
9455 )
9456 #else
9457 static const RgSchUePCqiSrsSrCfgIdxTbl *  rgSCHCfgUtlGetPcqiSrsSrRiTbl(tblType, min, max)
9458    RgSchPerTbl tblType;
9459    uint8_t* min;
9460    uint8_t* max;
9461 #endif
9462 {
9463     const RgSchUePCqiSrsSrCfgIdxTbl * table;
9464
9465     switch (tblType)
9466     {
9467
9468         case RG_SCH_FDD_PCQI_TBL:
9469         {
9470             table = rgSchUePCqiCfgIdxFddTbl;
9471             * min = 0;
9472             * max=RG_SCH_CQIPMI_CFGIDX_MAX_FDD;
9473             break;
9474         }
9475         case RG_SCH_TDD_PCQI_TBL:
9476         {
9477             table = rgSchUeCqiPmiCfgIdxTddTbl;
9478             * min = 0;
9479             * max=RG_SCH_CQIPMI_CFGIDX_MAX_TDD;
9480             break;
9481         }
9482         case RG_SCH_RI_TBL:
9483         {
9484             table = rgSchUeRiCfgIdxTbl;
9485             * min = 0;
9486             * max=RG_SCH_RI_CFGIDX_MAX;
9487             break;
9488         }
9489         case RG_SCH_FDD_SRS_TBL:
9490         {
9491             table = rgSchUeSrsCfgIdxFddTbl;
9492             * min = 0;
9493             * max=RG_SCH_SRS_ISRS_INDX_MAX_FDD;
9494             break;
9495         }
9496         case RG_SCH_TDD_SRS_TBL:
9497         {
9498             table = rgSchUeSrsCfgIdxTddTbl;
9499             * min = 0;
9500             * max=RG_SCH_SRS_ISRS_INDX_MAX_TDD;
9501             break;
9502         }
9503         case RG_SCH_SR_TBL:
9504         {
9505             table = rgSchUeSrCfgIdxTbl;
9506             * min = 0;
9507             * max=RG_SCH_ISR_INDX_MAX;
9508             break;
9509         }
9510         default:
9511         {
9512             table = (const RgSchUePCqiSrsSrCfgIdxTbl *) 0;
9513             * min = 0;
9514             * max = 0;
9515             break;
9516         }
9517
9518     }
9519     return  ( table );
9520 }
9521 /* #endif */
9522 #endif /* TFU_UPGRADE */
9523
9524 /***********************************************************
9525  *
9526  *     Func : rgSCHCfgVldtDrxUeCfg
9527  *
9528  *
9529  *     Desc : Validates UE DRX Timers Configuration recieved from RRC.
9530  *
9531  *     Ret  : S16
9532  *            ROK - Success
9533  *            RFAILED - Failed
9534  *
9535  *     Notes:
9536  *
9537  *     File :
9538  *
9539  **********************************************************/
9540 #ifdef ANSI
9541 static S16 rgSCHCfgVldtDrxUeCfg
9542 (
9543 RgSchCellCb       *cell,
9544 RgrUeDrxCfg       *ueDrxCfg
9545 )
9546 #else
9547 static S16 rgSCHCfgVldtDrxUeCfg(cell, ueDrxCfg)
9548 RgSchCellCb       *cell;
9549 RgrUeDrxCfg       *ueDrxCfg;
9550 #endif
9551 {
9552
9553    if (ueDrxCfg->isDrxEnabled == FALSE)
9554    {
9555       return ROK;
9556    }
9557
9558 #ifdef LTEMAC_R9
9559    if ( ueDrxCfg->cqiMask.pres )
9560    {
9561       if ( ueDrxCfg->cqiMask.val != RGR_DRX_SETUP )
9562       {
9563 #ifdef ALIGN_64BIT
9564          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid cqiMask configuration (%d)",
9565                   ueDrxCfg->cqiMask.val);
9566 #else
9567          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid cqiMask configuration(%ld)",
9568                   ueDrxCfg->cqiMask.val);
9569 #endif
9570          return RFAILED;
9571       }
9572    }
9573 #endif /*LTEMAC_R9*/
9574 #ifdef EMTC_ENABLE
9575    if(ueDrxCfg->isEmtcUe)
9576    {
9577       if(ueDrxCfg->drxOnDurTmrR13Pres)
9578       {
9579          if ( rgSCHEmtcCfgVldtDrxOnDurCfg(ueDrxCfg->drxOnDurTmr) != ROK )
9580          {
9581             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d)",
9582                ueDrxCfg->drxOnDurTmr);
9583             return RFAILED;
9584          }
9585        }
9586          else
9587          {
9588             if (rgSCHCfgVldtDrxOnDurCfg(ueDrxCfg->drxOnDurTmr) != ROK )
9589             {
9590                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d) for EMTC",
9591                ueDrxCfg->drxOnDurTmr);
9592                return RFAILED;
9593             }
9594
9595          }
9596     }
9597    else
9598 #endif
9599    {
9600       if ( rgSCHCfgVldtDrxOnDurCfg(ueDrxCfg->drxOnDurTmr) != ROK )
9601       {
9602          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d) for EMTC",
9603                ueDrxCfg->drxOnDurTmr);
9604          return RFAILED;
9605       }
9606    }
9607
9608    if ( rgSCHCfgVldtDrxInActvCfg(ueDrxCfg->drxInactvTmr) != ROK )
9609    {
9610       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Inactivity configuration(%d)",
9611                ueDrxCfg->drxInactvTmr);
9612       return RFAILED;
9613    }
9614 #ifdef EMTC_ENABLE
9615    if(ueDrxCfg->isEmtcUe)
9616    {
9617       if(ueDrxCfg->drxRetxTmrR13Pres)
9618       {
9619          if ( rgSCHEmtcCfgVldtDrxReTxCfg(ueDrxCfg->drxRetxTmr) != ROK )
9620          {
9621             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d) for EMTC",
9622                ueDrxCfg->drxRetxTmr);
9623             return RFAILED;
9624          }
9625       }
9626          else
9627          {
9628             if (rgSCHCfgVldtDrxReTxCfg(ueDrxCfg->drxRetxTmr) != ROK )
9629             {
9630                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d)",
9631                ueDrxCfg->drxRetxTmr);
9632                return RFAILED;
9633             }
9634
9635          }
9636     }
9637    else
9638 #endif
9639    {
9640       if ( rgSCHCfgVldtDrxReTxCfg(ueDrxCfg->drxRetxTmr) != ROK )
9641       {
9642          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d)",
9643                ueDrxCfg->drxRetxTmr);
9644          return RFAILED;
9645       }
9646    }
9647 #ifdef EMTC_ENABLE
9648    if(ueDrxCfg->isEmtcUe)
9649    {
9650       if ( rgSCHEmtcCfgVldtDrxUlReTxCfg(ueDrxCfg->emtcDrxUlRetxTmr) != ROK )
9651       {
9652          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d) for EMTC",
9653                ueDrxCfg->drxRetxTmr);
9654          return RFAILED;
9655       }
9656
9657    }
9658 #endif
9659
9660    if ( rgSCHCfgVldtDrxLngCycCfg(ueDrxCfg->drxLongCycleOffst) != ROK )
9661    {
9662       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LongCycle configuration");
9663       return RFAILED;
9664    }
9665
9666    if ( ueDrxCfg->drxLongCycleOffst.longDrxCycle < ueDrxCfg->drxOnDurTmr )
9667    {
9668       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
9669               " and onDuration timer values");
9670       return RFAILED;
9671    }
9672
9673 #ifdef LTE_TDD
9674    if( rgSCHCfgVldtTddDrxCycCfg(cell, ueDrxCfg->drxLongCycleOffst.longDrxCycle,
9675        ueDrxCfg->drxOnDurTmr, ueDrxCfg->drxLongCycleOffst.drxStartOffst) != ROK)
9676    {
9677       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
9678               " and onDuration timer values");
9679       return RFAILED;
9680    }
9681 #endif
9682
9683    if( TRUE == ueDrxCfg->drxShortDrx.pres )
9684    {
9685       if ( ueDrxCfg->drxShortDrx.shortDrxCycle < ueDrxCfg->drxOnDurTmr )
9686       {
9687          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of short DRX "
9688                  "Cycle and onDuration timer values");
9689          return RFAILED;
9690       }
9691
9692       if ( (ueDrxCfg->drxLongCycleOffst.longDrxCycle %
9693                ueDrxCfg->drxShortDrx.shortDrxCycle) != 0)
9694       {
9695          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId," Long DRX cycle is not multiple of "
9696                  "short DRX cycle");
9697          return RFAILED;
9698       }
9699
9700       if ( rgSCHCfgVldtDrxShrtCycCfg(ueDrxCfg->drxShortDrx) != ROK )
9701       {
9702          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Short Cycle configuration");
9703          return RFAILED;
9704       }
9705
9706 #ifdef LTE_TDD
9707       if( rgSCHCfgVldtTddDrxCycCfg(cell, ueDrxCfg->drxShortDrx.shortDrxCycle,
9708              ueDrxCfg->drxOnDurTmr,
9709              ueDrxCfg->drxLongCycleOffst.drxStartOffst %
9710              ueDrxCfg->drxShortDrx.shortDrxCycle) != ROK)
9711       {
9712          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
9713                  " and onDuration timer values");
9714          return RFAILED;
9715       }
9716 #endif
9717    }
9718
9719    return ROK;
9720 }/*rgSCHCfgVldtDrxUeCfg*/
9721
9722 /***********************************************************
9723  *
9724  *     Func : rgSCHCfgVldtDrxOnDurCfg
9725  *
9726  *
9727  *     Desc : Validates UE DRX On Duration configuration
9728  *            recieved from RRC.
9729  *
9730  *     Ret  : S16
9731  *            ROK - Success
9732  *            RFAILED - Failed
9733  *
9734  *     Notes:
9735  *
9736  *     File :
9737  *
9738  **********************************************************/
9739 #ifdef ANSI
9740 static S16 rgSCHCfgVldtDrxOnDurCfg
9741 (
9742 uint8_t      onDurTmr
9743 )
9744 #else
9745 static S16 rgSCHCfgVldtDrxOnDurCfg(onDurTmr)
9746 uint8_t      onDurTmr;
9747 #endif
9748 {
9749
9750    switch ( onDurTmr )
9751    {
9752       case RGR_DRX_PRD_1PSF:
9753       case RGR_DRX_PRD_2PSF:
9754       case RGR_DRX_PRD_3PSF:
9755       case RGR_DRX_PRD_4PSF:
9756       case RGR_DRX_PRD_5PSF:
9757       case RGR_DRX_PRD_6PSF:
9758       case RGR_DRX_PRD_8PSF:
9759       case RGR_DRX_PRD_10PSF:
9760       case RGR_DRX_PRD_20PSF:
9761       case RGR_DRX_PRD_30PSF:
9762       case RGR_DRX_PRD_40PSF:
9763       case RGR_DRX_PRD_50PSF:
9764       case RGR_DRX_PRD_60PSF:
9765       case RGR_DRX_PRD_80PSF:
9766       case RGR_DRX_PRD_100PSF:
9767       case RGR_DRX_PRD_200PSF:
9768          break;
9769
9770       default:
9771          {
9772             return RFAILED;
9773          }
9774    }/*switch(onDurTmr)*/
9775
9776    return ROK;
9777 }/*rgSCHCfgVldtOnDurCfg*/
9778
9779 /***********************************************************
9780  *
9781  *     Func : rgSCHCfgVldtDrxInActvCfg
9782  *
9783  *
9784  *     Desc : Validates UE DRX InActivity configuration
9785  *            recieved from RRC.
9786  *
9787  *     Ret  : S16
9788  *            ROK - Success
9789  *            RFAILED - Failed
9790  *
9791  *     Notes:
9792  *
9793  *     File :
9794  *
9795  **********************************************************/
9796 #ifdef ANSI
9797 static S16 rgSCHCfgVldtDrxInActvCfg
9798 (
9799 uint16_t      inActvTmr
9800 )
9801 #else
9802 static S16 rgSCHCfgVldtDrxInActvCfg(inActvTmr)
9803 uint16_t      inActvTmr;
9804 #endif
9805 {
9806    switch ( inActvTmr )
9807    {
9808       case RGR_DRX_PRD_1PSF:
9809       case RGR_DRX_PRD_2PSF:
9810       case RGR_DRX_PRD_3PSF:
9811       case RGR_DRX_PRD_4PSF:
9812       case RGR_DRX_PRD_5PSF:
9813       case RGR_DRX_PRD_6PSF:
9814       case RGR_DRX_PRD_8PSF:
9815       case RGR_DRX_PRD_10PSF:
9816       case RGR_DRX_PRD_20PSF:
9817       case RGR_DRX_PRD_30PSF:
9818       case RGR_DRX_PRD_40PSF:
9819       case RGR_DRX_PRD_50PSF:
9820       case RGR_DRX_PRD_60PSF:
9821       case RGR_DRX_PRD_80PSF:
9822       case RGR_DRX_PRD_100PSF:
9823       case RGR_DRX_PRD_200PSF:
9824       case RGR_DRX_PRD_300PSF:
9825       case RGR_DRX_PRD_500PSF:
9826       case RGR_DRX_PRD_750PSF:
9827       case RGR_DRX_PRD_1280PSF:
9828       case RGR_DRX_PRD_1920PSF:
9829       case RGR_DRX_PRD_2560PSF:
9830          break;
9831
9832       default:
9833          {
9834             return RFAILED;
9835          }
9836    }/*switch(InactvTmr)*/
9837
9838    return ROK;
9839 }/*rgSCHCfgVldtDrxInActvCfg*/
9840
9841 /***********************************************************
9842  *
9843  *     Func : rgSCHCfgVldtDrxReTxCfg
9844  *
9845  *
9846  *     Desc : Validates DRX ReTx timer  configuration
9847  *            recieved from RRC.
9848  *
9849  *     Ret  : S16
9850  *            ROK - Success
9851  *            RFAILED - Failed
9852  *
9853  *     Notes:
9854  *
9855  *     File :
9856  *
9857  **********************************************************/
9858 #ifdef ANSI
9859 static S16 rgSCHCfgVldtDrxReTxCfg
9860 (
9861 uint8_t       reTxTmr
9862 )
9863 #else
9864 static S16 rgSCHCfgVldtDrxReTxCfg(reTxTmr)
9865 uint8_t       reTxTmr;
9866 #endif
9867 {
9868    switch ( reTxTmr )
9869    {
9870       case RGR_DRX_PRD_1PSF:
9871       case RGR_DRX_PRD_2PSF:
9872       case RGR_DRX_PRD_4PSF:
9873       case RGR_DRX_PRD_6PSF:
9874       case RGR_DRX_PRD_8PSF:
9875       case RGR_DRX_PRD_16PSF:
9876       case RGR_DRX_PRD_24PSF:
9877       case RGR_DRX_PRD_33PSF:
9878          break;
9879
9880       default:
9881          {
9882             return RFAILED;
9883          }
9884    }/*switch(drxRetxTmr)*/
9885
9886    return ROK;
9887 }/*rgSCHCfgVldtDrxReTxCfg*/
9888
9889 /***********************************************************
9890  *
9891  *     Func : rgSCHCfgVldtDrxShrtCycCfg
9892  *
9893  *
9894  *     Desc : Validates DRX Short Cycle timer  configuration
9895  *            recieved from RRC.
9896  *
9897  *     Ret  : S16
9898  *            ROK - Success
9899  *
9900  *            RFAILED - Failed
9901  *
9902  *     Notes:
9903  *
9904  *     File :
9905  *
9906  **********************************************************/
9907 #ifdef ANSI
9908 static S16 rgSCHCfgVldtDrxLngCycCfg
9909 (
9910 RgrDrxLongCycleOffst       lngCycleOffst
9911 )
9912 #else
9913 static S16 rgSCHCfgVldtDrxLngCycCfg(lngCycleOffst)
9914 RgrDrxLongCycleOffst       lngCycleOffst;
9915 #endif
9916 {
9917    if ( rgSCHCfgVldtDrxLngCyclTmrs(lngCycleOffst.longDrxCycle) != ROK )
9918    {
9919       return RFAILED;
9920    }
9921
9922    if ( lngCycleOffst.drxStartOffst >= lngCycleOffst.longDrxCycle )
9923    {
9924       return RFAILED;
9925    }
9926
9927    return ROK;
9928 }/*rgSCHCfgVldtDrxLngCycCfg*/
9929
9930 /***********************************************************
9931  *
9932  *     Func : rgSCHCfgVldtDrxLngCyclTmrs
9933  *
9934  *
9935  *     Desc : Validates DRX Long Cycle timer values
9936  *            recieved from RRC.
9937  *
9938  *     Ret  : S16
9939  *            ROK - Success
9940  *
9941  *            RFAILED - Failed
9942  *
9943  *     Notes:
9944  *
9945  *     File :
9946  *
9947  **********************************************************/
9948 #ifdef ANSI
9949 static S16 rgSCHCfgVldtDrxLngCyclTmrs
9950 (
9951 uint16_t      val
9952 )
9953 #else
9954 static S16 rgSCHCfgVldtDrxLngCyclTmrs(val)
9955 uint16_t      val;
9956 #endif
9957 {
9958
9959    switch ( val )
9960    {
9961       case RGR_DRX_PRD_10SF:
9962       case RGR_DRX_PRD_20SF:
9963       case RGR_DRX_PRD_32SF:
9964       case RGR_DRX_PRD_40SF:
9965       case RGR_DRX_PRD_64SF:
9966       case RGR_DRX_PRD_80SF:
9967       case RGR_DRX_PRD_128SF:
9968       case RGR_DRX_PRD_160SF:
9969       case RGR_DRX_PRD_256SF:
9970       case RGR_DRX_PRD_320SF:
9971       case RGR_DRX_PRD_512SF:
9972       case RGR_DRX_PRD_640SF:
9973       case RGR_DRX_PRD_1024SF:
9974       case RGR_DRX_PRD_1280SF:
9975       case RGR_DRX_PRD_2048SF:
9976       case RGR_DRX_PRD_2560SF:
9977          break;
9978
9979       default:
9980          {
9981             return RFAILED;
9982          }
9983    }/*switch(longDrxCycle)*/
9984
9985    return ROK;
9986 }/*rgSCHCfgVldtDrxLngCyclTmrs*/
9987
9988 /***********************************************************
9989  *
9990  *     Func : rgSCHCfgVldtDrxShrtCycCfg
9991  *
9992  *
9993  *     Desc : Validates DRX Short Cycle timer  configuration
9994  *            recieved from RRC.
9995  *
9996  *     Ret  : S16
9997  *            ROK - Success
9998  *
9999  *            RFAILED - Failed
10000  *
10001  *     Notes:
10002  *
10003  *     File :
10004  *
10005  **********************************************************/
10006 #ifdef ANSI
10007 static S16 rgSCHCfgVldtDrxShrtCycCfg
10008 (
10009 RgrDrxShortDrx      shrtCycCfg
10010 )
10011 #else
10012 static S16 rgSCHCfgVldtDrxShrtCycCfg(shrtCycCfg)
10013 RgrDrxShortDrx      shrtCycCfg;
10014 #endif
10015 {
10016    switch(shrtCycCfg.shortDrxCycle)
10017    {
10018       case RGR_DRX_PRD_2SF:
10019       case RGR_DRX_PRD_5SF:
10020       case RGR_DRX_PRD_8SF:
10021       case RGR_DRX_PRD_10SF:
10022       case RGR_DRX_PRD_16SF:
10023       case RGR_DRX_PRD_20SF:
10024       case RGR_DRX_PRD_32SF:
10025       case RGR_DRX_PRD_40SF:
10026       case RGR_DRX_PRD_64SF:
10027       case RGR_DRX_PRD_80SF:
10028       case RGR_DRX_PRD_128SF:
10029       case RGR_DRX_PRD_160SF:
10030       case RGR_DRX_PRD_256SF:
10031       case RGR_DRX_PRD_320SF:
10032       case RGR_DRX_PRD_640SF:
10033          break;
10034
10035       default:
10036          {
10037             return RFAILED;
10038          }
10039
10040    }/*switch(shortDrxCycle)*/
10041
10042    if ( (shrtCycCfg.drxShortCycleTmr < RGR_DRX_SHRTCYCLE_MIN) ||
10043          (shrtCycCfg.drxShortCycleTmr > RGR_DRX_SHRTCYCLE_MAX)
10044       )
10045    {
10046       return RFAILED;
10047    }
10048
10049    return ROK;
10050 }
10051
10052 /**
10053  * @brief Handler for TA related UE Reconfiguration.
10054  *
10055  * @details
10056  *
10057  *     Function : rgSCHCfgUeTaRecfg
10058  *
10059  *     This function shall fetch the TA timer related information into the
10060  *     respective ueCb from the UE configuration as provided by the
10061  *     upper layers.
10062  *
10063  *  @param[in]  RgSchCellCb   *cell
10064  *  @param[in]  RgSchUeCb     *ueCb
10065  *  @param[in]  RgrUeCfg      *ueCfg
10066  *  @param[out] RgSchErrInfo  *errInfo
10067  *  @return     S16
10068  *      -# ROK
10069  *      -# RFAILED
10070  **/
10071 #ifdef ANSI
10072 static Void rgSCHCfgUeTaRecfg
10073 (
10074 RgSchCellCb       *cell,
10075 RgSchUeCb         *ueCb,
10076 RgrUeRecfg        *ueCfg,
10077 RgSchErrInfo      *err
10078 )
10079 #else
10080 static Void rgSCHCfgUeTaRecfg(cell, ueCb, ueCfg, err)
10081 RgSchCellCb       *cell;
10082 RgSchUeCb         *ueCb;
10083 RgrUeRecfg        *ueCfg;
10084 RgSchErrInfo      *err;
10085 #endif
10086 {
10087    UNUSED(err);
10088
10089    /* Update the TA related information */
10090
10091    if (ueCfg->ueTaTmrRecfg.pres)
10092    {
10093       /* Configuring taTmr with 30 deficit, to enable eNodeB sending
10094        * TA command before the expiry of TA at UE. Also considering for
10095        * possible retx for this TA command */
10096       /* [ccpu00121813]-ADD-Added chk if tatmr val > 30 */
10097       if(ueCfg->ueTaTmrRecfg.taTmr > 30)
10098       {
10099          ueCb->dl.taCb.cfgTaTmr = ueCfg->ueTaTmrRecfg.taTmr - 30;
10100       }
10101        /* If TA Timer is running. Stop it and then start it*/
10102       if (ueCb->taTmr.tmrEvnt != TMR_NONE)
10103       {
10104          rgSCHTmrStopTmr(cell, ueCb->taTmr.tmrEvnt, ueCb);
10105          rgSCHTmrStartTmr(cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
10106       }
10107       else
10108       {
10109          rgSCHTmrStartTmr(cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
10110       }
10111    }
10112    return;
10113 }  /* rgSCHCfgUeTaRecfg */
10114
10115 /* ccpu00117452 - MOD - Changed macro name from
10116    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
10117 #if ((defined (RGR_CQI_REPT)) && (defined (RGR_V2)))
10118 /***********************************************************
10119  *
10120  *     Func : rgSCHCfgUeCqiReptReCfg
10121  *
10122  *
10123  *     Desc : Reconfiguration of PUSH N CQI Reporting
10124  *
10125  *     Ret  : RFAILED in case of failure
10126  *            ROK if success
10127  *
10128  *     Notes:
10129  *
10130  *     File :
10131  *
10132  **********************************************************/
10133 #ifdef ANSI
10134 static S16 rgSCHCfgUeCqiReptReCfg
10135 (
10136 RgSchCellCb    *cell,
10137 RgSchUeCb      *ue,
10138 RgrUeRecfg     *ueRecfg
10139 )
10140 #else
10141 static  S16 rgSCHCfgUeCqiReptReCfg(cell, ue, ueRecfg)
10142 RgSchCellCb    *cell;
10143 RgSchUeCb      *ue;
10144 RgrUeRecfg     *ueRecfg;
10145 #endif
10146 {
10147    S16 retVal;
10148
10149    /* Check has it been disabled */
10150    if(ueRecfg->ueCqiReptCfg.numColltdCqiRept)
10151    {
10152     /* Check if we need to send CQI reports collagted so far and send if so */
10153       if(ue->schCqiInfo.cqiCount >=
10154               ueRecfg->ueCqiReptCfg.numColltdCqiRept)
10155       {
10156          RgrStaIndInfo *staInfo;
10157       /* if yes, Send StaInd to RRM */
10158          retVal = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&staInfo,
10159                   sizeof(RgrStaIndInfo));
10160          if(retVal != ROK)
10161          {
10162             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
10163                "Could not allocate memory for sending StaInd OLD CRNTI:%d",ueRecfg->oldCrnti);
10164             return (retVal);
10165          }
10166
10167       /* Fill StaInd for sending collated N CQI rpeort                        */
10168          rgSCHUtlFillSndStaInd(cell, ue, staInfo,
10169                ueRecfg->ueCqiReptCfg.numColltdCqiRept);
10170       }
10171    }
10172    else
10173    {
10174       ue->schCqiInfo.cqiCount = 0;
10175    }
10176
10177    ue->cqiReptCfgInfo.numColltdCqiRept =
10178       ueRecfg->ueCqiReptCfg.numColltdCqiRept;
10179    return ROK;
10180 } /* End of rgSCHCfgUeCqiReptReCfg */
10181 #endif /* End of RGR_CQI_REPT */
10182 /*This function Added Ue in ongoing L2 Meas*/
10183 /*LTE_L2_MEAS_PHASE2*/
10184 #ifdef LTE_L2_MEAS
10185 static S16 rgSchAddToL2Meas(RgSchCellCb *cellCb,RgSchDlLcCb *dlLc)
10186 {
10187    CmLList             *lnk;
10188    uint16_t       idx;
10189    RgSchL2MeasCb       *measCb = NULLP;
10190    lnk = cellCb->l2mList.first;
10191
10192    while(lnk != NULLP)
10193    {
10194       /* Get the MeasCb : RgSchL2MeasCb */
10195       measCb = (RgSchL2MeasCb *)lnk->node;
10196       if (measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
10197       {
10198          for(idx = 0;idx < measCb->measReq.avgPrbQciDl.numQci;idx++)
10199          {
10200             if(measCb->measReq.avgPrbQciDl.qci[idx] == dlLc->qciCb->qci)
10201             {
10202                break; /*exit from for loop*/
10203             }
10204          }
10205          if(idx  == measCb->measReq.avgPrbQciDl.numQci)
10206          {
10207             measCb->measReq.avgPrbQciDl.qci[measCb->measReq.avgPrbQciDl.numQci++] = dlLc->qciCb->qci;
10208          }
10209       }
10210       lnk = lnk->next;
10211    }/*End of while loop*/
10212
10213    return ROK;
10214 }
10215 #endif
10216 #ifdef LTE_ADV
10217 /**
10218  * @brief UE SCell Buffer Free
10219  *
10220  * @details
10221  *
10222  *     Function : rgSCHSCellFreeBuf
10223  *
10224  *     This functions will free allocated memory
10225  *     for UE secondart cellCB
10226  *
10227  *
10228  *  @param[in]  Inst         inst
10229  *  @param[in]  RgSchUeCb    *ue
10230  *  @param[int] RgrUeRecfg   *ueRecfg
10231  *  @param[out] uint8_t           idx
10232  *  @return  VOID
10233  **/
10234 #ifdef ANSI
10235 Void rgSCHSCellFreeBuf
10236 (
10237 Inst         inst,
10238 RgSchUeCb    *ue,
10239 RgrUeRecfg   *ueRecfg,
10240 uint8_t           idx
10241 )
10242 #else
10243 Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
10244 Inst         inst;
10245 RgSchUeCb    *ue;
10246 RgrUeRecfg   *ueRecfg;
10247 uint8_t           idx;
10248 #endif
10249 {
10250    RgSchUeCellInfo *sCellInfo = NULLP;
10251    RgrUeSecCellCfg *sCellInfoRecfg = NULLP;
10252
10253
10254    for(uint8_t i = 0; i <= idx; i++)
10255    {
10256       sCellInfoRecfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[i];
10257       sCellInfo = ue->cellInfo[(sCellInfoRecfg->sCellIdx)];
10258
10259       if (NULLP != sCellInfo)
10260       {
10261          rgSCHUtlFreeSBuf(inst, (Data**)&(sCellInfo),
10262                sizeof(RgSchUeCellInfo));
10263          ue->cellInfo[(sCellInfoRecfg->sCellIdx)] = NULLP;
10264
10265       }
10266    }
10267    return;
10268 }
10269 #endif
10270 /**********************************************************************
10271
10272          End of file
10273 **********************************************************************/