src/5gnrmac/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 >= RGSCH_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(RGR_SCH_TYPE_PFS == schedEnbCfg->dlSchdType)
2676    {
2677      rgSCHEnbPfsDlCfg(inst, errInfo);
2678    }
2679
2680    errInfo->errCause = RGSCHERR_NONE;
2681    RGSCHDBGINFO(inst, (rgSchPBuf(inst), "RGR SCH ENBconfig done: \n"));
2682    RETVALUE(ROK);
2683 }  /* rgSCHCfgRgrSchedEnbCfg */
2684
2685 #ifdef RG_5GTF
2686 /**
2687  * @brief Handler for the cell configuration of 5gtf.
2688  *
2689  * @details
2690  *
2691  *     Function : rgSCH5gtfCellCfg
2692  *
2693  *  @param[in]  RgSchCellCb   *cell
2694  *  @param[in]  RgSchCellCfg    *cellCfg
2695  *  @return  S16
2696  *      -# ROK
2697  *      -# RFAILED
2698  **/
2699 #ifdef ANSI
2700 PUBLIC S16 rgSCH5gtfCellCfg
2701 (
2702 RgSchCellCb   *cell,
2703 RgrCellCfg    *cellCfg
2704 )
2705 #else
2706 PUBLIC S16 rgSCH5gtfCellCfg(cell, cellCfg)
2707 RgSchCellCb   *cell;
2708 RgrCellCfg    *cellCfg;
2709 #endif
2710 {
2711    U8           idx;
2712
2713    TRC2(rgSCHCfgRgrCellCfg);
2714
2715    for(idx = 0; idx < MAX_5GTF_GROUP; idx++)
2716    {
2717       cell->cell5gtfCb.ueGrp5gConf[idx].beamBitMask = 0;
2718    }
2719
2720    for(idx = 0 ; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
2721    {
2722       cell->cell5gtfCb.dynConfig[idx] = cellCfg->Cell5gtfCfg.dynConfig[idx];
2723    }
2724    cell->cell5gtfCb.numUes = cellCfg->Cell5gtfCfg.numUes;
2725    cell->cell5gtfCb.uePerGrpPerTti = cellCfg->Cell5gtfCfg.uePerGrp;
2726    cell->cell5gtfCb.ueGrpPerTti = cellCfg->Cell5gtfCfg.ueGrpPerTti;
2727    cell->cell5gtfCb.numCCs = cellCfg->Cell5gtfCfg.numOfCC;
2728    cell->cell5gtfCb.bwPerCC = cellCfg->Cell5gtfCfg.bwPerCC;
2729    printf("\ncell cfg at schd,numUes:%u,uepergrp:%u,uegrppertti:%u,numCC:%u,bwPerc:%u cfi %u\n",
2730          cell->cell5gtfCb.numUes,cell->cell5gtfCb.uePerGrpPerTti,cell->cell5gtfCb.ueGrpPerTti,
2731          cell->cell5gtfCb.numCCs,cell->cell5gtfCb.bwPerCC, cell->cell5gtfCb.cfi);
2732    RETVALUE(ROK);
2733 }
2734 #endif
2735
2736 #ifdef XEON_LMT_ITBS
2737 EXTERN U16 gWrMaxDlItbs;
2738 EXTERN U16 gWrMaxUlItbs;
2739 #endif
2740 /**
2741  * @brief Handler for the cell configuration request from RRM to MAC.
2742  *
2743  * @details
2744  *
2745  *     Function : rgSCHCfgRgrCellCfg
2746  *
2747  *     Processing Steps:
2748  *      - Invoke SCH with cell control block to update
2749  *        scheduler specific information.
2750  *      - Update cell control block with the values recieved in the
2751  *        configuration.
2752  *      - Add to the active list of cells if cell becomes ACTIVE.
2753  *      - If successful, return ROK else RFAILED.
2754  *
2755  *  @param[in]  RgSchCb      *instCb
2756  *  @param[in]  SpId         spId
2757  *  @param[in]  RgSchCellCfg    *cellCfg
2758  *  @param[out] RgSchErrInfo *errInfo
2759  *  @return  S16
2760  *      -# ROK
2761  *      -# RFAILED
2762  **/
2763 #ifdef ANSI
2764 PUBLIC S16 rgSCHCfgRgrCellCfg
2765 (
2766 RgSchCb       *instCb,
2767 SpId          spId,
2768 RgrCellCfg    *cellCfg,
2769 RgSchErrInfo  *errInfo
2770 )
2771 #else
2772 PUBLIC S16 rgSCHCfgRgrCellCfg(instCb, spId, cellCfg, errInfo)
2773 RgSchCb       *instCb;
2774 SpId           spId;
2775 RgrCellCfg    *cellCfg;
2776 RgSchErrInfo  *errInfo;
2777 #endif
2778 {
2779    S16          ret;
2780    U8           idx;
2781    Pst          pst;
2782    RgInfCellReg cellRegReq;
2783    RgSchCellCb  *cell = NULLP;
2784    Inst         inst = instCb->rgSchInit.inst;
2785    U32          Idx1 = (U8)((cellCfg->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
2786
2787    TRC2(rgSCHCfgRgrCellCfg);
2788
2789    errInfo->errCause = RGSCHERR_CFG_RGR_CELL_CFG;
2790
2791    cmMemset((U8*)&pst, (U8)0, sizeof(Pst));
2792
2793    /* Allocate the scheduler's cell control block */
2794    if((ret = rgSCHUtlAllocSBuf(inst, (Data**)&cell, sizeof(RgSchCellCb)))
2795          != ROK)
2796    {
2797       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
2798       RETVALUE(RFAILED);
2799    }
2800 #ifdef EMTC_ENABLE
2801    if(cellCfg->emtcEnable)
2802    {
2803       if((ret = rgSCHEmtcCellAlloc(cell))
2804             != ROK)
2805       {
2806          RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for emtc cell");
2807          RETVALUE(RFAILED);
2808       }
2809    }
2810 #endif
2811    if ((U8 *)cell == NULLP)
2812    {
2813       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
2814       RETVALUE(RFAILED);
2815    }
2816    /* Initialize the lists of the cell */
2817    ret = rgSCHDbmInitCell(cell);
2818    if (ret != ROK)
2819    {
2820       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization FAILED for cell");
2821       rgSCHCfgFreeCellCb(cell);
2822       RETVALUE(RFAILED);
2823    }
2824 /* LTE_ADV_FLAG_REMOVED_START */
2825    if(cellCfg->rgrLteAdvCfg.pres & RGR_ABS)
2826    {
2827       cell->lteAdvCb.absCfg =
2828          cellCfg->rgrLteAdvCfg.absCfg;
2829       cmMemset((U8*)cell->lteAdvCb.absLoadInfo, 0, sizeof(U32)*RGR_ABS_PATTERN_LEN);
2830       cell->lteAdvCb.absLoadTtiCnt = 0;
2831    }
2832
2833    if(cellCfg->rgrLteAdvCfg.pres & RGR_SFR)
2834    {
2835       cell->lteAdvCb.sfrCfg =
2836          cellCfg->rgrLteAdvCfg.sfrCfg;
2837    }
2838    if(cellCfg->rgrLteAdvCfg.pres & RGR_DSFR)
2839    {
2840       cell->lteAdvCb.dsfrCfg =
2841          cellCfg->rgrLteAdvCfg.dsfrCfg;
2842    }
2843 /* LTE_ADV_FLAG_REMOVED_END */
2844
2845 #ifdef EMTC_ENABLE
2846    cell->emtcEnable = cellCfg->emtcEnable;
2847 #endif
2848    /* Initialize the cell */
2849    cell->cellId = cellCfg->cellId;
2850    cell->instIdx = inst;
2851    cell->macInst = cellCfg->macInst;
2852    cell->isCpUlExtend = cellCfg->isCpUlExtend;
2853    cell->isCpDlExtend = cellCfg->isCpDlExtend;
2854
2855    cell->numTxAntPorts = rgSchCb[inst].rgrSchedEnbCfg.numTxAntPorts;
2856    if(cell->numTxAntPorts == 1)
2857    {
2858       cell->numCellRSPerSf = RGSCH_NUM_CELL_RS_ONE_ANT_PORT;
2859    }
2860    else if(cell->numTxAntPorts == 2)
2861    {
2862       cell->numCellRSPerSf = RGSCH_NUM_CELL_RS_TWO_ANT_PORT;
2863    }
2864    else
2865    {
2866       cell->numCellRSPerSf = RGSCH_NUM_CELL_RS_FOUR_ANT_PORT;
2867    }
2868    cell->bwCfg = cellCfg->bwCfg;
2869    cell->pbchRbStart = ((((cell->bwCfg.dlTotalBw * 12)/2) - 36)/12); /* Ref section 6.6 in 36.211 */
2870    cell->pbchRbEnd = cell->pbchRbStart + 5;
2871    cell->pucchCfg = cellCfg->pucchCfg;
2872    cell->rachCfg = cellCfg->rachCfg;
2873    cell->siCfg = cellCfg->siCfg;
2874    cell->t300TmrVal = cellCfg->t300TmrVal;
2875 #ifdef RGR_SI_SCH
2876    /*Initialize the SI CB in Cell CB */
2877    cmMemset((U8 *)&cell->siCb, 0, sizeof(RgSchSiCb));
2878 #endif
2879    /*Fix: Added Guard Pool for RNTI which will contain RNTIs
2880        *for UEs deleted from Scheduler but not yet from MAC*/
2881    cmLListInit(&cell->rntiDb.rntiGuardPool);
2882
2883    /* Initialize the inWindow to sync with scheduler time when ticks starts */
2884 #ifdef LTEMAC_HDFDD
2885       cell->siCb.inWindow = (cellCfg->siCfg.siWinSize -
2886             (RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL));
2887 #else
2888       cell->siCb.inWindow = (cellCfg->siCfg.siWinSize -
2889             (RG_SCH_CMN_DL_DELTA));
2890 #endif
2891
2892       if(cell->siCb.inWindow < 0)
2893       {
2894          cell->siCb.inWindow = 0;
2895       }
2896    cell->macPreambleSet = cellCfg->macPreambleSet;
2897    cell->phichCfg = cellCfg->phichCfg;
2898
2899    /* Initialize UL and DL CCCH logical channels */
2900    cell->ulCcchId = RGSCH_INVALID_LC_ID;
2901    cell->dlCcchId = RGSCH_INVALID_LC_ID;
2902
2903    /* Update SRS configuration */
2904    cell->srsCfg.isSrsCfgPres = cellCfg->srsCfg.isSrsCfgSetup;
2905    if(cellCfg->srsCfg.isSrsCfgSetup)
2906    {
2907       cell->srsCfg.srsCfgPrdEnum = cellCfg->srsCfg.srsCfgPrdEnum;
2908       cell->srsCfg.srsBwEnum = cellCfg->srsCfg.srsBwEnum;
2909       cell->srsCfg.srsTxOffst =
2910          rgSrsTxOffstTbl[cellCfg->srsCfg.srsSubFrameCfg];
2911       /*ccpu00116923 - ADD - Srs Present support */
2912 #ifdef TFU_UPGRADE
2913       cell->srsCfg.srsSubFrameCfg = cellCfg->srsCfg.srsSubFrameCfg;
2914 #endif
2915    }
2916
2917    /* Configure all the common logical channels for the cell */
2918    for(idx = 0; idx < cellCfg->numCmnLcs; idx++)
2919    {
2920       /* This never returns failure and hence not checked for */
2921       rgSCHCfgRgrCmnLcCfg(cell, &(cellCfg->cmnLcCfg[idx]), errInfo);
2922    }
2923
2924    /* Invoke the MeasGap and ACK NACK Rep handler for cell cfg */
2925
2926    /* Dynamic CFI cell configuration */
2927    ret = rgSCHDynCfiCfg(cell, cellCfg);
2928    if(ret != ROK)
2929    {
2930       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr cell Config failed at "
2931        "Scheduler for cell");
2932       rgSCHCfgFreeCellCb(cell);
2933       RETVALUE(RFAILED);
2934    }
2935    /* Updating Auto TM Mode enable/diable flag */
2936    cell->isAutoCfgModeEnb = cellCfg->isAutoCfgModeEnb;
2937    {
2938      if(cell->isAutoCfgModeEnb)
2939      {
2940         RLOG0(L_INFO,"Auto Mode Cfg enabled durint cell cfg\n");
2941      }
2942    }
2943    /* CPU OvrLoad State Initialization */
2944 #ifdef XEON_LMT_ITBS
2945    cell->thresholds.maxDlItbs = gWrMaxDlItbs;
2946    cell->thresholds.maxUlItbs = gWrMaxUlItbs;
2947    RLOG2(L_INFO,"LIMIT DL and UL ITBS %d:%d \n",gWrMaxDlItbs,gWrMaxUlItbs);
2948 #else
2949    cell->thresholds.maxDlItbs = RG_SCH_DL_MAX_ITBS;
2950    cell->thresholds.maxUlItbs = RG_SCH_UL_MAX_ITBS;
2951 #endif
2952    cell->measurements.dlTpt = 0;
2953    cell->measurements.ulTpt = 0;
2954    cell->measurements.dlBytesCnt = 0;
2955    cell->measurements.ulBytesCnt = 0;
2956    cell->cpuOvrLdCntrl.cpuOvrLdIns = 0; /* 0 - No command */
2957    cell->cpuOvrLdCntrl.dlNxtIndxDecNumUeTti = 0;
2958    cell->cpuOvrLdCntrl.ulNxtIndxDecNumUeTti = 0;
2959    for ( idx = 0; idx < 10; idx++ )
2960    {
2961       cell->cpuOvrLdCntrl.maxUeNewTxPerTti[idx] = cellCfg->maxDlUeNewTxPerTti;
2962       cell->cpuOvrLdCntrl.maxUeNewRxPerTti[idx] = cellCfg->maxUlUeNewTxPerTti;
2963    }
2964
2965    /* Invoke scheduler to update scheduler specific information */
2966    ret =  rgSCHUtlRgrCellCfg(cell, cellCfg, errInfo);
2967    if (ret != ROK)
2968    {
2969       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr cell Config failed at "
2970        "Scheduler for cell ");
2971       rgSCHCfgFreeCellCb(cell);
2972       RETVALUE(RFAILED);
2973    }
2974
2975    /* Invoke DHM to update DHM specific information */
2976    rgSCHDhmRgrCellCfg(cell, cellCfg, errInfo);
2977
2978
2979    /* Initialize RNTI DB */
2980    ret = rgSCHDbmRntiDbInit(cell, cellCfg->macRnti.startRnti,
2981          cellCfg->macRnti.size);
2982    if (ret != ROK)
2983    {
2984       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr Cell Config failed at"
2985           " RNTI DB init for cell");
2986       rgSCHCfgFreeCellCb(cell);
2987       RETVALUE(RFAILED);
2988    }
2989
2990    /* Update the cell with recieved configuration */
2991    cell->dlHqCfg  =  cellCfg->dlHqCfg;
2992
2993    RLOG1(L_INFO,"Config DL HQTX = %d\n",cell->dlHqCfg.maxDlHqTx);
2994
2995    cell->crntSfIdx = 0;
2996    /* Allocate the subframe allocation information */
2997    if((ret = rgSCHUtlGetSfAlloc(cell)) != ROK)
2998    {
2999       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for "
3000                "cell");
3001       rgSCHCfgFreeCellCb(cell);
3002       RETVALUE(RFAILED);
3003    }
3004    /* Update RACH Related information
3005     * XXX: Below function yet to be written in RAM
3006     * To store the preambles given in  the configuration for PDCCH order in the
3007     * scheduler cell control block. Initialize the PRACH Mask Index allocated
3008     * for these preambles to invalid values */
3009
3010    cell->crntHqIdx = 0;
3011    /* Allocate the subframe allocation information */
3012    if((ret = rgSCHUtlGetRlsHqAlloc(cell)) != ROK)
3013    {
3014       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for"
3015                "cell");
3016       rgSCHCfgFreeCellCb(cell);
3017       RETVALUE(RFAILED);
3018    }
3019
3020    /* Associate a pair of upper and lower sapCbs with this cell */
3021    instCb->rgrSap[spId].cell = cell;
3022    instCb->tfuSap[spId].cell = cell;
3023    instCb->rgmSap[spId].cell = cell;
3024    cell->tfuSap = &(instCb->tfuSap[spId]);
3025
3026    /* CaDev Start */
3027       instCb->cells[Idx1] = cell;
3028    /* CaDev End */
3029
3030    /* rg001.201: Added for sending TTI tick to RRM */
3031 #if (defined(RGR_RRM_TICK) || defined(RGR_CQI_REPT))
3032    /* Associate the RGR SAP as well utilized while sending TTI
3033     * Ticks to RGR User. */
3034    cell->rgrSap = &(instCb->rgrSap[spId]);
3035 #endif
3036    cell->rgmSap = &(instCb->rgmSap[spId]);
3037 #ifdef RGR_RRM_TICK
3038    /* Store the periodicity configured */
3039    cell->rrmTtiIndPrd = cellCfg->rrmTtiIndPrd;
3040 #endif
3041
3042 #ifdef LTE_L2_MEAS
3043    cmLListInit(&cell->l2mList);
3044 #endif
3045
3046    if (rgSCHDrxCellCfg(cell,cellCfg) != ROK)
3047    {
3048       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Drx Memory allocation FAILED for"
3049          " cell");
3050       rgSCHCfgFreeCellCb(cell);
3051       RETVALUE(RFAILED);
3052    }
3053    cell->overLoadBackOffEnab = FALSE;/* Disabling RachOverload by default */
3054    /* Updating CSG Parameters */
3055    cell->minDlResNonCsg = cellCfg->csgParamCfg.minDlResNonCsg;
3056    cell->minUlResNonCsg = cellCfg->csgParamCfg.minUlResNonCsg;
3057
3058    /* Register the cell with MAC */
3059    rgSCHUtlGetPstToLyr(&pst, instCb, cell->macInst);
3060    cellRegReq.cellId = cell->cellId;
3061    cellRegReq.cellSapId = spId;
3062 #ifdef LTE_TDD
3063    cellRegReq.maxDlHqProcPerUe = rgSchTddDlNumHarqProcTbl[cellCfg->ulDlCfgIdx];
3064 #else
3065    cellRegReq.maxDlHqProcPerUe = RGSCH_MAX_DL_HQ_PROC;
3066 #endif
3067    RgSchMacCellReg(&pst, &cellRegReq);
3068
3069 #ifdef TENB_STATS
3070    cell->tenbStats = TSL2AllocCellStatsBlk(cell->cellId);
3071    cell->tenbStats->cellId = cell->cellId;
3072 #endif
3073
3074    rgSCHUtlCalcDciSizes(cell);
3075
3076 #ifdef LTE_ADV
3077    /* Initilalization of the list of UE for which this cell is secondary cell*/
3078    cmLListInit(&cell->sCellUeLst);
3079 #endif
3080
3081
3082 #ifdef LTE_ADV
3083    ret = rgSCHLaaSCellCbInit(cell, cellCfg);
3084    if (ret != ROK)
3085    {
3086       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Rgr Cell Config failed at"
3087           " Initializing the LAA Cell Control Cb");
3088       rgSCHCfgFreeCellCb(cell);
3089       RETVALUE(RFAILED);
3090    }
3091    cell->isPucchFormat3Sptd = cellCfg->isPucchFormat3Sptd;
3092    RLOG_ARG0(L_INFO,DBG_CELLID,cellCfg->cellId,"Format 3 is Enabled");
3093    printf ("\n Format 3 is Enabled for CELL:%d",cell->cellId);
3094 #endif
3095
3096
3097 #ifdef EMTC_ENABLE
3098
3099         if(cell->emtcEnable)
3100         {
3101           if (rgSCHCfgEmtcCellCfg(cell,&(cellCfg->emtcCellCfg)) != ROK)
3102           {
3103                  RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"EMTC Config Failed"
3104                                           " cell");
3105                  RETVALUE(RFAILED);
3106           }
3107         }
3108 #endif
3109
3110 #ifdef RG_5GTF
3111    ret = rgSCH5gtfCellCfg(cell, cellCfg);
3112    if (ret != ROK)
3113    {
3114       RLOG_ARG0(L_ERROR, DBG_CELLID,cellCfg->cellId,"5GTF Rgr Cell Config failed");
3115       rgSCHCfgFreeCellCb(cell);
3116       RETVALUE(RFAILED);
3117    }
3118 #endif
3119    errInfo->errCause = RGSCHERR_NONE;
3120    RETVALUE(ROK);
3121 }  /* rgSCHCfgRgrCellCfg */
3122
3123 /**
3124  * @brief Handler for the UE configuration request from RRC to MAC.
3125  *
3126  * @details
3127  *
3128  *     Function : rgSCHCfgRgrUeCfg
3129  *
3130  *     Processing Steps:
3131  *      - Allocate and create UE control block.
3132  *      - Update UE control block with the values recieved in the
3133  *        configuration.
3134  *      - Invoke RAM, SCH, UHM and DHM with created UE control block, to
3135  *        update random access, scheduler, uplink harq and downlink harq
3136  *        specific information respectively.
3137  *      - If successful, add the control block to hash list of UEs for the cell
3138  *        else Rollback and FAIL.
3139  *
3140  *  @param[in]  RgSchCellCb  *cell
3141  *  @param[in]  RgrUeCfg     *ueCfg
3142  *  @param[out] RgSchErrInfo *errInfo
3143  *  @return  S16
3144  *      -# ROK
3145  *      -# RFAILED
3146  **/
3147 #ifdef ANSI
3148 PUBLIC S16 rgSCHCfgRgrUeCfg
3149 (
3150 RgSchCellCb  *cell,
3151 RgrUeCfg     *ueCfg,
3152 RgSchErrInfo *errInfo
3153 )
3154 #else
3155 PUBLIC S16 rgSCHCfgRgrUeCfg(cell, ueCfg, errInfo)
3156 RgSchCellCb  *cell;
3157 RgrUeCfg     *ueCfg;
3158 RgSchErrInfo *errInfo;
3159 #endif
3160 {
3161    S16          ret;
3162    RgSchRaCb    *raCb=NULLP;
3163    RgSchUeCb    *ue = NULLP;
3164    Inst         inst = cell->instIdx;
3165    U32          lcgCnt;
3166    RgSchDlHqEnt *hqEnt = NULLP;
3167 #ifdef LTE_TDD
3168    U8           ulDlCfgIdx = cell->ulDlCfgIdx;
3169    U8           maxSubframes ;
3170    U8           maxDlSubframes;
3171 #endif
3172    U32          idx = 0;
3173 #ifdef TFU_UPGRADE
3174    RgSchUePCqiCb *cqiCb = NULLP;
3175 #endif
3176    TRC2(rgSCHCfgRgrUeCfg);
3177
3178   do {
3179      errInfo->errCause = RGSCHERR_CFG_RGR_UE_CFG;
3180      /* RACHO : Check for raCb only if preamble Id not provded */
3181 #ifndef PRE_DEF_UE_CTX
3182      if (ueCfg->dedPreambleId.pres == NOTPRSNT)
3183      {
3184         if ((raCb = rgSCHDbmGetRaCb(cell, ueCfg->crnti)) == NULLP)
3185         {
3186            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"No RaCb exists for"
3187                     "CRNTI:%d ",ueCfg->crnti);
3188            break;
3189         }
3190      }
3191 #endif
3192
3193      /* Allocate the Ue control block */
3194      if (((rgSCHUtlAllocSBuf(inst, (Data **)&ue, sizeof(RgSchUeCb))) != ROK) ||
3195             ((U8 *)ue == NULLP))
3196      {
3197         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId, "Memory allocation"
3198            " FAILED for CRNTI:%d", ueCfg->crnti);
3199         break;
3200      }
3201
3202      /* Inititialize Ue control block */
3203      ue->ueId = ueCfg->crnti;
3204      ue->cell = cell;
3205      /*ccpu00117778- Initialize Transmission Indices upon UE CB creation */
3206 #ifdef LA
3207    ue->lastRprdAckNackTime.sfn = cell->crntTime.sfn;
3208    ue->lastRprdAckNackTime.subframe = cell->crntTime.subframe;
3209    ue->ueIdle = FALSE;
3210 #endif
3211
3212    /* Allocate the Ue control block */
3213    if (((rgSCHUtlAllocSBuf(inst, (Data **)&(ue->cellInfo[RGSCH_PCELL_INDEX]),
3214                   sizeof(RgSchUeCellInfo))) != ROK))
3215    {
3216 #ifndef ALIGN_64BIT
3217       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%lu]SCellIdx :Memomy allocation "
3218                "Failed while Adding SCell Information\n", idx));
3219 #else
3220       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%u]SCellIdx :Memomy allocation "
3221                "Failed while Adding SCell Information\n", idx));
3222 #endif
3223       RETVALUE(RFAILED);
3224    }
3225
3226    ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)] = RGSCH_PCELL_INDEX;
3227    ue->cellInfo[RGSCH_PCELL_INDEX]->cell = cell;
3228    ue->cellInfo[RGSCH_PCELL_INDEX]->ue = ue;
3229 #ifdef LTE_ADV
3230    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellState = RG_SCH_SCELL_ACTIVE;
3231    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellIdx = RGSCH_PCELL_INDEX;
3232    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellId = cell->cellId;
3233
3234    if (ROK != rgSCHLaaInitDlRbAllocCb(cell,
3235             &ue->cellInfo[RGSCH_PCELL_INDEX]->dlAllocCb))
3236    {
3237       RETVALUE(RFAILED);
3238    }
3239 #endif
3240 #ifdef TFU_UPGRADE
3241      cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
3242      cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
3243      cqiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
3244      ue->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
3245      ue->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
3246 #endif
3247    /* LTE_ADV_FLAG_REMOVED_START */
3248    /* While doing UE configuration for SFR at SCH, by default
3249     * CC UE power is configured as LOW */
3250    ue->lteAdvUeCb.isCCUePHigh = FALSE;
3251    /* LTE_ADV_FLAG_REMOVED_END */
3252
3253      /* Initialize the lists of the UE */
3254      if((rgSCHDbmInitUe(ue)) != ROK)
3255      {
3256         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"DBM initialization "
3257            "failed for CRNTI:%d", ueCfg->crnti);
3258         break;
3259      }
3260 #ifdef EMTC_ENABLE
3261      if(raCb != NULLP)
3262      {
3263         if(TRUE == raCb->isEmtcRaCb)
3264         {
3265            ue->isEmtcUe = TRUE;
3266            if (rgSCHUtlUpdUeEmtcInfo(cell, ueCfg, ue) != ROK)
3267            {
3268               RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"EMTC UE Cfg"
3269                     "failed for CRNTI:%d", ueCfg->crnti);
3270               break;
3271            }
3272         }
3273      }
3274 #endif
3275
3276      /* Initialize scheduler related information for UE */
3277      if(rgSCHUtlRgrUeCfg(cell, ue, ueCfg, errInfo) != ROK)
3278      {
3279         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Scheduler handling "
3280                  "failed in config for CRNTI:%d", ueCfg->crnti);
3281         break;
3282      }
3283
3284      ret = rgSCHUhmHqEntInit(cell, ue);
3285      if (ret != ROK)
3286      {
3287         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"UHM HARQ Ent Init "
3288            "Failed for CRNTI:%d", ueCfg->crnti);
3289         break;
3290      }
3291
3292      /* Initialize RAM related information for UE
3293       * RACHO: if preamble Id is present in ueCfg then raCb will be NULL
3294       * so rgSCHRamRgrUeCfg should take care of creating raCb */
3295    if ((ueCfg->dedPreambleId.pres == NOTPRSNT) && (NULLP != raCb) )
3296      {
3297         if((rgSCHRamRgrUeCfg(cell, ue, raCb, errInfo)) != ROK)
3298         {
3299            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Random access "
3300               "handling config failed for CRNTI:%d", ueCfg->crnti);
3301            break;
3302         }
3303      }
3304      else /* if HO Ue */
3305      {
3306         RG_SCH_CMN_GET_UE_HQE(ue, cell) = rgSCHDhmHqEntInit(cell);
3307         hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
3308         if (hqEnt == NULLP)
3309         {
3310            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Hq Entity Initialization "
3311                     "failed in config for CRNTI:%d", ueCfg->crnti);
3312            break;
3313         }
3314 #ifdef EMTC_ENABLE
3315         rgSCHEmtcHqPAlloc(cell, hqEnt);
3316 #endif
3317         hqEnt->ue = ue;
3318         /* Fix : syed Assign hqEnt to UE only if msg4 is done */
3319
3320         rgSCHCmnDlInitHqEnt(cell, hqEnt);
3321
3322         /* For Hand-In UE Request Aper CQI report
3323          * immediately */
3324         if (ueCfg->ueDlCqiCfg.aprdCqiCfg.pres)
3325         {
3326            /* Set APCQI for Pcell only*/
3327            ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
3328         }
3329      }
3330      /* CA dev Start */
3331 #ifdef LTE_TDD
3332      maxDlSubframes = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
3333      maxSubframes = 2 * maxDlSubframes;
3334      ue->dl.numHqDlSfInfo = maxSubframes;
3335      rgSCHUtlAllocSBuf(cell->instIdx,
3336            (Data **)&ue->dl.dlSfHqInfo, sizeof(RgSchDlHqInfo) * (ue->dl.numHqDlSfInfo));
3337
3338 #else
3339      ue->dl.numHqDlSfInfo = RGSCH_NUM_DL_SUBFRAMES;
3340 #endif
3341 #ifndef RG_5GTF
3342      for (idx =0;idx < ue->dl.numHqDlSfInfo; idx++)
3343      {
3344         cmLListInit(&ue->dl.dlSfHqInfo[idx].hqPLst);
3345         ue->dl.dlSfHqInfo[idx].dlSfUeLnk.node = NULLP;
3346
3347      }
3348 #else
3349      {
3350         U8 cellIdx=0;
3351         for (cellIdx = 0;cellIdx < MAX_5GTF_CELL ; cellIdx++)
3352         {
3353            for (idx =0;idx < ue->dl.numHqDlSfInfo; idx++)
3354            {
3355               cmLListInit(&ue->dl.dlSfHqInfo[cellIdx][idx].hqPLst);
3356               ue->dl.dlSfHqInfo[cellIdx][idx].dlSfUeLnk.node = NULLP;
3357            }
3358         }
3359      }
3360 #endif
3361 #ifdef LTE_ADV
3362      rgSCHLaaInitDlHqInfo(cell, ue);
3363 #endif
3364      /* CA dev End */
3365
3366      /* Initialize lcgIds to Invalid */
3367      for (lcgCnt = 0; lcgCnt < RGSCH_MAX_LCG_PER_UE; lcgCnt++)
3368      {
3369         ue->ul.lcgArr[lcgCnt].lcgId = RGSCH_INVALID_LCG_ID;
3370      }
3371      if(raCb != NULLP)
3372      {
3373         rgSCHCfgRgrUePhrMsg3(cell,raCb,ue,errInfo);
3374         /* Moved this code out of rgSCHCfgRgrUePhrMsg3()
3375          * as it was not the appropriate place to
3376          * do this. */
3377         if (raCb->raState == RGSCH_RA_MSG4_DONE)
3378         {
3379            RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
3380                  "RNTI:%d RaCb deleted as Msg4 transmission is done",
3381                  raCb->tmpCrnti);
3382            rgSCHRamDelRaCb(cell, raCb, FALSE);
3383         }
3384      }
3385      /* Initialize uplink HARQ related information for UE */
3386      rgSCHUhmRgrUeCfg(cell, ue, ueCfg);
3387      cmInitTimers(&ue->bsrTmr, 1);
3388 #ifdef RGR_V1
3389      /* Added periodic BSR timer */
3390      cmInitTimers(&ue->bsrTmr, 1);
3391
3392      /* Fix - Added proper configuration from U-ARM */
3393      if(ueCfg->ueBsrTmrCfg.isPrdBsrTmrPres == TRUE)
3394      {
3395         ue->ul.bsrTmrCfg.isPrdBsrTmrPres = TRUE;
3396         ue->ul.bsrTmrCfg.prdBsrTmr       = ueCfg->ueBsrTmrCfg.prdBsrTmr;
3397         ue->ul.bsrTmrCfg.retxBsrTmr      = ueCfg->ueBsrTmrCfg.retxBsrTmr;
3398      }
3399
3400 #endif
3401      /* Initialize downlink HARQ related information for UE */
3402      rgSCHDhmRgrUeCfg(cell, ue, ueCfg, errInfo);
3403
3404      /* Initialize MeasureGap and Acknack Rep Information for UE */
3405      if((rgSCHMeasGapANRepUeCfg(cell, ue, ueCfg)) != ROK)
3406      {
3407         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Measurement Gap and"
3408                  " AckNack Rep failed in Config for CRNTI:%d", ueCfg->crnti);
3409         break;
3410      }
3411
3412
3413 #ifdef LTE_TDD
3414      if((rgSCHUtlAllocUeANFdbkInfo(ue,RGSCH_PCELL_INDEX)) != ROK)
3415      {
3416         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"Memomy allocation "
3417                  "Failed while UE related Ack Nack Information for CRNTI:%d",
3418                  ueCfg->crnti);
3419         break;
3420      }
3421      ue->dl.ackNackMode = ueCfg->ackNackModeEnum;
3422 #endif /* LTE_TDD */
3423
3424      /* Insert Ue */
3425      rgSCHDbmInsUeCb(cell, ue);
3426
3427 #ifdef TFU_UPGRADE
3428      /*  Int ialize APeriodic CQI/PMI/RI Information for UE */
3429
3430    RGSCHDBGPRM(cell->instIdx,(rgSchPBuf(cell->instIdx),
3431             "\n rgSCHCfgRgrUeCfg : CellID=%d  UeId =%d  AcqiCfg Pres =%d",
3432             cell->cellId, ue->ueId, ueCfg->ueDlCqiCfg.aprdCqiCfg.pres));
3433
3434       /*Store Trigger Set Bit String to UE */
3435
3436       ret = rgSCHCfgACqiUeCfg(cell,ue, (RG_SCH_CMN_GET_ACQICB(ue,cell)),ue->mimoInfo.txMode,
3437            &ueCfg->ueDlCqiCfg.aprdCqiCfg, ue->ueCatEnum);
3438
3439      ue->cqiRiWritIdx = 0;
3440      ue->cqiRiReadIdx = 0;
3441      /*   Initialize Periodic CQI/PMI, RI Information for UE  */
3442      ret = rgSCHCfgPCqiUeCfg(cell, ue, &ueCfg->ueDlCqiCfg.prdCqiCfg,
3443            ue->ueCatEnum);
3444
3445      /*   Initialize UL SRS Information for UE  */
3446      ret = rgSCHCfgSrsUeCfg(cell, ue, &ueCfg->srsCfg);
3447
3448      /*   Initialize SR Information for UE  */
3449      ret = rgSCHCfgSrUeCfg(cell, ue, &ueCfg->srCfg);
3450 #endif
3451
3452 #ifdef LTEMAC_HDFDD
3453      if (rgSCHHdFddUeCfg(cell, ue, ueCfg->isHdFddEnbld) != ROK)
3454      {
3455         RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,
3456                  "Could not do HD-FDD config for CRNTI:%d",ueCfg->crnti);
3457         break;
3458      }
3459
3460 #endif /* LTEMAC_HDFDD */
3461      /* ccpu00117452 - MOD - Changed macro name from
3462         RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
3463 #ifdef RGR_CQI_REPT
3464      ue->cqiReptCfgInfo.numColltdCqiRept =
3465         ueCfg->ueCqiReptCfg.numColltdCqiRept;
3466 #endif /* End of RGR_CQI_REPT */
3467 #ifdef TFU_UPGRADE
3468      RG_SCH_CMN_GET_PA(ue,cell).pres = FALSE;
3469      if (RG_SCH_UE_CFG_ISPAPRSNT(ueCfg->uePdschDedCfg.uepACfg))
3470      {
3471         RG_SCH_CMN_GET_PA(ue,cell).pres = TRUE;
3472         RG_SCH_CMN_GET_PA(ue,cell).val = ueCfg->uePdschDedCfg.uepACfg.pA;
3473      }
3474 #endif
3475      ue->isDrxEnabled = ueCfg->ueDrxCfg.isDrxEnabled;
3476
3477      if ( ue->isDrxEnabled )
3478      {
3479         if((rgSCHDrxUeCfg(cell,ue,ueCfg)) != ROK )
3480         {
3481            RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId,"DRX configuration failed",
3482                      ueCfg->crnti);
3483            break;
3484         }
3485      }
3486
3487      /* LTE_ADV_FLAG_REMOVED_START */
3488      if ((cell->lteAdvCb.sfrCfg.status == RGR_ENABLE) ||    \
3489         (cell->lteAdvCb.absCfg.status == RGR_ENABLE))
3490      {
3491         ue->lteAdvUeCb.rgrLteAdvUeCfg = ueCfg->ueLteAdvCfg;
3492      }
3493      /* LTE_ADV_FLAG_REMOVED_END */
3494
3495 #ifdef TENB_STATS
3496      ue->tenbStats = TSL2AllocUeStatsBlk(ue->ueId);
3497      ue->tenbStats->stats.rnti = ue->ueId;
3498 #endif
3499 #ifdef LTE_ADV
3500      /*Update A Value for PCell TBs*/
3501      ue->f1bCsAVal = rgSCHUtlGetMaxTbSupp(ue->mimoInfo.txMode);
3502      RLOG_ARG1(L_ERROR,DBG_CELLID, ueCfg->cellId,
3503             "\n UeCfg A value is %d\n",ue->f1bCsAVal);
3504 #endif
3505      errInfo->errCause = RGSCHERR_NONE;
3506
3507      ue->accessStratumRls = ueCfg->accessStratumRls;
3508      if (ue->numSCells > 0)
3509      {
3510         /* 2 bit CSI */
3511         rgSCHUtlUpdUeDciSize(cell, ue, TRUE);
3512      }
3513      else
3514      {
3515         /* 1 bit CSI Access Stratum Release Change */
3516         rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
3517      }
3518
3519      RETVALUE(ROK);
3520   }while(0);
3521
3522   if (ue)
3523   {
3524      rgSCHCfgFreeUeCb(cell, ue);
3525   }
3526   RETVALUE(RFAILED);
3527 }  /* rgSCHCfgRgrUeCfg */
3528
3529 /**
3530  * @brief Handler for PHR for MSG3.
3531  *
3532  * @details
3533  *
3534  *     Function : rgSCHCfgRgrUePhrMsg3
3535  *
3536  *     Processing Steps:
3537  *       Handle PHR related config for MSG3
3538  *
3539  *  @param[in]  RgSchCellCb  *cell
3540  *  @param[in]  RgrUeCb     *ueCb
3541  *  @param[in]  RgSchRaCb    *raCb
3542  *  @param[out] RgSchErrInfo *errInfo
3543  **/
3544 #ifdef ANSI
3545 PRIVATE Void rgSCHCfgRgrUePhrMsg3
3546 (
3547 RgSchCellCb  *cell,
3548 RgSchRaCb    *raCb,
3549 RgSchUeCb    *ue,
3550 RgSchErrInfo *errInfo
3551 )
3552 #else
3553 PRIVATE Void rgSCHCfgRgrUePhrMsg3(cell, raCb, ue, errInfo)
3554 RgSchCellCb  *cell;
3555 RgSchRaCb    *raCb;
3556 RgSchUeCb    *ue;
3557 RgSchErrInfo *errInfo;
3558 #endif
3559 {
3560
3561    TRC2(rgSCHCfgRgrUePhrMsg3);
3562
3563    /* Record msg3 allocation in the UE */
3564    rgSCHUtlRecMsg3Alloc(cell, ue, raCb);
3565
3566    /* If raCb received PHR, update scheduler */
3567    if(raCb->phr.pres == TRUE)
3568    {
3569       ue->macCeRptTime = raCb->msg3AllocTime;
3570       rgSCHUtlUpdPhr(cell, ue, raCb->phr.val, errInfo);
3571    }
3572
3573    RETVOID;
3574 }
3575
3576 /**
3577  *
3578  * @details
3579  *
3580  *     Function : rgSCHDynCfiReCfg
3581  *
3582  *  @param[in]  RgSchCellCb   *cell
3583  *              Bool          isDynCfiEnb
3584  *  @return  S16
3585  *      -# ROK
3586  *      -# RFAILED
3587  **/
3588 #ifdef ANSI
3589 PUBLIC Void rgSCHDynCfiReCfg
3590 (
3591 RgSchCellCb   *cell,
3592 Bool          isDynCfiEnb
3593 )
3594 #else
3595 PUBLIC Void rgSCHDynCfiReCfg(cell, isDynCfiEnb)
3596 RgSchCellCb   *cell;
3597 Bool          isDynCfiEnb;
3598 #endif
3599 {
3600    U8                idx;
3601    RgSchCmnDlCell    *cellSchDl = RG_SCH_CMN_GET_DL_CELL(cell);
3602
3603    TRC2(rgSCHDynCfiReCfg);
3604
3605    if(isDynCfiEnb)
3606    {
3607       cell->dynCfiCb.ttiCnt = 0;
3608       cellSchDl->newCfi = cellSchDl->currCfi;
3609    }
3610    else
3611    {
3612       /* Resetting the parameters*/
3613       cell->dynCfiCb.cceFailCnt          = 0;
3614       cell->dynCfiCb.cceFailSum          = 0;
3615       cell->dynCfiCb.prevCceFailIdx      = 0;
3616
3617       for(idx = 0; idx < cell->dynCfiCb.numFailSamples; idx++)
3618       {
3619          cell->dynCfiCb.cceFailSamples[idx] = 0;
3620       }
3621
3622       cell->dynCfiCb.cceUsed             = 0;
3623       cell->dynCfiCb.lowCceCnt           = 0;
3624       cell->dynCfiCb.ttiCnt = 0;
3625    }
3626 }
3627 /**
3628  * @brief Handler for the cell reconfiguration request from RRM to MAC.
3629  *
3630  * @details
3631  *
3632  *     Function : rgSCHCfgRgrCellRecfg
3633  *
3634  *     Processing Steps:
3635  *      - Invoke SCH with cell control block to update
3636  *        scheduler specific information.
3637  *      - Update cell control block with the values recieved in the
3638  *        configuration.
3639  *      - If successful, return ROK else RFAILED.
3640  *
3641  *  @param[in]  RgSchCellCb   *cell
3642  *  @param[in]  RgrCellRecfg  *cellRecfg
3643  *  @param[out] RgSchErrInfo  *errInfo
3644  *  @return  S16
3645  *      -# ROK
3646  *      -# RFAILED
3647  **/
3648 #ifdef ANSI
3649 PUBLIC S16 rgSCHCfgRgrCellRecfg
3650 (
3651 RgSchCellCb   *cell,
3652 RgrCellRecfg  *cellRecfg,
3653 RgSchErrInfo  *errInfo
3654 )
3655 #else
3656 PUBLIC S16 rgSCHCfgRgrCellRecfg(cell, cellRecfg, errInfo)
3657 RgSchCellCb   *cell;
3658 RgrCellRecfg  *cellRecfg;
3659 RgSchErrInfo  *errInfo;
3660 #endif
3661 {
3662    S16      ret;
3663    Inst    inst = cell->instIdx;
3664 /* LTE_ADV_FLAG_REMOVED_START */
3665    U8      i = 0;
3666    U16     len; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
3667 /* LTE_ADV_FLAG_REMOVED_END */
3668
3669    TRC2(rgSCHCfgRgrCellRecfg);
3670
3671
3672    errInfo->errCause = RGSCHERR_CFG_RGR_CELL_RECFG;
3673
3674    /* Invoke scheduler to update scheduler specific information */
3675    ret =  rgSCHUtlRgrCellRecfg(cell, cellRecfg, errInfo);
3676    if (ret != ROK)
3677    {
3678      RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId, "RGR Cell re-configuration failed "
3679           "at Scheduler ");
3680       RETVALUE(RFAILED);
3681    }
3682
3683    /* Invoke DHM to update DHM specific information */
3684    rgSCHDhmRgrCellRecfg(cell, cellRecfg, errInfo);
3685
3686       /* PUCCH Reconfiguration */
3687    if (cellRecfg->recfgTypes & RGR_CELL_PUCCH_RECFG)
3688    {
3689       cell->pucchCfg = cellRecfg->pucchRecfg;
3690    }
3691
3692    /* SRS Reconfiguration */
3693    if (cellRecfg->recfgTypes & RGR_CELL_SRS_RECFG)
3694    {
3695       cell->srsCfg.isSrsCfgPres = cellRecfg->srsRecfg.isSrsCfgSetup;
3696       if(cellRecfg->srsRecfg.isSrsCfgSetup)
3697       {
3698          cell->srsCfg.srsCfgPrdEnum = cellRecfg->srsRecfg.srsCfgPrdEnum;
3699          cell->srsCfg.srsBwEnum = cellRecfg->srsRecfg.srsBwEnum;
3700          cell->srsCfg.srsTxOffst =
3701             rgSrsTxOffstTbl[cellRecfg->srsRecfg.srsSubFrameCfg];
3702          /*ccpu00116923 - ADD - Srs Present support */
3703 #ifdef TFU_UPGRADE
3704          cell->srsCfg.srsSubFrameCfg = cellRecfg->srsRecfg.srsSubFrameCfg;
3705 #endif
3706       }
3707    }
3708
3709    /* RACH Reconfiguration */
3710    if (cellRecfg->recfgTypes & RGR_CELL_RACH_RECFG)
3711    {
3712       cell->rachCfg = cellRecfg->rachRecfg;
3713    }
3714
3715    /* ccpu00132256:MOD: Moved this assignment from Validation to here.*/
3716    if (cellRecfg->recfgTypes & RGR_CELL_TMRS_RECFG)
3717    {
3718       cell->t300TmrVal = cellRecfg->t300TmrVal;
3719    }
3720 #ifdef RGR_SI_SCH
3721    /* SI Reconfiguration */
3722    if (cellRecfg->recfgTypes & RGR_CELL_SI_RECFG)
3723    {
3724       /*Set the specified SI configuration. */
3725       cell->siCb.newSiCfg = cellRecfg->siReCfg;
3726       /* Set the Bit mask for SI re-configuration */
3727       cell->siCb.siBitMask |= RGSCH_SI_SICFG_UPD;
3728 #ifdef EMTC_ENABLE
3729       if(cell->emtcEnable)
3730       {
3731       rgSchEmtcUpdSiCfg(cell, cellRecfg);
3732       }
3733 #endif
3734    }
3735 #endif /*RGR_SI_SCH */
3736
3737    /* Overload RACH Control changes */
3738    if (cellRecfg->recfgTypes & RGR_CELL_CNTRL_CMD_RECFG)
3739    {
3740       if (cellRecfg->cntrlCmdCfg.cmdType == RGR_CNTRL_CMD_RACH_OVRLD)
3741       {
3742          cell->overLoadBackOffEnab = cellRecfg->cntrlCmdCfg.cmdDesc.rachOvrLd.backOffEnb;
3743          cell->overLoadBackOffval = cellRecfg->cntrlCmdCfg.cmdDesc.rachOvrLd.backOffVal;
3744       }
3745       else if (cellRecfg->cntrlCmdCfg.cmdType == RGR_CNTRL_CMD_CPU_OVRLD)
3746       {
3747          if( ROK != rgSCHUtlResetCpuOvrLdState(cell, cellRecfg->cntrlCmdCfg.cmdDesc.\
3748                                           cpuOvrLd.instruction))
3749          {
3750             RLOG_ARG1(L_ERROR,DBG_CELLID, cellRecfg->cellId,
3751                "Invalid CPU OvrLd Ins %d for cell",
3752                cellRecfg->cntrlCmdCfg.cmdDesc.cpuOvrLd.instruction);
3753             RETVALUE(RFAILED);
3754          }
3755       }
3756    }
3757
3758 /* LTE_ADV_FLAG_REMOVED_START */
3759    if (cellRecfg->recfgTypes & RGR_CELL_LTEA_FEATURE_RECFG)
3760    {
3761       if(cellRecfg->rgrLteAdvCfg.pres & RGR_ABS)
3762       {
3763          cell->lteAdvCb.absCfg =
3764             cellRecfg->rgrLteAdvCfg.absCfg;
3765       }
3766       if(cellRecfg->rgrLteAdvCfg.pres & RGR_SFR)
3767       {
3768          cmMemcpy((U8 *)&cell->lteAdvCb.sfrCfg, (U8 *)&cellRecfg->rgrLteAdvCfg.sfrCfg,
3769                sizeof(RgrSfrConfig));
3770          /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
3771          if (cellRecfg->rgrLteAdvCfg.sfrCfg.status == RGR_ENABLE)
3772          {
3773             for(i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
3774             {
3775                /*initialise the pools of CC and CE*/
3776                if(rgSchSFRTotalPoolInit(cell, cell->subFrms[i]))
3777                {
3778                   RETVALUE(RFAILED);
3779                }
3780             }
3781          }
3782          else
3783          {
3784             for(i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
3785             {
3786                /*initialise the pools of CC and CE*/
3787                rgSchSFRTotalPoolFree(&cell->subFrms[i]->sfrTotalPoolInfo, cell);
3788             }
3789
3790             if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
3791             {
3792                /* releasing rntp info val from each subframe */
3793                for(i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
3794                {
3795                   rgSchDSFRRntpInfoFree(&cell->subFrms[i]->rntpInfo, cell, cell->bwCfg.dlTotalBw);
3796                }
3797
3798                /* releasing RNTP Aggregation Info from CellCb*/
3799                rgSchDSFRRntpInfoFree(&cell->rntpAggrInfo, cell, cell->bwCfg.dlTotalBw);
3800
3801                cell->lteAdvCb.dsfrCfg.status = RGR_DISABLE;
3802             }
3803          }
3804       }
3805       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Start */
3806       if(cellRecfg->rgrLteAdvCfg.pres & RGR_DSFR)
3807       {
3808          cell->lteAdvCb.dsfrCfg =
3809             cellRecfg->rgrLteAdvCfg.dsfrCfg;
3810          if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
3811          {
3812             for(i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
3813             {
3814                /*initialise the pools of CC and CE*/
3815                if(rgSchDSFRRntpInfoInit(&cell->subFrms[i]->rntpInfo,cell,cell->bwCfg.dlTotalBw))
3816                {
3817                   RETVALUE(RFAILED);
3818                }
3819             }
3820             /*Calculating the length of RNTP array based on Dl Bandwidth */
3821             len = (U16)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /* KW fix for LTE_ADV */
3822             if(cell->rntpAggrInfo.pres == NOTPRSNT)
3823             {
3824                if((rgSCHUtlAllocSBuf(inst, (Data**)&(cell->rntpAggrInfo.val),
3825                            (len * sizeof(U8)))) != ROK)
3826                {
3827                   RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,
3828                             "Memory allocation FAILED for RNTP Alloc");
3829                   RETVALUE(RFAILED);
3830                }
3831                cell->rntpAggrInfo.pres = PRSNT_NODEF;
3832                cell->rntpAggrInfo.len  = len;
3833             }
3834          }
3835          /* in case if DSFR is disabled, need to free RNTP pattern val*/
3836          else
3837          {
3838             /* releasing rntp info val from each subframe */
3839             for(i = 0; i < RGSCH_NUM_DL_SUBFRAMES; i++)
3840             {
3841                rgSchDSFRRntpInfoFree(&cell->subFrms[i]->rntpInfo, cell, cell->bwCfg.dlTotalBw);
3842             }
3843
3844             /* releasing RNTP Aggregation Info from CellCb*/
3845             rgSchDSFRRntpInfoFree(&cell->rntpAggrInfo, cell, cell->bwCfg.dlTotalBw);
3846          }
3847       }
3848       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** End */
3849    }
3850 /* LTE_ADV_FLAG_REMOVED_END */
3851
3852    /* Dynamic CFI cell Reconfiguration */
3853    if(cellRecfg->recfgTypes & RGR_CELL_DYN_CFI_RECFG)
3854    {
3855       if(cell->dynCfiCb.isDynCfiEnb != cellRecfg->isDynCfiEnb)
3856       {
3857          if(cell->dynCfiCb.switchOvrInProgress)
3858          {
3859             cell->dynCfiCb.dynCfiRecfgPend = TRUE;
3860          }
3861          else
3862          {
3863             cell->dynCfiCb.isDynCfiEnb = cellRecfg->isDynCfiEnb;
3864             rgSCHDynCfiReCfg(cell, cellRecfg->isDynCfiEnb);
3865          }
3866       }
3867       else
3868       {
3869          /* To hanlde the case where reconfiguration comes for disabling
3870           * and then enabling before switchover period expires */
3871          cell->dynCfiCb.dynCfiRecfgPend = FALSE;
3872       }
3873    }
3874    /* Dynamic config of AUTO chnage flag */
3875    if(cellRecfg->recfgTypes & RGR_CELL_AUTO_CFG_MODE_RECFG)
3876    {
3877       if(cell->isAutoCfgModeEnb != cellRecfg->isAutoCfgModeEnb)
3878       {
3879          cell->isAutoCfgModeEnb = cellRecfg->isAutoCfgModeEnb;
3880       }
3881    }
3882    {
3883      if(cell->isAutoCfgModeEnb)
3884      {
3885         RLOG0(L_INFO,"Auto Mode Cfg enabled durint cell recfg\n");
3886      }
3887    }
3888
3889    if (cellRecfg->recfgTypes & RGR_CELL_CSG_PARAM_RECFG)
3890    {
3891       cell->minDlResNonCsg = cellRecfg->csgParamCfg.minDlResNonCsg;
3892       cell->minUlResNonCsg = cellRecfg->csgParamCfg.minUlResNonCsg;
3893    }
3894
3895    errInfo->errCause = RGSCHERR_NONE;
3896    RETVALUE(ROK);
3897 }  /* rgSCHCfgRgrCellRecfg */
3898
3899 /**
3900  * @brief Handler for the UE reconfiguration request from RRC to MAC.
3901  *
3902  * @details
3903  *
3904  *     Function : rgSCHCfgRgrUeRecfgRntiChg
3905  *
3906  *     Processing Steps:
3907  *      - If rnti changes,
3908  *        - Invoke RAM for UE reconfiguration.
3909  *        - Delete old UE from the list.
3910  *        - Update the new rnti and re-insert the UE in the list.
3911  *      - If successful, return ROK else RFAILED.
3912  *
3913  *  @param[in]  RgSchCellCb  *cell
3914  *  @param[in]  RgSchUeCb    *ue
3915  *  @param[in]  RgrUeRecfg   *ueRecfg
3916  *  @param[out] RgSchErrInfo *errInfo
3917  *  @return  S16
3918  *      -# ROK
3919  *      -# RFAILED
3920  **/
3921 #ifdef ANSI
3922 PRIVATE S16 rgSCHCfgRgrUeRecfgRntiChg
3923 (
3924 RgSchCellCb    *cell,
3925 RgSchUeCb      *ue,
3926 RgrUeRecfg     *ueRecfg,
3927 RgSchErrInfo   *errInfo
3928 )
3929 #else
3930 PRIVATE S16 rgSCHCfgRgrUeRecfgRntiChg(cell, ue, ueRecfg, errInfo)
3931 RgSchCellCb    *cell;
3932 RgSchUeCb      *ue;
3933 RgrUeRecfg     *ueRecfg;
3934 RgSchErrInfo   *errInfo;
3935 #endif
3936 {
3937 #ifdef LTE_ADV
3938    U8          sCellIdx;
3939 #endif
3940    S16          ret;
3941    RgSchRaCb    *raCb;
3942    RgSchRaCb    *oldRaCb;
3943    RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
3944    U8           idx;
3945
3946    TRC2(rgSCHCfgRgrUeRecfgRntiChg);
3947
3948    /* Handle CRNTI change in reconfiguration */
3949    if (ueRecfg->oldCrnti != ueRecfg->newCrnti)
3950    {
3951       RgSchRntiLnk   *oldRntiLnk=NULLP;
3952       CmLteRnti      oldRnti = 0;
3953       if ((raCb = rgSCHDbmGetRaCb(cell, ueRecfg->newCrnti)) == NULLP)
3954       {
3955          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UEID:No RaCb exists while"
3956               "Reconfig for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
3957          RETVALUE(RFAILED);
3958       }
3959
3960       /* rntiLnk does not exist for a HandIn UE. Hence this check. */
3961       if(ue->rntiLnk)
3962       {
3963          oldRntiLnk = ue->rntiLnk;
3964       }
3965       else
3966       {
3967          /* Fix : syed HO UE does not have a valid ue->rntiLnk */
3968          oldRnti = ue->ueId;
3969       }
3970
3971       RLOG2(L_INFO,"UE ID CHNG OLD %d new %d",ueRecfg->oldCrnti, ueRecfg->newCrnti);
3972
3973       /* Fix : syed Deleting Old DL HqEnt. It would be assigned after
3974        * reest RACH(msg4) is completed. */
3975       rgSCHDhmDelHqEnt(cell, hqEnt);
3976
3977       /* Initialize RAM related information for UE */
3978       ret = rgSCHRamRgrUeCfg(cell, ue, raCb, errInfo);
3979       if (ret != ROK)
3980       {
3981          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"RAM Handling for UE Reconfig failed"
3982               "for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
3983          RETVALUE(RFAILED);
3984       }
3985       /* Delete Ue from the ue list */
3986       rgSCHDbmDelUeCb(cell, ue);
3987
3988 #ifdef LTE_ADV
3989       if (ue->numSCells)
3990       {
3991          for ( sCellIdx = 1; sCellIdx < CM_LTE_MAX_CELLS; sCellIdx++)
3992          {
3993             if(ue->cellInfo[sCellIdx] != NULLP)
3994             {
3995                rgSCHDbmDelUeCb(ue->cellInfo[sCellIdx]->cell, ue);
3996             }
3997          }
3998       }
3999 #endif
4000
4001       /* Inititialize Ue control block */
4002       ue->ueId = ueRecfg->newCrnti;
4003       RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
4004             "Changing RNTI from %d to %d",
4005             ueRecfg->oldCrnti,
4006             ueRecfg->newCrnti);
4007 #ifdef EMTC_ENABLE
4008       if(ue->isEmtcUe)
4009       {
4010          rgSCHUtlUpdEmtcY(ue);
4011       }
4012 #endif
4013
4014       /* Fix ccpu00122631: PCell_Reest: Updating new Rnti in all the cells
4015        * dlAllocCb
4016        */
4017       for(idx = 0; idx < CM_LTE_MAX_CELLS; idx++)
4018       {
4019          if(ue->cellInfo[idx])
4020          {
4021             ue->cellInfo[idx]->dlAllocCb.rnti = ueRecfg->newCrnti;
4022          }
4023       }
4024
4025       rgSCHUtlRecMsg3Alloc(cell, ue, raCb);
4026
4027       /* If raCb received PHR, update scheduler */
4028       if(raCb->phr.pres == TRUE)
4029       {
4030          ue->macCeRptTime = raCb->msg3AllocTime;
4031          rgSCHUtlUpdPhr(cell, ue, raCb->phr.val, errInfo);
4032       }
4033
4034 #ifdef RGR_V2  /* Acc Fix */
4035      if(TRUE == ue->isDrxEnabled)
4036      {
4037          ueRecfg->ueDrxRecfg.isDrxEnabled = TRUE;
4038          ret = rgSCHDrxUeReCfg(cell,ue,ueRecfg);
4039
4040          if ( ret != ROK )
4041          {
4042              RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE DRX re-est failed"
4043               "for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
4044              RETVALUE(RFAILED);
4045          }
4046      }
4047 #endif /* Acc Fix */
4048
4049       /* Re-insert updated Ue */
4050       rgSCHDbmInsUeCb(cell, ue);
4051
4052 #ifdef LTE_ADV
4053       if (ue->numSCells)
4054       {
4055          for ( sCellIdx = 1; sCellIdx < CM_LTE_MAX_CELLS; sCellIdx++)
4056          {
4057             if(ue->cellInfo[sCellIdx] != NULLP)
4058             {
4059                rgSCHDbmInsUeCb(ue->cellInfo[sCellIdx]->cell, ue);
4060             }
4061          }
4062       }
4063 #endif
4064
4065
4066 #ifdef TENB_STATS
4067       ue->tenbStats->stats.rnti = ue->ueId;
4068 #endif
4069
4070       /* Fix : syed If MSG4 is done, since corresponding ueCb
4071        * is ready, the raCb should be cleared immediately.
4072        * Otherwise it would remain in the cell until timed out
4073        * and till then the hq Feedbacks will be assumed to be
4074        * for msg4 */
4075       if (raCb->raState == RGSCH_RA_MSG4_DONE)
4076       {
4077          RLOG_ARG1(L_DEBUG,DBG_CELLID,ueRecfg->cellId,
4078                "RNTI:%d with RaCb deleted as Msg4 transmission is done",
4079                raCb->tmpCrnti);
4080          rgSCHRamDelRaCb(cell, raCb, FALSE);
4081       }
4082       /* Fix : syed moving the UL CQI initialization to UERESET */
4083
4084       /* Release Older rnti */
4085       if(oldRntiLnk)
4086       {
4087          /* This is the rare case in which back to back reestablishment is
4088           * happening and previous re-est was not done completely (MSG4 was
4089           * not done) for an UE, and again re-est is triggered for the same
4090           * UE. We are deleting the old RA CB for the previous re-est which
4091           * still exist due to MSG4 not transmitted successfully */
4092          if ((oldRaCb = rgSCHDbmGetRaCb(cell, oldRntiLnk->rnti)) != NULLP)
4093          {
4094             rgSCHRamDelRaCb(cell, oldRaCb, FALSE);
4095          }
4096
4097          rgSCHUtlRlsRnti(cell, oldRntiLnk, TRUE, ueRecfg->newCrnti);
4098       }
4099       else
4100       {
4101          /* Fix : syed HO UE does not have a valid ue->rntiLnk */
4102              /* Just indicate to MAC, no need to release at SCH */
4103          RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
4104                "HO OldRnti:%d RLS and NewRnti:%d CHNG IND TO MAC",
4105                oldRnti, ueRecfg->newCrnti);
4106          rgSCHUtlIndRntiRls2Mac(cell, oldRnti, TRUE, ueRecfg->newCrnti);
4107       }
4108    }
4109    RETVALUE(ROK);
4110 }
4111 /**
4112  * @brief Handler for the UE reconfiguration request from RRC to MAC.
4113  *
4114  * @details
4115  *
4116  *     Function : rgSCHCfgRgrUeRecfg
4117  *
4118  *     Processing Steps:
4119  *      - If rnti changes,
4120  *        - Invoke RAM for UE reconfiguration.
4121  *        - Delete old UE from the list.
4122  *        - Update the new rnti and re-insert the UE in the list.
4123  *      - Update the UE control block with the reconfigured values.
4124  *      - Invoke SCH, UHM and DHM with updated UE control block to
4125  *        update scheduler, uplink HARQ and downlink HARQ specific
4126  *        parameters.
4127  *      - If successful, return ROK else RFAILED.
4128  *
4129  *  @param[in]  RgSchCellCb  *cell
4130  *  @param[in]  RgSchUeCb    *ue
4131  *  @param[in]  RgrUeRecfg   *ueRecfg
4132  *  @param[out] RgSchErrInfo *errInfo
4133  *  @return  S16
4134  *      -# ROK
4135  *      -# RFAILED
4136  **/
4137 #ifdef ANSI
4138 PUBLIC S16 rgSCHCfgRgrUeRecfg
4139 (
4140 RgSchCellCb    *cell,
4141 RgSchUeCb      *ue,
4142 RgrUeRecfg     *ueRecfg,
4143 RgSchErrInfo   *errInfo
4144 )
4145 #else
4146 PUBLIC S16 rgSCHCfgRgrUeRecfg(cell, ue, ueRecfg, errInfo)
4147 RgSchCellCb    *cell;
4148 RgSchUeCb      *ue;
4149 RgrUeRecfg     *ueRecfg;
4150 RgSchErrInfo   *errInfo;
4151 #endif
4152 {
4153    S16          ret;
4154 #ifdef LTE_ADV
4155    Bool dciChange = TRUE;
4156 #endif
4157
4158    TRC2(rgSCHCfgRgrUeRecfg);
4159
4160    errInfo->errCause = RGSCHERR_CFG_RGR_UE_RECFG;
4161
4162 #ifdef LTE_ADV
4163    if (ue->numSCells > 0)
4164    {
4165       dciChange = FALSE;
4166    }
4167    if ((ueRecfg->ueRecfgTypes & RGR_UE_UE_ACCESS_STRATUM_REL_RECFG) && \
4168          (ue->accessStratumRls != ueRecfg->accessStratumRls))
4169    {
4170       ue->accessStratumRls = ueRecfg->accessStratumRls;
4171       dciChange = TRUE;
4172    }
4173
4174    /* if SCELL_RECFG is present , no other
4175     * type will be present. Process Scell addition
4176     * and return
4177     * */
4178    if (ueRecfg->ueRecfgTypes & RGR_UE_SCELL_ADD_RECFG)
4179    {
4180       ret = rgSCHSCellCfgUeCfg(cell, ue, ueRecfg, errInfo);
4181       if( ret != ROK)
4182       {
4183          errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_SCELL_RECFG;
4184          /*FH: SCell config failed for a scell index hence revert all successful
4185           * Scell config and send negative confirmation to APP*/
4186          rgSCHSCellCfgUeCfgRollBack(cell, ue, ueRecfg);
4187          RETVALUE(RFAILED);
4188       }
4189    }
4190    if (dciChange == TRUE)
4191    {
4192       if (ue->numSCells > 0)
4193       {
4194          /* 2 bit CSI */
4195          rgSCHUtlUpdUeDciSize(cell, ue, TRUE);
4196       }
4197       else
4198       {
4199          /* 1 bit CSI Access Stratum Release Change */
4200          rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
4201       }
4202    }
4203    if (ueRecfg->ueRecfgTypes & RGR_UE_SCELL_PUCCH_RECFG)
4204    {
4205       ret = rgSCHSCellCfgUePucchReCfg(cell, ue, ueRecfg, errInfo);
4206       if( ret != ROK)
4207       {
4208          errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_UE_SCELL_PUCCH_RECFG;
4209          RETVALUE(RFAILED);
4210       }
4211    }
4212 #else
4213    if ((ueRecfg->ueRecfgTypes & RGR_UE_UE_ACCESS_STRATUM_REL_RECFG) && \
4214          (ue->accessStratumRls != ueRecfg->accessStratumRls))
4215    {
4216       ue->accessStratumRls = ueRecfg->accessStratumRls;
4217       rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
4218    }
4219 #endif /* LTE_ADV */
4220
4221    if (ueRecfg->ueRecfgTypes)
4222    {
4223       /* Update scheduler related information for UE */
4224       ret = rgSCHUtlRgrUeRecfg(cell, ue, ueRecfg, errInfo);
4225       if (ret != ROK)
4226       {
4227          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
4228              "Scheduler handling while reconfig failed"
4229               "for OLD CRNTI:%d NEW CRNTI:%d",ueRecfg->oldCrnti,ueRecfg->newCrnti);
4230          RETVALUE(RFAILED);
4231       }
4232
4233       /* Update uplink HARQ related information for UE */
4234       rgSCHUhmRgrUeRecfg(cell, ue, ueRecfg);
4235
4236       /* Update TA related information for UE */
4237       if (ueRecfg->ueRecfgTypes & RGR_UE_TATMR_RECFG)
4238       {
4239          rgSCHCfgUeTaRecfg(cell, ue, ueRecfg, errInfo);
4240       }
4241
4242       /*Update Measurement Gap and AckNack Details */
4243       /* After merging from 2.2 */
4244       if (ueRecfg->ueRecfgTypes & RGR_UE_ACKNACK_MEASGAP_RECFG)
4245       {
4246          ret = rgSCHMeasGapANRepUeRecfg(cell, ue, ueRecfg);
4247          if (ret != ROK)
4248          {
4249             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Measurement Gap and"
4250                      "AckNack Rep Recfg failed for OLD CRNTI:%d NEW CRNTI:%d",
4251                       ueRecfg->oldCrnti,ueRecfg->newCrnti);
4252             RETVALUE(RFAILED);
4253          }
4254       }
4255       if (ueRecfg->ueRecfgTypes & RGR_UE_BSRTMR_RECFG)
4256       {
4257          cmInitTimers(&ue->bsrTmr, 1);
4258          ue->ul.bsrTmrCfg = ueRecfg->ueBsrTmrRecfg;
4259          if ((ue->ul.bsrTmrCfg.isPrdBsrTmrPres) &&
4260                (ue->ul.bsrTmrCfg.prdBsrTmr == 0xFFFF))
4261          {
4262             ue->ul.bsrTmrCfg.isPrdBsrTmrPres = FALSE;
4263          }
4264       }
4265    }
4266
4267    if (RFAILED == rgSCHCfgRgrUeRecfgRntiChg (cell, ue, ueRecfg, errInfo))
4268    {
4269        RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"RNTI change "
4270                "failed for OLD CRNTI:%d NEW CRNTI:%d",
4271                 ueRecfg->oldCrnti,ueRecfg->newCrnti);
4272        RETVALUE(RFAILED);
4273    }
4274
4275 #ifdef TFU_UPGRADE
4276    /* Re-Initialize Aperiodic CQI Information for UE*/
4277    if ( ueRecfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG )
4278    {
4279       ret = rgSCHCfgAcqiUeReCfg(cell, ue, &ueRecfg->aprdDlCqiRecfg,
4280             ue->ueCatEnum);
4281    }
4282    /*   Re-Initialize Periodic CQI/PMI, RI Information for UE  */
4283    if ( ueRecfg->ueRecfgTypes & RGR_UE_PCQI_RECFG)
4284    {
4285       ret = rgSCHCfgPCqiUeReCfg(cell, ue, &ueRecfg->cqiCfg,
4286             ue->ueCatEnum);
4287    }
4288    /*   Re-Initialize UL SRS Information for UE  */
4289    if ( ueRecfg->ueRecfgTypes & RGR_UE_SRS_RECFG)
4290    {
4291       ret = rgSCHCfgSrsUeReCfg(cell, ue, &ueRecfg->srsCfg);
4292    }
4293    /*   Re-Initialize SR Information for UE  */
4294    if ( ueRecfg->ueRecfgTypes & RGR_UE_SR_RECFG)
4295    {
4296       ret = rgSCHCfgSrUeReCfg(cell, ue, &ueRecfg->srCfg);
4297    }
4298 #endif
4299
4300 #ifdef LTEMAC_HDFDD
4301    if(ueRecfg->isHdFddEnbld)
4302    {
4303         ret = rgSCHHdFddUeCfg(cell, ue, ueRecfg->isHdFddEnbld);
4304         if (ret != ROK)
4305         {
4306            errInfo->errCause = RGSCHERR_HDFDD_SPSCFGRD;
4307            RETVALUE(ret);
4308         }
4309    }
4310 #endif /* LTEMAC_HDFDD */
4311 #ifdef RGR_V2
4312   if ( ueRecfg->ueRecfgTypes & RGR_UE_DRX_RECFG)
4313   {
4314      ret = rgSCHDrxUeReCfg(cell,ue,ueRecfg);
4315
4316      if ( ret != ROK )
4317      {
4318         RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE DRX reconfig failed"
4319                "failed for OLD CRNTI:%d NEW CRNTI:%d",
4320                 ueRecfg->oldCrnti,ueRecfg->newCrnti);
4321         RETVALUE(RFAILED);
4322      }
4323   }
4324 #endif
4325 /* ccpu00117452 - MOD - Changed macro name from
4326    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
4327 #ifdef RGR_CQI_REPT
4328    /* CQI Reporting (N)  Re-configuration */
4329    if(ueRecfg->ueRecfgTypes & RGR_UE_CQIREPT_RECFG)
4330    {
4331       ret = rgSCHCfgUeCqiReptReCfg(cell, ue, ueRecfg);
4332       if(ret != OK)
4333       {
4334          errInfo->errCause = RGSCHERR_CQIREPT;
4335          RETVALUE(ret);
4336       }
4337    }
4338 #endif /* End of RGR_CQI_REPT */
4339 #ifdef TFU_UPGRADE
4340    /* pA Re-configuration */
4341    if((ueRecfg->ueRecfgTypes & RGR_UE_PA_RECFG) &&
4342          RG_SCH_UE_CFG_ISPAPRSNT(ueRecfg->uePdschDedCfg.uepACfg))
4343    {
4344       RG_SCH_CMN_GET_PA(ue,cell).pres = TRUE;
4345       RG_SCH_CMN_GET_PA(ue,cell).val = ueRecfg->uePdschDedCfg.uepACfg.pA;
4346    }
4347 #endif
4348
4349 /* LTE_ADV_FLAG_REMOVED_START */
4350    if(ueRecfg->ueRecfgTypes & RGR_UE_LTEA_RECFG)
4351    {
4352       if(ueRecfg->ueLteAdvCfg.pres & RGR_ABS)
4353       {
4354          ue->lteAdvUeCb.rgrLteAdvUeCfg.isAbsUe = ueRecfg->ueLteAdvCfg.isAbsUe;
4355       }
4356
4357       if(ueRecfg->ueLteAdvCfg.pres & RGR_SFR)
4358       {
4359          ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge = ueRecfg->ueLteAdvCfg.isUeCellEdge;
4360       }
4361    }
4362 /* LTE_ADV_FLAG_REMOVED_END */
4363 #ifdef EMTC_ENABLE
4364    if(ueRecfg->ueRecfgTypes & RGR_UE_EMTC_DPLXMODE_RECFG)
4365    {
4366       rgSCHEmtcHdFddUeCfg (cell, ue,
4367                ueRecfg->emtcUeRecfg.isHdFddEnbld);
4368    }
4369    if(ueRecfg->ueRecfgTypes & RGR_UE_EMTC_PO_TRIGGER)
4370    {
4371       rgSCHEmtcPOTrigger(cell, ue);
4372    }
4373 #endif
4374    errInfo->errCause = RGSCHERR_NONE;
4375
4376    RETVALUE(ROK);
4377 }  /* rgSCHCfgRgrUeRecfg */
4378
4379
4380 /**
4381  * @brief Handler for the logical channel reconfiguration request from
4382  * RRC to MAC.
4383  *
4384  * @details
4385  *
4386  *     Function : rgSCHCfgRgrLchRecfg
4387  *
4388  *     Processing Steps:
4389  *      - Invoke scheduler to update scheduler specific information.
4390  *      - Update the dedicated logical channel Cb with the reconfigured
4391  *        values.
4392  *      - If successful, return ROK else RFAILED.
4393  *
4394  *  @param[in]  RgUlCellCb  *cell
4395  *  @param[in]  RgUlUeCb    *ue
4396  *  @param[in]  RgSchUlLcCb    *ulLc
4397  *  @param[in]  RgSchDlLcCb    *dlLc
4398  *  @param[in]  RgrLchRecfg *lcRecfg
4399  *  @param[out] RgSchErrInfo   *errInfo
4400  *  @return  S16
4401  *      -# ROK
4402  *      -# RFAILED
4403  **/
4404 #ifdef ANSI
4405 PUBLIC S16 rgSCHCfgRgrLchRecfg
4406 (
4407 RgSchCellCb    *cell,
4408 RgSchUeCb      *ue,
4409 RgSchDlLcCb    *dlLc,
4410 RgrLchRecfg    *lcRecfg,
4411 RgSchErrInfo   *errInfo
4412 )
4413 #else
4414 PUBLIC S16 rgSCHCfgRgrLchRecfg(cell, ue, dlLc, lcRecfg, errInfo)
4415 RgSchCellCb    *cell;
4416 RgSchUeCb      *ue;
4417 RgSchDlLcCb    *dlLc;
4418 RgrLchRecfg    *lcRecfg;
4419 RgSchErrInfo   *errInfo;
4420 #endif
4421 {
4422    S16     ret = ROK;
4423
4424    TRC2(rgSCHCfgRgrLchRecfg);
4425
4426    errInfo->errCause = RGSCHERR_CFG_RGR_LC_RECFG;
4427    /* Invoke Scheduler to update the new configuration */
4428    ret = rgSCHUtlRgrLcRecfg(cell, ue, dlLc, lcRecfg, errInfo);
4429    if (ret != ROK)
4430    {
4431       RLOG_ARG2(L_ERROR,DBG_CELLID,lcRecfg->cellId,"Scheduler handling for LC Recfg"
4432               " failed for CRNTI:%d LCID:%d",lcRecfg->crnti,lcRecfg->lcId);
4433       RETVALUE(RFAILED);
4434    }
4435
4436    errInfo->errCause = RGSCHERR_NONE;
4437    RETVALUE(ROK);
4438 }  /* rgSCHCfgRgrLchRecfg */
4439 /**
4440  * @brief Handler for the logical channel reconfiguration request from
4441  * RRC to MAC.
4442  *
4443  * @details
4444  *
4445  *     Function : rgSCHCfgRgrLcgRecfg
4446  *
4447  *     Processing Steps:
4448  *      - Invoke scheduler to update scheduler specific information.
4449  *      - Update the dedicated logical channel Cb with the re-configured
4450  *        values.
4451  *      - If successful, return ROK else RFAILED.
4452  *
4453  *  @param[in]  RgUlCellCb   *cell
4454  *  @param[in]  RgUlUeCb     *ue
4455  *  @param[in]  RgrLcgRecfg  *lcgRecfg
4456  *  @param[out] RgSchErrInfo *errInfo
4457  *  @return  S16
4458  *      -# ROK
4459  *      -# RFAILED
4460  **/
4461 #ifdef ANSI
4462 PUBLIC S16 rgSCHCfgRgrLcgRecfg
4463 (
4464 RgSchCellCb    *cell,
4465 RgSchUeCb      *ue,
4466 RgrLcgRecfg    *lcgRecfg,
4467 RgSchErrInfo   *errInfo
4468 )
4469 #else
4470 PUBLIC S16 rgSCHCfgRgrLcgRecfg(cell, ue, lcgRecfg, errInfo)
4471 RgSchCellCb    *cell;
4472 RgSchUeCb      *ue;
4473 RgrLcgRecfg    *lcgRecfg;
4474 RgSchErrInfo   *errInfo;
4475 #endif
4476 {
4477    S16     ret = ROK;
4478
4479    TRC2(rgSCHCfgRgrLcgRecfg);
4480
4481    errInfo->errCause = RGSCHERR_CFG_RGR_LCG_RECFG;
4482
4483    /*Added for handling LCG ReConfig if the LCG was deleted */
4484    ue->ul.lcgArr[lcgRecfg->ulRecfg.lcgId].lcgId = lcgRecfg->ulRecfg.lcgId;
4485
4486    /* Invoke Scheduler to update the new configuration */
4487    ret = rgSCHUtlRgrLcgRecfg(cell, ue, lcgRecfg, errInfo);
4488    if (ret != ROK)
4489    {
4490       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgRecfg->cellId,"Scheduler handling for LCG Recfg"
4491               " failed for CRNTI:%d LCGID:%d",lcgRecfg->crnti,lcgRecfg->ulRecfg.lcgId);
4492       RETVALUE(RFAILED);
4493    }
4494
4495    errInfo->errCause = RGSCHERR_NONE;
4496    RETVALUE(ROK);
4497 }  /* rgSCHCfgRgrLcgRecfg */
4498
4499 /**
4500  * @brief Handler for the UE Reset request from RRM to MAC.
4501  *
4502  * @details
4503  *
4504  *     Function : rgSCHCfgRgrUeReset
4505  *
4506  *     Processing Steps:
4507  *     - Call Measument Gap Module and Ack/Nack Module for resetting UE.
4508  *     - Call Common Schduler UE rest API which inturn will call scheduler
4509  *     specific UE Reset APis to reset UE.
4510  *
4511  *  @param[in]  RgSchCellCb    *cell
4512  *  @param[in]  RgSchUeCb      *ue
4513  *  @param[in]  RgrRst         *reset
4514  *  @param[out] RgSchErrInfo   *errInfo
4515  *  @return  S16
4516  *      -# ROK
4517  *      -# RFAILED
4518  **/
4519 #ifdef ANSI
4520 PUBLIC S16 rgSCHCfgRgrUeReset
4521 (
4522 RgSchCellCb    *cell,
4523 RgSchUeCb      *ue,
4524 RgrRst         *reset,
4525 RgSchErrInfo   *errInfo
4526 )
4527 #else
4528 PUBLIC S16 rgSCHCfgRgrUeReset(cell, ue, reset, errInfo)
4529 RgSchCellCb    *cell;
4530 RgSchUeCb      *ue;
4531 RgrRst         *reset;
4532 RgSchErrInfo   *errInfo;
4533 #endif
4534 {
4535    U32     idx;
4536    RgSchRaCb *raCb;
4537
4538    TRC2(rgSCHCfgRgrUeReset);
4539
4540
4541    errInfo->errCause = RGSCHERR_CFG_RGR_UE_RESET;
4542
4543    /* Setting BO of Each Logical Channel of the UE to 0 */
4544    for (idx = 0; idx < RGSCH_MAX_LC_PER_UE; idx++)
4545    {
4546       if(ue->dl.lcCb[idx] != NULLP)
4547          ue->dl.lcCb[idx]->bo = 0;
4548    }
4549
4550    /* Reset the totalBo */
4551    ue->totalBo = 0;
4552    /* Call DRX module to stop all DRX timers */
4553    /* ccpu00129899 */
4554    if(ue->drxCb != NULLP)
4555    {
4556      (Void)rgSCHDrxUeDel(cell,ue);
4557    }
4558
4559    /* ccpu00140894- Stop TXMode transiition timer if it is running*/
4560    if (ue->txModeTransTmr.tmrEvnt != TMR_NONE)
4561    {
4562       rgSCHTmrStopTmr(cell, RG_SCH_TMR_TXMODE_TRNSTN, ue);
4563       ue->txModeTransCmplt =TRUE;
4564    }
4565
4566    /* ccpu00133470- Meas Gap should be released during RRC re-establishment */
4567    rgSCHMeasGapANRepUeDel(cell, ue, FALSE);
4568
4569    /* Call Common scheduler which in turn will call specific scheduler for UE
4570     * Reset*/
4571    rgSCHUtlUeReset(cell, ue);
4572 #ifdef LTE_ADV
4573    /*PCell which is at idx 0 is always active. Adding a line after the loop
4574     *setting RGSCH_PCELL_INDEX to SCELL ACTIVE*/
4575    ue->cellInfo[RGSCH_PCELL_INDEX]->sCellState = RG_SCH_SCELL_ACTIVE;
4576 #endif
4577
4578    /* In case of back to back reestablishments, when this UE's
4579     * previous ReEst is still in progress and has got RESET
4580     * as part of new ReEst */
4581    if((raCb = rgSCHDbmGetRaCb(cell, ue->ueId)) != NULLP)
4582    {
4583       rgSCHRamDelRaCb(cell, raCb, FALSE);
4584    }
4585    /* Fix : syed set UE inactive in DL until UE is reinitialization completed */
4586    ue->dl.dlInactvMask |= RG_HQENT_INACTIVE;
4587    ue->ul.ulInactvMask |= RG_HQENT_INACTIVE;
4588    /* [ccpu00127141] Resetting TA related parameters */
4589    ue->dl.taCb.ta = RGSCH_NO_TA_RQD;
4590    ue->dl.taCb.state = RGSCH_TA_IDLE;
4591
4592    /*[ccpu00121813]-ADD-Initializing outstanding TA value */
4593    ue->dl.taCb.outStndngTa = FALSE;
4594    ue->dl.taCb.outStndngTaval = RGSCH_NO_TA_RQD;
4595
4596    if (ue->dl.taCb.cfgTaTmr)
4597    {
4598       rgSCHTmrStartTmr (cell, ue, RG_SCH_TMR_TA, ue->dl.taCb.cfgTaTmr);
4599    }
4600
4601 #ifdef DL_LA
4602    /* Resetting the Tx mode change factor on UE reset */
4603    ue->mimoInfo.txModUpChgFactor = 0;
4604    ue->mimoInfo.txModDownChgFactor = 0;
4605 #endif
4606
4607    errInfo->errCause = RGSCHERR_NONE;
4608    RETVALUE(ROK);
4609 }  /* rgSCHCfgRgrUeReset */
4610
4611 /**
4612  * @brief Handler for the cell delete request from RRM to MAC.
4613  *
4614  * @details
4615  *
4616  *     Function : rgSCHCfgRgrCellDel
4617  *
4618  *     Processing Steps:
4619  *      - Fetch the cell control block.
4620  *      - Remove the cell control block from the hash list of cells.
4621  *      - Free the cell control block.
4622  *      - If successful, return ROK else return RFAILED.
4623  *
4624  *  @param[in]  RgSchCellCb    *cell
4625  *  @param[in]  RgrDel         *cellDelInfo
4626  *  @param[out] RgSchErrInfo   *errInfo
4627  *  @return  S16
4628  *      -# ROK
4629  *      -# RFAILED
4630  **/
4631 #ifdef ANSI
4632 PUBLIC S16 rgSCHCfgRgrCellDel
4633 (
4634 RgSchCellCb    *cell,
4635 RgrDel         *cellDelInfo,
4636 RgSchErrInfo   *errInfo
4637 )
4638 #else
4639 PUBLIC S16 rgSCHCfgRgrCellDel(cell, cellDelInfo, errInfo)
4640 RgSchCellCb    *cell;
4641 RgrDel         *cellDelInfo;
4642 RgSchErrInfo   *errInfo;
4643 #endif
4644 {
4645    TRC2(rgSCHCfgRgrCellDel);
4646
4647
4648    errInfo->errCause = RGSCHERR_CFG_RGR_CELL_DEL;
4649
4650    if (cell->cellId != cellDelInfo->u.cellDel.cellId)
4651    {
4652       RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,
4653                 "Cell does not exist");
4654       RETVALUE(RFAILED);
4655    }
4656
4657    /* Free the active cell */
4658    rgSCHCfgFreeCellCb(cell);
4659
4660    errInfo->errCause = RGSCHERR_NONE;
4661    RETVALUE(ROK);
4662 }  /* rgSCHCfgRgrCellDel */
4663
4664
4665 /**
4666  * @brief Handler for the UE delete request from RRM to MAC.
4667  *
4668  * @details
4669  *
4670  *     Function : rgSCHCfgRgrUeDel
4671  *
4672  *     Processing Steps:
4673  *      - Fetch the UE control block.
4674  *      - Remove the UE control block from the hash list of UEs for the cell.
4675  *      - Free the UE control block.
4676  *      - If successful, return ROK else return RFAILED.
4677  *
4678  *  @param[in]  RgSchCellCb    *cell
4679  *  @param[in]  RgrDel         *ueDelInfo
4680  *  @param[out] RgSchErrInfo   *errInfo
4681  *  @return  S16
4682  *      -# ROK
4683  *      -# RFAILED
4684  **/
4685 #ifdef ANSI
4686 PUBLIC S16 rgSCHCfgRgrUeDel
4687 (
4688 RgSchCellCb         *cell,
4689 RgrDel              *ueDelInfo,
4690 RgSchErrInfo        *errInfo
4691 )
4692 #else
4693 PUBLIC S16 rgSCHCfgRgrUeDel(cell, ueDelInfo, errInfo)
4694 RgSchCellCb         *cell;
4695 RgrDel              *ueDelInfo;
4696 RgSchErrInfo        *errInfo;
4697 #endif
4698 {
4699    RgSchUeCb        *ue;
4700    RgSchRaCb        *raCb;
4701 #ifdef LTE_ADV
4702    Inst    inst = cell->instIdx;
4703    RgSchCellCb      *secCellCb = NULLP;
4704 #endif
4705
4706    TRC2(rgSCHCfgRgrUeDel);
4707    errInfo->errCause = RGSCHERR_CFG_RGR_UE_DEL;
4708
4709    if (cell->cellId != ueDelInfo->u.ueDel.cellId)
4710    {
4711       RLOG_ARG1(L_ERROR,DBG_CELLID,ueDelInfo->u.ueDel.cellId,
4712                 "Cell does not exist CRNTI:%d",
4713                 ueDelInfo->u.ueDel.crnti);
4714       RETVALUE(RFAILED);
4715    }
4716    if ((ue = rgSCHDbmGetUeCb(cell, ueDelInfo->u.ueDel.crnti)) == NULLP)
4717    {
4718       if((raCb = rgSCHDbmGetRaCb(cell, ueDelInfo->u.ueDel.crnti)) == NULLP)
4719       {
4720          RLOG_ARG1(L_ERROR,DBG_CELLID,ueDelInfo->u.ueDel.cellId,
4721                   "RaCb does not exist for CRNTI:%d",ueDelInfo->u.ueDel.crnti);
4722          RETVALUE(RFAILED);
4723       }
4724       else
4725       {
4726          /* This happens in case of Msg4 rejection */
4727          raCb->toDel = TRUE;
4728          RETVALUE(ROK);
4729       }
4730    }
4731    else
4732    {
4733 #ifdef LTE_ADV
4734       if(ueDelInfo->u.ueScellRel.ueDelTypes & RGR_UE_SCELL_DEL_RECFG)
4735       {
4736          for(U8 idx = 0; idx < ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.numSCells; idx++)
4737          {
4738             if(NULLP != (secCellCb = (RgSchCellCb *)rgSchUtlGetCellCb(inst, \
4739                         ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.ueSCellRelDedCfg[idx].sCellId)))
4740             {
4741                rgSCHUtlSndUeSCellDel2Mac(secCellCb, ue->ueId);
4742                rgSCHSCellDelUeSCell(cell,ue,ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.ueSCellRelDedCfg[idx].sCellIdx);
4743                ue->numSCells--;
4744                if ( ue->numSCells == 0)
4745                {
4746                   ue->allocCmnUlPdcch = TRUE;
4747                }
4748             }
4749          }
4750          if (ue->numSCells == 0)
4751          {
4752             /* As there is no SCell left so DCI 0 size at UE specific search space
4753              * will be recalculated as the CSI is reduced to 1 bit */
4754             rgSCHUtlUpdUeDciSize(cell, ue, FALSE);
4755          }
4756       }
4757       else
4758 #endif
4759       {
4760          /* Delete Ue from the UE list of CELL*/
4761          rgSCHDbmDelUeCb(cell, ue);
4762
4763 #ifdef LTE_L2_MEAS
4764          rgSCHDbmDelL2MUe(cell, ue);
4765 #endif
4766
4767          /* Call MeasGap and AckNakRep processing module */
4768          rgSCHMeasGapANRepUeDel(cell, ue, TRUE);
4769
4770          /* ccpu00140894- Stop TXMode transiition timer if it is running*/
4771          if (ue->txModeTransTmr.tmrEvnt != TMR_NONE)
4772          {
4773             rgSCHTmrStopTmr(cell, RG_SCH_TMR_TXMODE_TRNSTN, ue);
4774          }
4775
4776          /* Call DRX module to remove UEs from various
4777           * lists it maintain
4778           */
4779          /* ccpu00129899 */
4780          if(ue->drxCb != NULLP)
4781          {
4782             (Void)rgSCHDrxUeDel(cell,ue);
4783             /* Free Ue */
4784          }
4785          /*Fix: If RA CB exists, delete it*/
4786          if((raCb = rgSCHDbmGetRaCb(cell, ueDelInfo->u.ueDel.crnti)) != NULLP)
4787          {
4788             /* Fix : syed RNTI was getting released twice, once by racb del
4789              * and subsequently by ueDel. Let it get released by ueDel alone */
4790             rgSCHRamDelRaCb(cell, raCb, FALSE);
4791          }
4792 #ifdef EMTC_ENABLE
4793          if(ue->isEmtcUe)
4794          {
4795             rgSCHEmtcUeDel(cell, ue);
4796          }
4797 #endif
4798
4799          rgSCHCfgFreeUeCb(cell, ue);
4800
4801          errInfo->errCause = RGSCHERR_NONE;
4802
4803       }
4804       RETVALUE(ROK);
4805    }
4806 }  /* rgSCHCfgRgrUeDel */
4807
4808
4809 /**
4810  * @brief Handler for the logical channel delete request from
4811  * RRM to MAC.
4812  *
4813  * @details
4814  *
4815  *     Function : rgSCHCfgRgrLcDel
4816  *
4817  *     Processing Steps:
4818  *      - Fetch the logical channel control block.
4819  *      - Free the logical channel control block.
4820  *      - If successful, return ROK else return RFAILED.
4821  *
4822  *  @param[in]  RgrDel      *lcDelInfo
4823  *  @param[out] RgSchErrInfo   *errInfo
4824  *  @return  S16
4825  *      -# ROK
4826  *      -# RFAILED
4827  **/
4828 #ifdef ANSI
4829 PUBLIC S16 rgSCHCfgRgrLcDel
4830 (
4831 RgSchCellCb    *cell,
4832 RgrDel         *lcDelInfo,
4833 RgSchErrInfo   *errInfo
4834 )
4835 #else
4836 PUBLIC S16 rgSCHCfgRgrLcDel(cell, lcDelInfo, errInfo)
4837 RgSchCellCb    *cell;
4838 RgrDel         *lcDelInfo;
4839 RgSchErrInfo   *errInfo;
4840 #endif
4841 {
4842    RgSchUeCb    *ue;
4843    RgSchDlLcCb  *dlLc;
4844 #ifdef LTE_L2_MEAS
4845    U8          lcId;
4846    U8          idx;
4847    RgSchUlLcCb  *ulLc;
4848 #endif
4849
4850    TRC2(rgSCHCfgRgrLcDel);
4851
4852    errInfo->errCause = RGSCHERR_CFG_RGR_LC_DEL;
4853
4854    /* Fetch the Active cell */
4855    if (cell->cellId != lcDelInfo->u.lchDel.cellId)
4856    {
4857       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "Cell does not exist %d",
4858                   lcDelInfo->u.lchDel.cellId);
4859       RETVALUE(RFAILED);
4860    }
4861
4862    /* Fetch the Ue */
4863    if ((ue = rgSCHDbmGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
4864    {
4865       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4866                 "UE does not exist for CRNTI:%d LCID:%d",
4867                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
4868       RETVALUE(RFAILED);
4869    }
4870    if (lcDelInfo->u.lchDel.lcgId > 3)
4871    {
4872       RLOG_ARG3(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4873                 "[%d]UEID:For LC %d, LCGid %d is invalid",
4874                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId,
4875                lcDelInfo->u.lchDel.lcgId);
4876       RETVALUE(RFAILED);
4877    }
4878    if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
4879          == NULLP)
4880    {
4881       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4882                 "LC does not exist for CRNTI:%d LCID:%d",
4883                lcDelInfo->u.lchDel.crnti, lcDelInfo->u.lchDel.lcId);
4884       RETVALUE(RFAILED);
4885    }
4886    rgSCHUtlRgrLcDel(cell, ue, lcDelInfo->u.lchDel.lcId,lcDelInfo->u.lchDel.lcgId);
4887
4888    /* Reduce any pending bo from this LC(if any)
4889     * from the UE's total BO */
4890    if(dlLc->bo)
4891    {
4892       if(ue->totalBo >= dlLc->bo)
4893       {
4894          ue->totalBo -= dlLc->bo;
4895       }
4896       else
4897       {
4898         ue->totalBo = 0; /* this scenario should not occur */
4899       }
4900    }
4901    rgSCHDbmDelDlDedLcCb(ue, dlLc);
4902    rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
4903
4904 #ifdef LTE_L2_MEAS
4905    lcId = lcDelInfo->u.lchDel.lcId;
4906    if (TRUE == ue->ul.lcCb[lcId -1].isValid)
4907    {
4908       ulLc = &(ue->ul.lcCb[lcId -1]);
4909       ue->ul.lcCb[lcId -1].isValid = FALSE;
4910
4911       if((ulLc->qciCb->ulUeCount) &&
4912             (ue->ulActiveLCs & (1 << (ulLc->qciCb->qci -1))))
4913       {
4914          ulLc->qciCb->ulUeCount--;
4915          ue->ulActiveLCs &= ~(1 << (ulLc->qciCb->qci -1));
4916       }
4917       /* Shifting LCs in LCG Array because of LC deletion */
4918       for (idx = ulLc->lcgArrIdx +1; idx < ulLc->lcg->numLch;
4919                idx++)
4920       {
4921          ulLc->lcg->lcArray[idx -1] =
4922             ulLc->lcg->lcArray[idx];
4923          ulLc->lcg->lcArray[idx -1]->lcgArrIdx = idx -1;
4924       }
4925       ulLc->lcg->numLch--;
4926       ulLc->lcg->lcArray[idx -1] = NULLP;
4927    }
4928 #endif /* LTE_L2_MEAS */
4929
4930
4931    errInfo->errCause = RGSCHERR_NONE;
4932    RETVALUE(ROK);
4933 }  /* rgSCHCfgRgrLcDel */
4934
4935
4936
4937 /**
4938  * @brief Handler for the logical channel delete request from
4939  * RRM to MAC.
4940  *
4941  * @details
4942  *
4943  *     Function : rgSCHCfgRgrLcgDel
4944  *
4945  *     Processing Steps:
4946  *      - Fetch the logical channel control block.
4947  *      - Free the logical channel control block.
4948  *      - If successful, return ROK else return RFAILED.
4949  *
4950  *  @param[in]  RgrDel      *lcDelInfo
4951  *  @param[out] RgSchErrInfo   *errInfo
4952  *  @return  S16
4953  *      -# ROK
4954  *      -# RFAILED
4955  **/
4956 #ifdef ANSI
4957 PUBLIC S16 rgSCHCfgRgrLcgDel
4958 (
4959 RgSchCellCb    *cell,
4960 RgrDel         *lcDelInfo,
4961 RgSchErrInfo   *errInfo
4962 )
4963 #else
4964 PUBLIC S16 rgSCHCfgRgrLcgDel(cell, lcDelInfo, errInfo)
4965 RgSchCellCb    *cell;
4966 RgrDel         *lcDelInfo;
4967 RgSchErrInfo   *errInfo;
4968 #endif
4969 {
4970    RgSchUeCb    *ue = NULLP;
4971 #ifdef LTE_L2_MEAS
4972    U8           lcCount = 0;
4973 #endif
4974    U8           lcgId = 0;
4975
4976    TRC2(rgSCHCfgRgrLcgDel);
4977
4978
4979    lcgId = lcDelInfo->u.lcgDel.lcgId;
4980
4981    errInfo->errCause = RGSCHERR_CFG_RGR_LCG_DEL;
4982
4983    /* Fetch the Active cell */
4984    if (cell->cellId != lcDelInfo->u.lcgDel.cellId)
4985    {
4986       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4987                 "CELL does not exist for CRNTI:%d LCGID:%d",
4988                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
4989       RETVALUE(RFAILED);
4990    }
4991
4992    /* Fetch the Ue */
4993    if ((ue = rgSCHDbmGetUeCb(cell, lcDelInfo->u.lcgDel.crnti)) == NULLP)
4994    {
4995       RLOG_ARG2(L_ERROR,DBG_CELLID,lcDelInfo->u.lchDel.cellId,
4996                 "UE does not exist for CRNTI:%d LCGID:%d",
4997                lcDelInfo->u.lchDel.crnti,lcDelInfo->u.lchDel.lcId);
4998       RETVALUE(RFAILED);
4999    }
5000
5001    /* set lcgId in UEs lcg cntrl blk to invalid */
5002    rgSCHUtlRgrLcgDel(cell, ue, lcgId);
5003    ue->ul.lcgArr[lcgId].lcgId = RGSCH_INVALID_LCG_ID;
5004
5005 #ifdef LTE_L2_MEAS
5006    /* Since LCs are being deleted, if any of them are contributing
5007       to Active UE count for a QCI, decrease the count */
5008    for (lcCount =0; (lcCount < RGSCH_MAX_LC_PER_UE) &&
5009          (lcCount < ue->ul.lcgArr[lcgId].numLch) ; lcCount++)
5010    {
5011       if (ue->ul.lcgArr[lcgId].lcArray[lcCount])
5012       {
5013          if((ue->ul.lcgArr[lcgId].
5014                   lcArray[lcCount]->qciCb->ulUeCount) &&
5015             (ue->ulActiveLCs &
5016              (1 << ((ue->ul.lcgArr[lcgId].
5017                     lcArray[lcCount])->qciCb->qci -1))))
5018             {
5019                /* L2_COUNTERS */
5020                ue->ul.lcgArr[lcgId].
5021                   lcArray[lcCount]->qciCb->ulUeCount--;
5022                ue->ulActiveLCs &= ~(1 <<
5023                      (ue->ul.lcgArr[lcgId].
5024                       lcArray[lcCount]->qciCb->qci -1));
5025             }
5026       }
5027    }
5028 #endif
5029
5030    errInfo->errCause = RGSCHERR_NONE;
5031    RETVALUE(ROK);
5032 }  /* rgSCHCfgRgrLcgDel */
5033
5034
5035
5036 /***********************************************************
5037  *
5038  *     Func : rgSCHCfgVldtRgrLcCfg
5039  *
5040  *
5041  *     Desc : Validates dedicated logical channel configuration recieved from RRM.
5042  *
5043  *     Ret  : S16
5044  *            ROK - Success
5045  *            RFAILED - Failed
5046  *
5047  *     Notes:
5048  *
5049  *     File :
5050  *
5051  **********************************************************/
5052 #ifdef ANSI
5053 PUBLIC S16 rgSCHCfgVldtRgrLcCfg
5054 (
5055 Inst             inst,
5056 RgrLchCfg     *lcCfg,
5057 RgSchCellCb      **cell,
5058 RgSchUeCb        **ue,
5059 RgSchErrInfo     *errInfo
5060 )
5061 #else
5062 PUBLIC S16 rgSCHCfgVldtRgrLcCfg(inst, lcCfg, cell, ue, errInfo)
5063 Inst             inst;
5064 RgrLchCfg     *lcCfg;
5065 RgSchCellCb      **cell;
5066 RgSchUeCb        **ue;
5067 RgSchErrInfo     *errInfo;
5068 #endif
5069 {
5070    TRC2(rgSCHCfgVldtRgrLcCfg);
5071
5072
5073    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LC_CFG;
5074
5075    if (((*cell) == NULLP) ||
5076        ((*cell)->cellId != lcCfg->cellId))
5077    {
5078       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Cell does not existi for "
5079                "CRNTI:%d LCID:%d",lcCfg->crnti, lcCfg->lcId);
5080       RETVALUE(RFAILED);
5081    }
5082
5083    /* Fetch the Ue */
5084    if ((*ue = rgSCHDbmGetUeCb(*cell, lcCfg->crnti)) == NULLP)
5085    {
5086       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"UE does not exist for dedicated"
5087          " logical channel CRNTI:%d LCID:%d", lcCfg->crnti, lcCfg->lcId);
5088       RETVALUE(RFAILED);
5089    }
5090
5091    /* Validate logical channel Id */
5092    if ((lcCfg->lcId < RGSCH_DEDLC_MIN_LCID)
5093             ||(lcCfg->lcId > RGSCH_DEDLC_MAX_LCID))
5094    {
5095       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid logical channel Id:%d"
5096                "for CRNTI:%d",lcCfg->lcId,lcCfg->crnti);
5097       RETVALUE(RFAILED);
5098    }
5099
5100    if (lcCfg->lcType != CM_LTE_LCH_DTCH && lcCfg->lcType != CM_LTE_LCH_DCCH)
5101    {
5102       RLOG_ARG3(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid logical channel Type %d"
5103                "CRNTI:%d LCID:%d",lcCfg->lcType,lcCfg->crnti, lcCfg->lcId);
5104       RETVALUE(RFAILED);
5105    }
5106
5107    RETVALUE(ROK);
5108 }  /* rgSCHCfgVldtRgrLcCfg */
5109
5110 /***********************************************************
5111  *
5112  *     Func : rgSCHCfgVldtRgrLcgCfg
5113  *
5114  *
5115  *     Desc : Validates dedicated logical channel group configuration recieved from RRM.
5116  *
5117  *     Ret  : S16
5118  *            ROK - Success
5119  *            RFAILED - Failed
5120  *
5121  *     Notes:
5122  *
5123  *     File :
5124  *
5125  **********************************************************/
5126 #ifdef ANSI
5127 PUBLIC S16 rgSCHCfgVldtRgrLcgCfg
5128 (
5129 Inst             inst,
5130 RgrLcgCfg        *lcgCfg,
5131 RgSchCellCb      **cell,
5132 RgSchUeCb        **ue,
5133 RgSchErrInfo     *errInfo
5134 )
5135 #else
5136 PUBLIC S16 rgSCHCfgVldtRgrLcgCfg(inst, lcgCfg, cell, ue, errInfo)
5137 Inst             inst;
5138 RgrLcgCfg        *lcgCfg;
5139 RgSchCellCb      **cell;
5140 RgSchUeCb        **ue;
5141 RgSchErrInfo     *errInfo;
5142 #endif
5143 {
5144    TRC2(rgSCHCfgVldtRgrLcgCfg);
5145
5146
5147    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_DED_LCG_CFG;
5148
5149    if (((*cell) == NULLP) ||
5150        ((*cell)->cellId != lcgCfg->cellId))
5151    {
5152       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgCfg->cellId,"Cell does not exist for"
5153                "CRNTI:%d LCGID:%d",lcgCfg->crnti,lcgCfg->ulInfo.lcgId);
5154       RETVALUE(RFAILED);
5155    }
5156
5157    /* Fetch the Ue */
5158    if ((*ue = rgSCHDbmGetUeCb(*cell, lcgCfg->crnti)) == NULLP)
5159    {
5160       RLOG_ARG2(L_ERROR,DBG_CELLID,lcgCfg->cellId,"UE does not exist for "
5161         "dedicated logical channel CRNTI:%d LCGID:%d", lcgCfg->crnti, lcgCfg->ulInfo.lcgId);
5162       RETVALUE(RFAILED);
5163    }
5164
5165    if ((lcgCfg->ulInfo.gbr != 0) && (lcgCfg->ulInfo.mbr < lcgCfg->ulInfo.gbr))
5166    {
5167      RETVALUE(RFAILED);
5168    }
5169
5170    RETVALUE(ROK);
5171 }  /* rgSCHCfgVldtRgrLcgCfg */
5172
5173
5174 /***********************************************************
5175  *
5176  *     Func : rgSCHCfgVldtRgrCellPwrCfg
5177  *
5178  *     Desc : Validates cell power configuration.
5179  *
5180  *     Ret  : S16
5181  *            ROK - Success
5182  *            RFAILED - Failed
5183  *
5184  *     Notes:
5185  *
5186  *     File :
5187  *
5188  **********************************************************/
5189 #ifdef ANSI
5190 PRIVATE S16 rgSCHCfgVldtRgrCellPwrCfg
5191 (
5192 Inst             inst,
5193 RgrCellCfg       *cellCfg,
5194 RgSchErrInfo     *errInfo
5195 )
5196 #else
5197 PRIVATE S16 rgSCHCfgVldtRgrCellPwrCfg(inst, cellCfg, errInfo)
5198 Inst             inst;
5199 RgrCellCfg       *cellCfg;
5200 RgSchErrInfo     *errInfo;
5201 #endif
5202 {
5203    UNUSED(inst);
5204    UNUSED(cellCfg);
5205    UNUSED(errInfo);
5206
5207    TRC2(rgSCHCfgVldtRgrCellPwrCfg);
5208
5209    /* This function does nothing now, placeholder for
5210     * subsequent power config validations that may be needed */
5211
5212
5213    RETVALUE(ROK);
5214 }  /* rgSCHCfgVldtRgrCellPwrCfg */
5215
5216
5217 /***********************************************************
5218  *
5219  *     Func : rgSCHCfgVldtRgrCmnLcCfg
5220  *
5221  *
5222  *     Desc : Validates common logical channel configuration recieved from RRM.
5223  *
5224  *  @param[in]  Inst         inst
5225  *  @param[in]  RgrCellCfg   *cellCfg
5226  *  @param[out] RgSchErrInfo *errInfo
5227  *     Ret  : S16
5228  *            ROK - Success
5229  *            RFAILED - Failed
5230  *
5231  *     Notes:
5232  *
5233  *     File :
5234  *
5235  **********************************************************/
5236 #ifdef ANSI
5237 PRIVATE S16 rgSCHCfgVldtRgrCmnLcCfg
5238 (
5239 Inst             inst,
5240 RgrCellCfg       *cellCfg,
5241 RgSchErrInfo     *errInfo
5242 )
5243 #else
5244 PRIVATE S16 rgSCHCfgVldtRgrCmnLcCfg(inst, cellCfg, errInfo)
5245 Inst             inst;
5246 RgrCellCfg       *cellCfg;
5247 RgSchErrInfo     *errInfo;
5248 #endif
5249 {
5250    U8            idx;
5251    RgrCmnLchCfg  *lcCfg;
5252    U8            dirVld  = FALSE;
5253    U8            bitMask = 0x00;
5254    U8            cnt=0;
5255
5256    TRC2(rgSCHCfgVldtRgrCmnLcCfg);
5257
5258    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CMN_LC_CFG;
5259
5260    for (idx = 0; idx < cellCfg->numCmnLcs; idx++)
5261    {
5262       lcCfg = &(cellCfg->cmnLcCfg[idx]);
5263       /* Validate downlink info */
5264       if (lcCfg->dir & RGR_DIR_TX)
5265       {
5266          if (lcCfg->lcType == CM_LTE_LCH_BCCH)
5267          {
5268             if (lcCfg->dlTrchType == CM_LTE_TRCH_DL_SCH)
5269             {
5270                if(cnt == 0)
5271                {
5272                   bitMask |= RGSCH_BCCH_DLSCH_CFG1;
5273                   cnt++;
5274                }
5275                else
5276                {
5277
5278                   if((
5279                      (cellCfg->siCfg.siWinSize == 1)  ||
5280                      (cellCfg->siCfg.siWinSize == 2)  ||
5281                      (cellCfg->siCfg.siWinSize == 5)  ||
5282                      (cellCfg->siCfg.siWinSize == 10) ||
5283                      (cellCfg->siCfg.siWinSize == 15) ||
5284                      (cellCfg->siCfg.siWinSize == 20) ||
5285                      (cellCfg->siCfg.siWinSize == 40)) &&
5286                      (cellCfg->siCfg.retxCnt>0)
5287                     )
5288                   {
5289                      bitMask |= RGSCH_BCCH_DLSCH_CFG2;
5290                   }
5291                   else
5292                   {
5293                      RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,
5294                            "Invalid si config for cell");
5295                      RETVALUE(RFAILED);
5296                   }
5297                }
5298             }
5299             else if (lcCfg->dlTrchType == CM_LTE_TRCH_BCH)
5300             {
5301                bitMask |= RGSCH_BCCH_BCH_CFG;
5302             }
5303             else
5304             {
5305                RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,
5306                      "Invalid transport channel %d for cell", lcCfg->dlTrchType);
5307                RETVALUE(RFAILED);
5308             }
5309          }
5310          else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
5311          {
5312             bitMask |= RGSCH_PCCH_CFG;
5313          }
5314          else if (lcCfg->lcType == CM_LTE_LCH_CCCH)
5315          {
5316             bitMask |= RGSCH_DL_CCCH_CFG;
5317          }
5318          dirVld = TRUE;
5319       }
5320
5321       /* Validate uplink info */
5322       if (lcCfg->dir & RGR_DIR_RX)
5323       {
5324          /* Uplink CCCH */
5325          if (lcCfg->lcType != CM_LTE_LCH_CCCH)
5326          {
5327             RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,"Invalid UL common lcType %d "
5328              "for cell", lcCfg->lcType);
5329             RETVALUE(RFAILED);
5330          }
5331          else
5332          {
5333             bitMask |= RGSCH_UL_CCCH_CFG;
5334          }
5335          dirVld = TRUE;
5336       }
5337
5338       /* Invalid direction */
5339       if (!dirVld)
5340       {
5341          RLOG_ARG1(L_ERROR,DBG_CELLID, cellCfg->cellId,"Invalid Direction %d",
5342             lcCfg->dir);
5343          RETVALUE(RFAILED);
5344       }
5345    }
5346    if (bitMask != RGSCH_CELL_ACTIVE_CFG)
5347    {
5348       RLOG_ARG0(L_ERROR,DBG_CELLID, cellCfg->cellId,
5349                 "Invalid Common channel config for cell");
5350       RETVALUE(RFAILED);
5351    }
5352
5353    RETVALUE(ROK);
5354 }  /* rgSCHCfgVldtRgrCmnLcCfg */
5355
5356
5357 /***********************************************************
5358  *
5359  *     Func : rgSCHCfgVldtUeCqiModeCfg
5360  *
5361  *
5362  *     Desc : Validates UE CQI modes Configuration recieved from RRC.
5363  *
5364  *     Ret  : S16
5365  *            ROK - Success
5366  *            RFAILED - Failed
5367  *
5368  *     Notes:
5369  *
5370  *     File :
5371  *
5372  **********************************************************/
5373 #ifdef ANSI
5374 PRIVATE S16 rgSCHCfgVldtUeCqiModeCfg
5375 (
5376 RgSchCellCb       *cell,
5377 RgrUeDlCqiCfg     *ueDlCqiCfg
5378 )
5379 #else
5380 PRIVATE S16 rgSCHCfgVldtUeCqiModeCfg(cell, ueDlCqiCfg)
5381 RgSchCellCb       *cell;
5382 RgrUeDlCqiCfg     *ueDlCqiCfg;
5383 #endif
5384 {
5385
5386     TRC2(rgSCHCfgVldtUeCqiModeCfg)
5387
5388 #ifndef TFU_UPGRADE
5389    if((ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx < 1) ||
5390          (ueDlCqiCfg->prdCqiCfg.cqiPmiCfgIdx > 1024))
5391    {
5392       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
5393                   "Invalid Periodic CQI Info");
5394       RETVALUE(RFAILED);
5395    }
5396 #endif
5397    /* Validate UE Aperiodic CQI mode */
5398    if ((ueDlCqiCfg->aprdCqiCfg.pres == TRUE) &&
5399        ((ueDlCqiCfg->aprdCqiCfg.aprdModeEnum > RGR_APRD_CQI_MOD31) ||
5400         (cell->bwCfg.dlTotalBw <= 7)))
5401    {
5402       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
5403                   "Invalid Aperiodic mode config for DL CQI",
5404             ueDlCqiCfg->aprdCqiCfg.aprdModeEnum);
5405       RETVALUE(RFAILED);
5406    }
5407 #ifndef TFU_UPGRADE
5408    /* Validate UE Periodic CQI mode */
5409    if (ueDlCqiCfg->prdCqiCfg.prdModeEnum > RGR_PRD_CQI_MOD21)
5410    {
5411       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
5412                   "Invalid periodic mode config for DL CQI",
5413                   ueDlCqiCfg->prdCqiCfg.prdModeEnum);
5414       RETVALUE(RFAILED);
5415    }
5416    /* Validate K value in periodic CQI Config */
5417    if(((ueDlCqiCfg->prdCqiCfg.prdModeEnum == RGR_PRD_CQI_MOD20) ||
5418             (ueDlCqiCfg->prdCqiCfg.prdModeEnum == RGR_PRD_CQI_MOD21)) &&
5419          ((ueDlCqiCfg->prdCqiCfg.k < 1)||
5420             (ueDlCqiCfg->prdCqiCfg.k > 4)))
5421    {
5422       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
5423                   "Invalid K for Subband CQI reporting");
5424       RETVALUE(RFAILED);
5425    }
5426 #else
5427    if ((ueDlCqiCfg->prdCqiCfg.type == 1) &&
5428        (ueDlCqiCfg->prdCqiCfg.cqiSetup.prdModeEnum > RGR_PRD_CQI_MOD21))
5429    {
5430      RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
5431                  "Invalid periodic mode config for DL CQI",
5432                  ueDlCqiCfg->prdCqiCfg.cqiSetup.prdModeEnum);
5433      RETVALUE(RFAILED);
5434    }
5435
5436 #endif
5437
5438    RETVALUE(ROK);
5439
5440 }
5441 /***********************************************************
5442  *
5443  *     Func : rgSCHCfgVldtUeMeasGapAckNakRepCfg
5444  *
5445  *
5446  *     Desc : Validates UE Measurement Gap and Ack Nack Repetition Configuration recieved from RRC.
5447  *
5448  *     Ret  : S16
5449  *            ROK - Success
5450  *            RFAILED - Failed
5451  *
5452  *     Notes:
5453  *
5454  *     File :
5455  *
5456  **********************************************************/
5457 #ifdef ANSI
5458 PRIVATE S16 rgSCHCfgVldtUeMeasGapAckNakRepCfg
5459 (
5460 RgSchCellCb       *cell,
5461 RgrUeCfg          *ueCfg
5462 )
5463 #else
5464 PRIVATE S16 rgSCHCfgVldtUeMeasGapAckNakRepCfg(cell, ueCfg)
5465 RgSchCellCb       *cell;
5466 RgrUeCfg          *ueCfg;
5467 #endif
5468 {
5469
5470    TRC2(rgSCHCfgVldtUeMeasGapAckNakRepCfg)
5471
5472 #ifdef LTE_TDD
5473    if ((ueCfg->ackNackModeEnum == RGR_TDD_ACKNACK_MODE_MULT) &&
5474          (ueCfg->ueAckNackCfg.isAckNackEnabled == TRUE))
5475    {
5476       RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"TDD ACK NACK Multiplexing Mode"
5477       "is not allowed when Ack/Nack is Enabled: %d CRNTI:%d",
5478        ueCfg->ueAckNackCfg.ackNackRepFactor,ueCfg->crnti);
5479       RETVALUE(RFAILED);
5480    }
5481 #endif /* LTE_TDD */
5482    /* Validate AckNackRep Factor */
5483    if((ueCfg->ueAckNackCfg.isAckNackEnabled == FALSE) &&
5484          (!ueCfg->ueMesGapCfg.isMesGapEnabled))
5485    {
5486       RETVALUE(ROK);
5487    }
5488
5489    if(ueCfg->ueAckNackCfg.isAckNackEnabled)
5490    {
5491    if ( (ueCfg->ueAckNackCfg.ackNackRepFactor < RGR_ACKNACK_REPFACT_N2)
5492          || (ueCfg->ueAckNackCfg.ackNackRepFactor > RGR_ACKNACK_REPFACT_N6))
5493    {
5494       RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId, "Invalid ACK NACK REP Factor:%d CRNTI:%d",
5495                ueCfg->ueAckNackCfg.ackNackRepFactor,ueCfg->crnti);
5496       RETVALUE(RFAILED);
5497    }
5498    }
5499    if(ueCfg->ueMesGapCfg.isMesGapEnabled)
5500    {
5501    switch(ueCfg->ueMesGapCfg.gapPrd)
5502    {
5503       case RG_MEAS_GAPPRD_40:
5504          if(ueCfg->ueMesGapCfg.gapOffst >= RG_MEAS_GAPPRD_40)
5505          {
5506             RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Offset:%d CRNTI:%d",
5507                      ueCfg->ueMesGapCfg.gapOffst,ueCfg->crnti);
5508             RETVALUE(RFAILED);
5509          }
5510          break;
5511       case RG_MEAS_GAPPRD_80:
5512          if(ueCfg->ueMesGapCfg.gapOffst >= RG_MEAS_GAPPRD_80)
5513          {
5514             RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Offset:%d CRNTI:%d",
5515                      ueCfg->ueMesGapCfg.gapOffst,ueCfg->crnti);
5516             RETVALUE(RFAILED);
5517          }
5518          break;
5519          default:
5520          {
5521             RLOG_ARG2(L_ERROR,DBG_CELLID,ueCfg->cellId,"Invalid GAP Periodicity Settings:%d"
5522                       "CRNTI:%d", ueCfg->ueMesGapCfg.gapPrd,ueCfg->crnti);
5523             RETVALUE(RFAILED);
5524          }
5525       }
5526    }
5527
5528    RETVALUE(ROK);
5529 }  /* rgSCHCfgVldtUeMeasGapAckNakRepCfg*/
5530
5531
5532 /***********************************************************
5533  *
5534  *     Func : rgSCHCfgVldtUeMeasGapAckNakRepRecfg
5535  *
5536  *
5537  *     Desc : Validates UE Measurement Gap and Ack Nack Repetition Configuration recieved from RRC.
5538  *
5539  *     Ret  : S16
5540  *            ROK - Success
5541  *            RFAILED - Failed
5542  *
5543  *     Notes:
5544  *
5545  *     File :
5546  *
5547  **********************************************************/
5548 #ifdef ANSI
5549 PRIVATE S16 rgSCHCfgVldtUeMeasGapAckNakRepRecfg
5550 (
5551 RgSchCellCb       *cell,
5552 RgrUeRecfg        *ueRecfg
5553 )
5554 #else
5555 PRIVATE S16 rgSCHCfgVldtUeMeasGapAckNakRepRecfg(cell, ueRecfg)
5556 RgSchCellCb       *cell;
5557 RgrUeRecfg        *ueRecfg;
5558 #endif
5559 {
5560
5561    TRC2(rgSCHCfgVldtUeMeasGapAckNakRepRecfg)
5562    if((ueRecfg->ueAckNackRecfg.isAckNackEnabled == FALSE) &&
5563           (!ueRecfg->ueMeasGapRecfg.isMesGapEnabled))
5564    {
5565       RETVALUE(ROK);
5566    }
5567
5568    if(ueRecfg->ueAckNackRecfg.isAckNackEnabled )
5569    {
5570    /* Validate AckNackRep Factor */
5571    if ( (ueRecfg->ueAckNackRecfg.ackNackRepFactor < RGR_ACKNACK_REPFACT_N2)
5572          || (ueRecfg->ueAckNackRecfg.ackNackRepFactor > RGR_ACKNACK_REPFACT_N6))
5573    {
5574       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid ACK NACK REP Factor:%d"
5575                "NEW CRNTI:%d",ueRecfg->ueAckNackRecfg.ackNackRepFactor,ueRecfg->newCrnti);
5576       RETVALUE(RFAILED);
5577    }
5578    }
5579    if(ueRecfg->ueMeasGapRecfg.isMesGapEnabled)
5580    {
5581    switch(ueRecfg->ueMeasGapRecfg.gapPrd)
5582    {
5583       case RG_MEAS_GAPPRD_40:
5584          if(ueRecfg->ueMeasGapRecfg.gapOffst >= RG_MEAS_GAPPRD_40)
5585          {
5586             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Offset:%d"
5587                      "NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapOffst,ueRecfg->newCrnti);
5588             RETVALUE(RFAILED);
5589          }
5590          break;
5591       case RG_MEAS_GAPPRD_80:
5592          if(ueRecfg->ueMeasGapRecfg.gapOffst >= RG_MEAS_GAPPRD_80)
5593          {
5594             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Offset:%d"
5595                      "NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapOffst,ueRecfg->newCrnti);
5596             RETVALUE(RFAILED);
5597          }
5598          break;
5599          default:
5600          {
5601             RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid GAP Periodicity Settings:%d"
5602                      "NEW CRNTI:%d",ueRecfg->ueMeasGapRecfg.gapPrd,ueRecfg->newCrnti);
5603             RETVALUE(RFAILED);
5604          }
5605       }
5606    }
5607
5608    RETVALUE(ROK);
5609 }  /* rgSCHCfgVldtUeMeasGapAckNakRepRecfg*/
5610
5611 #ifdef LTEMAC_SPS
5612 /***********************************************************
5613  *
5614  *     Func : rgSCHCfgVldtUeDlSpsCfg
5615  *
5616  *
5617  *     Desc : Validates UE's DL SPS configuration recieved from RRC.
5618  *
5619  *     Ret  : S16
5620  *            ROK - Success
5621  *            RFAILED - Failed
5622  *
5623  *     Notes:
5624  *
5625  *     File :
5626  *
5627  **********************************************************/
5628 #ifdef ANSI
5629 PRIVATE S16 rgSCHCfgVldtUeDlSpsCfg
5630 (
5631 RgSchCellCb       *cell,
5632 RgrUeSpsDlCfg     *dlSpsCfg
5633 )
5634 #else
5635 PRIVATE S16 rgSCHCfgVldtUeDlSpsCfg(cell, dlSpsCfg)
5636 RgSchCellCb       *cell;
5637 RgrUeSpsDlCfg     *dlSpsCfg;
5638 #endif
5639 {
5640
5641    U8                 idx = 0;
5642
5643    TRC2(rgSCHCfgVldtUeDlSpsCfg);
5644
5645    /* peridicity validation done in SPS module */
5646    if ((dlSpsCfg->numPucchVal > RG_SCH_MAX_NUM_N1PUCCH_PER_UE) ||
5647          (dlSpsCfg->numPucchVal == 0))
5648    {
5649       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid number of n1Pucch values"
5650                " in DL SPS Config");
5651       RETVALUE(RFAILED);
5652    }
5653
5654    for (idx = 0; idx < dlSpsCfg->numPucchVal; ++idx)
5655    {
5656       if (dlSpsCfg->n1PucchVal[idx] > RG_SCH_MAX_N1PUCCH_VAL)
5657       {
5658 #ifdef ALIGN_64BIT
5659          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid N1Pucch value"
5660                   " in DL SPS Config %u", dlSpsCfg->n1PucchVal[idx]);
5661 #else
5662          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid N1Pucch value"
5663                   " in DL SPS Config %lu", dlSpsCfg->n1PucchVal[idx]);
5664 #endif
5665          RETVALUE(RFAILED);
5666       }
5667    }
5668    /* SPS_TODO: check will change for TDD */
5669    if ((dlSpsCfg->numSpsHqProc == 0) ||
5670          (dlSpsCfg->numSpsHqProc > RGSCH_MAX_DL_HQ_PROC))
5671    {
5672       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid number of SPS HARQ procs"
5673                " in DL SPS Config");
5674       RETVALUE(RFAILED);
5675    }
5676
5677    RETVALUE(ROK);
5678 }  /* rgSCHCfgVldtDlSpsCfg */
5679 #endif /* LTEMAC_SPS */
5680
5681 /***********************************************************
5682  *
5683  *     Func : rgSCHCfgVldtUePwrCfg
5684  *
5685  *
5686  *     Desc : Validates UE Group power configuration recieved from RRC.
5687  *
5688  *     Ret  : S16
5689  *            ROK - Success
5690  *            RFAILED - Failed
5691  *
5692  *     Notes:
5693  *
5694  *     File :
5695  *
5696  **********************************************************/
5697 #ifdef ANSI
5698 PRIVATE S16 rgSCHCfgVldtUePwrCfg
5699 (
5700 RgSchCellCb       *cell,
5701 RgrUeUlPwrCfg     *pwrCfg
5702 )
5703 #else
5704 PRIVATE S16 rgSCHCfgVldtUePwrCfg(cell, pwrCfg)
5705 RgSchCellCb       *cell;
5706 RgrUeUlPwrCfg     *pwrCfg;
5707 #endif
5708 {
5709
5710    TRC2(rgSCHCfgVldtUePwrCfg);
5711
5712    /* Group power control works only in accumulated mode */
5713    if (!pwrCfg->isAccumulated)
5714    {
5715       /* Fix */
5716       if (pwrCfg->uePuschPwr.pres)
5717       {
5718          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Accumulation configutation"
5719               " not in sync with group power configuration");
5720          RETVALUE(RFAILED);
5721       }
5722    }
5723
5724    if (rgSCHCfgVldtUeGrpPwrCfg(cell, &pwrCfg->uePuschPwr) != ROK)
5725    {
5726       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid PUSCH Group power"
5727            " configuration");
5728       RETVALUE(RFAILED);
5729    }
5730    if (rgSCHCfgVldtUeGrpPwrCfg(cell, &pwrCfg->uePucchPwr) != ROK)
5731    {
5732       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid PUSCH Group power"
5733            " configuration");
5734       RETVALUE(RFAILED);
5735    }
5736
5737    RETVALUE(ROK);
5738 }  /* rgSCHCfgVldtUePwrCfg */
5739
5740 /***********************************************************
5741  *
5742  *     Func : rgSCHCfgVldtUeGrpPwrCfg
5743  *
5744  *
5745  *     Desc : Validates UE Group power configuration recieved from RRC.
5746  *
5747  *     Ret  : S16
5748  *            ROK - Success
5749  *            RFAILED - Failed
5750  *
5751  *     Notes:
5752  *
5753  *     File :
5754  *
5755  **********************************************************/
5756 #ifdef ANSI
5757 PRIVATE S16 rgSCHCfgVldtUeGrpPwrCfg
5758 (
5759 RgSchCellCb       *cell,
5760 RgrUeGrpPwrCfg *grpPwrCfg
5761 )
5762 #else
5763 PRIVATE S16 rgSCHCfgVldtUeGrpPwrCfg(cell, grpPwrCfg)
5764 RgSchCellCb       *cell;
5765 RgrUeGrpPwrCfg *grpPwrCfg;
5766 #endif
5767 {
5768
5769    TRC2(rgSCHCfgVldtUeGrpPwrCfg);
5770
5771    if ((grpPwrCfg->pres) &&
5772        (((grpPwrCfg->tpcRnti > cell->rntiDb.rntiStart) &&
5773         ((grpPwrCfg->tpcRnti <
5774                      (cell->rntiDb.rntiStart + cell->rntiDb.maxRntis))))))
5775    {
5776       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Uplink Group power "
5777              "configuration");
5778       RETVALUE(RFAILED);
5779    }
5780
5781    RETVALUE(ROK);
5782 }  /* rgSCHCfgVldtUeGrpPwrCfg */
5783
5784 #ifdef LTEMAC_SPS
5785 /***********************************************************
5786  *
5787  *     Func : rgSCHCfgVldtSpsReCfg
5788  *
5789  *
5790  *     Desc : Validates UE SPS and other SPS dependent
5791  *     configuration recieved from RRC.
5792  *
5793  *     Ret  : S16
5794  *            ROK - Success
5795  *            RFAILED - Failed
5796  *
5797  *     Notes:
5798  *
5799  *     File :
5800  *
5801  **********************************************************/
5802 #ifdef ANSI
5803 PRIVATE S16 rgSCHCfgVldtSpsReCfg
5804 (
5805 RgSchCellCb       *cell,
5806 RgSchUeCb         *ue,
5807 RgrUeRecfg        *ueRecfg
5808 )
5809 #else
5810 PRIVATE S16 rgSCHCfgVldtSpsReCfg(cell, ue, ueRecfg)
5811 RgSchCellCb       *cell;
5812 RgSchUeCb         *ue;
5813 RgrUeRecfg     *ueRecfg;
5814 #endif
5815 {
5816
5817    TRC2(rgSCHCfgVldtSpsReCfg);
5818    if ((ueRecfg->ueRecfgTypes & RGR_UE_DLSPS_RECFG) &&
5819          (ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled))
5820    {
5821       /* Validating SPS RNTI */
5822       if (((ueRecfg->ueSpsRecfg.spsRnti >=  cell->rntiDb.rntiStart) &&
5823           (ueRecfg->ueSpsRecfg.spsRnti<=
5824           (cell->rntiDb.rntiStart+cell->rntiDb.maxRntis)))||
5825           (ueRecfg->ueSpsRecfg.spsRnti == RGSCH_SI_RNTI) ||
5826           (ueRecfg->ueSpsRecfg.spsRnti == RGSCH_P_RNTI))
5827       {
5828          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid SPS RNTI "
5829                   " in DL SPS Recfg OLD CRNTI:%d NEW CCRNTI:%d",
5830                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5831          RETVALUE(RFAILED);
5832       }
5833       if (rgSCHCfgVldtUeDlSpsCfg(cell, &ueRecfg->ueSpsRecfg.dlSpsCfg) != ROK)
5834       {
5835          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid DL SPS configuration"
5836                   " for the OLD CRNTI:%d NEW CRNTI:%d",
5837                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5838          RETVALUE(RFAILED);
5839       }
5840    }
5841
5842 #if RG_SPS_UNUSED
5843    if(ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled)
5844    {
5845      if (ueRecfg->ueRecfgTypes & RGR_UE_DRX_RECFG)
5846      {
5847      /* ccpu00117035 - MOD - changed instIdx to inst */
5848      /* ccpu00117035 - MOD - changed ueID to oldCrnti*/
5849       RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
5850                " DRX reconfig not supported DL SPS enabled for OLD CRNTI:%d NEW CRNTI:%d",
5851                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5852       RETVALUE(RFAILED);
5853      }
5854    }
5855 #endif
5856 /* ccpu00117627 - ADD - SPS recfg validation against HDFDD */
5857 #ifdef LTEMAC_HDFDD
5858    if(ueRecfg->ueSpsRecfg.dlSpsCfg.isDlSpsEnabled)
5859    {
5860       if(ue->hdFddEnbld == TRUE)
5861       {
5862          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
5863                   "DL SPS is not supported for HDFDD enabled for OLD CRNTI:%d NEW CRNTI:%d",
5864                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5865          RETVALUE(RFAILED);
5866       }
5867    }
5868    if(ueRecfg->ueSpsRecfg.ulSpsCfg.isUlSpsEnabled)
5869    {
5870       if(ue->hdFddEnbld == TRUE)
5871       {
5872          RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,
5873                   "UL SPS is not supported for HDFDD enabled for OLD CRNTI:%d NEW CRNTI:%d",
5874                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5875          RETVALUE(RFAILED);
5876       }
5877    }
5878 #endif
5879
5880    RETVALUE(ROK);
5881 }  /*rgSCHCfgVldtSpsReCfg*/
5882 #endif
5883
5884 #if ((defined (RGR_CQI_REPT)) && (defined (RGR_V2)))
5885 /***********************************************************
5886  *
5887  *     Func : rgSCHCfgVldtCqiReptReCfg
5888  *
5889  *
5890  *     Desc : Validates UE CQI report for DL Power control
5891  *     configuration recieved from RRC.
5892  *
5893  *     Ret  : S16
5894  *            ROK - Success
5895  *            RFAILED - Failed
5896  *
5897  *     Notes:
5898  *
5899  *     File :
5900  *
5901  **********************************************************/
5902 #ifdef ANSI
5903 PRIVATE S16 rgSCHCfgVldtCqiReptReCfg
5904 (
5905 RgSchCellCb       *cell,
5906 RgrUeRecfg     *ueRecfg
5907 )
5908 #else
5909 PRIVATE S16 rgSCHCfgVldtCqiReptReCfg(cell, ueRecfg)
5910 RgSchCellCb       *cell;
5911 RgrUeRecfg     *ueRecfg;
5912 #endif
5913 {
5914
5915    TRC2(rgSCHCfgVldtCqiReptReCfg);
5916    /* Validate DL Power Control Config parameters */
5917    if (ueRecfg->ueCqiReptCfg.numColltdCqiRept > RGR_CQIRPTS_MAXN)
5918    {
5919       RLOG_ARG3(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalide numColltdCqiRept,"
5920                "MAX supported %d for OLD CRNTI:%d NEW CRNTI:%d",RGR_CQIRPTS_MAXN,
5921                   ueRecfg->oldCrnti,ueRecfg->newCrnti);
5922       RETVALUE(RFAILED);
5923    }
5924
5925    RETVALUE(ROK);
5926 }  /*rgSCHCfgVldtCqiReptReCfg*/
5927 #endif
5928
5929 /***********************************************************
5930  *
5931  *     Func : rgSCHCfgRgrLcChfg
5932  *
5933  *
5934  *     Desc : Handles dedicated logical channel configuration
5935  *     recieved from RRC.
5936  *
5937  *     Ret  : S16
5938  *            ROK - Success
5939  *            RFAILED - Failed
5940  *
5941  *     Notes:
5942  *
5943  *     File :
5944  *
5945  **********************************************************/
5946 #ifdef ANSI
5947 PUBLIC S16 rgSCHCfgRgrLchCfg
5948 (
5949 RgSchCellCb      *cell,
5950 RgSchUeCb        *ue,
5951 RgrLchCfg     *lcCfg,
5952 RgSchErrInfo     *errInfo
5953 )
5954 #else
5955 PUBLIC S16 rgSCHCfgRgrLchCfg(cell, ue, lcCfg, errInfo)
5956 RgSchCellCb      *cell;
5957 RgSchUeCb        *ue;
5958 RgrLchCfg     *lcCfg;
5959 RgSchErrInfo     *errInfo;
5960 #endif
5961 {
5962    S16       ret;
5963    RgSchDlLcCb  *dlLc = NULLP;
5964    Inst    inst = cell->instIdx;
5965 #ifdef LTE_L2_MEAS
5966    RgSchUlLcCb  *ulLc;
5967 #endif
5968
5969    TRC2(rgSCHCfgRgrLchCfg);
5970
5971    errInfo->errCause = RGSCHERR_CFG_RGR_DED_LC_CFG;
5972
5973    /* Allocate the downlink logical channel control block */
5974    if((ret = rgSCHUtlAllocSBuf(inst, (Data**)&dlLc,
5975                sizeof(RgSchDlLcCb))) != ROK)
5976    {
5977       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
5978                "Downlink LCId:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
5979       RETVALUE(RFAILED);
5980    }
5981    if ((U8 *)dlLc == NULLP)
5982    {
5983       RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
5984                "Downlink LCID:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
5985       RETVALUE(RFAILED);
5986    }
5987    dlLc->lcId   = lcCfg->lcId;
5988 #ifdef LTE_ADV
5989    rgSCHLaaLcCfg(cell, dlLc, lcCfg);
5990 #endif
5991
5992    rgSCHDbmInsDlDedLcCb(ue, dlLc);
5993
5994    ret = rgSCHUtlRgrLcCfg(cell, ue, dlLc, lcCfg, errInfo);
5995
5996    if (ret != ROK)
5997    {
5998       /* ROLLBACK */
5999       if (dlLc)
6000       {
6001          rgSCHDbmDelDlDedLcCb(ue, dlLc);
6002          rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
6003       }
6004
6005       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
6006         "configuration failed at SCH:UEID:%d LCID:%d CRNTI:%d",
6007         ue->ueId, lcCfg->lcId,lcCfg->crnti);
6008       RETVALUE(RFAILED);
6009    }
6010 #ifdef LTE_L2_MEAS
6011    RGSCH_ARRAY_BOUND_CHECK(inst, ue->ul.lcCb, (lcCfg->lcId -1));
6012    if ( !lcCfg->lcId ||
6013          (TRUE == ue->ul.lcCb[lcCfg->lcId -1].isValid))
6014    {
6015       /* ROLLBACK */
6016       if (dlLc)
6017       {
6018          rgSCHDbmDelDlDedLcCb(ue, dlLc);
6019          rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
6020       }
6021
6022       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
6023         "configuration failed at SCH: UL LC CB already existing"
6024         " UEID:%d LCID:%d CRNTI:%d",
6025         ue->ueId, lcCfg->lcId,lcCfg->crnti);
6026       RETVALUE(RFAILED);
6027    }
6028
6029    /* Create UL LC context to maintain LCG to LC mapping and
6030       LC and QCI mapping, this is for L2 Counters :UL ACTIVE UE
6031       PER QCI */
6032    ue->ul.lcCb[lcCfg->lcId -1].isValid = TRUE;
6033    ulLc = &(ue->ul.lcCb[lcCfg->lcId -1]);
6034
6035    ulLc->lcId = lcCfg->lcId;
6036    ulLc->qciCb = &(cell->qciArray[lcCfg->dlInfo.dlQos.qci]);
6037    ulLc->qciCb->qci = lcCfg->dlInfo.dlQos.qci;
6038    ue->ul.lcgArr[lcCfg->lcgId].lcArray[ue->ul.lcgArr[lcCfg->lcgId].numLch] = ulLc;
6039    ulLc->lcg = &ue->ul.lcgArr[lcCfg->lcgId];
6040    ulLc->lcgArrIdx = ue->ul.lcgArr[lcCfg->lcgId].numLch;
6041    ue->ul.lcgArr[lcCfg->lcgId].numLch++;
6042
6043    dlLc->qciCb = &(cell->qciArray[lcCfg->dlInfo.dlQos.qci]);
6044    dlLc->qciCb->qci = lcCfg->dlInfo.dlQos.qci;
6045    if(lcCfg->lcType == CM_LTE_LCH_DTCH)
6046    {
6047      rgSchAddToL2Meas(cell,dlLc); /*LTE_L2_MEAS_PHASE2*/
6048    }
6049 #endif /* LTE_L2_MEAS */
6050
6051    RETVALUE(ROK);
6052 }  /* rgSCHCfgRgrLchCfg */
6053
6054 /***********************************************************
6055  *
6056  *     Func : rgSCHCfgRgrLcgCfg
6057  *
6058  *
6059  *     Desc : Handles dedicated logical channel group configuration
6060  *     recieved from RRM.
6061  *
6062  *     Ret  : S16
6063  *            ROK - Success
6064  *            RFAILED - Failed
6065  *
6066  *     Notes:
6067  *
6068  *     File :
6069  *
6070  **********************************************************/
6071 #ifdef ANSI
6072 PUBLIC S16 rgSCHCfgRgrLcgCfg
6073 (
6074 RgSchCellCb      *cell,
6075 RgSchUeCb        *ue,
6076 RgrLcgCfg        *lcgCfg,
6077 RgSchErrInfo     *errInfo
6078 )
6079 #else
6080 PUBLIC S16 rgSCHCfgRgrLcgCfg(cell, ue, lcgCfg, errInfo)
6081 RgSchCellCb      *cell;
6082 RgSchUeCb        *ue;
6083 RgrLcgCfg        *lcgCfg;
6084 RgSchErrInfo     *errInfo;
6085 #endif
6086 {
6087    S16          ret = ROK;
6088
6089 #ifdef RG_UNUSED
6090 //#ifdef LTE_L2_MEAS
6091    U32          idx;
6092    RgSchUlLcCb  *ulLc;
6093 #endif
6094    TRC2(rgSCHCfgRgrLcgCfg);
6095
6096    errInfo->errCause = RGSCHERR_CFG_RGR_DED_LCG_CFG;
6097
6098    ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcgId = lcgCfg->ulInfo.lcgId;
6099
6100    ret = rgSCHUtlRgrLcgCfg(cell, ue, lcgCfg, errInfo);
6101    if (ret != ROK)
6102    {
6103       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,"Dedicated logical channel "
6104         "configuration failed at SCH: UEID:%d LCGID:%d CRNTI:%d",
6105         ue->ueId, lcgCfg->ulInfo.lcgId,lcgCfg->crnti);
6106       /* Roll back lcgCfg */
6107       ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcgId = RGSCH_INVALID_LCG_ID;
6108       rgSCHUtlRgrLcgDel(cell, ue, lcgCfg->ulInfo.lcgId);
6109       RETVALUE(RFAILED);
6110    }
6111 #ifdef RG_UNUSED
6112 //#ifdef LTE_L2_MEAS
6113    /* Copy all info of UL LCH in cfg to ulLcgCb */
6114    for (idx = 0; idx < lcgCfg->ulInfo.numLch; idx++)
6115    {
6116       /* Allocate the uplink logical channel control block */
6117       if((ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data**)&ulLc,
6118                   sizeof(RgSchUlLcCb))) != ROK)
6119       {
6120          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Memory allocation FAILED for ");
6121          RETVALUE(RFAILED);
6122       }
6123       if ((U8 *)ulLc == NULLP)
6124       {
6125          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Memory allocation FAILED for ");
6126          RETVALUE(RFAILED);
6127       }
6128       /* Create UL LC context to maintain LCG to LC mapping and
6129          LC and QCI mapping, this is for L2 Counters :UL ACTIVE UE
6130          PER QCI */
6131       ulLc->lcId = lcgCfg->ulInfo.lchUlCfg[idx].lcId;
6132       ulLc->qciCb = &(cell->qciArray[lcgCfg->ulInfo.lchUlCfg[idx].qci]);
6133       ulLc->qciCb->qci = lcgCfg->ulInfo.lchUlCfg[idx].qci;
6134       ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].lcArray[idx] = ulLc;
6135       /* L2_COUNTERS */
6136       ue->ul.lcCb[ulLc->lcId -1] = ulLc;
6137       ulLc->lcg = &ue->ul.lcgArr[lcgCfg->ulInfo.lcgId];
6138       ulLc->lcgArrIdx = idx;
6139    }
6140    ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].numLch = lcgCfg->ulInfo.numLch;
6141 #endif /* LTE_L2_MEAS */
6142
6143    RETVALUE(ROK);
6144 }  /* rgSCHCfgRgrLcgCfg */
6145
6146
6147
6148 /***********************************************************
6149  *
6150  *     Func : rgSCHCfgRgrCmnLcCfg
6151  *
6152  *
6153  *     Desc : Handles dedicated logical channel configuration
6154  *     recieved from RRC.
6155  *
6156  *     Ret  : S16
6157  *            ROK - Success
6158  *            RFAILED - Failed
6159  *
6160  *     Notes:
6161  *
6162  *     File :
6163  *
6164  **********************************************************/
6165 #ifdef ANSI
6166 PRIVATE S16 rgSCHCfgRgrCmnLcCfg
6167 (
6168 RgSchCellCb           *cell,
6169 RgrCmnLchCfg          *lcCfg,
6170 RgSchErrInfo          *errInfo
6171 )
6172 #else
6173 PRIVATE S16 rgSCHCfgRgrCmnLcCfg(cell, lcCfg, errInfo)
6174 RgSchCellCb         *cell;
6175 RgrCmnLchCfg        *lcCfg;
6176 RgSchErrInfo        *errInfo;
6177 #endif
6178 {
6179    RgSchClcDlLcCb cmnLcCb;
6180    TRC2(rgSCHCfgRgrCmnLcCfg);
6181
6182    errInfo->errCause = RGSCHERR_CFG_RGR_CMN_LC_CFG;
6183
6184    cmMemset((U8 *)&cmnLcCb, 0, sizeof(cmnLcCb));
6185
6186    /* Handle configuration for CCCH/BCCH/PCCH */
6187    if (lcCfg->lcType == CM_LTE_LCH_CCCH)
6188    {
6189       /* UL and DL CCCH configuration */
6190       if (lcCfg->dir & RGR_DIR_TX)
6191       {
6192          cell->dlCcchId = lcCfg->lcId;
6193       }
6194
6195       if (lcCfg->dir & RGR_DIR_RX)
6196       {
6197          cell->ulCcchId = lcCfg->lcId;
6198       }
6199    }
6200    else
6201    {
6202       cmnLcCb.lcId = lcCfg->lcId;
6203       rgSCHDbmInitCmnLcBoLst(&cmnLcCb);
6204       if (lcCfg->lcType == CM_LTE_LCH_BCCH)
6205       {
6206          /* BCCH on BCH and DLSCH configuration */
6207          if (lcCfg->dlTrchType == CM_LTE_TRCH_DL_SCH)
6208          {
6209             rgSCHDbmInsBcchOnDlsch(cell, &cmnLcCb);
6210          }
6211          else
6212          {
6213             rgSCHDbmInsBcchOnBch(cell, &cmnLcCb);
6214          }
6215       }
6216       else  /* PCCH configuration */
6217       {
6218          rgSCHDbmInsPcch(cell, &cmnLcCb);
6219       }
6220    }
6221
6222    RETVALUE(ROK);
6223 }  /* rgSCHCfgRgrCmnLcCfg */
6224
6225
6226
6227 /***********************************************************
6228  *
6229  *     Func : rgSCHCfgFreeDlDedLcCb
6230  *
6231  *
6232  *     Desc :
6233  *     - Processing Steps:
6234  *        - Frees downlink dedicated logical channel control block.
6235  *
6236  *     Ret  : Void
6237  *
6238  *     Notes:
6239  *
6240  *     File :
6241  *
6242  **********************************************************/
6243 #ifdef ANSI
6244 PRIVATE Void rgSCHCfgFreeDlDedLcCb
6245 (
6246 RgSchCellCb      *cell,
6247 RgSchUeCb        *ue,
6248 RgSchDlLcCb      *dlLc
6249 )
6250 #else
6251 PRIVATE Void rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc)
6252 RgSchCellCb      *cell;
6253 RgSchUeCb        *ue;
6254 RgSchDlLcCb      *dlLc;
6255 #endif
6256 {
6257    Inst    inst = cell->instIdx;
6258    TRC2(rgSCHCfgFreeDlDedLcCb);
6259
6260    rgSCHUtlFreeDlLc(cell, ue, dlLc);
6261
6262    /* De-allocate the Cb */
6263    /* ccpu00117052 - MOD - Passing double pointer
6264       for proper NULLP assignment*/
6265    rgSCHUtlFreeSBuf(inst, (Data **)&dlLc, sizeof(*dlLc));
6266
6267
6268   /* Stack Crash problem for TRACE5 changes. Added the return below */
6269   RETVOID;
6270
6271 }  /* rgSCHCfgFreeDlDedLcCb */
6272
6273
6274 /***********************************************************
6275  *
6276  *     Func : rgSCHCfgFreeDlCmnLcCb
6277  *
6278  *
6279  *     Desc :
6280  *     - Processing Steps:
6281  *        - Frees downlink common logical channel control block.
6282  *
6283  *     Ret  : Void
6284  *
6285  *     Notes:
6286  *
6287  *     File :
6288  *
6289  **********************************************************/
6290 #ifdef ANSI
6291 PRIVATE Void rgSCHCfgFreeDlCmnLcCb
6292 (
6293 RgSchClcDlLcCb   *cmnDlLc
6294 )
6295 #else
6296 PRIVATE Void rgSCHCfgFreeDlCmnLcCb(cmnDlLc)
6297 RgSchClcDlLcCb      *cmnDlLc;
6298 #endif
6299 {
6300    TRC2(rgSCHCfgFreeDlCmnLcCb);
6301
6302    cmMemset((U8*)cmnDlLc, 0, sizeof(*cmnDlLc));
6303    cmnDlLc->lcId = RGSCH_INVALID_LC_ID;
6304    RETVOID;
6305 }  /* rgSCHCfgFreeDlCmnLcCb */
6306
6307
6308 /***********************************************************
6309  *
6310  *     Func : rgSCHCfgFreeCellCb
6311  *
6312  *
6313  *     Desc :
6314  *     - Processing Steps:
6315  *        - Frees scheduler cell control block.
6316  *
6317  *     Ret  : Void
6318  *
6319  *     Notes:
6320  *
6321  *     File :
6322  *
6323  **********************************************************/
6324 #ifdef ANSI
6325 PUBLIC Void rgSCHCfgFreeCellCb
6326 (
6327 RgSchCellCb      *cell
6328 )
6329 #else
6330 PUBLIC Void rgSCHCfgFreeCellCb(cell)
6331 RgSchCellCb      *cell;
6332 #endif
6333 {
6334    Inst    inst = cell->instIdx;
6335    CmLList            *node;
6336    Buffer             *pdu;
6337    RgSchWarningSiInfo *warningSi;
6338    RgSchWarningSiPdu  *warningSiPdu;
6339    U8                  idx;
6340
6341    TRC2(rgSCHCfgFreeCellCb);
6342    /* ccpu00132385- SI Warning PDUs which are not processed need to be deleted */
6343    /* Search for used index in WarningSi */
6344    for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
6345    {
6346       if(cell->siCb.warningSi[idx].siId == 0)
6347         continue;
6348       cell->siCb.siCtx.siId = cell->siCb.warningSi[idx].siId;
6349       warningSi = (RgSchWarningSiInfo *) cell->siCb.
6350                   siArray[cell->siCb.siCtx.siId-1].si;
6351       if(warningSi != NULLP)
6352       {
6353          /* ccpu00136659: CMAS ETWS design change */
6354          while (CM_LLIST_FIRST_NODE(&warningSi->warningSiMsg.segLstCp, node))
6355          {
6356             warningSiPdu = (RgSchWarningSiPdu *)node->node;
6357             pdu = warningSiPdu->pdu;
6358             /* ccpu00136659: CMAS ETWS design change */
6359             cmLListDelFrm(&warningSi->warningSiMsg.segLstCp, node);
6360             RGSCH_FREE_MSG(pdu);
6361          }
6362          cell->siCb.siArray[cell->siCb.siCtx.siId-1].si = NULLP;
6363       }
6364    }
6365    /* Free lists of the cell */
6366    rgSCHCfgFreeUeLst(cell);
6367 #ifdef LTEMAC_SPS
6368    rgSCHCfgFreeSpsUeLst(cell);
6369 #endif /* LTEMAC_SPS */
6370 #ifdef EMTC_ENABLE
6371       if ( TRUE == cell->emtcEnable )
6372       {
6373          rgSCHEmtcCellDel(cell);
6374       }
6375 #endif
6376    rgSCHRamFreeCell(cell);
6377
6378    rgSCHDbmRntiDbDeInit(cell);
6379    /* Deallocate the subframe allocation information */
6380    rgSCHUtlPutSfAlloc(cell);
6381    rgSCHUtlFreeCell(cell);
6382
6383    rgSCHCfgFreeRgrCfgLst(cell);
6384    rgSCHCfgFreeCmnLcLst(cell);
6385
6386    rgSCHUtlPutRlsHqAlloc(cell);
6387
6388 #ifdef LTE_TDD
6389    rgSCHDbmDeInitUeTfuPendLst(cell);
6390 #endif /* LTE_TDD */
6391
6392 #ifdef RGR_SI_SCH
6393    rgSCHUtlPutSiInfo(cell);
6394 #endif/*RGR_SI_SCH*/
6395
6396    (Void)rgSCHDrxCellDel(cell);
6397
6398    rgSCHUtlFreeSBuf(inst, (Data**)&(cell->dynCfiCb.cceFailSamples),
6399                (cell->dynCfiCb.numFailSamples * sizeof(U16)));
6400
6401 #ifdef TENB_STATS
6402    TSL2DeallocCellStatsBlk(cell->cellId);
6403 #endif
6404
6405 #ifdef LTE_ADV
6406    /* LAA_SCELL: Trigger the De-Init function for the LAA Module */
6407    rgSCHLaaSCellCbDeInit(cell);
6408 #endif
6409
6410 #ifdef EMTC_ENABLE
6411    if(cell->emtcEnable)
6412    {
6413       rgSCHEmtcCellFree(cell);
6414    }
6415 #endif
6416    /* De-allocate the Cell */
6417    /* ccpu00117052 - MOD - Passing double pointer
6418    for proper NULLP assignment*/
6419    rgSCHUtlFreeSBuf(inst, (Data **)&cell, sizeof(*cell));
6420
6421
6422
6423   /* Stack Crash problem for TRACE5 changes. Added the return below */
6424   RETVOID;
6425
6426 }  /* rgSCHCfgFreeCellCb */
6427
6428
6429 /***********************************************************
6430  *
6431  *     Func : rgSCHCfgFreeUeCb
6432  *
6433  *
6434  *     Desc :
6435  *     - Processing Steps:
6436  *        - Frees UE control block.
6437  *
6438  *     Ret  : Void
6439  *
6440  *     Notes:
6441  *
6442  *     File :
6443  *
6444  **********************************************************/
6445 #ifdef ANSI
6446 PRIVATE Void rgSCHCfgFreeUeCb
6447 (
6448 RgSchCellCb    *cell,
6449 RgSchUeCb      *ue
6450 )
6451 #else
6452 PRIVATE Void rgSCHCfgFreeUeCb(cell, ue)
6453 RgSchCellCb    *cell;
6454 RgSchUeCb      *ue;
6455 #endif
6456 {
6457    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
6458    RgUeUlHqCb       *ulHqEnt;
6459    RgSchDlLcCb       *dlLc;
6460    Inst    inst = cell->instIdx;
6461    U8 lcCnt;
6462    U8 lcgId;
6463    TRC2(rgSCHCfgFreeUeCb);
6464
6465    /* Free all logical channel info per UE */
6466    while((dlLc = rgSCHDbmGetNextDlDedLcCb(ue, NULLP)) != NULLP)
6467    {
6468       rgSCHDbmDelDlDedLcCb(ue, dlLc);
6469       rgSCHCfgFreeDlDedLcCb(cell, ue, dlLc);
6470    }
6471    for (lcCnt =0; lcCnt<RGSCH_MAX_LC_PER_UE; lcCnt++)
6472    {
6473       if(ue->ul.lcCb[lcCnt].isValid == TRUE)
6474       {
6475          lcgId = ue->ul.lcCb[lcCnt].lcg->lcgId;
6476          if (lcgId <=3)
6477          {
6478             rgSCHUtlRgrLcDel(cell, ue, ue->ul.lcCb[lcCnt].lcId,lcgId);
6479             ue->ul.lcCb[lcCnt].isValid = FALSE;
6480          }
6481       }
6482    }
6483
6484    ulHqEnt = &(ueUl->hqEnt);
6485    /* Free Scheduler specific information per UE */
6486    rgSCHUtlFreeUe(cell, ue);
6487
6488    /* Free Uplink HARQ specific information per UE */
6489    rgSCHUhmFreeUe(cell, ulHqEnt);
6490
6491    if ( ue->drxCb != NULLP)
6492    {
6493       /* free drxCb */
6494    /* ccpu00117052 - MOD - Passing double pointer
6495    for proper NULLP assignment*/
6496       rgSCHUtlFreeSBuf(cell->instIdx,
6497             (Data**)(&(ue->drxCb)),
6498             sizeof(RgSchDrxUeCb));
6499    }
6500
6501    ue->drxCb = (RgSchDrxUeCb *)NULLP;
6502    /* Free Downlink HARQ specific information per UE */
6503    rgSCHDhmFreeUe(ue);
6504    /* Release the RNTI */
6505    if (ue->rntiLnk)
6506    {
6507       rgSCHUtlRlsRnti(cell, ue->rntiLnk, FALSE, 0);
6508    }
6509    else
6510    {
6511       /* Fix : syed HO UE does not have a valid ue->rntiLnk */
6512       /* Just indicate to MAC, no need to release at SCH */
6513       rgSCHUtlIndRntiRls2Mac(cell, ue->ueId, FALSE, 0);
6514    }
6515 /* rg009.201. Added changes of TFU_UPGRADE */
6516 #ifdef TFU_UPGRADE
6517     rgSCHCfgPCqiSrsSrUeDel(cell,ue);
6518 #endif
6519 #ifdef LTEMAC_HDFDD
6520     rgSCHHdFddUeDel(cell, ue);
6521 #endif
6522 #ifdef TENB_STATS
6523     if (ue->tenbStats)
6524     {
6525        TSL2DeallocUeStatsBlk(ue->ueId, ue->tenbStats);
6526     }
6527 #endif
6528
6529    /* CA TODO Some handling needed while SCell Delete*/
6530 #ifdef LTE_ADV
6531    /* Delete the UE from the PCell secCellActCeLst*/
6532    rgSCHSCellRmvFrmActLst(cell, ue);
6533    rgSCHSCellDelUe(cell,ue);
6534 #endif
6535
6536 #ifdef LTE_ADV
6537    rgSCHLaaDeInitDlRbAllocCb(cell, &ue->cellInfo[RGSCH_PCELL_INDEX]->dlAllocCb);
6538 #endif
6539
6540    rgSCHUtlFreeSBuf(inst, (Data **)&ue->cellInfo[0], sizeof(RgSchUeCellInfo));
6541    /* De-allocate the Ue */
6542    /* ccpu00117052 - MOD - Passing double pointer
6543    for proper NULLP assignment*/
6544 #ifdef EMTC_ENABLE
6545    if(ue->isEmtcUe)
6546    {
6547       rgSCHEmtcUeInfoFree(cell, ue);
6548    }
6549 #endif
6550    rgSCHUtlFreeSBuf(inst, (Data **)&ue, sizeof(*ue));
6551
6552   /* Stack Crash problem for TRACE5 changes. Added the return below */
6553   RETVOID;
6554
6555 }  /* rgSCHCfgFreeUeCb */
6556
6557 /***********************************************************
6558  *
6559  *     Func : rgSCHCfgFreeRgrCfgLst
6560  *
6561  *
6562  *     Desc :
6563  *     - Processing Steps:
6564  *        - Frees configuration lists in cell control block.
6565  *
6566  *     Ret  : Void
6567  *
6568  *     Notes:
6569  *
6570  *     File :
6571  *
6572  **********************************************************/
6573 #ifdef ANSI
6574 PRIVATE Void rgSCHCfgFreeRgrCfgLst
6575 (
6576 RgSchCellCb      *cell
6577 )
6578 #else
6579 PRIVATE Void rgSCHCfgFreeRgrCfgLst(cell)
6580 RgSchCellCb      *cell;
6581 #endif
6582 {
6583    RgSchCfgElem  *rgCfgElem;
6584    Inst    inst = cell->instIdx;
6585
6586    TRC2(rgSCHCfgFreeRgrCfgLst);
6587
6588    /* Free CURRENT RGR cfg list */
6589    while ((rgCfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
6590    {
6591       rgSCHDbmDelCrntRgrCfgElem(cell, rgCfgElem);
6592    /* ccpu00117052 - MOD - Passing double pointer
6593    for proper NULLP assignment*/
6594       rgSCHUtlFreeSBuf(inst, (Data **)&rgCfgElem, sizeof(*rgCfgElem));
6595    }
6596
6597    /* Free PENDING RGR cfg list */
6598    while ((rgCfgElem = rgSCHDbmGetNextPndngRgrCfgElem(cell, NULLP)) != NULLP)
6599    {
6600       rgSCHDbmDelPndngRgrCfgElem(cell, rgCfgElem);
6601    /* ccpu00117052 - MOD - Passing double pointer
6602    for proper NULLP assignment*/
6603       rgSCHUtlFreeSBuf(inst, (Data **)&rgCfgElem, sizeof(*rgCfgElem));
6604    }
6605
6606
6607   /* Stack Crash problem for TRACE5 changes. Added the return below */
6608   RETVOID;
6609
6610 }  /* rgSCHCfgFreeRgrCfgLst */
6611
6612
6613 /***********************************************************
6614  *
6615  *     Func : rgSCHCfgFreeCmnLcLst
6616  *
6617  *
6618  *     Desc :
6619  *     - Processing Steps:
6620  *        - Frees common logical channels in cell control block.
6621  *
6622  *     Ret  : Void
6623  *
6624  *     Notes:
6625  *
6626  *     File :
6627  *
6628  **********************************************************/
6629 #ifdef ANSI
6630 PRIVATE Void rgSCHCfgFreeCmnLcLst
6631 (
6632 RgSchCellCb      *cell
6633 )
6634 #else
6635 PRIVATE Void rgSCHCfgFreeCmnLcLst(cell)
6636 RgSchCellCb      *cell;
6637 #endif
6638 {
6639    RgSchClcDlLcCb *dlCmnLc;
6640
6641    TRC2(rgSCHCfgFreeCmnLcLst);
6642
6643    if ((dlCmnLc = rgSCHDbmGetBcchOnBch(cell)) != NULLP)
6644    {
6645       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6646    }
6647    if ((dlCmnLc = rgSCHDbmGetFirstBcchOnDlsch(cell)) != NULLP)
6648    {
6649       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6650    }
6651    if ((dlCmnLc = rgSCHDbmGetSecondBcchOnDlsch(cell)) != NULLP)
6652    {
6653       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6654    }
6655    if ((dlCmnLc = rgSCHDbmGetPcch(cell)) != NULLP)
6656    {
6657       rgSCHCfgFreeDlCmnLcCb(dlCmnLc);
6658    }
6659
6660
6661   /* Stack Crash problem for TRACE5 changes. Added the return below */
6662   RETVOID;
6663
6664 }  /* rgSCHCfgFreeCmnLcLst */
6665
6666
6667 /***********************************************************
6668  *
6669  *     Func : rgSCHCfgFreeUeLst
6670  *
6671  *
6672  *     Desc :
6673  *     - Processing Steps:
6674  *        - Frees UE list in cell control block.
6675  *
6676  *     Ret  : Void
6677  *
6678  *     Notes:
6679  *
6680  *     File :
6681  *
6682  **********************************************************/
6683 #ifdef ANSI
6684 PRIVATE Void rgSCHCfgFreeUeLst
6685 (
6686 RgSchCellCb      *cell
6687 )
6688 #else
6689 PRIVATE Void rgSCHCfgFreeUeLst(cell)
6690 RgSchCellCb      *cell;
6691 #endif
6692 {
6693    RgSchUeCb     *ue;
6694 #ifdef LTE_ADV
6695    RgSchUeCellInfo *sCellInfo;
6696    CmLList         *node;
6697 #endif
6698    TRC2(rgSCHCfgFreeUeLst);
6699
6700    /* Free Ues in the list */
6701    while ((ue = rgSCHDbmGetNextUeCb(cell, NULLP)) != NULLP)
6702    {
6703       rgSCHDbmDelUeCb(cell, ue);
6704
6705 #ifdef LTE_ADV
6706       if(ue->cell != cell)
6707       {
6708          continue;
6709       }
6710 #endif
6711
6712       /* Call MeasGap and AckNakRep processing module */
6713       rgSCHMeasGapANRepUeDel(cell, ue, TRUE);
6714
6715       rgSCHCfgFreeUeCb(cell, ue);
6716    }
6717
6718    /* De-initialize the Ue list */
6719    rgSCHDbmDeInitUeCbLst(cell);
6720
6721
6722 #ifdef LTE_ADV
6723    node = cell->sCellUeLst.first;
6724    while(node)
6725    {
6726       sCellInfo = (RgSchUeCellInfo *)node->node;
6727       node = node->next;
6728       rgSCHSCellDelUeSCell(sCellInfo->ue->cell, sCellInfo->ue, sCellInfo->sCellIdx);
6729    }
6730 #endif
6731
6732   /* Stack Crash problem for TRACE5 changes. Added the return below */
6733   RETVOID;
6734
6735 }  /* rgSCHCfgFreeUeLst */
6736
6737 #ifdef LTEMAC_SPS
6738 /***********************************************************
6739  *
6740  *     Func : rgSCHCfgFreeSpsUeLst
6741  *
6742  *
6743  *     Desc :
6744  *     - Processing Steps:
6745  *        - Frees Sps UE list in cell control block.
6746  *
6747  *     Ret  : Void
6748  *
6749  *     Notes:
6750  *
6751  *     File :
6752  *
6753  **********************************************************/
6754 #ifdef ANSI
6755 PRIVATE Void rgSCHCfgFreeSpsUeLst
6756 (
6757 RgSchCellCb      *cell
6758 )
6759 #else
6760 PRIVATE Void rgSCHCfgFreeSpsUeLst(cell)
6761 RgSchCellCb      *cell;
6762 #endif
6763 {
6764    RgSchUeCb     *ue;
6765
6766    TRC2(rgSCHCfgFreeSpsUeLst);
6767
6768    /* Free Ues in the list */
6769    while ((ue = rgSCHDbmGetNextSpsUeCb(cell, NULLP)))
6770    {
6771       rgSCHDbmDelSpsUeCb(cell, ue);
6772    }
6773
6774    /* De-initialize the Ue list */
6775    rgSCHDbmDeInitSpsUeCbLst(cell);
6776
6777 }  /* rgSCHCfgFreeSpsUeLst */
6778
6779 #endif /* LTEMAC_SPS */
6780
6781 #ifdef RGR_SI_SCH
6782 /***********************************************************
6783  *
6784  *     Func : rgSCHCfgVldtRgrCellSiCfg
6785  *
6786  *     Desc : Validates SI Configuration for SI
6787  *
6788  *     Ret  : S16
6789  *            ROK - Success
6790  *            RFAILED - Failed
6791  *
6792  *     Notes:
6793  *
6794  *     File :
6795  *
6796  **********************************************************/
6797 #ifdef ANSI
6798 PRIVATE S16 rgSCHCfgVldtRgrCellSiCfg
6799 (
6800 Inst             inst,
6801 RgrSiCfg         *siCfg
6802 )
6803 #else
6804 PRIVATE S16 rgSCHCfgVldtRgrCellSiCfg(inst, siCfg)
6805 Inst             inst;
6806 RgrSiCfg       *siCfg;
6807 #endif
6808 {
6809    U8   idx; /* idx for iteration */
6810
6811    UNUSED(inst);
6812
6813    TRC2(rgSCHCfgVldtRgrCellSiCfg);
6814
6815
6816 #ifndef LTE_TDD
6817    /* Check that retxCnt value should be <= value of siWinSize.
6818    This validation is only applicable for FDD mode. */
6819    if(siCfg->retxCnt > siCfg->siWinSize)
6820    {
6821       RLOG0(L_ERROR,"retxCnt is greater than siWinSize, validation failed");
6822       RETVALUE(RFAILED);
6823    }
6824 #endif
6825
6826    /* Validate that a valid value for numSi has been specified */
6827    if(siCfg->numSi > RGR_MAX_NUM_SI)
6828    {
6829       RLOG0(L_ERROR,"Validation for numSi in SI CFG failed");
6830       RETVALUE(RFAILED);
6831    }
6832
6833    /* MinPeriodicity will have the least configured periodicity
6834     * Hence initializing with Max periodicity */
6835    siCfg->minPeriodicity = RGR_SI_PERD_512;
6836
6837    /*Validate the value of periodicity specified for SIs */
6838    for(idx = 0;idx < siCfg->numSi;idx++)
6839    {
6840       siCfg->minPeriodicity =     RGSCH_MIN(siCfg->minPeriodicity,
6841             siCfg->siPeriodicity[idx]);
6842          /* Set the siPeriodicity as a multiple of 80 subframes */
6843          switch(siCfg->siPeriodicity[idx])
6844          {
6845             case RGR_SI_PERD_8:
6846             case RGR_SI_PERD_16:
6847             case RGR_SI_PERD_32:
6848             case RGR_SI_PERD_64:
6849             case RGR_SI_PERD_128:
6850             case RGR_SI_PERD_256:
6851             case RGR_SI_PERD_512:
6852                continue;
6853
6854          default:
6855             RLOG0(L_ERROR,"Validation for SI Periodicity in SI-CFG failed");
6856             RETVALUE(RFAILED);
6857       }
6858    }
6859
6860    RETVALUE(ROK);
6861 }  /* rgSCHCfgVldtRgrCellSiCfg */
6862
6863 /* LTE_ADV_FLAG_REMOVED_START */
6864 /***********************************************************
6865  *
6866  *     Func : rgSCHCfgVldtRgrCellLtrAdvCfg
6867  *
6868  *     Desc : Validates Lte Adv Configuration
6869  *
6870  *     Ret  : S16
6871  *            ROK - Success
6872  *            RFAILED - Failed
6873  *
6874  *     Notes:
6875  *
6876  *     File :
6877  *
6878  **********************************************************/
6879 #ifdef ANSI
6880 PRIVATE S16 rgSCHCfgVldtRgrCellLteAdvCfg
6881 (
6882  Inst                     inst,
6883  RgrLteAdvancedCellConfig *lteAdvCfg,
6884  U8                       dlTotalBw
6885  )
6886 #else
6887 PRIVATE S16 rgSCHCfgVldtRgrCellLteAdvCfg(inst, lteAdvCfg, dlTotalBw)
6888    Inst                     inst;
6889    RgrLteAdvancedCellConfig *lteAdvCfg;
6890    U8                       dlTotalBw;
6891 #endif
6892 {
6893    U8 temp[RGR_ABS_PATTERN_LEN];
6894    U32 idx;
6895    UNUSED(inst);
6896
6897    TRC2(rgSCHCfgVldtRgrCellLteAdvCfg);
6898
6899
6900    if((lteAdvCfg->pres & RGR_SFR) && (RGR_ENABLE == lteAdvCfg->sfrCfg.status))
6901    {
6902       if(lteAdvCfg->sfrCfg.cellEdgeRbRange.startRb > lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb)
6903       {
6904          RLOG0(L_ERROR,"Invalid configuration of cell edge bandwidth for SFR feature");
6905          RETVALUE(RFAILED);
6906       }
6907
6908       if(lteAdvCfg->sfrCfg.cellEdgeRbRange.endRb >= dlTotalBw)
6909       {
6910          RLOG0(L_ERROR,"Invalid configuration of cell edge end RB for SFR feature");
6911          RETVALUE(RFAILED);
6912       }
6913
6914 #ifdef TFU_UPGRADE
6915       if(lteAdvCfg->sfrCfg.pwrThreshold.pLow >= lteAdvCfg->sfrCfg.pwrThreshold.pHigh)
6916       {
6917          RLOG0(L_ERROR,"Invalid configuration of power threshold for SFR feature");
6918          RETVALUE(RFAILED);
6919       }
6920 #endif
6921    }
6922
6923    if((lteAdvCfg->pres & RGR_ABS) && (RGR_ENABLE == lteAdvCfg->absCfg.status))
6924    {
6925       if((RGR_ABS_MUTE != lteAdvCfg->absCfg.absPatternType) &&
6926             (RGR_ABS_TRANSMIT != lteAdvCfg->absCfg.absPatternType))
6927       {
6928          RLOG0(L_ERROR,"Invalid configuration of ABS pattern type");
6929          RETVALUE(RFAILED);
6930       }
6931
6932        cmMemcpy(temp,  (U8 *) lteAdvCfg->absCfg.absPattern,RGR_ABS_PATTERN_LEN);
6933
6934        /* Added validation for ABS pattern len */
6935       for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
6936       {
6937          if((temp[idx] != 1) && (temp[idx] != 0))
6938         {
6939          RLOG0(L_ERROR,"Invalid configuration of ABS pattern type");
6940          RETVALUE(RFAILED);
6941         }
6942       }
6943    }
6944
6945    RETVALUE(ROK);
6946 }
6947 /* LTE_ADV_FLAG_REMOVED_END */
6948
6949
6950 /***********************************************************
6951  *
6952  *     Func : rgSCHCfgVldtRgrCellCsgParamCfg
6953  *
6954  *     Desc : Validates CSG Parameter Configuration
6955  *
6956  *     Ret  : S16
6957  *            ROK - Success
6958  *            RFAILED - Failed
6959  *
6960  *     Notes:
6961  *
6962  *     File :
6963  *
6964  **********************************************************/
6965 #ifdef ANSI
6966 PRIVATE S16 rgSCHCfgVldtRgrCellCsgParamCfg
6967 (
6968 Inst                     inst,
6969 RgrCellCsgParamCfg       *csgParam
6970 )
6971 #else
6972 PRIVATE S16 rgSCHCfgVldtRgrCellCsgParamCfg(inst, csgParam)
6973 Inst                     inst;
6974 RgrCellCsgParamCfg       *csgParam;
6975 #endif
6976 {
6977
6978    TRC2(rgSCHCfgVldtRgrCellCsgParamCfg);
6979
6980    RGSCHDBGPRM(inst, (rgSchPBuf(inst), "Validating CSG Parameters \n"));
6981
6982    if(csgParam->minDlResNonCsg > 100)
6983    {
6984       RLOG0(L_ERROR,"Invalid Configuration of minimum DL resources "
6985             "for NON-CSG");
6986       RETVALUE(RFAILED);
6987    }
6988    if(csgParam->minUlResNonCsg > 100)
6989    {
6990       RLOG0(L_ERROR,"Invalid Configuration of minimum UL resources "
6991             "for NON-CSG");
6992       RETVALUE(RFAILED);
6993    }
6994    RETVALUE(ROK);
6995 }
6996
6997 /**
6998  * @brief Validates the SI configuration request from RRM to MAC.
6999  *
7000  * @details
7001  *
7002  *     Function : rgSCHCfgVldtRgrSiCfg
7003  *
7004  *     Processing Steps:
7005  *        - Validate the range of configured values recieved in
7006  *          configuration request.
7007  *        - If validated successfully,
7008  *          - Return ROK
7009  *        - Else
7010  *          - Return RFAILED.
7011  *      - Else return RFAILED.
7012  *  @param[in]  Inst         inst
7013  *  @param[in]  RgrCellCfg   *siCfg
7014  *  @param[out] RgSchCellCb  *cell
7015  *  @param[out] RgSchErrInfo *errInfo
7016  *  @return  S16
7017  *      -# ROK
7018  *      -# RFAILED
7019  **/
7020 #ifdef ANSI
7021 PUBLIC S16 rgSCHCfgVldtRgrSiCfg
7022 (
7023 Inst         inst,
7024 RgrSiCfgReqInfo *siCfg,
7025 RgSchCellCb      *cell,
7026 RgSchErrInfo *errInfo
7027 )
7028 #else
7029 PUBLIC S16 rgSCHCfgVldtRgrSiCfg(inst, siCfg, cell, errInfo)
7030 Inst         inst;
7031 RgrSiCfgReqInfo *siCfg;
7032 RgSchCellCb      *cell;
7033 RgSchErrInfo *errInfo;
7034 #endif
7035 {
7036    MsgLen  msgLen = 0;
7037    U8      numSi;
7038
7039    TRC2(rgSCHCfgVldtRgrSiCfg);
7040
7041
7042    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_SI_CFG;
7043
7044    /*Validate the cfgType parameter */
7045    switch(siCfg->cfgType)
7046    {
7047       /*ccpu00140789*/
7048       case RGR_SI_STOP:
7049          numSi = (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) ?
7050               cell->siCb.newSiCfg.numSi : cell->siCfg.numSi;
7051          if((siCfg->siId < RGSCH_SI_SIID_LOWER_LMT) ||
7052                  (siCfg->siId > numSi))
7053          {
7054             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid SI Id value"
7055                      " specified");
7056             RETVALUE(RFAILED);
7057          }
7058          errInfo->errCause = RGSCHERR_NONE;
7059          RETVALUE(ROK);
7060       break;
7061       case RGR_SI_CFG_TYPE_MIB:      /* SI CFG Type MIB */
7062       case RGR_SI_CFG_TYPE_SIB1:     /* SI CFG TYPE SIB1 */
7063       case RGR_SI_CFG_TYPE_SIB1_PWS: /* SI CFG TYPE SIB1_PWS */
7064       case RGR_SI_CFG_TYPE_SIB8_CDMA:    /* SI CFG TYPE SIB 8 CDMA */
7065 #ifdef EMTC_ENABLE
7066       case RGR_SI_CFG_EMTC_TYPE_SIB1_BR:
7067       case RGR_SI_CFG_EMTC_TYPE_SIB1_BR_PER:
7068 #endif
7069          break;
7070
7071       case RGR_SI_CFG_TYPE_SI:    /* SI CFG TYPE SI */
7072          /*Check that value of SI should be less than equal
7073            to configured numSi parameter value */
7074          /* Added siId validation for lower limit */
7075          numSi = (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) ?
7076             cell->siCb.newSiCfg.numSi : cell->siCfg.numSi;
7077          if((siCfg->siId < RGSCH_SI_SIID_LOWER_LMT) ||
7078                (siCfg->siId > numSi))
7079          {
7080             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid SI Id value"
7081                      " specified");
7082             RETVALUE(RFAILED);
7083          }
7084
7085          if(siCfg->siId > ((cell->siCfg.minPeriodicity * 10)/cell->siCfg.siWinSize))
7086          {
7087             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "SiId can not be scheduled ");
7088             RETVALUE(RFAILED);
7089          }
7090          break;
7091
7092 #ifdef EMTC_ENABLE
7093       case RGR_SI_CFG_EMTC_TYPE_SI:
7094       case RGR_SI_CFG_EMTC_TYPE_SI_PER:
7095          if(ROK != rgEmtcvalidateSiCfg(siCfg,cell))
7096          {
7097             RETVALUE(RFAILED);
7098          }
7099          break;
7100 #endif
7101       default:
7102          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid cfgType "
7103                       "parameter value");
7104          RETVALUE(RFAILED);
7105    }
7106
7107    /*Validate the specified pdu */
7108    if(NULLP == siCfg->pdu)
7109    {
7110       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid NULLP pdu "
7111                    "specified");
7112       RETVALUE(RFAILED);
7113    }
7114
7115    /*Check if PDU is of 0 length*/
7116    SFndLenMsg(siCfg->pdu, &msgLen);
7117    if(0 == msgLen)
7118    {
7119       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid pdu "
7120                    "specified");
7121       RETVALUE(RFAILED);
7122    }
7123
7124    errInfo->errCause = RGSCHERR_NONE;
7125
7126
7127    RETVALUE(ROK);
7128 }  /* rgSCHCfgVldtRgrSiCfg */
7129 #endif /*RGR_SI_SCH*/
7130
7131 /* LTE_ADV_FLAG_REMOVED_START */
7132 /**
7133  * @brief Validates the RNTP INF request from RRM to MAC.
7134  *
7135  * @details
7136  *
7137  *     Function : rgSCHCfgVldtRgrLoadInf
7138  *
7139  *     Processing Steps:
7140  *        - Validate the range of configured values recieved in
7141  *          LOAD INF request.
7142  *        - If validated successfully,
7143  *          - Return ROK
7144  *        - Else
7145  *          - Return RFAILED.
7146  *      - Else return RFAILED.
7147  *  @param[in]  Inst                inst
7148  *  @param[in]  RgrLoadInfReqInfo   *loadInfReq
7149  *  @param[out] RgSchCellCb         *cell
7150  *  @param[out] RgSchErrInfo        *errInfo
7151  *  @return  S16
7152  *      -# ROK
7153  *      -# RFAILED
7154  **/
7155 #ifdef ANSI
7156 PUBLIC S16 rgSCHCfgVldtRgrLoadInf
7157 (
7158  Inst              inst,
7159  RgrLoadInfReqInfo *loadInfReq,
7160  RgSchCellCb       *cell,
7161  RgSchErrInfo      *errInfo
7162  )
7163 #else
7164 PUBLIC S16 rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, errInfo)
7165    Inst              inst;
7166    RgrLoadInfReqInfo *loadInfReq;
7167    RgSchCellCb       *cell;
7168    RgSchErrInfo      *errInfo;
7169 #endif
7170 {
7171
7172    TRC2(rgSCHCfgVldtRgrLoadInf);
7173
7174
7175    errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_LOAD_INF;
7176
7177    /* Validate if the CC startRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
7178    if((loadInfReq->rgrCcPHighStartRb >= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.startRb) &&
7179          (loadInfReq->rgrCcPHighStartRb <= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.endRb))
7180    {
7181       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid rgrCcPHighStartRb received specified");
7182       RETVALUE(RFAILED);
7183    }
7184
7185    /* Validate if the CC endRb which we have received from DSFR lies in CE sub-band of the receiving eNB */
7186    if((loadInfReq->rgrCcPHighEndRb >= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.startRb) &&
7187          (loadInfReq->rgrCcPHighEndRb <= cell->lteAdvCb.sfrCfg.cellEdgeRbRange.endRb))
7188    {
7189       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid rgrCcPHighEndRb received specified");
7190       RETVALUE(RFAILED);
7191    }
7192
7193    errInfo->errCause = RGSCHERR_NONE;
7194
7195
7196    RETVALUE(ROK);
7197 }  /* rgSCHCfgVldtRgrLoadInf */
7198 /* LTE_ADV_FLAG_REMOVED_END */
7199
7200 #ifdef TFU_UPGRADE
7201
7202 /********************************************************************
7203  *   UE ACQI, PCQI, RI, SRS and SR Re/Configuration  Validation Functions  *
7204  *                                                                   *
7205  *********************************************************************/
7206
7207  /*
7208  * @brief Validates the Tx Mode and PUSCH Mode configuration.
7209  *
7210  * @details
7211  *
7212  *     Function : rgSCHCfgVldtRgrTxmodePuschMode
7213  *
7214  *     Processing Steps:
7215  *      - Validate whether the configured PUSCH Mode and the
7216  *         Configured Tx Mode are in the right combination
7217  *      - If validated successfully,
7218  *        - Return ROK.
7219  *      - Else
7220  *        - Return RFAILED.
7221  *
7222  *  @param[in]  RgSchCellCb     *cellCb
7223  *  @param[in]  RgrTxMode     txMde
7224  *  @param[in]  RgrAprdCqiMode puschMode
7225  *  @param[out] RgSchErrInfo *errInfo
7226  *  @return  S16
7227  *      -# ROK
7228  *      -# RFAILED
7229  */
7230 #ifdef ANSI
7231 PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode
7232 (
7233  RgSchCellCb     *cellCb,
7234  RgrTxMode       txMde,
7235  RgrAprdCqiMode  puschMode,
7236  RgSchErrInfo    *errInfo
7237  )
7238 #else
7239 PUBLIC S16 rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde, puschMode,errInfo)
7240    RgSchCellCb     *cellCb;
7241    RgrTxMode       txMde;
7242    RgrAprdCqiMode  puschMode;
7243    RgSchErrInfo    *errInfo;
7244 #endif
7245 {
7246    TRC2(rgSCHCfgVldtRgrTxmodePuschMode);
7247
7248
7249    if (txMde == RGR_UE_TM_1 ||  txMde == RGR_UE_TM_2 ||
7250          txMde == RGR_UE_TM_3 || txMde == RGR_UE_TM_7)
7251    {
7252       if (puschMode == RGR_APRD_CQI_MOD12 ||
7253             puschMode == RGR_APRD_CQI_MOD22  ||
7254             puschMode == RGR_APRD_CQI_MOD31)
7255       {
7256          RETVALUE(RFAILED);
7257       }
7258    }
7259
7260    if (txMde == RGR_UE_TM_4 ||  txMde == RGR_UE_TM_6)
7261    {
7262       if (puschMode == RGR_APRD_CQI_MOD20 ||
7263             puschMode == RGR_APRD_CQI_MOD30)
7264       {
7265          RETVALUE(RFAILED);
7266       }
7267    }
7268
7269    if (txMde == RGR_UE_TM_5 )
7270    {
7271       if (puschMode != RGR_APRD_CQI_MOD31)
7272       {
7273          RETVALUE(RFAILED);
7274       }
7275    }
7276 #ifdef LTE_ADV
7277    /* TOODO:: Tm8 and TM9 validation has to
7278     * be changed as mentioned inthe commented
7279     * code below*/
7280    /* TM8 and TM9 supports all modes
7281     * Mode 1-2, 2-2, 3-1 if pmi/ri reporting enabled
7282     * 2-0,3-0 of pmi/ri reporitng isdisabled *
7283     * if pmi/ri is enabled
7284     * Mode 1-2, 2-2, 3-1 if with pmi/ri and csi-rs ports > 1
7285     * 2-0,3-0 of pmi/ri reporitng isdisabled and csi-rs ports == 1*/
7286
7287 #endif
7288    RETVALUE(ROK);
7289 }/*rgSCHCfgVldtRgrTxmodePuschMode ends*/
7290
7291  /*
7292  * @brief Validates the UE ACQI configuration request from RRM to MAC.
7293  *
7294  * @details
7295  *
7296  *     Function : rgSCHCfgVldtRgrUeACqiCfg
7297  *
7298  *     Processing Steps:
7299  *      - Validate the UE configuration request from RRC to MAC at CFG:
7300  *        validate the ACQI Configuration
7301  *      - If validated successfully,
7302  *        - Return ROK.
7303  *      - Else
7304  *        - Return RFAILED.
7305  *
7306  *  @param[in] RgSchCellCb        *cellCb,
7307  *  @param[in] CmLteRnti          crnti,
7308  *  @param[in] RgrUeAprdDlCqiCfg   *acqiCfg,
7309  *  @param[in] RgrUeTxModeCfg     txMode,
7310  *  @param[out] RgSchErrInfo       *errInfo
7311
7312  *  @return  S16
7313  *      -# ROK
7314  *      -# RFAILED
7315  */
7316 #ifdef ANSI
7317 PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg
7318 (
7319  RgSchCellCb        *cellCb,
7320  CmLteRnti          crnti,
7321  RgrUeAprdDlCqiCfg  *acqiCfg,
7322  RgrUeTxModeCfg     txMode,
7323  RgSchErrInfo       *errInfo
7324  )
7325 #else
7326 PUBLIC S16 rgSCHCfgVldtRgrUeACqiCfg(cellCb, crnti, acqiCfg,txMode, errInfo)
7327    RgSchCellCb        *cellCb;
7328    CmLteRnti          crnti;
7329    RgrUeAprdDlCqiCfg  *acqiCfg;
7330    RgrUeTxModeCfg     txMode;
7331    RgSchErrInfo       *errInfo;
7332 #endif
7333 {
7334    RgrTxMode      txMde;
7335    RgrAprdCqiMode puschMode;
7336    TRC2(rgSCHCfgVldtRgrUeACqiCfg);
7337
7338
7339    if(acqiCfg->pres)
7340    {
7341       if(txMode.pres == TRUE)
7342       {
7343          txMde = txMode.txModeEnum;
7344          puschMode = acqiCfg->aprdModeEnum;
7345          if ( ROK != rgSCHCfgVldtRgrTxmodePuschMode(cellCb, txMde,
7346                   puschMode, errInfo))
7347          {
7348             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7349                      "Invalid Aperiodic CQI configuration CRNTI:%d",crnti);
7350             RETVALUE(RFAILED);
7351          }
7352       }
7353    }
7354    RETVALUE(ROK);
7355 }
7356
7357  /*
7358  * @brief Validates the Tx Mode and PUCCH Mode configuration.
7359  *
7360  * @details
7361  *
7362  *     Function : rgSCHCfgVldtRgrTxmodePucchMode
7363  *
7364  *     Processing Steps:
7365  *      - Validate whether the configured PUCCH Mode and the
7366  *         Configured Tx Mode are in the right combination
7367  *      - If validated successfully,
7368  *        - Return ROK.
7369  *      - Else
7370  *        - Return RFAILED.
7371  *
7372  *  @param[in]  RgSchCellCb     *cellCb
7373  *  @param[in]  RgrTxMode     txMde
7374  *  @param[in]  RgrPrdCqiMode     pucchMode
7375  *  @param[out] RgSchErrInfo *errInfo
7376  *  @return  S16
7377  *      -# ROK
7378  *      -# RFAILED
7379  */
7380 #ifdef ANSI
7381 PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode
7382 (
7383    RgSchCellCb     *cellCb,
7384    RgrTxMode       txMde,
7385    RgrPrdCqiMode   pucchMode,
7386    RgSchErrInfo    *errInfo
7387  )
7388 #else
7389 PUBLIC S16 rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde, pucchMode,errInfo)
7390    RgSchCellCb     *cellCb;
7391    RgrTxMode       txMde;
7392    RgrPrdCqiMode   pucchMode;
7393    RgSchErrInfo    *errInfo;
7394 #endif
7395 {
7396    TRC2(rgSCHCfgVldtRgrTxmodePucchMode);
7397
7398
7399   if (pucchMode == RGR_PRD_CQI_MOD10 || pucchMode == RGR_PRD_CQI_MOD20 )
7400   {
7401    if (txMde ==RGR_UE_TM_4 || txMde ==RGR_UE_TM_5 || txMde ==RGR_UE_TM_6)
7402    {
7403       RETVALUE(RFAILED);
7404    }
7405   }
7406   else if (pucchMode == RGR_PRD_CQI_MOD11 || pucchMode == RGR_PRD_CQI_MOD21)
7407   {
7408      if (txMde ==RGR_UE_TM_1 || txMde ==RGR_UE_TM_2 || txMde ==RGR_UE_TM_3 \
7409              || txMde ==RGR_UE_TM_7)
7410    {
7411       RETVALUE(RFAILED);
7412    }
7413   }
7414   /* TODO:: Tm8 and TM9 validation needs to be added */
7415    RETVALUE(ROK);
7416 }
7417
7418 /*
7419  * @brief Validates the UE Periodic CQI, PMI, RI, re/configuration request from RRM to MAC.
7420  *
7421  * @details
7422  *
7423  *     Function : rgSCHCfgVldtRgrUePCqiCfg
7424  *
7425  *     Processing Steps:
7426  *      - Validate the UE configuration request from RRC to MAC at CFG:
7427  *        validate the value range for Periodic CQI, PMI, RI values.
7428  *      - If validated successfully,
7429  *        - Return ROK.
7430  *      - Else
7431  *        - Return RFAILED.
7432  *
7433  *  @param[in] RgSchCellCb        *cellCb,
7434  *  @param[in] CmLteRnti          crnti,
7435  *  @param[in] RgrUePrdDlCqiCfg   *cqiCfg,
7436  *  @param[in] RgrUeTxModeCfg     txMode,
7437  *  @param[out] RgSchErrInfo       *errInfo
7438  *  @return  S16
7439  *      -# ROK
7440  *      -# RFAILED
7441  */
7442 #ifdef LTEMAC_HDFDD
7443 #ifdef ANSI
7444 PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg
7445 (
7446  RgSchCellCb        *cellCb,
7447  CmLteRnti          crnti,
7448  RgrUePrdDlCqiCfg   *cqiCfg,
7449  Bool               hdFdd,
7450  RgrUeTxModeCfg     txMode,
7451  RgSchErrInfo       *errInfo
7452  )
7453 #else
7454 PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg, hdFdd,
7455        txMode, errInfo)
7456    RgSchCellCb        *cellCb;
7457    CmLteRnti          crnti;
7458    RgrUePrdDlCqiCfg   *cqiCfg;
7459    Bool               hdFdd;
7460    RgrUeTxModeCfg     txMode;
7461    RgSchErrInfo       *errInfo;
7462 #endif
7463 #else
7464 #ifdef ANSI
7465 PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg
7466    (
7467     RgSchCellCb        *cellCb,
7468     CmLteRnti          crnti,
7469     RgrUePrdDlCqiCfg   *cqiCfg,
7470     RgrUeTxModeCfg     txMode,
7471     RgSchErrInfo       *errInfo
7472    )
7473 #else
7474 PUBLIC S16 rgSCHCfgVldtRgrUePCqiCfg(cellCb, crnti, cqiCfg,  txMode, errInfo)
7475    RgSchCellCb        *cellCb;
7476    CmLteRnti          crnti;
7477    RgrUePrdDlCqiCfg   *cqiCfg;
7478    RgrUeTxModeCfg     txMode;
7479    RgSchErrInfo       *errInfo;
7480 #endif
7481 #endif
7482 {
7483    RgrTxMode     txMde;
7484    RgrPrdCqiMode pucchMode;
7485
7486    TRC2(rgSCHCfgVldtRgrUePCqiCfg);
7487
7488    txMde = RGR_UE_TM_1;
7489    pucchMode = RGR_PRD_CQI_MOD20;
7490    if ( RGR_SCH_PCQI_SETUP == cqiCfg->type )
7491    {
7492       /*1. Validate for Tx Mode and PUCCH Mode combination*/
7493       if(txMode.pres == TRUE)
7494       {
7495          txMde = txMode.txModeEnum;
7496          pucchMode = cqiCfg->cqiSetup.prdModeEnum;
7497          if ( ROK != rgSCHCfgVldtRgrTxmodePucchMode(cellCb, txMde,
7498                   pucchMode, errInfo))
7499          {
7500             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7501                      "Invalid Tx Mode-PUCCH Mode combination CRNTI:%d",crnti);
7502             RETVALUE(RFAILED);
7503          }
7504       }
7505
7506       /*2. Validate for PCQI Reporting Type and PUCCH Mode combination*/
7507       if((cqiCfg->cqiSetup.cqiRepType==1) &&
7508               ((pucchMode == RGR_PRD_CQI_MOD20) ||
7509                (pucchMode == RGR_PRD_CQI_MOD21)))
7510       {
7511             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7512                      "Invalid Reporting Type-PUCCH Mode combination CRNTI:%d",crnti);
7513             RETVALUE(RFAILED);
7514       }
7515
7516       if((cqiCfg->cqiSetup.cqiRepType==2) &&
7517               ((pucchMode == RGR_PRD_CQI_MOD10) ||
7518                (pucchMode == RGR_PRD_CQI_MOD11)))
7519       {
7520             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7521                      "Invalid Reporting Type-PUCCH Mode combination CRNTI:%d",crnti);
7522             RETVALUE(RFAILED);
7523       }
7524
7525       /*3. Validate CQI/PMI and RI Configuration related parameter values */
7526       /*TODO- To be compared with configured n2Pucch Index*/
7527       if (cqiCfg->cqiSetup.cqiPResIdx > RG_SCH_PUCCH_RES_MAX_SUPP )
7528       {
7529          RLOG_ARG3(L_ERROR,DBG_CELLID,cellCb->cellId,
7530                   "Not Supported or Invalid CQI-PUCCH resourceIndex=%d Cfg Val=%d CRNTI:%d",
7531                   RG_SCH_PUCCH_RES_MAX_SUPP, cqiCfg->type,crnti);
7532          RETVALUE(RFAILED);
7533       }
7534
7535 #ifdef LTEMAC_HDFDD
7536       if(hdFdd)
7537       {
7538          if((cqiCfg->cqiSetup.cqiPCfgIdx > RG_SCH_ICQI_MAX_SUPP)||
7539                (cqiCfg->cqiSetup.cqiPCfgIdx < 7) ||
7540                (cqiCfg->cqiSetup.cqiPCfgIdx == 317))
7541          {
7542             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7543                      "Not Supported or Invalid Cfg CQI Min Index Sup =%d"
7544                      "Max Index Sup=%d  Cfg Val=%d CRNTI:%d", RG_SCH_ICQI_MIN_SUPP,
7545                      RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
7546             RETVALUE(RFAILED);
7547          }
7548       }
7549       else
7550       {
7551          if((cqiCfg->cqiSetup.cqiPCfgIdx > RG_SCH_ICQI_MAX_SUPP)||
7552                (cqiCfg->cqiSetup.cqiPCfgIdx == 317))
7553          {
7554             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7555                      "Not Supported or Invalid Cfg CQI Min Index Sup =%d "
7556                      "Max Index Sup=%d  Cfg Val=%d CRNTI:%d", RG_SCH_ICQI_MIN_SUPP,
7557                      RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
7558             RETVALUE(RFAILED);
7559          }
7560       }
7561 #else
7562       if((cqiCfg->cqiSetup.cqiPCfgIdx > RG_SCH_ICQI_MAX_SUPP)||
7563             (cqiCfg->cqiSetup.cqiPCfgIdx == 317))
7564       {
7565          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7566                   "Not Supported or Invalid Cfg CQI Min Index Sup =%d"
7567                   "Max Index Sup=%d  Cfg Val=%d CRNTI;%d", RG_SCH_ICQI_MIN_SUPP,
7568                   RG_SCH_ICQI_MAX_SUPP, cqiCfg->type,crnti);
7569          RETVALUE(RFAILED);
7570       }
7571 #endif
7572
7573       if((cqiCfg->cqiSetup.cqiRepType < RGR_UE_PCQI_WB_REP) ||
7574             (cqiCfg->cqiSetup.cqiRepType > RGR_UE_PCQI_SB_REP))
7575       {
7576          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7577                   "Invalid Cfg CQI Report"
7578                   "ModeCfg Val=%d CRNTI:%d", cqiCfg->type,crnti);
7579          RETVALUE(RFAILED);
7580       }
7581
7582       if((cqiCfg->cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP) &&
7583             ((cqiCfg->cqiSetup.k < RG_SCH_CQI_K_MIN) ||
7584             (cqiCfg->cqiSetup.k > RG_SCH_CQI_K_MAX)))
7585       {
7586          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7587                   "Invalid CQI Cfg K Cfg Val=%d CRNTI:%d", cqiCfg->type,crnti);
7588          RETVALUE(RFAILED);
7589       }
7590
7591       if((cqiCfg->cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP) &&
7592             (cellCb->bwCfg.dlTotalBw <= 7))
7593       {
7594          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7595                   "Invalid Periodic CQI mode Cfg for dlTotalBw (%d) for CRNTI:%d",
7596                   cellCb->bwCfg.dlTotalBw, crnti);
7597          RETVALUE(RFAILED);
7598       }
7599
7600 #ifndef LTE_TDD
7601       if (cqiCfg->cqiSetup.cqiPCfgIdx == RG_SCH_ICQI_RESV_FDD )
7602       {
7603          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7604                   "Reserved value Cfg =%d CRNTI:%d",
7605                   cqiCfg->cqiSetup.cqiPResIdx,crnti);
7606          RETVALUE(RFAILED);
7607       }
7608 #endif
7609
7610       /* 4. Check RI Configuration values */
7611        if(cqiCfg->cqiSetup.riEna == TRUE)
7612       {
7613          if(txMode.pres == TRUE)
7614          {
7615             if((txMde != RGR_UE_TM_3)
7616             && (txMde != RGR_UE_TM_4)
7617             && (txMde != RGR_UE_TM_8)
7618 #ifdef LTE_ADV
7619             && (txMde != RGR_UE_TM_9)
7620 #endif
7621              )
7622             {
7623                RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7624                   "Invalid Transmission Mode =%d CRNTI:%d",
7625                   txMde,crnti);
7626                RETVALUE(RFAILED);
7627             }
7628          }
7629
7630          if(cqiCfg->cqiSetup.riCfgIdx > RG_SCH_IRI_MAX_SUPP)
7631          {
7632           RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7633                   "Invalid Index RI value Cfg =%d CRNTI:%d",
7634                   cqiCfg->cqiSetup.riCfgIdx,crnti);
7635           RETVALUE(RFAILED);
7636          }
7637       }
7638    }
7639
7640
7641    RETVALUE(ROK);
7642 }
7643
7644 /*
7645  * @brief Validates the UE SRS Re/Configuation request from RRM to MAC.
7646  *
7647  * @details
7648  *
7649  *     Function : rgSCHCfgVldtRgrUeUlSrsCfg
7650  *
7651  *     Processing Steps:
7652  *      - Validate the UE configuration request from RRC to MAC at CFG:
7653  *        validate the value range for SRS values.
7654  *      - If validated successfully,
7655  *        - Return ROK.
7656  *      - Else
7657  *        - Return RFAILED.
7658  *
7659  *  @param[in] RgSchCellCb       *cellCb,
7660  *  @param[in] CmLteRnti         crnti,
7661  *  @param[in] RgrUeUlSrsCfg     *srsCfg,
7662  *  @param[out] RgSchErrInfo     *errInfo
7663  *  @return  S16
7664  *      -# ROK
7665  *      -# RFAILED
7666  */
7667 #ifdef LTEMAC_HDFDD
7668 #ifdef ANSI
7669 PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg
7670 (
7671  RgSchCellCb       *cellCb,
7672  CmLteRnti         crnti,
7673  RgrUeUlSrsCfg     *srsCfg,
7674  Bool              hdFdd,
7675  RgSchErrInfo      *errInfo
7676  )
7677 #else
7678 PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg, hdFdd, errInfo)
7679    RgSchCellCb     *cellCb;
7680    CmLteRnti       crnti;
7681    RgrUeUlSrsCfg   *srsCfg;
7682    Bool            hdFdd;
7683    RgSchErrInfo    *errInfo;
7684 #endif
7685 #else
7686 #ifdef ANSI
7687 PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg
7688 (
7689  RgSchCellCb       *cellCb,
7690  CmLteRnti         crnti,
7691  RgrUeUlSrsCfg     *srsCfg,
7692  RgSchErrInfo      *errInfo
7693  )
7694 #else
7695 PUBLIC S16 rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, crnti, srsCfg,  errInfo)
7696    RgSchCellCb     *cellCb;
7697    CmLteRnti       crnti;
7698    RgrUeUlSrsCfg   *srsCfg;
7699    RgSchErrInfo    *errInfo;
7700 #endif
7701 #endif
7702 {
7703    U16    srsPeri=0;
7704    U16    srsOffset=0;
7705    U8     srsSubframe=0;
7706
7707    TRC2(rgSCHCfgVldtRgrUeUlSrsCfg);
7708
7709
7710    if ( RGR_SCH_SRS_SETUP == srsCfg->type )
7711    {
7712
7713       /*ccpu00130768 - ADD - if cell specific SRS is not configured*/
7714       if(cellCb->srsCfg.isSrsCfgPres == FALSE)
7715       {
7716          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7717               "Cell specific SRS is not configured CRNTI:%d",crnti);
7718          RETVALUE(RFAILED);
7719       }
7720
7721       /*  1. Validate SRS Configuration related parameter values  */
7722       /* 1.1 iSRS should be 0-636; Ref: 36.213. Table 8.2-1 */
7723 #ifdef LTEMAC_HDFDD
7724       if(hdFdd)
7725       {
7726          if ( (srsCfg->srsSetup.srsCfgIdx < 7) ||
7727                (srsCfg->srsSetup.srsCfgIdx > RG_SCH_ISRS_MAX_SUPP) )
7728          {
7729             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7730                      "Not Supported or Invalid Cfg "
7731                      "SRS Min Index Sup =%d   Max Index Sup=%d  Cfg Val=%d CRNTI:%d",
7732                      RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
7733                      srsCfg->srsSetup.srsCfgIdx,crnti);
7734             RETVALUE(RFAILED);
7735          }
7736       }
7737       else
7738       {
7739          if ( srsCfg->srsSetup.srsCfgIdx > RG_SCH_ISRS_MAX_SUPP )
7740          {
7741             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7742                      "Not Supported or Invalid Cfg"
7743                      "SRS Min Index Sup =%d   Max Index Sup=%d  Cfg Val=%d CRNTI:%d",
7744                      RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
7745                      srsCfg->srsSetup.srsCfgIdx,crnti);
7746             RETVALUE(RFAILED);
7747          }
7748
7749       }
7750 #else
7751       if ( srsCfg->srsSetup.srsCfgIdx > RG_SCH_ISRS_MAX_SUPP )
7752       {
7753          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7754                   "Not Supported or Invalid Cfg"
7755                   "SRS Min Index Sup =%d   Max Index Sup=%d  Cfg Val=%d CRNTI:%d",
7756                   RG_SCH_ISRS_MIN_SUPP, RG_SCH_ISRS_MAX_SUPP,
7757                   srsCfg->srsSetup.srsCfgIdx,crnti);
7758          RETVALUE(RFAILED);
7759       }
7760 #endif
7761 #ifdef LTE_TDD
7762       /* Compute SRS Offset and Periodicity */
7763       rgSCHUtlGetCfgPerOff( RG_SCH_TDD_SRS_TBL,
7764             srsCfg->srsSetup.srsCfgIdx,
7765             &srsPeri, &srsOffset);
7766 #else
7767       rgSCHUtlGetCfgPerOff( RG_SCH_FDD_SRS_TBL,
7768             srsCfg->srsSetup.srsCfgIdx,
7769             &srsPeri, &srsOffset);
7770 #endif
7771        srsSubframe = srsOffset%RGSCH_NUM_SUB_FRAMES;
7772 #ifdef LTE_TDD
7773       if(rgSchTddCellSpSrsSubfrmTbl[cellCb->srsCfg.srsSubFrameCfg][srsSubframe] == FALSE)   {
7774 #else
7775       if(rgSchFddCellSpSrsSubfrmTbl[cellCb->srsCfg.srsSubFrameCfg][srsSubframe] == FALSE)   {
7776 #endif
7777          RLOG_ARG2(L_ERROR,DBG_CELLID,cellCb->cellId,
7778                "UE specific SRS is not occuring in Cell specific SRS subframe"
7779                "srs Cfg Idx =%d CRNTI:%d",
7780                srsCfg->srsSetup.srsCfgIdx,crnti);
7781          RETVALUE(RFAILED);
7782       }
7783
7784
7785       if ( srsCfg->srsSetup.fDomPosi > RG_SCH_SRS_FREQDOM_POS_MAX )
7786       {
7787          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7788                   "Not Supported or Invalid Cfg"
7789                   "SRS Min Freq Domain Position =%d"
7790                   "Max Freq Domain Position =%d  Cfg Val=%d CRNTI:%d",
7791                   RG_SCH_SRS_FREQDOM_POS_MIN, RG_SCH_SRS_FREQDOM_POS_MAX,
7792                   srsCfg->srsSetup.srsCfgIdx,crnti);
7793          RETVALUE(RFAILED);
7794       }
7795
7796       if ( srsCfg->srsSetup.txComb > RG_SCH_SRS_TXCOMB_MAX )
7797       {
7798          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7799                   "Not Supported or Invalid Cfg"
7800                   "SRS Min TX Comb =%d   Max TX Comb =%d  Cfg Val=%d CRNTI:%d",
7801                   RG_SCH_SRS_TXCOMB_MIN, RG_SCH_SRS_TXCOMB_MAX,
7802                   srsCfg->srsSetup.srsCfgIdx,crnti);
7803          RETVALUE(RFAILED);
7804       }
7805    }
7806    RETVALUE(ROK);
7807 }
7808
7809 /*
7810  * @brief Validates the UE SR Re/configuration request from RRM to MAC.
7811  *
7812  * @details
7813  *
7814  *     Function : rgSCHCfgVldtRgrUeSrCfg
7815  *
7816  *     Processing Steps:
7817  *      - Validate the UE re/configuration request from RRC to MAC at CFG:
7818  *        validate the value range for SR values.
7819  *      - If validated successfully,
7820  *        - Return ROK.
7821  *      - Else
7822  *        - Return RFAILED.
7823  *
7824  *  @param[in] RgSchCellCb      *cellCb,
7825  *  @param[in] CmLteRnti        crnti,
7826  *  @param[in] RgrUeSrCfg       *srCfg,
7827  *  @param[out] RgSchErrInfo    *errInfo
7828  *  @return  S16
7829  *      -# ROK
7830  *      -# RFAILED
7831  */
7832 #ifdef LTEMAC_HDFDD
7833 #ifdef ANSI
7834 PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg
7835 (
7836  RgSchCellCb      *cellCb,
7837  CmLteRnti        crnti,
7838  RgrUeSrCfg       *srCfg,
7839  Bool             hdFdd,
7840  RgSchErrInfo     *errInfo
7841  )
7842 #else
7843 PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, hdFdd, errInfo)
7844    RgSchCellCb    *cellCb;
7845    CmLteRnti      crnti;
7846    RgrUeSrCfg     *srCfg;
7847    Bool           hdFdd;
7848    RgSchErrInfo   *errInfo;
7849 #endif
7850 #else
7851 #ifdef ANSI
7852 PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg
7853 (
7854  RgSchCellCb      *cellCb,
7855  CmLteRnti        crnti,
7856  RgrUeSrCfg       *srCfg,
7857  RgSchErrInfo     *errInfo
7858  )
7859 #else
7860 PUBLIC S16 rgSCHCfgVldtRgrUeSrCfg(cellCb, crnti, srCfg, errInfo)
7861    RgSchCellCb    *cellCb;
7862    CmLteRnti      crnti;
7863    RgrUeSrCfg     *srCfg;
7864    RgSchErrInfo   *errInfo;
7865 #endif
7866 #endif
7867 {
7868
7869    TRC2(rgSCHCfgVldtRgrUeSrCfg);
7870
7871
7872
7873    if ( RGR_SCH_SR_SETUP == srCfg->type )
7874    {
7875       /* 1. Validate SR Configuration related parameter values  */
7876 #ifdef LTEMAC_HDFDD
7877       if(hdFdd)
7878       {
7879          if (( srCfg->srSetup.srResIdx > RG_SCH_SR_RES_IDX   ) ||
7880                ( srCfg->srSetup.srCfgIdx < 5 ) ||
7881                ( srCfg->srSetup.srCfgIdx > RG_SCH_ISR_MAX_SUPP ))
7882          {
7883             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7884                      "Invalid SR Index Cfg =%d"
7885                       "Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
7886                      RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
7887
7888             RETVALUE(RFAILED);
7889          }
7890       }
7891       else
7892       {
7893          if (( srCfg->srSetup.srResIdx > RG_SCH_SR_RES_IDX   ) ||
7894                ( srCfg->srSetup.srCfgIdx > RG_SCH_ISR_MAX_SUPP ))
7895          {
7896             RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7897                      "Invalid SR Index Cfg =%d"
7898                       "Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
7899                      RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
7900
7901             RETVALUE(RFAILED);
7902          }
7903       }
7904 #else
7905       if (( srCfg->srSetup.srResIdx > RG_SCH_SR_RES_IDX   ) ||
7906             ( srCfg->srSetup.srCfgIdx > RG_SCH_ISR_MAX_SUPP ))
7907       {
7908          RLOG_ARG4(L_ERROR,DBG_CELLID,cellCb->cellId,
7909                   "Invalid SR Index Cfg =%d"
7910                   "Max Supp=%d,Min Supp=%d CRNTI:%d", srCfg->srSetup.srCfgIdx,
7911                   RG_SCH_ISR_MAX_SUPP, RG_SCH_ISR_MIN_SUPP,crnti);
7912
7913          RETVALUE(RFAILED);
7914       }
7915 #endif
7916    }
7917    RETVALUE(ROK);
7918 }
7919
7920
7921 /*
7922  * @brief Validates the UE Aperiodic & Periodic  CQI, PMI, RI, SRS and SR Configuration
7923  *             request from RRM to MAC.
7924  *
7925  * @details
7926  *
7927  *     Function :rgSCHCfgVldtCqiSrSrsUeCfg
7928  *
7929  *     Processing Steps:
7930  *      - Validate the UE configuration request from RRC to MAC at CFG:
7931  *        validate the value range for Aperiodic & Periodic CQI, PMI, RI , SRS and SR values.
7932  *      - If validated successfully,
7933  *        - Return ROK.
7934  *      - Else
7935  *        - Return RFAILED.
7936  *
7937  *  @param[in]  RgSchCellCb  *cellCb
7938  *  @param[in]  RgrUeCfg     *ueCfg
7939  *  @param[out] RgSchErrInfo *errInfo
7940  *  @return  S16
7941  *      -# ROK
7942  *      -# RFAILED
7943  */
7944 #ifdef ANSI
7945 PRIVATE S16 rgSCHCfgVldtCqiSrSrsUeCfg
7946 (
7947  RgSchCellCb       *cellCb,
7948  RgrUeCfg          *ueCfg,
7949  RgSchErrInfo      *errInfo
7950  )
7951 #else
7952 PRIVATE S16  rgSCHCfgVldtCqiSrSrsUeCfg(cellCb, ueCfg,  errInfo)
7953    RgSchCellCb     *cellCb;
7954    RgrUeCfg        *ueCfg;
7955    RgSchErrInfo    *errInfo;
7956 #endif
7957 {
7958
7959    TRC2(rgSCHCfgVldtCqiSrSrsUeCfg);
7960
7961
7962    /*  1. Validate UE Aperiodic CQI related parameters */
7963    if ( ROK != rgSCHCfgVldtRgrUeACqiCfg (cellCb, ueCfg->crnti,
7964             &ueCfg->ueDlCqiCfg.aprdCqiCfg, ueCfg->txMode, errInfo ))
7965    {
7966       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7967        "Invalid Aperiodic CQI configuration CRNTI:%d",ueCfg->crnti);
7968       RETVALUE(RFAILED);
7969    }
7970
7971    /*  1. Validate UE Periodic CQI/PMI, SRS and SR related parameters */
7972 #ifdef LTEMAC_HDFDD
7973    if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueCfg->crnti,
7974             &ueCfg->ueDlCqiCfg.prdCqiCfg, ueCfg->isHdFddEnbld,
7975             ueCfg->txMode, errInfo ))
7976 #else
7977       if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueCfg->crnti,
7978              &ueCfg->ueDlCqiCfg.prdCqiCfg, ueCfg->txMode, errInfo ))
7979 #endif
7980       {
7981          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7982           "Invalid Periodic CQI configuration CRNTI:%d",ueCfg->crnti);
7983          RETVALUE(RFAILED);
7984       }
7985
7986    /*  2. Validate SRS Configuration related parameter values  */
7987 #ifdef LTEMAC_HDFDD
7988    if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueCfg->crnti, &ueCfg->srsCfg,
7989             ueCfg->isHdFddEnbld, errInfo ))
7990 #else
7991       if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueCfg->crnti,
7992                   &ueCfg->srsCfg, errInfo ))
7993 #endif
7994       {
7995          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
7996            "Invalid SRS  configuration CRNTI:%d",ueCfg->crnti);
7997          RETVALUE(RFAILED);
7998       }
7999
8000    /*  3. Validate SR Configuration related parameter values  */
8001 #ifdef LTEMAC_HDFDD
8002    if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueCfg->crnti, &ueCfg->srCfg,
8003             ueCfg->isHdFddEnbld, errInfo))
8004 #else
8005       if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueCfg->crnti,
8006                   &ueCfg->srCfg, errInfo))
8007 #endif
8008       {
8009          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
8010             "Invalid SR  configuration CRNTI:%d",ueCfg->crnti);
8011          RETVALUE(RFAILED);
8012       }
8013
8014    RETVALUE(ROK);
8015
8016 }
8017
8018
8019
8020 /*****************************************************************
8021  *   UE PCQI, RI, SRS and SR Re Configuration  Validation Functions  *
8022  *                                                                *
8023  ******************************************************************/
8024 /*
8025  * @brief Validates the UE Periodic CQI, PMI, RI, SRS and SR
8026  * Re-configuration request from RRM to MAC.
8027  *
8028  * @details
8029  *
8030  *     Function : rgSCHCfgVldtCqiSrSrsUeReCfg
8031  *
8032  *     Processing Steps:
8033  *      - Validate the UE Re configuration request from RRC to MAC at CFG:
8034  *        validate the value range for Periodic CQI, PMI, RI, SRS and SR values.
8035  *      - If validated successfully,
8036  *        - Return ROK.
8037  *      - Else
8038  *        - Return RFAILED.
8039  *
8040  *  @param[in]   RgSchCellCb *cellCb
8041  *  @param[in]   RgSchUeCb   *ueCb
8042  *  @param[in]  RgrUeCfg     *ueCfg
8043  *  @param[out] RgSchErrInfo *errInfo
8044  *  @return  S16
8045  *      -# ROK
8046  *      -# RFAILED
8047  */
8048 #ifdef ANSI
8049 PRIVATE S16 rgSCHCfgVldtCqiSrSrsUeReCfg
8050 (
8051  RgSchCellCb          *cellCb,
8052  RgSchUeCb            *ueCb,
8053  RgrUeRecfg           *ueReCfg,
8054  RgSchErrInfo         *errInfo
8055  )
8056 #else
8057 PRIVATE S16 rgSCHCfgVldtCqiSrSrsUeReCfg(cellCb, ueCb, ueReCfg, errInfo)
8058    RgSchCellCb          *cellCb;
8059    RgSchUeCb            *ueCb;
8060    RgrUeRecfg           *ueReCfg;
8061    RgSchErrInfo         *errInfo;
8062 #endif
8063 {
8064    RgrUeTxModeCfg     txMode;
8065    TRC3(rgSCHCfgVldtCqiSrSrsUeReCfg);
8066
8067    txMode.pres = TRUE;
8068    txMode.tmTrnstnState = RGR_TXMODE_RECFG_CMPLT;
8069    if ((ueReCfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG) &&
8070        (ueReCfg->txMode.pres == TRUE))
8071    {
8072       txMode.txModeEnum = ueReCfg->txMode.txModeEnum;
8073    }
8074    else
8075    {
8076       txMode.txModeEnum = ueCb->mimoInfo.txMode;
8077    }
8078
8079    /*    1. Validate UE CQI/PMI, SRS and SR related parameters */
8080
8081    if ( ueReCfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG )
8082    {
8083       if ( ROK != rgSCHCfgVldtRgrUeACqiCfg (cellCb, ueReCfg->oldCrnti,
8084                &ueReCfg->aprdDlCqiRecfg, txMode, errInfo ))
8085       {
8086          RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
8087          "Invalid Aperiodic CQI configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
8088          RETVALUE(RFAILED);
8089       }
8090    }
8091
8092
8093    /*    2. Validate UE CQI/PMI, SRS and SR related parameters */
8094
8095    if ( ueReCfg->ueRecfgTypes & RGR_UE_PCQI_RECFG )
8096    {
8097 #ifdef LTEMAC_HDFDD
8098       if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueReCfg->oldCrnti,
8099                &ueReCfg->cqiCfg, ueReCfg->isHdFddEnbld, txMode, errInfo ))
8100 #else
8101          if ( ROK != rgSCHCfgVldtRgrUePCqiCfg (cellCb, ueReCfg->oldCrnti,
8102                   &ueReCfg->cqiCfg, txMode, errInfo ))
8103 #endif
8104
8105          {
8106             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
8107             "Invalid Periodic CQI configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
8108             RETVALUE(RFAILED);
8109          }
8110    }
8111
8112    if(ueReCfg->ueRecfgTypes & RGR_UE_SRS_RECFG )
8113    {
8114 #ifdef LTEMAC_HDFDD
8115       if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueReCfg->oldCrnti,
8116                &ueReCfg->srsCfg, ueReCfg->isHdFddEnbld, errInfo ))
8117 #else
8118          if ( ROK != rgSCHCfgVldtRgrUeUlSrsCfg(cellCb, ueReCfg->oldCrnti,
8119                   &ueReCfg->srsCfg, errInfo ))
8120 #endif
8121          {
8122             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
8123               "Invalid SRS  configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
8124             RETVALUE(RFAILED);
8125          }
8126
8127    }
8128
8129    if ( ueReCfg->ueRecfgTypes & RGR_UE_SR_RECFG )
8130    {
8131 #ifdef LTEMAC_HDFDD
8132       if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueReCfg->oldCrnti,
8133             &ueReCfg->srCfg, ueReCfg->isHdFddEnbld, errInfo))
8134 #else
8135          if ( ROK != rgSCHCfgVldtRgrUeSrCfg (cellCb, ueReCfg->oldCrnti,
8136             &ueReCfg->srCfg, errInfo))
8137 #endif
8138          {
8139             RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
8140                      "Invalid SR configuration OLD CRNTI:%d",ueReCfg->oldCrnti);
8141             RETVALUE(RFAILED);
8142          }
8143    }
8144
8145    RETVALUE(ROK);
8146 }
8147
8148
8149 /*****************************************************************
8150  *   UE ACQI, PCQI, RI, SRS SR Configuration Functions      *
8151  *                                                                *
8152  ******************************************************************/
8153    /**
8154     * @brief Handles Aperiodic CQI , PMI, RI  configuration for a UE.
8155     *
8156     * @details
8157     *
8158     *     Function : rgSCHCfgACqiUeCfg
8159     *
8160     *     Invoking Module Processing:
8161     *      - This shall be invoked by SCH_GOM at UE configuration. It
8162     *      shall do the validations for the spec-defined values.
8163     *
8164     *     Processing Steps:
8165     *
8166     *     - Return ROK
8167     *
8168     *  @param[in]  RgSchCellCb  *cell
8169     *  @param[in]  RgrTxMode    txMode
8170     *  @param[in]  RgrUeAprdDlCqiCfg *aCqiCfg
8171     *  @param[in]  CmLteUeCategory        ueCat
8172     *  @return  S16
8173     *      -# ROK
8174     *
8175     **/
8176 #ifdef ANSI
8177 PUBLIC S16 rgSCHCfgACqiUeCfg
8178 (
8179 RgSchCellCb        *cellCb,
8180 RgSchUeCb          *ue,
8181 RgSchUeACqiCb      *acqiCb,
8182 RgrTxMode           ueTxMode,
8183 RgrUeAprdDlCqiCfg  *aCqiCfg,
8184 CmLteUeCategory     ueCat
8185 )
8186 #else
8187 PUBLIC S16 rgSCHCfgACqiUeCfg(cellCb,ue,acqiCb ueTxMode, aCqiCfg, ueCat)
8188 RgSchCellCb       *cellCb;
8189 RgSchUeCb          *ue;
8190 RgSchUeACqiCb     *acqiCb;
8191 RgrTxMode          ueTxMode;
8192 RgrUeAprdDlCqiCfg *aCqiCfg;
8193 CmLteUeCategory   ueCat;
8194 #endif
8195 {
8196    U8     M;  /*Num of Subbands -- Applicable only for Mode 2-0 and 2-2*/
8197    U8     k;  /*SubBand Size (RB)  --
8198               Holds different values depending on Mode*/
8199    U8     cqiPmiSzR1;   /*CQIPMI Size for Rank =1*/
8200    U8     cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
8201
8202    TRC3(rgSCHCfgACqiUeCfg);
8203
8204    cqiPmiSzR1 = 0;
8205    cqiPmiSzRn1 = 0;
8206
8207    acqiCb->aCqiCfg.pres = aCqiCfg->pres;
8208    acqiCb->aCqiCfg.aprdModeEnum = aCqiCfg->aprdModeEnum;
8209
8210    if(aCqiCfg->pres)
8211    {
8212 #ifdef LTE_ADV
8213       /*Store Trigger Set Bit String to UE */
8214       RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
8215       pCellInfo->acqiCb.aCqiCfg.triggerSet1 = aCqiCfg->triggerSet1;
8216       pCellInfo->acqiCb.aCqiCfg.triggerSet2 = aCqiCfg->triggerSet2;
8217 #endif
8218
8219
8220       switch(aCqiCfg->aprdModeEnum)
8221       {
8222          case RGR_APRD_CQI_MOD12:
8223          case RGR_APRD_CQI_MOD30:
8224          case RGR_APRD_CQI_MOD31:
8225             RG_SCH_GET_CQI_K_VAL(cellCb->bwCfg.dlTotalBw, k);
8226             acqiCb->N = RGSCH_CEIL(cellCb->bwCfg.dlTotalBw, k);
8227             acqiCb->k = k;
8228             break;
8229
8230          case RGR_APRD_CQI_MOD20:
8231          case RGR_APRD_CQI_MOD22:
8232             RG_SCH_GET_SBCQI_M_K_VAL(cellCb->bwCfg.dlTotalBw, M, k);
8233             acqiCb->N = RGSCH_CEIL(cellCb->bwCfg.dlTotalBw, k);
8234             acqiCb->k = k;
8235             acqiCb->M = M;
8236             acqiCb->L = RgSCHUeAcqi2022LBitWidth[M-1][acqiCb->N-1];
8237             break;
8238
8239          default:
8240             break;
8241       }
8242       if((ueTxMode == RGR_UE_TM_3) ||
8243          (ueTxMode == RGR_UE_TM_4))
8244       {
8245          if(cellCb->numTxAntPorts ==2)
8246          {
8247             acqiCb->riNumBits = 1;
8248          }
8249          else if(cellCb->numTxAntPorts ==4)
8250          {
8251             if(ueCat == CM_LTE_UE_CAT_8)
8252             {
8253                acqiCb->riNumBits = 3;
8254             }
8255             else if(ueCat >= CM_LTE_UE_CAT_5)
8256             {
8257                acqiCb->riNumBits = 2;
8258             }
8259             else
8260             {
8261                acqiCb->riNumBits = 1;
8262             }
8263          }
8264       }
8265       rgSCHCfgUtlFetchAcqiBitSz(acqiCb, cellCb->numTxAntPorts,
8266             &cqiPmiSzR1, &cqiPmiSzRn1);
8267       acqiCb->cqiPmiSzR1  = cqiPmiSzR1;
8268       acqiCb->cqiPmiSzRn1 = cqiPmiSzRn1;
8269    }
8270    acqiCb->cqiReqField = TRUE;
8271 #ifdef LTE_ADV
8272    rgSchCmnSetCqiReqField(RG_SCH_CMN_GET_SCELL_INFO(ue, cellCb),ue,&acqiCb->cqiReqField);
8273 #endif
8274
8275    RETVALUE(ROK);
8276 }
8277
8278 /**
8279  * @brief Handles Periodic CQI , PMI, RI  configuration for a UE.
8280  *
8281  * @details
8282  *
8283  *     Function : rgSCHCfgPCqiUeCfg
8284  *
8285  *     Invoking Module Processing:
8286  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8287  *      validations for the spec-defined values.
8288  *
8289  *     Processing Steps:
8290  *     - For UE-specific Periodic CQI  related configuration,
8291  *      - If Periodic CQI/PMI is configured,
8292  *        - Update UE with the configured values.
8293  - Compute and Update next occurance of CQI/PMI or RI Tranmission instance.
8294  - Update the CQI offset and CQI perodicity information
8295  - Add Ue to cell's list
8296  *
8297  *
8298  *     - For UE-specific Periodic RI  related configuration,
8299  *      - If Periodic RI is configured,
8300  *        - Update UE with the configured values.
8301  - Compute and Update next occurance of RI Tranmission instance.
8302  - Update the  RI offset and RI perodicity information
8303  *
8304  *
8305  *     - Return ROK
8306  *
8307  *  @param[in]  RgSchCellCb  *cell
8308  *  @param[in]  RgSchUeCb    *ue
8309  *  @param[in]  RgrUePrdDlCqiCfg *cqiCfg
8310  *  @param[in]  CmLteUeCategory   ueCat
8311  *  @return  S16
8312  *      -# ROK
8313  *
8314  **/
8315 #ifdef ANSI
8316 PUBLIC S16 rgSCHCfgPCqiUeCfg
8317 (
8318  RgSchCellCb         *cellCb,
8319  RgSchUeCb           *ueCb,
8320  RgrUePrdDlCqiCfg    *cqiCfg,
8321  CmLteUeCategory     ueCat
8322  )
8323 #else
8324 PUBLIC S16 rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
8325    RgSchCellCb       *cellCb;
8326    RgSchUeCb         *ueCb;
8327    RgrUePrdDlCqiCfg  *cqiCfg;
8328    CmLteUeCategory   ueCat;
8329 #endif
8330 {
8331    CmLteTimingInfo timingInfo;
8332    U16    crntTime;
8333    U16    cqiTrInstTime;
8334    U8     j;  /*Bandwidth Parts*/
8335    U8     temp;
8336    U8     loop;
8337    RgSchUePCqiCb *cqiCb = NULLP;
8338    TRC3(rgSCHCfgPCqiUeCfg);
8339
8340    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)+
8341                   (cellCb->crntTime.subframe);
8342    cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
8343    cqiCb->servCellInfo = ueCb->cellInfo[0];
8344    /* Periodic CQI is setup  */
8345    if (cqiCfg->type == RGR_SCH_PCQI_SETUP)
8346    {
8347       for(loop = 0; loop < MAX_CQI_RI_RPT_BUFF;loop++)
8348       {
8349          ueCb->rawCqiBitW[loop].type = TFU_RECP_REQ_INVLD; /* setting invalid  type*/
8350       }
8351       /*  1. Copy the Received CQI Cfg parameters to ueCb  */
8352       cmMemcpy((U8 *)&cqiCb->cqiCfg, (U8 *)cqiCfg,
8353             sizeof(RgrUePrdDlCqiCfg));
8354
8355       /*  2. Compute Periodic CQI Periodicity and subframe offset   */
8356 #ifndef LTE_TDD
8357       rgSCHUtlGetCfgPerOff(RG_SCH_FDD_PCQI_TBL, cqiCfg->cqiSetup.cqiPCfgIdx,
8358             &cqiCb->cqiPeri, &cqiCb->cqiOffset);
8359 #else
8360       rgSCHUtlGetCfgPerOff( RG_SCH_TDD_PCQI_TBL,
8361             cqiCfg->cqiSetup.cqiPCfgIdx,
8362             &cqiCb->cqiPeri, &cqiCb->cqiOffset);
8363 #endif
8364       RLOG_ARG3(L_DEBUG,DBG_CELLID,cellCb->cellId,
8365             "rgSCHCfgPCqiUeCfg(): UEID:%d CQI Peri=%d, CQI Offset=%d",
8366             ueCb->ueId,
8367             cqiCb->cqiPeri,
8368             cqiCb->cqiOffset);
8369
8370
8371       cqiTrInstTime = ((cqiCb->cqiPeri+crntTime) - cqiCb->cqiOffset)
8372          %cqiCb->cqiPeri;
8373       cqiCb->nCqiTrIdx = (crntTime +
8374             (cqiCb->cqiPeri - cqiTrInstTime));
8375       /* Introduced timing delta for reception req
8376        * in FDD*/
8377       if(cqiCb->nCqiTrIdx  <= (crntTime + TFU_RECPREQ_DLDELTA))
8378       {
8379          cqiCb->nCqiTrIdx = cqiCb->nCqiTrIdx + cqiCb->cqiPeri;
8380       }
8381
8382       /* To handle the SFN wrap around case */
8383       cqiCb->nCqiTrIdx = cqiCb->nCqiTrIdx % (RGSCH_MAX_SFN * RGSCH_NUM_SUB_FRAMES_5G);
8384
8385       timingInfo.sfn =  cqiCb->nCqiTrIdx/RGSCH_NUM_SUB_FRAMES_5G;
8386       timingInfo.subframe =  cqiCb->nCqiTrIdx % RGSCH_NUM_SUB_FRAMES_5G;
8387
8388       cqiCb->nCqiTrIdx = cqiCb->nCqiTrIdx
8389            %RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
8390
8391 #ifdef EMTC_ENABLE
8392           /*CQI Repetition configuration*/
8393       if(ueCb->isEmtcUe)
8394       {
8395           rgSchfillPucchCqiRepNumCountemtc(cqiCb, ueCb);
8396       }
8397 #endif
8398
8399       if(RGR_UE_PCQI_SB_REP == cqiCfg->cqiSetup.cqiRepType)
8400       {
8401          U8     k;  /*SubBand Size (RB) */
8402          RG_SCH_GET_CQI_J_VAL(cellCb->bwCfg.dlTotalBw, j);
8403          RG_SCH_GET_CQI_K_VAL(cellCb->bwCfg.dlTotalBw, k);
8404          cqiCb->J = j; /*Number of Bandwidth Parts*/
8405          /*h: reporting instances required for a complete CQI/PMI report */
8406          /*j:Number of bandwidth parts; k: Subband Size*/
8407          cqiCb->h = (cqiCb->cqiCfg.cqiSetup.k *j )+1;
8408          /* ccpu00140905- L-size is coming as 3 for 100Rbs where it should be 2*/
8409          temp = RGSCH_CEIL(cellCb->bwCfg.dlTotalBw, (j*k));
8410          cqiCb->label = (temp & (temp-1)) ?
8411             (1+ rgSCHUtlLog32bitNbase2(temp)) : rgSCHUtlLog32bitNbase2(temp);
8412
8413          rgSCHTomUtlPcqiSbCalcBpIdx(timingInfo,ueCb, cqiCb);
8414       }
8415 #ifdef LTE_ADV
8416       else
8417       {
8418          cqiCb->prioLvl = RG_SCH_CQI_PRIO_LVL_1;
8419       }
8420 #endif
8421
8422       /*    Place the UE in cellCb->tIUeLstCp  */
8423       cqiCb->cqiLstEnt.node=(PTR) cqiCb;
8424 #ifdef LTE_ADV
8425       cqiCb->isCqiIgnoByCollsn = FALSE;
8426       cqiCb->isRiIgnoByCollsn = FALSE;
8427 #endif
8428
8429
8430       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,
8431             &cqiCb->cqiLstEnt);
8432
8433
8434       /* 4. Rank Indicator Cfg handler */
8435       rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
8436    }
8437    else
8438    {
8439       cqiCb->cqiCfg.type =  RGR_SCH_PCQI_REL;
8440       if(cqiCb->nCqiTrIdx != RG_SCH_INVALID_IDX)
8441       {
8442          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,\
8443                &cqiCb->cqiLstEnt);
8444       }
8445       if(cqiCb->nRiTrIdx != RG_SCH_INVALID_IDX)
8446       {
8447          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst, \
8448                &cqiCb->riLstEnt);
8449           RG_SCH_RECORD(&cqiCb->histElem,RGSCH_ACTION_DEL,
8450             &cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst);
8451       }
8452       cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
8453       cqiCb->nRiTrIdx   = RG_SCH_INVALID_IDX;
8454       cqiCb->riDist   = RG_SCH_INVALID_IDX;
8455    }
8456    ueCb->nPCqiCb = cqiCb;
8457    ueCb->nPRiCb = cqiCb;
8458    RETVALUE(ROK);
8459 }
8460
8461 /**
8462  * @brief Handles Periodic  RI  configuration for a UE.
8463  *
8464  * @details
8465  *
8466  *     Function : rgSCHCfgRiUeCfg
8467  *
8468  *     Invoking Module Processing:
8469  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8470  *      validations for the spec-defined values.
8471  *
8472  *     Processing Steps:
8473  *     - For UE-specific Periodic RI  related configuration,
8474  *      - If Periodic RI is configured,
8475  *        - Update UE with the configured values.
8476  - Compute and Update next occurance of RI Tranmission instance.
8477  - Update the  RI offset and RI perodicity information
8478  *
8479  *     - Return ROK
8480  *
8481  *  @param[in]  RgSchCellCb  *cell
8482  *  @param[in]  RgSchUeCb    *ue
8483  *  @param[in]  RgrUePrdDlCqiCfg *cqiCfg
8484  *  @param[in]  CmLteUeCategory   ueCat
8485  *  @return  S16
8486  *      -# ROK
8487  *
8488  **/
8489 #ifdef ANSI
8490 PUBLIC S16 rgSCHCfgRiUeCfg
8491 (
8492  RgSchCellCb        *cellCb,
8493  RgSchUeCb          *ueCb,
8494  RgrUePrdDlCqiCfg   *cqiCfg,
8495  CmLteUeCategory    ueCat
8496  )
8497 #else
8498 PUBLIC S16 rgSCHCfgRiUeCfg(cellCb, ueCb, cqiCfg, ueCat)
8499    RgSchCellCb       *cellCb;
8500    RgSchUeCb         *ueCb;
8501    RgrUePrdDlCqiCfg  *cqiCfg;
8502    CmLteUeCategory   ueCat;
8503 #endif
8504 {
8505    U16     crntTime;
8506    U16     riTrInsTime;
8507    U8      j; /*Bandwidth parts. Valid for Modes 2-0, 2-1*/
8508    U16     periodicity;
8509    U16    tempIdx;
8510    RgSchUePCqiCb *cqiCb = NULLP;
8511
8512    TRC3(rgSCHCfgRiUeCfg);
8513
8514
8515
8516    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
8517       +(cellCb->crntTime.subframe);
8518    cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
8519    /* 1. Rank Indicator is enabled  */
8520    if(cqiCfg->cqiSetup.riEna)
8521    {
8522
8523       rgSCHUtlGetCfgPerOff(RG_SCH_RI_TBL,
8524             cqiCfg->cqiSetup.riCfgIdx,
8525             &cqiCb->riPeri, &cqiCb->riOffset);
8526
8527       RLOG_ARG3(L_DEBUG,DBG_CELLID,cellCb->cellId,
8528             "rgSCHCfgRiUeCfg(): RI Peri=%d, RI Offset=%d UEID:%d",
8529             cqiCb->riPeri, cqiCb->riOffset,ueCb->ueId);
8530
8531       cqiCb->perRiVal = 1;
8532       cqiCb->invalidateCqi = FALSE;
8533
8534       if(RGR_UE_PCQI_WB_REP == cqiCfg->cqiSetup.cqiRepType)
8535       {
8536          /*
8537             1. wideband RI reporting is configured
8538             (Mode 1-0 or 1-1)
8539             (10*sfn+floor(subframe)-Noffsetcqi-NoffsetRI )Mod(NCqiperiod
8540           *MriPeriod)=0
8541           */
8542          periodicity = cqiCb->cqiPeri * cqiCb->riPeri;
8543       }
8544       else
8545       {
8546          /*
8547          *  Where Widesband and Subband RI reporting is configured
8548          *   (Mode 2-0 or 2-1 )
8549          *   (10*sfn+floor(subframe)-Noffsetcqi-NoffsetRI )
8550          *   Mod(H. NCqiperiod *MriPeriod )=0
8551          *   where H= J * K +1;  J=Number of bandwidth parts(BW/subsize).
8552          *   K is RGR interf input
8553          */
8554
8555          RG_SCH_GET_CQI_J_VAL(cellCb->bwCfg.dlTotalBw, j);
8556          cqiCb->h = (cqiCb->cqiCfg.cqiSetup.k *j )+1;
8557          periodicity = cqiCb->h * cqiCb->cqiPeri *
8558                                   cqiCb->riPeri;
8559       }
8560
8561       /* In case of SFN wraparound, the SB CQI reporting cycle breaks
8562        * and RI->WB CQI->SBCQI.. should resume. RI is repositioned
8563        * accordingly. WBCQI handling is naturally accomplished */
8564       if (periodicity >= RGSCH_MAX_SUBFRM_5G)
8565       {
8566          periodicity = cqiCb->cqiOffset - cqiCb->riOffset +
8567                        RGSCH_MAX_SUBFRM_5G - (crntTime);
8568          tempIdx = crntTime + periodicity;
8569                         printf("CHECK_SID - periodicity %d tempIdx %d\n", periodicity, tempIdx);
8570       }
8571       else
8572       {
8573          if ((crntTime + TFU_RECPREQ_DLDELTA + periodicity) >
8574                             (RGSCH_MAX_SUBFRM_5G - 1))
8575          {
8576             riTrInsTime = (periodicity - cqiCb->cqiOffset + cqiCb->riOffset) % periodicity;
8577             tempIdx = RGSCH_MAX_SUBFRM_5G + (periodicity - riTrInsTime);
8578          }
8579          else
8580          {
8581             riTrInsTime = ((periodicity +crntTime )- \
8582                cqiCb->cqiOffset + cqiCb->riOffset)\
8583                        % periodicity;
8584             tempIdx = (crntTime + (periodicity -riTrInsTime));
8585          }
8586       }
8587       if (tempIdx <= (crntTime + TFU_RECPREQ_DLDELTA))
8588       {
8589          tempIdx = tempIdx + periodicity;
8590       }
8591       cqiCb->nRiTrIdx = tempIdx
8592          % RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
8593       if(periodicity >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
8594       {
8595          cqiCb->riDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
8596                 (U16) tempIdx);
8597       }
8598       else
8599       {
8600          cqiCb->riDist =0;
8601       }
8602       if(ueCb->mimoInfo.txMode == RGR_UE_TM_3
8603             || ueCb->mimoInfo.txMode == RGR_UE_TM_4)
8604       {
8605          if (cellCb->numTxAntPorts ==2)
8606          {
8607             cqiCb->riNumBits = 1;
8608          }
8609          else if(cellCb->numTxAntPorts ==4)
8610          {
8611             if(ueCat == CM_LTE_UE_CAT_8)
8612             {
8613                cqiCb->riNumBits = 3;
8614             }
8615             else if(ueCat >= CM_LTE_UE_CAT_5)
8616             {
8617                cqiCb->riNumBits = 2;
8618             }
8619             else
8620             {
8621                cqiCb->riNumBits = 1;
8622             }
8623          }
8624       }
8625       /*    Place the UE in cellCb->tIUeLstCp  */
8626       cqiCb->riLstEnt.node=(PTR) cqiCb;
8627
8628       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst,
8629             &cqiCb->riLstEnt);
8630       RG_SCH_RECORD(&cqiCb->histElem,RGSCH_ACTION_ADD,
8631          &cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst);
8632
8633
8634    }
8635    else
8636    {
8637       cqiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
8638       cqiCb->riDist   = RG_SCH_INVALID_IDX;
8639    }
8640
8641    RETVALUE(ROK);
8642
8643 }
8644
8645 /* @brief Handles SRS configuration for a UE.
8646  *
8647  * @details
8648  *
8649  *     Function : rgSCHCfgSrsUeCfg
8650  *
8651  *     Invoking Module Processing:
8652  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8653  *      validations for the spec-defined values.
8654  *
8655  *     Processing Steps:
8656  *     - For UE-specific SRS  related configuration,
8657  *      - If SRS is configured,
8658  *        - Update UE with the configured values.
8659  - Compute and Update next occurance of SRS Tranmission instance.
8660  - Update the  SRS offset and SRS perodicity information
8661  - Add Ue to cell's srs list
8662  *      - else
8663  *        - next occurance transmission instance of SRS  = RG_SCH_INVALID_IDX
8664  *
8665  *     - Return ROK
8666  *
8667  *  @param[in]  RgSchCellCb  *cell
8668  *  @param[in]  RgSchUeCb    *ue
8669  *  @param[in]  RgrUeUlSrsCfg   *srsCfg
8670  *
8671  *  @return  S16
8672  *      -# ROK
8673  *      -# RFAILED
8674  */
8675 #ifdef ANSI
8676 PUBLIC S16 rgSCHCfgSrsUeCfg
8677 (
8678  RgSchCellCb     *cellCb,
8679  RgSchUeCb       *ueCb,
8680  RgrUeUlSrsCfg   *srsCfg
8681  )
8682 #else
8683 PUBLIC S16 rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg)
8684    RgSchCellCb     *cellCb;
8685    RgSchUeCb       *ueCb;
8686    RgrUeUlSrsCfg   *srsCfg;
8687 #endif
8688 {
8689    U16      srsTrInsTime;
8690    U16      crntTime;
8691    U16      tempIdx;
8692
8693    TRC3(rgSCHCfgSrsUeCfg);
8694
8695
8696    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
8697       +(cellCb->crntTime.subframe);
8698
8699    if(RGR_SCH_SRS_SETUP == srsCfg->type)
8700    {
8701       /*  1. Copy the Received Cfg parameters to local cb  */
8702       cmMemcpy((U8 *)&ueCb->srsCb.srsCfg, (U8 *)srsCfg, sizeof(RgrUeUlSrsCfg));
8703
8704 #ifndef LTE_TDD
8705       /* 2.  Compute SRS Offset and Periodicity */
8706       rgSCHUtlGetCfgPerOff( RG_SCH_FDD_SRS_TBL,
8707             srsCfg->srsSetup.srsCfgIdx,
8708             &ueCb->srsCb.peri, &ueCb->srsCb.offset);
8709 #else
8710       rgSCHUtlGetCfgPerOff( RG_SCH_TDD_SRS_TBL,
8711             srsCfg->srsSetup.srsCfgIdx,
8712             &ueCb->srsCb.peri, &ueCb->srsCb.offset);
8713 #endif
8714
8715       RLOG_ARG3(L_DEBUG,DBG_CELLID,cellCb->cellId,
8716             "rgSCHCfgSrsUeCfg(): SRS Peri=%d, SRS Offset=%d UEID:%d",
8717             ueCb->srsCb.peri,ueCb->srsCb.offset,ueCb->ueId);
8718
8719       /*  3. Compute next Tranmission index for SRS */
8720       /*     Referenence: 36.213 Section:8.2
8721              i. SRS transmission instances for TDD with  period > 2 and for FDD are
8722              ((10*sfn +Ksrs-suframeoffset))/mod(periodicity))
8723              FDD: Ksrs is 0...9
8724              TDD: Ksrs Table 8.2-3:
8725              ii.The SRS transmission instances for TDD (periodicity == 2)
8726              (Ksrs-Toffset)mod(5)==0.  Note: This is not supported now
8727       */
8728
8729       srsTrInsTime = ((ueCb->srsCb.peri+crntTime) - ueCb->srsCb.offset)
8730          %ueCb->srsCb.peri;
8731      tempIdx = (crntTime + (ueCb->srsCb.peri - srsTrInsTime));
8732 #ifdef LTE_TDD
8733       if (tempIdx  <=  (crntTime + TFU_DELTA))
8734 #else
8735       if (tempIdx  <=  (crntTime + TFU_RECPREQ_DLDELTA))
8736 #endif
8737       {
8738          tempIdx = tempIdx + ueCb->srsCb.peri;
8739       }
8740       ueCb->srsCb.nSrsTrIdx =(U16) (tempIdx
8741          % RG_SCH_PCQI_SRS_SR_TRINS_SIZE);
8742       if(ueCb->srsCb.peri >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
8743       {
8744 #ifdef LTE_TDD
8745          ueCb->srsCb.srsDist = rgSCHUtlFindDist((U8)(crntTime+TFU_DELTA),
8746                                                     (U16)tempIdx);
8747 #else
8748          ueCb->srsCb.srsDist = rgSCHUtlFindDist((U8)(crntTime + TFU_RECPREQ_DLDELTA),
8749                                                     (U16)tempIdx);
8750 #endif
8751       }
8752       else
8753       {
8754          ueCb->srsCb.srsDist = 0;
8755       }
8756
8757       /*UE Tx Antenna Selection - START*/
8758       if(ueCb->ul.ulTxAntSel.pres == TRUE )
8759       {
8760           /*for both partial and full sounding bandwidth,
8761            and when frequency hopping is disabled */
8762          ueCb->srsCb.selectedAnt = (crntTime/ueCb->srsCb.peri)%2;
8763       }
8764       else
8765       {
8766          /* TS 36.213 specifies that if Tx Antenna Selection is
8767             disabled/not supported then its Port 0*/
8768          ueCb->srsCb.selectedAnt=0;
8769       }
8770       ueCb->validTxAnt = ueCb->srsCb.selectedAnt;
8771       /*UE Tx Antenna Selection - ENDS*/
8772
8773       ueCb->srsCb.srsLstEnt.node=(PTR)ueCb;
8774       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
8775             &ueCb->srsCb.srsLstEnt);
8776
8777
8778    }
8779    else
8780    {
8781       /*  SRS Release / Not configured */
8782       ueCb->srsCb.srsCfg.type = RGR_SCH_SRS_REL;
8783       if(ueCb->srsCb.nSrsTrIdx != RG_SCH_INVALID_IDX)
8784       {
8785          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
8786                &ueCb->srsCb.srsLstEnt);
8787       }
8788       ueCb->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
8789       ueCb->srsCb.srsLstEnt.node =(PTR) NULLP;
8790    }
8791
8792    RETVALUE(ROK);
8793 }
8794
8795
8796 /* * @brief Handles SR configuration for a UE.
8797  *
8798  * @details
8799  *
8800  *     Function : rgSCHCfgSrUeCfg
8801  *
8802  *     Invoking Module Processing:
8803  *      - This shall be invoked by SCH_GOM at UE configuration. It shall do the
8804  *      validations for the spec-defined values.
8805  *
8806  *      - If SR is configured,
8807  *        - Update UE with the configured values.
8808  - Compute and Update next occurance of SR Tranmission instance.
8809  - Update the  SR offset and SR perodicity information
8810  - Add Ue to cell->tIUeLstCp[n]
8811  *      - else
8812  *        - next occurance transmission instance of SR = RG_INVALID_SR_ID
8813  *
8814  *
8815  *     - Return ROK
8816  *
8817  *  @param[in]  RgSchCellCb  *cell
8818  *  @param[in]  RgSchUeCb    *ue
8819  *  @param[in]  RgrUeSrCfg       *srCfg
8820  *
8821  *  @return  S16
8822  *      -# ROK
8823  *      -# RFAILED
8824  */
8825 #ifdef ANSI
8826 PUBLIC S16 rgSCHCfgSrUeCfg
8827 (
8828  RgSchCellCb      *cellCb,
8829  RgSchUeCb        *ueCb,
8830  RgrUeSrCfg       *srCfg
8831  )
8832 #else
8833 PUBLIC S16 rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg)
8834    RgSchCellCb    *cellCb;
8835    RgSchUeCb      *ueCb;
8836    RgrUeSrCfg     *srCfg;
8837 #endif
8838 {
8839    U16     srTrInsTime;
8840    U16     crntTime;
8841
8842    TRC3(rgSCHCfgSrUeCfg);
8843
8844
8845    crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
8846       +(cellCb->crntTime.subframe);
8847    if(srCfg->type == RGR_SCH_SR_SETUP)
8848    {
8849       /*  1. Copy the Received Cfg parameters to local cb  */
8850       cmMemcpy((U8 *)&ueCb->srCb.srCfg, (U8 *)srCfg, sizeof(RgrUeSrCfg));
8851
8852
8853       /*  2. Compute SR periodicity and offset */
8854       rgSCHUtlGetCfgPerOff( RG_SCH_SR_TBL,
8855             srCfg->srSetup.srCfgIdx,
8856             &ueCb->srCb.peri, &ueCb->srCb.offset);
8857
8858       RLOG_ARG4(L_DEBUG,DBG_CELLID,cellCb->cellId ,
8859             "SR Config: idx(%u), period (%u) offset (%u) UEID:%d",
8860             srCfg->srSetup.srCfgIdx,
8861             ueCb->srCb.peri,
8862             ueCb->srCb.offset,
8863             ueCb->ueId);
8864 #ifdef EMTC_ENABLE
8865       if(ueCb->isEmtcUe)
8866       {
8867          rgSchfillPucchSrRepNumCountemtc(ueCb);
8868       }
8869 #endif
8870       /*   3. Compute Next Transmission Instance */
8871
8872       srTrInsTime = ((ueCb->srCb.peri+crntTime) - ueCb->srCb.offset)
8873          %ueCb->srCb.peri;
8874       ueCb->srCb.nSrTrIdx = (crntTime + (ueCb->srCb.peri- srTrInsTime));
8875 #ifdef LTE_TDD
8876       if (ueCb->srCb.nSrTrIdx  <= (crntTime + TFU_DELTA))
8877 #else
8878       if (ueCb->srCb.nSrTrIdx  <= (crntTime + TFU_RECPREQ_DLDELTA))
8879 #endif
8880       {
8881          ueCb->srCb.nSrTrIdx = ueCb->srCb.nSrTrIdx +  ueCb->srCb.peri;
8882       }
8883       ueCb->srCb.nSrTrIdx = ueCb->srCb.nSrTrIdx
8884          % RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
8885       ueCb->srCb.srLstEnt.node= (PTR) ueCb;
8886
8887       /* 4. Place UE in Cell SR Tranmisison Instance List  */
8888       cmLListAdd2Tail(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
8889             &ueCb->srCb.srLstEnt);
8890    }
8891    else
8892    {
8893       ueCb->srCb.srCfg.type =  RGR_SCH_SR_REL;
8894
8895       if(ueCb->srCb.nSrTrIdx != RG_SCH_INVALID_IDX)
8896       {
8897          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
8898                &ueCb->srCb.srLstEnt);
8899       }
8900       ueCb->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
8901       ueCb->srCb.srLstEnt.node = (PTR)NULLP;
8902    }
8903
8904    RETVALUE(ROK);
8905 }
8906
8907
8908 /*****************************************************************
8909  *    UE PCQI, RI, SRS and SR       Re Configuration Functions    *
8910  *                                                                *
8911  ******************************************************************/
8912
8913
8914 /* * @brief Handles Periodic CQI, PMI, RI  Re-configuration for a UE.
8915  *
8916  * @details
8917  *
8918  *     Function : rgSCHCfgPCqiUeReCfg
8919  *
8920  *     Invoking Module Processing:
8921  *      - This shall be invoked by SCH_GOM at UE Re configuration. It shall do the
8922  *      validations for the spec-defined values.
8923  *
8924  *     Processing Steps:
8925  *     - For UE-specific Periodic CQI  related configuration,
8926  *      - If Periodic CQI/PMI is re configured(first time enabled),
8927  *          - Update UE with the configured values.
8928  *         - Compute and Update next occurance of CQI/PMI or RI Tranmission
8929  *         instance.
8930  *         - Update the CQI offset and CQI perodicity information
8931  *         - Add Ue to cell's list
8932  *      - If Periodic CQI/PMI is re configured(modify),
8933  *         - Update UE with the configured values.
8934  *         - Del Ue from cell->tIUeLstCp list
8935  *          - Compute and Update next occurance of CQI/PMI or RI Tranmission
8936  *          instance.
8937  *         - Update the CQI offset and CQI perodicity information
8938  *         - Add Ue to cell's list
8939  *      - If Periodic CQI/PMI is re configured(disabled),
8940  *        - Update UE with the configured values.
8941  *         - Del Ue from cell's list
8942  *         - Update next occurance of CQI/PMI or RI Tranmission instance.
8943  *        - next occurance of CQI/PMI = RG_INVALID_CQIPMI_ID
8944  *
8945  *     - For UE-specific Periodic RI  related configuration,
8946  *      - If Periodic RI is configured(first time enabled),
8947  *        - Update UE with the configured values.
8948  *          - Compute and Update next occurance of RI Tranmission instance.
8949  *         - Update the  RI offset and RI perodicity information
8950  *      - If Periodic RI is configured(modify),
8951  *        - Update UE with the configured values.
8952  *         - Compute and Update next occurance of RI Tranmission instance.
8953  *         - Update the  RI offset and RI perodicity information
8954  *      - else
8955  *        - next occurance of RI  = RG_INVALID_CQIPMI_ID
8956  *
8957  *     - Return ROK
8958  *
8959  *  @param[in]  RgSchCellCb  *cell
8960  *  @param[in]  RgSchUeCb    *ue
8961  *  @param[in]  RgrUeCfg     *ueCfg
8962  *
8963  *  @return  S16
8964  *      -# ROK
8965  *
8966  */
8967 #ifdef ANSI
8968 PUBLIC S16 rgSCHCfgPCqiUeReCfg
8969 (
8970  RgSchCellCb        *cellCb,
8971  RgSchUeCb          *ueCb,
8972  RgrUePrdDlCqiCfg   *cqiCfg,
8973  CmLteUeCategory      ueCat
8974  )
8975 #else
8976 PUBLIC S16  rgSCHCfgPCqiUeReCfg(cellCb, ueCb, cqiCfg, ueCat)
8977    RgSchCellCb       *cellCb;
8978    RgSchUeCb         *ueCb;
8979    RgrUePrdDlCqiCfg  *cqiCfg;
8980    CmLteUeCategory  ueCat;
8981 #endif
8982 {
8983
8984    RgSchUePCqiCb *cqiCb = NULLP;
8985    TRC3(rgSCHCfgPCqiUeReCfg);
8986
8987    cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
8988    /* Fix: ccpu00124008 Fix for incorrect check causing missed CQI reception instance */
8989    if((cqiCfg->type == RGR_SCH_PCQI_SETUP) &&
8990          (cqiCb->cqiCfg.type != RGR_SCH_PCQI_SETUP))
8991    {
8992       /* 1. cqi is in Release (Disable) state,  Recfg is allowing Setup (Enable)
8993       */
8994       rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
8995
8996    }
8997    else if((cqiCfg->type == RGR_SCH_PCQI_SETUP) &&
8998          (cqiCb->cqiCfg.type == RGR_SCH_PCQI_SETUP ))
8999    {
9000
9001       /*
9002          2. Present is SETUP(Enable) state,  Recfg is modifying SETUP(Enable)
9003
9004          2.1 Delete UE from the cqiList
9005          2.2 Set next occurance Transmission instace to "INVALID"
9006          2.3 Compute Next occurance Transmission instace
9007          2.4 Placed ue in Transmission instance list.
9008          */
9009       if(cqiCb->nCqiTrIdx != RG_SCH_INVALID_IDX )
9010          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nCqiTrIdx].cqiLst,
9011                &cqiCb->cqiLstEnt);
9012
9013       if(cqiCb->nRiTrIdx != RG_SCH_INVALID_IDX )
9014       {
9015          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst,
9016                &cqiCb->riLstEnt);
9017          RG_SCH_RECORD(&cqiCb->histElem,RGSCH_ACTION_DEL,
9018             &cellCb->pCqiSrsSrLst[cqiCb->nRiTrIdx].riLst);
9019       }
9020
9021
9022       cqiCb->cqiLstEnt.next = NULLP;
9023       cqiCb->cqiLstEnt.prev  = NULLP;
9024       cqiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
9025       cqiCb->nRiTrIdx  = RG_SCH_INVALID_IDX;
9026       cqiCb->riDist    = RG_SCH_INVALID_IDX;
9027
9028       rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
9029    }
9030    else
9031    {
9032       /* Present is SETUP(Enable) state,  Recfg is Release(Disable)  */
9033       rgSCHCfgPCqiUeCfg(cellCb, ueCb, cqiCfg, ueCat);
9034    }
9035
9036    /* ccpu00140578:: */
9037    cqiCb->riRecpPrcsd = FALSE;
9038    RETVALUE(ROK);
9039 }
9040
9041
9042 /* * @brief Handles SRS  Re-configuration for a UE.
9043  *
9044  * @details
9045  *
9046  *     Function : rgSCHCfgSrsUeReCfg
9047  *
9048  *     Invoking Module Processing:
9049  *      - This shall be invoked by SCH_GOM at UE Re configuration. It shall do the
9050  *      validations for the spec-defined values.
9051  *
9052  *     Processing Steps:
9053  *     - For UE-specific SRS  related re configuration,
9054  *      - If SRS is configured modified(First time Enabled),
9055  *        - Update UE with the configured values.
9056  *         - Compute and Update next occurance of SRS Tranmission instance.
9057  *        - Update the  SRS offset and SRS perodicity information
9058  *        - Add Ue to cell's list
9059  *      - If SRS is configured modified(Changed offset or index ),
9060  *      - Delete UE from cell->tIUeLstCp[n] if present
9061  *      - Update UE with the configured values.
9062  *      - Compute and Update next occurance of SRS Tranmission instance.
9063  *      - Update the  SRS offset and SRS perodicity information
9064  *      - Add Ue to cell's list
9065  *      - If SRS is configured modified(disabled),
9066  *      - Delete UE from cell->tIUeLstCp[n] if present
9067  *        - Update next occurance of SRS Tranmission instance to "INVALID".
9068  *        - Update the  SRS offset and SRS perodicity information "INVALID"
9069  *      - else
9070  *        - ROK
9071  *
9072  *     - Return ROK
9073  *
9074  *  @param[in]  RgSchCellCb  *cell
9075  *  @param[in]  RgSchUeCb    *ue
9076  *  @param[in]  RgrUeUlSrsCfg    *srsCfg
9077  *
9078  *  @return  S16
9079  *      -# ROK
9080  *      -# RFAILED
9081  */
9082 #ifdef ANSI
9083 PUBLIC S16 rgSCHCfgSrsUeReCfg
9084 (
9085  RgSchCellCb        *cellCb,
9086  RgSchUeCb          *ueCb,
9087  RgrUeUlSrsCfg      *srsCfg
9088  )
9089 #else
9090 PUBLIC S16 rgSCHCfgSrsUeReCfg(cellCb, ueCb, srsCfg)
9091    RgSchCellCb      *cellCb;
9092    RgSchUeCb        *ueCb;
9093    RgrUeUlSrsCfg    *srsCfg;
9094 #endif
9095 {
9096
9097    TRC3(rgSCHCfgSrsUeReCfg);
9098
9099
9100
9101    if(( RGR_SCH_SRS_SETUP == srsCfg->type) ||
9102          ( RGR_SCH_SRS_SETUP != ueCb->srsCb.srsCfg.type ))
9103    {
9104       /*     1. Present is Release(Disable) state,  Recfg is allowing
9105        *     SETUP(Enable)  */
9106       rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg);
9107    }
9108    else if (( RGR_SCH_SRS_SETUP == srsCfg->type ) &&
9109          ( RGR_SCH_SRS_SETUP  == ueCb->srsCb.srsCfg.type))
9110    {
9111
9112       /*     2. Present is SETUP(Eanble) state,  Recfg is modifying SETUP(Enable)
9113
9114              2.1 Delete UE from the cqiList
9115              2.2 Set next occurance Transmission instance to "INVALID"
9116              2.3 Compute Next occurance Transmission instance
9117              2.4 Placed ue in Transmission instance list.
9118              */
9119       if (ueCb->srsCb.nSrsTrIdx != RG_SCH_INVALID_IDX)
9120       {
9121          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
9122                &ueCb->srsCb.srsLstEnt);
9123          ueCb->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
9124       }
9125
9126       rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg);
9127    }
9128    else
9129    {
9130       /* 3. Present is SETUP(Enable) state,  Recfg is Release(Disable)*/
9131       rgSCHCfgSrsUeCfg(cellCb, ueCb, srsCfg);
9132    }
9133    /* ccpu00140578:: */
9134    ueCb->srsCb.srsRecpPrcsd = FALSE;
9135
9136    RETVALUE(ROK);
9137 }
9138
9139 /* @brief Handles  SR Re-configuration for a UE.
9140  *
9141  * @details
9142  *
9143  *     Function : rgSCHCfgSrUeReCfg
9144  *
9145  *     Invoking Module Processing:
9146  *      - This shall be invoked by SCH_GOM at UE Re configuration.
9147  *      It shall do the validations for the spec-defined values.
9148  *
9149  *     Processing Steps:
9150  *     - For UE-specific SR  related re configuration,
9151  *      - If SR is configured modified(First time Enabled),
9152  *        - Update UE with the configured values.
9153  *          - Compute and Update next occurance of SR Tranmission instance.
9154  *         - Update the  SR offset and SR perodicity information
9155  *         - Add Ue to cell->tIUeLstCp[n]
9156  *      - If SR is configured modified(Changed offset or index ),
9157  *      - Delete UE from cell->tIUeLstCp[n] if present
9158  *       - Update UE with the configured values.
9159  *       - Compute and Update next occurance of SR Tranmission instance.
9160  *       - Update the  SR offset and SR perodicity information
9161  *       - Add Ue to cell->tIUeLstCp[n]
9162  *      - If SR is configured modified(disabled),
9163  *      - Delete UE from cell->tIUeLstCp[n] if present
9164  *         - Update next occurance of SR Tranmission instance to "INVALID".
9165  *         - Update the  SR offset and SR perodicity information "INVALID"
9166  *      - else
9167  *        - ROK
9168  *
9169  *
9170  *
9171  *     - Return ROK
9172  *
9173  *  @param[in]  RgSchCellCb  *cell
9174  *  @param[in]  RgSchUeCb    *ue
9175  *  @param[in]  RgrUeCfg     *ueCfg
9176  *
9177  *  @return  S16
9178  *      -# ROK
9179  *      -# RFAILED
9180  */
9181 #ifdef ANSI
9182 PUBLIC S16 rgSCHCfgSrUeReCfg
9183 (
9184  RgSchCellCb    *cellCb,
9185  RgSchUeCb      *ueCb,
9186  RgrUeSrCfg     *srCfg
9187  )
9188 #else
9189 PUBLIC S16 rgSCHCfgSrUeReCfg(cellCb, ueCb, srCfg)
9190    RgSchCellCb   *cellCb;
9191    RgSchUeCb     *ueCb;
9192    RgrUeSrCfg    *srCfg;
9193 #endif
9194 {
9195    TRC3(rgSCHCfgSrUeReCfg);
9196
9197
9198    /* Fix : syed Incorrect check for SR RECFG */
9199    if((srCfg->type == RGR_SCH_SR_SETUP) &&
9200          (ueCb->srCb.srCfg.type != RGR_SCH_SR_SETUP))
9201    {
9202       /*
9203          1. Present is Release(Disable) state,  Recfg is allowing SETUP(Enable)
9204          */
9205       rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
9206    }
9207    else if((srCfg->type == RGR_SCH_SR_SETUP) &&
9208          (ueCb->srCb.srCfg.type == RGR_SCH_SR_SETUP))
9209    {
9210
9211       /*   2. Present is SETUP(Eanble) state,  Recfg is modifying SETUP(Enable)
9212
9213            2.1 Delete UE from the cqiList
9214            2.2 Compute Next occurance Transmission instace
9215            */
9216       if(ueCb->srCb.nSrTrIdx != RG_SCH_INVALID_IDX )
9217       {
9218          cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
9219                &ueCb->srCb.srLstEnt);
9220          ueCb->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
9221       }
9222       rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
9223
9224    }
9225    else
9226    {
9227       /* 3. Present is SETUP(Enable) state,  Recfg is Release(Disable) */
9228       rgSCHCfgSrUeCfg(cellCb, ueCb, srCfg);
9229    }
9230
9231    RETVALUE(ROK);
9232 }
9233
9234 /* @brief Handles  ACQI Re-configuration for a UE.
9235  *
9236  * @details
9237  *
9238  *     Function : rgSCHCfgAcqiUeReCfg
9239  *
9240  *     Invoking Module Processing:
9241  *      - This shall be invoked by SCH_GOM at UE Re configuration.
9242  *      It shall do the validations for the spec-defined values.
9243  *
9244  *     Processing Steps:
9245  *     - For UE-specific ACQI  related re configuration,
9246  *          - Check if the ACQI Mode has been changed from the
9247  *             existing Configuration.
9248  *     - If the configuration has been changed,
9249  *          - Call Aperiodic Config function to change the config
9250  *      - else
9251  *        - ROK
9252  *
9253  *
9254  *     - Return ROK
9255  *
9256  *  @param[in]  RgSchCellCb  *cell
9257  *  @param[in]  RgSchUeCb    *ue
9258  *  @param[in]  RgrUeAprdDlCqiCfg   *acqiCfg
9259  *
9260  *  @return  S16
9261  *      -# ROK
9262  *      -# RFAILED
9263  */
9264 #ifdef ANSI
9265 PUBLIC S16 rgSCHCfgAcqiUeReCfg
9266 (
9267  RgSchCellCb    *cellCb,
9268  RgSchUeCb      *ueCb,
9269  RgrUeAprdDlCqiCfg   *acqiCfg,
9270  CmLteUeCategory   ueCat
9271  )
9272 #else
9273 PUBLIC S16 rgSCHCfgAcqiUeReCfg(cellCb, ueCb, acqiCfg, ueCat)
9274    RgSchCellCb   *cellCb;
9275    RgSchUeCb     *ueCb;
9276    RgrUeAprdDlCqiCfg   *acqiCfg;
9277    CmLteUeCategory   ueCat;
9278 #endif
9279 {
9280    TRC3(rgSCHCfgAcqiUeReCfg);
9281
9282    RETVALUE(rgSCHCfgACqiUeCfg(cellCb,ueCb,(RG_SCH_CMN_GET_ACQICB(ueCb,cellCb))
9283                                     ,ueCb->mimoInfo.txMode, acqiCfg, ueCat));
9284
9285 }
9286
9287 /*****************************************************************
9288  *   UE PCQI, RI, SRS and SR Configuration  Delete                *
9289  *                                                                *
9290  *****************************************************************/
9291
9292 /* @brief Free Periodic CQI/PMI/RI, SRS and SR transmission instance
9293  * related data structures of this UE from CellCb
9294  *
9295  * @details
9296  *
9297  *     Function : rgSCHCfgPCqiSrsSrUeDel
9298  *
9299  *     Invoking Module Processing:
9300  *      - This shall be invoked by SCH_GOM at Ue deletion.
9301  *
9302  *     Processing Steps:
9303  *      - For SRS Transmission Instance
9304  *       - if (srsTxInst!= RG_INVALID)
9305  *        - Remove from the cellCb->tIUeLstCp[srsTxInst*3+2]
9306  *       - else
9307  *        - Nothing to do
9308  *      - For SR Transmission Instance
9309  *       - if (srTxInst!= RG_INVALID)
9310  *        - Remove from the cellCb->tIUeLstCp[srTxInst*3+1]
9311  *       - else
9312  *        - Nothing to do
9313  *      - For Periodic CQI/PMI RI  Transmission Instance
9314  *       - if (pCqiTxInst!= RG_INVALID)
9315  *        - Remove from the cellCb->tIUeLstCp[srTxInst*3+0]
9316  *       - else
9317  *        - Nothing to do
9318  *      - Return ROK
9319  *  @param[in]  RgSchCellCb  *cell
9320  *  @param[in]  RgSchUeCb    *ue
9321  *
9322  *  @return  S16
9323  *      -# ROK
9324  */
9325 #ifdef ANSI
9326 PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel
9327 (
9328  RgSchCellCb      *cellCb,
9329  RgSchUeCb        *ueCb
9330  )
9331 #else
9332 PUBLIC S16 rgSCHCfgPCqiSrsSrUeDel(cellCb, ueCb)
9333    RgSchCellCb    *cellCb;
9334    RgSchUeCb      *ueCb;
9335 #endif
9336 {
9337 #ifdef LTE_ADV
9338    U32 cellIdx;
9339    U32 sCellCnt = 0;
9340 #endif
9341    RgSchUePCqiCb *cqiRiCb = NULLP;
9342    TRC3(rgSCHCfgPCqiSrsSrUeDel);
9343
9344    cqiRiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cellCb);
9345
9346
9347
9348    /* Delete SRS Transmission Instance  */
9349    if (ueCb->srsCb.nSrsTrIdx != RG_SCH_INVALID_IDX)
9350    {
9351       cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srsCb.nSrsTrIdx].srsLst,
9352             &ueCb->srsCb.srsLstEnt);
9353       ueCb->srsCb.nSrsTrIdx = RG_SCH_INVALID_IDX;
9354    }
9355
9356    /* Delete SR Transmission Instance  */
9357    if (ueCb->srCb.nSrTrIdx != RG_SCH_INVALID_IDX)
9358    {
9359       cmLListDelFrm(&cellCb->pCqiSrsSrLst[ueCb->srCb.nSrTrIdx].srLst,
9360             &ueCb->srCb.srLstEnt);
9361       ueCb->srCb.nSrTrIdx = RG_SCH_INVALID_IDX;
9362    }
9363
9364    /* Delete Periodic CQI/PMI  Transmission Instance  */
9365    if (cqiRiCb->nCqiTrIdx != RG_SCH_INVALID_IDX)
9366    {
9367       cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nCqiTrIdx].cqiLst,
9368             &cqiRiCb->cqiLstEnt);
9369       cqiRiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
9370
9371       /* Delete Periodic  RI  Transmission Instance  */
9372
9373       if (cqiRiCb->nRiTrIdx != RG_SCH_INVALID_IDX)
9374       {
9375          cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst,
9376                &cqiRiCb->riLstEnt);
9377          RG_SCH_RECORD(&cqiRiCb->histElem,RGSCH_ACTION_DEL,
9378             &cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst);
9379          cqiRiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
9380       }
9381    }
9382
9383 #ifdef LTE_ADV
9384    for (cellIdx =1; cellIdx <= RG_SCH_MAX_SCELL; cellIdx++)
9385    {
9386       /* If a serving cell is configured */
9387       if(ueCb->cellInfo[cellIdx] != NULLP)
9388       {
9389          /* If the serving cell is in ACTIVE state and
9390             If it is not the same serving cell as cqiRiCb for which
9391             collision is being checked */
9392          cqiRiCb = &ueCb->cellInfo[cellIdx]->cqiCb;
9393          /* Delete Periodic CQI/PMI  Transmission Instance  */
9394          if (cqiRiCb->nCqiTrIdx != RG_SCH_INVALID_IDX)
9395          {
9396             cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nCqiTrIdx].cqiLst,
9397                   &cqiRiCb->cqiLstEnt);
9398             cqiRiCb->nCqiTrIdx = RG_SCH_INVALID_IDX;
9399
9400             /* Delete Periodic  RI  Transmission Instance  */
9401
9402             if (cqiRiCb->nRiTrIdx != RG_SCH_INVALID_IDX)
9403             {
9404                cmLListDelFrm(&cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst,
9405                      &cqiRiCb->riLstEnt);
9406                RG_SCH_RECORD(&cqiRiCb->histElem,RGSCH_ACTION_DEL,
9407                   &cellCb->pCqiSrsSrLst[cqiRiCb->nRiTrIdx].riLst);
9408                cqiRiCb->nRiTrIdx = RG_SCH_INVALID_IDX;
9409             }
9410          }
9411          sCellCnt++;
9412          /* If all of the num of configured scells are checked then break */
9413          if (sCellCnt == ueCb->numSCells)
9414          {
9415             break;
9416          }
9417       }
9418    }
9419 #endif
9420
9421    RETVALUE(ROK);
9422 }
9423
9424
9425 /* @brief Search the cfgIdx in given table and retrive periodicity & offset
9426  * @details
9427  *
9428  *     Function : rgSCHUtlGetCfgPerOff
9429  *
9430  *     Invoking Module Processing:
9431  *      - This shall be invoked by Cfg Module
9432  *
9433  *     Processing Steps:
9434  *          binary search for given entry in table
9435  *          find the periodicty, offset for a given config index from the table
9436  *      - Return ROK
9437  *  @param[in]  RgSchPerTbl tbl
9438  *  @param[in]  U16      cfgIdx
9439  *  @param[out] U16     *peri
9440  *  @param[out] U16     *offset
9441  *
9442  *  @return  S16
9443  *      -# ROK
9444  *
9445  */
9446 #ifdef ANSI
9447 PUBLIC S16 rgSCHUtlGetCfgPerOff
9448 (
9449  RgSchPerTbl     tbl,
9450  U16             cfgIdx,
9451  U16             *peri,
9452  U16             *offset
9453  )
9454 #else
9455 PUBLIC S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
9456    RgSchPerTbl   tbl;
9457    U16           cfgIdx;
9458    U16           *peri;
9459    U16           *offset;
9460 #endif
9461 {
9462    U8     mid;
9463    U8     min = 0;
9464    U8     max = 0;
9465    CONSTANT RgSchUePCqiSrsSrCfgIdxTbl* table;
9466    TRC3(rgSCHUtlGetCfgPerOff);
9467
9468    /* Added the function instead of the MACRO to get the
9469     * periodicity table */
9470    table = rgSCHCfgUtlGetPcqiSrsSrRiTbl ( tbl,&min,&max );
9471    do{
9472       mid = (min+max)/2;
9473       if (( cfgIdx >= table[mid].min) &&
9474             ( cfgIdx <= table[mid].max))
9475       {
9476          *peri = table[mid].peri;
9477          *offset = cfgIdx - table[mid].offset;
9478          break;
9479       }
9480
9481       if ( cfgIdx > table[mid].min)
9482       {
9483          min = mid+1;
9484       }
9485       else
9486       {
9487          max = mid-1;
9488       }
9489
9490    }while( min <= max );
9491
9492    RETVALUE(ROK);
9493 }
9494
9495
9496 /***********************************************************
9497  *
9498  *     Func : rgSCHCfgUtlFetchAcqiBitSz
9499  *
9500  *
9501  *     Desc : Fetch the CQI/PMI bits for a UE based on the mode and store them
9502  *                for decoding.
9503  *
9504  *     Ret  : Void
9505  *            ROK - RETVOID
9506  *
9507  *     Notes:
9508  *
9509  *     File :
9510  *
9511  **********************************************************/
9512 #ifdef ANSI
9513 PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz
9514 (
9515  RgSchUeACqiCb      *acqiCb,
9516  U8                numTxAnt,
9517  U8*               cqiPmiSzR1,
9518  U8*               cqiPmiSzRn1
9519  )
9520 #else
9521 PRIVATE  Void rgSCHCfgUtlFetchAcqiBitSz(acqiCb, numTxAnt, cqiPmiSzR1, cqiPmiSzRn1)
9522  RgSchUeACqiCb      *acqiCb;
9523  U8                numTxAnt;
9524  U8*               cqiPmiSzR1;
9525  U8*               cqiPmiSzRn1;
9526 #endif
9527 {
9528
9529    U32               confRepMode;
9530
9531
9532    TRC3(rgSCHCfgUtlFetchAcqiBitSz);
9533
9534    confRepMode = acqiCb->aCqiCfg.aprdModeEnum;
9535    switch(confRepMode)
9536    {
9537       case RGR_APRD_CQI_MOD12:
9538          {
9539             if(numTxAnt == 2)
9540             {
9541                *cqiPmiSzR1 = 4 + 2*acqiCb->N;
9542                *cqiPmiSzRn1 = 8+ acqiCb->N;
9543             }
9544             else if(numTxAnt == 4)
9545             {
9546                *cqiPmiSzR1 = 4 + 4*acqiCb->N;
9547                *cqiPmiSzRn1 = 8 + 4*acqiCb->N;
9548             }
9549          }
9550          break;
9551
9552       case RGR_APRD_CQI_MOD20:
9553          {
9554             *cqiPmiSzR1 = 6 + acqiCb->L;
9555             *cqiPmiSzRn1 = 6  + acqiCb->L;
9556          }
9557          break;
9558
9559       case RGR_APRD_CQI_MOD22:
9560          {
9561             if(numTxAnt == 2)
9562             {
9563                *cqiPmiSzR1 = 10 + acqiCb->L;
9564                *cqiPmiSzRn1 = 14 + acqiCb->L;
9565             }
9566             else if(numTxAnt == 4)
9567             {
9568                *cqiPmiSzR1 = 14 + acqiCb->L;
9569                *cqiPmiSzRn1 = 20 + acqiCb->L;
9570             }
9571          }
9572          break;
9573
9574       case RGR_APRD_CQI_MOD30:
9575          {
9576             *cqiPmiSzR1 = 4 + 2*acqiCb->N;
9577             *cqiPmiSzRn1 = 4 + 2*acqiCb->N;
9578          }
9579          break;
9580
9581       case RGR_APRD_CQI_MOD31:
9582          {
9583             if(numTxAnt == 2)
9584             {
9585                *cqiPmiSzR1 = 6 + 2*acqiCb->N;
9586                *cqiPmiSzRn1 = 9 + 4*acqiCb->N;
9587             }
9588             else if(numTxAnt == 4)
9589             {
9590                *cqiPmiSzR1 = 8 + 2*acqiCb->N;
9591                *cqiPmiSzRn1 = 12 + 4*acqiCb->N;
9592             }
9593          }
9594          break;
9595       default:
9596          break;
9597    }
9598    RETVOID;
9599 }
9600 /* Added the function rgSCHCfgUtlGetPcqiCrsSrRiTbl to be used
9601  * instead of the MACRO RG_SCH_GET_PERIODICITY_TBL */
9602 /***********************************************************
9603  *
9604  *     Func : rgSCHCfgUtlGetPcqiCrsSrRiTbl
9605  *
9606  *
9607  *     Desc :  Get the Srs Cqi Crs Ri Table
9608  *
9609  *     Ret  : Void
9610  *            ROK - RETVOID
9611  *
9612  *     Notes:
9613  *
9614  *     File :
9615  *
9616  **********************************************************/
9617
9618 #ifdef ANSI
9619 PRIVATE CONSTANT RgSchUePCqiSrsSrCfgIdxTbl *  rgSCHCfgUtlGetPcqiSrsSrRiTbl
9620 (
9621    RgSchPerTbl tblType,
9622    U8* min,
9623    U8* max
9624 )
9625 #else
9626 PRIVATE CONSTANT RgSchUePCqiSrsSrCfgIdxTbl *  rgSCHCfgUtlGetPcqiSrsSrRiTbl(tblType, min, max)
9627    RgSchPerTbl tblType;
9628    U8* min;
9629    U8* max;
9630 #endif
9631 {
9632     CONSTANT RgSchUePCqiSrsSrCfgIdxTbl * table;
9633     TRC3(rgSCHCfgUtlGetPcqiCrsSrRiTbl);
9634
9635     switch (tblType)
9636     {
9637
9638         case RG_SCH_FDD_PCQI_TBL:
9639         {
9640             table = rgSchUePCqiCfgIdxFddTbl;
9641             * min = 0;
9642             * max=RG_SCH_CQIPMI_CFGIDX_MAX_FDD;
9643             break;
9644         }
9645         case RG_SCH_TDD_PCQI_TBL:
9646         {
9647             table = rgSchUeCqiPmiCfgIdxTddTbl;
9648             * min = 0;
9649             * max=RG_SCH_CQIPMI_CFGIDX_MAX_TDD;
9650             break;
9651         }
9652         case RG_SCH_RI_TBL:
9653         {
9654             table = rgSchUeRiCfgIdxTbl;
9655             * min = 0;
9656             * max=RG_SCH_RI_CFGIDX_MAX;
9657             break;
9658         }
9659         case RG_SCH_FDD_SRS_TBL:
9660         {
9661             table = rgSchUeSrsCfgIdxFddTbl;
9662             * min = 0;
9663             * max=RG_SCH_SRS_ISRS_INDX_MAX_FDD;
9664             break;
9665         }
9666         case RG_SCH_TDD_SRS_TBL:
9667         {
9668             table = rgSchUeSrsCfgIdxTddTbl;
9669             * min = 0;
9670             * max=RG_SCH_SRS_ISRS_INDX_MAX_TDD;
9671             break;
9672         }
9673         case RG_SCH_SR_TBL:
9674         {
9675             table = rgSchUeSrCfgIdxTbl;
9676             * min = 0;
9677             * max=RG_SCH_ISR_INDX_MAX;
9678             break;
9679         }
9680         default:
9681         {
9682             table = (CONSTANT RgSchUePCqiSrsSrCfgIdxTbl *) 0;
9683             * min = 0;
9684             * max = 0;
9685             break;
9686         }
9687
9688     }
9689     RETVALUE ( table );
9690 }
9691 /* #endif */
9692 #endif /* TFU_UPGRADE */
9693
9694 /***********************************************************
9695  *
9696  *     Func : rgSCHCfgVldtDrxUeCfg
9697  *
9698  *
9699  *     Desc : Validates UE DRX Timers Configuration recieved from RRC.
9700  *
9701  *     Ret  : S16
9702  *            ROK - Success
9703  *            RFAILED - Failed
9704  *
9705  *     Notes:
9706  *
9707  *     File :
9708  *
9709  **********************************************************/
9710 #ifdef ANSI
9711 PRIVATE S16 rgSCHCfgVldtDrxUeCfg
9712 (
9713 RgSchCellCb       *cell,
9714 RgrUeDrxCfg       *ueDrxCfg
9715 )
9716 #else
9717 PRIVATE S16 rgSCHCfgVldtDrxUeCfg(cell, ueDrxCfg)
9718 RgSchCellCb       *cell;
9719 RgrUeDrxCfg       *ueDrxCfg;
9720 #endif
9721 {
9722    TRC2(rgSCHCfgVldtDrxUeCfg)
9723
9724
9725    if (ueDrxCfg->isDrxEnabled == FALSE)
9726    {
9727       RETVALUE(ROK);
9728    }
9729
9730 #ifdef LTEMAC_R9
9731    if ( ueDrxCfg->cqiMask.pres )
9732    {
9733       if ( ueDrxCfg->cqiMask.val != RGR_DRX_SETUP )
9734       {
9735 #ifdef ALIGN_64BIT
9736          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid cqiMask configuration (%d)",
9737                   ueDrxCfg->cqiMask.val);
9738 #else
9739          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid cqiMask configuration(%ld)",
9740                   ueDrxCfg->cqiMask.val);
9741 #endif
9742          RETVALUE(RFAILED);
9743       }
9744    }
9745 #endif /*LTEMAC_R9*/
9746 #ifdef EMTC_ENABLE
9747    if(ueDrxCfg->isEmtcUe)
9748    {
9749       if(ueDrxCfg->drxOnDurTmrR13Pres)
9750       {
9751          if ( rgSCHEmtcCfgVldtDrxOnDurCfg(ueDrxCfg->drxOnDurTmr) != ROK )
9752          {
9753             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d)",
9754                ueDrxCfg->drxOnDurTmr);
9755             RETVALUE(RFAILED);
9756          }
9757        }
9758          else
9759          {
9760             if (rgSCHCfgVldtDrxOnDurCfg(ueDrxCfg->drxOnDurTmr) != ROK )
9761             {
9762                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d) for EMTC",
9763                ueDrxCfg->drxOnDurTmr);
9764                RETVALUE(RFAILED);
9765             }
9766
9767          }
9768     }
9769    else
9770 #endif
9771    {
9772       if ( rgSCHCfgVldtDrxOnDurCfg(ueDrxCfg->drxOnDurTmr) != ROK )
9773       {
9774          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid onDurTimer configuration(%d) for EMTC",
9775                ueDrxCfg->drxOnDurTmr);
9776          RETVALUE(RFAILED);
9777       }
9778    }
9779
9780    if ( rgSCHCfgVldtDrxInActvCfg(ueDrxCfg->drxInactvTmr) != ROK )
9781    {
9782       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Inactivity configuration(%d)",
9783                ueDrxCfg->drxInactvTmr);
9784       RETVALUE(RFAILED);
9785    }
9786 #ifdef EMTC_ENABLE
9787    if(ueDrxCfg->isEmtcUe)
9788    {
9789       if(ueDrxCfg->drxRetxTmrR13Pres)
9790       {
9791          if ( rgSCHEmtcCfgVldtDrxReTxCfg(ueDrxCfg->drxRetxTmr) != ROK )
9792          {
9793             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d) for EMTC",
9794                ueDrxCfg->drxRetxTmr);
9795             RETVALUE(RFAILED);
9796          }
9797       }
9798          else
9799          {
9800             if (rgSCHCfgVldtDrxReTxCfg(ueDrxCfg->drxRetxTmr) != ROK )
9801             {
9802                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d)",
9803                ueDrxCfg->drxRetxTmr);
9804                RETVALUE(RFAILED);
9805             }
9806
9807          }
9808     }
9809    else
9810 #endif
9811    {
9812       if ( rgSCHCfgVldtDrxReTxCfg(ueDrxCfg->drxRetxTmr) != ROK )
9813       {
9814          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d)",
9815                ueDrxCfg->drxRetxTmr);
9816          RETVALUE(RFAILED);
9817       }
9818    }
9819 #ifdef EMTC_ENABLE
9820    if(ueDrxCfg->isEmtcUe)
9821    {
9822       if ( rgSCHEmtcCfgVldtDrxUlReTxCfg(ueDrxCfg->emtcDrxUlRetxTmr) != ROK )
9823       {
9824          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid DrxReTX configuration(%d) for EMTC",
9825                ueDrxCfg->drxRetxTmr);
9826          RETVALUE(RFAILED);
9827       }
9828
9829    }
9830 #endif
9831
9832    if ( rgSCHCfgVldtDrxLngCycCfg(ueDrxCfg->drxLongCycleOffst) != ROK )
9833    {
9834       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid LongCycle configuration");
9835       RETVALUE(RFAILED);
9836    }
9837
9838    if ( ueDrxCfg->drxLongCycleOffst.longDrxCycle < ueDrxCfg->drxOnDurTmr )
9839    {
9840       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
9841               " and onDuration timer values");
9842       RETVALUE(RFAILED);
9843    }
9844
9845 #ifdef LTE_TDD
9846    if( rgSCHCfgVldtTddDrxCycCfg(cell, ueDrxCfg->drxLongCycleOffst.longDrxCycle,
9847        ueDrxCfg->drxOnDurTmr, ueDrxCfg->drxLongCycleOffst.drxStartOffst) != ROK)
9848    {
9849       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
9850               " and onDuration timer values");
9851       RETVALUE(RFAILED);
9852    }
9853 #endif
9854
9855    if( TRUE == ueDrxCfg->drxShortDrx.pres )
9856    {
9857       if ( ueDrxCfg->drxShortDrx.shortDrxCycle < ueDrxCfg->drxOnDurTmr )
9858       {
9859          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of short DRX "
9860                  "Cycle and onDuration timer values");
9861          RETVALUE(RFAILED);
9862       }
9863
9864       if ( (ueDrxCfg->drxLongCycleOffst.longDrxCycle %
9865                ueDrxCfg->drxShortDrx.shortDrxCycle) != 0)
9866       {
9867          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId," Long DRX cycle is not multiple of "
9868                  "short DRX cycle");
9869          RETVALUE(RFAILED);
9870       }
9871
9872       if ( rgSCHCfgVldtDrxShrtCycCfg(ueDrxCfg->drxShortDrx) != ROK )
9873       {
9874          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid Short Cycle configuration");
9875          RETVALUE(RFAILED);
9876       }
9877
9878 #ifdef LTE_TDD
9879       if( rgSCHCfgVldtTddDrxCycCfg(cell, ueDrxCfg->drxShortDrx.shortDrxCycle,
9880              ueDrxCfg->drxOnDurTmr,
9881              ueDrxCfg->drxLongCycleOffst.drxStartOffst %
9882              ueDrxCfg->drxShortDrx.shortDrxCycle) != ROK)
9883       {
9884          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Invalid combination of Long DRX Cycle "
9885                  " and onDuration timer values");
9886          RETVALUE(RFAILED);
9887       }
9888 #endif
9889    }
9890
9891    RETVALUE(ROK);
9892 }/*rgSCHCfgVldtDrxUeCfg*/
9893
9894 /***********************************************************
9895  *
9896  *     Func : rgSCHCfgVldtDrxOnDurCfg
9897  *
9898  *
9899  *     Desc : Validates UE DRX On Duration configuration
9900  *            recieved from RRC.
9901  *
9902  *     Ret  : S16
9903  *            ROK - Success
9904  *            RFAILED - Failed
9905  *
9906  *     Notes:
9907  *
9908  *     File :
9909  *
9910  **********************************************************/
9911 #ifdef ANSI
9912 PRIVATE S16 rgSCHCfgVldtDrxOnDurCfg
9913 (
9914 U8      onDurTmr
9915 )
9916 #else
9917 PRIVATE S16 rgSCHCfgVldtDrxOnDurCfg(onDurTmr)
9918 U8      onDurTmr;
9919 #endif
9920 {
9921    TRC2(rgSCHCfgVldtDrxOnDurCfg)
9922
9923    switch ( onDurTmr )
9924    {
9925       case RGR_DRX_PRD_1PSF:
9926       case RGR_DRX_PRD_2PSF:
9927       case RGR_DRX_PRD_3PSF:
9928       case RGR_DRX_PRD_4PSF:
9929       case RGR_DRX_PRD_5PSF:
9930       case RGR_DRX_PRD_6PSF:
9931       case RGR_DRX_PRD_8PSF:
9932       case RGR_DRX_PRD_10PSF:
9933       case RGR_DRX_PRD_20PSF:
9934       case RGR_DRX_PRD_30PSF:
9935       case RGR_DRX_PRD_40PSF:
9936       case RGR_DRX_PRD_50PSF:
9937       case RGR_DRX_PRD_60PSF:
9938       case RGR_DRX_PRD_80PSF:
9939       case RGR_DRX_PRD_100PSF:
9940       case RGR_DRX_PRD_200PSF:
9941          break;
9942
9943       default:
9944          {
9945             RETVALUE(RFAILED);
9946          }
9947    }/*switch(onDurTmr)*/
9948
9949    RETVALUE(ROK);
9950 }/*rgSCHCfgVldtOnDurCfg*/
9951
9952 /***********************************************************
9953  *
9954  *     Func : rgSCHCfgVldtDrxInActvCfg
9955  *
9956  *
9957  *     Desc : Validates UE DRX InActivity configuration
9958  *            recieved from RRC.
9959  *
9960  *     Ret  : S16
9961  *            ROK - Success
9962  *            RFAILED - Failed
9963  *
9964  *     Notes:
9965  *
9966  *     File :
9967  *
9968  **********************************************************/
9969 #ifdef ANSI
9970 PRIVATE S16 rgSCHCfgVldtDrxInActvCfg
9971 (
9972 U16      inActvTmr
9973 )
9974 #else
9975 PRIVATE S16 rgSCHCfgVldtDrxInActvCfg(inActvTmr)
9976 U16      inActvTmr;
9977 #endif
9978 {
9979    TRC2(rgSCHCfgVldtDrxInActvCfg)
9980
9981    switch ( inActvTmr )
9982    {
9983       case RGR_DRX_PRD_1PSF:
9984       case RGR_DRX_PRD_2PSF:
9985       case RGR_DRX_PRD_3PSF:
9986       case RGR_DRX_PRD_4PSF:
9987       case RGR_DRX_PRD_5PSF:
9988       case RGR_DRX_PRD_6PSF:
9989       case RGR_DRX_PRD_8PSF:
9990       case RGR_DRX_PRD_10PSF:
9991       case RGR_DRX_PRD_20PSF:
9992       case RGR_DRX_PRD_30PSF:
9993       case RGR_DRX_PRD_40PSF:
9994       case RGR_DRX_PRD_50PSF:
9995       case RGR_DRX_PRD_60PSF:
9996       case RGR_DRX_PRD_80PSF:
9997       case RGR_DRX_PRD_100PSF:
9998       case RGR_DRX_PRD_200PSF:
9999       case RGR_DRX_PRD_300PSF:
10000       case RGR_DRX_PRD_500PSF:
10001       case RGR_DRX_PRD_750PSF:
10002       case RGR_DRX_PRD_1280PSF:
10003       case RGR_DRX_PRD_1920PSF:
10004       case RGR_DRX_PRD_2560PSF:
10005          break;
10006
10007       default:
10008          {
10009             RETVALUE(RFAILED);
10010          }
10011    }/*switch(InactvTmr)*/
10012
10013    RETVALUE(ROK);
10014 }/*rgSCHCfgVldtDrxInActvCfg*/
10015
10016 /***********************************************************
10017  *
10018  *     Func : rgSCHCfgVldtDrxReTxCfg
10019  *
10020  *
10021  *     Desc : Validates DRX ReTx timer  configuration
10022  *            recieved from RRC.
10023  *
10024  *     Ret  : S16
10025  *            ROK - Success
10026  *            RFAILED - Failed
10027  *
10028  *     Notes:
10029  *
10030  *     File :
10031  *
10032  **********************************************************/
10033 #ifdef ANSI
10034 PRIVATE S16 rgSCHCfgVldtDrxReTxCfg
10035 (
10036 U8       reTxTmr
10037 )
10038 #else
10039 PRIVATE S16 rgSCHCfgVldtDrxReTxCfg(reTxTmr)
10040 U8       reTxTmr;
10041 #endif
10042 {
10043    TRC2(rgSCHCfgVldtDrxReTxCfg)
10044
10045    switch ( reTxTmr )
10046    {
10047       case RGR_DRX_PRD_1PSF:
10048       case RGR_DRX_PRD_2PSF:
10049       case RGR_DRX_PRD_4PSF:
10050       case RGR_DRX_PRD_6PSF:
10051       case RGR_DRX_PRD_8PSF:
10052       case RGR_DRX_PRD_16PSF:
10053       case RGR_DRX_PRD_24PSF:
10054       case RGR_DRX_PRD_33PSF:
10055          break;
10056
10057       default:
10058          {
10059             RETVALUE(RFAILED);
10060          }
10061    }/*switch(drxRetxTmr)*/
10062
10063    RETVALUE(ROK);
10064 }/*rgSCHCfgVldtDrxReTxCfg*/
10065
10066 /***********************************************************
10067  *
10068  *     Func : rgSCHCfgVldtDrxShrtCycCfg
10069  *
10070  *
10071  *     Desc : Validates DRX Short Cycle timer  configuration
10072  *            recieved from RRC.
10073  *
10074  *     Ret  : S16
10075  *            ROK - Success
10076  *
10077  *            RFAILED - Failed
10078  *
10079  *     Notes:
10080  *
10081  *     File :
10082  *
10083  **********************************************************/
10084 #ifdef ANSI
10085 PRIVATE S16 rgSCHCfgVldtDrxLngCycCfg
10086 (
10087 RgrDrxLongCycleOffst       lngCycleOffst
10088 )
10089 #else
10090 PRIVATE S16 rgSCHCfgVldtDrxLngCycCfg(lngCycleOffst)
10091 RgrDrxLongCycleOffst       lngCycleOffst;
10092 #endif
10093 {
10094    TRC2(rgSCHCfgVldtDrxLngCycCfg)
10095
10096    if ( rgSCHCfgVldtDrxLngCyclTmrs(lngCycleOffst.longDrxCycle) != ROK )
10097    {
10098       RETVALUE(RFAILED);
10099    }
10100
10101    if ( lngCycleOffst.drxStartOffst >= lngCycleOffst.longDrxCycle )
10102    {
10103       RETVALUE(RFAILED);
10104    }
10105
10106    RETVALUE(ROK);
10107 }/*rgSCHCfgVldtDrxLngCycCfg*/
10108
10109 /***********************************************************
10110  *
10111  *     Func : rgSCHCfgVldtDrxLngCyclTmrs
10112  *
10113  *
10114  *     Desc : Validates DRX Long Cycle timer values
10115  *            recieved from RRC.
10116  *
10117  *     Ret  : S16
10118  *            ROK - Success
10119  *
10120  *            RFAILED - Failed
10121  *
10122  *     Notes:
10123  *
10124  *     File :
10125  *
10126  **********************************************************/
10127 #ifdef ANSI
10128 PRIVATE S16 rgSCHCfgVldtDrxLngCyclTmrs
10129 (
10130 U16      val
10131 )
10132 #else
10133 PRIVATE S16 rgSCHCfgVldtDrxLngCyclTmrs(val)
10134 U16      val;
10135 #endif
10136 {
10137    TRC2(rgSCHCfgVldtDrxLngCyclTmrs)
10138
10139    switch ( val )
10140    {
10141       case RGR_DRX_PRD_10SF:
10142       case RGR_DRX_PRD_20SF:
10143       case RGR_DRX_PRD_32SF:
10144       case RGR_DRX_PRD_40SF:
10145       case RGR_DRX_PRD_64SF:
10146       case RGR_DRX_PRD_80SF:
10147       case RGR_DRX_PRD_128SF:
10148       case RGR_DRX_PRD_160SF:
10149       case RGR_DRX_PRD_256SF:
10150       case RGR_DRX_PRD_320SF:
10151       case RGR_DRX_PRD_512SF:
10152       case RGR_DRX_PRD_640SF:
10153       case RGR_DRX_PRD_1024SF:
10154       case RGR_DRX_PRD_1280SF:
10155       case RGR_DRX_PRD_2048SF:
10156       case RGR_DRX_PRD_2560SF:
10157          break;
10158
10159       default:
10160          {
10161             RETVALUE(RFAILED);
10162          }
10163    }/*switch(longDrxCycle)*/
10164
10165    RETVALUE(ROK);
10166 }/*rgSCHCfgVldtDrxLngCyclTmrs*/
10167
10168 /***********************************************************
10169  *
10170  *     Func : rgSCHCfgVldtDrxShrtCycCfg
10171  *
10172  *
10173  *     Desc : Validates DRX Short Cycle timer  configuration
10174  *            recieved from RRC.
10175  *
10176  *     Ret  : S16
10177  *            ROK - Success
10178  *
10179  *            RFAILED - Failed
10180  *
10181  *     Notes:
10182  *
10183  *     File :
10184  *
10185  **********************************************************/
10186 #ifdef ANSI
10187 PRIVATE S16 rgSCHCfgVldtDrxShrtCycCfg
10188 (
10189 RgrDrxShortDrx      shrtCycCfg
10190 )
10191 #else
10192 PRIVATE S16 rgSCHCfgVldtDrxShrtCycCfg(shrtCycCfg)
10193 RgrDrxShortDrx      shrtCycCfg;
10194 #endif
10195 {
10196    TRC2(rgSCHCfgVldtDrxShrtCycCfg)
10197
10198    switch(shrtCycCfg.shortDrxCycle)
10199    {
10200       case RGR_DRX_PRD_2SF:
10201       case RGR_DRX_PRD_5SF:
10202       case RGR_DRX_PRD_8SF:
10203       case RGR_DRX_PRD_10SF:
10204       case RGR_DRX_PRD_16SF:
10205       case RGR_DRX_PRD_20SF:
10206       case RGR_DRX_PRD_32SF:
10207       case RGR_DRX_PRD_40SF:
10208       case RGR_DRX_PRD_64SF:
10209       case RGR_DRX_PRD_80SF:
10210       case RGR_DRX_PRD_128SF:
10211       case RGR_DRX_PRD_160SF:
10212       case RGR_DRX_PRD_256SF:
10213       case RGR_DRX_PRD_320SF:
10214       case RGR_DRX_PRD_640SF:
10215          break;
10216
10217       default:
10218          {
10219             RETVALUE(RFAILED);
10220          }
10221
10222    }/*switch(shortDrxCycle)*/
10223
10224    if ( (shrtCycCfg.drxShortCycleTmr < RGR_DRX_SHRTCYCLE_MIN) ||
10225          (shrtCycCfg.drxShortCycleTmr > RGR_DRX_SHRTCYCLE_MAX)
10226       )
10227    {
10228       RETVALUE(RFAILED);
10229    }
10230
10231    RETVALUE(ROK);
10232 }
10233
10234 /**
10235  * @brief Handler for TA related UE Reconfiguration.
10236  *
10237  * @details
10238  *
10239  *     Function : rgSCHCfgUeTaRecfg
10240  *
10241  *     This function shall fetch the TA timer related information into the
10242  *     respective ueCb from the UE configuration as provided by the
10243  *     upper layers.
10244  *
10245  *  @param[in]  RgSchCellCb   *cell
10246  *  @param[in]  RgSchUeCb     *ueCb
10247  *  @param[in]  RgrUeCfg      *ueCfg
10248  *  @param[out] RgSchErrInfo  *errInfo
10249  *  @return     S16
10250  *      -# ROK
10251  *      -# RFAILED
10252  **/
10253 #ifdef ANSI
10254 PRIVATE Void rgSCHCfgUeTaRecfg
10255 (
10256 RgSchCellCb       *cell,
10257 RgSchUeCb         *ueCb,
10258 RgrUeRecfg        *ueCfg,
10259 RgSchErrInfo      *err
10260 )
10261 #else
10262 PRIVATE Void rgSCHCfgUeTaRecfg(cell, ueCb, ueCfg, err)
10263 RgSchCellCb       *cell;
10264 RgSchUeCb         *ueCb;
10265 RgrUeRecfg        *ueCfg;
10266 RgSchErrInfo      *err;
10267 #endif
10268 {
10269    TRC2(rgSCHCfgUeTaRecfg)
10270
10271    UNUSED(err);
10272
10273    /* Update the TA related information */
10274
10275    if (ueCfg->ueTaTmrRecfg.pres)
10276    {
10277       /* Configuring taTmr with 30 deficit, to enable eNodeB sending
10278        * TA command before the expiry of TA at UE. Also considering for
10279        * possible retx for this TA command */
10280       /* [ccpu00121813]-ADD-Added chk if tatmr val > 30 */
10281       if(ueCfg->ueTaTmrRecfg.taTmr > 30)
10282       {
10283          ueCb->dl.taCb.cfgTaTmr = ueCfg->ueTaTmrRecfg.taTmr - 30;
10284       }
10285        /* If TA Timer is running. Stop it and then start it*/
10286       if (ueCb->taTmr.tmrEvnt != TMR_NONE)
10287       {
10288          rgSCHTmrStopTmr(cell, ueCb->taTmr.tmrEvnt, ueCb);
10289          rgSCHTmrStartTmr(cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
10290       }
10291       else
10292       {
10293          rgSCHTmrStartTmr(cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
10294       }
10295    }
10296    RETVOID;
10297 }  /* rgSCHCfgUeTaRecfg */
10298
10299 /* ccpu00117452 - MOD - Changed macro name from
10300    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
10301 #if ((defined (RGR_CQI_REPT)) && (defined (RGR_V2)))
10302 /***********************************************************
10303  *
10304  *     Func : rgSCHCfgUeCqiReptReCfg
10305  *
10306  *
10307  *     Desc : Reconfiguration of PUSH N CQI Reporting
10308  *
10309  *     Ret  : RFAILED in case of failure
10310  *            ROK if success
10311  *
10312  *     Notes:
10313  *
10314  *     File :
10315  *
10316  **********************************************************/
10317 #ifdef ANSI
10318 PRIVATE S16 rgSCHCfgUeCqiReptReCfg
10319 (
10320 RgSchCellCb    *cell,
10321 RgSchUeCb      *ue,
10322 RgrUeRecfg     *ueRecfg
10323 )
10324 #else
10325 PRIVATE  S16 rgSCHCfgUeCqiReptReCfg(cell, ue, ueRecfg)
10326 RgSchCellCb    *cell;
10327 RgSchUeCb      *ue;
10328 RgrUeRecfg     *ueRecfg;
10329 #endif
10330 {
10331    S16 retVal;
10332    TRC3(rgSCHCfgUeCqiReptReCfg)
10333
10334    /* Check has it been disabled */
10335    if(ueRecfg->ueCqiReptCfg.numColltdCqiRept)
10336    {
10337     /* Check if we need to send CQI reports collagted so far and send if so */
10338       if(ue->schCqiInfo.cqiCount >=
10339               ueRecfg->ueCqiReptCfg.numColltdCqiRept)
10340       {
10341          RgrStaIndInfo *staInfo;
10342       /* if yes, Send StaInd to RRM */
10343          retVal = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&staInfo,
10344                   sizeof(RgrStaIndInfo));
10345          if(retVal != ROK)
10346          {
10347             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
10348                "Could not allocate memory for sending StaInd OLD CRNTI:%d",ueRecfg->oldCrnti);
10349             RETVALUE(retVal);
10350          }
10351
10352       /* Fill StaInd for sending collated N CQI rpeort                        */
10353          rgSCHUtlFillSndStaInd(cell, ue, staInfo,
10354                ueRecfg->ueCqiReptCfg.numColltdCqiRept);
10355       }
10356    }
10357    else
10358    {
10359       ue->schCqiInfo.cqiCount = 0;
10360    }
10361
10362    ue->cqiReptCfgInfo.numColltdCqiRept =
10363       ueRecfg->ueCqiReptCfg.numColltdCqiRept;
10364    RETVALUE(ROK);
10365 } /* End of rgSCHCfgUeCqiReptReCfg */
10366 #endif /* End of RGR_CQI_REPT */
10367 /*This function Added Ue in ongoing L2 Meas*/
10368 /*LTE_L2_MEAS_PHASE2*/
10369 #ifdef LTE_L2_MEAS
10370 PRIVATE S16 rgSchAddToL2Meas(RgSchCellCb *cellCb,RgSchDlLcCb *dlLc)
10371 {
10372    CmLList             *lnk;
10373    U16       idx;
10374    RgSchL2MeasCb       *measCb = NULLP;
10375    lnk = cellCb->l2mList.first;
10376
10377    while(lnk != NULLP)
10378    {
10379       /* Get the MeasCb : RgSchL2MeasCb */
10380       measCb = (RgSchL2MeasCb *)lnk->node;
10381       if (measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
10382       {
10383          for(idx = 0;idx < measCb->measReq.avgPrbQciDl.numQci;idx++)
10384          {
10385             if(measCb->measReq.avgPrbQciDl.qci[idx] == dlLc->qciCb->qci)
10386             {
10387                break; /*exit from for loop*/
10388             }
10389          }
10390          if(idx  == measCb->measReq.avgPrbQciDl.numQci)
10391          {
10392             measCb->measReq.avgPrbQciDl.qci[measCb->measReq.avgPrbQciDl.numQci++] = dlLc->qciCb->qci;
10393          }
10394       }
10395       lnk = lnk->next;
10396    }/*End of while loop*/
10397
10398    RETVALUE(ROK);
10399 }
10400 #endif
10401 #ifdef LTE_ADV
10402 /**
10403  * @brief UE SCell Buffer Free
10404  *
10405  * @details
10406  *
10407  *     Function : rgSCHSCellFreeBuf
10408  *
10409  *     This functions will free allocated memory
10410  *     for UE secondart cellCB
10411  *
10412  *
10413  *  @param[in]  Inst         inst
10414  *  @param[in]  RgSchUeCb    *ue
10415  *  @param[int] RgrUeRecfg   *ueRecfg
10416  *  @param[out] U8           idx
10417  *  @return  VOID
10418  **/
10419 #ifdef ANSI
10420 PUBLIC Void rgSCHSCellFreeBuf
10421 (
10422 Inst         inst,
10423 RgSchUeCb    *ue,
10424 RgrUeRecfg   *ueRecfg,
10425 U8           idx
10426 )
10427 #else
10428 PUBLIC Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
10429 Inst         inst;
10430 RgSchUeCb    *ue;
10431 RgrUeRecfg   *ueRecfg;
10432 U8           idx;
10433 #endif
10434 {
10435    RgSchUeCellInfo *sCellInfo = NULLP;
10436    RgrUeSecCellCfg *sCellInfoRecfg = NULLP;
10437
10438    TRC2(rgSCHSCellFreeBuf);
10439
10440    for(U8 i = 0; i <= idx; i++)
10441    {
10442       sCellInfoRecfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[i];
10443       sCellInfo = ue->cellInfo[(sCellInfoRecfg->sCellIdx)];
10444
10445       if (NULLP != sCellInfo)
10446       {
10447          rgSCHUtlFreeSBuf(inst, (Data**)&(sCellInfo),
10448                sizeof(RgSchUeCellInfo));
10449          ue->cellInfo[(sCellInfoRecfg->sCellIdx)] = NULLP;
10450
10451       }
10452    }
10453    RETVOID;
10454 }
10455 #endif
10456 /**********************************************************************
10457
10458          End of file
10459 **********************************************************************/