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