rg_sch_cmn.h

   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      Name:    LTE MAC SC1 scheduler
  21
  22      Type:    C header file
  23
  24      Desc:    Defines required by SC1 scheduler
  25
  26      File:    rg_sch_cmn.h
  27
  28 *********************************************************************21*/
  29
  30 \f
  31 #ifndef __RGSCHCMNH__
  32 #define __RGSCHCMNH__
  33 #ifdef __cplusplus
  34 extern "C" {
  35 #endif
  36
  37
  38 /***********************************************************************
  39                          Macro Definitions
  40  ***********************************************************************/
  41
  42 /* Scheduler1 tunable params */
  43 #define RG_SCH_CMN_GET_DL_SCHED_TYPE(cell) rgSchCb[cell->instIdx].rgrSchedEnbCfg.dlSchdType
  44 #define RG_SCH_CMN_GET_UL_SCHED_TYPE(cell) rgSchCb[cell->instIdx].rgrSchedEnbCfg.ulSchdType
  45 #define RG_SCH_CMN_GET_SCHED_CFG(cell) rgSchCb[cell->instIdx].rgrSchedEnbCfg
  46 #define RG_SCH_CMN_GET_ANT_PORTS(cell) rgSchCb[cell->instIdx].rgrSchedEnbCfg.numTxAntPorts
  47 #define RG_SCH_CMN_GET_CELL(cell) ((RgSchCmnCell *)((cell)->sc.sch))
  48 #define RG_SCH_CMN_GET_UL_CELL(cell) &(((RgSchCmnCell *)((cell)->sc.sch))->ul)
  49 #define RG_SCH_CMN_GET_DL_CELL(cell) &(((RgSchCmnCell *)((cell)->sc.sch))->dl)
  50 #define RG_SCH_CMN_GET_CMN_UE(ue) &(((RgSchCmnUe *)(((ue)->cellInfo[0])->sch))->cmn)
  51 #define RG_SCH_CMN_GET_UE(_ue,_cell) ((RgSchCmnUe *)((_ue->cellInfo[(_ue->cellIdToCellIdxMap\
  52                [RG_SCH_CELLINDEX(_cell)])])->sch))
  53 #define RG_SCH_CMN_GET_UL_UE(_ue,_cell) (&(((RgSchCmnUe *)((_ue->cellInfo[_ue->cellIdToCellIdxMap\
  54                [RG_SCH_CELLINDEX(_cell)]])->sch))->ul))
  55 #define RG_SCH_CMN_GET_DL_UE(_ue,_cell) (&(((RgSchCmnUe *)((_ue->cellInfo[_ue->cellIdToCellIdxMap\
  56                [RG_SCH_CELLINDEX(_cell)]])->sch))->dl))
  57 #define RG_SCH_CMN_GET_UE_HQE(_ue,_cell) (_ue->cellInfo[_ue->cellIdToCellIdxMap\
  58                [RG_SCH_CELLINDEX(_cell)]]->hqEnt)
  59
  60 #define RG_SCH_CMN_GET_DL_HQP(hqP) ((RgSchCmnDlHqProc *)((hqP)->sch))
  61 #define RG_SCH_CMN_GET_DL_SVC(svc) ((RgSchCmnDlSvc *)((svc)->sch))
  62 #define RG_SCH_CMN_GET_UL_LCG(lcg) ((RgSchCmnLcg *)((lcg)->sch))
  63
  64 /*f1b_Sprint3*/
  65 #define RG_SCH_IS_CELL_SEC(ue,cell) (((ue)->cellInfo[0]->sCellId != cell->cellId)? TRUE: FALSE)
  66 /*#define RG_SCH_IS_CELL_SEC(_ue,_cell) (((_ue)->cell != _cell)? TRUE: FALSE)*/
  67 /*f1b_Sprint3*/
  68
  69 #define RG_SCH_CMN_GET_LC_SCH_SPFC(_ue,_svc,_cell) (((RgSchCmnDlSvc *)(_svc->sch))->schSpfc[\
  70       _ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(_cell)]])
  71 #define RG_SCH_CMN_GET_PA(_ue,_cell) (_ue->cellInfo[_ue->cellIdToCellIdxMap\
  72                [RG_SCH_CELLINDEX(_cell)]]->pA)
  73 /* Changing the check for retransmission - now checking if alloc
  74  * is non NULL instead of using the isRetx field of the harq Proc.
  75  */
  76 #define RG_SCH_CMN_IS_UL_UE_RETX(_ue, _cell) ((&RG_SCH_CMN_GET_UL_UE(_ue, _cell)->hqEnt.hqProcCb[\
  77   ((RgSchCmnCell *)(ue->cell->sc.sch))->ul.schdHqProcIdx])->alloc)
  78
  79    /* Get acqiCb from appropiate ScellInfo */
  80 #define RG_SCH_CMN_GET_ACQICB(_ue,_cell) &(((_ue->cellInfo[_ue->cellIdToCellIdxMap\
  81    [RG_SCH_CELLINDEX(_cell)]])->acqiCb))
  82
  83 #define RG_SCH_CMN_GET_SCELL_INFO(_ue,_cell) (_ue->cellInfo[_ue->cellIdToCellIdxMap\
  84    [RG_SCH_CELLINDEX(_cell)]])
  85
  86 #define RG_SCH_CMN_GET_PCELL_INFO(_ue) (_ue->cellInfo[0])
  87
  88    /* Added support for SPS*/
  89 #ifdef LTEMAC_SPS
  90 #define RGSCH_SPS_MAX_SPS_ACTVN_BO                 400
  91 #define RGSCH_SPS_MAX_DL_HQP_TX                    4
  92 #define RGSCH_SPS_MAX_UL_ACT_CRC_FAIL              3
  93 #define RGSCH_SPS_MAX_UL_SPS_OCC_CRC_FAIL          3
  94 #define RGSCH_SPS_MAX_UL_REL_PDCCH                 2
  95 #define RG_SCH_CMN_GET_UL_SPS_CELL(cell) &(((RgSchCmnCell *)((cell)->sc.sch))->ul.ulSpsInfo)
  96 #define RG_SCH_CMN_GET_UL_SPS_UE(_ue,_cell) &(_ue->ul.ulSpsInfo)
  97 #define RG_SCH_CMN_SID_PACKET_SIZE 10
  98 #define RG_SCH_CMN_SPS_BSR_HEADROOM 6 /* PHR 2 bytes + Long BSR 4 bytes*/
  99
 100
 101 #define RGSCH_CMN_MIN_SCALABLE_CQI  RGSCH_SPS_CQI_SCALE_FACTOR+1
 102 /* Introduced timing delta for DL control in FDD */
 103 #ifdef LTE_TDD
 104 #define RGSCH_SPS_UL_LCM   40 /* Default lcm to start the spsSfTbl with */
 105 #else
 106 #define RGSCH_SPS_UL_DELTA (TFU_DLCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA)
 107 #define RGSCH_SPS_UL_LCM   20 /* Default lcm to start the spsSfTbl with */
 108 #endif
 109
 110
 111
 112 #define RG_SCH_CMN_IS_SPS_SCHD(_ue, _cell) (((((&RG_SCH_CMN_GET_UL_UE(_ue, _ue->cell)->hqEnt.hqProcCb[\
 113  ((RgSchCmnCell *)(_ue->cell->sc.sch))->ul.schdHqProcIdx])->alloc) &&\
 114 ((&RG_SCH_CMN_GET_UL_UE(_ue, _ue->cell)->hqEnt.hqProcCb[\
 115  ((RgSchCmnCell *)(_ue->cell->sc.sch))->ul.schdHqProcIdx])->alloc->rnti == _ue->spsRnti) ? TRUE:FALSE)) || \
 116   (_ue->ul.relPdcchSchdTime.sfn == _cell->crntTime.sfn && _ue->ul.relPdcchSchdTime.slot == _cell->crntTime.slot))
 117 #endif /* LTEMAC_SPS */
 118
 119 /* RRM_SP1_START */
 120 #define RG_SCH_CALC_GBR_UTILIZATION(_cell, _lcCb, _prbUsed) {\
 121    if(_lcCb->qciCb->qci <= RGM_MAX_QCI_REPORTS)\
 122    {\
 123       _cell->prbUsage.qciPrbRpts[_lcCb->qciCb->qci-1].dlTotPrbUsed += _prbUsed;\
 124       _cell->prbUsage.qciPrbRpts[_lcCb->qciCb->qci-1].qci = _lcCb->qciCb->qci;\
 125    }\
 126 }
 127 /* RRM_SP1_END */
 128
 129
 130    /* This is added due to the limitation in BRDCM Platform
 131     * BRDCM support only one Aperiodic Cqi reception in one UL Sf at lower MCS
 132     * Note: Should be removed once BRDCM provides support for this */
 133 #define RG_SCH_MAX_ACQI_PER_ULSF 1
 134
 135 #define RG_SCH_CMN_IS_UE_SCHDLD(_ue, _cell) (((RgSchCmnUe *)((_ue->cellInfo[_ue->cellIdToCellIdxMap\
 136                               [RG_SCH_CELLINDEX(_cell)]])->sch))->dl.proc != NULLP)
 137 #define RG_SCH_CMN_PROC_SLCTD_FOR_RETX(proc) ((proc->tbInfo[0].txCntr!=0) ||\
 138                                                (proc->tbInfo[1].txCntr!=0))
 139 #define RG_SCH_CMN_DL_IS_UE_ACTIVE(ue) (ue->dl.dlInactvMask == 0)
 140 #define RG_SCH_CMN_UL_IS_UE_ACTIVE(ue) (ue->ul.ulInactvMask == 0)
 141 /* ulInactvMask and dlInactvMask are simulataneously set/reset
 142  * hence check against one suffices */
 143 #define RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue) (ue->ul.ulInactvMask & RG_PDCCHODR_INACTIVE)
 144
 145 /* Adding routines to check Ue's Active state before triggering UE's Active transition */
 146 #define RG_SCH_CMN_DL_UPDT_INACTV_MASK( cellCb, ue, maskElmnt) \
 147    if(RG_SCH_CMN_DL_IS_UE_ACTIVE(ue))                          \
 148    {                                                           \
 149       ue->dl.dlInactvMask &= ~maskElmnt;                       \
 150    }                                                           \
 151    else                                                        \
 152    {                                                           \
 153       ue->dl.dlInactvMask &= ~maskElmnt;                       \
 154       if(RG_SCH_CMN_DL_IS_UE_ACTIVE(ue))                       \
 155       {                                                        \
 156          rgSCHUtlDlActvtUe(cellCb, ue);                        \
 157       }                                                        \
 158    }
 159
 160 #define RG_SCH_CMN_UL_UPDT_INACTV_MASK( cellCb, ue, maskElmnt) \
 161    if(RG_SCH_CMN_UL_IS_UE_ACTIVE(ue))                          \
 162    {                                                           \
 163       ue->ul.ulInactvMask &= ~maskElmnt;                       \
 164    }                                                           \
 165    else                                                        \
 166    {                                                           \
 167       ue->ul.ulInactvMask &= ~maskElmnt;                       \
 168       if(RG_SCH_CMN_UL_IS_UE_ACTIVE(ue))                       \
 169       {                                                        \
 170          rgSCHUtlUlActvtUe(cellCb, ue);                        \
 171       }                                                        \
 172    }
 173
 174 #define RG_SCH_CMN_CSG_REFRESH_TIME 16
 175 #define RG_SCH_CMN_OVRLDCTRL_REFRESH_TIME 50
 176
 177 /* totPrbCnt is set to 1 to avoid division by zero */
 178 #define RG_SCH_RESET_HCSG_DL_PRB_CNTR(_cmnDlCell) \
 179 {                                             \
 180    (_cmnDlCell)->ncsgPrbCnt = 0;                 \
 181    (_cmnDlCell)->totPrbCnt = 1;                  \
 182 }
 183
 184 #define RG_SCH_RESET_HCSG_UL_PRB_CNTR(_cmnUlCell) \
 185 {                                             \
 186    (_cmnUlCell)->ncsgPrbCnt = 0;                 \
 187    (_cmnUlCell)->totPrbCnt = 1;                  \
 188 }
 189
 190 #define RG_SCH_CMN_DL_SVC_IS_GBR(svc) ((((RgSchCmnDlSvc*)(svc->sch))->qci >= RG_SCH_CMN_GBR_QCI_START) && \
 191                                 (((RgSchCmnDlSvc*)(svc->sch))->qci <= RG_SCH_CMN_GBR_QCI_END))
 192
 193 /* Moved the below tables to rg_env_*.h files */
 194
 195
 196 #define RG_SCH_CMN_SET_FORCE_TD(_ue,_cell, _event)\
 197          {\
 198             RgSchCmnDlUe *_ueDl = RG_SCH_CMN_GET_DL_UE(_ue,_cell);\
 199             _ueDl->mimoInfo.forceTD |= (_event);\
 200          }
 201 #define RG_SCH_CMN_UNSET_FORCE_TD(_ue,_cell, _event)\
 202          {\
 203             RgSchCmnDlUe *_ueDl = RG_SCH_CMN_GET_DL_UE(_ue,_cell);\
 204             _ueDl->mimoInfo.forceTD &= ~(_event);\
 205          }
 206 #define RG_SCH_CMN_INIT_FORCE_TD(_ue,_cell, _val)\
 207          {\
 208             RgSchCmnDlUe *_ueDl = RG_SCH_CMN_GET_DL_UE(_ue,_cell);\
 209             _ueDl->mimoInfo.forceTD = (_val);\
 210          }
 211
 212 #define RG_SCH_CMN_DL_TBS_TO_MCS(x, y) do {\
 213    if (x <= 9) y = x; \
 214    else if (x <= 15) y = x + 1; \
 215    else y = x + 2;\
 216 } while(0)
 217
 218 #define RG_SCH_CMN_DL_MCS_TO_TBS(x, y) do {\
 219    if (x <= 9) y = x; \
 220    else if (x <= 16) y = x - 1; \
 221    else y = x - 2; \
 222 }while(0)
 223
 224 #define RG_SCH_CMN_UL_TBS_TO_MCS(x, y) do {\
 225    if (x <= 10) y = x; \
 226    else if (x <= 19) y = x + 1; \
 227    else y = x + 2;\
 228 } while(0)
 229
 230 #ifdef LTE_TDD
 231 #define RG_SCH_CMN_CHK_DL_DATA_ALLOWED(_cell, _idx)\
 232 (rgSchTddUlDlSubfrmTbl[_cell->ulDlCfgIdx][_idx] == RG_SCH_TDD_DL_SUBFRAME) ||\
 233 ((rgSchTddUlDlSubfrmTbl[_cell->ulDlCfgIdx][_idx] == RG_SCH_TDD_SPL_SUBFRAME) &&\
 234  (_cell->splSubfrmCfg.isDlDataAllowed == TRUE))
 235 #define RG_SCH_CMN_ADJ_DWPTS_ITBS(_cellDl, _iTbs) \
 236 {\
 237     if (_iTbs > 0)\
 238     {\
 239        _iTbs += rgSchCmnSplSfDeltaItbs[_cellDl->splSfCfg];\
 240        if ((S8)_iTbs < 0)\
 241        {\
 242           _iTbs = 0;\
 243        }\
 244     }\
 245     if (_iTbs > 26)\
 246     {\
 247        _iTbs = 26;\
 248     }\
 249 }
 250 #endif
 251
 252 /* RACHO start */
 253 /* minimum grant, in bytes, to be given to HO and pdcchOrdered UEs */
 254 #define RG_SCH_MIN_GRNT_HOPO 2
 255 /* maximum dedPrmbls */
 256 #define RG_SCH_MAX_DED_PRMBLS 60
 257 /* is PDCCH order generation supported */
 258 #define RG_SCH_CMN_IS_PO_SPRTD(cell) (cell->rachCfg.raOccasion.sfnEnum != RGR_SFN_NA)
 259 /* Min gap value between crntTime and time of PRACH Oppurtunity */
 260 /* RG_SCH_CMN_DL_DELTA is the number of SFs from crntTime at which
 261  * UE is expected to recieve PDCCH Order.
 262  * n+6 as per 213 6.1.1 last para */
 263 #define RG_SCH_CMN_MIN_PRACH_OPPR_GAP (6+RG_SCH_CMN_DL_DELTA)
 264 /* Idle time threshold in terms of subframes, implies
 265  * the max duration between a TA expiry and latest UL
 266  * data/Signal transmission time */
 267  /* Fix : syed Ignore if TaTmr is not configured */
 268 #define RG_SCH_CMN_UE_IDLE_THRSLD(ue) (RG_SCH_CMN_UE_IDLETIME_FCTR * ue->dl.taCb.cfgTaTmr)
 269 /* R8 Upgrade */
 270 #define RG_SCH_CMN_GET_BI_VAL(prevVal,numUe) ( prevVal + ( numUe * RG_SCH_CMN_BI_NUMUE_FACTOR ))
 271 #define RG_SCH_CMN_NUMUE_FACTOR    1
 272 #define RG_SCH_CMN_BITBL_INDEX(x) ((x/RG_SCH_CMN_NUMUE_FACTOR)>=12)? 12:(x/RG_SCH_CMN_NUMUE_FACTOR)
 273 #define RG_SCH_CMN_GET_BI(numUe)  rgSchCmnBiTbl[RG_SCH_CMN_BITBL_INDEX((numUe))]
 274 /* RACHO end */
 275
 276 #define RG_SCH_CMN_SVC_IS_GBR(svc) ((((RgSchCmnDlSvc*)(svc->sch))->qci >= RG_SCH_CMN_GBR_QCI_START) && \
 277                                 (((RgSchCmnDlSvc*)(svc->sch))->qci <= RG_SCH_CMN_GBR_QCI_END))
 278
 279 #define RG_SCH_CMN_SVC_IS_AMBR(svc) ((((RgSchCmnDlSvc*)(svc->sch))->qci > RG_SCH_CMN_GBR_QCI_END) && \
 280                                 (((RgSchCmnDlSvc*)(svc->sch))->qci <= RG_SCH_CMN_MAX_QCI))
 281
 282 #define RG_SCH_CMN_TBS_TO_MODODR(x, y) do {\
 283    if (x <= 5) y = 2; \
 284    else if (x <= 10) y = 4; \
 285    else y = 6;\
 286 } while(0)
 287
 288 /* To include the length and ModOrder in DataRecp Req. */
 289 #define RG_SCH_UL_MCS_TO_MODODR(x, y) do {\
 290    RGSCH_ARRAY_BOUND_CHECK(0, rgUlIMcsTbl, x); \
 291    y = (TfuModScheme)rgUlIMcsTbl[x].qm;\
 292 } while(0)
 293
 294 #define RG_SCH_CMN_ITBS_TO_RETX_IMCS(iTbs, iMcs) do {\
 295    if ((iTbs) <= 9) (iMcs) = 29; \
 296    else if ((iTbs) <= 15) (iMcs) = 30; \
 297    else (iMcs) = 31;\
 298 } while(0)
 299
 300 /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
 301  * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
 302  * MCS.  */
 303 #define RG_SCH_CMN_GET_MCS_FOR_RETX(tb, retxMcs) do {\
 304       if ((tb->isAckNackDtx == TFU_HQFDB_DTX)) { \
 305          retxMcs = tb->dlGrnt.iMcs; \
 306       } \
 307       else { \
 308          if (tb->dlGrnt.iMcs < 29) {\
 309             uint8_t _iTbs;\
 310             RG_SCH_CMN_DL_MCS_TO_TBS(tb->dlGrnt.iMcs, _iTbs);\
 311             RG_SCH_CMN_ITBS_TO_RETX_IMCS(_iTbs, retxMcs); \
 312          } \
 313          else {\
 314             retxMcs = tb->dlGrnt.iMcs; \
 315          }\
 316       }\
 317 }while(0)
 318
 319 #define RG_SCH_CMN_DL_TBS_TO_MCS_DTX(proc, iTbs, imcs) do {\
 320       if ((proc->isAckNackDtx == TFU_HQFDB_DTX)) { \
 321          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs); \
 322       } \
 323       else { \
 324          RG_SCH_CMN_ITBS_TO_RETX_IMCS(iTbs, imcs); \
 325       } \
 326 }while(0)
 327
 328 #define RG_SCH_CMN_UL_IS_CQI_VALID(cqi) ((cqi) > 0 && (cqi) < RG_SCH_CMN_UL_NUM_CQI)
 329
 330 #ifdef CCPU_OPT
 331 #define RG_SCH_CMN_DL_GET_HDR_EST(svc, hdrEst) do {\
 332    hdrEst  = svc->estRlcHdrSz;\
 333    hdrEst += RG_SCH_CMN_DED_MAX_HDRSIZE * RG_SCH_CMN_MAX_DED_SDU;\
 334    if (svc->staPduPrsnt) \
 335    {\
 336       hdrEst += RG_SCH_CMN_DED_MAX_HDRSIZE;\
 337    }\
 338 } while(0)
 339 #else
 340 #define RG_SCH_CMN_DL_GET_HDR_EST(svc, hdrEst) do {\
 341    hdrEst = RG_SCH_CMN_DED_MAX_HDRSIZE * RG_SCH_CMN_MAX_DED_SDU;\
 342 } while(0)
 343 #endif
 344
 345 #define RGSCH_CMN_MIN_GRNT_HDR (RG_SCH_CMN_DED_MAX_HDRSIZE * RG_SCH_CMN_MAX_DED_SDU + 1)
 346
 347 #define RG_SCH_CMN_MAX_UL_CONTRES_GRNT   4
 348 #define RG_SCH_CMN_UL_PRIOS              RG_SCH_CMN_MAX_PRIO + 1
 349 #define RG_SCH_CMN_MAX_ALLOC_TRACK       10
 350 /* Introduced timing delta for UL control in FDD*/
 351 #define RG_SCH_CMN_MIN_BSR_RECP_INTRVL   (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA)
 352 #define RG_SCH_CMN_MIN_MSG3_RECP_INTRVL  RG_SCH_CMN_DL_DELTA + RGSCH_RARSP_MSG3_DELTA
 353 /* Introduced timing delta for DL control in FDD */
 354 /* This interval RG_SCH_CMN_MIN_RETXMSG3_RECP_INTRVL is used in FDD only */
 355 #ifndef LTE_TDD
 356 #define RG_SCH_CMN_MIN_RETXMSG3_RECP_INTRVL (TFU_DLCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA)
 357 #endif
 358 /* Fixing the priority table to be more in line with the spec 23.203,table
 359  * 6.1.7 */
 360 #define RG_SCH_CMN_QCI_TO_PRIO           {1, 3, 2, 4, 0, 5, 6, 7, 8}
 361 #define RG_SCH_CMN_DCCH_PRIO             0
 362
 363 #define RG_SCH_CMN_GBR_QCI_START     1
 364 #define RG_SCH_CMN_GBR_QCI_END       4
 365 #define RG_SCH_CMN_NGBR_QCI_START    6
 366 #define RG_SCH_CMN_NGBR_QCI_END      9
 367
 368
 369 #define RG_SCH_CMN_UL_GBR_PRIO_START     1
 370 #define RG_SCH_CMN_UL_GBR_PRIO_END       4
 371 /* Introduced min & max qci for validation of qci */
 372 #define RG_SCH_CMN_MIN_QCI               1
 373 #define RG_SCH_CMN_MAX_QCI               9
 374 #define RG_SCH_CMN_NUM_QCI               9
 375 #define RG_SCH_CMN_MAX_CP                2
 376 #define RG_SCH_CMN_NOR_CP                0
 377 #define RG_SCH_CMN_EXT_CP                1
 378 #define RG_SCH_CMN_NUM_TBS               27
 379 #define RG_SCH_CMN_MAX_CQI               16
 380 #define RG_SCH_CMN_NUM_DCI               5 /* 6-0A, 6-1A, 6-0B, 6-1B and 6-2 */
 381 #define RB_SCH_CMN_NUM_SCS_PER_RB        12
 382 #define RG_SCH_CMN_NUM_RBS               110
 383 #define RG_SCH_CMN_UL_NUM_SF             RGSCH_NUM_UL_HQ_PROC+8
 384 #define RG_SCH_CMN_UL_NUM_RE_PER_RB(cell) ((cell)->ulNumRePerRb)
 385 #ifdef LTE_TDD
 386 #define RG_SCH_CMN_MAX_CMN_PDCCH 6
 387 #else
 388 #define RG_SCH_CMN_MAX_CMN_PDCCH 4
 389 #endif
 390 #define RG_SCH_CMN_UL_MAX_CQI            16
 391 #define RG_SCH_CMN_UL_SR_BYTES           1
 392 /* Refresh Timer Defines */
 393 /* MS_WORKAROUND : syed tuning refresh time to 100ms for PFS */
 394 #define RG_SCH_CMN_REFRESH_TIME 32 /* Refresh time/cycle in frames (10ms) */
 395 /* Fix: syed align multiple UEs to refresh at same time */
 396 #define RG_SCH_CMN_REFRESH_TIMERES 10
 397 #define RG_SCH_CMN_NUM_REFRESH_Q    16
 398 #define RG_SCH_CMN_EVNT_UE_REFRESH  1
 399
 400 #define RG_SCH_CMN_TPC_ACC_DEC_THRESHOLD  1
 401 #define RG_SCH_CMN_TPC_ACC_INC_1DB_THRESHOLD  1
 402 #define RG_SCH_CMN_TPC_ACC_INC_3DB_THRESHOLD  3
 403 #define RG_SCH_CMN_TPC_ABS_DEC_4DB_THRESHOLD  4
 404 #define RG_SCH_CMN_TPC_ABS_DEC_1DB_THRESHOLD  1
 405 #define RG_SCH_CMN_TPC_ABS_INC_1DB_THRESHOLD  4
 406 #define RG_SCH_CMN_TPC_ABS_INC_4DB_THRESHOLD  4
 407
 408 /* ccpu00117606 - ADD - Include CRS REs while calculating Efficiency */
 409 #define RG_SCH_CMN_MAX_ANT_CONF               3
 410 #define RG_SCH_CMN_NUM_SLOTS_PER_SF           2
 411 /* ccpu00117606 - ADD - Defines for Effective Cell RS for different Tx Ant Ports */
 412 #define RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT       6
 413 #define RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT       12
 414 #define RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT      16
 415
 416 /* ADD-new defines for Min & Max RI values */
 417 #define RG_SCH_CMN_MIN_RI 1
 418 #define RG_SCH_CMN_MAX_RI 4
 419
 420 #define RG_SCH_CMN_MAX_CW_PER_UE 2
 421
 422 #define RG_SCH_CMN_IS_RI_VALID(ri) \
 423    (ri >= RG_SCH_CMN_MIN_RI && ri <= RG_SCH_CMN_MAX_RI)
 424
 425 #define RGSCHCMNADDTOCRNTTIME(crntTime, toFill, incr) \
 426 {\
 427    uint32_t absoluteTime;\
 428    absoluteTime = crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTime.slot;\
 429    absoluteTime += incr;\
 430    toFill.sfn = (absoluteTime /RGSCH_NUM_SUB_FRAMES_5G)% 1024;\
 431    toFill.slot = absoluteTime % RGSCH_NUM_SUB_FRAMES_5G;\
 432 }
 433
 434 #define RG_SCH_CMN_PWR_USE_CFG_MAX_PWR    (-128)
 435
 436 #define RG_SCH_CMN_RARSP_WAIT_PRD   3
 437
 438 #define RG_SCH_CMN_MAX_SPL_CFI      2
 439 #define RG_SCH_CMN_INVALID_INFO     0xff
 440 #define RG_SCH_CMN_NUM_SUBCAR       12
 441
 442 #define RG_SCH_CMN_SUBFRM_0      0
 443 #define RG_SCH_CMN_SPL_SUBFRM_1  1
 444 #define RG_SCH_CMN_SUBFRM_5      5
 445 #define RG_SCH_CMN_SPL_SUBFRM_6  6
 446
 447 #define RG_SCH_CMN_VALUE_ONE 1
 448
 449 #define RG_SCH_CMN_IS_ODD(x) ((x) & 0x01)
 450
 451 #define RG_SCH_CMN_MAX_NUM_OF_SFN 10240
 452 #define RG_SCH_CMN_MAX_SFN_NUM 1023
 453
 454 #define RG_SCH_CMN_NUM_DL_AT_SWTCHPT   2
 455
 456 #define RG_SCH_CMN_10_MS_PRD      10
 457 #define RG_SCH_CMN_5_MS_PRD       5
 458
 459 #define RG_SCH_CMN_DECR_FRAME(_x, _y) {\
 460    S16 _tmpNo = (_x) - (_y); \
 461    if(_tmpNo < 0) { \
 462       (_x) = _tmpNo + RGSCH_MAX_SFN; \
 463    }\
 464    else {\
 465       (_x) = _tmpNo; \
 466    }\
 467 }
 468
 469 #ifdef EMTC_ENABLE
 470 /* ADD-new hash define for max msg3 mcs val */
 471 #define RG_SCH_CMN_MAX_EMTC_MSG3_IMCS 7
 472 #endif
 473
 474 #define RG_SCH_CMN_MAX_MSG3_IMCS 15
 475
 476 #define RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrsz) {\
 477    S16 _sfNum=0; \
 478    /* Get the last UL subframe no */ \
 479    for(_sfNum=RGSCH_NUM_SUB_FRAMES-1; _sfNum >= 0; _sfNum--) \
 480    { \
 481       if(rgSchTddUlDlSubfrmTbl[(cell)->ulDlCfgIdx][_sfNum] == \
 482             RG_SCH_TDD_UL_SUBFRAME) \
 483       { \
 484          break; \
 485       } \
 486    } \
 487    (raArrSz) = (_sfNum + ((RgSchCmnCell *)(cell)->sc.sch)->dl.numRaSubFrms \
 488                 + RG_SCH_CMN_RARSP_WAIT_PRD +  \
 489                 (cell)->rachCfg.raWinSize - 1) / RGSCH_NUM_SUB_FRAMES + 1; \
 490 }
 491
 492 /* Resource allocation type MACROs */
 493 #define RG_SCH_CMN_RA_TYPE0 0
 494 #define RG_SCH_CMN_RA_TYPE1 1
 495 #define RG_SCH_CMN_RA_TYPE2 2
 496 /* Added support for SPS*/
 497 #ifdef LTEMAC_SPS
 498 #define RG_SCH_SPS_CONS_DYN_SCHD 5
 499 #define RG_SCH_SPS_CONS_RED_BO   5
 500 #define RG_SCH_DL_SPS_ADDTL_BO   RGSCH_TA_SIZE /* 2 Bytes for TA */
 501 /* RBG subset MACROs for RA type 1 */
 502 #define RG_SCH_CMN_RBG_SUBSET0 0
 503 #define RG_SCH_CMN_RBG_SUBSET1 1
 504 #define RG_SCH_CMN_RBG_SUBSET2 2
 505 #define RG_SCH_CMN_RBG_SUBSET3 3
 506 #define RG_SCH_CMN_DL_NUM_ALLOCMASK 9
 507 #define RG_SCH_CMN_SPS_MAX_PRD 640
 508 #define RG_SCH_SPS_SID_INTERVAL 80
 509 #define RG_SCH_CMN_SPS_DL_ACTV   (1 << 0)
 510 #define RG_SCH_CMN_SPS_DL_REACTV_FREQ (1 << 1)
 511 #define RG_SCH_CMN_SPS_DL_REACTV_TIME (1 << 2)
 512 #define RG_SCH_CMN_SPS_DL_REACTV \
 513 (RG_SCH_CMN_SPS_DL_REACTV_FREQ | RG_SCH_CMN_SPS_DL_REACTV_TIME)
 514 #define RG_SCH_CMN_SPS_DL_REL    (1 << 3)
 515 #define RG_SCH_CMN_SPS_DL_MAX_N1PUCCH_IDX_PER_UE 4
 516 /* Number of 32 bit bitmasks for marking measurement gap for SPS */
 517 #define RG_SCH_CMN_SPS_DL_MEASGAP_32BITMASK_SIZE 3
 518
 519 /* 32 Bit mask size for n1Pucch: RG_SCH_SPS_DL_MAX_N1PUCCH_PER_SF/32 */
 520 #define RG_SCH_CMN_SPS_DL_N1PUCCH_32BITMASK_SIZE \
 521    ((RG_SCH_SPS_DL_MAX_N1PUCCH_PER_SF + 31)/32)
 522 #define RG_SCH_CMN_SPS_DL_INVALIDCQI_VAL 20
 523
 524 /* Maximum number of feasible periodicity values for SPS, SRS, CQI and SR */
 525 #define RG_SCH_CMN_SPS_MAX_NUM_PRD 21
 526
 527 /* Maximum value of iMcs for SPS UE */
 528 #define RG_SCH_CMN_SPS_DL_MAX_MCS 15
 529
 530 /* Minimum gap between SPEECH_GOOD packet and SID packet */
 531 #define RG_SCH_CMN_MIN_GAP_FOR_SID 60
 532
 533 /* DL SPS function MACROs */
 534
 535
 536 #define RG_SCH_CMN_SPS_GET_DL_CELL(cell) &(((RgSchCmnCell *)((cell)->sc.sch))->dl.dlSpsInfo)
 537 #define RG_SCH_CMN_SPS_GET_DL_UE(_ue) &(((RgSchCmnUe *)(((_ue)->cellInfo[0])->sch))->dl.dlSpsInfo)
 538 #define RG_SCH_CMN_SPS_GET_DL_SVC(svc) &(((RgSchCmnDlSvc *)((svc)->sch))->dlSvcSpsInfo)
 539 #define RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP) (((RgSchCmnDlHqProc *)((hqP)->sch))->isSpsSvcSchd)
 540 #define RG_SCH_CMN_SPS_DL_IS_SPS_TX_HQP(hqP) (((RgSchCmnDlHqProc *)((hqP)->sch))->isSpsActv)
 541 #define RG_SCH_CMN_IS_UE_SPS_SCHDLD(_ue, _cell,  _schdTime)\
 542    ((((_ue)->cellInfo[(_ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(_cell)])])->dlAllocCb.spsSchdTime.sfn == _schdTime.sfn) &&\
 543     (((_ue)->cellInfo[(_ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(_cell)])])->dlAllocCb.spsSchdTime.slot == _schdTime.slot))
 544
 545 #define RG_SCH_CMN_DL_COUNT_ONES(_bitMask, _size, _numOnes)\
 546 {\
 547    uint8_t _pos = 0;\
 548    *_numOnes = 0;\
 549    for (_pos = 0; _pos < _size; ++_pos)\
 550    {\
 551       *_numOnes += (_bitMask & (1 << (31 - _pos))) ? 1: 0;\
 552    }\
 553 }
 554
 555 #define RG_SCH_CMN_DL_GET_START_POS(_allocedBitmask, _size, _startPos)\
 556 {\
 557    uint8_t _pos = 0;\
 558    for (_pos = 0; _pos < _size; ++_pos)\
 559    {\
 560       if ((_allocedBitmask & (1 << (31 -_pos))))\
 561       {\
 562          continue;\
 563       }\
 564       else\
 565       {\
 566          *_startPos = _pos;\
 567          break;\
 568       }\
 569    }\
 570 }
 571
 572 /* This macros returns position of idx in a 32 bit bitmask from LSB */
 573 #define RG_SCH_CMN_DL_GET_POS_FRM_LSB(_idx) (31 - (_idx))
 574
 575 #define RG_SCH_CMN_SPS_GET_PRD_IDX(_prdVal, _prdIdx)\
 576 {\
 577    switch (_prdVal)\
 578    {\
 579       case 2: *_prdIdx = RG_SCH_CMN_SPS_PRD_2SF; break;\
 580       case 5: *_prdIdx = RG_SCH_CMN_SPS_PRD_5SF; break;\
 581       case 10: *_prdIdx = RG_SCH_CMN_SPS_PRD_10SF; break;\
 582       case 20: *_prdIdx = RG_SCH_CMN_SPS_PRD_20SF; break;\
 583       case 30: *_prdIdx = RG_SCH_CMN_SPS_PRD_30SF; break;\
 584       case 32: *_prdIdx = RG_SCH_CMN_SPS_PRD_32SF; break;\
 585       case 40: *_prdIdx = RG_SCH_CMN_SPS_PRD_40SF; break;\
 586       case 60: *_prdIdx = RG_SCH_CMN_SPS_PRD_60SF; break;\
 587       case 64: *_prdIdx = RG_SCH_CMN_SPS_PRD_64SF; break;\
 588       case 80: *_prdIdx = RG_SCH_CMN_SPS_PRD_80SF; break;\
 589       case 120: *_prdIdx = RG_SCH_CMN_SPS_PRD_120SF; break;\
 590       case 128: *_prdIdx = RG_SCH_CMN_SPS_PRD_128SF; break;\
 591       case 160: *_prdIdx = RG_SCH_CMN_SPS_PRD_160SF; break;\
 592       case 256: *_prdIdx = RG_SCH_CMN_SPS_PRD_256SF; break;\
 593       case 320: *_prdIdx = RG_SCH_CMN_SPS_PRD_320SF; break;\
 594       case 512: *_prdIdx = RG_SCH_CMN_SPS_PRD_512SF; break;\
 595       case 640: *_prdIdx = RG_SCH_CMN_SPS_PRD_640SF; break;\
 596       case 1024: *_prdIdx = RG_SCH_CMN_SPS_PRD_1024SF; break;\
 597       case 1280: *_prdIdx = RG_SCH_CMN_SPS_PRD_1280SF; break;\
 598       case 2048: *_prdIdx = RG_SCH_CMN_SPS_PRD_2048SF; break;\
 599       case 2560: *_prdIdx = RG_SCH_CMN_SPS_PRD_2560SF; break;\
 600       default:   *_prdIdx = RG_SCH_CMN_SPS_PRD_INVALID;break;\
 601    }\
 602 }
 603
 604 /* To be part of rg_env.h */
 605 /* Maximum n1Pucch values per sub-frame: multiple of 32 */
 606 #define RG_SCH_SPS_DL_MAX_N1PUCCH_PER_SF  96
 607 #define RG_SCH_SPS_DFLT_PRD 20
 608 #define RG_SCH_SPS_CQI_DECR_VAL 2
 609
 610 #ifdef LTE_TDD
 611 /* Added RgrSpsPrd casting to overcome G++ compilation warning*/
 612 #define RGSCH_SPS_GET_PRDCTY(_prdEnum, _prd) \
 613 { \
 614    switch((_prdEnum)) \
 615    { \
 616       case RGR_SPS_PRD_10SF: \
 617          (_prd) = (RgrSpsPrd)10; \
 618          break; \
 619       case RGR_SPS_PRD_20SF: \
 620          (_prd) = (RgrSpsPrd)20; \
 621          break; \
 622       case RGR_SPS_PRD_32SF: \
 623          (_prd) = (RgrSpsPrd)30; \
 624          break; \
 625       case RGR_SPS_PRD_40SF: \
 626          (_prd) = (RgrSpsPrd)40; \
 627          break; \
 628       case RGR_SPS_PRD_64SF: \
 629          (_prd) =(RgrSpsPrd)60; \
 630          break; \
 631       case RGR_SPS_PRD_80SF: \
 632          (_prd) = (RgrSpsPrd)80; \
 633          break; \
 634       case RGR_SPS_PRD_128SF: \
 635          (_prd) = (RgrSpsPrd)120; \
 636          break; \
 637       case RGR_SPS_PRD_160SF: \
 638          (_prd) = (RgrSpsPrd)160; \
 639          break; \
 640       case RGR_SPS_PRD_320SF: \
 641          (_prd) = (RgrSpsPrd)320; \
 642          break; \
 643       case RGR_SPS_PRD_640SF: \
 644          (_prd) = (RgrSpsPrd)640; \
 645          break; \
 646       default:\
 647          (_prd) = RGR_SPS_PRD_INVALID;\
 648    } \
 649 }
 650 #endif /*LTE_TDD*/
 651 /* ADD-hash define for actual transmission time */
 652 /* Feedback for RelPdcch should be received at MAC by HARQ_INTERVAL+
 653  * RG_TFU_HQ_IND_DELTA time.*/
 654 #define RG_SCH_CMN_SPS_TX_TIME (RG_SCH_CMN_HARQ_INTERVAL + TFU_HQFBKIND_ULDELTA)
 655 #endif /* LTEMAC_SPS */
 656
 657 /* LTE_ADV_FLAG_REMOVED_START */
 658 #define RG_SCH_CMN_IS_UE_CELL_EDGE(_ue) _ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge;
 659 #define RG_SCH_CMN_IS_SFR_ENB(_rgSchCellCb)  _rgSchCellCb->lteAdvCb.sfrCfg.status;
 660 #define RG_SCH_CMN_SFR_POOL(_subFrm)  _subFrm->sfrTotalPoolInfo;
 661
 662 #define RG_SCH_MAX_RNTP_SAMPLES 10000
 663 /* LTE_ADV_FLAG_REMOVED_END */
 664
 665 #ifdef LTE_ADV
 666 #define RG_SCH_CMN_IS_SCELL_ACTV(_ue,_sCellIdx) (((_ue)->cellInfo[_sCellIdx] != NULLP) && \
 667          ((_ue)->cellInfo[_sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
 668
 669 /* As per spec 36.133 sec 7.7.3*/
 670 #define RG_SCH_CMN_MAX_SCELL_ACT_DELAY 24
 671 #ifndef TDD
 672 #define RG_SCH_CMN_SCELL_ACT_DELAY_TMR (RG_SCH_CMN_MAX_SCELL_ACT_DELAY - TFU_HQFBKIND_ULDELTA - RG_SCH_CMN_HARQ_INTERVAL)
 673 #endif
 674
 675 /* Is this harq proc belongs to P-cell or S-cell */
 676 #define RG_SCH_CMN_IS_PCELL_HQP(hqP) (((hqP->hqE->ue)&&(hqP->hqE->ue->cell == hqP->hqE->cell))?TRUE:FALSE)
 677 #define RG_SCH_CMN_GET_CELL_IDX_FROM_HQP(hqP) hqP->hqE->ue->cellIdToCellIdxMap[hqP->hqE->cell->cellId]
 678 #endif
 679
 680 /* DL allocation MACROs */
 681
 682 #define RG_SCH_CMN_GET_ALLOCCB_FRM_UE(_ue,_cell) &(((_ue)->cellInfo[(_ue)->cellIdToCellIdxMap\
 683                [RG_SCH_CELLINDEX(_cell)]])->dlAllocCb);
 684 #define RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(_raCb) &((_raCb)->rbAllocInfo);
 685 #define RG_SCH_CMN_INIT_SCHD_LNK(_schdLstLnk, _node)\
 686 {\
 687       (_schdLstLnk)->node = (PTR)_node;\
 688       (_schdLstLnk)->prev = NULLP;\
 689       (_schdLstLnk)->next = NULLP;\
 690 }
 691
 692 /* Changes for MIMO feature addition */
 693 #define RG_SCH_CMN_FILL_DL_TXINFO(_allocInfo, _rb, _sFlg, _prcInf, _numLyr, _sf)\
 694 {\
 695    _allocInfo->rbsReq                    = _rb;\
 696    _allocInfo->mimoAllocInfo.swpFlg      = _sFlg;\
 697    _allocInfo->mimoAllocInfo.precIdxInfo = _prcInf;\
 698    _allocInfo->mimoAllocInfo.numTxLyrs   = _numLyr;\
 699    _allocInfo->dlSf                      = _sf;\
 700 }
 701
 702 #define RG_SCH_CMN_FILL_DL_TBINFO(_tbInfo, _bytsReq, _iTbs, _imcs, _tbCb, _noLyr)\
 703 {\
 704    (_tbInfo)->schdlngForTb = TRUE;\
 705    (_tbInfo)->bytesReq     = _bytsReq;\
 706    (_tbInfo)->iTbs         = _iTbs;\
 707    (_tbInfo)->imcs         = _imcs;\
 708    (_tbInfo)->tbCb         = _tbCb;\
 709    (_tbInfo)->noLyr        = _noLyr;\
 710 }
 711
 712 /* Bit Masks to Force Transmit diversity scheme */
 713 #define RG_SCH_CMN_TD_RI_1         0x01 /* Transmit Diversity due to RI==1 in case
 714                                            of TM3 */
 715 #define RG_SCH_CMN_TD_NO_PMI       0x02 /* Transmit Diversity due to No PMI */
 716 #define RG_SCH_CMN_TD_TXMODE_RECFG 0x04 /* Transmit Diversity due to TXMODE ReCfg */
 717 #define RG_SCH_CMN_TD_TXSCHEME_CHNG 0x08 /* Transmit Diversity due to TX scheme
 718                                             change */
 719 #define RG_SCH_CMN_TD_LAA_SINGLE_TB 0x10 /* Transmit Diversity due to one LAA TB
 720                                             scheduled */
 721
 722 #define RG_SCH_MAX_UL_TX_ANT 2
 723
 724 /*Maximum achievable code rate for non 64QAM UEs.
 725  *Value should NEVER be > than 93. Refer to 36.213, Table 7.2.3-1*/
 726 #define RG_SCH_CMN_MAX_CODE_RATE_16QAM    85  /* 85% code rate*/
 727 #define RG_SCH_CMN_MAX_EFF_BITS         4096
 728
 729 /* Refer BI table from 36.321 Table 7.2.1 */
 730 #define RG_SCH_CMN_NUM_BI_VAL           13
 731
 732 /*New macro to determine UE Category. We use the stored "ueCat" to
 733  * index a UE category array. Therefore, the stored ueCat is 1 less
 734  * than actual UE cateogry.*/
 735 #define RG_SCH_CMN_GET_UE_CTGY(ue) ((RG_SCH_CMN_GET_CMN_UE(ue))->ueCat + 1)
 736 /*ccpu00117270-ADD-END*/
 737
 738 #define RG_SCH_CMN_UPD_RBS_TO_ADD(_CELL,_DLSF,_ALLCINFO,_RBSREQ,_RBSTOADD) \
 739 {\
 740           uint8_t  addtlRbsAvl;\
 741           addtlRbsAvl = rgSCHCmnFindNumAddtlRbsAvl(_CELL,_DLSF,_ALLCINFO);\
 742           if(_RBSREQ > addtlRbsAvl)\
 743           {\
 744               _RBSTOADD = addtlRbsAvl;\
 745           }\
 746           else\
 747           {\
 748               _RBSTOADD = _RBSREQ;\
 749           }\
 750 }
 751    /* ccpu00126002 ADD macro added to check wrap around when index is reached
 752    MAX_CQI_RI_RPT_BUFF*/
 753 #define RG_SCH_INCR_CQIRI_INDEX(idx)\
 754 {\
 755    (idx)++;\
 756    if(MAX_CQI_RI_RPT_BUFF == idx)\
 757    {\
 758       idx = 0;\
 759    }\
 760    if(MAX_CQI_RI_RPT_BUFF <= idx)\
 761    {\
 762       printf("\n Invalid CQI write index:%d ",idx);\
 763    }\
 764 }
 765 #define RG_SCH_DECR_CQIRI_INDEX(idx)\
 766 {\
 767    if(0 == idx)\
 768    {\
 769      idx = (MAX_CQI_RI_RPT_BUFF -1 );\
 770    }\
 771    else\
 772      (idx)--;\
 773    if(0 > idx)\
 774    {\
 775       printf("\n Invalid CQI write index:%d ",idx);\
 776    }\
 777 }
 778
 779
 780 #define RG_SCH_CHK_ITBS_RANGE(_iTbs, _maxiTbs) \
 781 {\
 782    if (_iTbs < 0) \
 783    {\
 784       _iTbs = 0;\
 785    }\
 786    else if (_iTbs > (_maxiTbs))\
 787    {\
 788       _iTbs = (_maxiTbs);\
 789    }\
 790 }
 791
 792
 793 /* LTE_ADV_FLAG_REMOVED_START */
 794 #define RG_SCH_CMN_SFR_UPD_RBS_TO_ADD_IN_POOL(_CELL,_DLSF,_POOLINFO,_ALLCINFO,_RBSREQ,_RBSTOADD) \
 795 {\
 796    uint8_t  addtlRbsAvl;\
 797    addtlRbsAvl = rgSCHCmnSFRFindNumAddtlRbsAvl(_CELL,_DLSF,_POOLINFO,_ALLCINFO);\
 798    if(_RBSREQ > addtlRbsAvl)\
 799    {\
 800       _RBSTOADD = addtlRbsAvl;\
 801    }\
 802    else\
 803    {\
 804       _RBSTOADD = _RBSREQ;\
 805    }\
 806 }
 807 /* LTE_ADV_FLAG_REMOVED_END */
 808
 809 /* DELTA for CFI applying */
 810 #define RG_SCH_CFI_APPLY_DELTA      4
 811 #define RG_SCH_MAX_TX_LYRS_4        4   /*CA dev*/
 812
 813 #define RG_SCH_CFI_STEP_UP(_cell, _cellSch, _currCfi)\
 814 {                                       \
 815    _cellSch->dl.newCfi = ((_currCfi) < _cell->dynCfiCb.maxCfi) ?  \
 816                           (_currCfi + 1):_cell->dynCfiCb.maxCfi;      \
 817    _cell->dynCfiCb.cfiIncr++;            \
 818 }
 819
 820 #define RG_SCH_CFI_STEP_DOWN(_cell, _cellSch, _currCfi)\
 821 {                                       \
 822    _cellSch->dl.newCfi = _currCfi-1;      \
 823    _cell->dynCfiCb.cfiDecr++;            \
 824 }
 825
 826 #define RG_SCH_UPDT_CW2_CQI(_cqiCw1,_cqiCw2,_diffCqi)\
 827    if (_cqiCw1 > rgSchCmnDlCqiDiffOfst[_diffCqi]) \
 828    {\
 829       _cqiCw2 = _cqiCw1 - rgSchCmnDlCqiDiffOfst[_diffCqi]; \
 830    } \
 831    else \
 832    { \
 833       _cqiCw2 = 1; \
 834    }
 835
 836 #ifdef DL_LA
 837 /* TM Mode Step Up/Down Factor macros */
 838 #define RG_SCH_MODE_CHNG_STEPUP_FACTOR              1
 839 #define RG_SCH_MODE_CHNG_STEPDOWN_FACTOR            1
 840 #define RG_SCH_MODE_CHNG_STEPUP_THRSHD              150
 841 #define RG_SCH_MODE_CHNG_STEPDOWN_CHECK_FACTOR      10
 842 #define RG_SCH_MODE_CHNG_STEPDOWN_THRSHD            100
 843
 844 #define RG_SCH_TXSCHEME_CHNG_THRSHD                 5
 845 #define RG_SCH_TXSCHEME_CHNG_ITBS_FACTOR            5
 846
 847 #define RG_SCH_FILL_RGM_TRANSMODE_IND(_ueId, _cellId, _mode, _txModChgInd)\
 848 {\
 849   _txModChgInd->usCrnti = _ueId;\
 850   _txModChgInd->bCellId = _cellId;\
 851   _txModChgInd->eMode = _mode - 1;\
 852 }
 853 #endif
 854 #ifdef __cplusplus
 855 }
 856 #endif
 857 #endif /* __RGSCHCMNH__ */
 858
 859 /********************************************************************30**
 860
 861          End of file
 862 **********************************************************************/