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