Code Review / o-du / l2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
fixed unused-function and unused variable warnings
[o-du/l2.git] / src / 5gnrsch / rg_sch_cmn.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 fucntions
26
27      File:     rg_sch_cmn.c
28
29 **********************************************************************/
30
31 /** @file rg_sch_cmn.c
32 @brief This file implements the schedulers main access to MAC layer code.
33 */
34
35 static const char* RLOG_MODULE_NAME="MAC";
36 static int RLOG_FILE_ID=187;
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_llist.h"      /* common linked list library */
47 #include "cm_err.h"        /* common error */
48 #include "cm_lte.h"        /* common LTE */
49 #include "cm5.h"
50 #include "lrg.h"
51 #include "rgr.h"
52 #include "tfu.h"
53 #include "rgm.h"
54 #include "rg_env.h"
55 #include "rg_sch_err.h"
56 #include "rg_sch_inf.h"
57 #include "rg_sch.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 Scheduler */
77 #include "rg_sch.x"        /* typedefs for Scheduler */
78 #include "rg_sch_cmn.x"    /* typedefs for Scheduler */
79 #ifdef MAC_SCH_STATS
80 #include "lrg.x"            /* Stats Structures */
81 #endif /* MAC_SCH_STATS */
82 #ifdef __cplusplus
83 extern "C" {
84 #endif /* __cplusplus */
85
86 #ifdef EMTC_ENABLE
87 EXTERN U32 emtcStatsUlTomSrInd;
88 EXTERN U32 emtcStatsUlBsrTmrTxp;
89 #endif
90
91 #define RG_ITBS_DIFF(_x, _y) ((_x) > (_y) ? (_x) - (_y) : (_y) - (_x))
92 EXTERN Void rgSCHSc1UlInit ARGS((RgUlSchdApis *apis));
93 #ifdef RG_PHASE2_SCHED
94 EXTERN Void rgSCHRrUlInit ARGS((RgUlSchdApis *apis));
95 #ifdef EMTC_ENABLE
96 EXTERN Void rgSCHEmtcHqInfoFree ARGS((RgSchCellCb *cell, RgSchDlHqProcCb *hqP));
97 EXTERN Void rgSCHEmtcRrUlInit ARGS((RgUlSchdApis *apis));
98 EXTERN Void rgSCHEmtcCmnDlInit ARGS((Void));
99 EXTERN Void rgSCHEmtcCmnUlInit ARGS((Void));
100 EXTERN Void rgSCHEmtcCmnUeNbReset ARGS((RgSchUeCb *ueCb));
101 EXTERN RgSchCmnCqiToTbs *rgSchEmtcCmnCqiToTbs[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_CFI];
102 #endif
103 EXTERN Void rgSCHMaxciUlInit ARGS((RgUlSchdApis *apis));
104 EXTERN Void rgSCHPfsUlInit ARGS((RgUlSchdApis *apis));
105 #endif
106 EXTERN Void rgSCHSc1DlInit ARGS((RgDlSchdApis *apis));
107 #ifdef RG_PHASE2_SCHED
108 EXTERN Void rgSCHRrDlInit ARGS((RgDlSchdApis *apis));
109 #ifdef EMTC_ENABLE
110 EXTERN Void rgSCHEmtcRrDlInit ARGS((RgDlEmtcSchdApis *apis));
111 #endif
112 EXTERN Void rgSCHMaxciDlInit ARGS((RgDlSchdApis *apis));
113 EXTERN Void rgSCHPfsDlInit ARGS((RgDlSchdApis *apis));
114 #ifdef TFU_UPGRADE
115 EXTERN Void rgSCHDlfsInit ARGS((RgDlfsSchdApis *apis));
116 #endif
117 #endif
118 #ifdef EMTC_ENABLE
119 EXTERN Void rgSCHCmnGetCqiEmtcDciFrmt2AggrLvl ARGS((RgSchCellCb *cell));
120 EXTERN Void rgSCHCmnGetEmtcDciFrmtSizes ARGS((RgSchCellCb *cell));
121 EXTERN Void rgSCHEmtcRrUlProcRmvFrmRetx ARGS((RgSchCellCb *cell, RgSchUlHqProcCb *proc));
122 EXTERN S16 rgSCHCmnPrecompEmtcMsg3Vars
123 ARGS((
124 RgSchCmnUlCell *cellUl,
125 U8           ccchCqi,
126 U16          msgSzA,
127 U8           sbSize,
128 Bool         isEcp
129 ));
130 PUBLIC Void rgSCHEmtcCmnUeCcchSduDel
131 (
132 RgSchCellCb  *cell,
133 RgSchUeCb    *ueCb
134 );
135 EXTERN Void rgSCHEmtcRmvFrmTaLst
136 (
137 RgSchCmnDlCell  *cellDl,
138 RgSchUeCb       *ue
139 );
140 EXTERN Void rgSCHEmtcInitTaLst
141 (
142 RgSchCmnDlCell  *cellDl
143 );
144 EXTERN Void rgSCHEmtcAddToTaLst
145 (
146 RgSchCmnDlCell  *cellDl,
147 RgSchUeCb       *ue
148 );
149
150 #endif
151
152 #ifdef RGR_SI_SCH
153 PRIVATE Void rgSCHDlSiSched ARGS((RgSchCellCb  *cell,
154                       RgSchCmnDlRbAllocInfo *allocInfo,
155                       RgInfSfAlloc  *subfrmAlloc));
156 PRIVATE Void rgSCHChkNUpdSiCfg ARGS((RgSchCellCb  *cell));
157 PRIVATE Void rgSCHSelectSi ARGS((RgSchCellCb *cell));
158 #endif /*RGR_SI_SCH*/
159 /* LTE_ADV_FLAG_REMOVED_START */
160 #ifndef LTE_TDD
161 #ifdef UNUSE_FUN
162 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
163 (
164 RgSchCellCb        *cell,
165 RgSchUeCb          *ue,
166 RgSchDlSf          *dlSf,
167 U8                 rbStrt,
168 U8                 numRb
169 );
170 PRIVATE S16 rgSCHCmnBuildRntpInfo (
171 RgSchCellCb        *cell,
172 U8                 *rntpPtr,
173 U8                  startRb,
174 U8                  nmbRb,
175 U16                 bw
176 );
177 #endif
178 #endif
179
180 PUBLIC Void rgSCHCmnDlSpsSch
181 (
182  RgSchCellCb        *cell
183 );
184 /* LTE_ADV_FLAG_REMOVED_END */
185
186 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc ARGS((
187 RgSchCellCb           *cell,
188 RgSchCmnDlRbAllocInfo *allocInfo
189 ));
190 PRIVATE Void rgSCHBcchPcchDlRbAlloc ARGS((
191 RgSchCellCb           *cell,
192 RgSchCmnDlRbAllocInfo *allocInfo
193 ));
194 PRIVATE Void rgSCHCmnDlBcchPcchAlloc ARGS((
195 RgSchCellCb  *cell
196 ));
197 #ifdef RGR_CQI_REPT
198 PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
199  RgSchCellCb        *cell,
200  RgSchUeCb          *ue,
201  TfuDlCqiPucch      *pucchCqi,
202  RgrUeCqiRept       *ueCqiRept,
203  Bool               *isCqiAvail,
204  Bool               *is2ndCwCqiAvail
205  ));
206 PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
207  RgSchCellCb        *cell,
208  RgSchUeCb          *ue,
209  TfuDlCqiPusch      *puschCqi,
210  RgrUeCqiRept       *ueCqiRept,
211  Bool               *isCqiAvail,
212  Bool               *is2ndCwCqiAvail
213  ));
214 #else
215 PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
216  RgSchCellCb        *cell,
217  RgSchUeCb          *ue,
218  TfuDlCqiPucch      *pucchCqi
219  ));
220 PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
221  RgSchCellCb        *cell,
222  RgSchUeCb          *ue,
223  TfuDlCqiPusch      *puschCqi
224  ));
225 #endif
226 /* ccpu00117452 - MOD - Changed macro name from
227    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
228 #ifdef RGR_CQI_REPT
229 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept ARGS((
230    RgSchCellCb        *cell,
231    RgSchUeCb          *ue,
232    RgrUeCqiRept        *ueCqiRept));
233 #endif /* End of RGR_CQI_REPT */
234 /* Fix: syed align multiple UEs to refresh at same time */
235 PRIVATE Void rgSCHCmnGetRefreshPer ARGS((
236    RgSchCellCb  *cell,
237    RgSchUeCb    *ue,
238    U32          *waitPer));
239 PRIVATE S16 rgSCHCmnApplyUeRefresh ARGS((
240 RgSchCellCb     *cell,
241 RgSchUeCb       *ue));
242 #ifdef DL_LA
243 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa ARGS
244 ((
245 RgSchCellCb   *cell,
246 RgSchUeCb     *ue
247 ));
248 PRIVATE Void rgSCHCheckAndSetTxScheme ARGS
249 ((
250 RgSchCellCb   *cell,
251 RgSchUeCb     *ue
252 ));
253 #endif
254
255 #ifdef LTE_TDD
256 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz ARGS
257 ((
258 RgSchCellCb    *cell,
259 U32             bo,
260 U8             *rb,
261 U8             *iTbs,
262 U8              lyr,
263 U8              cfi
264 ));
265
266 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw ARGS
267 ((
268 RgSchCellCb    *cell,
269 U32             bo,
270 U8             *rb,
271 U8              maxRb,
272 U8             *iTbs1,
273 U8             *iTbs2,
274 U8              lyr1,
275 U8              lyr2,
276 U32            *tb1Sz, 
277 U32            *tb2Sz, 
278 U8              cfi
279 ));
280
281 #endif
282 #ifdef UNUSE_FUN
283 PRIVATE Void rgSCHCmnNonDlfsType0Alloc
284 (
285 RgSchCellCb        *cell,
286 RgSchDlSf          *dlSf,
287 RgSchDlRbAlloc     *allocInfo,
288 RgSchUeCb          *ue
289 );
290 #endif
291 PRIVATE Void  rgSCHCmnInitRbAlloc ARGS 
292 ((
293 RgSchCellCb        *cell
294 ));
295 #ifdef __cplusplus
296 }
297 #endif /* __cplusplus */
298
299
300 /* local defines */
301 PUBLIC  RgSchdApis          rgSchCmnApis;
302 PRIVATE RgUlSchdApis        rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
303 PRIVATE RgDlSchdApis        rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
304 #ifdef EMTC_ENABLE
305 PRIVATE RgUlSchdApis        rgSchEmtcUlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
306 PRIVATE RgDlEmtcSchdApis        rgSchEmtcDlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
307 #endif
308 #ifdef RG_PHASE2_SCHED
309 PRIVATE RgDlfsSchdApis      rgSchDlfsSchdTbl[RGSCH_NUM_DLFS_SCHEDULERS];
310 #endif
311 PRIVATE RgUlSchdInits       rgSchUlSchdInits = RGSCH_ULSCHED_INITS;
312 PRIVATE RgDlSchdInits       rgSchDlSchdInits = RGSCH_DLSCHED_INITS;
313 #ifdef EMTC_ENABLE
314 PRIVATE RgEmtcUlSchdInits       rgSchEmtcUlSchdInits = RGSCH_EMTC_ULSCHED_INITS;
315 PRIVATE RgEmtcDlSchdInits       rgSchEmtcDlSchdInits = RGSCH_EMTC_DLSCHED_INITS;
316 #endif
317 #if (defined (RG_PHASE2_SCHED) && defined (TFU_UPGRADE))
318 PRIVATE RgDlfsSchdInits     rgSchDlfsSchdInits = RGSCH_DLFSSCHED_INITS;
319 #endif
320
321 typedef Void (*RgSchCmnDlAllocRbFunc) ARGS((RgSchCellCb *cell, RgSchDlSf *subFrm,
322 RgSchUeCb *ue, U32 bo, U32 *effBo, RgSchDlHqProcCb *proc,
323 RgSchCmnDlRbAllocInfo *cellWdAllocInfo));
324 typedef U8 (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, 
325       U8 numLyrs, Bool bothCwEnbld));
326 #ifdef UNUSE_FUN
327 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
328 RgSchCellCb                *cell,
329 RgSchDlRbAlloc             *rbAllocInfo,
330 RgSchDlHqProcCb            *hqP,
331 RgSchPdcch                 *pdcch,
332 U8                         tpc
333 ));
334 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
335 RgSchCellCb                *cell,
336 RgSchDlRbAlloc             *rbAllocInfo,
337 RgSchDlHqProcCb            *hqP,
338 RgSchPdcch                 *pdcch,
339 U8                         tpc
340 ));
341 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
342 RgSchCellCb                *cell,
343 RgSchDlRbAlloc             *rbAllocInfo,
344 RgSchDlHqProcCb            *hqP,
345 RgSchPdcch                 *pdcch,
346 U8                         tpc
347 ));
348 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
349 RgSchCellCb                *cell,
350 RgSchDlRbAlloc             *rbAllocInfo,
351 RgSchDlHqProcCb            *hqP,
352 RgSchPdcch                 *pdcch,
353 U8                         tpc
354 ));
355 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
356 RgSchCellCb                *cell,
357 RgSchDlRbAlloc             *rbAllocInfo,
358 RgSchDlHqProcCb            *hqP,
359 RgSchPdcch                 *pdcch,
360 U8                         tpc
361 ));
362 #endif
363 PRIVATE Void rgSCHCmnDlAllocTxRbTM1 ARGS((
364 RgSchCellCb                *cell,
365 RgSchDlSf                  *subFrm,
366 RgSchUeCb                  *ue,
367 U32                        bo,
368 U32                        *effBo,
369 RgSchDlHqProcCb            *proc,
370 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
371 ));
372 PRIVATE Void rgSCHCmnDlAllocTxRbTM2 ARGS((
373 RgSchCellCb                *cell,
374 RgSchDlSf                  *subFrm,
375 RgSchUeCb                  *ue,
376 U32                        bo,
377 U32                        *effBo,
378 RgSchDlHqProcCb            *proc,
379 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
380 ));
381 PRIVATE Void rgSCHCmnDlAllocTxRbTM3 ARGS((
382 RgSchCellCb                *cell,
383 RgSchDlSf                  *subFrm,
384 RgSchUeCb                  *ue,
385 U32                        bo,
386 U32                        *effBo,
387 RgSchDlHqProcCb            *proc,
388 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
389 ));
390 PRIVATE Void rgSCHCmnDlAllocTxRbTM4 ARGS((
391 RgSchCellCb                *cell,
392 RgSchDlSf                  *subFrm,
393 RgSchUeCb                  *ue,
394 U32                        bo,
395 U32                        *effBo,
396 RgSchDlHqProcCb            *proc,
397 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
398 ));
399 #ifdef RG_UNUSED
400 PRIVATE Void rgSCHCmnDlAllocTxRbTM5 ARGS((
401 RgSchCellCb                *cell,
402 RgSchDlSf                  *subFrm,
403 RgSchUeCb                  *ue,
404 U32                        bo,
405 U32                        *effBo,
406 RgSchDlHqProcCb            *proc,
407 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
408 ));
409 #endif
410 PRIVATE Void rgSCHCmnDlAllocTxRbTM6 ARGS((
411 RgSchCellCb                *cell,
412 RgSchDlSf                  *subFrm,
413 RgSchUeCb                  *ue,
414 U32                        bo,
415 U32                        *effBo,
416 RgSchDlHqProcCb            *proc,
417 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
418 ));
419 PRIVATE Void rgSCHCmnDlAllocTxRbTM7 ARGS((
420 RgSchCellCb                *cell,
421 RgSchDlSf                  *subFrm,
422 RgSchUeCb                  *ue,
423 U32                        bo,
424 U32                        *effBo,
425 RgSchDlHqProcCb            *proc,
426 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
427 ));
428 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1 ARGS((
429 RgSchCellCb                *cell,
430 RgSchDlSf                  *subFrm,
431 RgSchUeCb                  *ue,
432 U32                        bo,
433 U32                        *effBo,
434 RgSchDlHqProcCb            *proc,
435 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
436 ));
437 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2 ARGS((
438 RgSchCellCb                *cell,
439 RgSchDlSf                  *subFrm,
440 RgSchUeCb                  *ue,
441 U32                        bo,
442 U32                        *effBo,
443 RgSchDlHqProcCb            *proc,
444 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
445 ));
446 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3 ARGS((
447 RgSchCellCb                *cell,
448 RgSchDlSf                  *subFrm,
449 RgSchUeCb                  *ue,
450 U32                        bo,
451 U32                        *effBo,
452 RgSchDlHqProcCb            *proc,
453 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
454 ));
455 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4 ARGS((
456 RgSchCellCb                *cell,
457 RgSchDlSf                  *subFrm,
458 RgSchUeCb                  *ue,
459 U32                        bo,
460 U32                        *effBo,
461 RgSchDlHqProcCb            *proc,
462 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
463 ));
464 #ifdef RG_UNUSED
465 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5 ARGS((
466 RgSchCellCb                *cell,
467 RgSchDlSf                  *subFrm,
468 RgSchUeCb                  *ue,
469 U32                        bo,
470 U32                        *effBo,
471 RgSchDlHqProcCb            *proc,
472 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
473 ));
474 #endif
475 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6 ARGS((
476 RgSchCellCb                *cell,
477 RgSchDlSf                  *subFrm,
478 RgSchUeCb                  *ue,
479 U32                        bo,
480 U32                        *effBo,
481 RgSchDlHqProcCb            *proc,
482 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
483 ));
484 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7 ARGS((
485 RgSchCellCb                *cell,
486 RgSchDlSf                  *subFrm,
487 RgSchUeCb                  *ue,
488 U32                        bo,
489 U32                        *effBo,
490 RgSchDlHqProcCb            *proc,
491 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
492 ));
493
494 #ifdef LTE_ADV 
495 PRIVATE U8 rgSchGetN1ResCount ARGS ((
496  RgSchUeCb *ue,
497  U16       servCellId 
498 ));
499 PUBLIC Bool rgSchCmnChkDataOnlyOnPcell 
500 (
501  RgSchUeCb         *ue,
502  RgSchDlSf         *dlSf
503 );
504 #endif /*LTE_ADV */
505 PUBLIC U8 rgSCHCmnCalcPcqiBitSz
506 (
507  RgSchUeCb    *ueCb, 
508  U8           numTxAnt
509 );
510
511 #ifndef LTE_ADV
512 /* Functions specific to each transmission mode for DL Tx RB Allocation*/
513 RgSchCmnDlAllocRbFunc  dlAllocTxRbFunc[7] = {rgSCHCmnDlAllocTxRbTM1,
514 rgSCHCmnDlAllocTxRbTM2, rgSCHCmnDlAllocTxRbTM3, rgSCHCmnDlAllocTxRbTM4,
515 NULLP, rgSCHCmnDlAllocTxRbTM6, rgSCHCmnDlAllocTxRbTM7};
516
517 /* Functions specific to each transmission mode for DL Retx RB Allocation*/
518 RgSchCmnDlAllocRbFunc  dlAllocRetxRbFunc[7] = {rgSCHCmnDlAllocRetxRbTM1,
519 rgSCHCmnDlAllocRetxRbTM2, rgSCHCmnDlAllocRetxRbTM3, rgSCHCmnDlAllocRetxRbTM4,
520 NULLP, rgSCHCmnDlAllocRetxRbTM6, rgSCHCmnDlAllocRetxRbTM7};
521 #else
522 /* Functions specific to each transmission mode for DL Tx RB Allocation*/
523 RgSchCmnDlAllocRbFunc  dlAllocTxRbFunc[9] = {rgSCHCmnDlAllocTxRbTM1,
524 rgSCHCmnDlAllocTxRbTM2, rgSCHCmnDlAllocTxRbTM3, rgSCHCmnDlAllocTxRbTM4,
525 NULLP, rgSCHCmnDlAllocTxRbTM6, rgSCHCmnDlAllocTxRbTM7, NULLP, NULLP};
526
527 /* Functions specific to each transmission mode for DL Retx RB Allocation*/
528 RgSchCmnDlAllocRbFunc  dlAllocRetxRbFunc[9] = {rgSCHCmnDlAllocRetxRbTM1,
529 rgSCHCmnDlAllocRetxRbTM2, rgSCHCmnDlAllocRetxRbTM3, rgSCHCmnDlAllocRetxRbTM4,
530 NULLP, rgSCHCmnDlAllocRetxRbTM6, rgSCHCmnDlAllocRetxRbTM7, NULLP, NULLP};
531
532 #endif
533
534
535 PRIVATE U8 rgSCHCmnDlTM3PrecInf2 ARGS((
536 RgSchCellCb                *cell,
537 RgSchUeCb                  *ue,
538 U8                         numTxLyrs,
539 Bool                       bothCwEnbld
540 ));
541 PRIVATE U8 rgSCHCmnDlTM3PrecInf4 ARGS((
542 RgSchCellCb                *cell,
543 RgSchUeCb                  *ue,
544 U8                         numTxLyrs,
545 Bool                       bothCwEnbld
546 ));
547 PRIVATE U8 rgSCHCmnDlTM4PrecInf2 ARGS((
548 RgSchCellCb                *cell,
549 RgSchUeCb                  *ue,
550 U8                         numTxLyrs,
551 Bool                       bothCwEnbld
552 ));
553 PRIVATE U8 rgSCHCmnDlTM4PrecInf4 ARGS((
554 RgSchCellCb                *cell,
555 RgSchUeCb                  *ue,
556 U8                         numTxLyrs,
557 Bool                       bothCwEnbld
558 ));
559 /* Functions specific to each transmission mode for DL RB Allocation*/
560 RgSchCmnDlGetPrecInfFunc getPrecInfoFunc[2][2] = {
561 {rgSCHCmnDlTM3PrecInf2, rgSCHCmnDlTM3PrecInf4},
562 {rgSCHCmnDlTM4PrecInf2, rgSCHCmnDlTM4PrecInf4}
563 };
564
565 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb ARGS((
566 RgSchCellCb                *cell,
567 RgSchDlSf                  *subFrm,
568 RgSchUeCb                  *ue,
569 RgSchDlHqTbCb              *tbInfo,
570 U8                         noLyr,
571 U8                         *numRb,
572 U32                        *effBo
573 ));
574 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb ARGS((
575 RgSchCellCb                *cell,
576 RgSchDlSf                  *subFrm,
577 RgSchUeCb                  *ue,
578 RgSchDlHqProcCb            *proc,
579 U8                         *numRb,
580 Bool                       *swpFlg,
581 U32                        *effBo
582 ));
583 PRIVATE Void rgSCHCmnDlTM3TxTx ARGS((
584 RgSchCellCb                *cell,
585 RgSchDlSf                  *subFrm,
586 RgSchUeCb                  *ue,
587 U32                        bo,
588 U32                        *effBo,
589 RgSchDlHqProcCb            *proc,
590 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
591 ));
592 PRIVATE Void rgSCHCmnDlTM3TxRetx ARGS((
593 RgSchCellCb                *cell,
594 RgSchDlSf                  *subFrm,
595 RgSchUeCb                  *ue,
596 U32                        bo,
597 U32                        *effBo,
598 RgSchDlHqProcCb            *proc,
599 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
600 ));
601 PRIVATE Void rgSCHCmnDlTM3RetxRetx ARGS((
602 RgSchCellCb                *cell,
603 RgSchDlSf                  *subFrm,
604 RgSchUeCb                  *ue,
605 U32                        bo,
606 U32                        *effBo,
607 RgSchDlHqProcCb            *proc,
608 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
609 ));
610
611 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc ARGS((
612 RgSchCellCb        *cell,
613 RgSchDlSf          *dlSf,
614 U8                 rbStrt,
615 U8                 numRb
616 ));
617 /* LTE_ADV_FLAG_REMOVED_START */
618 #ifndef LTE_TDD
619 PRIVATE Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc ARGS((
620 RgSchCellCb        *cell,
621 RgSchDlSf          *dlSf,
622 U8                 rbStrt,
623 U8                 numRb
624 ));
625 #endif
626 /* LTE_ADV_FLAG_REMOVED_END */
627 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx ARGS((
628 RgSchCellCb        *cell,
629 RgSchCmnDlRbAllocInfo *allocInfo,
630 RgSchUeCb             *ue,
631 RgSchDlHqProcCb       *proc
632 ));
633 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx ARGS((
634 RgSchCellCb        *cell,
635 RgSchCmnDlRbAllocInfo *allocInfo,
636 RgSchUeCb             *ue,
637 RgSchDlHqProcCb       *hqP
638 ));
639 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst ARGS((
640 RgSchCmnDlRbAllocInfo *allocInfo,
641 RgSchUeCb             *ue,
642 RgSchDlHqProcCb       *proc
643 ));
644 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb ARGS((
645 RgSchCellCb                *cell,
646 RgSchDlSf                  *subFrm,
647 RgSchUeCb                  *ue,
648 RgSchDlHqTbCb              *reTxTb,
649 RgSchDlHqTbCb              *txTb,
650 U8                         *numRb,
651 U32                        *effBo
652 ));
653 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb ARGS((
654 RgSchCellCb                *cell,
655 RgSchDlSf                  *subFrm,
656 RgSchUeCb                  *ue,
657 RgSchDlHqProcCb            *proc,
658 U32                        bo,
659 U8                         *numRb,
660 U32                        *effBo
661 ));
662 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb ARGS((
663 RgSchCellCb                *cell,
664 RgSchDlSf                  *subFrm,
665 RgSchUeCb                  *ue,
666 RgSchDlHqTbCb              *tbInfo,
667 U32                        bo,
668 U8                         *numRb,
669 U32                        *effBo
670 ));
671 #ifndef LTEMAC_SPS
672 PRIVATE Void rgSCHCmnFillHqPTb ARGS((
673 RgSchCellCb                *cell,
674 RgSchDlRbAlloc             *rbAllocInfo,
675 U8                         tbAllocIdx,
676 RgSchPdcch                 *pdcch
677 ));
678 #endif
679 #ifdef LTEMAC_SPS
680 PRIVATE Void rgSCHCmnDlGetBestFitHole ARGS((
681 U32         *allocMask,
682 U8          numMaskRbs,
683 U32         *crntAllocMask,
684 U8          rbsReq,
685 U8          *allocStart,
686 U8          *allocNumRbs,
687 Bool        isPartialAlloc
688 ));
689 #ifdef RGSCH_SPS_UNUSED
690 PRIVATE U32 rgSCHCmnGetRaType1Mask ARGS((
691 U8                rbIdx,
692 U8                rbgSize,
693 U8                *type1Subset
694 ));
695 #endif
696 PRIVATE U32 rgSCHCmnGetRaType0Mask ARGS((
697 U8                rbIdx,
698 U8                rbgSize
699 ));
700 PRIVATE U32 rgSCHCmnGetRaType2Mask ARGS((
701 U8                rbIdx,
702 U8                *maskIdx
703 ));
704 #endif
705
706 PUBLIC Bool rgSCHCmnRetxAllocAvoid ARGS(( 
707 RgSchDlSf                  *subFrm,
708 RgSchCellCb                *cell,
709 RgSchDlHqProcCb            *proc
710 ));
711
712 PUBLIC U16 rgSCHCmnGetSiSetId ARGS((
713 U16    sfn,
714 U8     sf,
715 U16    minPeriodicity
716 ));
717
718 #ifdef TFU_UPGRADE
719 #ifdef UNUSE_FUN
720 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
721 RgSchCellCb  *cell,
722 RgSchUeCb    *ue,
723 U32          maxRb,
724 U32          *numSb,
725 U8           *iTbs,
726 U32          hqSz,
727 U32          stepDownItbs,
728 U32          effTgt
729 ));
730 #endif
731 #endif
732
733 #ifdef RG_5GTF
734 //TODO_SID: Currenly table is only for 100 Prbs. Need to modify wrt VRBG table 8.1.5.2.1-1 V5G_213
735 U32 rgSch5gtfTbSzTbl[MAX_5GTF_MCS] = 
736     {1864, 5256, 8776, 13176, 17576, 21976, 26376, 31656, 35176, 39576, 43976, 47496, 52776, 59376, 66392};
737 U32 g5gtfTtiCnt = 0;
738 U32 gUl5gtfSrRecv = 0;
739 U32 gUl5gtfBsrRecv = 0;
740 U32 gUl5gtfUeSchPick = 0;
741 U32 gUl5gtfPdcchSchd = 0;
742 U32 gUl5gtfAllocAllocated = 0;
743 U32 gUl5gtfUeRbAllocDone = 0;
744 U32 gUl5gtfUeRmvFnlzZeroBo = 0;
745 U32 gUl5gtfUeFnlzReAdd = 0;
746 U32 gUl5gtfPdcchSend = 0;
747 U32 gUl5gtfRbAllocFail = 0;
748 U32 ul5gtfsidUlMarkUl = 0;
749 U32 ul5gtfsidDlSchdPass = 0;
750 U32 ul5gtfsidDlAlreadyMarkUl = 0;
751 U32 ul5gtfTotSchdCnt = 0;
752 #endif
753
754 /* CQI Offset Index to Beta CQI Offset value mapping,
755  * stored as parts per 1000. Reserved is set to 0.
756  * Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
757 PUBLIC U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
758    1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
759    3125, 3500, 4000, 5000, 6250};
760 PUBLIC U32 rgSchCmnBetaHqOffstTbl[16] =  {2000, 2500, 3125, 
761    4000, 5000, 6250, 8000,10000, 12625, 15875, 20000, 
762    31000, 50000,80000,126000,0};
763 PUBLIC U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000, 
764    2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
765    15875,20000,0,0,0};
766 PUBLIC S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
767
768 /* Include CRS REs while calculating Efficiency */
769 CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
770 CONSTANT PRIVATE U8 rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
771 U32 cfiSwitchCnt ;
772 U32 cfiIncr ;
773 U32 cfiDecr ;
774
775
776 #ifdef TFU_UPGRADE
777 PUBLIC S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
778 PUBLIC S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
779 #endif
780
781 typedef struct rgSchCmnDlUeDciFrmtOptns
782 {
783   TfuDciFormat spfcDciFrmt;   /* TM(Transmission Mode) specific DCI format.
784                                * Search space : UE Specific by C-RNTI only. */
785   U8           spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
786   TfuDciFormat prfrdDciFrmt;  /* Preferred DCI format among the available
787                                * options for TD (Transmit Diversity) */
788   U8           prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
789 }RgSchCmnDlUeDciFrmtOptns;
790 #ifndef LTE_ADV
791
792 /* DCI Format options for each Transmission Mode */
793 RgSchCmnDlUeDciFrmtOptns rgSchCmnDciFrmtOptns[7] = {
794    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
795    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
796    {TFU_DCI_FORMAT_2A,RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
797    {TFU_DCI_FORMAT_2, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
798    {TFU_DCI_FORMAT_1D,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
799    {TFU_DCI_FORMAT_1B,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
800    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2}
801 };
802
803 #else
804 /* DCI Format options for each Transmission Mode */
805 RgSchCmnDlUeDciFrmtOptns rgSchCmnDciFrmtOptns[9] = {
806    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
807    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
808    {TFU_DCI_FORMAT_2A,RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
809    {TFU_DCI_FORMAT_2, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
810    {TFU_DCI_FORMAT_1D,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
811    {TFU_DCI_FORMAT_1B,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
812    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2}
813 };
814 #endif
815
816
817 typedef struct rgSchCmnDlImcsTbl
818 {
819   U8   modOdr; /* Modulation Order */
820   U8   iTbs;   /* ITBS */
821 }RgSchCmnDlImcsTbl[29];
822
823 CONSTANT struct rgSchCmnMult235Info
824 {
825    U8   match;    /* Closest number satisfying 2^a.3^b.5^c, with a bias
826                   * towards the smaller number */
827    U8   prvMatch; /* Closest number not greater than array index
828                   * satisfying 2^a.3^b.5^c */
829 } rgSchCmnMult235Tbl[110+1] = {
830    {0, 0},  /* dummy */
831    {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {6, 6}, {8, 8},
832    {9, 9}, {10, 10}, {10, 10}, {12, 12}, {12, 12}, {15, 12}, {15, 15},
833    {16, 16}, {16, 16}, {18, 18}, {18, 18}, {20, 20}, {20, 20}, {20, 20},
834    {24, 20}, {24, 24}, {25, 25}, {25, 25}, {27, 27}, {27, 27}, {30, 27},
835    {30, 30}, {30, 30}, {32, 32}, {32, 32}, {32, 32}, {36, 32}, {36, 36},
836    {36, 36}, {36, 36}, {40, 36}, {40, 40}, {40, 40}, {40, 40}, {45, 40},
837    {45, 40}, {45, 45}, {45, 45}, {48, 45}, {48, 48}, {48, 48}, {50, 50},
838    {50, 50}, {50, 50}, {54, 50}, {54, 54}, {54, 54}, {54, 54}, {54, 54},
839    {60, 54}, {60, 54}, {60, 60}, {60, 60}, {60, 60}, {64, 60}, {64, 64},
840    {64, 64}, {64, 64}, {64, 64}, {64, 64}, {72, 64}, {72, 64}, {72, 64},
841    {72, 72}, {72, 72}, {75, 72}, {75, 75}, {75, 75}, {75, 75}, {80, 75},
842    {80, 75}, {80, 80}, {81, 81}, {81, 81}, {81, 81}, {81, 81}, {81, 81},
843    {90, 81}, {90, 81}, {90, 81}, {90, 81}, {90, 90}, {90, 90}, {90, 90},
844    {90, 90}, {96, 90}, {96, 90}, {96, 96}, {96, 96}, {96, 96}, {100, 96},
845    {100, 100}, {100, 100}, {100, 100}, {100, 100}, {100, 100}, {108, 100},
846    {108, 100}, {108, 100}, {108, 108}, {108, 108}, {108, 108}
847 };
848
849 /* R8 Upgrade */
850 /* BI table from 36.321 Table 7.2.1 */
851 CONSTANT PRIVATE S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
852       0, 10, 20, 30,40,60,80,120,160,240,320,480,960};
853 PUBLIC RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
854  {     0,                0              },
855  {RGSCH_CMN_QM_CQI_1,RGSCH_CMN_UL_EFF_CQI_1 },
856  {RGSCH_CMN_QM_CQI_2,RGSCH_CMN_UL_EFF_CQI_2 },
857  {RGSCH_CMN_QM_CQI_3,RGSCH_CMN_UL_EFF_CQI_3 },
858  {RGSCH_CMN_QM_CQI_4,RGSCH_CMN_UL_EFF_CQI_4 },
859  {RGSCH_CMN_QM_CQI_5,RGSCH_CMN_UL_EFF_CQI_5 },
860  {RGSCH_CMN_QM_CQI_6,RGSCH_CMN_UL_EFF_CQI_6 },
861  {RGSCH_CMN_QM_CQI_7,RGSCH_CMN_UL_EFF_CQI_7 },
862  {RGSCH_CMN_QM_CQI_8,RGSCH_CMN_UL_EFF_CQI_8 },
863  {RGSCH_CMN_QM_CQI_9,RGSCH_CMN_UL_EFF_CQI_9 },
864  {RGSCH_CMN_QM_CQI_10,RGSCH_CMN_UL_EFF_CQI_10 },
865  {RGSCH_CMN_QM_CQI_11,RGSCH_CMN_UL_EFF_CQI_11 },
866  {RGSCH_CMN_QM_CQI_12,RGSCH_CMN_UL_EFF_CQI_12 },
867  {RGSCH_CMN_QM_CQI_13,RGSCH_CMN_UL_EFF_CQI_13 },
868  {RGSCH_CMN_QM_CQI_14,RGSCH_CMN_UL_EFF_CQI_14 },
869  {RGSCH_CMN_QM_CQI_15,RGSCH_CMN_UL_EFF_CQI_15 },
870 };
871
872 #ifdef RG_UNUSED
873 /* This table maps a (delta_offset * 2 + 2) to a (beta * 8)
874  * where beta is 10^-(delta_offset/10) rounded off to nearest 1/8
875  */
876 PRIVATE U16 rgSchCmnUlBeta8Tbl[29] = {
877    6, RG_SCH_CMN_UL_INVALID_BETA8, 8, 9, 10, 11, 13, 14, 16, 18, 20, 23,
878    25, 28, 32, RG_SCH_CMN_UL_INVALID_BETA8, 40, RG_SCH_CMN_UL_INVALID_BETA8,
879    50, RG_SCH_CMN_UL_INVALID_BETA8, 64, RG_SCH_CMN_UL_INVALID_BETA8, 80,
880    RG_SCH_CMN_UL_INVALID_BETA8, 101, RG_SCH_CMN_UL_INVALID_BETA8, 127,
881    RG_SCH_CMN_UL_INVALID_BETA8, 160
882 };
883 #endif
884
885 /* QCI to SVC priority mapping. Index specifies the Qci*/
886 PRIVATE U8 rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
887
888 /* The configuration is efficiency measured per 1024 REs.  */
889 /* The first element stands for when CQI is not known      */
890 /* This table is used to translate CQI to its corrospoding */
891 /* allocation parameters. These are currently from 36.213  */
892 /* Just this talbe needs to be edited for modifying the    */
893 /* the resource allocation behaviour                       */
894
895 /* ADD CQI to MCS mapping correction
896  * single dimensional array is replaced by 2 dimensions for different CFI*/
897 PRIVATE U16 rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
898     RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI2,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI3};
899
900 PRIVATE U16 rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
901     RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI2, RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI3};
902
903 /* This configuration determines the transalation of a UEs CQI to its    */
904 /* PDCCH coding efficiency. This may be edited based on the installation */
905 PRIVATE U8 rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
906
907 /* Indexed by [DciFrmt].
908  * Considering the following definition in determining the dciFrmt index.
909  * typedef enum
910 {
911    TFU_DCI_FORMAT_0,
912    TFU_DCI_FORMAT_1,
913    TFU_DCI_FORMAT_1A,
914    TFU_DCI_FORMAT_1B,
915    TFU_DCI_FORMAT_1C,
916    TFU_DCI_FORMAT_1D,
917    TFU_DCI_FORMAT_2,
918    TFU_DCI_FORMAT_2A,
919    TFU_DCI_FORMAT_3,
920    TFU_DCI_FORMAT_3A
921 } TfuDciFormat;
922 */
923 PRIVATE U16 rgSchCmnDciFrmtSizes[10];
924
925
926 PRIVATE U16 rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
927
928 #ifdef LTE_TDD
929
930 PUBLIC RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
931    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME},
932    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME},
933    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME},
934    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,   RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME},
935    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME,   RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME},
936    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_DL_SUBFRAME,   RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME},
937    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME}
938 };
939
940 /* SPS_INTG_FIX */
941 #ifdef LTEMAC_SPS
942 PUBLIC U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
943    /* 0 */ 6,
944    /* 1 */ 7,
945    /* 2 */ 8,
946    /* 3 */ 11,
947    /* 4 */ 12,
948    /* 5 */ 13,
949    /* 6 */ 7};
950
951 #endif
952
953
954 /* Special Subframes in OFDM symbols */
955 /* ccpu00134197-MOD-Correct the number of symbols */
956 PUBLIC RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
957         {3,  1, 1, 3,   1, 1},
958         {9,  1, 1, 8,   1, 1},
959         {10, 1, 1, 9,   1, 1},
960         {11, 1, 1, 10,  1, 1},
961         {12, 1, 1, 3,   2, 2},
962         {3,  2, 2, 8,   2, 2},
963         {9,  2, 2, 9,   2, 2},
964         {10, 2, 2, 0,   0, 0},
965         {11, 2, 2, 0,   0, 0}
966 };
967
968 /* PHICH 'm' value Table */
969 PUBLIC RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
970         {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
971         {0, 1, 0, 0, 1, 0, 1, 0, 0, 1},
972         {0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
973         {1, 0, 0, 0, 0, 0, 0, 0, 1, 1},
974         {0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
975         {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
976         {1, 1, 0, 0, 0, 1, 1, 0, 0, 1}
977 };
978
979 /* PHICH 'K' value Table */
980 PUBLIC RgSchTddKPhichTbl rgSchTddKPhichTbl = {
981         {0, 0, 4, 7, 6, 0, 0, 4, 7, 6},
982         {0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
983         {0, 0, 6, 0, 0, 0, 0, 6, 0, 0},
984         {0, 0, 6, 6, 6, 0, 0, 0, 0, 0},
985         {0, 0, 6, 6, 0, 0, 0, 0, 0, 0},
986         {0, 0, 6, 0, 0, 0, 0, 0, 0, 0},
987         {0, 0, 4, 6, 6, 0, 0, 4, 7, 0}
988 };
989
990 /* Uplink association index 'K' value Table */
991 PUBLIC RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
992         {0, 0, 6, 4, 0, 0, 0, 6, 4, 0},
993         {0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
994         {0, 0, 4, 4, 4, 0, 0, 0, 0, 0},
995         {0, 0, 4, 4, 0, 0, 0, 0, 0, 0},
996         {0, 0, 4, 0, 0, 0, 0, 0, 0, 0},
997         {0, 0, 7, 7, 5, 0, 0, 7, 7, 0}
998 };
999
1000
1001 /* PUSCH 'K' value Table */
1002 PUBLIC RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
1003         {4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
1004         {0, 6, 0, 0, 4, 0, 6, 0, 0, 4},
1005         {0, 0, 0, 4, 0, 0, 0, 0, 4, 0},
1006         {4, 0, 0, 0, 0, 0, 0, 0, 4, 4},
1007         {0, 0, 0, 0, 0, 0, 0, 0, 4, 4},
1008         {0, 0, 0, 0, 0, 0, 0, 0, 4, 0},
1009         {7, 7, 0, 0, 0, 7, 7, 0, 0, 5}
1010 };
1011
1012 /* PDSCH to PUCCH Table for DL Harq Feed back. Based on the 
1013    Downlink association set index 'K' table */
1014 PUBLIC U8 rgSchTddPucchTxTbl[7][10] = {
1015         {4,  6,  0, 0, 0, 4, 6, 0, 0,  0},
1016         {7,  6,  0, 0, 4, 7, 6, 0, 0,  4},
1017         {7,  6,  0, 4, 8, 7, 6, 0, 4,  8},
1018         {4,  11, 0, 0, 0, 7, 6, 6, 5,  5},
1019         {12, 11, 0, 0, 8, 7, 7, 6, 5,  4},
1020         {12, 11, 0, 9, 8, 7, 6, 5, 4, 13},
1021         {7,  7,  0, 0, 0, 7, 7, 0, 0,  5}
1022 };
1023
1024 /* Table to fetch the next DL sf idx for applying the 
1025    new CFI. The next Dl sf Idx at which the new CFI 
1026    is applied is always the starting Sf of the next ACK/NACK
1027    Fdbk bundle. 
1028    
1029    Ex: In Cfg-2, sf4 and sf9 are the only subframes at which 
1030        a new ACK/NACK bundle of DL subframes can start
1031        
1032    D  S  U  D  D  D  S  U  D  D  D  S  U  D  D  D  S  U  D  D    
1033                4              9
1034    
1035    dlSf Array for Cfg-2:
1036    sfNum:  0  1  3  4  5  6  8  9  0  1   3  4  5  6  8  9 
1037    sfIdx:  0  1  2  3  4  5  6  7  8  9  10 11 12 12 14 15 
1038     
1039    If CFI changes at sf0,  nearest DL SF bundle >= 4 TTI is sf4
1040    So at sf4 the new CFI can be applied. To arrive at sf4 from
1041    sf0, the sfIdx has to be increased by 3 */  
1042                  
1043 PUBLIC U8 rgSchTddPdcchSfIncTbl[7][10] = {
1044  /* A/N Bundl: 0,1,5,6*/   {2,  1,  0, 0, 0, 2, 1,  0,  0,  0},
1045  /* A/N Bundl: 0,4,5,9*/   {2,  2,  0, 0, 3, 2, 2,  0,  0,  3},
1046  /* A/N Bundl: 4,9*/       {3,  6,  0, 5, 4, 3, 6,  0,  5,  4},
1047  /* A/N Bundl: 1,7,9*/     {4,  3,  0, 0, 0, 4, 5,  4,  6,  5},
1048  /* A/N Bundl: 0,6*/       {4,  3,  0, 0, 6, 5, 4,  7,  6,  5},
1049  /* A/N Bundl: 9*/         {8,  7,  0, 6, 5, 4, 12, 11, 10, 9},
1050  /* A/N Bundl: 0,1,5,6,9*/ {2,  1,  0, 0, 0, 2, 2,  0,  0,  3}
1051 };
1052    
1053
1054 /* combine compilation fixes */
1055 #ifdef LTEMAC_SPS
1056 /* subframe offset values to be used when twoIntervalsConfig is enabled in UL
1057  * SPS for a UE */
1058 PUBLIC RgSchTddSfOffTbl rgSchTddSfOffTbl = {
1059         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0},
1060         {0, 0, 1, -1,  0, 0, 0,  1, -1, 0},
1061         {0, 0, 5,  0,  0, 0, 0, -5,  0, 0},
1062         {0, 0, 1,  1, -2, 0, 0,  0,  0, 0},
1063         {0, 0, 1, -1,  0, 0, 0,  0,  0, 0},
1064         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0},
1065         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0}
1066 };
1067
1068
1069 /* Table to determine when uplink SPS configured grants should
1070  * explicitly be reserved in a subframe. When enries are same
1071  * as that of Msg3SubfrmTbl, indicates competition with msg3.
1072  * As of now, this is same as Msg3SubfrmTbl (leaving out uldlcfg 2),
1073  * except that all 255s are now zeros. */
1074 PUBLIC RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
1075         {0,    0,  0,  6,  8,  0, 0,  0,  6,  8},
1076         {0,    0,  6,  9,  0,  0, 0,  6,  9,  0},
1077         {0,    0,  10,  0,  0,  0, 0,  10,  0,  0},
1078         {0,   0,  0,  0,  8,  0, 7,  7,  14,  0},
1079         {0,   0,  0,  9,  0,  0, 7,  15,  0, 0},
1080         {0,   0,  10,  0,  0,  0, 16,  0, 0, 0},
1081         {0,    0,  0,  0,  8,  0, 0,  0,  9,  0}
1082 };
1083
1084 /* Inverse DL Assoc Set index Table */
1085 PUBLIC RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
1086        {4,  6,  0, 0, 0, 4, 6, 0, 0,  0},
1087        {7,  6,  0, 0, 4, 7, 6, 0, 0,  4},
1088        {7,  6,  0, 4, 8, 7, 6, 0, 4,  8},
1089        {4,  11, 0, 0, 0, 7, 6, 6, 5,  5},
1090        {12, 11, 0, 0, 8, 7, 7, 6, 5,  4},
1091        {12, 11, 0, 9, 8, 7, 6, 5, 4, 13},
1092        {7,  7,  0, 0, 0, 7, 7, 0, 0,  5}
1093 };
1094
1095 #endif /* (LTEMAC_SPS ) */
1096
1097 /* Number of Uplink subframes Table */
1098 PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
1099
1100 /* Downlink HARQ processes Table */
1101 PUBLIC RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
1102
1103 /* Uplink HARQ processes Table */
1104 PUBLIC RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
1105
1106 /* Downlink association index set 'K' value Table */
1107 PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
1108         { {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
1109
1110         { {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
1111
1112         { {0, {0}}, {0, {0}}, {4, {8, 7, 4, 6}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {4, {8, 7, 4, 6}}, {0, {0}}, {0, {0}} },
1113
1114         { {0, {0}}, {0, {0}}, {3, {7, 6, 11}}, {2, {6, 5}}, {2, {5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1115
1116         { {0, {0}}, {0, {0}}, {4, {12, 8, 7, 11}}, {4, {6, 5, 4, 7}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1117
1118         { {0, {0}}, {0, {0}}, {9, {13, 12, 9, 8, 7, 5, 4, 11, 6}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1119
1120         { {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {1, {5}}, {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {0, {0}} }
1121 };
1122
1123  /* ccpu132282-ADD-the table rgSchTddDlAscSetIdxKTbl is rearranged in 
1124   * decreasing order of Km, this is used to calculate the NCE used for 
1125   * calculating N1Pucch Resource for Harq*/
1126 PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
1127         { {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
1128
1129         { {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
1130
1131         { {0, {0}}, {0, {0}}, {4, {8, 7, 6, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {4, {8, 7, 6, 4}}, {0, {0}}, {0, {0}} },
1132
1133         { {0, {0}}, {0, {0}}, {3, {11, 7, 6}}, {2, {6, 5}}, {2, {5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1134
1135         { {0, {0}}, {0, {0}}, {4, {12, 11, 8, 7}}, {4, {7, 6, 5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1136
1137         { {0, {0}}, {0, {0}}, {9, {13, 12, 11, 9, 8, 7, 6, 5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1138
1139         { {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {1, {5}}, {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {0, {0}} }
1140 };
1141
1142 /* Minimum number of Ack/Nack feeback information to be
1143    stored for each UL-DL configuration */
1144 PUBLIC RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
1145
1146 /* Uplink switch points and number of UL subframes Table */
1147 PUBLIC RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
1148      {2,3,3}, {2,2,2}, {2,1,1}, {1,3,0}, {1,2,0}, {1,1,0}, {2,3,2}
1149 };
1150
1151 /* Uplink switch points and number of DL subframes Table */
1152 PUBLIC RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
1153      {2,2,2}, {2,3,3}, {2,4,4}, {1,7,0}, {1,8,0}, {1,9,0}, {2,2,3}
1154 };
1155
1156 /* Number of UL subframes present before a particular subframe */
1157 PUBLIC RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
1158         {0, 0, 1, 2, 3, 3, 3, 4, 5, 6},
1159         {0, 0, 1, 2, 2, 2, 2, 3, 4, 4},
1160         {0, 0, 1, 1, 1, 1, 1, 2, 2, 2},
1161         {0, 0, 1, 2, 3, 3, 3, 3, 3, 3},
1162         {0, 0, 1, 2, 2, 2, 2, 2, 2, 2},
1163         {0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
1164         {0, 0, 1, 2, 3, 3, 3, 4, 5, 5}
1165 };
1166
1167 /* Number of DL subframes present till a particular subframe */
1168 PUBLIC RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
1169         {1, 2, 2, 2, 2, 3, 4, 4, 4, 4},
1170         {1, 2, 2, 2, 3, 4, 5, 5, 5, 6},
1171         {1, 2, 2, 3, 4, 5, 6, 6, 7, 8},
1172         {1, 2, 2, 2, 2, 3, 4, 5, 6, 7},
1173         {1, 2, 2, 2, 3, 4, 5, 6, 7, 8},
1174         {1, 2, 2, 3, 4, 5, 6, 7, 8, 9},
1175         {1, 2, 2, 2, 2, 3, 4, 4, 4, 5}
1176 };
1177
1178
1179 /* Nearest possible UL subframe Index from UL subframe
1180  * DL Index < UL Index */
1181 PUBLIC RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
1182         {0, 1, 1, 1, 1, 5, 6, 6, 6, 6},
1183         {0, 1, 1, 1, 4, 5, 6, 6, 6, 9},
1184         {0, 1, 1, 3, 4, 5, 6, 6, 8, 9},
1185         {0, 1, 1, 1, 1, 5, 6, 7, 8, 9},
1186         {0, 1, 1, 1, 4, 5, 6, 7, 8, 9},
1187         {0, 1, 1, 3, 4, 5, 6, 7, 8, 9},
1188         {0, 1, 1, 1, 1, 5, 6, 6, 6, 9}
1189 };
1190
1191 /* Nearest possible DL subframe Index from UL subframe
1192  * DL Index > UL Index
1193  * 10 represents Next SFN low DL Idx */
1194 PUBLIC RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
1195         {0, 1, 5, 5, 5, 5, 6, 10, 10, 10},
1196         {0, 1, 4, 4, 4, 5, 6,  9,  9,  9},
1197         {0, 1, 3, 3, 4, 5, 6,  8,  8,  9},
1198         {0, 1, 5, 5, 5, 5, 6,  7,  8,  9},
1199         {0, 1, 4, 4, 4, 5, 6,  7,  8,  9},
1200         {0, 1, 3, 3, 4, 5, 6,  7,  8,  9},
1201         {0, 1, 5, 5, 5, 5, 6,  9,  9,  9}
1202 };
1203
1204 /* RACH Message3 related information */
1205 PUBLIC RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
1206         {7,      6,  255,  255,  255,  7,   6,  255,  255,  255},
1207         {7,      6,  255,  255,    8,  7,   6,  255,  255,    8},
1208         {7,      6,  255,  9,      8,  7,   6,  255,    9,    8},
1209         {12,    11,  255,  255,  255,  7,   6,    6,    6,   13},
1210         {12,    11,  255,  255,    8,  7,   6,    6,   14,   13},
1211         {12,    11,  255,    9,    8,  7,   6,   15,   14,   13},
1212         {7,      6,  255,  255,  255,  7,   6,  255,  255,    8}
1213 };
1214
1215 /* ccpu00132341-DEL Removed rgSchTddRlsDlSubfrmTbl and used Kset table for 
1216  * releasing DL HARQs */
1217
1218 /* DwPTS Scheduling Changes Start */
1219 /* Provides the number of Cell Reference Signals in DwPTS
1220  * region per RB */
1221 PRIVATE U8  rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
1222            {4, 8,  16}, /* Spl Sf cfg 1,2,3,6,7,8 */
1223            {6, 12, 20}, /* Spl Sf cfg 4 */
1224 };
1225
1226 PRIVATE S8  rgSchCmnSplSfDeltaItbs[9] = RG_SCH_DWPTS_ITBS_ADJ;
1227 /* DwPTS Scheduling Changes End */
1228 #endif
1229
1230
1231 PRIVATE U32 rgSchCmnBsrTbl[64] = {
1232    0, 10, 12, 14, 17, 19, 22, 26,
1233    31, 36, 42, 49, 57, 67, 78, 91,
1234    107, 125, 146, 171, 200, 234, 274, 321,
1235    376, 440, 515, 603, 706, 826, 967, 1132,
1236    1326, 1552, 1817, 2127, 2490, 2915, 3413, 3995,
1237    4677, 5476, 6411, 7505, 8787, 10287, 12043, 14099,
1238    16507, 19325, 22624, 26487, 31009, 36304, 42502, 49759,
1239    58255, 68201, 79846, 93479, 109439, 128125, 150000, 220000
1240 };
1241
1242 PRIVATE U32 rgSchCmnExtBsrTbl[64] = {
1243    0, 10, 13, 16, 19, 23, 29, 35,
1244    43, 53, 65, 80, 98, 120, 147, 181,
1245    223, 274, 337, 414, 509, 625, 769, 945,
1246    1162, 1429, 1757, 2161, 2657, 3267, 4017, 4940,
1247    6074, 7469, 9185, 11294, 13888, 17077, 20999, 25822,
1248    31752, 39045, 48012, 59039, 72598, 89272, 109774, 134986,
1249    165989, 204111, 250990, 308634, 379519, 466683, 573866, 705666,
1250    867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
1251 };
1252
1253 #ifdef UNUSE_FUN
1254 PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
1255 #endif
1256 PUBLIC U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
1257
1258 PUBLIC RgSchTbSzTbl rgTbSzTbl = {
1259  {
1260    {16,    32,    56,    88,    120,   152,   176,   208,   224,   256,   288,   328,   344,   376,   392,   424,   456,   488,   504,   536,   568,   600,   616,   648,   680,   712,   744,   776,   776,   808,   840,   872,   904,   936,   968,   1000,  1032,  1032,  1064,  1096,  1128,  1160,  1192,  1224,  1256,  1256,  1288,  1320,  1352,  1384,  1416,  1416,  1480,  1480,  1544,  1544,  1608,  1608,  1608,  1672,  1672,  1736,  1736,  1800,  1800,  1800,  1864,  1864,  1928,  1928,  1992,  1992,  2024,  2088,  2088,  2088,  2152,  2152,  2216,  2216,  2280,  2280,  2280,  2344,  2344,  2408,  2408,  2472,  2472,  2536,  2536,  2536,  2600,  2600,  2664,  2664,  2728,  2728,  2728,  2792,  2792,  2856,  2856,  2856,  2984,  2984,  2984,  2984,  2984,  3112},
1261    {24,    56,    88,    144,   176,   208,   224,   256,   328,   344,   376,   424,   456,   488,   520,   568,   600,   632,   680,   712,   744,   776,   808,   872,   904,   936,   968,   1000,  1032,  1064,  1128,  1160,  1192,  1224,  1256,  1288,  1352,  1384,  1416,  1416,  1480,  1544,  1544,  1608,  1608,  1672,  1736,  1736,  1800,  1800,  1864,  1864,  1928,  1992,  1992,  2024,  2088,  2088,  2152,  2152,  2216,  2280,  2280,  2344,  2344,  2408,  2472,  2472,  2536,  2536,  2600,  2600,  2664,  2728,  2728,  2792,  2792,  2856,  2856,  2856,  2984,  2984,  2984,  3112,  3112,  3112,  3240,  3240,  3240,  3240,  3368,  3368,  3368,  3496,  3496,  3496,  3496,  3624,  3624,  3624,  3752,  3752,  3752,  3752,  3880,  3880,  3880,  4008,  4008,  4008},
1262    {32,    72,    144,   176,   208,   256,   296,   328,   376,   424,   472,   520,   568,   616,   648,   696,   744,   776,   840,   872,   936,   968,   1000,  1064,  1096,  1160,  1192,  1256,  1288,  1320,  1384,  1416,  1480,  1544,  1544,  1608,  1672,  1672,  1736,  1800,  1800,  1864,  1928,  1992,  2024,  2088,  2088,  2152,  2216,  2216,  2280,  2344,  2344,  2408,  2472,  2536,  2536,  2600,  2664,  2664,  2728,  2792,  2856,  2856,  2856,  2984,  2984,  3112,  3112,  3112,  3240,  3240,  3240,  3368,  3368,  3368,  3496,  3496,  3496,  3624,  3624,  3624,  3752,  3752,  3880,  3880,  3880,  4008,  4008,  4008,  4136,  4136,  4136,  4264,  4264,  4264,  4392,  4392,  4392,  4584,  4584,  4584,  4584,  4584,  4776,  4776,  4776,  4776,  4968,  4968},
1263    {40,    104,   176,   208,   256,   328,   392,   440,   504,   568,   616,   680,   744,   808,   872,   904,   968,   1032,  1096,  1160,  1224,  1256,  1320,  1384,  1416,  1480,  1544,  1608,  1672,  1736,  1800,  1864,  1928,  1992,  2024,  2088,  2152,  2216,  2280,  2344,  2408,  2472,  2536,  2536,  2600,  2664,  2728,  2792,  2856,  2856,  2984,  2984,  3112,  3112,  3240,  3240,  3368,  3368,  3496,  3496,  3624,  3624,  3624,  3752,  3752,  3880,  3880,  4008,  4008,  4136,  4136,  4264,  4264,  4392,  4392,  4392,  4584,  4584,  4584,  4776,  4776,  4776,  4776,  4968,  4968,  4968,  5160,  5160,  5160,  5352,  5352,  5352,  5352,  5544,  5544,  5544,  5736,  5736,  5736,  5736,  5992,  5992,  5992,  5992,  6200,  6200,  6200,  6200,  6456,  6456},
1264    {56,    120,   208,   256,   328,   408,   488,   552,   632,   696,   776,   840,   904,   1000,  1064,  1128,  1192,  1288,  1352,  1416,  1480,  1544,  1608,  1736,  1800,  1864,  1928,  1992,  2088,  2152,  2216,  2280,  2344,  2408,  2472,  2600,  2664,  2728,  2792,  2856,  2984,  2984,  3112,  3112,  3240,  3240,  3368,  3496,  3496,  3624,  3624,  3752,  3752,  3880,  4008,  4008,  4136,  4136,  4264,  4264,  4392,  4392,  4584,  4584,  4584,  4776,  4776,  4968,  4968,  4968,  5160,  5160,  5160,  5352,  5352,  5544,  5544,  5544,  5736,  5736,  5736,  5992,  5992,  5992,  5992,  6200,  6200,  6200,  6456,  6456,  6456,  6456,  6712,  6712,  6712,  6968,  6968,  6968,  6968,  7224,  7224,  7224,  7480,  7480,  7480,  7480,  7736,  7736,  7736,  7992},
1265    {72,    144,   224,   328,   424,   504,   600,   680,   776,   872,   968,   1032,  1128,  1224,  1320,  1384,  1480,  1544,  1672,  1736,  1864,  1928,  2024,  2088,  2216,  2280,  2344,  2472,  2536,  2664,  2728,  2792,  2856,  2984,  3112,  3112,  3240,  3368,  3496,  3496,  3624,  3752,  3752,  3880,  4008,  4008,  4136,  4264,  4392,  4392,  4584,  4584,  4776,  4776,  4776,  4968,  4968,  5160,  5160,  5352,  5352,  5544,  5544,  5736,  5736,  5736,  5992,  5992,  5992,  6200,  6200,  6200,  6456,  6456,  6712,  6712,  6712,  6968,  6968,  6968,  7224,  7224,  7224,  7480,  7480,  7480,  7736,  7736,  7736,  7992,  7992,  7992,  8248,  8248,  8248,  8504,  8504,  8760,  8760,  8760,  8760,  9144,  9144,  9144,  9144,  9528,  9528,  9528,  9528,  9528},
1266    {328,    176,   256,   392,   504,   600,   712,   808,   936,   1032,  1128,  1224,  1352,  1480,  1544,  1672,  1736,  1864,  1992,  2088,  2216,  2280,  2408,  2472,  2600,  2728,  2792,  2984,  2984,  3112,  3240,  3368,  3496,  3496,  3624,  3752,  3880,  4008,  4136,  4136,  4264,  4392,  4584,  4584,  4776,  4776,  4968,  4968,  5160,  5160,  5352,  5352,  5544,  5736,  5736,  5992,  5992,  5992,  6200,  6200,  6456,  6456,  6456,  6712,  6712,  6968,  6968,  6968,  7224,  7224,  7480,  7480,  7736,  7736,  7736,  7992,  7992,  8248,  8248,  8248,  8504,  8504,  8760,  8760,  8760,  9144,  9144,  9144,  9144,  9528,  9528,  9528,  9528,  9912,  9912,  9912,  10296, 10296, 10296, 10296, 10680, 10680, 10680, 10680, 11064, 11064, 11064, 11448, 11448, 11448},
1267    {104,   224,   328,   472,   584,   712,   840,   968,   1096,  1224,  1320,  1480,  1608,  1672,  1800,  1928,  2088,  2216,  2344,  2472,  2536,  2664,  2792,  2984,  3112,  3240,  3368,  3368,  3496,  3624,  3752,  3880,  4008,  4136,  4264,  4392,  4584,  4584,  4776,  4968,  4968,  5160,  5352,  5352,  5544,  5736,  5736,  5992,  5992,  6200,  6200,  6456,  6456,  6712,  6712,  6712,  6968,  6968,  7224,  7224,  7480,  7480,  7736,  7736,  7992,  7992,  8248,  8248,  8504,  8504,  8760,  8760,  8760,  9144,  9144,  9144,  9528,  9528,  9528,  9912,  9912,  9912,  10296, 10296, 10296, 10680, 10680, 10680, 11064, 11064, 11064, 11448, 11448, 11448, 11448, 11832, 11832, 11832, 12216, 12216, 12216, 12576, 12576, 12576, 12960, 12960, 12960, 12960, 13536, 13536},
1268    {120,   256,   392,   536,   680,   808,   968,   1096,  1256,  1384,  1544,  1672,  1800,  1928,  2088,  2216,  2344,  2536,  2664,  2792,  2984,  3112,  3240,  3368,  3496,  3624,  3752,  3880,  4008,  4264,  4392,  4584,  4584,  4776,  4968,  4968,  5160,  5352,  5544,  5544,  5736,  5992,  5992,  6200,  6200,  6456,  6456,  6712,  6968,  6968,  7224,  7224,  7480,  7480,  7736,  7736,  7992,  7992,  8248,  8504,  8504,  8760,  8760,  9144,  9144,  9144,  9528,  9528,  9528,  9912,  9912,  9912,  10296, 10296, 10680, 10680, 10680, 11064, 11064, 11064, 11448, 11448, 11448, 11832, 11832, 12216, 12216, 12216, 12576, 12576, 12576, 12960, 12960, 12960, 13536, 13536, 13536, 13536, 14112, 14112, 14112, 14112, 14688, 14688, 14688, 14688, 15264, 15264, 15264, 15264},
1269    {136,   296,   456,   616,   776,   936,   1096,  1256,  1416,  1544,  1736,  1864,  2024,  2216,  2344,  2536,  2664,  2856,  2984,  3112,  3368,  3496,  3624,  3752,  4008,  4136,  4264,  4392,  4584,  4776,  4968,  5160,  5160,  5352,  5544,  5736,  5736,  5992,  6200,  6200,  6456,  6712,  6712,  6968,  6968,  7224,  7480,  7480,  7736,  7992,  7992,  8248,  8248,  8504,  8760,  8760,  9144,  9144,  9144,  9528,  9528,  9912,  9912,  10296, 10296, 10296, 10680, 10680, 11064, 11064, 11064, 11448, 11448, 11832, 11832, 11832, 12216, 12216, 12576, 12576, 12960, 12960, 12960, 13536, 13536, 13536, 13536, 14112, 14112, 14112, 14112, 14688, 14688, 14688, 15264, 15264, 15264, 15264, 15840, 15840, 15840, 16416, 16416, 16416, 16416, 16992, 16992, 16992, 16992, 17568},
1270    {144,   328,   504,   680,   872,   1032,  1224,  1384,  1544,  1736,  1928,  2088,  2280,  2472,  2664,  2792,  2984,  3112,  3368,  3496,  3752,  3880,  4008,  4264,  4392,  4584,  4776,  4968,  5160,  5352,  5544,  5736,  5736,  5992,  6200,  6200,  6456,  6712,  6712,  6968,  7224,  7480,  7480,  7736,  7992,  7992,  8248,  8504,  8504,  8760,  9144,  9144,  9144,  9528,  9528,  9912,  9912,  10296, 10296, 10680, 10680, 11064, 11064, 11448, 11448, 11448, 11832, 11832, 12216, 12216, 12576, 12576, 12960, 12960, 12960, 13536, 13536, 13536, 14112, 14112, 14112, 14688, 14688, 14688, 14688, 15264, 15264, 15264, 15840, 15840, 15840, 16416, 16416, 16416, 16992, 16992, 16992, 16992, 17568, 17568, 17568, 18336, 18336, 18336, 18336, 18336, 19080, 19080, 19080, 19080},
1271    {176,   376,   584,   776,   1000,  1192,  1384,  1608,  1800,  2024,  2216,  2408,  2600,  2792,  2984,  3240,  3496,  3624,  3880,  4008,  4264,  4392,  4584,  4776,  4968,  5352,  5544,  5736,  5992,  5992,  6200,  6456,  6712,  6968,  6968,  7224,  7480,  7736,  7736,  7992,  8248,  8504,  8760,  8760,  9144,  9144,  9528,  9528,  9912,  9912,  10296, 10680, 10680, 11064, 11064, 11448, 11448, 11832, 11832, 12216, 12216, 12576, 12576, 12960, 12960, 13536, 13536, 13536, 14112, 14112, 14112, 14688, 14688, 14688, 15264, 15264, 15840, 15840, 15840, 16416, 16416, 16416, 16992, 16992, 16992, 17568, 17568, 17568, 18336, 18336, 18336, 18336, 19080, 19080, 19080, 19080, 19848, 19848, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 21384, 21384, 22152, 22152, 22152},
1272    {208,   440,   680,   904,   1128,  1352,  1608,  1800,  2024,  2280,  2472,  2728,  2984,  3240,  3368,  3624,  3880,  4136,  4392,  4584,  4776,  4968,  5352,  5544,  5736,  5992,  6200,  6456,  6712,  6712,  6968,  7224,  7480,  7736,  7992,  8248,  8504,  8760,  8760,  9144,  9528,  9528,  9912,  9912,  10296, 10680, 10680, 11064, 11064, 11448, 11832, 11832, 12216, 12216, 12576, 12576, 12960, 12960, 13536, 13536, 14112, 14112, 14112, 14688, 14688, 15264, 15264, 15264, 15840, 15840, 16416, 16416, 16416, 16992, 16992, 17568, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19080, 19080, 19848, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 21384, 21384, 22152, 22152, 22152, 22920, 22920, 22920, 23688, 23688, 23688, 23688, 24496, 24496, 24496, 24496, 25456},
1273    {224,   488,   744,   1000,  1256,  1544,  1800,  2024,  2280,  2536,  2856,  3112,  3368,  3624,  3880,  4136,  4392,  4584,  4968,  5160,  5352,  5736,  5992,  6200,  6456,  6712,  6968,  7224,  7480,  7736,  7992,  8248,  8504,  8760,  9144,  9144,  9528,  9912,  9912,  10296, 10680, 10680, 11064, 11448, 11448, 11832, 12216, 12216, 12576, 12960, 12960, 13536, 13536, 14112, 14112, 14688, 14688, 14688, 15264, 15264, 15840, 15840, 16416, 16416, 16992, 16992, 16992, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19080, 19848, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 21384, 22152, 22152, 22152, 22920, 22920, 22920, 23688, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 25456, 25456, 26416, 26416, 26416, 26416, 27376, 27376, 27376, 27376, 28336, 28336},
1274    {256,   552,   840,   1128,  1416,  1736,  1992,  2280,  2600,  2856,  3112,  3496,  3752,  4008,  4264,  4584,  4968,  5160,  5544,  5736,  5992,  6200,  6456,  6968,  7224,  7480,  7736,  7992,  8248,  8504,  8760,  9144,  9528,  9912,  9912,  10296, 10680, 11064, 11064, 11448, 11832, 12216, 12216, 12576, 12960, 12960, 13536, 13536, 14112, 14112, 14688, 14688, 15264, 15264, 15840, 15840, 16416, 16416, 16992, 16992, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19848, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 22152, 22152, 22152, 22920, 22920, 22920, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 25456, 25456, 26416, 26416, 26416, 27376, 27376, 27376, 28336, 28336, 28336, 28336, 29296, 29296, 29296, 29296, 30576, 30576, 30576, 30576, 31704, 31704},
1275    {280,   600,   904,   1224,  1544,  1800,  2152,  2472,  2728,  3112,  3368,  3624,  4008,  4264,  4584,  4968,  5160,  5544,  5736,  6200,  6456,  6712,  6968,  7224,  7736,  7992,  8248,  8504,  8760,  9144,  9528,  9912,  10296, 10296, 10680, 11064, 11448, 11832, 11832, 12216, 12576, 12960, 12960, 13536, 13536, 14112, 14688, 14688, 15264, 15264, 15840, 15840, 16416, 16416, 16992, 16992, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 22152, 22152, 22152, 22920, 22920, 23688, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 25456, 26416, 26416, 26416, 27376, 27376, 27376, 28336, 28336, 28336, 29296, 29296, 29296, 29296, 30576, 30576, 30576, 30576, 31704, 31704, 31704, 31704, 32856, 32856, 32856, 34008, 34008},
1276    {328,   632,   968,   1288,  1608,  1928,  2280,  2600,  2984,  3240,  3624,  3880,  4264,  4584,  4968,  5160,  5544,  5992,  6200,  6456,  6712,  7224,  7480,  7736,  7992,  8504,  8760,  9144,  9528,  9912,  9912,  10296, 10680, 11064, 11448, 11832, 12216, 12216, 12576, 12960, 13536, 13536, 14112, 14112, 14688, 14688, 15264, 15840, 15840, 16416, 16416, 16992, 16992, 17568, 17568, 18336, 18336, 19080, 19080, 19848, 19848, 19848, 20616, 20616, 21384, 21384, 22152, 22152, 22152, 22920, 22920, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 25456, 26416, 26416, 26416, 27376, 27376, 27376, 28336, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 30576, 30576, 31704, 31704, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 34008, 34008, 35160, 35160, 35160, 35160},
1277    {336,   696,   1064,  1416,  1800,  2152,  2536,  2856,  3240,  3624,  4008,  4392,  4776,  5160,  5352,  5736,  6200,  6456,  6712,  7224,  7480,  7992,  8248,  8760,  9144,  9528,  9912,  10296, 10296, 10680, 11064, 11448, 11832, 12216, 12576, 12960, 13536, 13536, 14112, 14688, 14688, 15264, 15264, 15840, 16416, 16416, 16992, 17568, 17568, 18336, 18336, 19080, 19080, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 22152, 22152, 22920, 22920, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 26416, 26416, 26416, 27376, 27376, 27376, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 35160, 35160, 36696, 36696, 36696, 36696, 37888, 37888, 37888, 39232, 39232, 39232, 39232},
1278    {376,   776,   1160,  1544,  1992,  2344,  2792,  3112,  3624,  4008,  4392,  4776,  5160,  5544,  5992,  6200,  6712,  7224,  7480,  7992,  8248,  8760,  9144,  9528,  9912,  10296, 10680, 11064, 11448, 11832, 12216, 12576, 12960, 13536, 14112, 14112, 14688, 15264, 15264, 15840, 16416, 16416, 16992, 17568, 17568, 18336, 18336, 19080, 19080, 19848, 19848, 20616, 21384, 21384, 22152, 22152, 22920, 22920, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 26416, 26416, 27376, 27376, 27376, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 40576, 42368, 42368, 42368, 42368, 43816, 43816},
1279    {408,   840,   1288,  1736,  2152,  2600,  2984,  3496,  3880,  4264,  4776,  5160,  5544,  5992,  6456,  6968,  7224,  7736,  8248,  8504,  9144,  9528,  9912,  10296, 10680, 11064, 11448, 12216, 12576, 12960, 13536, 13536, 14112, 14688, 15264, 15264, 15840, 16416, 16992, 16992, 17568, 18336, 18336, 19080, 19080, 19848, 20616, 20616, 21384, 21384, 22152, 22152, 22920, 22920, 23688, 24496, 24496, 25456, 25456, 25456, 26416, 26416, 27376, 27376, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 30576, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 40576, 42368, 42368, 42368, 43816, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 46888},
1280    {440,   904,   1384,  1864,  2344,  2792,  3240,  3752,  4136,  4584,  5160,  5544,  5992,  6456,  6968,  7480,  7992,  8248,  8760,  9144,  9912,  10296, 10680, 11064, 11448, 12216, 12576, 12960, 13536, 14112, 14688, 14688, 15264, 15840, 16416, 16992, 16992, 17568, 18336, 18336, 19080, 19848, 19848, 20616, 20616, 21384, 22152, 22152, 22920, 22920, 23688, 24496, 24496, 25456, 25456, 26416, 26416, 27376, 27376, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 46888, 48936, 48936, 48936, 48936, 48936, 51024, 51024, 51024},
1281    {488,   1000,  1480,  1992,  2472,  2984,  3496,  4008,  4584,  4968,  5544,  5992,  6456,  6968,  7480,  7992,  8504,  9144,  9528,  9912,  10680, 11064, 11448, 12216, 12576, 12960, 13536, 14112, 14688, 15264, 15840, 15840, 16416, 16992, 17568, 18336, 18336, 19080, 19848, 19848, 20616, 21384, 21384, 22152, 22920, 22920, 23688, 24496, 24496, 25456, 25456, 26416, 26416, 27376, 27376, 28336, 28336, 29296, 29296, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 46888, 48936, 48936, 48936, 48936, 51024, 51024, 51024, 51024, 52752, 52752, 52752, 52752, 55056, 55056, 55056},
1282    {520,   1064,  1608,  2152,  2664,  3240,  3752,  4264,  4776,  5352,  5992,  6456,  6968,  7480,  7992,  8504,  9144,  9528,  10296, 10680, 11448, 11832, 12576, 12960, 13536, 14112, 14688, 15264, 15840, 16416, 16992, 16992, 17568, 18336, 19080, 19080, 19848, 20616, 21384, 21384, 22152, 22920, 22920, 23688, 24496, 24496, 25456, 25456, 26416, 27376, 27376, 28336, 28336, 29296, 29296, 30576, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 48936, 48936, 48936, 48936, 51024, 51024, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 55056, 57336, 57336, 57336, 57336, 59256, 59256, 59256},
1283    {552,   1128,  1736,  2280,  2856,  3496,  4008,  4584,  5160,  5736,  6200,  6968,  7480,  7992,  8504,  9144,  9912,  10296, 11064, 11448, 12216, 12576, 12960, 13536, 14112, 14688, 15264, 15840, 16416, 16992, 17568, 18336, 19080, 19848, 19848, 20616, 21384, 22152, 22152, 22920, 23688, 24496, 24496, 25456, 25456, 26416, 27376, 27376, 28336, 28336, 29296, 29296, 30576, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 36696, 36696, 37888, 37888, 37888, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 55056, 57336, 57336, 57336, 57336, 59256, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776},
1284    {584,   1192,  1800,  2408,  2984,  3624,  4264,  4968,  5544,  5992,  6712,  7224,  7992,  8504,  9144,  9912,  10296, 11064, 11448, 12216, 12960, 13536, 14112, 14688, 15264, 15840, 16416, 16992, 17568, 18336, 19080, 19848, 19848, 20616, 21384, 22152, 22920, 22920, 23688, 24496, 25456, 25456, 26416, 26416, 27376, 28336, 28336, 29296, 29296, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 39232, 39232, 40576, 40576, 42368, 42368, 42368, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 52752, 52752, 52752, 52752, 55056, 55056, 55056, 57336, 57336, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776, 63776, 63776, 63776, 66592, 66592, 66592, 66592},
1285    {616,   1256,  1864,  2536,  3112,  3752,  4392,  5160,  5736,  6200,  6968,  7480,  8248,  8760,  9528,  10296, 10680, 11448, 12216, 12576, 13536, 14112, 14688, 15264, 15840, 16416, 16992, 17568, 18336, 19080, 19848, 20616, 20616, 21384, 22152, 22920, 23688, 24496, 24496, 25456, 26416, 26416, 27376, 28336, 28336, 29296, 29296, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 36696, 36696, 37888, 37888, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 46888, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 55056, 57336, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776, 63776, 63776, 63776, 66592, 66592, 66592, 66592, 68808, 68808, 68808, 71112},
1286    {712,   1480,  2216,  2984,  3752,  4392,  5160,  5992,  6712,  7480,  8248,  8760,  9528,  10296, 11064, 11832, 12576, 13536, 14112, 14688, 15264, 16416, 16992, 17568, 18336, 19080, 19848, 20616, 21384, 22152, 22920, 23688, 24496, 25456, 25456, 26416, 27376, 28336, 29296, 29296, 30576, 30576, 31704, 32856, 32856, 34008, 35160, 35160, 36696, 36696, 37888, 37888, 39232, 40576, 40576, 40576, 42368, 42368, 43816, 43816, 45352, 45352, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 55056, 57336, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 63776, 63776, 63776, 66592, 66592, 66592, 68808, 68808, 68808, 71112, 71112, 71112, 73712, 73712, 75376, 75376, 75376, 75376, 75376, 75376, 75376, 75376, 75376, 75376, 75376}
1287  },
1288  {
1289    {32,    88,    152,   208,   256,   328,   376,   424,   488,   536,   600,   648,   712,   776,   808,   872,   936,   1000,  1032,  1096,  1160,  1224,  1256,  1320,  1384,  1416,  1480,  1544,  1608,  1672,  1736,  1800,  1800,  1864,  1928,  1992,  2088,  2088,  2152,  2216,  2280,  2344,  2408,  2472,  2536,  2536,  2600,  2664,  2728,  2792,  2856,  2856,  2984,  2984,  3112,  3112,  3240,  3240,  3240,  3368,  3368,  3496,  3496,  3624,  3624,  3624,  3752,  3752,  3880,  3880,  4008,  4008,  4008,  4136,  4136,  4136,  4264,  4264,  4392,  4392,  4584,  4584,  4584,  4776,  4776,  4776,  4776,  4968,  4968,  5160,  5160,  5160,  5160,  5160,  5352,  5352,  5544,  5544,  5544,  5544,  5544,  5736,  5736,  5736,  5992,  5992,  5992,  5992,  5992,  6200},
1290    {56,    144,   208,   256,   344,   424,   488,   568,   632,   712,   776,   872,   936,   1000,  1064,  1160,  1224,  1288,  1384,  1416,  1544,  1608,  1672,  1736,  1800,  1864,  1992,  2024,  2088,  2152,  2280,  2344,  2408,  2472,  2536,  2600,  2728,  2792,  2856,  2856,  2984,  3112,  3112,  3240,  3240,  3368,  3496,  3496,  3624,  3624,  3752,  3752,  3880,  4008,  4008,  4008,  4136,  4136,  4264,  4264,  4392,  4584,  4584,  4776,  4776,  4776,  4968,  4968,  5160,  5160,  5160,  5160,  5352,  5544,  5544,  5544,  5544,  5736,  5736,  5736,  5992,  5992,  5992,  6200,  6200,  6200,  6456,  6456,  6456,  6456,  6712,  6712,  6712,  6968,  6968,  6968,  6968,  7224,  7224,  7224,  7480,  7480,  7480,  7480,  7736,  7736,  7736,  7992,  7992,  7992},
1291    {72,    176,   256,   328,   424,   520,   616,   696,   776,   872,   968,   1064,  1160,  1256,  1320,  1416,  1544,  1608,  1672,  1800,  1864,  1992,  2088,  2152,  2216,  2344,  2408,  2536,  2600,  2664,  2792,  2856,  2984,  3112,  3112,  3240,  3368,  3368,  3496,  3624,  3624,  3752,  3880,  4008,  4008,  4136,  4264,  4264,  4392,  4584,  4584,  4584,  4776,  4776,  4968,  5160,  5160,  5160,  5352,  5352,  5544,  5544,  5736,  5736,  5736,  5992,  5992,  6200,  6200,  6200,  6456,  6456,  6456,  6712,  6712,  6712,  6968,  6968,  6968,  7224,  7224,  7224,  7480,  7480,  7736,  7736,  7736,  7992,  7992,  7992,  8248,  8248,  8248,  8504,  8504,  8504,  8760,  8760,  8760,  9144,  9144,  9144,  9144,  9144,  9528,  9528,  9528,  9528,  9912,  9912},
1292    {104,   208,   328,   440,   568,   680,   808,   904,   1032,  1160,  1256,  1384,  1480,  1608,  1736,  1864,  1992,  2088,  2216,  2344,  2472,  2536,  2664,  2792,  2856,  2984,  3112,  3240,  3368,  3496,  3624,  3752,  3880,  4008,  4136,  4264,  4392,  4392,  4584,  4776,  4776,  4968,  4968,  5160,  5352,  5352,  5544,  5544,  5736,  5736,  5992,  5992,  6200,  6200,  6456,  6456,  6712,  6712,  6968,  6968,  7224,  7224,  7224,  7480,  7480,  7736,  7736,  7992,  7992,  8248,  8248,  8504,  8504,  8760,  8760,  8760,  9144,  9144,  9144,  9528,  9528,  9528,  9528,  9912,  9912,  9912,  10296, 10296, 10296, 10680, 10680, 10680, 10680, 11064, 11064, 11064, 11448, 11448, 11448, 11448, 11832, 11832, 11832, 11832, 12576, 12576, 12576, 12576, 12960, 12960},
1293    {120,   256,   408,   552,   696,   840,   1000,  1128,  1288,  1416,  1544,  1736,  1864,  1992,  2152,  2280,  2408,  2600,  2728,  2856,  2984,  3112,  3240,  3496,  3624,  3752,  3880,  4008,  4136,  4264,  4392,  4584,  4776,  4968,  4968,  5160,  5352,  5544,  5544,  5736,  5992,  5992,  6200,  6200,  6456,  6456,  6712,  6968,  6968,  7224,  7224,  7480,  7480,  7736,  7992,  7992,  8248,  8248,  8504,  8504,  8760,  8760,  9144,  9144,  9144,  9528,  9528,  9912,  9912,  9912,  10296, 10296, 10296, 10680, 10680, 11064, 11064, 11064, 11448, 11448, 11448, 11832, 11832, 11832, 11832, 12576, 12576, 12576, 12960, 12960, 12960, 12960, 13536, 13536, 13536, 14112, 14112, 14112, 14112, 14688, 14688, 14688, 14688, 14688, 14688, 14688, 15264, 15264, 15264, 15840},
1294    {144,   328,   504,   680,   872,   1032,  1224,  1384,  1544,  1736,  1928,  2088,  2280,  2472,  2664,  2792,  2984,  3112,  3368,  3496,  3752,  3880,  4008,  4264,  4392,  4584,  4776,  4968,  5160,  5352,  5544,  5736,  5736,  5992,  6200,  6200,  6456,  6712,  6968,  6968,  7224,  7480,  7480,  7736,  7992,  7992,  8248,  8504,  8760,  8760,  9144,  9144,  9528,  9528,  9528,  9912,  9912,  10296, 10296, 10680, 10680, 11064, 11064, 11448, 11448, 11448, 11832, 11832,  11832,  12576,  12576,  12576,  12960, 12960, 13536, 13536, 13536, 14112, 14112, 14112, 14688, 14688, 14688, 14688, 14688, 14688, 15264, 15264, 15264, 15840, 15840, 15840, 16416, 16416, 16416, 16992,  16992,  17568,  17568,  17568,  17568,  18336,  18336,  18336,  18336,  19080,  19080,  19080,  19080,  19080},
1295    {176,   392,   600,   808,   1032,  1224,  1480,  1672,  1864,  2088,  2280,  2472,  2728,  2984,  3112,  3368,  3496,  3752,  4008,  4136,  4392,  4584,  4776,  4968,  5160,  5352,  5736,  5992,  5992,  6200,  6456,  6712,  6968,  6968,  7224,  7480,  7736,  7992,  8248,  8248,  8504,  8760,  9144,  9144,  9528,  9528,  9912,  9912,  10296, 10296, 10680, 10680, 11064, 11448, 11448, 11832, 11832, 11832, 12576, 12576, 12960, 12960, 12960, 13536, 13536, 14112, 14112, 14112,  14688,  14688,  14688,  14688,  15264, 15264, 15264, 15840, 15840, 16416, 16416, 16416, 16992, 16992, 17568, 17568, 17568, 18336, 18336, 18336, 18336, 19080, 19080, 19080, 19080, 19848, 19848, 19848,  20616, 20616, 20616, 20616, 21384, 21384, 21384, 21384, 24264, 24264, 24264, 22920, 22920, 22920},
1296    {224,   472,   712,   968,   1224,  1480,  1672,  1928,  2216,  2472,  2664,  2984,  3240,  3368,  3624,  3880,  4136,  4392,  4584,  4968,  5160,  5352,  5736,  5992,  6200,  6456,  6712,  6712,  6968,  7224,  7480,  7736,  7992,  8248,  8504,  8760,  9144,  9144,  9528,  9912,  9912,  10296, 10680, 10680, 11064, 11448, 11448, 11832, 11832, 12216, 12576, 12576, 12960, 12960, 13536, 13536, 14112, 14112, 14688, 14688, 14688, 14688, 15264, 15264, 15840, 15840, 16416, 16416, 16992, 16992, 17568, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19080, 19848, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 21384, 24264, 24264, 24264, 22920, 22920, 22920, 22920, 23688, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 25456, 25456, 25456, 25456, 25456, 27376, 27376},
1297    {256,   536,   808,   1096,  1384,  1672,  1928,  2216,  2536,  2792,  3112,  3368,  3624,  3880,  4264,  4584,  4776,  4968,  5352,  5544,  5992,  6200,  6456,  6712,  6968,  7224,  7480,  7736,  7992,  8504,  8760,  9144,  9144,  9528,  9912,  9912,  10296, 10680, 11064, 11064, 11448, 11832, 12216, 12216, 12576, 12960, 12960, 13536, 13536, 14112, 14112, 14688, 14688, 15264, 15264, 15264, 15840, 15840, 16416, 16992, 16992, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19080, 19848, 19848, 19848, 20616, 20616, 21384, 21384, 21384, 24264, 24264, 24264, 22920, 22920, 22920, 23688, 23688, 24496, 24496, 24496, 25456, 25456, 25456, 25456, 25456, 25456, 27376, 27376, 27376, 27376, 28336, 28336, 28336, 28336, 29296, 29296, 29296, 29296, 30576, 30576, 30576, 30576},
1298    {296,   616,   936,   1256,  1544,  1864,  2216,  2536,  2856,  3112,  3496,  3752,  4136,  4392,  4776,  5160,  5352,  5736,  5992,  6200,  6712,  6968,  7224,  7480,  7992,  8248,  8504,  8760,  9144,  9528,  9912,  10296, 10296, 10680, 11064, 11448, 11832, 11832, 12216, 12576, 12960, 13536, 13536, 14112, 14112, 14688, 14688, 15264, 15264, 15840, 16416, 16416, 16992, 16992, 17568, 17568, 18336, 18336, 18336, 19080, 19080, 19848, 19848, 20616, 20616, 20616, 21384, 21384, 24264, 24264, 24264, 22920, 22920, 23688, 23688, 23688, 24496, 24496, 25456, 25456, 25456, 25456, 25456, 27376, 27376, 27376, 27376, 28336, 28336, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 32856, 32856, 34008, 34008, 34008, 34008, 35160},
1299    {328,   680,   1032,  1384,  1736,  2088,  2472,  2792,  3112,  3496,  3880,  4264,  4584,  4968,  5352,  5736,  5992,  6200,  6712,  6968,  7480,  7736,  7992,  8504,  8760,  9144,  9528,  9912,  10296, 10680, 11064, 11448, 11448, 11832, 12216, 12576, 12960, 13536, 13536, 14112, 14688, 14688, 15264, 15264, 15840, 16416, 16416, 16992, 16992, 17568, 18336, 18336, 18336, 19080, 19080, 19848, 19848, 20616, 20616, 21384, 21384, 24264, 24264, 22920, 22920, 22920, 23688, 23688, 24496, 24496, 25456, 25456, 25456, 25456, 25456, 27376, 27376, 27376, 28336, 28336, 28336, 29296, 29296, 29296, 29296, 30576, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 36696, 36696, 37888, 37888, 37888, 37888},
1300    {376,   776,   1192,  1608,  2024,  2408,  2792,  3240,  3624,  4008,  4392,  4776,  5352,  5736,  5992,  6456,  6968,  7224,  7736,  7992,  8504,  8760,  9144,  9528,  9912,  10680, 11064, 11448, 11832, 12216, 12576, 12960, 13536, 13536, 14112, 14688, 14688, 15264, 15840, 16416, 16416, 16992, 17568, 17568, 18336, 18336, 19080, 19080, 19848, 19848, 20616, 21384, 21384, 22152, 22152, 22920, 22920, 23688, 23688, 24496, 24496, 25456, 25456, 25456, 25456, 27376, 27376, 27376, 28336, 28336, 28336, 29296, 29296, 29296, 30576, 30576, 31704, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 36696, 37888, 37888, 37888, 37888, 39232, 39232, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 42368, 42368, 43816, 43816, 43816},
1301    {440,   904,   1352,  1800,  2280,  2728,  3240,  3624,  4136,  4584,  4968,  5544,  5992,  6456,  6712,  7224,  7736,  8248,  8760,  9144,  9528,  9912,  10680, 11064, 11448, 11832, 12216, 12576, 12960, 13536, 14112, 14688, 15264, 15264, 15840, 16416, 16992, 17568, 17568, 18336, 19080, 19080, 19848, 19848, 20616, 21384, 21384, 22152, 22152, 22920, 23688, 23688, 24496, 24496, 25456, 25456, 25456, 25456, 27376, 27376, 28336, 28336, 28336, 29296, 29296, 30576, 30576, 30576, 31704, 31704, 32856, 32856, 32856, 34008, 34008, 35160, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 46888, 48936, 48936, 48936, 48936, 51024},
1302    {488,   1000,  1544,  2024,  2536,  3112,  3624,  4136,  4584,  5160,  5736,  6200,  6712,  7224,  7736,  8248,  8760,  9144,  9912,  10296, 10680, 11448, 11832, 12216, 12960, 13536, 14112, 14688, 14688, 15264, 15840, 16416, 16992, 17568, 18336, 18336, 19080, 19848, 19848, 20616, 21384, 21384, 22152, 22920, 22920, 23688, 24496, 24496, 25456, 25456, 26416, 26416, 27376, 27376, 28336, 29296, 29296, 29296, 30576, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 34008, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 51024, 52752, 52752, 52752, 52752, 55056, 55056, 55056, 55056, 57336, 57336},
1303    {552,   1128,  1736,  2280,  2856,  3496,  4008,  4584,  5160,  5736,  6200,  6968,  7480,  7992,  8504,  9144,  9912,  10296, 11064, 11448, 12216, 12576, 12960, 13536, 14112, 14688, 15264, 15840, 16416, 16992, 17568, 18336, 19080, 19848, 19848, 20616, 21384, 22152, 22152, 22920, 23688, 24496, 24496, 25456, 25456, 26416, 27376, 27376, 28336, 28336, 29296, 29296, 30576, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 45352, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 57336, 57336, 57336, 57336, 59256, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776, 63776},
1304    {600,   1224,  1800,  2472,  3112,  3624,  4264,  4968,  5544,  6200,  6712,  7224,  7992,  8504,  9144,  9912,  10296, 11064, 11832, 12216, 12960, 13536, 14112, 14688, 15264, 15840, 16416, 16992, 17568, 18336, 19080, 19848, 20616, 20616, 21384, 22152, 22920, 23688, 23688, 24496, 25456, 25456, 26416, 27376, 27376, 28336, 29296, 29296, 30576, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 36696, 36696, 36696, 37888, 37888, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 46888, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 57336, 57336, 57336, 59256, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776, 63776, 63776, 63776, 66592, 66592, 66592, 68808, 68808},
1305    {632,   1288,  1928,  2600,  3240,  3880,  4584,  5160,  5992,  6456,  7224,  7736,  8504,  9144,  9912,  10296, 11064, 11832, 12216, 12960, 13536, 14112, 14688, 15840, 16416, 16992, 17568, 18336, 19080, 19848, 19848, 20616, 21384, 22152, 22920, 23688, 24496, 24496, 25456, 26416, 26416, 27376, 28336, 28336, 29296, 30576, 30576, 31704, 31704, 32856, 32856, 34008, 34008, 35160, 35160, 36696, 36696, 37888, 37888, 39232, 39232, 39232, 40576, 40576, 42368, 42368, 43816, 43816, 43816, 45352, 45352, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 57336, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776, 63776, 63776, 63776, 66592, 66592, 66592, 68808, 68808, 68808, 68808, 71112, 71112, 71112, 71112},
1306    {696,   1416,  2152,  2856,  3624,  4392,  5160,  5736,  6456,  7224,  7992,  8760,  9528,  10296, 10680, 11448, 12216, 12960, 13536, 14688, 15264, 15840, 16416, 17568, 18336, 19080, 19848, 20616, 20616, 21384, 22152, 22920, 23688, 24496, 25456, 26416, 26416, 27376, 28336, 29296, 29296, 30576, 30576, 31704, 32856, 32856, 34008, 35160, 35160, 36696, 36696, 37888, 37888, 39232, 39232, 40576, 40576, 40576, 42368, 42368, 43816, 43816, 45352, 45352, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 52752, 52752, 52752, 55056, 55056, 55056, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 61664, 63776, 63776, 63776, 66592, 66592, 66592, 68808, 68808, 68808, 71112, 71112, 71112, 71112, 73712, 73712, 73712, 73712, 76208, 76208, 76208, 78704, 78704, 78704, 78704},
1307    {776,   1544,  2344,  3112,  4008,  4776,  5544,  6200,  7224,  7992,  8760,  9528,  10296, 11064, 11832, 12576, 13536, 14112, 15264, 15840, 16416, 17568, 18336, 19080, 19848, 20616, 21384, 22152, 22920, 23688, 24496, 25456, 26416, 27376, 27376, 28336, 29296, 30576, 30576, 31704, 32856, 32856, 34008, 35160, 35160, 36696, 37888, 37888, 39232, 39232, 40576, 40576, 42368, 42368, 43816, 43816, 45352, 45352, 46888, 46888, 48936, 48936, 48936, 51024, 51024, 52752, 52752, 55056, 55056, 55056, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 63776, 63776, 63776, 66592, 66592, 66592, 68808, 68808, 68808, 71112, 71112, 71112, 73712, 73712, 73712, 76208, 76208, 76208, 76208, 78704, 78704, 78704, 81176, 81176, 81176, 81176, 84760, 84760, 84760, 84760, 87936, 87936},
1308    {840,   1736,  2600,  3496,  4264,  5160,  5992,  6968,  7736,  8504,  9528,  10296, 11064, 12216, 12960, 13536, 14688, 15264, 16416, 16992, 18336, 19080, 19848, 20616, 21384, 22152, 22920, 24496, 25456, 25456, 26416, 27376, 28336, 29296, 30576, 30576, 31704, 32856, 34008, 34008, 35160, 36696, 36696, 37888, 39232, 39232, 40576, 40576, 42368, 43816, 43816, 45352, 45352, 46888, 46888, 48936, 48936, 51024, 51024, 51024, 52752, 52752, 55056, 55056, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 61664, 63776, 63776, 66592, 66592, 66592, 68808, 68808, 68808, 71112, 71112, 71112, 73712, 73712, 73712, 76208, 76208, 76208, 78704, 78704, 78704, 81176, 81176, 81176, 81176, 84760, 84760, 84760, 87936, 87936, 87936, 87936, 90816, 90816, 90816, 93800, 93800, 93800, 93800},
1309    {904,   1864,  2792,  3752,  4584,  5544,  6456,  7480,  8248,  9144,  10296, 11064, 12216, 12960, 14112, 14688, 15840, 16992, 17568, 18336, 19848, 20616, 21384, 22152, 22920, 24496, 25456, 26416, 27376, 28336, 29296, 29296, 30576, 31704, 32856, 34008, 34008, 35160, 36696, 36696, 37888, 39232, 40576, 40576, 42368, 42368, 43816, 45352, 45352, 46888, 46888, 48936, 48936, 51024, 51024, 52752, 52752, 55056, 55056, 57336, 57336, 59256, 59256, 59256, 61664, 61664, 63776, 63776, 63776, 66592, 66592, 68808, 68808, 68808, 71112, 71112, 71112, 73712, 73712, 73712, 76208, 76208, 78704, 78704, 78704, 81176, 81176, 81176, 84760, 84760, 84760, 84760, 87936, 87936, 87936, 90816, 90816, 90816, 93800, 93800, 93800, 93800, 97896, 97896, 97896, 97896, 97896, 101840, 101840, 101840},
1310    {1000,  1992,  2984,  4008,  4968,  5992,  6968,  7992,  9144,  9912,  11064, 12216, 12960, 14112, 15264, 15840, 16992, 18336, 19080, 19848, 21384, 22152, 22920, 24496, 25456, 26416, 27376, 28336, 29296, 30576, 31704, 31704, 32856, 34008, 35160, 36696, 36696, 37888, 39232, 40576, 40576, 42368, 43816, 43816, 45352, 46888, 46888, 48936, 48936, 51024, 51024, 52752, 52752, 55056, 55056, 57336, 57336, 59256, 59256, 61664, 61664, 63776, 63776, 63776, 66592, 66592, 68808, 68808, 71112, 71112, 71112, 73712, 73712, 73712, 76208, 76208, 78704, 78704, 78704, 81176, 81176, 81176, 84760, 84760, 84760, 87936, 87936, 87936, 90816, 90816, 90816, 93800, 93800, 93800, 93800, 97896, 97896, 97896, 97896, 101840, 101840, 101840, 101840, 105528, 105528, 105528, 105528, 110136, 110136, 110136},
1311    {1064,  2152,  3240,  4264,  5352,  6456,  7480,  8504,  9528,  10680, 11832, 12960, 14112, 15264, 16416, 16992, 18336, 19080, 20616, 21384, 22920, 23688, 24496, 25456, 27376, 28336, 29296, 30576, 31704, 32856, 34008, 34008, 35160, 36696, 37888, 39232, 40576, 40576, 42368, 43816, 43816, 45352, 46888, 46888, 48936, 48936, 51024, 51024, 52752, 55056, 55056, 57336, 57336, 59256, 59256, 61664, 61664, 63776, 63776, 66592, 66592, 68808, 68808, 68808, 71112, 71112, 73712, 73712, 73712, 76208, 76208, 78704, 78704, 81176, 81176, 81176, 84760, 84760, 84760, 87936, 87936, 87936, 90816, 90816, 90816, 93800, 93800, 93800, 97896, 97896, 97896, 97896, 101840, 101840, 101840, 101840, 105528, 105528, 105528, 110136, 110136, 110136, 110136, 115040, 115040, 115040, 115040, 119816, 119816, 119816},
1312    {1128,  2280,  3496,  4584,  5736,  6968,  7992,  9144,  10296, 11448, 12576, 13536, 14688, 15840, 16992, 18336, 19848, 20616, 22152, 22920, 24496, 25456, 26416, 27376, 28336, 29296, 30576, 31704, 32856, 34008, 35160, 36696, 37888, 39232, 40576, 40576, 42368, 43816, 45352, 45352, 46888, 48936, 48936, 51024, 51024, 52752, 55056, 55056, 57336, 57336, 59256, 59256, 61664, 61664, 63776, 63776, 66592, 66592, 68808, 68808, 71112, 71112, 73712, 73712, 76208, 76208, 76208, 78704, 78704, 81176, 81176, 81176, 84760, 84760, 87936, 87936, 87936, 90816, 90816, 90816, 93800, 93800, 93800, 97896, 97896, 97896, 101840,101840,101840,101840,105528, 105528, 105528, 110136, 110136, 110136, 110136, 115040, 115040, 115040, 115040, 119816, 119816, 119816, 119816, 124464, 124464, 124464, 124464, 128496},
1313    {1192,  2408,  3624,  4968,  5992,  7224,  8504,  9912,  11064, 12216, 13536, 14688, 15840, 16992, 18336, 19848, 20616, 22152, 22920, 24496, 25456, 26416, 28336, 29296, 30576, 31704, 32856, 34008, 35160, 36696, 37888, 39232, 40576, 42368, 42368, 43816, 45352, 46888, 46888, 48936, 51024, 51024, 52752, 52752, 55056, 57336, 57336, 59256, 59256, 61664, 61664, 63776, 63776, 66592, 66592, 68808, 71112, 71112, 73712, 73712, 73712, 76208, 76208, 78704, 78704, 81176, 81176, 84760, 84760, 84760, 87936, 87936, 90816, 90816, 90816, 93800, 93800, 93800, 97896, 97896, 97896, 101840, 101840, 101840, 105528, 105528, 105528, 105528, 110136, 110136, 110136, 115040, 115040, 115040, 115040, 119816, 119816, 119816, 124464, 124464, 124464, 124464, 128496, 128496, 128496, 128496, 133208, 133208, 133208, 133208},
1314    {1256,  2536,  3752,  5160,  6200,  7480,  8760,  10296, 11448, 12576, 14112, 15264, 16416, 17568, 19080, 20616, 21384, 22920, 24496, 25456, 26416, 28336, 29296, 30576, 31704, 32856, 34008, 35160, 36696, 37888, 39232, 40576, 42368, 43816, 43816, 45352, 46888, 48936, 48936, 51024, 52752, 52752, 55056, 55056, 57336, 59256, 59256, 61664, 61664, 63776, 63776, 66592, 66592, 68808, 71112, 71112, 73712, 73712, 76208, 76208, 78704, 78704, 81176, 81176, 81176, 84760, 84760, 87936, 87936, 87936, 90816, 90816, 93800, 93800, 93800, 97896, 97896, 97896, 101840, 101840, 101840, 105528, 105528, 105528, 110136, 110136, 110136, 110136, 115040,115040, 115040, 119816, 119816, 119816, 124464, 124464, 124464, 124464, 128496, 128496, 128496, 128496, 133208, 133208, 133208, 133208, 137792, 137792, 137792, 142248},
1315    {1480,  2984,  4392,  5992,  7480,  8760,  10296, 11832, 13536, 14688, 16416, 17568, 19080, 20616, 22152, 23688, 25456, 26416, 28336, 29296, 30576, 32856, 34008, 35160, 36696, 37888, 40576, 40576, 42368, 43816, 45352, 46888, 48936, 51024, 52752, 52752, 55056, 55056, 57336, 59256, 59256, 61664, 63776, 63776, 66592, 68808, 68808, 71112, 73712, 75376, 75376, 75376, 75376, 75376, 75376, 81176, 84760, 84760, 87936, 87936, 90816, 90816, 93800, 93800, 97896, 97896, 97896, 101840, 101840, 105528, 105528, 105528, 110136, 110136, 110136, 110136, 115040, 115040, 115040, 119816, 119816, 119816, 124464, 124464, 124464, 128496, 128496, 128496, 133208, 133208, 133208, 137792, 137792, 137792, 142248, 142248, 142248, 146856, 146856,149776, 149776, 149776, 149776, 149776, 149776, 149776, 149776, 149776, 149776, 149776}
1316  }
1317 };
1318 RgSchUlIMcsTbl rgUlIMcsTbl = {
1319    {2, 0}, {2, 1}, {2, 2}, {2, 3}, {2, 4}, {2, 5},
1320    {2, 6}, {2, 7}, {2, 8}, {2, 9}, {2, 10},
1321    {4, 10}, {4, 11}, {4, 12}, {4, 13}, {4, 14},
1322    {4, 15}, {4, 16}, {4, 17}, {4, 18}, {4, 19},
1323    {6, 19}, {6, 20}, {6, 21}, {6, 22}, {6, 23},
1324    {6, 24}, {6, 25}, {6, 26}
1325 };
1326 RgSchUeCatTbl rgUeCatTbl = {
1327    /*Column1:Maximum number of bits of an UL-SCH 
1328              transport block transmitted within a TTI
1329              - maxUlBits
1330      Column2:Maximum number of bits of a DLSCH
1331              transport block received within a TTI 
1332              - maxDlBits
1333      Column3:Total number of soft channel bits 
1334              - maxSftChBits
1335      Column4:Support for 64QAM in UL 
1336              - ul64qamSup
1337      Column5:Maximum number of DL-SCH transport
1338              block bits received within a TTI
1339              - maxDlTbBits
1340      Column6:Maximum number of supported layers for 
1341              spatial multiplexing in DL 
1342              - maxTxLyrs*/
1343    {5160,  {10296,0},      250368,  FALSE, 10296,  1},
1344    {25456, {51024,0},      1237248, FALSE, 51024,  2},
1345    {51024, {75376,0},      1237248, FALSE, 102048, 2},
1346    {51024, {75376,0},      1827072, FALSE, 150752, 2},
1347    {75376, {149776,0},     3667200, TRUE,  299552, 4},
1348    {51024, {75376,149776}, 3654144, FALSE, 301504,  4},
1349    {51024, {75376,149776}, 3654144, FALSE, 301504,  4},
1350    {149776,{299856,0},     35982720,TRUE,  2998560, 8}
1351 };
1352
1353 /* [ccpu00138532]-ADD-The below table stores the min HARQ RTT time
1354    in Downlink for TDD and FDD. Indices 0 to 6 map to tdd UL DL config 0-6. 
1355    Index 7 map to FDD */    
1356 U8 rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
1357 /* Number of CFI Switchover Index is equals to 7 TDD Indexes + 1 FDD index */
1358 U8 rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
1359
1360 /* EffTbl is calculated for single layer and two layers.
1361   * CqiToTbs is calculated for single layer and two layers */
1362 RgSchCmnTbSzEff rgSchCmnNorCfi1Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi2Eff[RGSCH_MAX_NUM_LYR_PERCW];
1363 RgSchCmnTbSzEff rgSchCmnNorCfi3Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi4Eff[RGSCH_MAX_NUM_LYR_PERCW];
1364 /* New variable to store UL effiency values for normal and extended CP*/
1365 RgSchCmnTbSzEff rgSchCmnNorUlEff[1],rgSchCmnExtUlEff[1];
1366 RgSchCmnCqiToTbs rgSchCmnNorCfi1CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi2CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1367 RgSchCmnCqiToTbs rgSchCmnNorCfi3CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi4CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1368 RgSchCmnCqiToTbs *rgSchCmnCqiToTbs[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_CFI];
1369 RgSchCmnTbSzEff rgSchCmnExtCfi1Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi2Eff[RGSCH_MAX_NUM_LYR_PERCW];
1370 RgSchCmnTbSzEff rgSchCmnExtCfi3Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi4Eff[RGSCH_MAX_NUM_LYR_PERCW];
1371 RgSchCmnCqiToTbs rgSchCmnExtCfi1CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi2CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1372 RgSchCmnCqiToTbs rgSchCmnExtCfi3CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi4CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1373 /* Include CRS REs while calculating Efficiency */
1374 RgSchCmnTbSzEff *rgSchCmnEffTbl[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_ANT_CONF][RG_SCH_CMN_MAX_CFI];
1375 RgSchCmnTbSzEff *rgSchCmnUlEffTbl[RG_SCH_CMN_MAX_CP];
1376 #ifdef LTE_TDD
1377 RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3, 1};
1378 #else
1379 /* Added matrix 'rgRaPrmblToRaFrmTbl'for computation of RA sub-frames from RA preamble */
1380 RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3};
1381 #endif
1382
1383 EXTERN  RgUlSchdInits        rgSchUlSchdInits;
1384 EXTERN  RgDlSchdInits        rgSchDlSchdInits;
1385 EXTERN  RgDlfsSchdInits      rgSchDlfsSchdInits;
1386 #ifdef EMTC_ENABLE
1387 EXTERN  RgEmtcUlSchdInits        rgSchEmtcUlSchdInits;
1388 EXTERN  RgEmtcDlSchdInits        rgSchEmtcDlSchdInits;
1389 #endif
1390
1391 /* RACHO : start */
1392 PRIVATE S16 rgSCHCmnUeIdleExdThrsld ARGS((
1393 RgSchCellCb     *cell,
1394 RgSchUeCb       *ue
1395 ));
1396 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe ARGS((
1397 RgSchCellCb           *cell,
1398 U16                   rapId
1399 ));
1400 PRIVATE Void rgSCHCmnDelDedPreamble ARGS((
1401 RgSchCellCb           *cell,
1402 U8                    preambleId
1403 ));
1404 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe ARGS((
1405 RgSchCellCb           *cell,
1406 U16                   rapId,
1407 CmLteTimingInfo       timingInfo
1408 ));
1409 PRIVATE Void rgSCHCmnDelRachInfo ARGS((
1410 RgSchCellCb  *cell,
1411 RgSchUeCb    *ue
1412 ));
1413 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe ARGS((
1414 RgSchCellCb           *cell,
1415 RgSchUlSf             *sf,
1416 RgSchUeCb             *ue,
1417 U8                    maxRb
1418 ));
1419 PRIVATE Void rgSCHCmnHdlHoPo ARGS((
1420 RgSchCellCb           *cell,
1421 CmLListCp             *raRspLst,
1422 RgSchRaReqInfo        *raReq
1423 ));
1424 PRIVATE Void rgSCHCmnAllocPoHoGrnt ARGS((
1425 RgSchCellCb           *cell,
1426 CmLListCp             *raRspLst,
1427 RgSchUeCb             *ue,
1428 RgSchRaReqInfo        *raReq
1429 ));
1430 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf ARGS((
1431 RgSchCellCb *cell,
1432 RgSchUeCb   *ue,
1433 RgSchPdcch  *pdcc,
1434 U8          rapId,
1435 U8          prachMskIdx
1436 ));
1437 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ ARGS((
1438 RgSchCellCb                *cell,
1439 RgSchUeCb                  *ue
1440 ));
1441 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ ARGS((
1442 RgSchCellCb                *cell,
1443 RgSchUeCb                  *ue
1444 ));
1445 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx ARGS((
1446 RgSchCellCb  *cell
1447 ));
1448 PRIVATE Void rgSCHCmnUpdRachParam ARGS((
1449 RgSchCellCb  *cell
1450 ));
1451 PRIVATE S16 rgSCHCmnAllocPOParam ARGS((
1452 RgSchCellCb  *cell,
1453 RgSchDlSf    *dlSf,
1454 RgSchUeCb    *ue,
1455 RgSchPdcch   **pdcch,
1456 U8           *rapId,
1457 U8           *prachMskIdx
1458 ));
1459 PRIVATE Void rgSCHCmnGenPdcchOrder ARGS((
1460 RgSchCellCb  *cell,
1461 RgSchDlSf    *dlSf
1462 ));
1463 PRIVATE Void rgSCHCmnCfgRachDedPrm ARGS((
1464 RgSchCellCb   *cell
1465 ));
1466 /* RACHO : end */
1467
1468 PRIVATE Void rgSCHCmnHdlUlInactUes ARGS((
1469 RgSchCellCb  *cell
1470 ));
1471 PRIVATE Void rgSCHCmnHdlDlInactUes ARGS((
1472 RgSchCellCb  *cell
1473 ));
1474 PRIVATE Void rgSCHCmnUlInit ARGS((Void
1475 ));
1476 PRIVATE Void rgSCHCmnDlInit ARGS((Void
1477 ));
1478 PRIVATE Void rgSCHCmnInitDlRbAllocInfo ARGS((
1479 RgSchCmnDlRbAllocInfo  *allocInfo
1480 ));
1481 PRIVATE Void rgSCHCmnUpdUlCompEffBsr ARGS((
1482 RgSchUeCb *ue
1483 ));
1484 #if RG_UNUSED
1485 PRIVATE Void rgSCHCmnUlSetAllUnSched  ARGS((
1486 RgSchCmnUlRbAllocInfo *allocInfo
1487 ));
1488 PRIVATE Void rgSCHCmnUlUpdSf ARGS((
1489          RgSchCellCb           *cell,
1490          RgSchCmnUlRbAllocInfo *allocInfo,
1491          RgSchUlSf     *sf
1492          ));
1493 PRIVATE Void rgSCHCmnUlHndlAllocRetx ARGS((
1494          RgSchCellCb           *cell,
1495          RgSchCmnUlRbAllocInfo *allocInfo,
1496          RgSchUlSf     *sf,
1497          RgSchUlAlloc  *alloc
1498          ));
1499 #endif
1500 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch ARGS((
1501 RgSchCellCb  *cell,
1502 RgSchDlSf    *dlSf
1503 ));
1504 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch ARGS((
1505 RgSchCellCb  *cell,
1506 RgSchUlSf    *ulSf
1507 ));
1508 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ ARGS((
1509 RgSchCellCb     *cell,
1510 RgSchUeCb       *ue
1511 ));
1512 PRIVATE S16 rgSCHCmnTmrExpiry ARGS((
1513 PTR cb,               /* Pointer to timer control block */
1514 S16 tmrEvnt           /* Timer Event */
1515 ));
1516 PRIVATE S16 rgSCHCmnTmrProc ARGS((
1517 RgSchCellCb *cell
1518 ));
1519 PRIVATE Void rgSCHCmnAddUeToRefreshQ ARGS((
1520 RgSchCellCb     *cell,
1521 RgSchUeCb       *ue,
1522 U32             wait
1523 ));
1524 PRIVATE Void rgSCHCmnDlCcchRetx ARGS((
1525 RgSchCellCb             *cell,
1526 RgSchCmnDlRbAllocInfo   *allocInfo
1527 ));
1528 PRIVATE Void rgSCHCmnUpdUeMimoInfo ARGS((
1529 RgrUeCfg     *ueCfg,
1530 RgSchCmnDlUe *ueDl,
1531 RgSchCellCb  *cell,
1532 RgSchCmnCell *cellSchd
1533 ));
1534 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo ARGS((
1535 RgSchCellCb   *cell,
1536 RgSchUeCb     *ue,
1537 RgSchCmnUlUe  *ueUl,
1538 RgSchCmnUe    *ueSchCmn,
1539 RgSchCmnCell  *cellSchd,
1540 Bool          isEcp 
1541 ));
1542 #ifdef RGR_V1
1543 PRIVATE Void rgSCHCmnDlCcchSduRetx ARGS((
1544 RgSchCellCb             *cell,
1545 RgSchCmnDlRbAllocInfo   *allocInfo
1546 ));
1547 PRIVATE Void rgSCHCmnDlCcchSduTx ARGS((
1548 RgSchCellCb             *cell,
1549 RgSchCmnDlRbAllocInfo   *allocInfo
1550 ));
1551 PRIVATE S16 rgSCHCmnCcchSduAlloc ARGS((
1552 RgSchCellCb                *cell,
1553 RgSchUeCb                  *ueCb,
1554 RgSchCmnDlRbAllocInfo      *allocInfo
1555 ));
1556 PRIVATE S16 rgSCHCmnCcchSduDedAlloc ARGS((
1557 RgSchCellCb                *cell,
1558 RgSchUeCb                  *ueCb
1559 ));
1560 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc ARGS((
1561 RgSchCellCb           *cell,
1562 RgSchUeCb             *ueCb,
1563 RgSchDlSf             *dlSf
1564 ));
1565 #endif
1566 PRIVATE Void rgSCHCmnInitVars ARGS((
1567          RgSchCellCb *cell
1568          ));
1569
1570 /*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now PUBLIC */
1571 PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
1572          RgSchCellCb           *cell,
1573          RgSchUlSf             *sf,
1574          U32                   count,
1575          CmLListCp             *reqLst,
1576          CmLListCp             *schdLst,
1577          CmLListCp             *nonSchdLst,
1578          Bool                  isNewTx
1579          ));
1580 PRIVATE S16 rgSCHCmnUlRbAllocForUe ARGS((
1581          RgSchCellCb           *cell,
1582          RgSchUlSf             *sf,
1583          RgSchUeCb             *ue,
1584          U8                    maxRb,
1585          RgSchUlHole           *hole
1586          ));
1587 PRIVATE Void rgSCHCmnMsg3GrntReq ARGS((
1588          RgSchCellCb     *cell,
1589          CmLteRnti       rnti,
1590          Bool            preamGrpA,
1591          RgSchUlHqProcCb *hqProc,
1592          RgSchUlAlloc    **ulAllocRef,
1593          U8              *hqProcIdRef
1594          ));
1595 #ifdef UNUSE_FUN
1596 PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
1597          RgSchCmnUlCell  *cellUl,
1598          RgSchUlAlloc    *alloc,
1599          U8               idx
1600          ));
1601 #endif
1602 PRIVATE Void rgSCHCmnDlCcchRarAlloc ARGS((
1603 RgSchCellCb             *cell
1604 ));
1605 PRIVATE Void rgSCHCmnDlCcchTx ARGS((
1606 RgSchCellCb             *cell,
1607 RgSchCmnDlRbAllocInfo   *allocInfo
1608 ));
1609 PRIVATE Void rgSCHCmnDlBcchPcch ARGS((
1610 RgSchCellCb             *cell,
1611 RgSchCmnDlRbAllocInfo   *allocInfo,
1612 RgInfSfAlloc            *subfrmAlloc
1613 ));
1614 PUBLIC Bool rgSCHCmnChkInWin ARGS((
1615 CmLteTimingInfo   frm,
1616 CmLteTimingInfo   start,
1617 CmLteTimingInfo   end
1618 ));
1619 PUBLIC Bool rgSCHCmnChkPastWin ARGS((
1620 CmLteTimingInfo   frm,
1621 CmLteTimingInfo   end
1622 ));
1623 PRIVATE Void rgSCHCmnClcAlloc ARGS((
1624 RgSchCellCb             *cell,
1625 RgSchDlSf               *sf,
1626 RgSchClcDlLcCb          *lch,
1627 U16                     rnti,
1628 RgSchCmnDlRbAllocInfo   *allocInfo
1629 ));
1630 #ifndef LTEMAC_SPS
1631 PRIVATE Void rgSCHCmnClcRbAlloc ARGS((
1632 RgSchCellCb             *cell,
1633 U32                     bo,
1634 U8                      cqi,
1635 U8                      *rb,
1636 U32                     *tbs,
1637 U8                      *mcs,
1638 RgSchDlSf               *sf 
1639 ));
1640 #endif
1641
1642 PRIVATE S16 rgSCHCmnMsg4Alloc ARGS((
1643 RgSchCellCb                *cell,
1644 RgSchRaCb                  *raCb,
1645 RgSchCmnDlRbAllocInfo      *allocInfo
1646 ));
1647 PRIVATE S16 rgSCHCmnMsg4DedAlloc ARGS((
1648 RgSchCellCb                *cell,
1649 RgSchRaCb                  *raCb
1650 ));
1651 PRIVATE Void rgSCHCmnDlRaRsp ARGS((
1652 RgSchCellCb                *cell,
1653 RgSchCmnDlRbAllocInfo      *allocInfo
1654 ));
1655 PRIVATE S16 rgSCHCmnRaRspAlloc ARGS((
1656 RgSchCellCb             *cell,
1657 RgSchDlSf               *subFrm,
1658 U16                     rntiIdx,
1659 U16                     rarnti,
1660 U8                      noRaRnti,
1661 RgSchCmnDlRbAllocInfo   *allocInfo
1662 ));
1663 PRIVATE Void rgSCHCmnUlUeDelAllocs ARGS((
1664 RgSchCellCb  *cell,
1665 RgSchUeCb   *ue
1666 ));
1667 PRIVATE Void rgSCHCmnDlSetUeAllocLmt ARGS((
1668 RgSchCellCb   *cell,
1669 RgSchCmnDlUe  *ueDl,
1670 Bool          isEmtcUe
1671 ));
1672 PRIVATE S16 rgSCHCmnDlRgrCellCfg ARGS((
1673 RgSchCellCb    *cell,
1674 RgrCellCfg     *cfg,
1675 RgSchErrInfo   *err
1676 ));
1677 PRIVATE Void rgSCHCmnUlAdapRetx ARGS((
1678 RgSchUlAlloc    *alloc,
1679 RgSchUlHqProcCb *proc
1680 ));
1681 PRIVATE Void rgSCHCmnUlUpdAllocRetx ARGS((
1682 RgSchCellCb    *cell,
1683 RgSchUlAlloc   *alloc
1684 ));
1685 PRIVATE Void rgSCHCmnUlSfReTxAllocs ARGS((
1686 RgSchCellCb *cell,
1687 RgSchUlSf   *sf
1688 ));
1689 /* Fix: syed Adaptive Msg3 Retx crash. */
1690 #ifdef UNUSE_FUN
1691 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
1692 RgSchCellCb *cell,
1693 RgSchUlSf   *sf
1694 ));
1695 #endif
1696 #ifdef TFU_UPGRADE
1697 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
1698 ((
1699 RgSchCellCb *cell,
1700 RgSchUeCb    *ue,
1701 RgrUeRecfg   *ueRecfg,
1702 U8 numTxPorts
1703 ));
1704 #else
1705 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
1706 ((
1707 RgSchCellCb *cell,
1708 RgSchUeCb    *ue,
1709 RgrUeRecfg   *ueRecfg
1710 ));
1711 #endif
1712
1713
1714 /*
1715  * DL RB allocation specific functions
1716  */
1717
1718 PRIVATE Void rgSCHCmnDlRbAlloc ARGS((
1719 RgSchCellCb           *cell,
1720 RgSchCmnDlRbAllocInfo *allocInfo
1721 ));
1722 PRIVATE Void rgSCHCmnNonDlfsRbAlloc ARGS((
1723 RgSchCellCb           *cell,
1724 RgSchCmnDlRbAllocInfo *allocInfo
1725 ));
1726 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc ARGS((
1727 RgSchCellCb           *cell,
1728 RgSchDlRbAlloc        *cmnAllocInfo));
1729
1730 #ifndef LTE_TDD
1731 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj ARGS((
1732 RgSchCellCb           *cell,
1733 RgSchDlRbAlloc        *cmnAllocInfo,
1734 U8                    pbchSsRsSym,
1735 Bool                  isBcchPcch
1736 ));
1737 /* Added function to adjust TBSize*/
1738 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj ARGS((
1739 RgSchDlRbAlloc        *allocInfo,
1740 U8                    numOvrlapgPbchRb,
1741 U8                    pbchSsRsSym,
1742 U8                    idx,
1743 U32                   bytesReq
1744 ));
1745
1746 /* Added function to find num of overlapping PBCH rb*/
1747 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs ARGS((
1748 RgSchCellCb           *cell,
1749 RgSchDlSf             *dlSf,
1750 RgSchDlRbAlloc        *allocInfo,
1751 U8                    *numOvrlapgPbchRb
1752 ));
1753
1754 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl ARGS((
1755 RgSchCellCb           *cell,
1756 RgSchDlSf             *dlSf,
1757 RgSchDlRbAlloc        *allocInfo
1758 ));
1759 #ifdef DEBUGP
1760 #ifdef UNUSE_FUN
1761 PRIVATE Void rgSCHCmnFindCodeRate ARGS((
1762 RgSchCellCb           *cell,
1763 RgSchDlSf             *dlSf,
1764 RgSchDlRbAlloc        *allocInfo,
1765 U8                    idx
1766 ));
1767 #endif
1768 #endif
1769 #endif
1770 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
1771 RgSchCellCb           *cell,
1772 RgSchCmnMsg4RbAlloc   *msg4AllocInfo,
1773 U8                    isRetx
1774 ));
1775 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc ARGS((
1776 RgSchCellCb           *cell,
1777 RgSchRaCb             *raCb,
1778 RgSchDlSf             *dlSf
1779 ));
1780
1781 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc ARGS((
1782 RgSchCellCb           *cell,
1783 RgSchUeCb             *ue,
1784 RgSchDlSf             *dlSf,
1785 U8                    *isDlBwAvail
1786 ));
1787 #ifndef LTEMAC_SPS
1788 PRIVATE U32 rgSCHCmnCalcRiv ARGS(( U8 bw,
1789          U8           rbStart,
1790          U8           numRb));
1791 #endif
1792
1793 #ifdef LTE_TDD
1794 PRIVATE Void rgSCHCmnUpdHqAndDai ARGS((
1795 RgSchDlHqProcCb   *hqP,
1796 RgSchDlSf         *subFrm,
1797 RgSchDlHqTbCb     *tbCb,
1798 U8                tbAllocIdx
1799 ));
1800 PRIVATE S16 rgSCHCmnUlCalcAvailBw ARGS((
1801 RgSchCellCb *cell,
1802 RgrCellCfg  *cellCfg,
1803 U8          cfi,
1804 U8          *rbStartRef,
1805 U8          *bwAvailRef
1806 ));
1807 PRIVATE S16 rgSCHCmnDlKdashUlAscInit ARGS((
1808 RgSchCellCb *cell
1809 ));
1810 PRIVATE S16 rgSCHCmnDlANFdbkInit ARGS((
1811 RgSchCellCb *cell
1812 ));
1813 PRIVATE S16 rgSCHCmnDlNpValInit ARGS((
1814 RgSchCellCb *cell
1815 ));
1816 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst ARGS((
1817 RgSchCellCb *cell
1818 ));
1819 PRIVATE S16 rgSCHCmnDlCpyRachInfo ARGS((
1820 RgSchCellCb        *cell,
1821 RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
1822 U8                 raArrSz
1823 ));
1824 PRIVATE S16 rgSCHCmnDlRachInfoInit ARGS((
1825 RgSchCellCb *cell
1826 ));
1827 PRIVATE S16 rgSCHCmnDlPhichOffsetInit ARGS((
1828 RgSchCellCb *cell
1829 ));
1830 #endif
1831 #ifdef TFU_UPGRADE
1832 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt ARGS
1833 ((
1834  RgSchCellCb          *cell,
1835  RgSchUeCb            *ue,
1836  U8                          wideCqi
1837  ));
1838  PRIVATE RgSchCmnRank rgSCHCmnComputeRank ARGS
1839 ((
1840  RgrTxMode    txMode,
1841  U32          *pmiBitMap,
1842  U8           numTxPorts
1843  ));
1844
1845  PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3 ARGS
1846 ((
1847  U32 *pmiBitMap
1848  ));
1849
1850   PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3 ARGS
1851 ((
1852  U32 *pmiBitMap
1853  ));
1854
1855   PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4 ARGS
1856 ((
1857  U32 *pmiBitMap
1858  ));
1859
1860   PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4 ARGS
1861 ((
1862  U32 *pmiBitMap
1863  ));
1864
1865  PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr ARGS
1866 ((
1867  RgSchCellCb        *cell,
1868  TfuSrsRpt        *srsRpt
1869  ));
1870 #endif
1871
1872 /* comcodsepa : start */
1873 \f
1874 /**
1875  * @brief This function computes efficiency and stores in a table.
1876  *
1877  * @details
1878  *
1879  *     Function: rgSCHCmnCompEff
1880  *     Purpose:  this function computes the efficiency as number of
1881  *               bytes per 1024 symbols. The CFI table is also filled
1882  *               with the same information such that comparison is valid
1883  *
1884  *     Invoked by: Scheduler
1885  *
1886  *  @param[in]  U8            noPdcchSym
1887  *  @param[in]  U8            cpType
1888  *  @param[in]  U8            txAntIdx
1889  *  @param[in]  RgSchCmnTbSzEff* effTbl
1890  *  @return  Void
1891  *
1892  **/
1893 #ifdef ANSI
1894 PRIVATE Void rgSCHCmnCompEff
1895 (
1896 U8                    noPdcchSym,
1897 U8                    cpType,
1898 U8                    txAntIdx,
1899 RgSchCmnTbSzEff       *effTbl
1900 )
1901 #else
1902 PRIVATE Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
1903 U8                    noPdcchSym;
1904 U8                    cpType;
1905 U8                    txAntIdx;
1906 RgSchCmnTbSzEff       *effTbl;
1907 #endif
1908 {
1909    U8               noResPerRb;
1910    U8               noSymPerRb;
1911    U8               resOfCrs; /* Effective REs occupied by CRS */
1912    U8               i, j;
1913
1914    TRC2(rgSCHCmnCompEff);
1915
1916    switch (cpType)
1917    {
1918       case RG_SCH_CMN_NOR_CP:
1919          noSymPerRb = 14;
1920          break;
1921       case RG_SCH_CMN_EXT_CP:
1922          noSymPerRb = 12;
1923          break;
1924       default:
1925          /* Generate a log error. This case should never be executed */
1926          RETVOID;
1927    }
1928
1929    /* Depending on the Tx Antenna Index, deduct the
1930     * Resource elements for the CRS */
1931    switch (txAntIdx)
1932    {
1933       case 0:
1934          resOfCrs = RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT;
1935          break;
1936       case 1:
1937          resOfCrs = RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT;
1938          break;
1939       case 2:
1940          resOfCrs = RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT;
1941          break;
1942       default:
1943          /* Generate a log error. This case should never be executed */
1944          RETVOID;
1945    }
1946    noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
1947    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
1948    {
1949       (*effTbl)[i] = 0;
1950       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
1951       {
1952          /* This line computes the coding efficiency per 1024 REs */
1953          (*effTbl)[i] += (rgTbSzTbl[0][i][j] * 1024) / (noResPerRb * (j+1));
1954       }
1955       (*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
1956    }
1957    RETVOID;
1958 }
1959 /**
1960  * @brief This function computes efficiency and stores in a table.
1961  *
1962  * @details
1963  *
1964  *     Function: rgSCHCmnCompUlEff
1965  *     Purpose:  this function computes the efficiency as number of
1966  *               bytes per 1024 symbols. The CFI table is also filled
1967  *               with the same information such that comparison is valid
1968  *
1969  *     Invoked by: Scheduler
1970  *
1971  *  @param[in]  U8            noUlRsSym
1972  *  @param[in]  U8            cpType
1973  *  @param[in]  U8            txAntIdx
1974  *  @param[in]  RgSchCmnTbSzEff* effTbl
1975  *  @return  Void
1976  *
1977  **/
1978 #ifdef ANSI
1979 PRIVATE Void rgSCHCmnCompUlEff
1980 (
1981 U8                    noUlRsSym,
1982 U8                    cpType,
1983 RgSchCmnTbSzEff       *effTbl
1984 )
1985 #else
1986 PRIVATE Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
1987 U8                    noUlRsSym;
1988 U8                    cpType;
1989 RgSchCmnTbSzEff       *effTbl;
1990 #endif
1991 {
1992    U8               noResPerRb;
1993    U8               noSymPerRb;
1994    U8               i, j;
1995
1996    TRC2(rgSCHCmnCompUlEff);
1997
1998    switch (cpType)
1999    {
2000       case RG_SCH_CMN_NOR_CP:
2001          noSymPerRb = 14;
2002          break;
2003       case RG_SCH_CMN_EXT_CP:
2004          noSymPerRb = 12;
2005          break;
2006       default:
2007          /* Generate a log error. This case should never be executed */
2008          RETVOID;
2009    }
2010
2011    noResPerRb = ((noSymPerRb - noUlRsSym) * RB_SCH_CMN_NUM_SCS_PER_RB);
2012    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
2013    {
2014       (*effTbl)[i] = 0;
2015       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
2016       {
2017          /* This line computes the coding efficiency per 1024 REs */
2018          (*effTbl)[i] += (rgTbSzTbl[0][i][j] * 1024) / (noResPerRb * (j+1));
2019       }
2020       (*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
2021    }
2022    RETVOID;
2023 }
2024
2025 /**
2026  * @brief This function computes efficiency for 2 layers and stores in a table.
2027  *
2028  * @details
2029  *
2030  *     Function: rgSCHCmn2LyrCompEff
2031  *     Purpose:  this function computes the efficiency as number of
2032  *               bytes per 1024 symbols. The CFI table is also filled
2033  *               with the same information such that comparison is valid
2034  *
2035  *     Invoked by: Scheduler
2036  *
2037  *  @param[in]  U8            noPdcchSym
2038  *  @param[in]  U8            cpType
2039  *  @param[in]  U8            txAntIdx
2040  *  @param[in]  RgSchCmnTbSzEff* effTbl2Lyr
2041  *  @return  Void
2042  *
2043  **/
2044 #ifdef ANSI
2045 PRIVATE Void rgSCHCmn2LyrCompEff
2046 (
2047 U8                    noPdcchSym,
2048 U8                    cpType,
2049 U8                    txAntIdx,
2050 RgSchCmnTbSzEff       *effTbl2Lyr
2051 )
2052 #else
2053 PRIVATE Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
2054 U8                    noPdcchSym;
2055 U8                    cpType;
2056 U8                    txAntIdx;
2057 RgSchCmnTbSzEff       *effTbl2Lyr;
2058 #endif
2059 {
2060    U8               noResPerRb;
2061    U8               noSymPerRb;
2062    U8               resOfCrs; /* Effective REs occupied by CRS */
2063    U8               i, j;
2064
2065    TRC2(rgSCHCmn2LyrCompEff);
2066
2067    switch (cpType)
2068    {
2069       case RG_SCH_CMN_NOR_CP:
2070          noSymPerRb = 14;
2071          break;
2072       case RG_SCH_CMN_EXT_CP:
2073          noSymPerRb = 12;
2074          break;
2075       default:
2076          /* Generate a log error. This case should never be executed */
2077          RETVOID;
2078    }
2079
2080    /* Depending on the Tx Antenna Index, deduct the
2081     * Resource elements for the CRS */
2082    switch (txAntIdx)
2083    {
2084       case 0:
2085          resOfCrs = RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT;
2086          break;
2087       case 1:
2088          resOfCrs = RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT;
2089          break;
2090       case 2:
2091          resOfCrs = RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT;
2092          break;
2093       default:
2094          /* Generate a log error. This case should never be executed */
2095          RETVOID;
2096    }
2097
2098    noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
2099    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
2100    {
2101       (*effTbl2Lyr)[i] = 0;
2102       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
2103       {
2104          /* This line computes the coding efficiency per 1024 REs */
2105          (*effTbl2Lyr)[i] += (rgTbSzTbl[1][i][j] * 1024) / (noResPerRb * (j+1));
2106       }
2107       (*effTbl2Lyr)[i] /= RG_SCH_CMN_NUM_RBS;
2108    }
2109    RETVOID;
2110 }
2111
2112 \f
2113 /**
2114  * @brief This function initializes the rgSchCmnDciFrmtSizes table.
2115  *
2116  * @details
2117  *
2118  *     Function: rgSCHCmnGetDciFrmtSizes
2119  *     Purpose:  This function determines the sizes of all
2120  *               the available DCI Formats. The order of
2121  *               bits addition for each format is inaccordance
2122  *               with the specs.
2123  *     Invoked by: rgSCHCmnRgrCellCfg
2124  *
2125  *  @return  Void
2126  *
2127  **/
2128 #ifdef ANSI
2129 PRIVATE Void rgSCHCmnGetDciFrmtSizes
2130 (
2131 RgSchCellCb *cell
2132 )
2133 #else
2134 PRIVATE Void rgSCHCmnGetDciFrmtSizes(cell)
2135 RgSchCellCb *cell;
2136 #endif
2137 {
2138
2139    TRC2(rgSCHCmnGetDciFrmtSizes);
2140
2141    /* DCI Format 0 size determination */
2142    rgSchCmnDciFrmtSizes[0] = 1 +
2143                              1 +
2144                              rgSCHUtlLog32bitNbase2((cell->bwCfg.ulTotalBw * \
2145                              (cell->bwCfg.ulTotalBw + 1))/2) +
2146                              5 +
2147                              1 +
2148                              2 +
2149                              3 +
2150 #ifdef LTE_TDD
2151                              2 +
2152                              2 +
2153 #endif
2154                              1;
2155    /* DCI Format 1 size determination */
2156    rgSchCmnDciFrmtSizes[1] = 1 +
2157    RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2158                              5 +
2159 #ifndef LTE_TDD
2160                              3 +
2161 #else
2162                              4 + 2 + /* HqProc Id and DAI */
2163 #endif
2164                              1 +
2165                              2 +
2166                              2;
2167
2168    /* DCI Format 1A size determination */
2169    rgSchCmnDciFrmtSizes[2] = 1 + /* Flag for format0/format1a differentiation */
2170                1 + /* Localized/distributed VRB assignment flag */
2171                5 + /* For mcs */
2172 #ifndef LTE_TDD
2173                3 + /* Harq process Id */
2174 #else
2175                4 + /* Harq process Id */
2176                2 + /* UL Index or DAI */
2177 #endif
2178                1 + /* New Data Indicator */
2179                2 + /* For RV */
2180                2 + /* For tpc */
2181                1 + rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2182                    (cell->bwCfg.dlTotalBw + 1))/2);
2183                /* Resource block assignment ceil[log2(bw(bw+1)/2)] : \
2184                   Since VRB is local */
2185
2186    /* DCI Format 1B size determination */
2187    rgSchCmnDciFrmtSizes[3] = 1 +
2188                              rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2189                              (cell->bwCfg.dlTotalBw + 1))/2) +
2190                              5 +
2191                              3 +
2192 #ifdef LTE_TDD
2193                              1 + /* HqP */
2194                              2 + /* Dai */
2195 #endif
2196                              1 +
2197                              2 +
2198                              2 +
2199                              ((cell->numTxAntPorts == 4)? 4:2) +
2200                              1;
2201
2202    /* DCI Format 1C size determination */
2203    /* Approximation: NDLVrbGap1 ~= Nprb for DL */
2204    rgSchCmnDciFrmtSizes[4] = (cell->bwCfg.dlTotalBw < 50)? 0:1 +
2205                              (cell->bwCfg.dlTotalBw < 50)?
2206                              (rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw/2 * \
2207                                 (cell->bwCfg.dlTotalBw/2 + 1))/2)) :
2208                              (rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw/4 * \
2209                                 (cell->bwCfg.dlTotalBw/4 + 1))/2)) +
2210                              5;
2211
2212    /* DCI Format 1D size determination */
2213    rgSchCmnDciFrmtSizes[5] = 1 +
2214                              rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2215                              (cell->bwCfg.dlTotalBw + 1))/2) +
2216                              5 +
2217                              3 +
2218 #ifdef LTE_TDD
2219                              1 + 2 +
2220 #endif
2221                              1 +
2222                              2 +
2223                              2 +
2224                              ((cell->numTxAntPorts == 4)? 4:2) +
2225                              1;
2226
2227    /* DCI Format 2 size determination */
2228    rgSchCmnDciFrmtSizes[6] = ((cell->bwCfg.dlTotalBw < 10)?0:1) +
2229                              RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2230                              2 +
2231 #ifdef LTE_TDD
2232                              2 + 1 +
2233 #endif
2234                              3 +
2235                              1 +
2236                              (5 + 1 + 2)*2 +
2237                              ((cell->numTxAntPorts == 4)? 6:3);
2238
2239    /* DCI Format 2A size determination */
2240    rgSchCmnDciFrmtSizes[7] = ((cell->bwCfg.dlTotalBw < 10)?0:1) +
2241                              RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2242                              2 +
2243 #ifdef LTE_TDD
2244                              2 + 1 +
2245 #endif
2246                              3 +
2247                              1 +
2248                              (5 + 1 + 2)*2 +
2249                              ((cell->numTxAntPorts == 4)? 2:0);
2250
2251    /* DCI Format 3 size determination */
2252    rgSchCmnDciFrmtSizes[8] = rgSchCmnDciFrmtSizes[0];
2253
2254    /* DCI Format 3A size determination */
2255    rgSchCmnDciFrmtSizes[9] = rgSchCmnDciFrmtSizes[0];
2256
2257    RETVOID;
2258 }
2259
2260
2261 /**
2262  * @brief This function initializes the cmnCell->dciAggrLvl table.
2263  *
2264  * @details
2265  *
2266  *     Function: rgSCHCmnGetCqiDciFrmt2AggrLvl
2267  *     Purpose:  This function determines the Aggregation level
2268  *               for each CQI level against each DCI format.
2269  *     Invoked by: rgSCHCmnRgrCellCfg
2270  *
2271  *  @return  Void
2272  *
2273  **/
2274 #ifdef ANSI
2275 PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl
2276 (
2277 RgSchCellCb *cell
2278 )
2279 #else
2280 PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl(cell)
2281 RgSchCellCb *cell;
2282 #endif
2283 {
2284    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
2285    U8            i;
2286    U8            j;
2287
2288    TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
2289
2290    for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
2291    {
2292       for (j = 0; j < 10; j++)
2293       {
2294          U32 pdcchBits; /* Actual number of phy bits needed for a given DCI Format
2295                * for a given CQI Level */
2296          pdcchBits = (rgSchCmnDciFrmtSizes[j] * 1024)/rgSchCmnCqiPdcchEff[i];
2297                         /* V5G_211 : 6.6 */
2298          if (pdcchBits < 192)
2299          {
2300              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL2;
2301              continue;
2302          }
2303          if (pdcchBits < 384)
2304          {
2305              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL4;
2306              continue;
2307          }
2308          if (pdcchBits < 768)
2309          {
2310              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL8;
2311              continue;
2312          }
2313          cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL16;
2314       }
2315    }
2316    RETVOID;
2317 }
2318 \f
2319 /**
2320  * @brief This function initializes all the data for the scheduler.
2321  *
2322  * @details
2323  *
2324  *     Function: rgSCHCmnDlInit
2325  *     Purpose:  This function initializes the following information:
2326  *               1. Efficiency table
2327  *               2. CQI to table index - It is one row for upto 3 RBs
2328  *                  and another row for greater than 3 RBs
2329  *                  currently extended prefix is compiled out.
2330  *     Invoked by: MAC intialization code..may be ActvInit
2331  *
2332  *  @return  Void
2333  *
2334  **/
2335 #ifdef ANSI
2336 PRIVATE Void rgSCHCmnDlInit
2337 (
2338 )
2339 #else
2340 PRIVATE Void rgSCHCmnDlInit()
2341 #endif
2342 {
2343    U8                   i;
2344    S16                  j;
2345    S16                  k;
2346    U8                   idx;
2347    RgSchCmnTbSzEff      *effTbl;
2348    RgSchCmnCqiToTbs     *tbsTbl;
2349
2350    TRC2(rgSCHCmnDlInit);
2351
2352    /* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
2353    /* Init Efficiency table for normal cyclic prefix */
2354    /*Initialize Efficiency table for Layer Index 0 */
2355    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2356    /*Initialize Efficiency table for each of the CFI indices. The
2357     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2358    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][0] = &rgSchCmnNorCfi1Eff[0];
2359    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][1] = &rgSchCmnNorCfi2Eff[0];
2360    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][2] = &rgSchCmnNorCfi3Eff[0];
2361    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][3] = &rgSchCmnNorCfi4Eff[0];
2362    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2363    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][0] = &rgSchCmnNorCfi1Eff[0];
2364    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][1] = &rgSchCmnNorCfi2Eff[0];
2365    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][2] = &rgSchCmnNorCfi3Eff[0];
2366    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][3] = &rgSchCmnNorCfi4Eff[0];
2367    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2368    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][0] = &rgSchCmnNorCfi1Eff[0];
2369    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][1] = &rgSchCmnNorCfi2Eff[0];
2370    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][2] = &rgSchCmnNorCfi3Eff[0];
2371    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][3] = &rgSchCmnNorCfi4Eff[0];
2372
2373    /*Initialize CQI to TBS table for Layer Index 0 for Normal CP */
2374    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][0] = &rgSchCmnNorCfi1CqiToTbs[0];
2375    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][1] = &rgSchCmnNorCfi2CqiToTbs[0];
2376    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][2] = &rgSchCmnNorCfi3CqiToTbs[0];
2377    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][3] = &rgSchCmnNorCfi4CqiToTbs[0];
2378
2379    /*Intialize Efficency table for Layer Index 1 */
2380    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2381    /*Initialize Efficiency table for each of the CFI indices. The
2382     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2383    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][0] = &rgSchCmnNorCfi1Eff[1];
2384    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][1] = &rgSchCmnNorCfi2Eff[1];
2385    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][2] = &rgSchCmnNorCfi3Eff[1];
2386    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][3] = &rgSchCmnNorCfi4Eff[1];
2387    /*Initialize Efficiency table for Tx Antenna Port Index 1 */
2388    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][0] = &rgSchCmnNorCfi1Eff[1];
2389    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][1] = &rgSchCmnNorCfi2Eff[1];
2390    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][2] = &rgSchCmnNorCfi3Eff[1];
2391    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][3] = &rgSchCmnNorCfi4Eff[1];
2392    /*Initialize Efficiency table for Tx Antenna Port Index 2 */
2393    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][0] = &rgSchCmnNorCfi1Eff[1];
2394    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][1] = &rgSchCmnNorCfi2Eff[1];
2395    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][2] = &rgSchCmnNorCfi3Eff[1];
2396    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][3] = &rgSchCmnNorCfi4Eff[1];
2397
2398    /*Initialize CQI to TBS table for Layer Index 1 for Normal CP */
2399    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][0] = &rgSchCmnNorCfi1CqiToTbs[1];
2400    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][1] = &rgSchCmnNorCfi2CqiToTbs[1];
2401    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][2] = &rgSchCmnNorCfi3CqiToTbs[1];
2402    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][3] = &rgSchCmnNorCfi4CqiToTbs[1];
2403
2404    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2405    {
2406       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2407       {
2408          /* EfficiencyTbl calculation incase of 2 layers for normal CP  */
2409          rgSCHCmnCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
2410                rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i]);
2411          rgSCHCmn2LyrCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
2412                rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i]);
2413       }
2414    }
2415
2416    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2417    {
2418       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2419       {
2420          effTbl = rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i];
2421          tbsTbl = rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][i];
2422          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2423                (j >= 0) && (k > 0); --j)
2424          {
2425             /* ADD CQI to MCS mapping correction
2426             * single dimensional array is replaced by 2 dimensions for different CFI*/
2427             if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
2428             {
2429                (*tbsTbl)[k--] = (U8)j;
2430             }
2431          }
2432          for (; k > 0; --k)
2433          {
2434             (*tbsTbl)[k] = 0;
2435          }
2436          /* effTbl,tbsTbl calculation incase of 2 layers for normal CP */
2437          effTbl = rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i];
2438          tbsTbl = rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][i];
2439          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2440                (j >= 0) && (k > 0); --j)
2441          {
2442             /* ADD CQI to MCS mapping correction
2443             * single dimensional array is replaced by 2 dimensions for different CFI*/
2444             if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
2445             {
2446                (*tbsTbl)[k--] = (U8)j;
2447             }
2448          }
2449          for (; k > 0; --k)
2450          {
2451             (*tbsTbl)[k] = 0;
2452          }
2453       }
2454    }
2455
2456    /* Efficiency Table for Extended CP */
2457    /*Initialize Efficiency table for Layer Index 0 */
2458    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2459    /*Initialize Efficiency table for each of the CFI indices. The
2460     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2461    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][0] = &rgSchCmnExtCfi1Eff[0];
2462    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][1] = &rgSchCmnExtCfi2Eff[0];
2463    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][2] = &rgSchCmnExtCfi3Eff[0];
2464    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][3] = &rgSchCmnExtCfi4Eff[0];
2465    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2466    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][0] = &rgSchCmnExtCfi1Eff[0];
2467    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][1] = &rgSchCmnExtCfi2Eff[0];
2468    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][2] = &rgSchCmnExtCfi3Eff[0];
2469    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][3] = &rgSchCmnExtCfi4Eff[0];
2470    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2471    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][0] = &rgSchCmnExtCfi1Eff[0];
2472    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][1] = &rgSchCmnExtCfi2Eff[0];
2473    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][2] = &rgSchCmnExtCfi3Eff[0];
2474    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][3] = &rgSchCmnExtCfi4Eff[0];
2475
2476    /*Initialize CQI to TBS table for Layer Index 0 for Extended CP */
2477    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][0] = &rgSchCmnExtCfi1CqiToTbs[0];
2478    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][1] = &rgSchCmnExtCfi2CqiToTbs[0];
2479    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][2] = &rgSchCmnExtCfi3CqiToTbs[0];
2480    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][3] = &rgSchCmnExtCfi4CqiToTbs[0];
2481
2482    /*Initialize Efficiency table for Layer Index 1 */
2483    /*Initialize Efficiency table for each of the CFI indices. The
2484     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2485    /*Initialize Efficency table for Tx Antenna Port Index 0 */
2486    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][0] = &rgSchCmnExtCfi1Eff[1];
2487    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][1] = &rgSchCmnExtCfi2Eff[1];
2488    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][2] = &rgSchCmnExtCfi3Eff[1];
2489    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][3] = &rgSchCmnExtCfi4Eff[1];
2490    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2491    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][0] = &rgSchCmnExtCfi1Eff[1];
2492    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][1] = &rgSchCmnExtCfi2Eff[1];
2493    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][2] = &rgSchCmnExtCfi3Eff[1];
2494    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][3] = &rgSchCmnExtCfi4Eff[1];
2495    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2496    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][0] = &rgSchCmnExtCfi1Eff[1];
2497    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][1] = &rgSchCmnExtCfi2Eff[1];
2498    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][2] = &rgSchCmnExtCfi3Eff[1];
2499    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][3] = &rgSchCmnExtCfi4Eff[1];
2500
2501    /*Initialize CQI to TBS table for Layer Index 1 for Extended CP */
2502    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][0] = &rgSchCmnExtCfi1CqiToTbs[1];
2503    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][1] = &rgSchCmnExtCfi2CqiToTbs[1];
2504    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][2] = &rgSchCmnExtCfi3CqiToTbs[1];
2505    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][3] = &rgSchCmnExtCfi4CqiToTbs[1];
2506    /* Activate this code when extended cp is supported */
2507    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2508    {
2509       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2510       {
2511          /* EfficiencyTbl calculation incase of 2 layers for extendedl CP  */
2512          rgSCHCmnCompEff( (U8)(i + 1 ), (U8)RG_SCH_CMN_EXT_CP, idx,\
2513                rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i]);
2514          rgSCHCmn2LyrCompEff((U8)(i + 1), (U8) RG_SCH_CMN_EXT_CP,idx, \
2515                rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i]);
2516       }
2517    }
2518
2519    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2520    {
2521       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2522       {
2523          effTbl = rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i];
2524          tbsTbl = rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][i];
2525          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2526                (j >= 0) && (k > 0); --j)
2527          {
2528             /* ADD CQI to MCS mapping correction
2529             * single dimensional array is replaced by 2 dimensions for different CFI*/
2530             if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
2531             {
2532                (*tbsTbl)[k--] = (U8)j;
2533             }
2534          }
2535          for (; k > 0; --k)
2536          {
2537             (*tbsTbl)[k] = 0;
2538          }
2539          /* effTbl,tbsTbl calculation incase of 2 layers for extended CP */
2540          effTbl = rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i];
2541          tbsTbl = rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][i];
2542          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2543                (j >= 0) && (k > 0); --j)
2544          {
2545            /* ADD CQI to MCS mapping correction
2546             * single dimensional array is replaced by 2 dimensions for different CFI*/
2547             if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
2548             {
2549                (*tbsTbl)[k--] = (U8)j;
2550             }
2551          }
2552          for (; k > 0; --k)
2553          {
2554             (*tbsTbl)[k] = 0;
2555          }
2556       }
2557    }
2558    RETVOID;
2559 }
2560 \f
2561 /**
2562  * @brief This function initializes all the data for the scheduler.
2563  *
2564  * @details
2565  *
2566  *     Function: rgSCHCmnUlInit
2567  *     Purpose:  This function initializes the following information:
2568  *               1. Efficiency table
2569  *               2. CQI to table index - It is one row for upto 3 RBs
2570  *                  and another row for greater than 3 RBs
2571  *                  currently extended prefix is compiled out.
2572  *     Invoked by: MAC intialization code..may be ActvInit
2573  *
2574  *  @return  Void
2575  *
2576  **/
2577 #ifdef ANSI
2578 PRIVATE Void rgSCHCmnUlInit
2579 (
2580 )
2581 #else
2582 PRIVATE Void rgSCHCmnUlInit()
2583 #endif
2584 {
2585    U8              *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
2586    RgSchCmnTbSzEff    *effTbl    = &rgSchCmnNorUlEff[0];
2587    CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
2588    S16              i;
2589    S16              j;
2590    TRC2(rgSCHCmnUlInit);
2591
2592    /* Initaializing new variable added for UL eff */
2593    rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
2594    /* Reason behind using 3 as the number of symbols to rule out for
2595     * efficiency table computation would be that we are using 2 symbols for
2596     * DMRS(1 in each slot) and 1 symbol for SRS*/
2597    rgSCHCmnCompUlEff(RGSCH_UL_SYM_DMRS_SRS,RG_SCH_CMN_NOR_CP,rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP]);
2598
2599    for (i = RGSCH_NUM_ITBS - 1, j = RG_SCH_CMN_UL_NUM_CQI - 1;
2600          i >= 0 && j > 0; --i)
2601    {
2602       if ((*effTbl)[i] <= cqiTbl[j].eff)
2603       {
2604          mapTbl[j--] = (U8)i;
2605       }
2606    }
2607    for (; j > 0; --j)
2608    {
2609       mapTbl[j] = 0;
2610    }
2611    effTbl    = &rgSchCmnExtUlEff[0];
2612    mapTbl    = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_EXT_CP][0];
2613
2614    /* Initaializing new variable added for UL eff */
2615    rgSchCmnUlEffTbl[RG_SCH_CMN_EXT_CP] = &rgSchCmnExtUlEff[0];
2616    /* Reason behind using 3 as the number of symbols to rule out for
2617     * efficiency table computation would be that we are using 2 symbols for
2618     * DMRS(1 in each slot) and 1 symbol for SRS*/
2619    rgSCHCmnCompUlEff(3,RG_SCH_CMN_EXT_CP,rgSchCmnUlEffTbl[RG_SCH_CMN_EXT_CP]);
2620
2621    for (i = RGSCH_NUM_ITBS - 1, j = RG_SCH_CMN_UL_NUM_CQI - 1;
2622          i >= 0 && j > 0; --i)
2623    {
2624       if ((*effTbl)[i] <= cqiTbl[j].eff)
2625       {
2626          mapTbl[j--] = (U8)i;
2627       }
2628    }
2629    for (; j > 0; --j)
2630    {
2631       mapTbl[j] = 0;
2632    }
2633    rgSCHPwrInit();
2634    RETVOID;
2635 }
2636
2637 /**
2638  * @brief This function initializes all the data for the scheduler.
2639  *
2640  * @details
2641  *
2642  *     Function: rgSCHCmnInit
2643  *     Purpose:  This function initializes the following information:
2644  *               1. Efficiency table
2645  *               2. CQI to table index - It is one row for upto 3 RBs
2646  *                  and another row for greater than 3 RBs
2647  *                  currently extended prefix is compiled out.
2648  *     Invoked by: MAC intialization code..may be ActvInit
2649  *
2650  *  @return  Void
2651  *
2652  **/
2653 #ifdef ANSI
2654 PUBLIC Void rgSCHCmnInit
2655 (
2656 )
2657 #else
2658 PUBLIC Void rgSCHCmnInit()
2659 #endif
2660 {
2661    U8   idx;
2662    TRC2(rgSCHCmnInit);
2663
2664    rgSCHCmnDlInit();
2665    rgSCHCmnUlInit();
2666 #ifdef EMTC_ENABLE
2667    rgSCHEmtcCmnDlInit();
2668    rgSCHEmtcCmnUlInit();
2669 #endif      
2670 #ifdef LTEMAC_SPS
2671    rgSCHCmnSpsInit();
2672 #endif
2673
2674    /* Init the function pointers */
2675    rgSchCmnApis.rgSCHRgrUeCfg         = rgSCHCmnRgrUeCfg;
2676    rgSchCmnApis.rgSCHRgrUeRecfg       = rgSCHCmnRgrUeRecfg;
2677    rgSchCmnApis.rgSCHFreeUe           = rgSCHCmnUeDel;
2678    rgSchCmnApis.rgSCHRgrCellCfg       = rgSCHCmnRgrCellCfg;
2679    rgSchCmnApis.rgSCHRgrCellRecfg     = rgSCHCmnRgrCellRecfg;
2680    rgSchCmnApis.rgSCHFreeCell         = rgSCHCmnCellDel;
2681    rgSchCmnApis.rgSCHRgrLchCfg        = rgSCHCmnRgrLchCfg;
2682    rgSchCmnApis.rgSCHRgrLcgCfg        = rgSCHCmnRgrLcgCfg;
2683    rgSchCmnApis.rgSCHRgrLchRecfg      = rgSCHCmnRgrLchRecfg;
2684    rgSchCmnApis.rgSCHRgrLcgRecfg      = rgSCHCmnRgrLcgRecfg;
2685    rgSchCmnApis.rgSCHFreeDlLc         = rgSCHCmnFreeDlLc;
2686    rgSchCmnApis.rgSCHFreeLcg          = rgSCHCmnLcgDel;
2687    rgSchCmnApis.rgSCHRgrLchDel        = rgSCHCmnRgrLchDel;
2688    rgSchCmnApis.rgSCHActvtUlUe        = rgSCHCmnActvtUlUe;
2689    rgSchCmnApis.rgSCHActvtDlUe        = rgSCHCmnActvtDlUe;
2690    rgSchCmnApis.rgSCHHdlUlTransInd    = rgSCHCmnHdlUlTransInd;
2691    rgSchCmnApis.rgSCHDlDedBoUpd       = rgSCHCmnDlDedBoUpd;
2692    rgSchCmnApis.rgSCHUlRecMsg3Alloc   = rgSCHCmnUlRecMsg3Alloc;
2693    rgSchCmnApis.rgSCHUlCqiInd         = rgSCHCmnUlCqiInd;
2694    rgSchCmnApis.rgSCHPucchDeltaPwrInd = rgSCHPwrPucchDeltaInd;
2695    rgSchCmnApis.rgSCHUlHqProcForUe    = rgSCHCmnUlHqProcForUe;
2696 #ifdef RG_UNUSED
2697    rgSchCmnApis.rgSCHUpdUlHqProc      = rgSCHCmnUpdUlHqProc;
2698 #endif
2699    rgSchCmnApis.rgSCHUpdBsrShort      = rgSCHCmnUpdBsrShort;
2700    rgSchCmnApis.rgSCHUpdBsrTrunc      = rgSCHCmnUpdBsrTrunc;
2701    rgSchCmnApis.rgSCHUpdBsrLong       = rgSCHCmnUpdBsrLong;
2702    rgSchCmnApis.rgSCHUpdPhr           = rgSCHCmnUpdPhr;
2703    rgSchCmnApis.rgSCHUpdExtPhr        = rgSCHCmnUpdExtPhr;
2704    rgSchCmnApis.rgSCHContResUlGrant   = rgSCHCmnContResUlGrant;
2705    rgSchCmnApis.rgSCHSrRcvd           = rgSCHCmnSrRcvd;
2706    rgSchCmnApis.rgSCHFirstRcptnReq    = rgSCHCmnFirstRcptnReq;
2707    rgSchCmnApis.rgSCHNextRcptnReq     = rgSCHCmnNextRcptnReq;
2708    rgSchCmnApis.rgSCHFirstHqFdbkAlloc = rgSCHCmnFirstHqFdbkAlloc;
2709    rgSchCmnApis.rgSCHNextHqFdbkAlloc  = rgSCHCmnNextHqFdbkAlloc;
2710    rgSchCmnApis.rgSCHDlProcAddToRetx  = rgSCHCmnDlProcAddToRetx;
2711    rgSchCmnApis.rgSCHDlCqiInd         = rgSCHCmnDlCqiInd;
2712 #ifdef EMTC_ENABLE
2713    rgSchCmnApis.rgSCHUlProcAddToRetx  = rgSCHCmnEmtcUlProcAddToRetx;
2714 #endif
2715 #ifdef TFU_UPGRADE
2716    rgSchCmnApis.rgSCHSrsInd           = rgSCHCmnSrsInd;
2717 #endif
2718    rgSchCmnApis.rgSCHDlTARpt          = rgSCHCmnDlTARpt;
2719    rgSchCmnApis.rgSCHDlRlsSubFrm      = rgSCHCmnDlRlsSubFrm;
2720    rgSchCmnApis.rgSCHUeReset          = rgSCHCmnUeReset;
2721 #ifdef LTEMAC_SPS
2722    rgSchCmnApis.rgSCHHdlCrntiCE         = rgSCHCmnHdlCrntiCE;
2723    rgSchCmnApis.rgSCHDlProcAck        = rgSCHCmnDlProcAck;
2724    rgSchCmnApis.rgSCHDlRelPdcchFbk    = rgSCHCmnDlRelPdcchFbk;
2725    rgSchCmnApis.rgSCHUlSpsRelInd      = rgSCHCmnUlSpsRelInd;
2726    rgSchCmnApis.rgSCHUlSpsActInd      = rgSCHCmnUlSpsActInd;
2727    rgSchCmnApis.rgSCHUlCrcFailInd     = rgSCHCmnUlCrcFailInd;
2728    rgSchCmnApis.rgSCHUlCrcInd     = rgSCHCmnUlCrcInd;
2729 #endif
2730    rgSchCmnApis.rgSCHDrxStrtInActvTmrInUl = rgSCHCmnDrxStrtInActvTmrInUl;
2731    rgSchCmnApis.rgSCHUpdUeDataIndLcg      = rgSCHCmnUpdUeDataIndLcg;
2732
2733    for (idx = 0; idx < RGSCH_NUM_SCHEDULERS; ++idx)
2734    {
2735       rgSchUlSchdInits[idx](&rgSchUlSchdTbl[idx]);
2736       rgSchDlSchdInits[idx](&rgSchDlSchdTbl[idx]);
2737    }
2738 #ifdef EMTC_ENABLE 
2739    for (idx = 0; idx < RGSCH_NUM_EMTC_SCHEDULERS; ++idx)
2740    {
2741       rgSchEmtcUlSchdInits[idx](&rgSchEmtcUlSchdTbl[idx]);
2742       rgSchEmtcDlSchdInits[idx](&rgSchEmtcDlSchdTbl[idx]);
2743    }
2744 #endif
2745 #if (defined (RG_PHASE2_SCHED) && defined(TFU_UPGRADE))
2746    for (idx = 0; idx < RGSCH_NUM_DLFS_SCHEDULERS; ++idx)
2747    {
2748       rgSchDlfsSchdInits[idx](&rgSchDlfsSchdTbl[idx]);
2749    }
2750 #endif
2751 #ifdef LTE_ADV
2752    rgSchCmnApis.rgSCHRgrSCellUeCfg         = rgSCHCmnRgrSCellUeCfg;
2753    rgSchCmnApis.rgSCHRgrSCellUeDel         = rgSCHCmnRgrSCellUeDel;
2754 #endif
2755    RETVOID;
2756 }
2757
2758 \f
2759 /**
2760  * @brief This function is a wrapper to call scheduler specific API.
2761  *
2762  * @details
2763  *
2764  *     Function: rgSCHCmnDlRlsSubFrm
2765  *     Purpose:  Releases scheduler Information from DL SubFrm.
2766  *
2767  *     Invoked by: DHM
2768  *
2769  *  @param[in]   RgSchCellCb     *cell
2770  *  @param[out]  CmLteTimingInfo frm
2771  *  @return  Void
2772  *
2773  **/
2774 #ifdef ANSI
2775 PUBLIC Void rgSCHCmnDlRlsSubFrm
2776 (
2777 RgSchCellCb        *cell,
2778 CmLteTimingInfo   frm
2779 )
2780 #else
2781 PUBLIC Void rgSCHCmnDlRlsSubFrm(cell, frm)
2782 RgSchCellCb        *cell;
2783 CmLteTimingInfo    frm;
2784 #endif
2785 {
2786    RgSchCmnCell        *cellSch = RG_SCH_CMN_GET_CELL(cell);
2787    RgSchDlSf           *sf;
2788
2789    TRC2(rgSCHCmnDlRlsSubFrm);
2790
2791    /* Get the pointer to the subframe */
2792    sf = rgSCHUtlSubFrmGet(cell, frm);
2793
2794    rgSCHUtlSubFrmPut(cell, sf);
2795    if (sf->dlfsSf)
2796    {
2797       /* Re-initialize DLFS specific information for the sub-frame */
2798       cellSch->apisDlfs->rgSCHDlfsReinitSf(cell, sf);
2799    }
2800    RETVOID;
2801 }
2802
2803
2804 \f
2805 /**
2806  * @brief This function is the starting function for DL allocation.
2807  *
2808  * @details
2809  *
2810  *     Function: rgSCHCmnDlCmnChAlloc
2811  *     Purpose:  Scheduling for downlink. It performs allocation in the order
2812  *               of priority wich BCCH/PCH first, CCCH, Random Access and TA.
2813  *
2814  *     Invoked by: Scheduler
2815  *
2816  *  @param[in]  RgSchCellCb*           cell
2817  *  @param[out] RgSchCmnDlRbAllocInfo* allocInfo
2818  *  @return  Void
2819  *
2820  **/
2821 #ifdef ANSI
2822 PRIVATE Void rgSCHCmnDlCcchRarAlloc
2823 (
2824 RgSchCellCb             *cell
2825 )
2826 #else
2827 PRIVATE Void rgSCHCmnDlCcchRarAlloc(cell)
2828 RgSchCellCb             *cell;
2829 #endif
2830 {
2831    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
2832
2833    TRC2(rgSCHCmnDlCcchRarAlloc);
2834
2835    rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
2836    /* LTE_ADV_FLAG_REMOVED_START */
2837    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2838    {
2839       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2840       {
2841          /*eNodeB need to blank the subframe */
2842       }
2843       else
2844       {
2845          rgSCHCmnDlCcchTx(cell, &cellSch->allocInfo);
2846       }
2847    }
2848    else
2849    {
2850       rgSCHCmnDlCcchTx(cell, &cellSch->allocInfo);
2851    }
2852    /* LTE_ADV_FLAG_REMOVED_END */
2853
2854 #ifdef RGR_V1
2855
2856    /*Added these function calls for processing CCCH SDU arriving
2857     * after guard timer expiry.Functions differ from above two functions
2858     * in using ueCb instead of raCb.*/
2859    rgSCHCmnDlCcchSduRetx(cell, &cellSch->allocInfo);
2860    /* LTE_ADV_FLAG_REMOVED_START */
2861    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2862    {
2863       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2864       {
2865          /*eNodeB need to blank the subframe */
2866       }
2867       else
2868       {
2869          rgSCHCmnDlCcchSduTx(cell, &cellSch->allocInfo);
2870       }
2871    }
2872    else
2873    {
2874       rgSCHCmnDlCcchSduTx(cell, &cellSch->allocInfo);
2875    }
2876    /* LTE_ADV_FLAG_REMOVED_END */
2877 #endif
2878
2879 #ifdef LTE_TDD
2880    if(cellSch->ul.msg3SchdIdx != RGSCH_INVALID_INFO)
2881    {
2882       /* Do not schedule msg3 if there is a CFI change ongoing */
2883       if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2884       {
2885          rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2886       }
2887    }
2888 #else
2889    /* LTE_ADV_FLAG_REMOVED_START */
2890    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2891    {
2892       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2893       {
2894          /*eNodeB need to blank the subframe */
2895       }
2896       else
2897       {
2898          /* Do not schedule msg3 if there is a CFI change ongoing */
2899          if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2900          {
2901             rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2902          }
2903       }
2904    }
2905    else
2906    {
2907       /* Do not schedule msg3 if there is a CFI change ongoing */
2908       if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2909       {
2910          rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2911       }
2912    }
2913    /* LTE_ADV_FLAG_REMOVED_END */
2914 #endif
2915
2916    RETVOID;
2917 }
2918
2919 #ifdef RGR_V1
2920 /**
2921  * @brief Scheduling for CCCH SDU.
2922  *
2923  * @details
2924  *
2925  *     Function: rgSCHCmnCcchSduAlloc
2926  *     Purpose:  Scheduling for CCCH SDU
2927  *
2928  *     Invoked by: Scheduler
2929  *
2930  *  @param[in]  RgSchCellCb*          cell
2931  *  @param[in]  RgSchUeCb*            ueCb
2932  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
2933  *  @return  S16
2934  *
2935  **/
2936 #ifdef ANSI
2937 PRIVATE S16 rgSCHCmnCcchSduAlloc
2938 (
2939 RgSchCellCb                *cell,
2940 RgSchUeCb                  *ueCb,
2941 RgSchCmnDlRbAllocInfo      *allocInfo
2942 )
2943 #else
2944 PRIVATE S16 rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)
2945 RgSchCellCb                *cell;
2946 RgSchUeCb                  *ueCb;
2947 RgSchCmnDlRbAllocInfo      *allocInfo;
2948 #endif
2949 {
2950    RgSchDlRbAlloc  *rbAllocInfo;
2951    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
2952    RgSchCmnDlUe       *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
2953
2954    TRC2(rgSCHCmnCcchSduAlloc);
2955
2956    /* Return if subframe BW exhausted */
2957    if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
2958        allocInfo->ccchSduAlloc.ccchSduDlSf->bwAssigned)
2959    {
2960       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2961          "bw<=bwAssigned for UEID:%d",ueCb->ueId);
2962       RETVALUE(RFAILED);
2963    }
2964
2965    if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
2966    {
2967       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2968          "rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
2969       RETVALUE(RFAILED);
2970    }
2971
2972    rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
2973    rbAllocInfo->dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
2974
2975    if (rgSCHCmnCcchSduDedAlloc(cell, ueCb) != ROK)
2976    {
2977       /* Fix : syed Minor failure handling, release hqP if Unsuccessful */    
2978       rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
2979       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2980          "rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
2981       RETVALUE(RFAILED);
2982    }
2983    cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
2984    ueDl->proc->reqLnk.node = (PTR)ueDl->proc;
2985    allocInfo->ccchSduAlloc.ccchSduDlSf->schdCcchUe++;
2986
2987    RETVALUE(ROK);
2988 }
2989 /**
2990  * @brief This function scheduler for downlink CCCH messages.
2991  *
2992  * @details
2993  *
2994  *     Function: rgSCHCmnDlCcchSduTx
2995  *     Purpose:  Scheduling for downlink CCCH
2996  *
2997  *     Invoked by: Scheduler
2998  *
2999  *  @param[in]  RgSchCellCb           *cell
3000  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3001  *  @return  Void
3002  *
3003  **/
3004 #ifdef ANSI
3005 PRIVATE Void rgSCHCmnDlCcchSduTx
3006 (
3007 RgSchCellCb             *cell,
3008 RgSchCmnDlRbAllocInfo   *allocInfo
3009 )
3010 #else
3011 PRIVATE Void rgSCHCmnDlCcchSduTx(cell, allocInfo)
3012 RgSchCellCb             *cell;
3013 RgSchCmnDlRbAllocInfo   *allocInfo;
3014 #endif
3015 {
3016    CmLList           *node;
3017    RgSchUeCb         *ueCb;
3018    RgSchCmnDlUe      *ueCmnDl;
3019    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3020
3021    RgSchDlSf         *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
3022    
3023    TRC2(rgSCHCmnDlCcchSduTx);
3024
3025    node = cell->ccchSduUeLst.first;
3026    while(node)
3027    {
3028       if(cellSch->dl.maxCcchPerDlSf &&
3029             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3030       {
3031          break;
3032       }
3033       else
3034       {
3035          ueCb = (RgSchUeCb *)(node->node);
3036          ueCmnDl  = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
3037          node = node->next;
3038          /* Fix : syed postpone scheduling for this
3039           * until msg4 is done */
3040          /* Fix : syed RLC can erroneously send CCCH SDU BO 
3041           * twice. Hence an extra guard to avoid if already 
3042           * scheduled for RETX */
3043          if ((!(ueCb->dl.dlInactvMask & RG_HQENT_INACTIVE)) &&
3044                (!ueCmnDl->proc))
3045          {
3046             if ((rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)) != ROK)
3047             {
3048                break;
3049             }
3050          }
3051          else
3052          {
3053             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"ERROR!! THIS SHOULD "
3054                      "NEVER HAPPEN for UEID:%d", ueCb->ueId);
3055             continue;
3056          }
3057       }
3058    }
3059    RETVOID;
3060 }
3061 #endif
3062 \f
3063 /**
3064  * @brief This function scheduler for downlink CCCH messages.
3065  *
3066  * @details
3067  *
3068  *     Function: rgSCHCmnDlCcchTx
3069  *     Purpose:  Scheduling for downlink CCCH
3070  *
3071  *     Invoked by: Scheduler
3072  *
3073  *  @param[in]  RgSchCellCb           *cell
3074  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3075  *  @return  Void
3076  *
3077  **/
3078 #ifdef ANSI
3079 PRIVATE Void rgSCHCmnDlCcchTx
3080 (
3081 RgSchCellCb             *cell,
3082 RgSchCmnDlRbAllocInfo   *allocInfo
3083 )
3084 #else
3085 PRIVATE Void rgSCHCmnDlCcchTx(cell, allocInfo)
3086 RgSchCellCb             *cell;
3087 RgSchCmnDlRbAllocInfo   *allocInfo;
3088 #endif
3089 {
3090    CmLList           *node;
3091    RgSchRaCb         *raCb;
3092    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3093    RgSchDlSf         *dlSf = allocInfo->msg4Alloc.msg4DlSf;
3094    
3095    TRC2(rgSCHCmnDlCcchTx);
3096
3097    node = cell->raInfo.toBeSchdLst.first;
3098    while(node)
3099    {
3100       if(cellSch->dl.maxCcchPerDlSf &&
3101             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3102       {
3103          break;
3104       }
3105       else
3106       {
3107
3108          raCb = (RgSchRaCb *)(node->node);
3109          node = node->next;
3110          /* Address allocation for this UE for MSG 4 */
3111          /* Allocation for Msg4 */
3112          if ((rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)) != ROK)
3113          {
3114             break;
3115          }
3116       }
3117    }
3118    RETVOID;
3119 }
3120
3121 #ifdef RGR_V1
3122 /**
3123  * @brief This function scheduler for downlink CCCH messages.
3124  *
3125  * @details
3126  *
3127  *     Function: rgSCHCmnDlCcchSduRetx
3128  *     Purpose:  Scheduling for downlink CCCH
3129  *
3130  *     Invoked by: Scheduler
3131  *
3132  *  @param[in]  RgSchCellCb           *cell
3133  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3134  *  @return  Void
3135  *
3136  **/
3137 #ifdef ANSI
3138 PRIVATE Void rgSCHCmnDlCcchSduRetx
3139 (
3140 RgSchCellCb             *cell,
3141 RgSchCmnDlRbAllocInfo   *allocInfo
3142 )
3143 #else
3144 PRIVATE Void rgSCHCmnDlCcchSduRetx(cell, allocInfo)
3145 RgSchCellCb             *cell;
3146 RgSchCmnDlRbAllocInfo   *allocInfo;
3147 #endif
3148 {
3149    RgSchDlRbAlloc  *rbAllocInfo;
3150    CmLList           *node;
3151    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3152    RgSchUeCb         *ueCb;
3153    RgSchDlHqProcCb   *hqP;
3154    U8                retxBw = 0;
3155    RgSchCmnDlUe      *ueDl;
3156    RgSchDlSf         *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
3157    
3158    TRC2(rgSCHCmnDlCcchSduRetx);
3159
3160    node = cellSch->dl.ccchSduRetxLst.first;
3161    while(node)
3162    {
3163       if(cellSch->dl.maxCcchPerDlSf &&
3164             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3165       {
3166          break;
3167       }
3168       else
3169       {
3170
3171          hqP = (RgSchDlHqProcCb *)(node->node);
3172          node = node->next;
3173
3174          /* DwPts Scheduling Changes Start */      
3175 #ifdef LTE_TDD
3176          if (rgSCHCmnRetxAvoidTdd(allocInfo->ccchSduAlloc.ccchSduDlSf, 
3177                   cell, hqP) == TRUE)
3178          {
3179             continue;  
3180          }
3181 #endif
3182          /* DwPts Scheduling Changes End */     
3183
3184          if (hqP->tbInfo[0].dlGrnt.numRb > (dlSf->bw - dlSf->bwAssigned))
3185          {
3186             break;
3187          }
3188          ueCb = (RgSchUeCb*)(hqP->hqE->ue);
3189          ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
3190
3191          rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
3192          /* Fill RB Alloc Info */
3193          rbAllocInfo->dlSf = dlSf;
3194          rbAllocInfo->tbInfo[0].bytesReq =  hqP->tbInfo[0].ccchSchdInfo.totBytes;
3195          rbAllocInfo->rbsReq = hqP->tbInfo[0].dlGrnt.numRb;
3196          /* Fix : syed iMcs setting did not correspond to RETX */
3197          RG_SCH_CMN_GET_MCS_FOR_RETX((&hqP->tbInfo[0]), 
3198                rbAllocInfo->tbInfo[0].imcs);
3199          rbAllocInfo->rnti = ueCb->ueId;
3200          rbAllocInfo->tbInfo[0].noLyr = hqP->tbInfo[0].numLyrs;
3201          /* Fix : syed Copying info in entirety without depending on stale TX information */
3202          rbAllocInfo->tbInfo[0].tbCb = &hqP->tbInfo[0];
3203          rbAllocInfo->tbInfo[0].schdlngForTb = TRUE;
3204          /* Fix : syed Assigning proc to scratchpad */ 
3205          ueDl->proc = hqP;
3206
3207          retxBw += rbAllocInfo->rbsReq;
3208
3209          cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduRetxLst, \
3210                &hqP->reqLnk);
3211          hqP->reqLnk.node = (PTR)hqP;
3212          dlSf->schdCcchUe++;
3213       }
3214    }
3215    dlSf->bwAssigned += retxBw;
3216    RETVOID;
3217 }
3218 #endif
3219 \f
3220 /**
3221  * @brief This function scheduler for downlink CCCH messages.
3222  *
3223  * @details
3224  *
3225  *     Function: rgSCHCmnDlCcchRetx
3226  *     Purpose:  Scheduling for downlink CCCH
3227  *
3228  *     Invoked by: Scheduler
3229  *
3230  *  @param[in]  RgSchCellCb           *cell
3231  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3232  *  @return  Void
3233  *
3234  **/
3235 #ifdef ANSI
3236 PRIVATE Void rgSCHCmnDlCcchRetx
3237 (
3238 RgSchCellCb             *cell,
3239 RgSchCmnDlRbAllocInfo   *allocInfo
3240 )
3241 #else
3242 PRIVATE Void rgSCHCmnDlCcchRetx(cell, allocInfo)
3243 RgSchCellCb             *cell;
3244 RgSchCmnDlRbAllocInfo   *allocInfo;
3245 #endif
3246 {
3247    CmLList           *node;
3248    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3249    RgSchRaCb         *raCb;
3250    RgSchDlHqProcCb   *hqP;
3251    U8                retxBw = 0;
3252    RgSchDlSf         *dlSf = allocInfo->msg4Alloc.msg4DlSf;
3253         
3254    TRC2(rgSCHCmnDlCcchRetx);
3255
3256    node = cellSch->dl.msg4RetxLst.first;
3257    while(node)
3258    {
3259       if(cellSch->dl.maxCcchPerDlSf &&
3260             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3261       {
3262          break;
3263       }
3264       else
3265       {
3266          hqP = (RgSchDlHqProcCb *)(node->node);
3267
3268          node = node->next;
3269
3270          /* DwPts Scheduling Changes Start */     
3271 #ifdef LTE_TDD      
3272          if (rgSCHCmnRetxAvoidTdd(allocInfo->msg4Alloc.msg4DlSf, 
3273                   cell, hqP) == TRUE)
3274          {
3275             continue;  
3276          }
3277 #endif      
3278          /* DwPts Scheduling Changes End */      
3279
3280          if (hqP->tbInfo[0].dlGrnt.numRb > (dlSf->bw - dlSf->bwAssigned))
3281          {
3282             break;
3283          }
3284          raCb = (RgSchRaCb*)(hqP->hqE->raCb);
3285          /* Fill RB Alloc Info */
3286          raCb->rbAllocInfo.dlSf = dlSf;
3287          raCb->rbAllocInfo.tbInfo[0].bytesReq =  hqP->tbInfo[0].ccchSchdInfo.totBytes;
3288          raCb->rbAllocInfo.rbsReq = hqP->tbInfo[0].dlGrnt.numRb;
3289          /* Fix : syed iMcs setting did not correspond to RETX */
3290          RG_SCH_CMN_GET_MCS_FOR_RETX((&hqP->tbInfo[0]), 
3291                raCb->rbAllocInfo.tbInfo[0].imcs);
3292          raCb->rbAllocInfo.rnti = raCb->tmpCrnti;
3293          raCb->rbAllocInfo.tbInfo[0].noLyr = hqP->tbInfo[0].numLyrs;
3294          /* Fix; syed Copying info in entirety without depending on stale TX information */
3295          raCb->rbAllocInfo.tbInfo[0].tbCb = &hqP->tbInfo[0];
3296          raCb->rbAllocInfo.tbInfo[0].schdlngForTb = TRUE;
3297
3298          retxBw += raCb->rbAllocInfo.rbsReq;
3299
3300          cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4RetxLst, \
3301                &hqP->reqLnk);
3302          hqP->reqLnk.node = (PTR)hqP;
3303          dlSf->schdCcchUe++;
3304       }
3305    }
3306    dlSf->bwAssigned += retxBw;
3307    RETVOID;
3308 }
3309
3310 \f
3311 /**
3312  * @brief This function implements scheduler DL allocation for
3313  *        for broadcast (on PDSCH) and paging.
3314  *
3315  * @details
3316  *
3317  *     Function: rgSCHCmnDlBcchPcch
3318  *     Purpose:  This function implements scheduler for DL allocation
3319  *               for broadcast (on PDSCH) and paging.
3320  *
3321  *     Invoked by: Scheduler
3322  *
3323  *  @param[in]  RgSchCellCb*     cell
3324  *  @return  S16
3325  *      -# ROK
3326  *      -# RFAILED
3327  **/
3328 #ifdef ANSI
3329 PRIVATE Void rgSCHCmnDlBcchPcch
3330 (
3331 RgSchCellCb             *cell,
3332 RgSchCmnDlRbAllocInfo   *allocInfo,
3333 RgInfSfAlloc            *subfrmAlloc
3334 )
3335 #else
3336 PRIVATE Void rgSCHCmnDlBcchPcch(cell, allocInfo, subfrmAlloc)
3337 RgSchCellCb             *cell;
3338 RgSchCmnDlRbAllocInfo   *allocInfo;
3339 RgInfSfAlloc            *subfrmAlloc;
3340 #endif
3341 {
3342    CmLteTimingInfo   frm;
3343    RgSchDlSf         *sf;
3344    RgSchClcDlLcCb    *pcch;
3345    RgSchClcBoRpt     *bo;
3346 #ifndef RGR_SI_SCH
3347    Bool              valid;
3348    RgSchClcDlLcCb    *bcch, *bch;
3349 #endif/*RGR_SI_SCH*/
3350
3351
3352    TRC2(rgSCHCmnDlBcchPcch);
3353
3354    frm   = cell->crntTime;
3355 #ifdef LTEMAC_HDFDD
3356    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
3357       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
3358    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
3359 #else
3360   // RGSCH_SUBFRAME_INDEX(frm);
3361    //RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
3362 #endif
3363
3364    /* Compute the subframe for which allocation is being made        */
3365    /* essentially, we need pointer to the dl frame for this subframe */
3366    sf = rgSCHUtlSubFrmGet(cell, frm);
3367
3368
3369 #ifndef RGR_SI_SCH
3370    bch = rgSCHDbmGetBcchOnBch(cell);
3371 #if (ERRCLASS & ERRCLS_DEBUG)
3372    if (bch == NULLP)
3373    {
3374       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
3375       RETVOID;
3376    }
3377 #endif
3378    if (bch->boLst.first != NULLP)
3379    {
3380       bo = (RgSchClcBoRpt *)(bch->boLst.first->node);
3381       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3382       {
3383          sf->bch.tbSize = bo->bo;
3384          cmLListDelFrm(&bch->boLst, bch->boLst.first);
3385          /* ccpu00117052 - MOD - Passing double pointer
3386             for proper NULLP assignment*/
3387          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(*bo));
3388          rgSCHUtlFillRgInfCmnLcInfo(sf, subfrmAlloc, bch->lcId,TRUE);
3389       }
3390    }
3391    else
3392    {
3393       if ((frm.sfn % 4 == 0) && (frm.subframe == 0))
3394       {
3395       }
3396    }
3397
3398    allocInfo->bcchAlloc.schdFirst = FALSE;
3399    bcch = rgSCHDbmGetFirstBcchOnDlsch(cell);
3400 #if (ERRCLASS & ERRCLS_DEBUG)
3401    if (bcch == NULLP)
3402    {
3403       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
3404       RETVOID;
3405    }
3406 #endif
3407    if (bcch->boLst.first != NULLP)
3408    {
3409       bo = (RgSchClcBoRpt *)(bcch->boLst.first->node);
3410
3411       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3412       {
3413          allocInfo->bcchAlloc.schdFirst = TRUE;
3414          /* Time to perform allocation for this BCCH transmission */
3415          rgSCHCmnClcAlloc(cell, sf, bcch, RGSCH_SI_RNTI, allocInfo);
3416       }
3417    }
3418
3419    if(!allocInfo->bcchAlloc.schdFirst)
3420    {
3421       CmLList   *lnk;
3422       bcch = rgSCHDbmGetSecondBcchOnDlsch(cell);
3423 #if (ERRCLASS & ERRCLS_DEBUG)
3424       if (bcch == NULLP)
3425       {
3426          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
3427          RETVOID;
3428       }
3429 #endif
3430       lnk = bcch->boLst.first;
3431       while (lnk != NULLP)
3432       {
3433          bo = (RgSchClcBoRpt *)(lnk->node);
3434          lnk = lnk->next;
3435          valid = rgSCHCmnChkInWin(frm, bo->timeToTx, bo->maxTimeToTx);
3436
3437          if(valid)
3438          {
3439             bo->i = RGSCH_CALC_SF_DIFF(frm, bo->timeToTx);
3440             /* Time to perform allocation for this BCCH transmission */
3441             rgSCHCmnClcAlloc(cell, sf, bcch, RGSCH_SI_RNTI, allocInfo);
3442             break;
3443          }
3444          else
3445          {
3446             valid = rgSCHCmnChkPastWin(frm, bo->maxTimeToTx);
3447             if(valid)
3448             {
3449                cmLListDelFrm(&bcch->boLst, &bo->boLstEnt);
3450                /* ccpu00117052 - MOD - Passing double pointer
3451                   for proper NULLP assignment*/
3452                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo,
3453                      sizeof(RgSchClcBoRpt));
3454             }
3455          }
3456       }
3457    }
3458 #else
3459    rgSCHDlSiSched(cell, allocInfo, subfrmAlloc);
3460 #endif/*RGR_SI_SCH*/
3461
3462    pcch = rgSCHDbmGetPcch(cell);
3463 #ifdef ERRCLS_KW
3464    if (pcch == NULLP)
3465    {
3466       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
3467       RETVOID;
3468    }
3469 #endif
3470    if (pcch->boLst.first != NULLP)
3471    {
3472       bo = (RgSchClcBoRpt *)(pcch->boLst.first->node);
3473
3474       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3475       {
3476          /* Time to perform allocation for this PCCH transmission */
3477          rgSCHCmnClcAlloc(cell, sf, pcch, RGSCH_P_RNTI, allocInfo);
3478       }
3479    }
3480    RETVOID;
3481 }
3482
3483 /*
3484 *
3485 *       Fun:   rgSCHCmnChkInWin
3486 *
3487 *       Desc:  This function checks if frm occurs in window
3488 *
3489 *       Ret:   TRUE      - if in window
3490 *              FALSE     - otherwise
3491 *
3492 *       Notes: None
3493 *
3494 *       File:  rg_sch_cmn.c
3495 *
3496 */
3497 #ifdef ANSI
3498 PUBLIC Bool rgSCHCmnChkInWin
3499 (
3500 CmLteTimingInfo   frm,
3501 CmLteTimingInfo   start,
3502 CmLteTimingInfo   end
3503 )
3504 #else
3505 PUBLIC Bool rgSCHCmnChkInWin(frm, start, end)
3506 CmLteTimingInfo   frm;
3507 CmLteTimingInfo   start;
3508 CmLteTimingInfo   end;
3509 #endif
3510 {
3511    Bool    inWin = FALSE;
3512
3513    TRC2(rgSCHCmnChkInWin);
3514
3515    if (end.sfn > start.sfn)
3516    {
3517       if (frm.sfn > start.sfn
3518             || (frm.sfn == start.sfn && frm.slot >= start.slot))
3519       {
3520          if (frm.sfn < end.sfn
3521 #ifdef EMTC_ENABLE
3522                || (frm.sfn == end.sfn && frm.slot <= end.slot))
3523 #else
3524                || (frm.sfn == end.sfn && frm.slot <= start.slot))
3525 #endif
3526          {
3527             inWin = TRUE;
3528          }
3529       }
3530    }
3531    /* Testing for wrap around, sfn wraparound check should be enough */
3532    else if (end.sfn < start.sfn)
3533    {
3534       if (frm.sfn > start.sfn
3535             || (frm.sfn == start.sfn && frm.slot >= start.slot))
3536       {
3537          inWin = TRUE;
3538       }
3539       else
3540       {
3541          if (frm.sfn < end.sfn
3542                || (frm.sfn == end.sfn && frm.slot <= end.slot))
3543          {
3544             inWin = TRUE;
3545          }
3546       }
3547    }
3548    else  /* start.sfn == end.sfn */
3549    {
3550       if (frm.sfn == start.sfn
3551             && (frm.slot >= start.slot
3552                && frm.slot <= end.slot))
3553       {
3554          inWin = TRUE;
3555       }
3556    }
3557
3558    RETVALUE(inWin);
3559 } /* end of rgSCHCmnChkInWin*/
3560
3561 /*
3562 *
3563 *       Fun:   rgSCHCmnChkPastWin
3564 *
3565 *       Desc:  This function checks if frm has gone past window edge
3566 *
3567 *       Ret:   TRUE      - if past window edge
3568 *              FALSE     - otherwise
3569 *
3570 *       Notes: None
3571 *
3572 *       File:  rg_sch_cmn.c
3573 *
3574 */
3575 #ifdef ANSI
3576 PUBLIC Bool rgSCHCmnChkPastWin
3577 (
3578 CmLteTimingInfo   frm,
3579 CmLteTimingInfo   end
3580 )
3581 #else
3582 PUBLIC Bool rgSCHCmnChkPastWin(frm, end)
3583 CmLteTimingInfo   frm;
3584 CmLteTimingInfo   end;
3585 #endif
3586 {
3587    CmLteTimingInfo  refFrm = end;
3588    Bool             pastWin;
3589
3590    TRC2(rgSCHCmnChkPastWin);
3591
3592    RGSCH_INCR_FRAME(refFrm.sfn);
3593    RGSCH_INCR_SUB_FRAME(end, 1);
3594    pastWin = rgSCHCmnChkInWin(frm, end, refFrm);
3595
3596    RETVALUE(pastWin);
3597 } /* end of rgSCHCmnChkPastWin*/
3598 \f
3599 /**
3600  * @brief This function implements allocation of the resources for common
3601  * channels BCCH, PCCH.
3602  *
3603  * @details
3604  *
3605  *     Function: rgSCHCmnClcAlloc
3606  *     Purpose:  This function implements selection of number of RBs based
3607  *               the allowed grant for the service. It is also responsible
3608  *               for selection of MCS for the transmission.
3609  *
3610  *     Invoked by: Scheduler
3611  *
3612  *  @param[in]  RgSchCellCb                *cell,
3613  *  @param[in]  RgSchDlSf                  *sf,
3614  *  @param[in]  RgSchClcDlLcCb             *lch,
3615  *  @param[in]  U16                        rnti,
3616  *  @param[out] RgSchCmnDlRbAllocInfo      *allocInfo
3617  *  @return     Void
3618  *
3619  **/
3620 #ifdef ANSI
3621 PRIVATE Void rgSCHCmnClcAlloc
3622 (
3623 RgSchCellCb             *cell,
3624 RgSchDlSf               *sf,
3625 RgSchClcDlLcCb          *lch,
3626 U16                     rnti,
3627 RgSchCmnDlRbAllocInfo   *allocInfo
3628 )
3629 #else
3630 PRIVATE Void rgSCHCmnClcAlloc(cell, sf, lch, rnti, allocInfo)
3631 RgSchCellCb             *cell;
3632 RgSchDlSf               *sf;
3633 RgSchClcDlLcCb          *lch;
3634 U16                     rnti;
3635 RgSchCmnDlRbAllocInfo   *allocInfo;
3636 #endif
3637 {
3638    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
3639    RgSchClcBoRpt        *bo;
3640    U32                  rb=0;
3641    U8                   mcs;
3642    U32                  tbs;
3643 #ifdef LTE_TDD   
3644    U8                   lostRe;
3645    U8                   cfi = cellDl->currCfi;  
3646 #endif
3647
3648    TRC2(rgSCHCmnClcAlloc);
3649
3650    bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
3651
3652    mcs = bo->mcs;
3653    tbs = bo->bo;
3654    /* rgSCHCmnClcRbAllocForFxdTb(cell, bo->bo, cellDl->ccchCqi, &rb);*/
3655    if(cellDl->bitsPerRb==0)
3656    {
3657       while ((rgTbSzTbl[0][0][rb]) < (tbs*8))
3658       {
3659          rb++;
3660       }
3661       rb = rb+1;
3662    }
3663    else
3664    {
3665       rb = RGSCH_CEIL((tbs*8), cellDl->bitsPerRb);
3666    }
3667    /* DwPTS Scheduling Changes Start */   
3668 #ifdef LTE_TDD
3669    if(sf->sfType == RG_SCH_SPL_SF_DATA) 
3670    {
3671       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
3672
3673       /* Calculate the less RE's because of DwPTS */
3674       lostRe = rb * (cellDl->noResPerRb[cfi] - cellDl->numReDwPts[cfi]);
3675
3676       /* Increase number of RBs in Spl SF to compensate for lost REs */
3677       rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]); 
3678    }
3679 #endif
3680    /* DwPTS Scheduling Changes End */   
3681    /*ccpu00115595- end*/
3682    /* additional check to see if required RBs
3683     * exceeds the available */
3684    if (rb > sf->bw - sf->bwAssigned)
3685    {
3686       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
3687                 "failed for CRNTI:%d",rnti);
3688       RETVOID;
3689    }
3690
3691    /* Update the subframe Allocated BW field */
3692    sf->bwAssigned = sf->bwAssigned + rb;
3693    /* Fill in the BCCH/PCCH transmission info to the RBAllocInfo struct */
3694    if (rnti == RGSCH_SI_RNTI)
3695    {
3696       allocInfo->bcchAlloc.rnti = rnti;
3697       allocInfo->bcchAlloc.dlSf = sf;
3698       allocInfo->bcchAlloc.tbInfo[0].bytesReq = tbs;
3699       allocInfo->bcchAlloc.rbsReq = rb;
3700       allocInfo->bcchAlloc.tbInfo[0].imcs = mcs;
3701       allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
3702       /* Nprb indication at PHY for common Ch */
3703       allocInfo->bcchAlloc.nPrb = bo->nPrb;
3704    }
3705    else
3706    {
3707       allocInfo->pcchAlloc.rnti = rnti;
3708       allocInfo->pcchAlloc.dlSf = sf;
3709       allocInfo->pcchAlloc.tbInfo[0].bytesReq = tbs;
3710       allocInfo->pcchAlloc.rbsReq = rb;
3711       allocInfo->pcchAlloc.tbInfo[0].imcs = mcs;
3712       allocInfo->pcchAlloc.tbInfo[0].noLyr = 1;
3713       allocInfo->pcchAlloc.nPrb = bo->nPrb;
3714    }
3715    RETVOID;
3716 }
3717
3718 \f
3719 /**
3720  * @brief This function implements PDCCH allocation for common channels.
3721  *
3722  * @details
3723  *
3724  *     Function: rgSCHCmnCmnPdcchAlloc
3725  *     Purpose:  This function implements allocation of PDCCH for a UE.
3726  *               1. This uses index 0 of PDCCH table for efficiency.
3727  *               2. Uses he candidate PDCCH count for the aggr level.
3728  *               3. Look for availability for each candidate and choose
3729  *                  the first one available.
3730  *
3731  *     Invoked by: Scheduler
3732  *
3733  *  @param[in]  RgSchCellCb           *cell
3734  *  @param[in]  RgSchDlSf             *sf
3735  *  @return     RgSchPdcch *
3736  *               -# NULLP when unsuccessful
3737  *
3738  **/
3739 #ifdef ANSI
3740 PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc
3741 (
3742 RgSchCellCb                *cell,
3743 RgSchDlSf                  *subFrm
3744 )
3745 #else
3746 PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
3747 RgSchCellCb                *cell;
3748 RgSchDlSf                  *subFrm;
3749 #endif
3750 {
3751    CmLteAggrLvl         aggrLvl;
3752    RgSchPdcchInfo       *pdcchInfo;
3753    RgSchPdcch           *pdcch;
3754    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
3755    U8                   numCce;  /*store num CCEs based on 
3756                                   aggregation level */
3757    TRC2(rgSCHCmnCmnPdcchAlloc);
3758
3759    aggrLvl   = cellSch->dl.cmnChAggrLvl;
3760
3761    pdcchInfo = &(subFrm->pdcchInfo);
3762
3763     /* Updating the no. of nCce in pdcchInfo, in case if CFI
3764     * was changed  */
3765 #ifdef LTE_TDD
3766    if(subFrm->nCce != pdcchInfo->nCce)
3767    {   
3768       rgSCHUtlPdcchInit(cell, subFrm, subFrm->nCce);
3769    }
3770 #else   
3771    if(cell->nCce != pdcchInfo->nCce)
3772    {
3773       rgSCHUtlPdcchInit(cell, subFrm, cell->nCce);
3774    }
3775 #endif  
3776
3777    switch (aggrLvl)
3778    {
3779       case CM_LTE_AGGR_LVL4:
3780         numCce = 4;
3781         break;
3782       case CM_LTE_AGGR_LVL8:
3783         numCce = 8;
3784         break;
3785                 case CM_LTE_AGGR_LVL16:
3786         numCce = 16;
3787         break;
3788       default:
3789         RETVALUE(NULLP);
3790    }
3791
3792    if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
3793    {
3794 #ifdef LTEMAC_SPS
3795       pdcch->isSpsRnti = FALSE;
3796 #endif
3797       /* Increment the CCE used counter in the current subframe */
3798       subFrm->cceCnt += numCce;
3799       pdcch->pdcchSearchSpace = RG_SCH_CMN_SEARCH_SPACE;
3800
3801       RETVALUE(pdcch);
3802    }
3803
3804    /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
3805    subFrm->isCceFailure = TRUE;
3806
3807    RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
3808             "PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u", 
3809             aggrLvl);
3810    RETVALUE(NULLP);
3811 }
3812
3813 \f
3814 /**
3815  * @brief This function implements bandwidth allocation for common channels.
3816  *
3817  * @details
3818  *
3819  *     Function: rgSCHCmnClcRbAlloc
3820  *     Purpose:  This function implements bandwith allocation logic
3821  *               for common control channels.
3822  *
3823  *     Invoked by: Scheduler
3824  *
3825  *  @param[in]  RgSchCellCb*  cell
3826  *  @param[in]  U32           bo
3827  *  @param[in]  U8            cqi
3828  *  @param[in]  U8            *rb
3829  *  @param[in]  U32           *tbs
3830  *  @param[in]  U8            *mcs
3831  *  @param[in]  RgSchDlSf     *sf
3832  *  @return  Void
3833  *
3834  **/
3835 #ifdef LTEMAC_SPS
3836 #ifdef ANSI
3837 PUBLIC Void rgSCHCmnClcRbAlloc
3838 (
3839 RgSchCellCb             *cell,
3840 U32                     bo,
3841 U8                      cqi,
3842 U8                      *rb,
3843 U32                     *tbs,
3844 U8                      *mcs,
3845 U8                      *iTbs,
3846 Bool                    isSpsBo,
3847 RgSchDlSf               *sf 
3848 )
3849 #else
3850 PUBLIC Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
3851 RgSchCellCb             *cell;
3852 U32                     bo;
3853 U8                      cqi;
3854 U8                      *rb;
3855 U32                     *tbs;
3856 U8                      *mcs;
3857 U8                      *iTbs;
3858 Bool                    isSpsBo;
3859 RgSchDlSf               *sf; 
3860 #endif
3861 #else
3862 #ifdef ANSI
3863 PRIVATE Void rgSCHCmnClcRbAlloc
3864 (
3865 RgSchCellCb             *cell,
3866 U32                     bo,
3867 U8                      cqi,
3868 U8                      *rb,
3869 U32                     *tbs,
3870 U8                      *mcs,
3871 RgSchDlSf               *sf 
3872 )
3873 #else
3874 PRIVATE Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
3875 RgSchCellCb             *cell;
3876 U32                     bo;
3877 U8                      cqi;
3878 U8                      *rb;
3879 U32                     *tbs;
3880 U8                      *mcs;
3881 RgSchDlSf               *sf; 
3882 #endif
3883 #endif /* LTEMAC_SPS */
3884 {
3885    U8                   iTbsVal;
3886    RgSchCmnTbSzEff      *effTbl;
3887    U32                  eff;
3888    U32                  noRes;
3889    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
3890    U8                   cfi = cellSch->dl.currCfi;
3891    U32                  tmpRb=0;
3892    TRC2(rgSCHCmnClcRbAlloc);
3893
3894    /* first get the CQI to MCS table and determine the number of RBs */
3895    effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
3896    iTbsVal = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[cqi];
3897    RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
3898
3899    /* Efficiency is number of bits per 1024 REs */
3900    eff  = (*effTbl)[iTbsVal];
3901
3902    /* Get the number of REs needed for this bo  */
3903    noRes = ((bo * 8 * 1024) / eff );
3904
3905    /* Get the number of RBs needed for this transmission */
3906    /* Number of RBs = No of REs / No of REs per RB       */
3907    tmpRb = RGSCH_CEIL(noRes, cellSch->dl.noResPerRb[cfi]);
3908    /* KWORK_FIX: added check to see if rb has crossed maxRb*/
3909    RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
3910    if (tmpRb > cellSch->dl.maxDlBwPerUe)
3911    {
3912       tmpRb = cellSch->dl.maxDlBwPerUe;
3913    }
3914    while ((rgTbSzTbl[0][iTbsVal][tmpRb-1]/8) < bo && 
3915            (tmpRb < cellSch->dl.maxDlBwPerUe))
3916    {
3917       tmpRb++;
3918       RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
3919    }
3920    *tbs =  rgTbSzTbl[0][iTbsVal][tmpRb-1]/8;
3921    *rb = (U8)tmpRb;
3922    RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
3923
3924    RETVOID;
3925 }
3926
3927 \f
3928
3929 /**
3930  * @brief Scheduling for MSG4.
3931  *
3932  * @details
3933  *
3934  *     Function: rgSCHCmnMsg4Alloc
3935  *     Purpose:  Scheduling for MSG4
3936  *
3937  *     Invoked by: Scheduler
3938  *
3939  *  @param[in]  RgSchCellCb*          cell
3940  *  @param[in]  RgSchRaCb*            raCb
3941  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3942  *  @return  S16
3943  *
3944  **/
3945 #ifdef ANSI
3946 PRIVATE S16 rgSCHCmnMsg4Alloc
3947 (
3948 RgSchCellCb                *cell,
3949 RgSchRaCb                  *raCb,
3950 RgSchCmnDlRbAllocInfo      *allocInfo
3951 )
3952 #else
3953 PRIVATE S16 rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)
3954 RgSchCellCb                *cell;
3955 RgSchRaCb                  *raCb;
3956 RgSchCmnDlRbAllocInfo      *allocInfo;
3957 #endif
3958 {
3959    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
3960
3961    TRC2(rgSCHCmnMsg4Alloc);
3962
3963  /* SR_RACH_STATS : MSG4 TO BE TXED */
3964    rgNumMsg4ToBeTx++;
3965    /* Return if subframe BW exhausted */
3966    if (allocInfo->msg4Alloc.msg4DlSf->bw <=
3967        allocInfo->msg4Alloc.msg4DlSf->bwAssigned)
3968    {
3969       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
3970          "bw<=bwAssigned");
3971       RETVALUE(RFAILED);
3972    }
3973
3974    if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
3975    {
3976       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
3977          "rgSCHDhmGetMsg4HqProc failed");
3978       RETVALUE(RFAILED);
3979    }
3980
3981    raCb->rbAllocInfo.dlSf = allocInfo->msg4Alloc.msg4DlSf;
3982
3983    if (rgSCHCmnMsg4DedAlloc(cell, raCb) != ROK)
3984    {
3985       /* Fix : syed Minor failure handling, release hqP if Unsuccessful */    
3986       rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
3987       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
3988          "rgSCHCmnMsg4DedAlloc failed.");
3989       RETVALUE(RFAILED);
3990    }
3991    cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
3992    raCb->dlHqE->msg4Proc->reqLnk.node = (PTR)raCb->dlHqE->msg4Proc;
3993    allocInfo->msg4Alloc.msg4DlSf->schdCcchUe++;
3994
3995    RETVALUE(ROK);
3996 }
3997
3998 \f
3999 /**
4000  * @brief This function implements PDCCH allocation for an UE.
4001  *
4002  * @details
4003  *
4004  *     Function: PdcchAlloc
4005  *     Purpose:  This function implements allocation of PDCCH for an UE.
4006  *               1. Get the aggregation level for the CQI of the UE.
4007  *               2. Get the candidate PDCCH count for the aggr level.
4008  *               3. Look for availability for each candidate and choose
4009  *                  the first one available.
4010  *
4011  *     Invoked by: Scheduler
4012  *
4013  *  @param[in]  cell
4014  *  @param[in]  subFrm
4015  *  @param[in]  cqi
4016  *  @param[in]  dciFrmt
4017  *  @return  RgSchPdcch *
4018  *         -# NULLP when unsuccessful
4019  *
4020  **/
4021 #ifdef ANSI
4022 PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc
4023 (
4024 RgSchCellCb             *cell,
4025 RgSchUeCb               *ue,
4026 RgSchDlSf               *subFrm,
4027 U8                      cqi,
4028 TfuDciFormat            dciFrmt,
4029 Bool                    isDtx
4030 )
4031 #else
4032 PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
4033 RgSchCellCb             *cell;
4034 RgSchUeCb               *ue;
4035 RgSchDlSf               *subFrm;
4036 U8                      cqi;
4037 TfuDciFormat            dciFrmt;
4038 Bool                    isDtx;
4039 #endif
4040 {
4041    CmLteAggrLvl     aggrLvl;
4042    RgSchPdcchInfo   *pdcchInfo;
4043    RgSchPdcch       *pdcch;
4044
4045    TRC2(rgSCHCmnPdcchAlloc);
4046
4047    /* 3.1 consider the selected DCI format size in determining the
4048     * aggregation level */
4049    //TODO_SID Need to update. Currently using 4 aggregation level
4050    aggrLvl   = CM_LTE_AGGR_LVL2;//cellSch->dciAggrLvl[cqi][dciFrmt];
4051
4052 #ifdef LTE_ADV
4053    if((dciFrmt == TFU_DCI_FORMAT_1A) &&
4054       ((ue) && (ue->allocCmnUlPdcch)) )
4055    {
4056       pdcch = rgSCHCmnCmnPdcchAlloc(cell, subFrm);
4057       /* Since CRNTI Scrambled */
4058       if(NULLP != pdcch)
4059       {
4060          pdcch->dciNumOfBits = ue->dciSize.cmnSize[dciFrmt];
4061         // prc_trace_format_string(PRC_TRACE_GROUP_PS, PRC_TRACE_INFO_LOW,"Forcing alloc in CMN search spc size %d fmt %d \n",
4062         // pdcch->dciNumOfBits, dciFrmt);
4063       }
4064       RETVALUE(pdcch);
4065    }
4066 #endif
4067
4068    /* Incrementing aggrLvl by 1 if it not AGGR_LVL8(MAX SIZE)
4069     * inorder to increse the redudancy bits for better decoding of UE */
4070    if (isDtx)
4071    {
4072       if (aggrLvl != CM_LTE_AGGR_LVL16)
4073       {
4074          switch(aggrLvl)
4075          {
4076             case CM_LTE_AGGR_LVL2:
4077                aggrLvl = CM_LTE_AGGR_LVL4;
4078                 break;
4079             case CM_LTE_AGGR_LVL4:
4080                aggrLvl = CM_LTE_AGGR_LVL8;
4081                break;
4082             case CM_LTE_AGGR_LVL8:
4083                aggrLvl = CM_LTE_AGGR_LVL16;
4084                break;
4085             default:
4086                break;
4087          }
4088          /* aggrLvl   += 1; */
4089       }
4090    }
4091
4092    pdcchInfo = &subFrm->pdcchInfo;
4093
4094    /* Updating the no. of nCce in pdcchInfo, in case if CFI
4095     * was changed  */
4096 #ifdef LTE_TDD
4097    if(subFrm->nCce != pdcchInfo->nCce)
4098    {   
4099       rgSCHUtlPdcchInit(cell, subFrm, subFrm->nCce);
4100    }
4101 #else   
4102    if(cell->nCce != pdcchInfo->nCce)
4103    {
4104       rgSCHUtlPdcchInit(cell, subFrm, cell->nCce);
4105    }
4106 #endif       
4107
4108    if (pdcchInfo->nCce < (1 << (aggrLvl - 1)))
4109    {
4110       /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
4111       subFrm->isCceFailure = TRUE;
4112       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
4113             "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)", 
4114             aggrLvl);
4115
4116       RETVALUE(NULLP);
4117    }
4118
4119    if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
4120    {
4121       /* SR_RACH_STATS : Reset isTBMsg4 */
4122       pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4= FALSE;         
4123       pdcch->dci.u.format0Info.isSrGrant = FALSE;
4124 #ifdef LTEMAC_SPS
4125       pdcch->isSpsRnti = FALSE;
4126 #endif
4127       /* Increment the CCE used counter in the current subframe */
4128       subFrm->cceCnt += aggrLvl;
4129       pdcch->pdcchSearchSpace = RG_SCH_UE_SPECIFIC_SEARCH_SPACE;
4130       if (ue != NULLP)
4131                 {
4132 #ifdef LTE_ADV
4133                  if (ue->cell != cell)
4134                  {
4135                     /* Secondary Cell */
4136                     //pdcch->dciNumOfBits = ue->dciSize.noUlCcSize[dciFrmt];
4137                     pdcch->dciNumOfBits = MAX_5GTF_DCIA1B1_SIZE;
4138                  }
4139                  else
4140 #endif
4141                  {
4142                     //pdcch->dciNumOfBits = ue->dciSize.dedSize[dciFrmt];
4143                     //TODO_SID Need to update dci size.
4144                     pdcch->dciNumOfBits = MAX_5GTF_DCIA1B1_SIZE;
4145                  }
4146                 }
4147       else
4148       {
4149          /* MSG4 */
4150          pdcch->dciNumOfBits = cell->dciSize.size[dciFrmt];
4151       }
4152       RETVALUE(pdcch);
4153    }
4154
4155    /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
4156    subFrm->isCceFailure = TRUE;
4157
4158    RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
4159          "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
4160          aggrLvl);
4161    RETVALUE(NULLP);
4162 }
4163
4164 #ifdef RGR_V1
4165 /**
4166  * @brief This function implements BW allocation for CCCH SDU
4167  *
4168  * @details
4169  *
4170  *     Function: rgSCHCmnCcchSduDedAlloc
4171  *     Purpose:  Downlink bandwidth Allocation for CCCH SDU.
4172  *
4173  *     Invoked by: Scheduler
4174  *
4175  *  @param[in]  RgSchCellCb*     cell
4176  *  @param[out] RgSchUeCb        *ueCb
4177  *  @return S16
4178  *
4179  **/
4180 #ifdef ANSI
4181 PRIVATE S16 rgSCHCmnCcchSduDedAlloc
4182 (
4183 RgSchCellCb      *cell,
4184 RgSchUeCb        *ueCb
4185 )
4186 #else
4187 PRIVATE S16 rgSCHCmnCcchSduDedAlloc(cell, ueCb)
4188 RgSchCellCb      *cell;
4189 RgSchUeCb        *ueCb;
4190 #endif
4191 {
4192    RgSchDlHqEnt      *hqE = NULLP;
4193    U32                  effBo;
4194    RgSchDlRbAlloc       *rbAllocinfo = NULLP;
4195    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4196    U8                   iTbs;
4197    U8                   numRb;
4198 #ifdef LTE_TDD
4199    U8                   cfi     = cellDl->currCfi;
4200 #endif
4201
4202    TRC2(rgSCHCmnCcchSduDedAlloc);
4203
4204    rbAllocinfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
4205
4206    effBo  =   ueCb->dlCcchInfo.bo + RGSCH_CCCH_SDU_HDRSIZE;
4207
4208 #ifndef LTEMAC_SPS
4209    rgSCHCmnClcRbAlloc(cell, effBo, cellDl->ccchCqi, &rbAllocinfo->rbsReq, \
4210                       &rbAllocinfo->tbInfo[0].bytesReq,
4211                       &rbAllocinfo->tbInfo[0].imcs, rbAllocinfo->dlSf);
4212 #else /* LTEMAC_SPS */
4213    rgSCHCmnClcRbAlloc(cell, effBo, cellDl->ccchCqi, &rbAllocinfo->rbsReq, \
4214                       &rbAllocinfo->tbInfo[0].bytesReq,\
4215                       &rbAllocinfo->tbInfo[0].imcs, &iTbs, FALSE, 
4216                       rbAllocinfo->dlSf);
4217 #endif /* LTEMAC_SPS */
4218
4219    iTbs = 0;
4220    /* Cannot exceed the total number of RBs in the cell */
4221    if ((S16)rbAllocinfo->rbsReq > ((S16)(rbAllocinfo->dlSf->bw - \
4222                                    rbAllocinfo->dlSf->bwAssigned)))
4223    {
4224       /* Check if atleast one allocation was possible.
4225          This may be the case where the Bw is very less and
4226          with the configured CCCH CQI, CCCH SDU exceeds the min Bw */
4227       if (rbAllocinfo->dlSf->bwAssigned == 0)
4228       {
4229          numRb   = rbAllocinfo->dlSf->bw;
4230          RG_SCH_CMN_DL_MCS_TO_TBS(rbAllocinfo->tbInfo[0].imcs, iTbs);
4231          while (rgTbSzTbl[0][++iTbs][numRb-1]/8 < effBo)
4232          {
4233             iTbs++;
4234          }
4235          rbAllocinfo->rbsReq = numRb;
4236          rbAllocinfo->tbInfo[0].bytesReq = rgTbSzTbl[0][iTbs][numRb-1]/8;
4237          /* DwPTS Scheduling Changes Start */
4238 #ifdef LTE_TDD
4239          if(rbAllocinfo->dlSf->sfType == RG_SCH_SPL_SF_DATA)
4240          {
4241             rbAllocinfo->tbInfo[0].bytesReq =
4242                rgSCHCmnCalcDwPtsTbSz(cell, effBo, &numRb, &iTbs, 1,cfi);
4243          }
4244 #endif
4245          /* DwPTS Scheduling Changes End */
4246          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, rbAllocinfo->tbInfo[0].imcs);
4247       }
4248       else
4249       {
4250          RETVALUE(RFAILED);
4251       }
4252    }
4253
4254    /* Update the subframe Allocated BW field */
4255    rbAllocinfo->dlSf->bwAssigned = rbAllocinfo->dlSf->bwAssigned + \
4256                                    rbAllocinfo->rbsReq;
4257    hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
4258    rbAllocinfo->tbInfo[0].tbCb = &hqE->ccchSduProc->tbInfo[0];
4259    rbAllocinfo->rnti = ueCb->ueId;
4260    rbAllocinfo->tbInfo[0].noLyr = 1;
4261
4262    RETVALUE(ROK);
4263 }
4264 #endif
4265 \f
4266 /**
4267  * @brief This function implements BW allocation for MSG4
4268  *
4269  * @details
4270  *
4271  *     Function: rgSCHCmnMsg4DedAlloc
4272  *     Purpose:  Downlink bandwidth Allocation for MSG4.
4273  *
4274  *     Invoked by: Scheduler
4275  *
4276  *  @param[in]  RgSchCellCb*     cell
4277  *  @param[out] RgSchRaCb        *raCb
4278  *  @return S16
4279  *
4280  **/
4281 #ifdef ANSI
4282 PRIVATE S16 rgSCHCmnMsg4DedAlloc
4283 (
4284 RgSchCellCb      *cell,
4285 RgSchRaCb        *raCb
4286 )
4287 #else
4288 PRIVATE S16 rgSCHCmnMsg4DedAlloc(cell, raCb)
4289 RgSchCellCb      *cell;
4290 RgSchRaCb        *raCb;
4291 #endif
4292 {
4293    U32                  effBo;
4294    RgSchDlRbAlloc       *rbAllocinfo = &raCb->rbAllocInfo;
4295    U8                   iTbs;
4296    U8                   numRb;
4297 #ifdef LTE_TDD
4298    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4299    U8                   cfi     = cellDl->currCfi;
4300 #endif
4301
4302    TRC2(rgSCHCmnMsg4DedAlloc);
4303
4304    effBo  = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
4305
4306 #ifndef LTEMAC_SPS
4307    rgSCHCmnClcRbAlloc(cell, effBo, raCb->ccchCqi, &rbAllocinfo->rbsReq, \
4308          &rbAllocinfo->tbInfo[0].bytesReq,\
4309          &rbAllocinfo->tbInfo[0].imcs, rbAllocinfo->dlSf);
4310 #else /* LTEMAC_SPS */
4311    rgSCHCmnClcRbAlloc(cell, effBo, raCb->ccchCqi, &rbAllocinfo->rbsReq, \
4312                       &rbAllocinfo->tbInfo[0].bytesReq,\
4313                       &rbAllocinfo->tbInfo[0].imcs, &iTbs, FALSE,
4314                       rbAllocinfo->dlSf);
4315 #endif /* LTEMAC_SPS */
4316
4317    iTbs = 0;
4318    /* Cannot exceed the total number of RBs in the cell */
4319    if ((S16)rbAllocinfo->rbsReq > ((S16)(rbAllocinfo->dlSf->bw - \
4320                rbAllocinfo->dlSf->bwAssigned)))
4321    {
4322       /* Check if atleast one allocation was possible.
4323          This may be the case where the Bw is very less and
4324          with the configured CCCH CQI, CCCH SDU exceeds the min Bw */
4325       if (rbAllocinfo->dlSf->bwAssigned == 0)
4326       {
4327          numRb   = rbAllocinfo->dlSf->bw;
4328          RG_SCH_CMN_DL_MCS_TO_TBS(rbAllocinfo->tbInfo[0].imcs, iTbs);
4329          while (rgTbSzTbl[0][++iTbs][numRb-1]/8 < effBo)
4330          {
4331             iTbs++;
4332          }
4333          rbAllocinfo->rbsReq = numRb;
4334          rbAllocinfo->tbInfo[0].bytesReq = rgTbSzTbl[0][iTbs][numRb-1]/8;
4335          /* DwPTS Scheduling Changes Start */
4336 #ifdef LTE_TDD
4337          if(rbAllocinfo->dlSf->sfType == RG_SCH_SPL_SF_DATA)
4338          {
4339             rbAllocinfo->tbInfo[0].bytesReq =
4340                rgSCHCmnCalcDwPtsTbSz(cell, effBo, &numRb, &iTbs, 1, cfi);
4341          }
4342 #endif
4343          /* DwPTS Scheduling Changes End */
4344          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, rbAllocinfo->tbInfo[0].imcs);
4345       }
4346       else
4347       {
4348          RETVALUE(RFAILED);
4349       }
4350    }
4351
4352    /* Update the subframe Allocated BW field */
4353    rbAllocinfo->dlSf->bwAssigned = rbAllocinfo->dlSf->bwAssigned + \
4354                                    rbAllocinfo->rbsReq;
4355    rbAllocinfo->rnti = raCb->tmpCrnti;
4356    rbAllocinfo->tbInfo[0].tbCb = &raCb->dlHqE->msg4Proc->tbInfo[0];
4357    rbAllocinfo->tbInfo[0].schdlngForTb = TRUE;
4358    rbAllocinfo->tbInfo[0].noLyr = 1;
4359
4360    RETVALUE(ROK);
4361 }
4362
4363 #ifdef LTE_TDD
4364 /**
4365  * @brief This function implements scheduling for RA Response.
4366  *
4367  * @details
4368  *
4369  *     Function: rgSCHCmnDlRaRsp
4370  *     Purpose:  Downlink scheduling for RA responses.
4371  *
4372  *     Invoked by: Scheduler
4373  *
4374  *  @param[in]  RgSchCellCb*     cell
4375  *  @return  Void
4376  *
4377  **/
4378 #ifdef ANSI
4379 PRIVATE Void rgSCHCmnDlRaRsp
4380 (
4381 RgSchCellCb                *cell,
4382 RgSchCmnDlRbAllocInfo      *allocInfo
4383 )
4384 #else
4385 PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
4386 RgSchCellCb                *cell;
4387 RgSchCmnDlRbAllocInfo      *allocInfo;
4388 #endif
4389 {
4390    CmLteTimingInfo      frm;
4391    CmLteTimingInfo      schFrm;
4392    RgSchDlSf            *subFrm;
4393    U16                  rarnti;
4394    U8                   i;
4395    U8                   noRaRnti=0;
4396    U8                   raIdx;
4397    RgSchTddRachRspLst   *rachRsp;
4398    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
4399    U8                   sfnIdx;
4400    U8                   subfrmIdx;
4401    U16                  rntiIdx=0;
4402    TRC2(rgSCHCmnDlRaRsp);
4403
4404    frm   = cell->crntTime;
4405    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
4406
4407    /* Compute the subframe for which allocation is being made        */
4408    /* essentially, we need pointer to the dl frame for this subframe */
4409    subFrm  = rgSCHUtlSubFrmGet(cell, frm);
4410
4411    /* Get the RACH Response scheduling related information
4412     * for the subframe with RA index */
4413    raIdx = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][frm.subframe]-1;
4414
4415    rachRsp = &cell->rachRspLst[raIdx];
4416
4417    for(sfnIdx = 0; sfnIdx < rachRsp->numRadiofrms; sfnIdx++)
4418    {
4419       /* For all scheduled RACH Responses in SFNs */
4420       schFrm = frm;
4421       RG_SCH_CMN_DECR_FRAME(schFrm.sfn, rachRsp->rachRsp[sfnIdx].sfnOffset);
4422       /* For all scheduled RACH Responses in subframes */
4423       for(subfrmIdx = 0;
4424             subfrmIdx < rachRsp->rachRsp[sfnIdx].numSubfrms; subfrmIdx++)
4425       {
4426          schFrm.subframe = rachRsp->rachRsp[sfnIdx].subframe[subfrmIdx];
4427          /* compute the last RA RNTI used in the previous subframe */
4428          raIdx = (((schFrm.sfn % cell->raInfo.maxRaSize) * \
4429                   RGSCH_NUM_SUB_FRAMES * RGSCH_MAX_RA_RNTI_PER_SUBFRM) \
4430                                     + schFrm.subframe);
4431
4432          /* For all RA RNTIs within a subframe */
4433
4434          for(i=0; (i < RGSCH_MAX_RA_RNTI_PER_SUBFRM) && \
4435                (noRaRnti < RGSCH_MAX_TDD_RA_RSP_ALLOC); i++)
4436          {
4437             rarnti = (schFrm.subframe + RGSCH_NUM_SUB_FRAMES*i + 1);
4438             rntiIdx = (raIdx + RGSCH_NUM_SUB_FRAMES*i);
4439
4440             if (cell->raInfo.raReqLst[rntiIdx].first != NULLP)
4441             {
4442                /* compute the next RA RNTI */
4443                if (rgSCHCmnRaRspAlloc(cell, subFrm, rntiIdx,
4444                         rarnti, noRaRnti, allocInfo) != ROK)
4445                {
4446                   /* The resources are exhausted */
4447                   break;
4448                }
4449                noRaRnti++;
4450             }
4451          }
4452          noRaRnti=0;
4453       }
4454    }
4455
4456    RETVOID;
4457 }
4458 #else
4459 /**
4460  * @brief This function implements scheduling for RA Response.
4461  *
4462  * @details
4463  *
4464  *     Function: rgSCHCmnDlRaRsp
4465  *     Purpose:  Downlink scheduling for RA responses.
4466  *
4467  *     Invoked by: Scheduler
4468  *
4469  *  @param[in]  RgSchCellCb*          cell
4470  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
4471  *  @return  Void
4472  *
4473  **/
4474 #ifdef ANSI
4475 PRIVATE Void rgSCHCmnDlRaRsp  //FDD
4476 (
4477 RgSchCellCb                *cell,
4478 RgSchCmnDlRbAllocInfo      *allocInfo
4479 )
4480 #else
4481 PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
4482 RgSchCellCb                *cell;
4483 RgSchCmnDlRbAllocInfo      *allocInfo;
4484 #endif
4485 {
4486    CmLteTimingInfo      frm;
4487    CmLteTimingInfo      winStartFrm;
4488    RgSchDlSf            *subFrm;
4489    U8                   winStartIdx;
4490    U8                   winGap;
4491    U8                   rarnti;
4492    U8                   raIdx;
4493    RgSchCmnCell         *sched;
4494    U8                   i,noRaRnti=0;
4495    TRC2(rgSCHCmnDlRaRsp);
4496
4497    frm   = cell->crntTime;
4498    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
4499
4500    /* Compute the subframe for which allocation is being made        */
4501    /* essentially, we need pointer to the dl frame for this subframe */
4502    subFrm  = rgSCHUtlSubFrmGet(cell, frm);
4503    sched   = RG_SCH_CMN_GET_CELL(cell);
4504
4505    /* ccpu00132523 - Window Start calculated by considering RAR window size, 
4506     * RAR Wait period, Subframes occuppied for respective preamble format*/
4507    winGap = (sched->dl.numRaSubFrms-1) + (cell->rachCfg.raWinSize-1) 
4508              +RGSCH_RARSP_WAIT_PERIOD;
4509
4510    /* Window starting occassion is retrieved using the gap and tried to 
4511     * fit to the size of raReqLst array*/ 
4512    RGSCHDECRFRMCRNTTIME(frm, winStartFrm, winGap);
4513
4514         //5G_TODO TIMING update. Need to check
4515    winStartIdx = (winStartFrm.sfn & 1) * RGSCH_MAX_RA_RNTI+ winStartFrm.slot;
4516
4517    for(i = 0; ((i < cell->rachCfg.raWinSize) && (noRaRnti < RG_SCH_CMN_MAX_CMN_PDCCH)); i++)
4518    {
4519       raIdx = (winStartIdx + i) % RGSCH_RAREQ_ARRAY_SIZE;
4520
4521       if (cell->raInfo.raReqLst[raIdx].first != NULLP)
4522       {
4523          allocInfo->raRspAlloc[noRaRnti].biEstmt = \
4524                          (!i * RGSCH_ONE_BIHDR_SIZE);
4525          rarnti = raIdx % RGSCH_MAX_RA_RNTI+ 1;
4526          if (rgSCHCmnRaRspAlloc(cell, subFrm, raIdx,
4527                                  rarnti, noRaRnti, allocInfo) != ROK)
4528          {
4529             /* The resources are exhausted */
4530             break;
4531          }
4532          /* ccpu00132523- If all the RAP ids are not scheduled then need not 
4533           * proceed for next RA RNTIs*/
4534          if(allocInfo->raRspAlloc[noRaRnti].numRapids < cell->raInfo.raReqLst[raIdx].count)
4535          {
4536             break;
4537          }
4538          noRaRnti++; /* Max of RG_SCH_CMN_MAX_CMN_PDCCH RARNTIs
4539                         for response allocation */
4540       }
4541    }
4542    RETVOID;
4543 }
4544 #endif
4545
4546 \f
4547 /**
4548  * @brief This function allocates the resources for an RARNTI.
4549  *
4550  * @details
4551  *
4552  *     Function: rgSCHCmnRaRspAlloc
4553  *     Purpose:  Allocate resources to a RARNTI.
4554  *               0. Allocate PDCCH for sending the response.
4555  *               1. Locate the number of RA requests pending for the RARNTI.
4556  *               2. Compute the size of data to be built.
4557  *               3. Using common channel CQI, compute the number of RBs.
4558  *
4559  *     Invoked by: Scheduler
4560  *
4561  *  @param[in]  RgSchCellCb             *cell,
4562  *  @param[in]  RgSchDlSf               *subFrm,
4563  *  @param[in]  U16                     rarnti,
4564  *  @param[in]  U8                      noRaRnti
4565  *  @param[out] RgSchCmnDlRbAllocInfo   *allocInfo
4566  *  @return  S16
4567  *
4568  **/
4569 #ifdef ANSI
4570 PRIVATE S16 rgSCHCmnRaRspAlloc
4571 (
4572 RgSchCellCb             *cell,
4573 RgSchDlSf               *subFrm,
4574 U16                     raIndex,
4575 U16                     rarnti,
4576 U8                      noRaRnti,
4577 RgSchCmnDlRbAllocInfo   *allocInfo
4578 )
4579 #else
4580 PRIVATE S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
4581 RgSchCellCb             *cell;
4582 RgSchDlSf               *subFrm;
4583 U16                     raIndex;
4584 U16                     rarnti;
4585 U8                      noRaRnti;
4586 RgSchCmnDlRbAllocInfo   *allocInfo;
4587 #endif
4588 {
4589    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4590    RgSchCmnUlCell       *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4591    U16                  noBytes;
4592    U32                  rb = 0;
4593    U32                  tbs;
4594    /*ccpu00116700,ccpu00116708- Corrected the wrong type for mcs*/
4595    U8                   mcs;
4596    CmLListCp            *reqLst;
4597    /* RACH handling related changes */
4598    Bool                 isAlloc = FALSE;
4599    static U8            schdNumRapid = 0;
4600    U8                   remNumRapid = 0;
4601    U8                   nPrb = 0;
4602    S32                  allwdTbSz = 0;
4603 #ifdef LTE_TDD   
4604    U16                  lostRe;  
4605    U8                   cfi = cellDl->currCfi;  
4606 #endif   
4607
4608    TRC2(rgSCHCmnRaRspAlloc);
4609 #ifndef RGR_V1
4610    UNUSED(cellUl);
4611 #endif
4612
4613    /* ccpu00132523: Resetting the schdRap Id count in every scheduling subframe*/
4614    if(noRaRnti == 0)
4615    {
4616       schdNumRapid = 0;
4617    }
4618
4619
4620    if (subFrm->bw == subFrm->bwAssigned)
4621    {
4622       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4623          "bw == bwAssigned RARNTI:%d",rarnti);
4624       RETVALUE(RFAILED);
4625    }
4626
4627    reqLst = &cell->raInfo.raReqLst[raIndex];
4628    if (reqLst->count == 0)
4629    {
4630       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4631          "reqLst Count=0 RARNTI:%d",rarnti);
4632       RETVALUE(RFAILED);
4633    }
4634    remNumRapid = reqLst->count;
4635
4636 #ifdef RGR_V1
4637    /* Limit number of rach rsps to maxMsg3PerUlsf */
4638    if ( schdNumRapid+remNumRapid > cellUl->maxMsg3PerUlSf )
4639    {
4640       remNumRapid = cellUl->maxMsg3PerUlSf-schdNumRapid;
4641    }
4642 #endif
4643  
4644    while (remNumRapid)
4645    {
4646       /* Try allocating for as many RAPIDs as possible */
4647       /* BI sub-header size to the tbSize requirement */
4648       noBytes  = RGSCH_GET_RAR_BYTES(remNumRapid) +\
4649                  allocInfo->raRspAlloc[noRaRnti].biEstmt;
4650       if ((allwdTbSz = rgSCHUtlGetAllwdCchTbSz(noBytes*8, &nPrb, &mcs)) == -1)
4651       {
4652          remNumRapid--;
4653          continue;
4654       }
4655
4656       /* rgSCHCmnClcRbAllocForFxdTb(cell, allwdTbSz/8, cellDl->ccchCqi, &rb);*/
4657       if(cellDl->bitsPerRb==0)
4658       {
4659          while ((rgTbSzTbl[0][0][rb]) <(U32) allwdTbSz)
4660          {
4661             rb++;
4662          }
4663          rb = rb+1;
4664       }
4665       else
4666       {
4667          rb = RGSCH_CEIL(allwdTbSz, cellDl->bitsPerRb);
4668       }
4669       /* DwPTS Scheduling Changes Start */      
4670 #ifdef LTE_TDD      
4671       if (subFrm->sfType == RG_SCH_SPL_SF_DATA)
4672       {
4673          RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
4674
4675          /* Calculate the less RE's because of DwPTS */
4676          lostRe = rb * (cellDl->noResPerRb[cfi] - 
4677                                   cellDl->numReDwPts[cfi]);
4678           
4679          /* Increase number of RBs in Spl SF to compensate for lost REs */
4680          rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]);
4681       }
4682 #endif      
4683       /* DwPTS Scheduling Changes End */
4684
4685       /*ccpu00115595- end*/
4686       if (rb > subFrm->bw - subFrm->bwAssigned)
4687       {
4688          remNumRapid--;
4689          continue;
4690       }
4691       /* Allocation succeeded for 'remNumRapid' */
4692       isAlloc = TRUE;
4693       tbs = allwdTbSz/8;
4694       printf("\n!!!RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
4695                                       noBytes,allwdTbSz,tbs,rb);
4696       break;
4697    }
4698    if (!isAlloc)
4699    {
4700       RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
4701       RETVALUE(RFAILED);
4702    }
4703
4704    subFrm->bwAssigned = subFrm->bwAssigned + rb;
4705
4706    /* Fill AllocInfo structure */
4707    allocInfo->raRspAlloc[noRaRnti].rnti = rarnti;
4708    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].bytesReq = tbs;
4709    allocInfo->raRspAlloc[noRaRnti].rbsReq = rb;
4710    allocInfo->raRspAlloc[noRaRnti].dlSf = subFrm;
4711    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].imcs = mcs;
4712    allocInfo->raRspAlloc[noRaRnti].raIndex = raIndex;
4713    /* RACH changes for multiple RAPID handling */
4714    allocInfo->raRspAlloc[noRaRnti].numRapids = remNumRapid;
4715    allocInfo->raRspAlloc[noRaRnti].nPrb = nPrb;
4716    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].noLyr = 1;
4717    allocInfo->raRspAlloc[noRaRnti].vrbgReq = RGSCH_CEIL(nPrb,MAX_5GTF_VRBG_SIZE); 
4718    schdNumRapid += remNumRapid; 
4719    RETVALUE(ROK);
4720 }
4721
4722 /***********************************************************
4723  *
4724  *     Func : rgSCHCmnUlAllocFillRbInfo
4725  *
4726  *     Desc : Fills the start RB and the number of RBs for
4727  *            uplink allocation.
4728  *
4729  *     Ret  : void
4730  *
4731  *     Notes:
4732  *
4733  *     File :
4734  *
4735  **********************************************************/
4736 #ifdef ANSI
4737 PUBLIC Void rgSCHCmnUlAllocFillRbInfo
4738 (
4739 RgSchCellCb   *cell,
4740 RgSchUlSf      *sf,
4741 RgSchUlAlloc  *alloc
4742 )
4743 #else
4744 PUBLIC Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
4745 RgSchCellCb    *cell;
4746 RgSchUlSf      *sf;
4747 RgSchUlAlloc   *alloc;
4748 #endif
4749 {
4750     RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4751     RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4752     U8             cfi = cellDl->currCfi;
4753
4754
4755    TRC2(rgSCHCmnUlAllocFillRbInfo);
4756    alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) + 
4757                                     cell->dynCfiCb.bwInfo[cfi].startRb;
4758
4759    /* Num RBs = numSbAllocated * sbSize - less RBs in the last SB */
4760    alloc->grnt.numRb = (alloc->numSb * cellUl->sbSize);
4761
4762    RETVOID;
4763 }
4764
4765 /**
4766  * @brief Grant request for Msg3.
4767  *
4768  * @details
4769  *
4770  *     Function : rgSCHCmnMsg3GrntReq
4771  *
4772  *     This is invoked by downlink scheduler to request allocation
4773  *     for msg3.
4774  *     Steps:
4775  *     - Attempt to allocate msg3 in the current msg3 subframe
4776  *       Allocation attempt based on whether preamble is from group A
4777  *       and the value of MESSAGE_SIZE_GROUP_A
4778  *     - Link allocation with passed RNTI and msg3 HARQ process
4779  *     - Set the HARQ process ID (*hqProcIdRef)
4780  *
4781  *  @param[in]  RgSchCellCb       *cell
4782  *  @param[in]  CmLteRnti         rnti
4783  *  @param[in]  Bool              preamGrpA
4784  *  @param[in]  RgSchUlHqProcCb   *hqProc
4785  *  @param[out] RgSchUlAlloc      **ulAllocRef
4786  *  @param[out] U8                *hqProcIdRef
4787  *  @return  Void
4788  **/
4789 #ifdef ANSI
4790 PRIVATE Void rgSCHCmnMsg3GrntReq
4791 (
4792 RgSchCellCb     *cell,
4793 CmLteRnti       rnti,
4794 Bool            preamGrpA,
4795 RgSchUlHqProcCb *hqProc,
4796 RgSchUlAlloc    **ulAllocRef,
4797 U8              *hqProcIdRef
4798 )
4799 #else
4800 PRIVATE Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
4801                                  ulAllocRef, hqProcIdRef)
4802 RgSchCellCb     *cell;
4803 CmLteRnti       rnti;
4804 Bool            preamGrpA;
4805 RgSchUlHqProcCb *hqProc;
4806 RgSchUlAlloc    **ulAllocRef;
4807 U8              *hqProcIdRef;
4808 #endif
4809 {
4810    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4811    RgSchUlSf       *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
4812    RgSchUlHole     *hole;
4813    RgSchUlAlloc    *alloc;
4814    U8              iMcs;
4815    U8              numSb;
4816
4817    TRC2(rgSCHCmnMsg3GrntReq);
4818
4819    *ulAllocRef = NULLP;
4820
4821    /* Fix: ccpu00120610 Use remAllocs from subframe during msg3 allocation */
4822    if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
4823    {
4824       RETVOID;
4825    }
4826    if (preamGrpA == FALSE)
4827    {
4828       numSb = cellUl->ra.prmblBNumSb;
4829       iMcs  = cellUl->ra.prmblBIMcs;
4830    }
4831    else
4832    {
4833       numSb = cellUl->ra.prmblANumSb;
4834       iMcs  = cellUl->ra.prmblAIMcs;
4835    }
4836
4837    if ((hole = rgSCHUtlUlHoleFirst(sf)) != NULLP)
4838    {
4839       if(*sf->allocCountRef == 0)
4840       {
4841          RgSchCmnDlCell  *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4842          /* Reinitialize the hole */
4843          if (sf->holeDb->count == 1 && (hole->start == 0)) /* Sanity check of holeDb */
4844          {
4845             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;
4846             /* Re-Initialize available subbands because of CFI change*/
4847             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;   
4848          }
4849          else
4850          {
4851             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4852                      "Error! holeDb sanity check failed RNTI:%d",rnti);
4853          } 
4854       }
4855       if (numSb <= hole->num)
4856       {
4857          U8 iTbs;
4858          alloc                = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
4859          rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
4860          alloc->grnt.iMcs     = iMcs;
4861          alloc->grnt.iMcsCrnt = iMcs;
4862          iTbs                 = rgSCHCmnUlGetITbsFrmIMcs(iMcs);
4863          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[0], iTbs); 
4864          /* To include the length and ModOrder in DataRecp Req.*/
4865          alloc->grnt.datSz = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
4866          RG_SCH_UL_MCS_TO_MODODR(iMcs, alloc->grnt.modOdr);
4867          /* RACHO : setting nDmrs to 0 and UlDelaybit to 0*/
4868          alloc->grnt.nDmrs    = 0;
4869          alloc->grnt.hop      = 0;
4870          alloc->grnt.delayBit = 0;
4871          alloc->grnt.isRtx    = FALSE;
4872          *ulAllocRef          = alloc;
4873          *hqProcIdRef         = (cellUl->msg3SchdHqProcIdx);
4874          hqProc->procId       = *hqProcIdRef;
4875          hqProc->ulSfIdx      = (cellUl->msg3SchdIdx);
4876          alloc->rnti          = rnti;
4877          alloc->ue            = NULLP;
4878          alloc->pdcch         = FALSE;
4879          alloc->forMsg3       = TRUE;
4880          alloc->hqProc        = hqProc;
4881          rgSCHUhmNewTx(hqProc, (U8)(cell->rachCfg.maxMsg3Tx - 1), alloc);
4882          //RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
4883          printf(
4884                "\nRNTI:%d MSG3 ALLOC proc(%p)procId(%d)schdIdx(%d)\n",
4885                alloc->rnti,
4886                ((PTR)alloc->hqProc),
4887                alloc->hqProc->procId,
4888                alloc->hqProc->ulSfIdx);
4889          RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
4890                "alloc(%p)maxMsg3Tx(%d)",
4891                ((PTR)alloc),
4892                cell->rachCfg.maxMsg3Tx);
4893       }
4894    }
4895
4896    RETVOID;
4897 }
4898
4899 \f
4900 /**
4901  * @brief This function determines the allocation limits and
4902  *        parameters that aid in DL scheduling.
4903  *
4904  * @details
4905  *
4906  *     Function: rgSCHCmnDlSetUeAllocLmt
4907  *     Purpose:  This function determines the Maximum RBs
4908  *               a UE is eligible to get based on softbuffer
4909  *               limitation and cell->>>maxDlBwPerUe. The Codeword
4910  *               specific parameters like iTbs, eff and noLyrs
4911  *               are also set in this function. This function
4912  *               is called while UE configuration and UeDlCqiInd.
4913  *
4914  *     Invoked by: Scheduler
4915  *
4916  *  @param[in]  RgSchCellCb   *cellCb
4917  *  @param[in]  RgSchCmnDlUe  *ueDl
4918  *  @return  Void
4919  *
4920  **/
4921 #ifdef ANSI
4922 PRIVATE Void rgSCHCmnDlSetUeAllocLmt
4923 (
4924 RgSchCellCb   *cell,
4925 RgSchCmnDlUe  *ueDl,
4926 Bool          isEmtcUe
4927 )
4928 #else
4929 PRIVATE Void rgSCHCmnDlSetUeAllocLmt(cell, ueDl, isEmtcUe)
4930 RgSchCellCb   *cell;
4931 RgSchCmnDlUe  *ueDl;
4932 Bool          isEmtcUe;
4933 #endif
4934 {
4935    U8            modOrder;
4936    U32           maxRb;
4937    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
4938    U8            cfi = cellSch->dl.currCfi;
4939
4940    TRC2(rgSCHCmnDlSetUeAllocLmt);
4941
4942 #ifdef EMTC_ENABLE
4943    if(TRUE == isEmtcUe)
4944    {
4945       /* ITbs for CW0 for 1 Layer Tx */
4946       ueDl->mimoInfo.cwInfo[0].iTbs[0] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[0][cfi]))\
4947                                              [ueDl->mimoInfo.cwInfo[0].cqi];
4948       /* ITbs for CW0 for 2 Layer Tx */
4949       ueDl->mimoInfo.cwInfo[0].iTbs[1] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[1][cfi]))\
4950                                              [ueDl->mimoInfo.cwInfo[0].cqi];
4951       /* Eff for CW0 for 1 Layer Tx */
4952       ueDl->mimoInfo.cwInfo[0].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4953                                             [ueDl->mimoInfo.cwInfo[0].iTbs[0]];
4954       /* Eff for CW0 for 2 Layer Tx */
4955       ueDl->mimoInfo.cwInfo[0].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4956                                             [ueDl->mimoInfo.cwInfo[0].iTbs[1]];
4957
4958       /* ITbs for CW1 for 1 Layer Tx */
4959       ueDl->mimoInfo.cwInfo[1].iTbs[0] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[0][cfi]))\
4960                                              [ueDl->mimoInfo.cwInfo[1].cqi];
4961       /* ITbs for CW1 for 2 Layer Tx */
4962       ueDl->mimoInfo.cwInfo[1].iTbs[1] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[1][cfi]))\
4963                                              [ueDl->mimoInfo.cwInfo[1].cqi];
4964       /* Eff for CW1 for 1 Layer Tx */
4965       ueDl->mimoInfo.cwInfo[1].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4966                                             [ueDl->mimoInfo.cwInfo[1].iTbs[0]];
4967       /* Eff for CW1 for 2 Layer Tx */
4968       ueDl->mimoInfo.cwInfo[1].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4969                                             [ueDl->mimoInfo.cwInfo[1].iTbs[1]];
4970    }
4971    else
4972 #endif 
4973    {
4974       /* ITbs for CW0 for 1 Layer Tx */
4975       ueDl->mimoInfo.cwInfo[0].iTbs[0] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
4976                                          [ueDl->mimoInfo.cwInfo[0].cqi];
4977       /* ITbs for CW0 for 2 Layer Tx */
4978       ueDl->mimoInfo.cwInfo[0].iTbs[1] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[1][cfi]))\
4979                                          [ueDl->mimoInfo.cwInfo[0].cqi];
4980       /* Eff for CW0 for 1 Layer Tx */
4981       ueDl->mimoInfo.cwInfo[0].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4982                                         [ueDl->mimoInfo.cwInfo[0].iTbs[0]];
4983       /* Eff for CW0 for 2 Layer Tx */
4984       ueDl->mimoInfo.cwInfo[0].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4985                                         [ueDl->mimoInfo.cwInfo[0].iTbs[1]];
4986       
4987       /* ITbs for CW1 for 1 Layer Tx */
4988       ueDl->mimoInfo.cwInfo[1].iTbs[0] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
4989                                          [ueDl->mimoInfo.cwInfo[1].cqi];
4990       /* ITbs for CW1 for 2 Layer Tx */
4991       ueDl->mimoInfo.cwInfo[1].iTbs[1] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[1][cfi]))\
4992                                          [ueDl->mimoInfo.cwInfo[1].cqi];
4993       /* Eff for CW1 for 1 Layer Tx */
4994       ueDl->mimoInfo.cwInfo[1].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4995                                         [ueDl->mimoInfo.cwInfo[1].iTbs[0]];
4996       /* Eff for CW1 for 2 Layer Tx */
4997       ueDl->mimoInfo.cwInfo[1].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4998                                         [ueDl->mimoInfo.cwInfo[1].iTbs[1]];
4999    }
5000
5001 //#ifdef DL_LA 
5002   // ueDl->laCb.cqiBasediTbs =  ueDl->mimoInfo.cwInfo[0].iTbs[0] * 100;
5003 //#endif
5004    /* Assigning noLyrs to each CW assuming optimal Spatial multiplexing
5005     * capability */
5006    (ueDl->mimoInfo.ri/2 == 0)? (ueDl->mimoInfo.cwInfo[0].noLyr = 1) : \
5007               (ueDl->mimoInfo.cwInfo[0].noLyr = ueDl->mimoInfo.ri/2);
5008    ueDl->mimoInfo.cwInfo[1].noLyr = ueDl->mimoInfo.ri - ueDl->mimoInfo.cwInfo[0].noLyr;
5009    /* rg002.101:ccpu00102106: correcting DL harq softbuffer limitation logic.
5010     * The maxTbSz is the maximum number of PHY bits a harq process can
5011     * hold. Hence we limit our allocation per harq process based on this.
5012     * Earlier implementation we misinterpreted the maxTbSz to be per UE
5013     * per TTI, but in fact it is per Harq per TTI. */
5014    /* rg002.101:ccpu00102106: cannot exceed the harq Tb Size
5015     * and harq Soft Bits limit.*/
5016
5017    /* Considering iTbs corresponding to 2 layer transmission for
5018     * codeword0(approximation) and the maxLayers supported by
5019     * this UE at this point of time. */
5020    RG_SCH_CMN_TBS_TO_MODODR(ueDl->mimoInfo.cwInfo[0].iTbs[1], modOrder);
5021
5022    /* Bits/modOrder gives #REs, #REs/noResPerRb gives #RBs */
5023    /* rg001.301 -MOD- [ccpu00119213] : avoiding wraparound */
5024    maxRb = ((ueDl->maxSbSz)/(cellSch->dl.noResPerRb[cfi] * modOrder *\
5025                    ueDl->mimoInfo.ri));
5026    if (cellSch->dl.isDlFreqSel)
5027    {
5028       /* Rounding off to left nearest multiple of RBG size */
5029       maxRb -= maxRb % cell->rbgSize;
5030    }
5031    ueDl->maxRb = RGSCH_MIN(maxRb, cellSch->dl.maxDlBwPerUe);
5032    if (cellSch->dl.isDlFreqSel)
5033    {
5034       /* Rounding off to right nearest multiple of RBG size */
5035       if (ueDl->maxRb % cell->rbgSize)
5036       {
5037          ueDl->maxRb += (cell->rbgSize - 
5038                          (ueDl->maxRb % cell->rbgSize));
5039       }
5040    }
5041
5042    /* Set the index of the cwInfo, which is better in terms of
5043     * efficiency. If RI<2, only 1 CW, hence btrCwIdx shall be 0 */
5044    if (ueDl->mimoInfo.ri < 2)
5045    {
5046       ueDl->mimoInfo.btrCwIdx = 0;
5047    }
5048    else
5049    {
5050       if (ueDl->mimoInfo.cwInfo[0].eff[ueDl->mimoInfo.cwInfo[0].noLyr-1] <\
5051           ueDl->mimoInfo.cwInfo[1].eff[ueDl->mimoInfo.cwInfo[1].noLyr-1])
5052       {
5053          ueDl->mimoInfo.btrCwIdx = 1;
5054       }
5055       else
5056       {
5057          ueDl->mimoInfo.btrCwIdx = 0;
5058       }
5059    }
5060
5061    RETVOID;
5062    }
5063
5064 #ifdef DL_LA
5065
5066 /**
5067  * @brief This function updates TX Scheme.
5068  *
5069  * @details
5070  *
5071  *     Function: rgSCHCheckAndSetTxScheme 
5072  *     Purpose:  This function determines the Maximum RBs
5073  *               a UE is eligible to get based on softbuffer
5074  *               limitation and cell->>>maxDlBwPerUe. The Codeword
5075  *               specific parameters like iTbs, eff and noLyrs
5076  *               are also set in this function. This function
5077  *               is called while UE configuration and UeDlCqiInd.
5078  *
5079  *     Invoked by: Scheduler
5080  *
5081  *  @param[in]  RgSchCellCb   *cell
5082  *  @param[in]  RgSchUeCb     *ue
5083  *  @return  Void
5084  *
5085  **/
5086 #ifdef ANSI
5087 PRIVATE Void rgSCHCheckAndSetTxScheme 
5088 (
5089 RgSchCellCb   *cell,
5090 RgSchUeCb     *ue
5091 )
5092 #else
5093 PRIVATE Void rgSCHCheckAndSetTxScheme(cell, ue)
5094 RgSchCellCb   *cell;
5095 RgSchUeCb     *ue;
5096 #endif
5097 {
5098    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
5099    RgSchCmnDlUe  *ueDl =  RG_SCH_CMN_GET_DL_UE(ue ,cell);
5100    U8            cfi = cellSch->dl.currCfi;
5101    U8            maxiTbs;
5102    U8            cqiBasediTbs;
5103    U8            actualiTbs;
5104
5105    TRC2(rgSCHCheckAndSetTxScheme);
5106
5107    maxiTbs      = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
5108                 [RG_SCH_CMN_MAX_CQI - 1];
5109    cqiBasediTbs = (ueDl->laCb[0].cqiBasediTbs)/100;
5110    actualiTbs   = ueDl->mimoInfo.cwInfo[0].iTbs[0];
5111
5112    if((actualiTbs < RG_SCH_TXSCHEME_CHNG_ITBS_FACTOR) && (cqiBasediTbs >
5113      actualiTbs) && ((cqiBasediTbs - actualiTbs) > RG_SCH_TXSCHEME_CHNG_THRSHD)) 
5114    {
5115       RG_SCH_CMN_SET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
5116    }
5117    
5118    if(actualiTbs >= maxiTbs)
5119    {
5120       RG_SCH_CMN_UNSET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
5121    }
5122
5123    RETVOID;
5124 }
5125
5126 /**
5127  * @brief This function determines the allocation limits and
5128  *        parameters that aid in DL scheduling.
5129  *
5130  * @details
5131  *
5132  *     Function: rgSCHCmnDlSetUeAllocLmtLa
5133  *     Purpose:  This function determines the Maximum RBs
5134  *               a UE is eligible to get based on softbuffer
5135  *               limitation and cell->>>maxDlBwPerUe. The Codeword
5136  *               specific parameters like iTbs, eff and noLyrs
5137  *               are also set in this function. This function
5138  *               is called while UE configuration and UeDlCqiInd.
5139  *
5140  *     Invoked by: Scheduler
5141  *
5142  *  @param[in]  RgSchCellCb   *cell
5143  *  @param[in]  RgSchUeCb     *ue
5144  *  @return  Void
5145  *
5146  **/
5147 #ifdef ANSI
5148 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa
5149 (
5150 RgSchCellCb   *cell,
5151 RgSchUeCb     *ue
5152 )
5153 #else
5154 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
5155 RgSchCellCb   *cell;
5156 RgSchUeCb     *ue;
5157 #endif
5158 {
5159    U8            modOrder;
5160    U32           maxRb;
5161    U8            reportediTbs;
5162    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
5163    RgSchCmnDlUe  *ueDl =  RG_SCH_CMN_GET_DL_UE(ue,cell);
5164    U8            cfi = cellSch->dl.currCfi;
5165    U8            maxiTbs;
5166    U8            cwIdx = 0; 
5167
5168    TRC2(rgSCHCmnDlSetUeAllocLmtLa);
5169
5170    maxiTbs      = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
5171    if(ueDl->cqiFlag == TRUE)
5172    {
5173       for(cwIdx=0; cwIdx < RG_SCH_CMN_MAX_CW_PER_UE; cwIdx++)
5174       {
5175          S32 iTbsNew;
5176
5177          /* Calcluating the reported iTbs for code word 0 */
5178          reportediTbs = ue->ue5gtfCb.mcs; 
5179
5180          iTbsNew = (S32) reportediTbs;
5181
5182          if(!ueDl->laCb[cwIdx].notFirstCqi)
5183          {
5184             /* This is the first CQI report from UE */
5185             ueDl->laCb[cwIdx].cqiBasediTbs = (iTbsNew * 100);
5186             ueDl->laCb[cwIdx].notFirstCqi  =  TRUE;
5187          }
5188          else if ((RG_ITBS_DIFF(reportediTbs, ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0])) > 5)
5189          {
5190             /* Ignore this iTBS report and mark that last iTBS report was */
5191             /* ignored so that subsequently we reset the LA algorithm     */
5192             ueDl->laCb[cwIdx].lastiTbsIgnored = TRUE;
5193             ueDl->laCb[cwIdx].numLastiTbsIgnored++;
5194             if( ueDl->laCb[cwIdx].numLastiTbsIgnored > 10)
5195             {
5196                /* CQI reported by UE is not catching up. Reset the LA algorithm */
5197                ueDl->laCb[cwIdx].cqiBasediTbs = (iTbsNew * 100);
5198                ueDl->laCb[cwIdx].deltaiTbs = 0;
5199                ueDl->laCb[cwIdx].lastiTbsIgnored = FALSE;
5200                ueDl->laCb[cwIdx].numLastiTbsIgnored = 0;
5201             }
5202          }
5203          else
5204          {
5205             if (ueDl->laCb[cwIdx].lastiTbsIgnored != TRUE)
5206             {
5207                ueDl->laCb[cwIdx].cqiBasediTbs = ((20 * iTbsNew * 100) +
5208                      (80 * ueDl->laCb[cwIdx].cqiBasediTbs))/100;
5209             }
5210             else
5211             {
5212                /* Reset the LA as iTbs in use caught up with the value   */
5213                /* reported by UE.                                        */
5214                ueDl->laCb[cwIdx].cqiBasediTbs = ((20 * iTbsNew * 100) +
5215                      (80 * ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0] * 100))/100;
5216                ueDl->laCb[cwIdx].deltaiTbs = 0;
5217                ueDl->laCb[cwIdx].lastiTbsIgnored = FALSE;
5218             }
5219          }
5220
5221          iTbsNew = (ueDl->laCb[cwIdx].cqiBasediTbs + ueDl->laCb[cwIdx].deltaiTbs)/100;
5222
5223          RG_SCH_CHK_ITBS_RANGE(iTbsNew, maxiTbs);       
5224
5225          ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0] = RGSCH_MIN(iTbsNew, cell->thresholds.maxDlItbs);
5226          //ueDl->mimoInfo.cwInfo[cwIdx].iTbs[1] = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
5227 #ifdef RG_5GTF
5228          ue->ue5gtfCb.mcs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
5229          /*
5230          printf("reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n", 
5231                  reportediTbs, ueDl->laCb[cwIdx].cqiBasediTbs, ueDl->laCb[cwIdx].deltaiTbs,
5232                  iTbsNew, ue->ue5gtfCb.mcs, cwIdx);
5233          */
5234 #endif
5235
5236          if((ue->mimoInfo.txMode != RGR_UE_TM_3) && (ue->mimoInfo.txMode != RGR_UE_TM_4))
5237          {
5238             break; 
5239          }
5240       }
5241       ueDl->cqiFlag = FALSE;
5242    } 
5243
5244
5245    RETVOID;
5246 }
5247 #endif
5248 /***********************************************************
5249  *
5250  *     Func : rgSCHCmnDlUeResetTemp
5251  *
5252  *     Desc : Reset whatever variables where temporarily used
5253  *            during UE scheduling.
5254  *
5255  *     Ret  : Void
5256  *
5257  *     Notes:
5258  *
5259  *     File :
5260  *
5261  **********************************************************/
5262 #ifdef ANSI
5263 PUBLIC Void rgSCHCmnDlHqPResetTemp 
5264 (
5265 RgSchDlHqProcCb         *hqP
5266 )
5267 #else
5268 PUBLIC Void rgSCHCmnDlHqPResetTemp(hqP)
5269 RgSchDlHqProcCb         *hqP;
5270 #endif
5271 {
5272
5273    TRC2(rgSCHCmnDlHqPResetTemp);
5274
5275    /* Fix: syed having a hqP added to Lists for RB assignment rather than
5276     * a UE, as adding UE was limiting handling some scenarios */ 
5277     hqP->reqLnk.node = (PTR)NULLP;
5278     hqP->schdLstLnk.node = (PTR)NULLP;
5279
5280    RETVOID;
5281 }  /* rgSCHCmnDlHqPResetTemp */
5282
5283 /***********************************************************
5284  *
5285  *     Func : rgSCHCmnDlUeResetTemp
5286  *
5287  *     Desc : Reset whatever variables where temporarily used
5288  *            during UE scheduling.
5289  *
5290  *     Ret  : Void
5291  *
5292  *     Notes:
5293  *
5294  *     File :
5295  *
5296  **********************************************************/
5297 #ifdef ANSI
5298 PUBLIC Void rgSCHCmnDlUeResetTemp
5299 (
5300 RgSchUeCb               *ue,
5301 RgSchDlHqProcCb         *hqP
5302 )
5303 #else
5304 PUBLIC Void rgSCHCmnDlUeResetTemp(ue, hqP)
5305 RgSchUeCb               *ue;
5306 RgSchDlHqProcCb         *hqP;
5307 #endif
5308 {
5309    RgSchDlRbAlloc  *allocInfo;
5310    RgSchCmnDlUe       *cmnUe = RG_SCH_CMN_GET_DL_UE(ue,hqP->hqE->cell);
5311 #ifdef LTE_ADV
5312    Void           *tmpCb;
5313 #endif
5314
5315    TRC2(rgSCHCmnDlUeResetTemp);
5316
5317    /* Fix : syed check for UE's existence was useless.
5318     * Instead we need to check that reset is done only for the 
5319     * information of a scheduled harq proc, which is cmnUe->proc.
5320     * Reset should not be done for non-scheduled hqP */
5321    if((cmnUe->proc == hqP) || (cmnUe->proc == NULLP))
5322    {
5323       cmnUe->proc = NULLP;
5324       allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, hqP->hqE->cell);
5325 #ifdef LTE_ADV
5326       tmpCb = allocInfo->laaCb;
5327 #endif
5328       cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
5329       allocInfo->rnti = ue->ueId;
5330 #ifdef LTE_ADV
5331       allocInfo->laaCb = tmpCb;
5332 #endif
5333       /* Fix: syed moving this to a common function for both scheduled
5334        * and non-scheduled UEs */
5335       cmnUe->outStndAlloc = 0;
5336    }
5337    rgSCHCmnDlHqPResetTemp(hqP);
5338
5339    RETVOID;
5340 }  /* rgSCHCmnDlUeResetTemp */
5341
5342 /***********************************************************
5343  *
5344  *     Func : rgSCHCmnUlUeResetTemp
5345  *
5346  *     Desc : Reset whatever variables where temporarily used
5347  *            during UE scheduling.
5348  *
5349  *     Ret  : Void
5350  *
5351  *     Notes:
5352  *
5353  *     File :
5354  *
5355  **********************************************************/
5356 #ifdef ANSI
5357 PUBLIC Void rgSCHCmnUlUeResetTemp
5358 (
5359 RgSchCellCb             *cell,
5360 RgSchUeCb               *ue
5361 )
5362 #else
5363 PUBLIC Void rgSCHCmnUlUeResetTemp(cell, ue)
5364 RgSchCellCb             *cell;
5365 RgSchUeCb               *ue;
5366 #endif
5367 {
5368    RgSchCmnUlUe       *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
5369
5370    TRC2(rgSCHCmnUlUeResetTemp);
5371
5372    cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
5373
5374    RETVOID;
5375 }  /* rgSCHCmnUlUeResetTemp */
5376
5377
5378 \f
5379 /**
5380  * @brief This function fills the PDCCH information from dlProc.
5381  *
5382  * @details
5383  *
5384  *     Function: rgSCHCmnFillPdcch
5385  *     Purpose:  This function fills in the PDCCH information
5386  *               obtained from the RgSchDlRbAlloc
5387  *               during common channel scheduling(P, SI, RA - RNTI's).
5388  *
5389  *     Invoked by: Downlink Scheduler
5390  *
5391  *  @param[out] RgSchPdcch*       pdcch
5392  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
5393  *  @return  Void
5394  *
5395  **/
5396 #ifdef ANSI
5397 PUBLIC Void rgSCHCmnFillPdcch
5398 (
5399 RgSchCellCb                *cell,
5400 RgSchPdcch                 *pdcch,
5401 RgSchDlRbAlloc             *rbAllocInfo
5402 )
5403 #else
5404 PUBLIC Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
5405 RgSchCellCb                *cell;
5406 RgSchPdcch                 *pdcch;
5407 RgSchDlRbAlloc             *rbAllocInfo;
5408 #endif
5409 {
5410
5411    TRC2(rgSCHCmnFillPdcch);
5412
5413    /* common channel pdcch filling,
5414     * only 1A and Local is supported */
5415    pdcch->rnti                       = rbAllocInfo->rnti;
5416    pdcch->dci.dciFormat              = rbAllocInfo->dciFormat;
5417    switch(rbAllocInfo->dciFormat)
5418    {
5419 #ifdef RG_5GTF  /* ANOOP: ToDo: DCI format B1/B2 filling */
5420       case TFU_DCI_FORMAT_B1:
5421          {
5422             /* ToDo: Anoop */
5423             pdcch->dci.u.formatB1Info.formatType = 0;
5424             pdcch->dci.u.formatB1Info.xPDSCHRange = rbAllocInfo->tbInfo[0].cmnGrnt.xPDSCHRange;
5425             pdcch->dci.u.formatB1Info.RBAssign = rbAllocInfo->tbInfo[0].cmnGrnt.rbAssign;
5426             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.hqProcId = 0;
5427             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
5428             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = 0;
5429             //pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].ndi;
5430             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].cmnGrnt.rv;
5431             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
5432             pdcch->dci.u.formatB1Info.CSI_BSI_BRI_Req = 0;
5433             pdcch->dci.u.formatB1Info.CSIRS_BRRS_TxTiming = 0;
5434             pdcch->dci.u.formatB1Info.CSIRS_BRRS_SymbIdx = 0;
5435             pdcch->dci.u.formatB1Info.CSIRS_BRRS_ProcInd = 0;
5436             pdcch->dci.u.formatB1Info.xPUCCH_TxTiming = 0;
5437             //TODO_SID: Need to update
5438             pdcch->dci.u.formatB1Info.freqResIdx_xPUCCH = 0;
5439             pdcch->dci.u.formatB1Info.beamSwitch  = 0;
5440             pdcch->dci.u.formatB1Info.SRS_Config = 0;
5441             pdcch->dci.u.formatB1Info.SRS_Symbol = 0;
5442             //TODO_SID: Need to check.Currently setting 0(1 layer, ports(8) w/o OCC).
5443             pdcch->dci.u.formatB1Info.AntPorts_numLayers = 0;
5444             pdcch->dci.u.formatB1Info.SCID = rbAllocInfo->tbInfo[0].cmnGrnt.SCID;
5445             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
5446             pdcch->dci.u.formatB1Info.tpcCmd = 1; //tpc;
5447             pdcch->dci.u.formatB1Info.DL_PCRS = 0;
5448
5449             break; /* case TFU_DCI_FORMAT_B1: */
5450          }
5451
5452       case TFU_DCI_FORMAT_B2:
5453          {
5454             //printf(" RG_5GTF:: Pdcch filling with DCI format B2\n");
5455             /* ToDo: Anoop */
5456             break; /* case TFU_DCI_FORMAT_B2: */
5457          }
5458 #endif
5459       case TFU_DCI_FORMAT_1A:
5460          pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
5461
5462          /*Nprb indication at PHY for common Ch
5463           *setting least significant bit of tpc field to 1 if
5464           nPrb=3 and 0 otherwise. */
5465          if (rbAllocInfo->nPrb == 3)
5466          {
5467             pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = 1;
5468          }
5469          else
5470          {
5471             pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = 0;
5472          }
5473          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.nGap2.pres = NOTPRSNT;
5474          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.isLocal = TRUE;
5475          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.mcs     = \
5476                                                                    rbAllocInfo->tbInfo[0].imcs;
5477          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.ndi     = 0;
5478          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv      = 0;
5479          /* Add RIV CALC */
5480          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.type =
5481             TFU_ALLOC_TYPE_RIV;
5482          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.u.riv =
5483             rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
5484                   rbAllocInfo->allocInfo.raType2.rbStart,
5485                   rbAllocInfo->allocInfo.raType2.numRb);
5486
5487 #ifdef LTE_TDD
5488          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres = \
5489                                                                            FALSE;
5490 #ifdef TFU_TDD
5491          pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
5492          pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 1;
5493 #endif
5494 #endif
5495          break; /* case TFU_DCI_FORMAT_1A: */
5496       case TFU_DCI_FORMAT_1:
5497          pdcch->dci.u.format1Info.tpcCmd = 0;
5498          /* Avoiding this check,as we dont support Type1 RA */
5499 #ifdef RG_UNUSED
5500          if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
5501          {
5502 #endif
5503             pdcch->dci.u.format1Info.allocInfo.isAllocType0 = TRUE;
5504             pdcch->dci.u.format1Info.allocInfo.resAllocMap[0] =
5505                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
5506                 & 0xff);
5507             pdcch->dci.u.format1Info.allocInfo.resAllocMap[1] =
5508                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
5509                 & 0x00ff);
5510             pdcch->dci.u.format1Info.allocInfo.resAllocMap[2] =
5511                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
5512                 & 0x0000ff);
5513             pdcch->dci.u.format1Info.allocInfo.resAllocMap[3] =
5514                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
5515 #ifdef RG_UNUSED
5516          }
5517 #endif
5518          pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
5519          pdcch->dci.u.format1Info.allocInfo.ndi = 0;
5520          pdcch->dci.u.format1Info.allocInfo.mcs = rbAllocInfo->tbInfo[0].imcs;
5521          pdcch->dci.u.format1Info.allocInfo.rv = 0;
5522 #ifdef TFU_TDD
5523          pdcch->dci.u.format1Info.dai = 1;
5524 #endif
5525          break;
5526       default:
5527          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Allocator's icorrect "
5528             "dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
5529          break;
5530    }
5531    RETVOID;
5532 }
5533
5534 #ifdef LTE_TDD
5535 /**
5536  * @brief This function finds whether the subframe is special subframe or not.
5537  *
5538  * @details
5539  *
5540  *     Function: rgSCHCmnIsSplSubfrm
5541  *     Purpose:  This function finds the subframe index of the special subframe
5542  *               and finds whether the current DL index matches it or not.
5543  *
5544  *     Invoked by: Scheduler
5545  *
5546  *  @param[in] U8                   splfrmCnt
5547  *  @param[in] U8                   curSubfrmIdx
5548  *  @param[in] U8                   periodicity
5549  *  @param[in] RgSchTddSubfrmInfo   *subfrmInfo
5550  *  @return  Bool
5551  *
5552  **/
5553 #ifdef ANSI
5554 PRIVATE Bool rgSCHCmnIsSplSubfrm
5555 (
5556 U8                   splfrmCnt,
5557 U8                   curSubfrmIdx,
5558 U8                   periodicity,
5559 RgSchTddSubfrmInfo   *subfrmInfo
5560 )
5561 #else
5562 PRIVATE Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
5563 U8                   splfrmCnt;
5564 U8                   curSubfrmIdx;
5565 U8                   periodicity;
5566 RgSchTddSubfrmInfo   *subfrmInfo;
5567 #endif
5568 {
5569    U8 dlSfCnt = 0;
5570    U8 splfrmIdx  = 0;
5571
5572    TRC2(rgSCHCmnIsSplSubfrm);
5573
5574    if(splfrmCnt > 0)
5575    {
5576       if(periodicity == RG_SCH_CMN_5_MS_PRD)
5577       {
5578          if(splfrmCnt%2)
5579          {
5580             dlSfCnt = ((splfrmCnt-1)/2) *\
5581                       (subfrmInfo->numFrmHf1 + subfrmInfo->numFrmHf2);
5582             dlSfCnt = dlSfCnt + subfrmInfo->numFrmHf1;
5583          }
5584          else
5585          {
5586             dlSfCnt = (splfrmCnt/2) * \
5587                       (subfrmInfo->numFrmHf1 + subfrmInfo->numFrmHf2);
5588          }
5589       }
5590       else
5591       {
5592          dlSfCnt = splfrmCnt * subfrmInfo->numFrmHf1;
5593       }
5594       splfrmIdx = RG_SCH_CMN_SPL_SUBFRM_1 +\
5595                   (periodicity*splfrmCnt - dlSfCnt);
5596    }
5597    else
5598    {
5599       splfrmIdx = RG_SCH_CMN_SPL_SUBFRM_1;
5600    }
5601
5602    if(splfrmIdx == curSubfrmIdx)
5603    {
5604       RETVALUE(TRUE);
5605    }
5606
5607    RETVALUE(FALSE);
5608 }
5609
5610 /**
5611  * @brief This function updates DAI or UL index.
5612  *
5613  * @details
5614  *
5615  *     Function: rgSCHCmnUpdHqAndDai
5616  *     Purpose:  Updates the DAI based on UL-DL Configuration
5617  *               index and UE. It also updates the HARQ feedback
5618  *               time and 'm' index.
5619  *
5620  *     Invoked by: TOM
5621  *
5622  *  @param[in]  RgDlHqProcCb  *hqP
5623  *  @param[in]  RgSchDlSf     *subFrm
5624  *  @param[in]  RgSchDlHqTbCb *tbCb
5625  *  @param[in]  U8            tbAllocIdx
5626  *  @return  Void
5627  *
5628  **/
5629 #ifdef ANSI
5630 PRIVATE Void rgSCHCmnUpdHqAndDai
5631 (
5632 RgSchDlHqProcCb   *hqP,
5633 RgSchDlSf         *subFrm,
5634 RgSchDlHqTbCb     *tbCb,
5635 U8                tbAllocIdx
5636 )
5637 #else
5638 PRIVATE Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
5639 RgSchDlHqProcCb   *hqP;
5640 RgSchDlSf         *subFrm;
5641 RgSchDlHqTbCb     *tbCb;
5642 U8                tbAllocIdx;
5643 #endif
5644 {
5645    RgSchUeCb      *ue = hqP->hqE->ue;
5646    
5647    TRC2(rgSCHCmnUpdHqAndDai);
5648
5649    if(subFrm != NULLP)
5650    {
5651       /* set the time at which UE shall send the feedback
5652        * for this process */
5653       tbCb->fdbkTime.sfn = (tbCb->timingInfo.sfn + \
5654             subFrm->dlFdbkInfo.sfnOffset) % RGSCH_MAX_SFN;
5655       tbCb->fdbkTime.subframe = subFrm->dlFdbkInfo.subframe;
5656       tbCb->m = subFrm->dlFdbkInfo.m;
5657    }
5658    else
5659    {
5660       /* set the time at which UE shall send the feedback
5661        * for this process */
5662       tbCb->fdbkTime.sfn = (tbCb->timingInfo.sfn + \
5663             hqP->subFrm->dlFdbkInfo.sfnOffset) % RGSCH_MAX_SFN;
5664       tbCb->fdbkTime.subframe = hqP->subFrm->dlFdbkInfo.subframe;
5665       tbCb->m = hqP->subFrm->dlFdbkInfo.m;
5666    }
5667
5668    /* ccpu00132340-MOD- DAI need to be updated for first TB only*/
5669    if(ue && !tbAllocIdx)
5670    {
5671       Bool   havePdcch = (tbCb->hqP->pdcch ? TRUE : FALSE);
5672       U8     dlDai;
5673       
5674       dlDai = rgSCHCmnUpdDai(ue, &tbCb->fdbkTime, tbCb->m, havePdcch,tbCb->hqP,
5675             &tbCb->dai);
5676       if(havePdcch)
5677       {/* Non SPS occasions */
5678          tbCb->hqP->pdcch->dlDai = dlDai;
5679          /* hqP->ulDai is used for N1 resource filling
5680           * when SPS occaions present in a bundle */
5681          tbCb->hqP->ulDai = tbCb->dai;
5682          tbCb->hqP->dlDai = dlDai;
5683       }
5684    }
5685
5686    /* Updatijng pucchFdbkIdx for both PUCCH or PUSCH
5687       fdbk reception */
5688    tbCb->pucchFdbkIdx = tbCb->hqP->ulDai;
5689
5690    RETVOID;
5691 }
5692
5693
5694 /**
5695  * @brief This function updates DAI or UL index.
5696  *
5697  * @details
5698  *
5699  *     Function: rgSCHCmnUpdDai
5700  *     Purpose:  Updates the DAI in the ack-nack info, a valid
5701  *               ue should be passed
5702  *
5703  *     Invoked by: TOM
5704  *
5705  *  @param[in]  RgDlHqProcCb  *hqP
5706  *  @param[in]  RgSchDlSf     *subFrm
5707  *  @param[in]  RgSchDlHqTbCb *tbCb
5708  *  @return  U8 dlDai 
5709  *
5710  **/
5711 #ifdef ANSI
5712 PUBLIC U8 rgSCHCmnUpdDai
5713 (
5714 RgSchUeCb         *ue,
5715 CmLteTimingInfo   *fdbkTime,
5716 U8                 m,
5717 Bool               havePdcch,
5718 RgSchDlHqProcCb   *hqP,
5719 U8                *ulDai
5720 )
5721 #else
5722 PUBLIC U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
5723 RgSchUeCb         *ue;
5724 CmLteTimingInfo   *fdbkTime;
5725 U8                 m;
5726 Bool               havePdcch;
5727 RgSchDlHqProcCb   *hqP;
5728 U8                *ulDai;
5729 #endif
5730 {
5731    RgSchTddANInfo *anInfo;
5732    U8             servCellIdx;
5733    U8             ackNackFdbkArrSize;
5734   
5735
5736    TRC2(rgSCHCmnUpdDai);
5737
5738    if(hqP != NULLP)
5739    {/* Non SPS */
5740 #ifdef LTE_ADV
5741       servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
5742             hqP->hqE->cell->cellId,
5743             ue);
5744 #else
5745      servCellIdx = RGSCH_PCELL_INDEX;
5746 #endif
5747       ackNackFdbkArrSize = hqP->hqE->cell->ackNackFdbkArrSize;
5748    }else
5749    {/* SPS on primary cell */
5750       servCellIdx = RGSCH_PCELL_INDEX;
5751       ackNackFdbkArrSize = ue->cell->ackNackFdbkArrSize;
5752    }
5753
5754
5755    anInfo = rgSCHUtlGetUeANFdbkInfo(ue, fdbkTime,servCellIdx);
5756
5757    /* If no ACK/NACK feedback already present, create a new one */
5758    if(NULLP == anInfo)
5759    {
5760       anInfo = &ue->cellInfo[servCellIdx]->anInfo[ue->cellInfo[servCellIdx]->nextFreeANIdx];
5761       anInfo->sfn = fdbkTime->sfn;
5762       anInfo->subframe = fdbkTime->subframe;
5763       anInfo->latestMIdx = m;
5764       /* Fixing DAI value - ccpu00109162 */
5765       /* Handle TDD case as in MIMO definition of the function */
5766       anInfo->ulDai = 1;
5767       if (havePdcch)
5768       {
5769          anInfo->dlDai = 1;
5770       }
5771       anInfo->isSpsOccasion = FALSE;
5772       /* set the free Index to store  Ack/Nack Information*/
5773       ue->cellInfo[servCellIdx]->nextFreeANIdx = (ue->cellInfo[servCellIdx]->nextFreeANIdx + 1) %
5774          ackNackFdbkArrSize;
5775
5776    }
5777    else
5778    {
5779       anInfo->latestMIdx = m;
5780       /* Fixing DAI value - ccpu00109162 */
5781       /* Handle TDD case as in MIMO definition of the function */
5782       anInfo->ulDai = anInfo->ulDai + 1;
5783       if (havePdcch)
5784       {
5785          anInfo->dlDai = anInfo->dlDai + 1;
5786       }
5787    }
5788 #ifdef LTE_ADV
5789    /* ignoring the Scell check,
5790     * for primary cell this field is unused*/
5791    if(hqP != NULLP)
5792    {/* SPS*/
5793       anInfo->n1ResTpcIdx = hqP->tpc;
5794    }
5795
5796    if(ulDai)
5797    {/* As this not required for release pdcch */
5798       *ulDai = anInfo->ulDai;
5799    }
5800 #endif
5801    RETVALUE(anInfo->dlDai);
5802
5803 }
5804 #endif /* ifdef LTE_TDD */
5805
5806 PUBLIC U32 rgHqRvRetxCnt[4][2];
5807 PUBLIC U32 rgUlrate_grant;
5808
5809 /**
5810  * @brief This function fills the HqP TB with rbAllocInfo.
5811  *
5812  * @details
5813  *
5814  *     Function: rgSCHCmnFillHqPTb
5815  *     Purpose:  This function fills in the HqP TB with rbAllocInfo.
5816  *
5817  *     Invoked by: rgSCHCmnFillHqPTb
5818  *
5819  *  @param[in]  RgSchCellCb*      cell
5820  *  @param[in]  RgSchDlRbAlloc    *rbAllocInfo,
5821  *  @param[in]  U8                tbAllocIdx
5822  *  @param[in]  RgSchPdcch        *pdcch
5823  *  @return  Void
5824  *
5825  **/
5826 #ifdef LTEMAC_SPS
5827 #ifdef ANSI
5828 PUBLIC Void rgSCHCmnFillHqPTb
5829 (
5830 RgSchCellCb                *cell,
5831 RgSchDlRbAlloc             *rbAllocInfo,
5832 U8                         tbAllocIdx,
5833 RgSchPdcch                 *pdcch
5834 )
5835 #else
5836 PUBLIC Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
5837 RgSchCellCb                *cell;
5838 RgSchDlRbAlloc             *rbAllocInfo;
5839 U8                         tbAllocIdx;
5840 RgSchPdcch                 *pdcch;
5841 #endif
5842 #else
5843 #ifdef ANSI
5844 PRIVATE Void rgSCHCmnFillHqPTb
5845 (
5846 RgSchCellCb                *cell,
5847 RgSchDlRbAlloc             *rbAllocInfo,
5848 U8                         tbAllocIdx,
5849 RgSchPdcch                 *pdcch
5850 )
5851 #else
5852 PRIVATE Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
5853 RgSchCellCb                *cell;
5854 RgSchDlRbAlloc             *rbAllocInfo;
5855 U8                         tbAllocIdx;
5856 RgSchPdcch                 *pdcch;
5857 #endif
5858 #endif /* LTEMAC_SPS */
5859 {
5860    RgSchCmnDlCell     *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
5861    RgSchDlTbAllocInfo *tbAllocInfo = &rbAllocInfo->tbInfo[tbAllocIdx];
5862    RgSchDlHqTbCb      *tbInfo = tbAllocInfo->tbCb;
5863    RgSchDlHqProcCb    *hqP = tbInfo->hqP;
5864
5865    TRC2(rgSCHCmnFillHqPTb);
5866
5867    /*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
5868     * Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
5869     */
5870    if ( tbAllocInfo->isDisabled)
5871    {
5872
5873       tbInfo->dlGrnt.iMcs = 0;
5874       tbInfo->dlGrnt.rv   = 1;
5875    }
5876    /* Fill for TB retransmission */
5877    else if (tbInfo->txCntr > 0)
5878    {
5879
5880       tbInfo->timingInfo = cmnCellDl->time;
5881       /* Fix */
5882       if ((tbInfo->isAckNackDtx == TFU_HQFDB_DTX)) 
5883       {
5884          tbInfo->dlGrnt.iMcs = tbAllocInfo->imcs;         
5885          rgHqRvRetxCnt[tbInfo->dlGrnt.rv][tbInfo->tbIdx]++;
5886       }
5887       else
5888       {
5889          tbInfo->dlGrnt.rv = rgSchCmnDlRvTbl[++(tbInfo->ccchSchdInfo.rvIdx) & 0x03];
5890       }
5891
5892       /* fill the scheduler information of hqProc */
5893       tbInfo->ccchSchdInfo.totBytes = tbAllocInfo->bytesAlloc;
5894       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx,hqP->tbInfo,tbInfo->tbIdx );
5895       rgSCHDhmHqTbRetx(hqP->hqE, tbInfo->timingInfo, hqP, tbInfo->tbIdx);
5896    }
5897    /* Fill for TB transmission */
5898    else
5899    {
5900       /* Fill the HqProc */
5901       tbInfo->dlGrnt.iMcs = tbAllocInfo->imcs;
5902       tbInfo->tbSz = tbAllocInfo->bytesAlloc;
5903       tbInfo->timingInfo = cmnCellDl->time;
5904
5905       tbInfo->dlGrnt.rv = rgSchCmnDlRvTbl[0];
5906       /* fill the scheduler information of hqProc */
5907       tbInfo->ccchSchdInfo.rvIdx = 0;
5908       tbInfo->ccchSchdInfo.totBytes = tbAllocInfo->bytesAlloc;
5909       /* DwPts Scheduling Changes Start */
5910       /* DwPts Scheduling Changes End */ 
5911       cell->measurements.dlBytesCnt += tbAllocInfo->bytesAlloc;
5912    }
5913
5914    /*ccpu00120365:-ADD-only add to subFrm list if tb is not disabled */
5915    if ( tbAllocInfo->isDisabled == FALSE )
5916    {
5917       /* Set the number of transmitting SM layers for this TB */
5918       tbInfo->numLyrs = tbAllocInfo->noLyr;
5919       /* Set the TB state as WAITING to indicate TB has been
5920        * considered for transmission */
5921       tbInfo->state  = HQ_TB_WAITING;
5922       hqP->subFrm = rbAllocInfo->dlSf;
5923       tbInfo->hqP->pdcch  = pdcch;
5924       //tbInfo->dlGrnt.numRb = rbAllocInfo->rbsAlloc;
5925       rgSCHUtlDlHqPTbAddToTx(hqP->subFrm, hqP, tbInfo->tbIdx);
5926    }
5927    RETVOID;
5928 }
5929
5930 /**
5931  * @brief This function fills the PDCCH DCI format 2 information from dlProc.
5932  *
5933  * @details
5934  *
5935  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2
5936  *     Purpose:  This function fills in the PDCCH information
5937  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
5938  *               for dedicated service scheduling. It also
5939  *               obtains TPC to be filled in from the power module.
5940  *               Assign the PDCCH to HQProc.
5941  *
5942  *     Invoked by: Downlink Scheduler
5943  *
5944  *  @param[in]  RgSchCellCb*      cell
5945  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
5946  *  @param[in]  RgDlHqProc*       hqP
5947  *  @param[out]  RgSchPdcch        *pdcch
5948  *  @param[in]   U8               tpc
5949  *  @return  Void
5950  *
5951  **/
5952 #ifdef ANSI
5953 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2
5954 (
5955 RgSchCellCb                *cell,
5956 RgSchDlRbAlloc             *rbAllocInfo,
5957 RgSchDlHqProcCb            *hqP,
5958 RgSchPdcch                 *pdcch,
5959 U8                         tpc
5960 )
5961 #else
5962 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
5963 RgSchCellCb                *cell;
5964 RgSchDlRbAlloc             *rbAllocInfo;
5965 RgSchDlHqProcCb            *hqP;
5966 RgSchPdcch                 *pdcch;
5967 U8                         tpc;
5968 #endif
5969 {
5970
5971    TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
5972
5973    rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);   
5974    //Currently hardcoding values here.
5975    //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
5976    switch(rbAllocInfo->dciFormat)
5977    {
5978       case TFU_DCI_FORMAT_B1:
5979          {
5980             pdcch->dci.u.formatB1Info.formatType = 0;
5981             pdcch->dci.u.formatB1Info.xPDSCHRange = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange;
5982             pdcch->dci.u.formatB1Info.RBAssign = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign;
5983             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.hqProcId = hqP->procId;
5984             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
5985             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
5986             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
5987             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
5988             pdcch->dci.u.formatB1Info.CSI_BSI_BRI_Req = 0;
5989             pdcch->dci.u.formatB1Info.CSIRS_BRRS_TxTiming = 0;
5990             pdcch->dci.u.formatB1Info.CSIRS_BRRS_SymbIdx = 0;
5991             pdcch->dci.u.formatB1Info.CSIRS_BRRS_ProcInd = 0;
5992             pdcch->dci.u.formatB1Info.xPUCCH_TxTiming = 0;
5993             //TODO_SID: Need to update
5994             pdcch->dci.u.formatB1Info.freqResIdx_xPUCCH = 0;
5995             pdcch->dci.u.formatB1Info.beamSwitch  = 0;
5996             pdcch->dci.u.formatB1Info.SRS_Config = 0;
5997             pdcch->dci.u.formatB1Info.SRS_Symbol = 0;
5998             //TODO_SID: Need to check.Currently setting 0(1 layer, ports(8) w/o OCC).
5999             pdcch->dci.u.formatB1Info.AntPorts_numLayers = 0;
6000             pdcch->dci.u.formatB1Info.SCID = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.SCID;
6001             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
6002             pdcch->dci.u.formatB1Info.tpcCmd = 1; //tpc;
6003             pdcch->dci.u.formatB1Info.DL_PCRS = 0;
6004             break;
6005          }
6006       case TFU_DCI_FORMAT_B2:
6007          {
6008             pdcch->dci.u.formatB2Info.formatType = 1;
6009             pdcch->dci.u.formatB2Info.xPDSCHRange = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange;
6010             pdcch->dci.u.formatB2Info.RBAssign = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign;
6011             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.hqProcId = hqP->procId;
6012             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
6013             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6014             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6015             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
6016             pdcch->dci.u.formatB2Info.CSI_BSI_BRI_Req = 0;
6017             pdcch->dci.u.formatB2Info.CSIRS_BRRS_TxTiming = 0;
6018             pdcch->dci.u.formatB2Info.CSIRS_BRRS_SymbIdx = 0;
6019             pdcch->dci.u.formatB2Info.CSIRS_BRRS_ProcInd = 0;
6020             pdcch->dci.u.formatB2Info.xPUCCH_TxTiming = 0;
6021             //TODO_SID: Need to update
6022             pdcch->dci.u.formatB2Info.freqResIdx_xPUCCH = 0;
6023             pdcch->dci.u.formatB2Info.beamSwitch  = 0;
6024             pdcch->dci.u.formatB2Info.SRS_Config = 0;
6025             pdcch->dci.u.formatB2Info.SRS_Symbol = 0;
6026             //TODO_SID: Need to check.Currently setting 4(2 layer, ports(8,9) w/o OCC).
6027             pdcch->dci.u.formatB2Info.AntPorts_numLayers = 4;
6028             pdcch->dci.u.formatB2Info.SCID = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.SCID;
6029             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
6030             pdcch->dci.u.formatB2Info.tpcCmd = 1; //tpc;
6031             pdcch->dci.u.formatB2Info.DL_PCRS = 0;
6032             break;
6033          }
6034          default:
6035             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId," 5GTF_ERROR Allocator's icorrect "
6036                "dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
6037             break;
6038    }
6039    
6040    RETVOID;
6041 }
6042
6043 extern U32 totPcellSCell;
6044 extern U32 addedForScell;
6045 extern U32 addedForScell1;
6046 extern U32 addedForScell2;
6047 /**
6048  * @brief This function fills the PDCCH information from dlProc.
6049  *
6050  * @details
6051  *
6052  *     Function: rgSCHCmnFillHqPPdcch
6053  *     Purpose:  This function fills in the PDCCH information
6054  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6055  *               for dedicated service scheduling. It also
6056  *               obtains TPC to be filled in from the power module.
6057  *               Assign the PDCCH to HQProc.
6058  *
6059  *     Invoked by: Downlink Scheduler
6060  *
6061  *  @param[in]  RgSchCellCb*      cell
6062  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6063  *  @param[in]  RgDlHqProc*       hqP
6064  *  @return  Void
6065  *
6066  **/
6067 #ifdef ANSI
6068 PUBLIC Void rgSCHCmnFillHqPPdcch
6069 (
6070 RgSchCellCb                *cell,
6071 RgSchDlRbAlloc             *rbAllocInfo,
6072 RgSchDlHqProcCb            *hqP
6073 )
6074 #else
6075 PUBLIC Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
6076 RgSchCellCb                *cell;
6077 RgSchDlRbAlloc             *rbAllocInfo;
6078 RgSchDlHqProcCb            *hqP;
6079 #endif
6080 {
6081    RgSchCmnDlCell     *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
6082    RgSchPdcch         *pdcch = rbAllocInfo->pdcch;
6083    U8                 tpc = 1;
6084
6085    TRC2(rgSCHCmnFillHqPPdcch);
6086
6087    if (hqP->hqE->ue)
6088    {
6089 #ifdef LTE_ADV
6090       if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6091       {
6092          tpc = hqP->tpc;
6093       }
6094       else
6095 #endif
6096       {
6097          tpc = rgSCHPwrPucchTpcForUe(cell, hqP->hqE->ue);
6098       }
6099       /* Fix: syed moving this to a common function for both scheduled
6100        * and non-scheduled UEs */
6101
6102       pdcch->ue = hqP->hqE->ue;
6103       if (hqP->hqE->ue->csgMmbrSta == FALSE)
6104       {
6105          cmnCell->ncsgPrbCnt += rbAllocInfo->rbsAlloc;
6106       }
6107       cmnCell->totPrbCnt += rbAllocInfo->rbsAlloc;
6108 #ifdef TENB_STATS
6109       {
6110          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlPrbUsg += 
6111             rbAllocInfo->rbsAlloc;
6112          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlSumCw0iTbs += 
6113             rbAllocInfo->tbInfo[0].iTbs;
6114          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlNumCw0iTbs ++; 
6115          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt +=
6116             (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6117
6118 #ifdef LTE_ADV
6119       totPcellSCell += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6120       if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6121       {
6122          addedForScell +=  (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6123          addedForScell1 += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6124 /*
6125          printf (" Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
6126          hqP->procId,
6127          hqP->hqE->cell->cellId,
6128          addedForScell,
6129          addedForScell1,
6130          cell->crntTime.sfn,
6131          cell->crntTime.slot);
6132          */
6133       }
6134 #endif
6135          hqP->hqE->cell->tenbStats->sch.dlPrbUsage[0] += 
6136             rbAllocInfo->rbsAlloc;
6137          hqP->hqE->cell->tenbStats->sch.dlSumCw0iTbs += 
6138             rbAllocInfo->tbInfo[0].iTbs;
6139          hqP->hqE->cell->tenbStats->sch.dlNumCw0iTbs ++; 
6140          hqP->hqE->cell->tenbStats->sch.dlTtlTpt +=
6141             (rbAllocInfo->tbInfo[0].bytesAlloc << 3); 
6142          if (rbAllocInfo->tbInfo[1].schdlngForTb)
6143          {
6144             hqP->hqE->cell->tenbStats->sch.dlSumCw1iTbs += 
6145                rbAllocInfo->tbInfo[1].iTbs;
6146             hqP->hqE->cell->tenbStats->sch.dlNumCw1iTbs ++; 
6147             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlSumCw1iTbs += 
6148                rbAllocInfo->tbInfo[1].iTbs;
6149             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlNumCw1iTbs ++; 
6150             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt +=
6151                (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6152
6153
6154 #ifdef LTE_ADV
6155             if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6156             {
6157                addedForScell +=  (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6158                addedForScell2 += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6159 /*
6160          printf (" Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
6161          hqP->procId,
6162          hqP->hqE->cell->cellId,
6163          addedForScell,
6164          addedForScell2);
6165          */
6166             }
6167             totPcellSCell += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6168 #endif
6169
6170
6171             hqP->hqE->cell->tenbStats->sch.dlTtlTpt +=
6172                (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6173          }
6174          /*
6175          printf ("add DL TPT is %lu  sfn:sf %d:%d \n", hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt ,
6176          cell->crntTime.sfn,
6177          cell->crntTime.slot);
6178          */
6179       }
6180 #endif
6181    }
6182
6183    pdcch->rnti                       = rbAllocInfo->rnti;
6184    pdcch->dci.dciFormat              = rbAllocInfo->dciFormat;
6185    /* Update subframe and pdcch info in HqTb control block */
6186    switch(rbAllocInfo->dciFormat)
6187    {
6188 #ifdef RG_5GTF  
6189       case TFU_DCI_FORMAT_B1:
6190       case TFU_DCI_FORMAT_B2:
6191            {
6192         // printf(" RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
6193               rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, \
6194                     pdcch, tpc);
6195               break;
6196            }
6197 #endif
6198       default:
6199          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6200             "Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
6201          break;
6202    }
6203    RETVOID;
6204 }
6205 #ifdef UNUSE_FUN
6206 /**
6207  * @brief This function fills the PDCCH DCI format 1 information from dlProc.
6208  *
6209  * @details
6210  *
6211  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1
6212  *     Purpose:  This function fills in the PDCCH information
6213  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6214  *               for dedicated service scheduling. It also
6215  *               obtains TPC to be filled in from the power module.
6216  *               Assign the PDCCH to HQProc.
6217  *
6218  *     Invoked by: Downlink Scheduler
6219  *
6220  *  @param[in]  RgSchCellCb*      cell
6221  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6222  *  @param[in]  RgDlHqProc*       hqP
6223  *  @param[out]  RgSchPdcch        *pdcch
6224  *  @param[in]   U8               tpc
6225  *  @return  Void
6226  *
6227  **/
6228
6229 #ifdef ANSI
6230 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1
6231 (
6232 RgSchCellCb                *cell,
6233 RgSchDlRbAlloc             *rbAllocInfo,
6234 RgSchDlHqProcCb            *hqP,
6235 RgSchPdcch                 *pdcch,
6236 U8                         tpc
6237 )
6238 #else
6239 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
6240 RgSchCellCb                *cell;
6241 RgSchDlRbAlloc             *rbAllocInfo;
6242 RgSchDlHqProcCb            *hqP;
6243 RgSchPdcch                 *pdcch;
6244 U8                         tpc;
6245 #endif
6246 {
6247
6248 #ifdef LTE_TDD
6249    RgSchTddANInfo     *anInfo;
6250 #endif
6251
6252 #ifdef LTEMAC_SPS
6253 /* For activation or reactivation,
6254  * Harq ProcId should be 0 */
6255    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6256 #endif
6257
6258     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
6259
6260     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6261     pdcch->dci.u.format1Info.tpcCmd = tpc;
6262      /* Avoiding this check,as we dont support Type1 RA */
6263 #ifdef RG_UNUSED
6264     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6265     {
6266 #endif
6267        pdcch->dci.u.format1Info.allocInfo.isAllocType0 = TRUE;
6268        pdcch->dci.u.format1Info.allocInfo.resAllocMap[0] =
6269          ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6270                & 0xff);
6271        pdcch->dci.u.format1Info.allocInfo.resAllocMap[1] =
6272          ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6273                & 0x00ff);
6274        pdcch->dci.u.format1Info.allocInfo.resAllocMap[2] =
6275            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6276                & 0x0000ff);
6277        pdcch->dci.u.format1Info.allocInfo.resAllocMap[3] =
6278            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6279 #ifdef RG_UNUSED
6280     }
6281 #endif
6282 #ifdef LTEMAC_SPS
6283     if ((!(hqP->tbInfo[0].txCntr)) &&
6284        (cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6285          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6286          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV)))
6287        )
6288     {
6289        pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
6290     }
6291     else
6292     {
6293       pdcch->dci.u.format1Info.allocInfo.harqProcId = hqP->procId;
6294     }
6295 #else
6296     pdcch->dci.u.format1Info.allocInfo.harqProcId = hqP->procId;
6297 #endif
6298
6299     pdcch->dci.u.format1Info.allocInfo.ndi = 
6300                         rbAllocInfo->tbInfo[0].tbCb->ndi;
6301     pdcch->dci.u.format1Info.allocInfo.mcs = 
6302                         rbAllocInfo->tbInfo[0].imcs;
6303     pdcch->dci.u.format1Info.allocInfo.rv = 
6304                         rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6305 #ifdef LTE_TDD
6306        if(hqP->hqE->ue != NULLP)
6307        {
6308 #ifdef LTE_ADV
6309            U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6310                                         hqP->hqE->cell->cellId,
6311                                         hqP->hqE->ue);
6312
6313            anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6314                             &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6315 #else
6316            anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6317                             &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6318 #endif
6319 #ifdef TFU_TDD
6320           if(anInfo)
6321           {
6322              pdcch->dci.u.format1Info.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6323           }
6324           else
6325           {
6326                /* Fixing DAI value - ccpu00109162 */
6327              pdcch->dci.u.format1Info.dai = RG_SCH_MAX_DAI_IDX;
6328           }
6329 #endif
6330        }
6331        else
6332        {
6333             /* always 0 for RACH */
6334            pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
6335 #ifdef TFU_TDD
6336             /* Fixing DAI value - ccpu00109162 */
6337            pdcch->dci.u.format1Info.dai = 1;
6338 #endif
6339        }
6340 #endif
6341  
6342
6343        RETVOID;
6344 }
6345 /**
6346  * @brief This function fills the PDCCH DCI format 1A information from dlProc.
6347  *
6348  * @details
6349  *
6350  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1A
6351  *     Purpose:  This function fills in the PDCCH information
6352  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6353  *               for dedicated service scheduling. It also
6354  *               obtains TPC to be filled in from the power module.
6355  *               Assign the PDCCH to HQProc.
6356  *
6357  *     Invoked by: Downlink Scheduler
6358  *
6359  *  @param[in]  RgSchCellCb*      cell
6360  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6361  *  @param[in]  RgDlHqProc*       hqP
6362  *  @param[out]  RgSchPdcch        *pdcch
6363  *  @param[in]   U8               tpc
6364  *  @return  Void
6365  *
6366  **/
6367 #ifdef ANSI
6368 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A
6369 (
6370 RgSchCellCb                *cell,
6371 RgSchDlRbAlloc             *rbAllocInfo,
6372 RgSchDlHqProcCb            *hqP,
6373 RgSchPdcch                 *pdcch,
6374 U8                         tpc
6375 )
6376 #else
6377 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
6378 RgSchCellCb                *cell;
6379 RgSchDlRbAlloc             *rbAllocInfo;
6380 RgSchDlHqProcCb            *hqP;
6381 RgSchPdcch                 *pdcch;
6382 U8                         tpc;
6383 #endif
6384 {
6385
6386 #ifdef LTE_TDD
6387    RgSchTddANInfo     *anInfo;
6388 #endif
6389
6390 #ifdef LTEMAC_SPS
6391    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6392 #endif
6393
6394     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
6395
6396     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6397     pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
6398     pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = tpc;
6399     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.mcs     = \
6400       rbAllocInfo->tbInfo[0].imcs;
6401     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres = TRUE;
6402 #ifdef LTEMAC_SPS
6403     if ((!(hqP->tbInfo[0].txCntr)) &&
6404        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6405          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6406          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6407        ))
6408     {
6409        pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val = 0;
6410     }
6411     else
6412     {
6413       pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val
6414                                                 = hqP->procId;
6415     }
6416 #else
6417     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val =
6418                                               hqP->procId;
6419 #endif
6420     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.ndi     = \
6421        rbAllocInfo->tbInfo[0].tbCb->ndi;
6422     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv      = \
6423        rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6424          /* As of now, we do not support Distributed allocations */
6425     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.isLocal = TRUE;
6426     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.nGap2.pres = NOTPRSNT;
6427     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.type =
6428             TFU_ALLOC_TYPE_RIV;
6429     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.u.riv =
6430     rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
6431                   rbAllocInfo->allocInfo.raType2.rbStart,
6432                   rbAllocInfo->allocInfo.raType2.numRb);
6433 #ifdef LTE_TDD
6434     if(hqP->hqE->ue != NULLP)
6435     {
6436 #ifdef LTE_ADV
6437        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6438                                         hqP->hqE->cell->cellId,
6439                                         hqP->hqE->ue);
6440        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6441                               &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6442 #else
6443        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6444                               &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6445 #endif
6446 #ifdef TFU_TDD
6447        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
6448        if(anInfo)
6449        {
6450           pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 
6451                               RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6452        }
6453        else
6454        {
6455           /* Fixing DAI value - ccpu00109162 */
6456           pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = RG_SCH_MAX_DAI_IDX;
6457           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6458                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6459                     rbAllocInfo->rnti);
6460        }
6461 #endif
6462     }
6463     else
6464     {
6465             /* always 0 for RACH */
6466        pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres
6467                                                                      = FALSE;
6468 #ifdef TFU_TDD
6469        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
6470             /* Fixing DAI value - ccpu00109162 */
6471        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 1;
6472 #endif
6473     }
6474 #endif
6475  
6476     RETVOID;
6477 }       
6478 /**
6479  * @brief This function fills the PDCCH DCI format 1B information from dlProc.
6480  *
6481  * @details
6482  *
6483  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1B
6484  *     Purpose:  This function fills in the PDCCH information
6485  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6486  *               for dedicated service scheduling. It also
6487  *               obtains TPC to be filled in from the power module.
6488  *               Assign the PDCCH to HQProc.
6489  *
6490  *     Invoked by: Downlink Scheduler
6491  *
6492  *  @param[in]  RgSchCellCb*      cell
6493  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6494  *  @param[in]  RgDlHqProc*       hqP
6495  *  @param[out]  RgSchPdcch        *pdcch
6496  *  @param[in]   U8               tpc
6497  *  @return  Void
6498  *
6499  **/
6500 #ifdef ANSI
6501 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B
6502 (
6503 RgSchCellCb                *cell,
6504 RgSchDlRbAlloc             *rbAllocInfo,
6505 RgSchDlHqProcCb            *hqP,
6506 RgSchPdcch                 *pdcch,
6507 U8                         tpc
6508 )
6509 #else
6510 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
6511 RgSchCellCb                *cell;
6512 RgSchDlRbAlloc             *rbAllocInfo;
6513 RgSchDlHqProcCb            *hqP;
6514 RgSchPdcch                 *pdcch;
6515 U8                         tpc;
6516 #endif
6517 {
6518
6519 #ifdef LTE_TDD
6520    RgSchTddANInfo     *anInfo;
6521 #endif
6522
6523 #ifdef LTEMAC_SPS
6524    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6525 #endif
6526
6527     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
6528
6529     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6530     pdcch->dci.u.format1bInfo.tpcCmd  = tpc;
6531     pdcch->dci.u.format1bInfo.allocInfo.mcs     = \
6532            rbAllocInfo->tbInfo[0].imcs;
6533 #ifdef LTEMAC_SPS
6534     if ((!(hqP->tbInfo[0].txCntr)) &&
6535        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6536          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6537          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6538        ))
6539     {
6540        pdcch->dci.u.format1bInfo.allocInfo.harqProcId = 0;
6541     }
6542     else
6543     {
6544       pdcch->dci.u.format1bInfo.allocInfo.harqProcId = hqP->procId;
6545     }
6546 #else
6547     pdcch->dci.u.format1bInfo.allocInfo.harqProcId = hqP->procId;
6548 #endif
6549     pdcch->dci.u.format1bInfo.allocInfo.ndi     = \
6550           rbAllocInfo->tbInfo[0].tbCb->ndi;
6551     pdcch->dci.u.format1bInfo.allocInfo.rv      = \
6552            rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6553          /* As of now, we do not support Distributed allocations */
6554     pdcch->dci.u.format1bInfo.allocInfo.isLocal = TRUE;
6555     pdcch->dci.u.format1bInfo.allocInfo.nGap2.pres = NOTPRSNT;
6556     pdcch->dci.u.format1bInfo.allocInfo.alloc.type =
6557             TFU_ALLOC_TYPE_RIV;
6558     pdcch->dci.u.format1bInfo.allocInfo.alloc.u.riv =
6559     rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
6560                   rbAllocInfo->allocInfo.raType2.rbStart,
6561                   rbAllocInfo->allocInfo.raType2.numRb);
6562          /* Fill precoding Info */
6563     pdcch->dci.u.format1bInfo.allocInfo.pmiCfm = \
6564                rbAllocInfo->mimoAllocInfo.precIdxInfo >> 4;
6565     pdcch->dci.u.format1bInfo.allocInfo.tPmi   = \
6566                rbAllocInfo->mimoAllocInfo.precIdxInfo & 0x0F;
6567 #ifdef LTE_TDD
6568     if(hqP->hqE->ue != NULLP)
6569     {
6570 #ifdef LTE_ADV
6571        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6572                                         hqP->hqE->cell->cellId,
6573                                         hqP->hqE->ue);
6574        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6575              &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6576 #else
6577        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6578              &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6579 #endif
6580 #ifdef TFU_TDD
6581        if(anInfo)
6582        {
6583           pdcch->dci.u.format1bInfo.dai = 
6584                          RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6585        }
6586        else
6587        {
6588           pdcch->dci.u.format1bInfo.dai = RG_SCH_MAX_DAI_IDX;
6589           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6590                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6591                    rbAllocInfo->rnti);
6592        }
6593 #endif
6594     }
6595 #endif
6596        
6597     RETVOID;
6598
6599 }
6600 /**
6601  * @brief This function fills the PDCCH DCI format 2 information from dlProc.
6602  *
6603  * @details
6604  *
6605  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2
6606  *     Purpose:  This function fills in the PDCCH information
6607  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6608  *               for dedicated service scheduling. It also
6609  *               obtains TPC to be filled in from the power module.
6610  *               Assign the PDCCH to HQProc.
6611  *
6612  *     Invoked by: Downlink Scheduler
6613  *
6614  *  @param[in]  RgSchCellCb*      cell
6615  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6616  *  @param[in]  RgDlHqProc*       hqP
6617  *  @param[out]  RgSchPdcch        *pdcch
6618  *  @param[in]   U8               tpc
6619  *  @return  Void
6620  *
6621  **/
6622 #ifdef ANSI
6623 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2
6624 (
6625 RgSchCellCb                *cell,
6626 RgSchDlRbAlloc             *rbAllocInfo,
6627 RgSchDlHqProcCb            *hqP,
6628 RgSchPdcch                 *pdcch,
6629 U8                         tpc
6630 )
6631 #else
6632 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
6633 RgSchCellCb                *cell;
6634 RgSchDlRbAlloc             *rbAllocInfo;
6635 RgSchDlHqProcCb            *hqP;
6636 RgSchPdcch                 *pdcch;
6637 U8                         tpc;
6638 #endif
6639 {
6640
6641 #ifdef LTE_TDD
6642    RgSchTddANInfo     *anInfo;
6643 #endif
6644
6645 #ifdef LTEMAC_SPS
6646 /* ccpu00119023-ADD-For activation or reactivation,
6647  * Harq ProcId should be 0 */
6648    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6649 #endif
6650
6651     TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
6652
6653     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6654     /*ccpu00120365:-ADD-call also if tb is disabled */
6655     if (rbAllocInfo->tbInfo[1].schdlngForTb ||
6656         rbAllocInfo->tbInfo[1].isDisabled)
6657     {
6658         rgSCHCmnFillHqPTb(cell, rbAllocInfo, 1, pdcch);
6659     }
6660     pdcch->dci.u.format2Info.tpcCmd = tpc;
6661          /* Avoiding this check,as we dont support Type1 RA */
6662 #ifdef RG_UNUSED
6663     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6664     {
6665 #endif
6666         pdcch->dci.u.format2Info.allocInfo.isAllocType0 = TRUE;
6667         pdcch->dci.u.format2Info.allocInfo.resAllocMap[0] =
6668           ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6669                & 0xff);
6670         pdcch->dci.u.format2Info.allocInfo.resAllocMap[1] =
6671            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6672                & 0x00ff);
6673         pdcch->dci.u.format2Info.allocInfo.resAllocMap[2] =
6674                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6675                 & 0x0000ff);
6676         pdcch->dci.u.format2Info.allocInfo.resAllocMap[3] =
6677                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6678 #ifdef RG_UNUSED
6679     }
6680 #endif
6681 #ifdef LTEMAC_SPS
6682     if ((!(hqP->tbInfo[0].txCntr)) &&
6683        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6684          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6685          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6686        ))
6687     {
6688        pdcch->dci.u.format2Info.allocInfo.harqProcId = 0;
6689     }
6690     else
6691     {
6692       pdcch->dci.u.format2Info.allocInfo.harqProcId = hqP->procId;
6693     }
6694 #else
6695      pdcch->dci.u.format2Info.allocInfo.harqProcId = hqP->procId;
6696 #endif
6697          /* Initialize the TB info for both the TBs */
6698      pdcch->dci.u.format2Info.allocInfo.tbInfo[0].mcs = 0;
6699      pdcch->dci.u.format2Info.allocInfo.tbInfo[0].rv  = 1;
6700      pdcch->dci.u.format2Info.allocInfo.tbInfo[1].mcs = 0;
6701      pdcch->dci.u.format2Info.allocInfo.tbInfo[1].rv  = 1;
6702          /* Fill tbInfo for scheduled TBs */
6703      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6704         tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6705      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6706         tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[0].imcs;
6707      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6708             tbCb->tbIdx].rv = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6709           /* If we reach this function. It is safely assumed that
6710            *  rbAllocInfo->tbInfo[0] always has non default valid values.
6711            *  rbAllocInfo->tbInfo[1]'s scheduling is optional */
6712      if (rbAllocInfo->tbInfo[1].schdlngForTb == TRUE)
6713      {
6714             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6715                 tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[1].tbCb->ndi;
6716             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6717                 tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[1].imcs;
6718             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6719                 tbCb->tbIdx].rv = rbAllocInfo->tbInfo[1].tbCb->dlGrnt.rv;
6720      }
6721      pdcch->dci.u.format2Info.allocInfo.transSwap =
6722              rbAllocInfo->mimoAllocInfo.swpFlg;
6723      pdcch->dci.u.format2Info.allocInfo.precoding =
6724              rbAllocInfo->mimoAllocInfo.precIdxInfo;
6725 #ifdef LTE_TDD
6726      if(hqP->hqE->ue != NULLP)
6727      {
6728
6729 #ifdef LTE_ADV
6730         U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6731                                         hqP->hqE->cell->cellId,
6732                                         hqP->hqE->ue);
6733         anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6734                            &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6735 #else
6736         anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6737                            &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6738 #endif
6739 #ifdef TFU_TDD
6740         if(anInfo)
6741         {
6742            pdcch->dci.u.format2Info.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6743         }
6744         else
6745         {
6746            pdcch->dci.u.format2Info.dai = RG_SCH_MAX_DAI_IDX;
6747            RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6748                     "PDCCH is been scheduled without updating anInfo RNTI:%d",
6749                     rbAllocInfo->rnti);
6750         }
6751 #endif
6752      }
6753 #endif
6754
6755      RETVOID;
6756 }
6757 /**
6758  * @brief This function fills the PDCCH DCI format 2A information from dlProc.
6759  *
6760  * @details
6761  *
6762  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2A
6763  *     Purpose:  This function fills in the PDCCH information
6764  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6765  *               for dedicated service scheduling. It also
6766  *               obtains TPC to be filled in from the power module.
6767  *               Assign the PDCCH to HQProc.
6768  *
6769  *     Invoked by: Downlink Scheduler
6770  *
6771  *  @param[in]  RgSchCellCb*      cell
6772  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6773  *  @param[in]  RgDlHqProc*       hqP
6774  *  @param[out]  RgSchPdcch        *pdcch
6775  *  @param[in]   U8               tpc
6776  *  @return  Void
6777  *
6778  **/
6779 #ifdef ANSI
6780 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A
6781 (
6782 RgSchCellCb                *cell,
6783 RgSchDlRbAlloc             *rbAllocInfo,
6784 RgSchDlHqProcCb            *hqP,
6785 RgSchPdcch                 *pdcch,
6786 U8                         tpc
6787 )
6788 #else
6789 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
6790 RgSchCellCb                *cell;
6791 RgSchDlRbAlloc             *rbAllocInfo;
6792 RgSchDlHqProcCb            *hqP;
6793 RgSchPdcch                 *pdcch;
6794 U8                         tpc;
6795 #endif
6796 {
6797 #ifdef LTE_TDD
6798    RgSchTddANInfo     *anInfo;
6799 #endif
6800
6801 #ifdef LTEMAC_SPS
6802    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6803 #endif
6804
6805     TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
6806
6807     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6808     /*ccpu00120365:-ADD-call also if tb is disabled */
6809     if (rbAllocInfo->tbInfo[1].schdlngForTb ||
6810           rbAllocInfo->tbInfo[1].isDisabled)
6811     {
6812
6813         rgSCHCmnFillHqPTb(cell, rbAllocInfo, 1, pdcch);
6814     }
6815
6816     pdcch->dci.u.format2AInfo.tpcCmd = tpc;
6817          /* Avoiding this check,as we dont support Type1 RA */
6818 #ifdef RG_UNUSED
6819     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6820     {
6821 #endif
6822         pdcch->dci.u.format2AInfo.allocInfo.isAllocType0 = TRUE;
6823         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[0] =
6824               ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6825                & 0xff);
6826         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[1] =
6827               ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6828                & 0x00ff);
6829         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[2] =
6830                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6831                 & 0x0000ff);
6832         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[3] =
6833                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6834 #ifdef RG_UNUSED
6835     }
6836 #endif
6837 #ifdef LTEMAC_SPS
6838     if ((!(hqP->tbInfo[0].txCntr)) &&
6839        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6840          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6841          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6842        ))
6843     {
6844        pdcch->dci.u.format2AInfo.allocInfo.harqProcId = 0;
6845     }
6846     else
6847     {
6848       pdcch->dci.u.format2AInfo.allocInfo.harqProcId = hqP->procId;
6849     }
6850 #else
6851     pdcch->dci.u.format2AInfo.allocInfo.harqProcId = hqP->procId;
6852 #endif
6853          /* Initialize the TB info for both the TBs */
6854     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[0].mcs = 0;
6855     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[0].rv  = 1;
6856     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[1].mcs = 0;
6857     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[1].rv  = 1;
6858          /* Fill tbInfo for scheduled TBs */
6859     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6860             tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6861     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6862             tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[0].imcs;
6863     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6864             tbCb->tbIdx].rv = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6865          /* If we reach this function. It is safely assumed that
6866           *  rbAllocInfo->tbInfo[0] always has non default valid values.
6867           *  rbAllocInfo->tbInfo[1]'s scheduling is optional */
6868
6869     if (rbAllocInfo->tbInfo[1].schdlngForTb == TRUE)
6870     {
6871             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6872                tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[1].tbCb->ndi;
6873             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6874                tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[1].imcs;
6875             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6876                tbCb->tbIdx].rv = rbAllocInfo->tbInfo[1].tbCb->dlGrnt.rv;
6877
6878     }
6879     pdcch->dci.u.format2AInfo.allocInfo.transSwap =
6880             rbAllocInfo->mimoAllocInfo.swpFlg;
6881     pdcch->dci.u.format2AInfo.allocInfo.precoding =
6882             rbAllocInfo->mimoAllocInfo.precIdxInfo;
6883 #ifdef LTE_TDD
6884     if(hqP->hqE->ue != NULLP)
6885     {
6886 #ifdef LTE_ADV
6887        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6888                                         hqP->hqE->cell->cellId,
6889                                         hqP->hqE->ue);
6890        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6891                          &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6892 #else
6893        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6894                          &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6895 #endif
6896 #ifdef TFU_TDD
6897        if(anInfo)
6898        {
6899           pdcch->dci.u.format2AInfo.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6900        }
6901        else
6902        {
6903           pdcch->dci.u.format2AInfo.dai = RG_SCH_MAX_DAI_IDX;
6904           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6905                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6906                    rbAllocInfo->rnti);
6907        }
6908 #endif
6909      }
6910 #endif
6911
6912
6913     RETVOID;
6914 }
6915 #endif
6916 /**
6917  * @brief init of Sch vars.
6918  *
6919  * @details
6920  *
6921  *     Function: rgSCHCmnInitVars
6922        Purpose:  Initialization of various UL subframe indices
6923  *
6924  *  @param[in]  RgSchCellCb *cell
6925  *  @return  Void
6926  *
6927  **/
6928 #ifdef ANSI
6929 PRIVATE Void rgSCHCmnInitVars
6930 (
6931 RgSchCellCb *cell
6932 )
6933 #else
6934 PRIVATE Void rgSCHCmnInitVars(cell)
6935 RgSchCellCb *cell;
6936 #endif
6937 {
6938    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
6939
6940    TRC2(rgSCHCmnInitVars);
6941
6942    cellUl->idx         = RGSCH_INVALID_INFO;
6943    cellUl->schdIdx     = RGSCH_INVALID_INFO;
6944    cellUl->schdHqProcIdx = RGSCH_INVALID_INFO;
6945    cellUl->msg3SchdIdx = RGSCH_INVALID_INFO;
6946 #ifdef EMTC_ENBLE
6947    cellUl->emtcMsg3SchdIdx = RGSCH_INVALID_INFO;
6948 #endif
6949    cellUl->msg3SchdHqProcIdx = RGSCH_INVALID_INFO;
6950    cellUl->rcpReqIdx   = RGSCH_INVALID_INFO;
6951    cellUl->hqFdbkIdx[0] = RGSCH_INVALID_INFO;
6952    cellUl->hqFdbkIdx[1] = RGSCH_INVALID_INFO;
6953    cellUl->reTxIdx[0]   = RGSCH_INVALID_INFO;
6954    cellUl->reTxIdx[1]   = RGSCH_INVALID_INFO;
6955   /* Stack Crash problem for TRACE5 Changes. Added the return below */
6956   RETVOID;
6957
6958 }
6959
6960 #ifndef LTE_TDD
6961 /**
6962  * @brief Updation of Sch vars per TTI.
6963  *
6964  * @details
6965  *
6966  *     Function: rgSCHCmnUpdVars
6967  *     Purpose:  Updation of Sch vars per TTI.
6968  *
6969  *  @param[in]  RgSchCellCb *cell
6970  *  @return  Void
6971  *
6972  **/
6973 #ifdef ANSI
6974 PUBLIC Void rgSCHCmnUpdVars
6975 (
6976 RgSchCellCb *cell
6977 )
6978 #else
6979 PUBLIC Void rgSCHCmnUpdVars(cell)
6980 RgSchCellCb *cell;
6981 #endif
6982 {
6983    CmLteTimingInfo   timeInfo;
6984    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
6985    U16 idx;
6986
6987    TRC2(rgSCHCmnUpdVars);
6988
6989    idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
6990    cellUl->idx     = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
6991 #ifdef UL_ADPT_DBG     
6992    printf("idx %d cellUl->idx  %d RGSCH_NUM_SUB_FRAMES_5G %d  time(%d %d) \n",idx,cellUl->idx ,RGSCH_NUM_SUB_FRAMES_5G,cell->crntTime.sfn,cell->crntTime.slot);
6993 #endif    
6994    /* Need to scheduler for after SCHED_DELTA */
6995    /* UL allocation has been advanced by 1 subframe
6996     * so that we do not wrap around and send feedback
6997     * before the data is even received by the PHY */
6998    /* Introduced timing delta for UL control */
6999    idx = (cellUl->idx + TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA);
7000    cellUl->schdIdx     = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7001
7002    RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,
7003             TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA)
7004    cellUl->schdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
7005
7006    /* ccpu00127193 filling schdTime for logging and enhancement purpose*/
7007    cellUl->schdTime = timeInfo;
7008
7009    /* msg3 scheduling two subframes after general scheduling */
7010    idx = (cellUl->idx + RG_SCH_CMN_DL_DELTA + RGSCH_RARSP_MSG3_DELTA);
7011    cellUl->msg3SchdIdx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7012
7013    RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,
7014             RG_SCH_CMN_DL_DELTA+ RGSCH_RARSP_MSG3_DELTA)
7015    cellUl->msg3SchdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
7016
7017    idx = (cellUl->idx + TFU_RECPREQ_DLDELTA);
7018
7019    cellUl->rcpReqIdx   = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7020
7021    /* Downlink harq feedback is sometime after data reception / harq failure */
7022    /* Since feedback happens prior to scheduling being called, we add 1 to   */
7023    /* take care of getting the correct subframe for feedback                 */
7024    idx = (cellUl->idx - TFU_CRCIND_ULDELTA + RG_SCH_CMN_UL_NUM_SF);
7025 #ifdef UL_ADPT_DBG     
7026    printf("Finally setting cellUl->hqFdbkIdx[0] = %d TFU_CRCIND_ULDELTA %d RG_SCH_CMN_UL_NUM_SF %d\n",idx,TFU_CRCIND_ULDELTA,RG_SCH_CMN_UL_NUM_SF);
7027 #endif
7028    cellUl->hqFdbkIdx[0]   = (idx % (RG_SCH_CMN_UL_NUM_SF));
7029
7030    idx = ((cellUl->schdIdx) % (RG_SCH_CMN_UL_NUM_SF));
7031
7032    cellUl->reTxIdx[0] = (U8) idx;
7033 #ifdef UL_ADPT_DBG     
7034    printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
7035 #endif
7036    /* RACHO: update cmn sched specific RACH variables,
7037     * mainly the prachMaskIndex */
7038    rgSCHCmnUpdRachParam(cell);
7039
7040    RETVOID;
7041 }
7042 #endif
7043
7044 #ifdef LTE_TDD
7045
7046 /**
7047  * @brief To get uplink subframe index associated with current PHICH
7048  *        transmission.
7049  *
7050  * @details
7051  *
7052  *     Function: rgSCHCmnGetPhichUlSfIdx
7053  *     Purpose:  Gets uplink subframe index associated with current PHICH
7054  *               transmission based on SFN and subframe no
7055  *
7056  *  @param[in]  CmLteTimingInfo  *timeInfo
7057  *  @param[in]  RgSchCellCb              *cell
7058  *  @return U8
7059  *
7060  **/
7061 #ifdef ANSI
7062 PUBLIC U8  rgSCHCmnGetPhichUlSfIdx
7063 (
7064 CmLteTimingInfo *timeInfo,
7065 RgSchCellCb *cell
7066 )
7067 #else
7068 PUBLIC U8  rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
7069 CmLteTimingInfo *timeInfo;
7070 RgSchCellCb        *cell;
7071 #endif
7072 {
7073    RgSchCmnUlCell       *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
7074    RgSchDlSf            *dlsf;
7075    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
7076    U8                   idx;
7077    U16                  numUlSf;
7078    U16                  sfn;
7079    U8                   subframe;
7080
7081    TRC2(rgSCHCmnGetPhichUlSfIdx);
7082
7083    dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
7084
7085    if(dlsf->phichOffInfo.sfnOffset == RGSCH_INVALID_INFO)
7086    {
7087       RETVALUE(RGSCH_INVALID_INFO);
7088    }
7089    subframe = dlsf->phichOffInfo.subframe;
7090
7091    sfn = (RGSCH_MAX_SFN + timeInfo->sfn -
7092                    dlsf->phichOffInfo.sfnOffset) % RGSCH_MAX_SFN;
7093
7094    /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
7095     * wrap case such that idx will be proper*/
7096    numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7097    numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
7098    idx = numUlSf % (cellUl->numUlSubfrms);
7099
7100    RETVALUE(idx);
7101 }
7102
7103 /**
7104  * @brief To get uplink subframe index.
7105  *
7106  * @details
7107  *
7108  *
7109  *     Function: rgSCHCmnGetUlSfIdx
7110  *     Purpose:  Gets uplink subframe index based on SFN and subframe number.
7111  *
7112  *  @param[in]  CmLteTimingInfo  *timeInfo
7113  *  @param[in]  U8               ulDlCfgIdx
7114  *  @return U8
7115  *
7116  **/
7117 #ifdef ANSI
7118 PUBLIC U8  rgSCHCmnGetUlSfIdx
7119 (
7120 CmLteTimingInfo *timeInfo,
7121 RgSchCellCb *cell
7122 )
7123 #else
7124 PUBLIC U8  rgSCHCmnGetUlSfIdx(timeInfo, cell)
7125 CmLteTimingInfo *timeInfo;
7126 RgSchCellCb *cell;
7127 #endif
7128 {
7129    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
7130    U8                ulDlCfgIdx = cell->ulDlCfgIdx;
7131    U8                idx = 0;
7132    U16               numUlSf;
7133
7134    TRC2(rgSCHCmnGetUlSfIdx);
7135
7136    /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
7137     * wrap case such that idx will be proper*/
7138    numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7139    numUlSf = ((numUlSf * timeInfo->sfn) + \
7140          rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->subframe]) - 1;
7141    idx = numUlSf % (cellUl->numUlSubfrms);
7142
7143    RETVALUE(idx);
7144 }
7145
7146 #endif
7147
7148 /**
7149  * @brief To get uplink hq index.
7150  *
7151  * @details
7152  *
7153  *
7154  *     Function: rgSCHCmnGetUlHqProcIdx
7155  *     Purpose:  Gets uplink subframe index based on SFN and subframe number.
7156  *
7157  *  @param[in]  CmLteTimingInfo  *timeInfo
7158  *  @param[in]  U8               ulDlCfgIdx
7159  *  @return U8
7160  *
7161  **/
7162 #ifdef ANSI
7163 PUBLIC U8  rgSCHCmnGetUlHqProcIdx
7164 (
7165 CmLteTimingInfo *timeInfo,
7166 RgSchCellCb *cell
7167 )
7168 #else
7169 PUBLIC U8  rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
7170 CmLteTimingInfo *timeInfo;
7171 RgSchCellCb *cell;
7172 #endif
7173 {
7174    U8            procId;
7175    U32           numUlSf;
7176   
7177 #ifndef LTE_TDD
7178    numUlSf  = (timeInfo->sfn * RGSCH_NUM_SUB_FRAMES_5G + timeInfo->slot);
7179    procId   = numUlSf % RGSCH_NUM_UL_HQ_PROC;
7180 #else
7181    U8            ulDlCfgIdx = cell->ulDlCfgIdx;
7182    /*ccpu00130639 - MOD - To get correct UL HARQ Proc IDs for all UL/DL Configs*/
7183    U8            numUlSfInSfn;
7184    S8            sfnCycle = cell->tddHqSfnCycle;
7185    U8            numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
7186
7187    /* TRACE 5 Changes */
7188    TRC2(rgSCHCmnGetUlHqProcIdx);
7189
7190    /* Calculate the number of UL SF in one SFN */
7191    numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
7192                rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7193
7194    /* Check for the SFN wrap around case */
7195    if(cell->crntTime.sfn == 1023 && timeInfo->sfn == 0)
7196    {
7197       sfnCycle++;
7198    }
7199    else if(cell->crntTime.sfn == 0 && timeInfo->sfn == 1023)
7200    {
7201       /* sfnCycle decremented by 1 */
7202       sfnCycle = (sfnCycle + numUlHarq-1) % numUlHarq;
7203    }
7204    /* Calculate the total number of UL sf */
7205    /*  -1 is done since uplink sf are counted from 0 */
7206    numUlSf = numUlSfInSfn *  (timeInfo->sfn + (sfnCycle*1024)) +
7207                   rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->slot] - 1;
7208
7209    procId = numUlSf % numUlHarq;   
7210 #endif
7211    RETVALUE(procId);
7212 }
7213
7214
7215 /* UL_ALLOC_CHANGES */
7216 /***********************************************************
7217  *
7218  *     Func : rgSCHCmnUlFreeAlloc
7219  *
7220  *     Desc : Free an allocation - invokes UHM and releases
7221  *            alloc for the scheduler
7222  *            Doest need subframe as argument
7223  *
7224  *     Ret  :
7225  *
7226  *     Notes:
7227  *
7228  *     File :
7229  *
7230  **********************************************************/
7231 #ifdef ANSI
7232 PUBLIC Void rgSCHCmnUlFreeAlloc
7233 (
7234 RgSchCellCb     *cell,
7235 RgSchUlAlloc    *alloc
7236 )
7237 #else
7238 PUBLIC Void rgSCHCmnUlFreeAlloc(cell, alloc)
7239 RgSchCellCb     *cell;
7240 RgSchUlAlloc    *alloc;
7241 #endif
7242 {
7243    RgSchUlHqProcCb *hqProc;
7244    TRC2(rgSCHCmnUlFreeAllocation);
7245
7246    if (alloc->forMsg3)
7247    {
7248       /* Fix : Release RNTI upon MSG3 max TX failure for non-HO UEs */
7249       if ((alloc->hqProc->remTx == 0) &&
7250           (alloc->hqProc->rcvdCrcInd == FALSE) &&
7251           (alloc->raCb))
7252       {
7253          RgSchRaCb      *raCb = alloc->raCb;
7254          rgSCHUhmFreeProc(alloc->hqProc, cell);
7255          rgSCHUtlUlAllocRelease(alloc);
7256          rgSCHRamDelRaCb(cell, raCb, TRUE);
7257          RETVOID;
7258       }
7259    }
7260    
7261    hqProc = alloc->hqProc;
7262    rgSCHUtlUlAllocRelease(alloc);
7263    rgSCHUhmFreeProc(hqProc, cell);
7264    RETVOID;
7265 }
7266
7267
7268 /***********************************************************
7269  *
7270  *     Func : rgSCHCmnUlFreeAllocation
7271  *
7272  *     Desc : Free an allocation - invokes UHM and releases
7273  *            alloc for the scheduler
7274  *
7275  *     Ret  :
7276  *
7277  *     Notes:
7278  *
7279  *     File :
7280  *
7281  **********************************************************/
7282 #ifdef ANSI
7283 PUBLIC Void rgSCHCmnUlFreeAllocation
7284 (
7285 RgSchCellCb     *cell,
7286 RgSchUlSf       *sf,
7287 RgSchUlAlloc    *alloc
7288 )
7289 #else
7290 PUBLIC Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
7291 RgSchCellCb     *cell;
7292 RgSchUlSf       *sf;
7293 RgSchUlAlloc    *alloc;
7294 #endif
7295 {
7296    RgSchUlHqProcCb *hqProc;
7297
7298    TRC2(rgSCHCmnUlFreeAllocation);
7299
7300    if (alloc->forMsg3)
7301    {
7302       /* Fix : Release RNTI upon MSG3 max TX failure for non-HO UEs */
7303       if ((alloc->hqProc->remTx == 0) &&
7304           (alloc->hqProc->rcvdCrcInd == FALSE) &&
7305           (alloc->raCb))
7306       {
7307          RgSchRaCb      *raCb = alloc->raCb;
7308          rgSCHUhmFreeProc(alloc->hqProc, cell);
7309          rgSCHUtlUlAllocRls(sf, alloc);
7310          rgSCHRamDelRaCb(cell, raCb, TRUE);
7311          RETVOID;
7312       }
7313    }
7314    
7315    hqProc = alloc->hqProc;
7316    rgSCHUhmFreeProc(hqProc, cell);
7317 #ifdef LTE_L2_MEAS
7318    /* re-setting the PRB count while freeing the allocations */
7319    sf->totPrb = 0;
7320 #endif
7321    rgSCHUtlUlAllocRls(sf, alloc);
7322
7323    RETVOID;
7324 }
7325
7326 /**
7327  * @brief This function implements PDCCH allocation for an UE
7328  *        in the currently running subframe.
7329  *
7330  * @details
7331  *
7332  *     Function: rgSCHCmnPdcchAllocCrntSf
7333  *     Purpose:  This function determines current DL subframe
7334  *               and UE DL CQI to call the actual pdcch allocator
7335  *               function.
7336  *               Note that this function is called only
7337  *               when PDCCH request needs to be made during
7338  *               uplink scheduling.
7339  *
7340  *     Invoked by: Scheduler
7341  *
7342  *  @param[in]  RgSchCellCb  *cell
7343  *  @param[in]  RgSchUeCb    *ue
7344  *  @return  RgSchPdcch *
7345  *         -# NULLP when unsuccessful
7346  **/
7347 #ifdef ANSI
7348 PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
7349 (
7350 RgSchCellCb                *cell,
7351 RgSchUeCb                  *ue
7352 )
7353 #else
7354 PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
7355 RgSchCellCb                *cell;
7356 RgSchUeCb                  *ue;
7357 #endif
7358 {
7359    CmLteTimingInfo      frm = cell->crntTime;
7360    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7361    RgSchDlSf            *sf;
7362    RgSchPdcch           *pdcch = NULLP;
7363
7364    TRC2(rgSCHCmnPdcchAllocCrntSf);
7365    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
7366    sf = rgSCHUtlSubFrmGet(cell, frm);
7367
7368 #ifdef LTE_ADV
7369    if (ue->allocCmnUlPdcch)
7370    {
7371       pdcch = rgSCHCmnCmnPdcchAlloc(cell, sf);
7372       /* Since CRNTI Scrambled */
7373       if(NULLP != pdcch)
7374       {
7375          pdcch->dciNumOfBits = ue->dciSize.cmnSize[TFU_DCI_FORMAT_0];
7376       }
7377    }
7378    else
7379 #endif
7380    {
7381       //pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, y, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_0, FALSE);
7382                 pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_A1, FALSE);
7383    }
7384    RETVALUE(pdcch);
7385 }
7386
7387 /***********************************************************
7388  *
7389  *     Func : rgSCHCmnUlAllocFillNdmrs
7390  *
7391  *     Desc : Determines and fills N_dmrs for a UE uplink
7392  *            allocation.
7393  *
7394  *     Ret  :
7395  *
7396  *     Notes: N_dmrs determination is straightforward, so
7397  *            it is configured per subband
7398  *
7399  *     File :
7400  *
7401  **********************************************************/
7402 #ifdef ANSI
7403 PUBLIC Void rgSCHCmnUlAllocFillNdmrs
7404 (
7405 RgSchCmnUlCell *cellUl,
7406 RgSchUlAlloc   *alloc
7407 )
7408 #else
7409 PUBLIC Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
7410 RgSchCmnUlCell *cellUl;
7411 RgSchUlAlloc   *alloc;
7412 #endif
7413 {
7414    TRC2(rgSCHCmnUlAllocFillNdmrs);
7415    alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
7416    RETVOID;
7417 }
7418
7419 /***********************************************************
7420  *
7421  *     Func : rgSCHCmnUlAllocLnkHqProc
7422  *
7423  *     Desc : Links a new allocation for an UE with the
7424  *            appropriate HARQ process of the UE.
7425  *
7426  *     Ret  :
7427  *
7428  *     Notes:
7429  *
7430  *     File :
7431  *
7432  **********************************************************/
7433 #ifdef ANSI
7434 PUBLIC Void rgSCHCmnUlAllocLnkHqProc
7435 (
7436 RgSchUeCb       *ue,
7437 RgSchUlAlloc    *alloc,
7438 RgSchUlHqProcCb *proc,
7439 Bool            isRetx
7440 )
7441 #else
7442 PUBLIC Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
7443 RgSchUeCb       *ue;
7444 RgSchUlAlloc    *alloc;
7445 RgSchUlHqProcCb *proc;
7446 Bool            isRetx;
7447 #endif
7448 {
7449    TRC2(rgSCHCmnUlAllocLnkHqProc);
7450
7451    if(TRUE == isRetx)
7452    {
7453       rgSCHCmnUlAdapRetx(alloc, proc);
7454    }
7455    else
7456    {
7457 #ifdef LTE_L2_MEAS /* L2_COUNTERS */
7458       alloc->ue = ue;
7459 #endif
7460       rgSCHUhmNewTx(proc, (((RgUeUlHqCb*)proc->hqEnt)->maxHqRetx), alloc);
7461    }
7462    RETVOID;
7463 }
7464
7465 /**
7466  * @brief This function releases a PDCCH in the subframe that is
7467  *        currently being allocated for.
7468  *
7469  * @details
7470  *
7471  *     Function: rgSCHCmnPdcchRlsCrntSf
7472  *     Purpose:  This function determines current DL subframe
7473  *               which is considered for PDCCH allocation,
7474  *               and then calls the actual function that
7475  *               releases a PDCCH in a specific subframe.
7476  *               Note that this function is called only
7477  *               when PDCCH release needs to be made during
7478  *               uplink scheduling.
7479  *
7480  *     Invoked by: Scheduler
7481  *
7482  *  @param[in]  RgSchCellCb  *cell
7483  *  @param[in]  RgSchPdcch   *pdcch
7484  *  @return  Void
7485  **/
7486 #ifdef ANSI
7487 PUBLIC Void rgSCHCmnPdcchRlsCrntSf
7488 (
7489 RgSchCellCb                *cell,
7490 RgSchPdcch                 *pdcch
7491 )
7492 #else
7493 PUBLIC Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
7494 RgSchCellCb                *cell;
7495 RgSchPdcch                 *pdcch;
7496 #endif
7497 {
7498    CmLteTimingInfo      frm = cell->crntTime;
7499    RgSchDlSf               *sf;
7500
7501    TRC2(rgSCHCmnPdcchRlsCrntSf);
7502
7503    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
7504    sf = rgSCHUtlSubFrmGet(cell, frm);
7505    rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, pdcch);
7506    RETVOID;
7507 }
7508 /***********************************************************
7509  *
7510  *     Func : rgSCHCmnUlFillPdcchWithAlloc
7511  *
7512  *     Desc : Fills a PDCCH with format 0 information.
7513  *
7514  *     Ret  :
7515  *
7516  *     Notes:
7517  *
7518  *     File :
7519  *
7520  **********************************************************/
7521 #ifdef ANSI
7522 PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc
7523 (
7524 RgSchPdcch      *pdcch,
7525 RgSchUlAlloc    *alloc,
7526 RgSchUeCb       *ue
7527 )
7528 #else
7529 PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
7530 RgSchPdcch      *pdcch;
7531 RgSchUlAlloc    *alloc;
7532 RgSchUeCb       *ue;
7533 #endif
7534 {
7535
7536    TRC2(rgSCHCmnUlFillPdcchWithAlloc);
7537
7538    pdcch->ue = ue;
7539    pdcch->rnti = alloc->rnti;
7540    //pdcch->dci.dciFormat = TFU_DCI_FORMAT_A2;
7541    pdcch->dci.dciFormat = alloc->grnt.dciFrmt;
7542
7543    //Currently hardcoding values here.
7544    //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
7545    switch(pdcch->dci.dciFormat)
7546    {
7547       case TFU_DCI_FORMAT_A1:
7548                 {
7549                         pdcch->dci.u.formatA1Info.formatType = 0;
7550          pdcch->dci.u.formatA1Info.xPUSCHRange = alloc->grnt.xPUSCHRange;
7551          pdcch->dci.u.formatA1Info.xPUSCH_TxTiming = 0;
7552          pdcch->dci.u.formatA1Info.RBAssign = alloc->grnt.rbAssign;
7553          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.hqProcId = alloc->grnt.hqProcId;
7554          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.mcs = alloc->grnt.iMcsCrnt;
7555          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.ndi = alloc->hqProc->ndi;
7556          pdcch->dci.u.formatA1Info.CSI_BSI_BRI_Req = 0;
7557          pdcch->dci.u.formatA1Info.CSIRS_BRRS_TxTiming = 0;
7558          pdcch->dci.u.formatA1Info.CSIRS_BRRS_SymbIdx = 0;
7559          pdcch->dci.u.formatA1Info.CSIRS_BRRS_ProcInd = 0;
7560          pdcch->dci.u.formatA1Info.numBSI_Reports = 0;
7561          pdcch->dci.u.formatA1Info.uciOnxPUSCH = alloc->grnt.uciOnxPUSCH;
7562          pdcch->dci.u.formatA1Info.beamSwitch  = 0;
7563          pdcch->dci.u.formatA1Info.SRS_Config = 0;
7564          pdcch->dci.u.formatA1Info.SRS_Symbol = 0;
7565          pdcch->dci.u.formatA1Info.REMapIdx_DMRS_PCRS_numLayers = 0;
7566          pdcch->dci.u.formatA1Info.SCID = alloc->grnt.SCID;
7567          pdcch->dci.u.formatA1Info.PMI = alloc->grnt.PMI;
7568          pdcch->dci.u.formatA1Info.UL_PCRS = 0;
7569          pdcch->dci.u.formatA1Info.tpcCmd = alloc->grnt.tpc;
7570                         break;
7571       }
7572                 case TFU_DCI_FORMAT_A2:
7573                 {
7574                         pdcch->dci.u.formatA2Info.formatType = 1;
7575          pdcch->dci.u.formatA2Info.xPUSCHRange = alloc->grnt.xPUSCHRange;
7576          pdcch->dci.u.formatA2Info.xPUSCH_TxTiming = 0;
7577          pdcch->dci.u.formatA2Info.RBAssign = alloc->grnt.rbAssign;
7578          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.hqProcId = alloc->grnt.hqProcId;
7579          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.mcs = alloc->grnt.iMcsCrnt;
7580          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.ndi = alloc->hqProc->ndi;
7581          pdcch->dci.u.formatA2Info.CSI_BSI_BRI_Req = 0;
7582          pdcch->dci.u.formatA2Info.CSIRS_BRRS_TxTiming = 0;
7583          pdcch->dci.u.formatA2Info.CSIRS_BRRS_SymbIdx = 0;
7584          pdcch->dci.u.formatA2Info.CSIRS_BRRS_ProcInd = 0;
7585          pdcch->dci.u.formatA2Info.numBSI_Reports = 0;
7586          pdcch->dci.u.formatA2Info.uciOnxPUSCH = alloc->grnt.uciOnxPUSCH;
7587          pdcch->dci.u.formatA2Info.beamSwitch  = 0;
7588          pdcch->dci.u.formatA2Info.SRS_Config = 0;
7589          pdcch->dci.u.formatA2Info.SRS_Symbol = 0;
7590          pdcch->dci.u.formatA2Info.REMapIdx_DMRS_PCRS_numLayers = 0;
7591          pdcch->dci.u.formatA2Info.SCID = alloc->grnt.SCID;
7592          pdcch->dci.u.formatA2Info.PMI = alloc->grnt.PMI;
7593          pdcch->dci.u.formatA2Info.UL_PCRS = 0;
7594          pdcch->dci.u.formatA2Info.tpcCmd = alloc->grnt.tpc;
7595                         break;
7596                 }
7597       default:
7598          RLOG1(L_ERROR," 5GTF_ERROR UL Allocator's icorrect "
7599                "dciForamt Fill RNTI:%d",alloc->rnti);
7600          break;
7601    }    
7602    
7603
7604    RETVOID;
7605 }
7606
7607 /***********************************************************
7608  *
7609  *     Func : rgSCHCmnUlAllocFillTpc
7610  *
7611  *     Desc : Determines and fills TPC for an UE allocation.
7612  *
7613  *     Ret  :
7614  *
7615  *     Notes:
7616  *
7617  *     File :
7618  *
7619  **********************************************************/
7620 #ifdef ANSI
7621 PUBLIC Void rgSCHCmnUlAllocFillTpc
7622 (
7623 RgSchCellCb  *cell,
7624 RgSchUeCb    *ue,
7625 RgSchUlAlloc *alloc
7626 )
7627 #else
7628 PUBLIC Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
7629 RgSchCellCb  *cell;
7630 RgSchUeCb    *ue;
7631 RgSchUlAlloc *alloc;
7632 #endif
7633 {
7634    TRC2(rgSCHCmnUlAllocFillTpc);
7635    alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
7636    RETVOID;
7637 }
7638
7639
7640 /***********************************************************
7641  *
7642  *     Func : rgSCHCmnAddUeToRefreshQ
7643  *
7644  *     Desc : Adds a UE to refresh queue, so that the UE is
7645  *            periodically triggered to refresh it's GBR and
7646  *            AMBR values.
7647  *
7648  *     Ret  :
7649  *
7650  *     Notes:
7651  *
7652  *     File :
7653  *
7654  **********************************************************/
7655 #ifdef ANSI
7656 PRIVATE Void rgSCHCmnAddUeToRefreshQ
7657 (
7658 RgSchCellCb     *cell,
7659 RgSchUeCb       *ue,
7660 U32             wait
7661 )
7662 #else
7663 PRIVATE Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
7664 RgSchCellCb     *cell;
7665 RgSchUeCb       *ue;
7666 U32             wait;
7667 #endif
7668 {
7669    RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
7670    CmTmrArg       arg;
7671    RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
7672
7673    TRC2(rgSCHCmnAddUeToRefreshQ);
7674    UNUSED(cell);
7675
7676    cmMemset((U8 *)&arg, 0, sizeof(arg));
7677    arg.tqCp   = &sched->tmrTqCp;
7678    arg.tq     = sched->tmrTq;
7679    arg.timers = &ueSchd->tmr;
7680    arg.cb     = (PTR)ue;
7681    arg.tNum   = 0;
7682    arg.max    = 1;
7683    arg.evnt   = RG_SCH_CMN_EVNT_UE_REFRESH;
7684    arg.wait   = wait;
7685    cmPlcCbTq(&arg);
7686    RETVOID;
7687 }
7688
7689 /**
7690  * @brief Perform UE reset procedure.
7691  *
7692  * @details
7693  *
7694  *     Function : rgSCHCmnUlUeReset
7695  *
7696  *     This functions performs BSR resetting and
7697  *     triggers UL specific scheduler
7698  *     to Perform UE reset procedure.
7699  *
7700  *  @param[in]  RgSchCellCb  *cell
7701  *  @param[in]  RgSchUeCb    *ue
7702  *  @return  Void
7703  **/
7704 #ifdef ANSI
7705 PRIVATE Void rgSCHCmnUlUeReset
7706 (
7707 RgSchCellCb  *cell,
7708 RgSchUeCb    *ue
7709 )
7710 #else
7711 PRIVATE Void rgSCHCmnUlUeReset(cell, ue)
7712 RgSchCellCb  *cell;
7713 RgSchUeCb    *ue;
7714 #endif
7715 {
7716    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7717    RgSchCmnUlUe         *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
7718    U8                   lcgCnt=0;
7719    RgSchCmnLcg          *lcgCmn;
7720    CmLList              *node;
7721    RgSchCmnAllocRecord  *allRcd;
7722    TRC2(rgSCHCmnUlUeReset);
7723
7724    ue->ul.minReqBytes = 0;
7725    ue->ul.totalBsr = 0;
7726    ue->ul.effBsr = 0;
7727    ue->ul.nonGbrLcgBs = 0;
7728    ue->ul.effAmbr = ue->ul.cfgdAmbr;
7729
7730    node = ueUl->ulAllocLst.first;
7731    while (node)
7732    {
7733       allRcd = (RgSchCmnAllocRecord *)node->node;
7734       allRcd->alloc = 0;
7735       node = node->next;
7736    }
7737    for(lcgCnt = 0; lcgCnt < RGSCH_MAX_LCG_PER_UE; lcgCnt++)
7738    {
7739       lcgCmn = RG_SCH_CMN_GET_UL_LCG(&ue->ul.lcgArr[lcgCnt]);
7740       lcgCmn->bs = 0;
7741       lcgCmn->reportedBs = 0;
7742       lcgCmn->effGbr = lcgCmn->cfgdGbr;
7743       lcgCmn->effDeltaMbr = lcgCmn->deltaMbr;
7744    }
7745    rgSCHCmnUlUeDelAllocs(cell, ue);
7746
7747    ue->isSrGrant = FALSE;
7748
7749    cellSchd->apisUl->rgSCHUlUeReset(cell, ue);
7750
7751    /* Stack Crash problem for TRACE5 changes. Added the return below */
7752    RETVOID;
7753
7754 }
7755
7756 /**
7757  * @brief RESET UL CQI and DL CQI&RI to conservative values
7758     * for a reestablishing UE.
7759  *
7760  * @details
7761  *
7762  *     Function : rgSCHCmnResetRiCqi 
7763  *     
7764  *     RESET UL CQI and DL CQI&RI to conservative values
7765  *     for a reestablishing UE
7766  *
7767  *  @param[in]  RgSchCellCb  *cell
7768  *  @param[in]  RgSchUeCb    *ue
7769  *  @return  Void
7770  **/
7771 #ifdef ANSI
7772 PRIVATE Void rgSCHCmnResetRiCqi 
7773 (
7774 RgSchCellCb  *cell,
7775 RgSchUeCb    *ue
7776 )
7777 #else
7778 PRIVATE Void rgSCHCmnResetRiCqi(cell, ue)
7779 RgSchCellCb  *cell;
7780 RgSchUeCb    *ue;
7781 #endif
7782 {
7783    RgSchCmnCell  *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7784    RgSchCmnUe    *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
7785    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7786    RgSchCmnUlUe  *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
7787
7788    TRC2(rgSCHCmnResetRiCqi);
7789
7790    rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, 
7791          cell->isCpUlExtend);
7792
7793    ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
7794    ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
7795    ueDl->mimoInfo.ri = 1;
7796    if ((ue->mimoInfo.txMode == RGR_UE_TM_4) ||
7797           (ue->mimoInfo.txMode == RGR_UE_TM_6))
7798    {
7799       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
7800    }
7801    if (ue->mimoInfo.txMode == RGR_UE_TM_3)
7802    {
7803       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
7804    }
7805 #ifdef EMTC_ENABLE   
7806    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, ue->isEmtcUe);
7807 #else
7808    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, FALSE);
7809 #endif      
7810
7811 #ifdef TFU_UPGRADE
7812    /* Request for an early Aper CQI in case of reest */
7813    RgSchUeACqiCb  *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell); 
7814    if(acqiCb && acqiCb->aCqiCfg.pres)
7815    {
7816       acqiCb->aCqiTrigWt = 0;
7817    }
7818 #endif   
7819
7820    RETVOID;
7821 }
7822
7823 /**
7824  * @brief Perform UE reset procedure.
7825  *
7826  * @details
7827  *
7828  *     Function : rgSCHCmnDlUeReset
7829  *
7830  *     This functions performs BO resetting and
7831  *     triggers DL specific scheduler
7832  *     to Perform UE reset procedure.
7833  *
7834  *  @param[in]  RgSchCellCb  *cell
7835  *  @param[in]  RgSchUeCb    *ue
7836  *  @return  Void
7837  **/
7838 #ifdef ANSI
7839 PRIVATE Void rgSCHCmnDlUeReset
7840 (
7841 RgSchCellCb  *cell,
7842 RgSchUeCb    *ue
7843 )
7844 #else
7845 PRIVATE Void rgSCHCmnDlUeReset(cell, ue)
7846 RgSchCellCb  *cell;
7847 RgSchUeCb    *ue;
7848 #endif
7849 {
7850    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7851    RgSchCmnDlCell       *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
7852    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7853
7854    TRC2(rgSCHCmnDlUeReset);
7855
7856    if (ueDl->rachInfo.poLnk.node != NULLP)
7857    {
7858       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
7859    }
7860
7861    /* Fix: syed Remove from TA List if this UE is there.
7862     * If TA Timer is running. Stop it */
7863    if (ue->dlTaLnk.node)
7864    {
7865       cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
7866       ue->dlTaLnk.node = (PTR)NULLP;
7867    }
7868    else if (ue->taTmr.tmrEvnt != TMR_NONE)
7869    {
7870       rgSCHTmrStopTmr(cell, ue->taTmr.tmrEvnt, ue);
7871    }
7872
7873    cellSchd->apisDl->rgSCHDlUeReset(cell, ue);
7874 #ifdef LTE_ADV
7875    if (ue->numSCells)
7876    {
7877       rgSCHSCellDlUeReset(cell,ue);
7878    }
7879 #endif
7880 }
7881
7882 /**
7883  * @brief Perform UE reset procedure.
7884  *
7885  * @details
7886  *
7887  *     Function : rgSCHCmnUeReset
7888  *
7889  *     This functions triggers specific scheduler
7890  *     to Perform UE reset procedure.
7891  *
7892  *  @param[in]  RgSchCellCb  *cell
7893  *  @param[in]  RgSchUeCb    *ue
7894  *  @return  S16
7895  *      -# ROK
7896  *      -# RFAILED
7897  **/
7898 #ifdef ANSI
7899 PUBLIC Void rgSCHCmnUeReset
7900 (
7901 RgSchCellCb  *cell,
7902 RgSchUeCb    *ue
7903 )
7904 #else
7905 PUBLIC Void rgSCHCmnUeReset(cell, ue)
7906 RgSchCellCb  *cell;
7907 RgSchUeCb    *ue;
7908 #endif
7909 {
7910    U8 idx;
7911    Pst               pst;
7912    RgInfResetHqEnt   hqEntRstInfo;
7913
7914    TRC2(rgSCHCmnUeReset);
7915    /* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
7916    rgSCHCmnDelRachInfo(cell, ue);
7917
7918    rgSCHPwrUeReset(cell, ue);
7919
7920    rgSCHCmnUlUeReset(cell, ue);
7921    rgSCHCmnDlUeReset(cell, ue);
7922    
7923 #ifdef LTE_ADV
7924    /* Making allocCmnUlPdcch TRUE to allocate DCI0/1A from Common search space.
7925       As because multiple cells are added hence 2 bits CqiReq is there 
7926       This flag will be set to FALSE once we will get Scell READY */
7927    ue->allocCmnUlPdcch = TRUE;
7928 #endif
7929
7930    /* Fix : syed RESET UL CQI and DL CQI&RI to conservative values
7931     * for a reestablishing UE */
7932    /*Reset Cqi Config for all the configured cells*/
7933    for (idx = 0;idx < CM_LTE_MAX_CELLS; idx++)
7934    {
7935       if (ue->cellInfo[idx] != NULLP) 
7936       {   
7937          rgSCHCmnResetRiCqi(ue->cellInfo[idx]->cell, ue);
7938       }
7939    }
7940    /*After Reset Trigger APCQI for Pcell*/
7941    RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
7942    if(pCellInfo->acqiCb.aCqiCfg.pres)
7943    {
7944       ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
7945    }
7946
7947 /* sending HqEnt reset to MAC */
7948    hqEntRstInfo.cellId = cell->cellId;
7949    hqEntRstInfo.crnti  = ue->ueId;
7950
7951    rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
7952    RgSchMacRstHqEnt(&pst,&hqEntRstInfo);
7953
7954    RETVOID;
7955 }
7956
7957 /**
7958  * @brief UE out of MeasGap or AckNackReptn.
7959  *
7960  * @details
7961  *
7962  *     Function : rgSCHCmnActvtUlUe
7963  *
7964  *     This functions triggers specific scheduler
7965  *     to start considering it for scheduling.
7966  *
7967  *  @param[in]  RgSchCellCb  *cell
7968  *  @param[in]  RgSchUeCb    *ue
7969  *  @return  S16
7970  *      -# ROK
7971  *      -# RFAILED
7972  **/
7973 #ifdef ANSI
7974 PUBLIC Void rgSCHCmnActvtUlUe
7975 (
7976 RgSchCellCb  *cell,
7977 RgSchUeCb    *ue
7978 )
7979 #else
7980 PUBLIC Void rgSCHCmnActvtUlUe(cell, ue)
7981 RgSchCellCb  *cell;
7982 RgSchUeCb    *ue;
7983 #endif
7984 {
7985    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7986    TRC2(rgSCHCmnActvtUlUe);
7987
7988    /* : take care of this in UL retransmission */
7989    cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
7990    RETVOID;
7991 }
7992
7993 /**
7994  * @brief UE out of MeasGap or AckNackReptn.
7995  *
7996  * @details
7997  *
7998  *     Function : rgSCHCmnActvtDlUe
7999  *
8000  *     This functions triggers specific scheduler
8001  *     to start considering it for scheduling.
8002  *
8003  *  @param[in]  RgSchCellCb  *cell
8004  *  @param[in]  RgSchUeCb    *ue
8005  *  @return  S16
8006  *      -# ROK
8007  *      -# RFAILED
8008  **/
8009 #ifdef ANSI
8010 PUBLIC Void rgSCHCmnActvtDlUe
8011 (
8012 RgSchCellCb  *cell,
8013 RgSchUeCb    *ue
8014 )
8015 #else
8016 PUBLIC Void rgSCHCmnActvtDlUe(cell, ue)
8017 RgSchCellCb  *cell;
8018 RgSchUeCb    *ue;
8019 #endif
8020 {
8021    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8022    TRC2(rgSCHCmnActvtDlUe);
8023
8024    cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
8025    RETVOID;
8026 }
8027
8028 /**
8029  * @brief This API is invoked to indicate scheduler of a CRC indication.
8030  *
8031  * @details
8032  *
8033  *     Function : rgSCHCmnHdlUlTransInd
8034  *      This API is invoked to indicate scheduler of a CRC indication.
8035  *
8036  *  @param[in]  RgSchCellCb     *cell
8037  *  @param[in]  RgSchUeCb       *ue
8038  *  @param[in]  CmLteTimingInfo timingInfo
8039  *
8040  *  @return Void
8041  **/
8042 #ifdef ANSI
8043 PUBLIC Void rgSCHCmnHdlUlTransInd
8044 (
8045 RgSchCellCb     *cell,
8046 RgSchUeCb       *ue,
8047 CmLteTimingInfo timingInfo
8048 )
8049 #else
8050 PUBLIC Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
8051 RgSchCellCb     *cell;
8052 RgSchUeCb       *ue;
8053 CmLteTimingInfo timingInfo;
8054 #endif
8055 {
8056    TRC2(rgSCHCmnHdlUlTransInd);
8057
8058    /* Update the latest UL dat/sig transmission time */
8059    RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
8060    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
8061    {
8062       /* Some UL Transmission from this UE.
8063        * Activate this UE if it was inactive */
8064       RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
8065       RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
8066    }
8067    RETVOID;
8068 }
8069
8070 #ifdef TFU_UPGRADE
8071
8072 /**
8073  * @brief Compute the minimum Rank based on Codebook subset
8074  *        restriction configuration for 4 Tx Ports and Tx Mode 4.
8075  *
8076  * @details
8077  *
8078  *     Function : rgSCHCmnComp4TxMode4
8079  *
8080  *     Depending on BitMap set at CBSR during Configuration
8081  *      - return the least possible Rank
8082  *
8083  *
8084  *  @param[in]  U32 *pmiBitMap
8085  *  @return  RgSchCmnRank
8086  **/
8087 #ifdef ANSI
8088 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4
8089 (
8090  U32    *pmiBitMap
8091  )
8092 #else
8093 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
8094    U32  *pmiBitMap;
8095 #endif
8096 {
8097    U32 bitMap0, bitMap1;
8098    TRC2(rgSCHCmnComp4TxMode4);
8099    bitMap0 = pmiBitMap[0];
8100    bitMap1 = pmiBitMap[1];
8101    if((bitMap1) & 0xFFFF)
8102    {
8103       RETVALUE (RG_SCH_CMN_RANK_1);
8104    }
8105    else if((bitMap1>>16) & 0xFFFF)
8106    {
8107       RETVALUE (RG_SCH_CMN_RANK_2);
8108    }
8109    else if((bitMap0) & 0xFFFF)
8110    {
8111       RETVALUE (RG_SCH_CMN_RANK_3);
8112    }
8113    else if((bitMap0>>16) & 0xFFFF)
8114    {
8115       RETVALUE (RG_SCH_CMN_RANK_4);
8116    }
8117    else
8118    {
8119       RETVALUE (RG_SCH_CMN_RANK_1);
8120    }
8121 }
8122
8123
8124 /**
8125  * @brief Compute the minimum Rank based on Codebook subset
8126  *        restriction configuration for 2 Tx Ports and Tx Mode 4.
8127  *
8128  * @details
8129  *
8130  *     Function : rgSCHCmnComp2TxMode4
8131  *
8132  *     Depending on BitMap set at CBSR during Configuration
8133  *      - return the least possible Rank
8134  *
8135  *
8136  *  @param[in]  U32 *pmiBitMap
8137  *  @return  RgSchCmnRank
8138  **/
8139 #ifdef ANSI
8140 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4
8141 (
8142  U32    *pmiBitMap
8143  )
8144 #else
8145 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
8146    U32  *pmiBitMap;
8147 #endif
8148 {
8149    U32 bitMap0;
8150    TRC2(rgSCHCmnComp2TxMode4);
8151    bitMap0 = pmiBitMap[0];
8152    if((bitMap0>>26)& 0x0F)
8153    {
8154       RETVALUE (RG_SCH_CMN_RANK_1);
8155    }
8156    else if((bitMap0>>30) & 3)
8157    {
8158       RETVALUE (RG_SCH_CMN_RANK_2);
8159    }
8160    else
8161    {
8162       RETVALUE (RG_SCH_CMN_RANK_1);
8163    }
8164 }
8165
8166 /**
8167  * @brief Compute the minimum Rank based on Codebook subset
8168  *        restriction configuration for 4 Tx Ports and Tx Mode 3.
8169  *
8170  * @details
8171  *
8172  *     Function : rgSCHCmnComp4TxMode3
8173  *
8174  *     Depending on BitMap set at CBSR during Configuration
8175  *      - return the least possible Rank
8176  *
8177  *
8178  *  @param[in]  U32 *pmiBitMap
8179  *  @return  RgSchCmnRank
8180  **/
8181 #ifdef ANSI
8182 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3
8183 (
8184  U32    *pmiBitMap
8185  )
8186 #else
8187 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
8188    U32  *pmiBitMap;
8189 #endif
8190 {
8191    U32 bitMap0;
8192    TRC2(rgSCHCmnComp4TxMode3);
8193    bitMap0 = pmiBitMap[0];
8194    if((bitMap0>>28)& 1)
8195    {
8196       RETVALUE (RG_SCH_CMN_RANK_1);
8197    }
8198    else if((bitMap0>>29) &1)
8199    {
8200       RETVALUE (RG_SCH_CMN_RANK_2);
8201    }
8202    else if((bitMap0>>30) &1)
8203    {
8204       RETVALUE (RG_SCH_CMN_RANK_3);
8205    }
8206    else if((bitMap0>>31) &1)
8207    {
8208       RETVALUE (RG_SCH_CMN_RANK_4);
8209    }
8210    else
8211    {
8212       RETVALUE (RG_SCH_CMN_RANK_1);
8213    }
8214 }
8215
8216 /**
8217  * @brief Compute the minimum Rank based on Codebook subset
8218  *        restriction configuration for 2 Tx Ports and Tx Mode 3.
8219  *
8220  * @details
8221  *
8222  *     Function : rgSCHCmnComp2TxMode3
8223  *
8224  *     Depending on BitMap set at CBSR during Configuration
8225  *      - return the least possible Rank
8226  *
8227  *
8228  *  @param[in]  U32 *pmiBitMap
8229  *  @return  RgSchCmnRank
8230  **/
8231 #ifdef ANSI
8232 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3
8233 (
8234  U32 *pmiBitMap
8235  )
8236 #else
8237 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
8238    U32 *pmiBitMap;
8239 #endif
8240 {
8241    U32 bitMap0;
8242    TRC2(rgSCHCmnComp2TxMode3);
8243    bitMap0 = pmiBitMap[0];
8244    if((bitMap0>>30)& 1)
8245    {
8246       RETVALUE (RG_SCH_CMN_RANK_1);
8247    }
8248    else if((bitMap0>>31) &1)
8249    {
8250       RETVALUE (RG_SCH_CMN_RANK_2);
8251    }
8252    else
8253    {
8254       RETVALUE (RG_SCH_CMN_RANK_1);
8255    }
8256 }
8257
8258 /**
8259  * @brief Compute the minimum Rank based on Codebook subset
8260  *        restriction configuration.
8261  *
8262  * @details
8263  *
8264  *     Function : rgSCHCmnComputeRank
8265  *
8266  *     Depending on Num Tx Ports and Transmission mode
8267  *      - return the least possible Rank
8268  *
8269  *
8270  *  @param[in]  RgrTxMode txMode
8271  *  @param[in]  U32 *pmiBitMap
8272  *  @param[in]  U8 numTxPorts
8273  *  @return  RgSchCmnRank
8274  **/
8275 #ifdef ANSI
8276 PRIVATE RgSchCmnRank rgSCHCmnComputeRank
8277 (
8278  RgrTxMode    txMode,
8279  U32          *pmiBitMap,
8280  U8           numTxPorts
8281  )
8282 #else
8283 PRIVATE RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
8284    RgrTxMode    txMode;
8285    U32          *pmiBitMap;
8286    U8           numTxPorts;
8287 #endif
8288 {
8289    TRC2(rgSCHCmnComputeRank);
8290
8291    if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
8292    {
8293       RETVALUE (rgSCHCmnComp2TxMode3(pmiBitMap));
8294    }
8295    else if (numTxPorts ==4 && txMode == RGR_UE_TM_3)
8296    {
8297       RETVALUE (rgSCHCmnComp4TxMode3(pmiBitMap));
8298    }
8299    else if (numTxPorts ==2 && txMode == RGR_UE_TM_4)
8300    {
8301       RETVALUE (rgSCHCmnComp2TxMode4(pmiBitMap));
8302    }
8303    else if (numTxPorts ==4 && txMode == RGR_UE_TM_4)
8304    {
8305       RETVALUE (rgSCHCmnComp4TxMode4(pmiBitMap));
8306    }
8307    else
8308    {
8309       RETVALUE (RG_SCH_CMN_RANK_1);
8310    }
8311 }
8312
8313 #endif
8314
8315 /**
8316  * @brief Harq Entity Deinitialization for CMN SCH.
8317  *
8318  * @details
8319  *
8320  *     Function : rgSCHCmnDlDeInitHqEnt 
8321  *
8322  *     Harq Entity Deinitialization for CMN SCH 
8323  *
8324  *  @param[in]  RgSchCellCb  *cell
8325  *  @param[in]  RgSchDlHqEnt *hqE 
8326  *  @return  VOID
8327  **/
8328 /*KWORK_FIX:Changed function return type to void */
8329 #ifdef ANSI
8330 PUBLIC Void rgSCHCmnDlDeInitHqEnt 
8331 (
8332 RgSchCellCb  *cell,
8333 RgSchDlHqEnt *hqE
8334 )
8335 #else
8336 PUBLIC Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
8337 RgSchCellCb  *cell;
8338 RgSchDlHqEnt *hqE;
8339 #endif
8340 {
8341    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8342    RgSchDlHqProcCb      *hqP;
8343    U8                   cnt;
8344    S16                  ret;
8345
8346    TRC2(rgSCHCmnDlDeInitHqEnt);
8347
8348    ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
8349    /* Free only If the Harq proc are created*/
8350    if(RFAILED == ret)
8351    {
8352    }
8353
8354    for(cnt = 0; cnt < hqE->numHqPrcs; cnt++)
8355    {
8356       hqP = &hqE->procs[cnt];
8357       if ((RG_SCH_CMN_GET_DL_HQP(hqP)))
8358       {
8359          rgSCHUtlFreeSBuf(cell->instIdx,
8360               (Data**)(&(hqP->sch)), (sizeof(RgSchCmnDlHqProc)));
8361       }
8362    }
8363 #ifdef LTE_ADV
8364    rgSCHLaaDeInitDlHqProcCb (cell, hqE);
8365 #endif
8366
8367    RETVOID;
8368 }
8369
8370 /**
8371  * @brief Harq Entity initialization for CMN SCH.
8372  *
8373  * @details
8374  *
8375  *     Function : rgSCHCmnDlInitHqEnt 
8376  *
8377  *     Harq Entity initialization for CMN SCH 
8378  *
8379  *  @param[in]  RgSchCellCb  *cell
8380  *  @param[in]  RgSchUeCb    *ue
8381  *  @return  S16
8382  *      -# ROK
8383  *      -# RFAILED
8384  **/
8385 #ifdef ANSI
8386 PUBLIC S16 rgSCHCmnDlInitHqEnt 
8387 (
8388 RgSchCellCb  *cell,
8389 RgSchDlHqEnt  *hqEnt
8390 )
8391 #else
8392 PUBLIC S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
8393 RgSchCellCb  *cell;
8394 RgSchDlHqEnt  *hqEnt;
8395 #endif
8396
8397 {
8398    RgSchDlHqProcCb      *hqP;
8399    U8                   cnt;
8400
8401    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8402    TRC2(rgSCHCmnDlInitHqEnt);
8403
8404    for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
8405    {
8406       hqP = &hqEnt->procs[cnt];
8407       if (rgSCHUtlAllocSBuf(cell->instIdx,
8408                (Data**)&(hqP->sch), (sizeof(RgSchCmnDlHqProc))) != ROK)
8409       {
8410          RETVALUE(RFAILED);
8411       }
8412    }
8413 #ifdef EMTC_ENABLE
8414    if((cell->emtcEnable) &&(hqEnt->ue->isEmtcUe))
8415    {
8416       if(ROK != cellSchd->apisEmtcDl->rgSCHDlUeHqEntInit(cell, hqEnt))
8417       {
8418          RETVALUE(RFAILED);
8419       }
8420
8421    }
8422    else
8423 #endif
8424    {
8425       if(ROK != cellSchd->apisDl->rgSCHDlUeHqEntInit(cell, hqEnt))
8426       {
8427          RETVALUE(RFAILED);
8428       }
8429    }
8430
8431    RETVALUE(ROK);
8432 }  /* rgSCHCmnDlInitHqEnt */
8433
8434 /**
8435  * @brief This function computes distribution of refresh period
8436  *
8437  * @details
8438  *
8439  *     Function: rgSCHCmnGetRefreshDist 
8440  *     Purpose: This function computes distribution of refresh period
8441  *              This is required to align set of UEs refresh
8442  *              around the different consecutive subframe.
8443  *               
8444  *     Invoked by: rgSCHCmnGetRefreshPerDist
8445  *
8446  *  @param[in]  RgSchCellCb        *cell
8447  *  @param[in]  RgSchUeCb          *ue
8448  *  @return  Void
8449  *
8450  **/
8451 #ifdef ANSI
8452 PRIVATE U8 rgSCHCmnGetRefreshDist 
8453 (
8454 RgSchCellCb        *cell,
8455 RgSchUeCb          *ue
8456 )
8457 #else
8458 PRIVATE U8 rgSCHCmnGetRefreshDist(cell, ue)
8459 RgSchCellCb        *cell;
8460 RgSchUeCb          *ue;
8461 #endif
8462 {
8463    U8   refOffst;
8464 #ifdef DEBUGP
8465    Inst inst = cell->instIdx;
8466 #endif
8467    TRC2(rgSCHCmnGetRefreshDist);
8468
8469    for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
8470    {
8471       if(cell->refreshUeCnt[refOffst] < RGSCH_MAX_REFRESH_GRPSZ)
8472       {
8473          cell->refreshUeCnt[refOffst]++;
8474          ue->refreshOffset = refOffst;
8475          /* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst,  cell->refreshUeCnt[refOffst]); */
8476          RETVALUE(refOffst);
8477       }
8478    }
8479   
8480    RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Allocation of refresh distribution failed\n"));
8481    /* We should not enter here  normally, but incase of failure, allocating from  last offset*/
8482    cell->refreshUeCnt[refOffst-1]++;
8483    ue->refreshOffset = refOffst-1;
8484
8485    RETVALUE(refOffst-1);
8486 }
8487 /**
8488  * @brief This function computes initial Refresh Wait Period.
8489  *
8490  * @details
8491  *
8492  *     Function: rgSCHCmnGetRefreshPer 
8493  *     Purpose: This function computes initial Refresh Wait Period.
8494  *              This is required to align multiple UEs refresh
8495  *              around the same time.
8496  *               
8497  *     Invoked by: rgSCHCmnGetRefreshPer 
8498  *
8499  *  @param[in]  RgSchCellCb        *cell
8500  *  @param[in]  RgSchUeCb          *ue
8501  *  @param[in]  U32                *waitPer 
8502  *  @return  Void
8503  *
8504  **/
8505 #ifdef ANSI
8506 PRIVATE Void rgSCHCmnGetRefreshPer 
8507 (
8508 RgSchCellCb        *cell,
8509 RgSchUeCb          *ue,
8510 U32                *waitPer
8511 )
8512 #else
8513 PRIVATE Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
8514 RgSchCellCb        *cell;
8515 RgSchUeCb          *ue;
8516 U32                *waitPer;
8517 #endif
8518 {
8519    U32       refreshPer;           
8520    U32       crntSubFrm;
8521
8522    TRC2(rgSCHCmnGetRefreshPer);     
8523
8524    refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
8525    crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot;
8526    /* Fix: syed align multiple UEs to refresh at same time */
8527    *waitPer = refreshPer - (crntSubFrm % refreshPer);
8528    *waitPer = RGSCH_CEIL(*waitPer, RG_SCH_CMN_REFRESH_TIMERES);
8529    *waitPer = *waitPer + rgSCHCmnGetRefreshDist(cell, ue);
8530
8531    RETVOID;
8532 }
8533
8534
8535 #ifdef LTE_ADV
8536 /**
8537  * @brief UE initialisation for scheduler.
8538  *
8539  * @details
8540  *
8541  *     Function : rgSCHCmnRgrSCellUeCfg
8542  *
8543  *     This functions intialises UE specific scheduler 
8544  *     information for SCELL
8545  *     0. Perform basic validations
8546  *     1. Allocate common sched UE cntrl blk
8547  *     2. Perform DL cfg (allocate Hq Procs Cmn sched cntrl blks)
8548  *     3. Perform UL cfg
8549  *     4. Perform DLFS cfg
8550  *
8551  *  @param[in]  RgSchCellCb  *cell
8552  *  @param[in]  RgSchUeCb    *ue
8553  *  @param[out] RgSchErrInfo *err
8554  *  @return  S16
8555  *      -# ROK
8556  *      -# RFAILED
8557  **/
8558 #ifdef ANSI
8559 PUBLIC S16 rgSCHCmnRgrSCellUeCfg
8560 (
8561 RgSchCellCb  *sCell,
8562 RgSchUeCb    *ue,
8563 RgrUeSecCellCfg  *sCellInfoCfg,
8564 RgSchErrInfo *err
8565 )
8566 #else
8567 PUBLIC S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
8568 RgSchCellCb  *sCell;
8569 RgSchUeCb    *ue;
8570 RgrUeSecCellCfg  *sCellInfoCfg;
8571 RgSchErrInfo *err;
8572 #endif
8573 {
8574    U8 i;
8575    S16                  ret;
8576    U8                   cnt;
8577    RgSchCmnAllocRecord  *allRcd;
8578    RgSchDlRbAlloc       *allocInfo;
8579    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
8580    RgSchCmnUlUe         *ueUl;
8581    RgSchCmnUlUe         *ueUlPcell;
8582    RgSchCmnUe           *pCellUeSchCmn;
8583    RgSchCmnUe           *ueSchCmn;
8584    RgSchCmnDlUe         *ueDl;
8585    RgSchCmnDlUe         *pCellUeDl;
8586 #ifdef DEBUGP
8587    Inst                 inst = ue->cell->instIdx;
8588 #endif
8589    U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
8590    TRC2(rgSCHCmnRgrSCellUeCfg);
8591
8592    pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
8593    pCellUeDl = &pCellUeSchCmn->dl;
8594
8595    /* 1. Allocate Common sched control block */
8596    if((rgSCHUtlAllocSBuf(sCell->instIdx,
8597                (Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
8598    {
8599       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
8600       err->errCause = RGSCHERR_SCH_CFG;
8601       RETVALUE(RFAILED);
8602    }
8603    ueSchCmn = RG_SCH_CMN_GET_UE(ue,sCell);
8604
8605    /*2.  Perform UEs downlink configuration */
8606    ueDl = &ueSchCmn->dl;
8607
8608    /*CA TODO*/
8609    ueDl->mimoInfo = pCellUeDl->mimoInfo;
8610
8611    if ((ue->mimoInfo.txMode == RGR_UE_TM_4) ||
8612          (ue->mimoInfo.txMode == RGR_UE_TM_6))
8613    {
8614       RG_SCH_CMN_SET_FORCE_TD(ue, sCell, RG_SCH_CMN_TD_NO_PMI);
8615    }
8616    if (ue->mimoInfo.txMode == RGR_UE_TM_3)
8617    {
8618       RG_SCH_CMN_SET_FORCE_TD(ue, sCell, RG_SCH_CMN_TD_RI_1);
8619    }
8620    RGSCH_ARRAY_BOUND_CHECK(sCell->instIdx, rgUeCatTbl, pCellUeSchCmn->cmn.ueCat);
8621    ueDl->maxTbBits = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlTbBits;
8622    /*CA dev-Start*/
8623    U8 ri = 0;
8624    ri = RGSCH_MIN(ri, sCell->numTxAntPorts);
8625    if(((CM_LTE_UE_CAT_6 == pCellUeSchCmn->cmn.ueCat )
8626             ||(CM_LTE_UE_CAT_7 == pCellUeSchCmn->cmn.ueCat)) 
8627          && (4 == ri))
8628    {
8629       ueDl->maxTbSz = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlBits[1];
8630    }
8631    else
8632    {
8633       ueDl->maxTbSz = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlBits[0];
8634    }
8635    /*CA dev-End*/
8636    /* Fix : syed Assign hqEnt to UE only if msg4 is done */
8637 #ifdef LTE_TDD
8638    ueDl->maxSbSz = (rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxSftChBits/
8639          rgSchTddDlNumHarqProcTbl[sCell->ulDlCfgIdx]);
8640 #else
8641    ueDl->maxSbSz = (rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxSftChBits/
8642          RGSCH_NUM_DL_HQ_PROC);
8643 #endif
8644 #ifdef EMTC_ENABLE   
8645    rgSCHCmnDlSetUeAllocLmt(sCell, ueDl, ue->isEmtcUe);
8646 #else
8647    rgSCHCmnDlSetUeAllocLmt(sCell, ueDl, FALSE);
8648 #endif      
8649
8650    /* DL ambr */
8651    /* ambrCfgd config moved to ueCb.dl, as it's not needed for per cell wise*/
8652
8653    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, sCell);
8654    allocInfo->rnti = ue->ueId;
8655
8656    /* Initializing the lastCfi value to current cfi value */
8657    ueDl->lastCfi = cellSchd->dl.currCfi;
8658
8659    if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
8660    {
8661       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
8662       RETVALUE(RFAILED);
8663    }
8664
8665    /* TODO: enhance for DLFS RB Allocation for SCELLs in future dev */
8666
8667    /* DLFS UE Config */
8668    if (cellSchd->dl.isDlFreqSel)
8669    {
8670       if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
8671       {
8672          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
8673          RETVALUE(RFAILED);
8674       }
8675    }
8676
8677    /* TODO: Do UL SCELL CFG during UL CA dev */
8678    {
8679       ueUl = RG_SCH_CMN_GET_UL_UE(ue, sCell);
8680
8681       /* TODO_ULCA: SRS for SCELL needs to be handled in the below function call */
8682       rgSCHCmnUpdUeUlCqiInfo(sCell, ue, ueUl, ueSchCmn, cellSchd,
8683             sCell->isCpUlExtend);
8684
8685       ret = rgSCHUhmHqEntInit(sCell, ue);
8686       if (ret != ROK)
8687       {
8688          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
8689                "Failed for CRNTI:%d", ue->ueId);
8690          RETVALUE(RFAILED);
8691       }
8692
8693       ueUlPcell = RG_SCH_CMN_GET_UL_UE(ue, ue->cell);
8694       /* Initialize uplink HARQ related information for UE */
8695       ueUl->hqEnt.maxHqRetx = ueUlPcell->hqEnt.maxHqRetx;
8696       cmLListInit(&ueUl->hqEnt.free);
8697       cmLListInit(&ueUl->hqEnt.inUse);
8698       for(i=0; i < ueUl->hqEnt.numHqPrcs; i++)
8699       {
8700          ueUl->hqEnt.hqProcCb[i].hqEnt = (void*)(&ueUl->hqEnt);
8701          ueUl->hqEnt.hqProcCb[i].procId = i;
8702          ueUl->hqEnt.hqProcCb[i].ulSfIdx = RGSCH_INVALID_INFO;
8703          ueUl->hqEnt.hqProcCb[i].alloc = NULLP;
8704 #ifdef LTEMAC_SPS
8705          /* ccpu00139513- Initializing SPS flags*/
8706          ueUl->hqEnt.hqProcCb[i].isSpsActvnHqP = FALSE;
8707          ueUl->hqEnt.hqProcCb[i].isSpsOccnHqP = FALSE;
8708 #endif
8709          cmLListAdd2Tail(&ueUl->hqEnt.free, &ueUl->hqEnt.hqProcCb[i].lnk);
8710          ueUl->hqEnt.hqProcCb[i].lnk.node = (PTR)&ueUl->hqEnt.hqProcCb[i];
8711       }
8712
8713       /* Allocate UL BSR allocation tracking List */
8714       cmLListInit(&ueUl->ulAllocLst);
8715
8716       for (cnt = 0; cnt < RG_SCH_CMN_MAX_ALLOC_TRACK; cnt++)
8717       {
8718          if((rgSCHUtlAllocSBuf(sCell->instIdx,
8719                      (Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
8720          {
8721             RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
8722                   "for CRNTI:%d",ue->ueId);
8723             err->errCause = RGSCHERR_SCH_CFG;
8724             RETVALUE(RFAILED);
8725          }
8726          allRcd->allocTime = sCell->crntTime;
8727          cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
8728          allRcd->lnk.node = (PTR)allRcd;
8729       }
8730
8731       /* After initialising UL part, do power related init */
8732       ret = rgSCHPwrUeSCellCfg(sCell, ue, sCellInfoCfg);
8733       if (ret != ROK)
8734       {
8735          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
8736                "power config for UE CRNTI:%d",ue->ueId);
8737          RETVALUE(RFAILED);
8738       }
8739
8740 #ifdef EMTC_ENABLE   
8741       if(TRUE == ue->isEmtcUe)
8742       {
8743          if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
8744          {
8745             RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
8746                   "for CRNTI:%d",ue->ueId);
8747             RETVALUE(RFAILED);
8748          }
8749       }
8750       else
8751 #endif
8752       {
8753       if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
8754       {
8755          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
8756                "for CRNTI:%d",ue->ueId);
8757          RETVALUE(RFAILED);
8758       }
8759       }
8760    
8761       ue->ul.isUlCaEnabled = TRUE;
8762    }
8763
8764    RETVALUE(ROK);
8765 }  /* rgSCHCmnRgrSCellUeCfg */
8766
8767
8768 /**
8769  * @brief UE initialisation for scheduler.
8770  *
8771  * @details
8772  *
8773  *     Function : rgSCHCmnRgrSCellUeDel 
8774  *
8775  *     This functions Delete UE specific scheduler 
8776  *     information for SCELL
8777  *
8778  *  @param[in]  RgSchCellCb  *cell
8779  *  @param[in]  RgSchUeCb    *ue
8780  *  @return  S16
8781  *      -# ROK
8782  *      -# RFAILED
8783  **/
8784 #ifdef ANSI
8785 PUBLIC S16 rgSCHCmnRgrSCellUeDel
8786 (
8787 RgSchUeCellInfo *sCellInfo,
8788 RgSchUeCb    *ue
8789 )
8790 #else
8791 PUBLIC S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
8792 RgSchUeCellInfo *sCellInfo;
8793 RgSchUeCb    *ue;
8794 #endif
8795 {
8796    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
8797    Inst                 inst = ue->cell->instIdx;
8798
8799    TRC2(rgSCHCmnRgrSCellUeDel);
8800
8801    cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
8802
8803    /* UL CA */
8804    rgSCHCmnUlUeDelAllocs(sCellInfo->cell, ue);
8805
8806 #ifdef EMTC_ENABLE   
8807    if(TRUE == ue->isEmtcUe)
8808    {
8809       cellSchd->apisEmtcUl->rgSCHFreeUlUe(sCellInfo->cell, ue);
8810    }
8811    else
8812 #endif
8813    {
8814    cellSchd->apisUl->rgSCHFreeUlUe(sCellInfo->cell, ue);
8815    }
8816
8817    /* DLFS UE Config */
8818    if (cellSchd->dl.isDlFreqSel)
8819    {
8820       if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
8821       {
8822          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
8823          RETVALUE(RFAILED);
8824       }
8825    }
8826
8827    rgSCHUtlFreeSBuf(sCellInfo->cell->instIdx,
8828          (Data**)(&(sCellInfo->sch)), (sizeof(RgSchCmnUe)));
8829
8830
8831    RETVALUE(ROK);
8832 }  /* rgSCHCmnRgrSCellUeDel */
8833  
8834 #endif
8835
8836 #ifdef RG_5GTF
8837 /**
8838  * @brief Handles 5gtf configuration for a UE
8839  *
8840  * @details
8841  *
8842  *     Function : rgSCHCmn5gtfUeCfg
8843  *
8844  *     Processing Steps:
8845  *
8846  *      - Return ROK
8847  *
8848  *  @param[in]  RgSchCellCb  *cell
8849  *  @param[in]  RgSchUeCb    *ue
8850  *  @param[in]  RgrUeCfg     *cfg
8851  *  @return  S16
8852  *      -# ROK
8853  *      -# RFAILED
8854  **/
8855 #ifdef ANSI
8856 PUBLIC S16 rgSCHCmn5gtfUeCfg
8857 (
8858 RgSchCellCb *cell,
8859 RgSchUeCb   *ue,
8860 RgrUeCfg    *cfg
8861 )
8862 #else
8863 PUBLIC S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
8864 RgSchCellCb *cell;
8865 RgSchUeCb   *ue;
8866 RgrUeCfg    *cfg;
8867 #endif
8868 {
8869    TRC2(rgSCHCmnRgrUeCfg);
8870
8871    RgSchUeGrp *ue5gtfGrp;
8872    ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
8873    ue->ue5gtfCb.BeamId = cfg->ue5gtfCfg.BeamId;
8874    ue->ue5gtfCb.numCC = cfg->ue5gtfCfg.numCC;   
8875    ue->ue5gtfCb.mcs = cfg->ue5gtfCfg.mcs;
8876    ue->ue5gtfCb.maxPrb = cfg->ue5gtfCfg.maxPrb;
8877
8878    ue->ue5gtfCb.cqiRiPer = 100;
8879    /* 5gtf TODO: CQIs to start from (10,0)*/
8880    ue->ue5gtfCb.nxtCqiRiOccn.sfn = 10;
8881    ue->ue5gtfCb.nxtCqiRiOccn.slot = 0;
8882    ue->ue5gtfCb.rank = 1;
8883
8884    printf("\nschd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
8885          ue->ue5gtfCb.mcs,ue->ue5gtfCb.maxPrb); 
8886
8887    ue5gtfGrp = &(cell->cell5gtfCb.ueGrp5gConf[ue->ue5gtfCb.BeamId]);
8888
8889    /* TODO_5GTF: Currently handling 1 group only. Need to update when multi group 
8890       scheduling comes into picture */
8891    if(ue5gtfGrp->beamBitMask & (1 << ue->ue5gtfCb.BeamId))
8892    {
8893       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
8894             "5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
8895       RETVALUE(RFAILED);
8896    }
8897    ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
8898
8899    RETVALUE(ROK);
8900 }
8901 #endif
8902
8903 /**
8904  * @brief UE initialisation for scheduler.
8905  *
8906  * @details
8907  *
8908  *     Function : rgSCHCmnRgrUeCfg
8909  *
8910  *     This functions intialises UE specific scheduler
8911  *     information
8912  *     0. Perform basic validations
8913  *     1. Allocate common sched UE cntrl blk
8914  *     2. Perform DL cfg (allocate Hq Procs Cmn sched cntrl blks)
8915  *     3. Perform UL cfg
8916  *     4. Perform DLFS cfg
8917  *
8918  *  @param[in]  RgSchCellCb  *cell
8919  *  @param[in]  RgSchUeCb    *ue
8920  *  @param[int] RgrUeCfg     *ueCfg
8921  *  @param[out] RgSchErrInfo *err
8922  *  @return  S16
8923  *      -# ROK
8924  *      -# RFAILED
8925  **/
8926 #ifdef ANSI
8927 PUBLIC S16 rgSCHCmnRgrUeCfg
8928 (
8929 RgSchCellCb  *cell,
8930 RgSchUeCb    *ue,
8931 RgrUeCfg     *ueCfg,
8932 RgSchErrInfo *err
8933 )
8934 #else
8935 PUBLIC S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
8936 RgSchCellCb  *cell;
8937 RgSchUeCb    *ue;
8938 RgrUeCfg     *ueCfg;
8939 RgSchErrInfo *err;
8940 #endif
8941 {
8942    RgSchDlRbAlloc  *allocInfo;
8943    S16                  ret;
8944    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8945    RgSchCmnUe           *ueSchCmn;
8946    RgSchCmnUlUe         *ueUl;
8947    RgSchCmnDlUe         *ueDl;
8948    U8                   cnt;
8949    RgSchCmnAllocRecord  *allRcd;
8950    U32                  waitPer;
8951    U32                  idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
8952    RgSchUeCellInfo      *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
8953    TRC2(rgSCHCmnRgrUeCfg);
8954
8955
8956    /* 1. Allocate Common sched control block */
8957    if((rgSCHUtlAllocSBuf(cell->instIdx,
8958                (Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
8959    {
8960       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
8961             "Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
8962       err->errCause = RGSCHERR_SCH_CFG;
8963       RETVALUE(RFAILED);
8964    }
8965    ueSchCmn   = RG_SCH_CMN_GET_UE(ue,cell);
8966    ue->dl.ueDlCqiCfg = ueCfg->ueDlCqiCfg;
8967    pCellInfo->acqiCb.aCqiCfg = ueCfg->ueDlCqiCfg.aprdCqiCfg;
8968    if(ueCfg->ueCatEnum > 0 )
8969    {
8970      /*KWORK_FIX removed NULL chk for ueSchCmn*/
8971       ueSchCmn->cmn.ueCat = ueCfg->ueCatEnum - 1; 
8972    }
8973    else
8974    {
8975       ueSchCmn->cmn.ueCat = 0; /* Assuming enum values correctly set */
8976    }
8977    cmInitTimers(&ueSchCmn->cmn.tmr, 1);
8978
8979    /*2.  Perform UEs downlink configuration */
8980    ueDl = &ueSchCmn->dl;
8981    /* RACHO : store the rapId assigned for HandOver UE.
8982     * Append UE to handover list of cmnCell */
8983    if (ueCfg->dedPreambleId.pres == PRSNT_NODEF)
8984    {
8985       rgSCHCmnDelDedPreamble(cell, ueCfg->dedPreambleId.val);
8986       ueDl->rachInfo.hoRapId = ueCfg->dedPreambleId.val;
8987       cmLListAdd2Tail(&cellSchd->rachCfg.hoUeLst, &ueDl->rachInfo.hoLnk);
8988       ueDl->rachInfo.hoLnk.node = (PTR)ue;
8989    }
8990
8991    rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd);
8992
8993    if (ueCfg->txMode.pres == TRUE)
8994    {
8995       if ((ueCfg->txMode.txModeEnum == RGR_UE_TM_4) ||
8996             (ueCfg->txMode.txModeEnum == RGR_UE_TM_6))
8997       {
8998          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
8999       }
9000       if (ueCfg->txMode.txModeEnum == RGR_UE_TM_3)
9001       {
9002          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9003       }
9004    }
9005    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
9006    ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
9007    /*CA dev-Start*/
9008    U8 ri = 0;
9009    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
9010    if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
9011             ||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat)) 
9012                   && (4 == ri))
9013    {
9014       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[1];
9015    }
9016    else
9017    {
9018       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[0];
9019    }
9020    /*CA dev-End*/
9021    /* Fix : syed Assign hqEnt to UE only if msg4 is done */
9022 #ifdef LTE_TDD
9023    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9024          rgSchTddDlNumHarqProcTbl[cell->ulDlCfgIdx]);
9025 #else
9026    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9027          RGSCH_NUM_DL_HQ_PROC);
9028 #endif
9029 #ifdef EMTC_ENABLE   
9030    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, ue->isEmtcUe);
9031 #else
9032    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, FALSE);
9033 #endif 
9034      /* if none of the DL and UL AMBR are configured then fail the configuration
9035     */     
9036    if((ueCfg->ueQosCfg.dlAmbr == 0) && (ueCfg->ueQosCfg.ueBr == 0))
9037    {
9038       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
9039          "configured as 0 for CRNTI:%d",ueCfg->crnti);
9040       err->errCause = RGSCHERR_SCH_CFG;
9041       RETVALUE(RFAILED);
9042    }
9043    /* DL ambr */
9044    ue->dl.ambrCfgd = (ueCfg->ueQosCfg.dlAmbr * RG_SCH_CMN_REFRESH_TIME)/100;
9045
9046    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
9047    allocInfo->rnti = ue->ueId;
9048
9049    /* Initializing the lastCfi value to current cfi value */
9050    ueDl->lastCfi = cellSchd->dl.currCfi;
9051 #ifdef EMTC_ENABLE
9052    if(cell->emtcEnable && ue->isEmtcUe)
9053    {
9054       if ((cellSchd->apisEmtcDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
9055       {
9056          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9057                "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
9058          RETVALUE(RFAILED);
9059       }
9060
9061    }
9062    else
9063 #endif
9064    {
9065       if ((cellSchd->apisDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
9066       {
9067          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9068                "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
9069          RETVALUE(RFAILED);
9070       }
9071    }
9072
9073
9074
9075    /* 3. Initialize ul part */
9076    ueUl     = &ueSchCmn->ul;
9077
9078    rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
9079             cell->isCpUlExtend);
9080
9081    ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
9082                                RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
9083
9084    ue->ul.cfgdAmbr = (ueCfg->ueQosCfg.ueBr * RG_SCH_CMN_REFRESH_TIME)/100;
9085    ue->ul.effAmbr = ue->ul.cfgdAmbr;
9086    RGSCHCPYTIMEINFO(cell->crntTime, ue->ul.ulTransTime);
9087
9088    /* Allocate UL BSR allocation tracking List */
9089    cmLListInit(&ueUl->ulAllocLst);
9090
9091    for (cnt = 0; cnt < RG_SCH_CMN_MAX_ALLOC_TRACK; cnt++)
9092    {
9093       if((rgSCHUtlAllocSBuf(cell->instIdx,
9094                   (Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
9095       {
9096          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
9097                    "for CRNTI:%d",ueCfg->crnti);
9098          err->errCause = RGSCHERR_SCH_CFG;
9099          RETVALUE(RFAILED);
9100       }
9101       allRcd->allocTime = cell->crntTime;
9102       cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
9103       allRcd->lnk.node = (PTR)allRcd;
9104    }
9105    /* Allocate common sch cntrl blocks for LCGs */
9106    for (cnt=0; cnt<RGSCH_MAX_LCG_PER_UE; cnt++)
9107    {
9108       ret = rgSCHUtlAllocSBuf(cell->instIdx,
9109             (Data**)&(ue->ul.lcgArr[cnt].sch), (sizeof(RgSchCmnLcg)));
9110       if (ret != ROK)
9111       {
9112          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9113             "SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
9114          err->errCause = RGSCHERR_SCH_CFG;
9115          RETVALUE(ret);
9116       }
9117    }
9118    /* After initialising UL part, do power related init */
9119    ret = rgSCHPwrUeCfg(cell, ue, ueCfg);
9120    if (ret != ROK)
9121    {
9122       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
9123          "power config for UE CRNTI:%d",ueCfg->crnti);
9124       RETVALUE(RFAILED);
9125    }
9126 #ifdef LTEMAC_SPS
9127    ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
9128    if (ret != ROK)
9129    {
9130       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
9131          "SPS config for CRNTI:%d",ueCfg->crnti);
9132       RETVALUE(RFAILED);
9133    }
9134 #endif /* LTEMAC_SPS */
9135
9136 #ifdef EMTC_ENABLE   
9137    if(TRUE == ue->isEmtcUe)
9138    {
9139       if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
9140       {
9141          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
9142                   "for CRNTI:%d",ueCfg->crnti);
9143          RETVALUE(RFAILED);
9144       }
9145    }
9146    else
9147 #endif
9148    {
9149    if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
9150    {
9151       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
9152                "for CRNTI:%d",ueCfg->crnti);
9153       RETVALUE(RFAILED);
9154    }
9155    }
9156
9157    /* DLFS UE Config */
9158    if (cellSchd->dl.isDlFreqSel)
9159    {
9160       if ((cellSchd->apisDlfs->rgSCHDlfsUeCfg(cell, ue, ueCfg, err)) != ROK)
9161       {
9162          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
9163                    "for CRNTI:%d",ueCfg->crnti);
9164          RETVALUE(RFAILED);
9165       }
9166    }
9167
9168    /* Fix: syed align multiple UEs to refresh at same time */
9169    rgSCHCmnGetRefreshPer(cell, ue, &waitPer);
9170    /* Start UE Qos Refresh Timer */
9171    rgSCHCmnAddUeToRefreshQ(cell, ue, waitPer);
9172 #ifdef RG_5GTF
9173    rgSCHCmn5gtfUeCfg(cell, ue, ueCfg);
9174 #endif
9175
9176    RETVALUE(ROK);
9177 }  /* rgSCHCmnRgrUeCfg */
9178
9179 /**
9180  * @brief UE TX mode reconfiguration handler.
9181  *
9182  * @details
9183  *
9184  *     Function : rgSCHCmnDlHdlTxModeRecfg
9185  *
9186  *     This functions updates UE specific scheduler
9187  *     information upon UE reconfiguration.
9188  *
9189  *  @param[in]  RgSchUeCb    *ue
9190  *  @param[in] RgrUeRecfg   *ueRecfg
9191  *  @return  Void
9192  **/
9193 #ifdef TFU_UPGRADE
9194 #ifdef ANSI
9195 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
9196 (
9197 RgSchCellCb *cell,
9198 RgSchUeCb    *ue,
9199 RgrUeRecfg   *ueRecfg,
9200 U8 numTxPorts
9201 )
9202 #else
9203 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
9204 RgSchCellCb *cell;
9205 RgSchUeCb    *ue;
9206 RgrUeRecfg   *ueRecfg;
9207 U8 numTxPorts;
9208 #endif
9209 #else
9210 #ifdef ANSI
9211 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
9212 (
9213 RgSchCellCb *cell,
9214 RgSchUeCb    *ue,
9215 RgrUeRecfg   *ueRecfg
9216 )
9217 #else
9218 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg)
9219 RgSchCellCb *cell;
9220 RgSchUeCb    *ue;
9221 RgrUeRecfg   *ueRecfg;
9222 #endif
9223 #endif
9224 {
9225    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
9226    TRC2(rgSCHCmnDlHdlTxModeRecfg);
9227
9228    if (ueRecfg->txMode.pres != PRSNT_NODEF)
9229    {
9230       RETVOID;
9231    }
9232    /* ccpu00140894- Starting Timer for TxMode Transition Completion*/
9233    ue->txModeTransCmplt =FALSE;
9234    rgSCHTmrStartTmr (ue->cell, ue, RG_SCH_TMR_TXMODE_TRNSTN, RG_SCH_TXMODE_TRANS_TIMER);
9235    if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_CMPLT)
9236    {
9237       RG_SCH_CMN_UNSET_FORCE_TD(ue, cell,
9238                                 RG_SCH_CMN_TD_TXMODE_RECFG);
9239      /* MS_WORKAROUND for ccpu00123186 MIMO Fix Start: need to set FORCE TD bitmap based on TX mode */
9240      ueDl->mimoInfo.ri = 1;
9241      if ((ueRecfg->txMode.txModeEnum == RGR_UE_TM_4) ||
9242           (ueRecfg->txMode.txModeEnum == RGR_UE_TM_6))
9243       {
9244          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
9245       }
9246       if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_3)
9247       {
9248          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9249       }
9250       /* MIMO Fix End: need to set FORCE TD bitmap based on TX mode */
9251       RETVOID;
9252    }
9253    if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_START)
9254    {
9255       /* start afresh forceTD masking */
9256       RG_SCH_CMN_INIT_FORCE_TD(ue, cell, 0);
9257       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_TXMODE_RECFG);
9258       /* Intialize MIMO related parameters of UE */
9259
9260 #ifdef TFU_UPGRADE
9261       if(ueRecfg->txMode.pres)
9262       {
9263          if((ueRecfg->txMode.txModeEnum ==RGR_UE_TM_3) ||
9264                (ueRecfg->txMode.txModeEnum ==RGR_UE_TM_4))
9265          {
9266             if(ueRecfg->ueCodeBookRstRecfg.pres)
9267             {
9268                ueDl->mimoInfo.ri =
9269                   rgSCHCmnComputeRank(ueRecfg->txMode.txModeEnum,
9270                     ueRecfg->ueCodeBookRstRecfg.pmiBitMap, numTxPorts);
9271             }
9272             else
9273             {
9274                ueDl->mimoInfo.ri = 1;
9275             }
9276          }
9277          else
9278          {
9279             ueDl->mimoInfo.ri = 1;
9280          }
9281       }
9282       else
9283       {
9284          ueDl->mimoInfo.ri = 1;
9285       }
9286 #else
9287       ueDl->mimoInfo.ri = 1;
9288 #endif /* TFU_UPGRADE */
9289       if ((ueRecfg->txMode.txModeEnum == RGR_UE_TM_4) ||
9290           (ueRecfg->txMode.txModeEnum == RGR_UE_TM_6))
9291       {
9292          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
9293       }
9294       if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_3)
9295       {
9296          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9297       }
9298       RETVOID;
9299    }
9300 }
9301 /***********************************************************
9302  *
9303  *     Func : rgSCHCmnUpdUeMimoInfo
9304  *
9305  *     Desc : Updates UL and DL Ue Information
9306  *
9307  *     Ret  :
9308  *
9309  *     Notes:
9310  *
9311  *     File :
9312  *
9313  **********************************************************/
9314 #ifdef ANSI
9315 PRIVATE Void rgSCHCmnUpdUeMimoInfo
9316 (
9317 RgrUeCfg     *ueCfg,
9318 RgSchCmnDlUe *ueDl,
9319 RgSchCellCb  *cell,
9320 RgSchCmnCell *cellSchd
9321 )
9322 #else
9323 PRIVATE Void rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd)
9324 RgrUeCfg     *ueCfg;
9325 RgSchCmnDlUe *ueDl;
9326 RgSchCellCb  *cell;
9327 RgSchCmnCell *cellSchd;
9328 #endif
9329 {
9330    TRC2(rgSCHCmnUpdUeMimoInfo)
9331 #ifdef TFU_UPGRADE
9332    if(ueCfg->txMode.pres)
9333    {
9334       if((ueCfg->txMode.txModeEnum ==RGR_UE_TM_3) ||
9335             (ueCfg->txMode.txModeEnum ==RGR_UE_TM_4))
9336       {
9337          if(ueCfg->ueCodeBookRstCfg.pres)
9338          {
9339             ueDl->mimoInfo.ri =
9340                rgSCHCmnComputeRank(ueCfg->txMode.txModeEnum,
9341                  ueCfg->ueCodeBookRstCfg.pmiBitMap, cell->numTxAntPorts);
9342          }
9343          else
9344          {
9345             ueDl->mimoInfo.ri = 1;
9346          }
9347       }
9348       else
9349       {
9350          ueDl->mimoInfo.ri = 1;
9351       }
9352    }
9353    else
9354    {
9355       ueDl->mimoInfo.ri = 1;
9356    }
9357
9358 #else
9359    ueDl->mimoInfo.ri = 1;
9360 #endif /*TFU_UPGRADE */
9361    ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
9362    ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
9363
9364    RETVOID;
9365 }
9366 /***********************************************************
9367  *
9368  *     Func : rgSCHCmnUpdUeUlCqiInfo
9369  *
9370  *     Desc : Updates UL and DL Ue Information
9371  *
9372  *     Ret  :
9373  *
9374  *     Notes:
9375  *
9376  *     File :
9377  *
9378  **********************************************************/
9379 #ifdef ANSI
9380 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo
9381 (
9382 RgSchCellCb   *cell,
9383 RgSchUeCb     *ue,
9384 RgSchCmnUlUe  *ueUl,
9385 RgSchCmnUe    *ueSchCmn,
9386 RgSchCmnCell  *cellSchd,
9387 Bool          isEcp
9388 )
9389 #else
9390 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, isEcp)
9391 RgSchCellCb  *cell;
9392 RgSchUeCb    *ue;
9393 RgSchCmnUlUe *ueUl;
9394 RgSchCmnUe   *ueSchCmn;
9395 RgSchCmnCell *cellSchd;
9396 Bool          isEcp;
9397 #endif
9398 {
9399
9400    TRC2(rgSCHCmnUpdUeUlCqiInfo)
9401
9402 #ifdef TFU_UPGRADE
9403    if(ue->srsCb.srsCfg.type  ==  RGR_SCH_SRS_SETUP)
9404    {
9405      if(ue->ul.ulTxAntSel.pres)
9406      {
9407        ueUl->crntUlCqi[ue->srsCb.selectedAnt] = cellSchd->ul.dfltUlCqi;
9408        ueUl->validUlCqi = ueUl->crntUlCqi[ue->srsCb.selectedAnt];
9409      }
9410      else
9411      {
9412        ueUl->crntUlCqi[0] = cellSchd->ul.dfltUlCqi;
9413        ueUl->validUlCqi =  ueUl->crntUlCqi[0];
9414      }
9415       ue->validTxAnt = ue->srsCb.selectedAnt;
9416    }
9417    else
9418    {
9419       ueUl->validUlCqi = cellSchd->ul.dfltUlCqi;
9420       ue->validTxAnt = 0;
9421    }
9422 #ifdef UL_LA
9423    ueUl->ulLaCb.cqiBasediTbs = rgSchCmnUlCqiToTbsTbl[isEcp]
9424                                                 [ueUl->validUlCqi] * 100;   
9425    ueUl->ulLaCb.deltaiTbs = 0;
9426 #endif
9427
9428 #else
9429    ueUl->crntUlCqi[0] = cellSchd->ul.dfltUlCqi;
9430 #endif /*TFU_UPGRADE */
9431    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
9432    if (rgUeCatTbl[ueSchCmn->cmn.ueCat].ul64qamSup == FALSE)
9433    {
9434       ueUl->maxUlCqi = cellSchd->ul.max16qamCqi;
9435    }
9436    else
9437    {
9438       ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
9439    }
9440
9441    RETVOID;
9442 }
9443 /***********************************************************
9444  *
9445  *     Func : rgSCHCmnUpdUeCatCfg
9446  *
9447  *     Desc : Updates UL and DL Ue Information
9448  *
9449  *     Ret  :
9450  *
9451  *     Notes:
9452  *
9453  *     File :
9454  *
9455  **********************************************************/
9456 #ifdef ANSI
9457 PRIVATE Void rgSCHCmnUpdUeCatCfg
9458 (
9459 RgSchUeCb    *ue,
9460 RgSchCellCb  *cell
9461 )
9462 #else
9463 PRIVATE Void rgSCHCmnUpdUeCatCfg(ue, cell)
9464 RgSchUeCb    *ue;
9465 RgSchCellCb  *cell;
9466 #endif
9467 {
9468    RgSchDlHqEnt *hqE = NULLP;
9469    RgSchCmnUlUe *ueUl     = RG_SCH_CMN_GET_UL_UE(ue,cell);
9470    RgSchCmnDlUe *ueDl     = RG_SCH_CMN_GET_DL_UE(ue,cell);
9471    RgSchCmnUe   *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
9472    RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
9473
9474    TRC2(rgSCHCmnUpdUeCatCfg)
9475
9476    ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
9477    
9478    hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
9479    /*CA dev-Start*/
9480    U8 ri = 0;
9481    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
9482    if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
9483             ||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat)) 
9484          && (RG_SCH_MAX_TX_LYRS_4 == ri))
9485    {
9486       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[1];
9487    }
9488    else
9489    {
9490       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[0];
9491    }
9492    /*CA dev-End*/
9493    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9494                            hqE->numHqPrcs);
9495    if (rgUeCatTbl[ueSchCmn->cmn.ueCat].ul64qamSup == FALSE)
9496    {
9497       ueUl->maxUlCqi = cellSchd->ul.max16qamCqi;
9498    }
9499    else
9500    {
9501       ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
9502    }
9503    ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
9504                    RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
9505    RETVOID;
9506 }
9507
9508 /**
9509  * @brief UE reconfiguration for scheduler.
9510  *
9511  * @details
9512  *
9513  *     Function : rgSChCmnRgrUeRecfg
9514  *
9515  *     This functions updates UE specific scheduler
9516  *     information upon UE reconfiguration.
9517  *
9518  *  @param[in]  RgSchCellCb  *cell
9519  *  @param[in]  RgSchUeCb    *ue
9520  *  @param[int] RgrUeRecfg   *ueRecfg
9521  *  @param[out] RgSchErrInfo *err
9522  *  @return  S16
9523  *      -# ROK
9524  *      -# RFAILED
9525  **/
9526 #ifdef ANSI
9527 PUBLIC S16 rgSCHCmnRgrUeRecfg
9528 (
9529 RgSchCellCb  *cell,
9530 RgSchUeCb    *ue,
9531 RgrUeRecfg   *ueRecfg,
9532 RgSchErrInfo *err
9533 )
9534 #else
9535 PUBLIC S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
9536 RgSchCellCb  *cell;
9537 RgSchUeCb    *ue;
9538 RgrUeRecfg   *ueRecfg;
9539 RgSchErrInfo *err;
9540 #endif
9541 {
9542    RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
9543    U32          waitPer;
9544
9545    TRC2(rgSCHCmnRgrUeRecfg);
9546    /* Basic validations */
9547    if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
9548    {
9549 #ifdef TFU_UPGRADE
9550       rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, cell->numTxAntPorts);
9551 #else
9552       rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg);
9553 #endif /* TFU_UPGRADE */
9554    }
9555    if(ueRecfg->ueRecfgTypes & RGR_UE_CSG_PARAM_RECFG)
9556    {
9557       ue->csgMmbrSta = ueRecfg->csgMmbrSta;
9558    }
9559    /* Changes for UE Category reconfiguration feature */
9560    if(ueRecfg->ueRecfgTypes & RGR_UE_UECAT_RECFG)
9561    {
9562        rgSCHCmnUpdUeCatCfg(ue, cell);
9563    }
9564    if (ueRecfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG)
9565    {
9566       RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
9567       pCellInfo->acqiCb.aCqiCfg = ueRecfg->aprdDlCqiRecfg;
9568    }
9569 #ifndef TFU_UPGRADE
9570    if (ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG)
9571    {
9572       if ((ueRecfg->prdDlCqiRecfg.pres == TRUE)
9573             && (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD10)
9574             && (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD20))
9575       {
9576          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unsupported periodic CQI "
9577             "reporting mode %d for old CRNIT:%d", 
9578             (int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
9579          err->errCause = RGSCHERR_SCH_CFG;
9580          RETVALUE(RFAILED);
9581       }
9582      ue->dl.ueDlCqiCfg.prdCqiCfg = ueRecfg->prdDlCqiRecfg;
9583    }
9584 #endif
9585
9586    if (ueRecfg->ueRecfgTypes & RGR_UE_ULPWR_RECFG)
9587    {
9588       if (rgSCHPwrUeRecfg(cell, ue, ueRecfg) != ROK)
9589       {
9590          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9591                "Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
9592          RETVALUE(RFAILED);
9593       }
9594    }
9595
9596    if (ueRecfg->ueRecfgTypes & RGR_UE_QOS_RECFG)
9597    {
9598       /* Uplink Sched related Initialization */
9599       if ((ueRecfg->ueQosRecfg.dlAmbr == 0) && (ueRecfg->ueQosRecfg.ueBr == 0))
9600       {
9601          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
9602             "configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
9603          err->errCause = RGSCHERR_SCH_CFG;
9604          RETVALUE(RFAILED);
9605       }
9606       ue->ul.cfgdAmbr = (ueRecfg->ueQosRecfg.ueBr * \
9607       RG_SCH_CMN_REFRESH_TIME)/100;
9608       /* Downlink Sched related Initialization */
9609       ue->dl.ambrCfgd = (ueRecfg->ueQosRecfg.dlAmbr * \
9610       RG_SCH_CMN_REFRESH_TIME)/100;
9611       /* Fix: syed Update the effAmbr and effUeBR fields w.r.t the
9612        * new QOS configuration */
9613       rgSCHCmnDelUeFrmRefreshQ(cell, ue);
9614       /* Fix: syed align multiple UEs to refresh at same time */
9615       rgSCHCmnGetRefreshPer(cell, ue, &waitPer);
9616       rgSCHCmnApplyUeRefresh(cell, ue);
9617       rgSCHCmnAddUeToRefreshQ(cell, ue, waitPer);
9618    }
9619 #ifdef EMTC_ENABLE   
9620    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
9621    {
9622       if ((cellSchCmn->apisEmtcUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9623       {
9624          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9625                "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9626          RETVALUE(RFAILED);
9627       }
9628       if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9629       {
9630          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9631                "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9632          RETVALUE(RFAILED);
9633       }
9634    }
9635    else
9636 #endif
9637    {
9638       if ((cellSchCmn->apisUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9639       {
9640          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9641             "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9642          RETVALUE(RFAILED);
9643       }
9644       if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9645       {
9646          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9647             "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9648          RETVALUE(RFAILED);
9649       }
9650    }
9651    /* DLFS UE Config */
9652    if (cellSchCmn->dl.isDlFreqSel)
9653    {
9654       if ((cellSchCmn->apisDlfs->rgSCHDlfsUeRecfg(cell, ue, \
9655          ueRecfg, err)) != ROK)
9656       {
9657          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9658                "DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
9659          RETVALUE(RFAILED);
9660       }
9661    }
9662
9663 #ifdef LTEMAC_SPS
9664    /* Invoke re-configuration on SPS module */
9665    if (rgSCHCmnSpsUeRecfg(cell, ue, ueRecfg, err) != ROK)
9666    {
9667       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9668               "DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
9669       RETVALUE(RFAILED);
9670    }
9671 #endif
9672
9673    RETVALUE(ROK);
9674 }  /* rgSCHCmnRgrUeRecfg*/
9675
9676 /***********************************************************
9677  *
9678  *     Func : rgSCHCmnUlUeDelAllocs
9679  *
9680  *     Desc : Deletion of all UE allocations.
9681  *
9682  *     Ret  :
9683  *
9684  *     Notes:
9685  *
9686  *     File :
9687  *
9688  **********************************************************/
9689 #ifdef ANSI
9690 PRIVATE Void rgSCHCmnUlUeDelAllocs
9691 (
9692 RgSchCellCb  *cell,
9693 RgSchUeCb   *ue
9694 )
9695 #else
9696 PRIVATE Void rgSCHCmnUlUeDelAllocs(cell, ue)
9697 RgSchCellCb  *cell;
9698 RgSchUeCb   *ue;
9699 #endif
9700 {
9701    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
9702    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
9703    U8 i;
9704 #ifdef LTEMAC_SPS
9705    RgSchCmnUlUeSpsInfo   *ulSpsUe   = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
9706 #endif
9707    TRC2(rgSCHCmnUlUeDelAllocs);
9708
9709    for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
9710    {
9711       RgSchUlHqProcCb *proc = rgSCHUhmGetUlHqProc(cell, ue, i);
9712
9713 #ifdef ERRCLS_KW
9714       /* proc can't be NULL here */
9715       if (proc)
9716 #endif
9717       {
9718          /* R8 Upgrade */
9719          proc->ndi = 0;
9720          if (proc->alloc)
9721          {
9722             /* Added Insure Fixes Of reading Dangling memory.NULLed crntAlloc */
9723 #ifdef LTEMAC_SPS
9724             if(proc->alloc == ulSpsUe->ulSpsSchdInfo.crntAlloc)
9725             {
9726                ulSpsUe->ulSpsSchdInfo.crntAlloc = NULLP;
9727                ulSpsUe->ulSpsSchdInfo.crntAllocSf = NULLP;
9728             }
9729 #endif
9730 #ifdef EMTC_ENABLE
9731             rgSCHCmnUlFreeAllocation(cell, &cellUl->ulSfArr[proc->ulSfIdx],
9732                   proc->alloc,ue->isEmtcUe);
9733 #else
9734             rgSCHCmnUlFreeAllocation(cell, &cellUl->ulSfArr[proc->ulSfIdx],
9735                   proc->alloc);
9736 #endif
9737             /* PHY probably needn't be intimated since
9738              * whatever intimation it needs happens at the last minute
9739              */
9740          }
9741          /* Fix: syed Adaptive Msg3 Retx crash. Remove the harqProc
9742           * from adaptive retx List. */
9743          if (proc->reTxLnk.node)
9744          {
9745             {
9746                //TODO_SID: Need to take care
9747                cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk); 
9748                proc->reTxLnk.node = (PTR)NULLP;
9749             }
9750          }
9751       }
9752    }
9753    RETVOID;
9754 }
9755
9756 /***********************************************************
9757  *
9758  *     Func : rgSCHCmnDelUeFrmRefreshQ
9759  *
9760  *     Desc : Adds a UE to refresh queue, so that the UE is
9761  *            periodically triggered to refresh it's GBR and
9762  *            AMBR values.
9763  *
9764  *     Ret  :
9765  *
9766  *     Notes:
9767  *
9768  *     File :
9769  *
9770  **********************************************************/
9771 #ifdef ANSI
9772 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ
9773 (
9774 RgSchCellCb     *cell,
9775 RgSchUeCb       *ue
9776 )
9777 #else
9778 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ(cell, ue)
9779 RgSchCellCb     *cell;
9780 RgSchUeCb       *ue;
9781 #endif
9782 {
9783    RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
9784    CmTmrArg       arg;
9785    RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
9786
9787    TRC2(rgSCHCmnDelUeFrmRefreshQ);
9788
9789 #ifdef RGL_SPECIFIC_CHANGES
9790    if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
9791    {
9792       if(cell->refreshUeCnt[ue->refreshOffset])
9793       {
9794          cell->refreshUeCnt[ue->refreshOffset]--;
9795       }
9796    }
9797 #endif
9798
9799
9800    cmMemset((U8 *)&arg, 0, sizeof(arg));
9801    arg.tqCp   = &sched->tmrTqCp;
9802    arg.tq     = sched->tmrTq;
9803    arg.timers = &ueSchd->tmr;
9804    arg.cb     = (PTR)ue;
9805    arg.tNum   = 0;
9806    arg.max    = 1;
9807    arg.evnt   = RG_SCH_CMN_EVNT_UE_REFRESH;
9808
9809    cmRmvCbTq(&arg);
9810    RETVOID;
9811 }
9812
9813 /***********************************************************
9814  *
9815  *     Func : rgSCHCmnUeCcchSduDel
9816  *
9817  *     Desc : Clear CCCH SDU scheduling context.
9818  *
9819  *     Ret  :
9820  *
9821  *     Notes:
9822  *
9823  *     File :
9824  *
9825  **********************************************************/
9826 #ifdef ANSI
9827 PRIVATE Void rgSCHCmnUeCcchSduDel
9828 (
9829 RgSchCellCb  *cell,
9830 RgSchUeCb    *ueCb
9831 )
9832 #else
9833 PRIVATE Void rgSCHCmnUeCcchSduDel(cell, ueCb)
9834 RgSchCellCb  *cell;
9835 RgSchUeCb    *ueCb;
9836 #endif
9837 {
9838    RgSchDlHqEnt      *hqE = NULLP;
9839    RgSchDlHqProcCb   *ccchSduHqP = NULLP;
9840    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
9841
9842    TRC2(rgSCHCmnUeCcchSduDel);
9843
9844    hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
9845    if (hqE == NULLP)
9846    {
9847       RETVOID;
9848    }
9849    ccchSduHqP = hqE->ccchSduProc;
9850    if(ueCb->ccchSduLnk.node != NULLP)
9851    {
9852       /* Remove the ccchSduProc if it is in the Tx list */
9853       cmLListDelFrm(&(cell->ccchSduUeLst), &(ueCb->ccchSduLnk));
9854       ueCb->ccchSduLnk.node = NULLP;   
9855    }
9856    else if(ccchSduHqP != NULLP)
9857    {
9858       /* Fix for crash due to stale pdcch. Release ccch pdcch*/
9859       if(ccchSduHqP->pdcch)
9860       {
9861          cmLListDelFrm(&ccchSduHqP->subFrm->pdcchInfo.pdcchs,
9862                &ccchSduHqP->pdcch->lnk);
9863          cmLListAdd2Tail(&cell->pdcchLst, &ccchSduHqP->pdcch->lnk);
9864          ccchSduHqP->pdcch = NULLP;
9865       }
9866       if(ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk.node != NULLP)
9867       {
9868          /* Remove the ccchSduProc if it is in the retx list */
9869          cmLListDelFrm(&cellSch->dl.ccchSduRetxLst,
9870           &ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk);
9871          /* ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk.node = NULLP; */
9872          rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
9873       }
9874       else if ((ccchSduHqP->subFrm != NULLP) &&
9875        (ccchSduHqP->hqPSfLnk.node != NULLP))
9876       {
9877          rgSCHUtlDlHqPTbRmvFrmTx(ccchSduHqP->subFrm, 
9878                ccchSduHqP, 0, FALSE);
9879          rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
9880       }
9881    }   
9882    RETVOID;
9883 }
9884
9885
9886
9887
9888 /**
9889  * @brief UE deletion for scheduler.
9890  *
9891  * @details
9892  *
9893  *     Function : rgSCHCmnUeDel
9894  *
9895  *     This functions deletes all scheduler information
9896  *     pertaining to an UE.
9897  *
9898  *  @param[in]  RgSchCellCb  *cell
9899  *  @param[in]  RgSchUeCb    *ue
9900  *  @return  Void
9901  **/
9902 #ifdef ANSI
9903 PUBLIC Void rgSCHCmnUeDel
9904 (
9905 RgSchCellCb  *cell,
9906 RgSchUeCb    *ue
9907 )
9908 #else
9909 PUBLIC Void rgSCHCmnUeDel(cell, ue)
9910 RgSchCellCb  *cell;
9911 RgSchUeCb    *ue;
9912 #endif
9913 {
9914    RgSchDlHqEnt         *hqE = NULLP;
9915    RgSchCmnUlUe         *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
9916    CmLList              *node;
9917    RgSchCmnAllocRecord  *allRcd;
9918    U8                    cnt;
9919    RgSchCmnCell         *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
9920    U32                   idx = 0;
9921    TRC2(rgSCHCmnUeDel);
9922
9923    if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
9924    {
9925       /* Common scheduler config has not happened yet */
9926       RETVOID;
9927    }
9928    hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
9929    if(hqE)
9930    {
9931       /* UE Free can be triggered before MSG4 done when dlHqE is not updated */
9932 #ifdef EMTC_ENABLE
9933       if(ue->isEmtcUe)
9934       {
9935          rgSCHEmtcCmnUeCcchSduDel(cell, ue);
9936       }
9937       else
9938 #endif
9939      {    
9940          rgSCHCmnUeCcchSduDel(cell, ue);
9941      }
9942    }
9943    rgSCHCmnDelUeFrmRefreshQ(cell, ue);
9944
9945    rgSCHCmnUlUeDelAllocs(cell, ue);
9946
9947    rgSCHCmnDelRachInfo(cell, ue);
9948
9949 #ifdef EMTC_ENABLE   
9950    if(TRUE == ue->isEmtcUe)
9951    {
9952       cellSchCmn->apisEmtcUl->rgSCHFreeUlUe(cell, ue);
9953    }
9954    else
9955 #endif
9956    {
9957    cellSchCmn->apisUl->rgSCHFreeUlUe(cell, ue);
9958    }
9959 #ifdef LTE_ADV
9960    if (ue->numSCells)
9961    {
9962       for(idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
9963       {
9964          if(ue->cellInfo[idx] != NULLP) 
9965          {
9966             rgSCHSCellDelUeSCell(cell,ue,idx);
9967          }
9968       }
9969
9970    }
9971 #endif
9972 #ifdef EMTC_ENABLE
9973    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
9974    {
9975       cellSchCmn->apisEmtcDl->rgSCHFreeDlUe(cell, ue);
9976    }
9977    else
9978 #endif
9979    {
9980       cellSchCmn->apisDl->rgSCHFreeDlUe(cell, ue);
9981    }
9982    rgSCHPwrUeDel(cell, ue);
9983
9984 #ifdef LTEMAC_SPS
9985    rgSCHCmnSpsUeDel(cell, ue);
9986 #endif /* LTEMAC_SPS*/
9987
9988    /* CA Dev Start*/
9989    rgSchCmnDlSfHqDel(ue, cell);
9990    /* CA Dev End*/
9991    /* DLFS UE delete */
9992    if (cellSchCmn->dl.isDlFreqSel)
9993    {
9994       cellSchCmn->apisDlfs->rgSCHDlfsUeDel(cell, ue);
9995    }
9996    node = ueUl->ulAllocLst.first;
9997
9998 /* ccpu00117052 - MOD - Passing double pointer in all the places of
9999    rgSCHUtlFreeSBuf function call for proper NULLP assignment*/
10000    while(node)
10001    {
10002       allRcd = (RgSchCmnAllocRecord *)node->node;
10003       node = node->next;
10004       cmLListDelFrm(&ueUl->ulAllocLst, &allRcd->lnk);
10005       rgSCHUtlFreeSBuf(cell->instIdx,
10006          (Data**)(&allRcd), (sizeof(RgSchCmnAllocRecord)));
10007    }
10008
10009    for(cnt = 0; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
10010    {
10011       if (ue->ul.lcgArr[cnt].sch != NULLP)
10012       {
10013          rgSCHUtlFreeSBuf(cell->instIdx,
10014             (Data**)(&(ue->ul.lcgArr[cnt].sch)), (sizeof(RgSchCmnLcg)));
10015       }
10016    }
10017
10018    /* Fix : syed Moved hqEnt deinit to rgSCHCmnDlDeInitHqEnt */
10019    idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
10020    rgSCHUtlFreeSBuf(cell->instIdx,
10021          (Data**)(&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch))), (sizeof(RgSchCmnUe)));
10022    RETVOID;
10023 }  /* rgSCHCmnUeDel */
10024
10025 \f
10026 /**
10027  * @brief This function handles the common code rate configurations
10028  *        done as part of RgrCellCfg/RgrCellRecfg.
10029  *
10030  * @details
10031  *
10032  *     Function: rgSCHCmnDlCnsdrCmnRt
10033  *     Purpose:  This function handles the common code rate configurations
10034  *        done as part of RgrCellCfg/RgrCellRecfg.
10035  *
10036  *     Invoked by: Scheduler
10037  *
10038  *  @param[in]  RgSchCellCb                *cell
10039  *  @param[in]  RgrDlCmnCodeRateCfg     *dlCmnCodeRate
10040  *  @return     S16
10041  *
10042  **/
10043 #ifdef ANSI
10044 PRIVATE S16 rgSCHCmnDlCnsdrCmnRt
10045 (
10046 RgSchCellCb             *cell,
10047 RgrDlCmnCodeRateCfg     *dlCmnCodeRate
10048 )
10049 #else
10050 PRIVATE S16 rgSCHCmnDlCnsdrCmnRt(cell, dlCmnCodeRate)
10051 RgSchCellCb             *cell;
10052 RgrDlCmnCodeRateCfg     *dlCmnCodeRate;
10053 #endif
10054 {
10055    RgSchCmnCell         *cellDl = RG_SCH_CMN_GET_CELL(cell);
10056    U32                  bitsPerRb;
10057    U32                  bitsPer2Rb;
10058    U32                  bitsPer3Rb;
10059    U8                   i, rbNum;
10060    U32                  pdcchBits;
10061
10062    TRC2(rgSCHCmnDlCnsdrCmnRt);
10063
10064    /* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
10065     * bits per 1024/2 REs */
10066    if (dlCmnCodeRate->bcchPchRaCodeRate != 0)
10067    {
10068       bitsPerRb = ((dlCmnCodeRate->bcchPchRaCodeRate * 2) *
10069             cellDl->dl.noResPerRb[3])/1024;
10070    }
10071    else
10072    {
10073       bitsPerRb = ((RG_SCH_CMN_DEF_BCCHPCCH_CODERATE * 2) *
10074             cellDl->dl.noResPerRb[3])/1024;
10075    }
10076    /* Store bitsPerRb in cellDl->dl to use later to determine
10077     * Number of RBs for UEs with SI-RNTI, P-RNTI and RA-RNTI */
10078    cellDl->dl.bitsPerRb = bitsPerRb;
10079    /* ccpu00115595 end*/
10080    /* calculate the ITbs for 2 RBs. Initialize ITbs to MAX value */
10081    i = 0;
10082    rbNum = 2;
10083    bitsPer2Rb = bitsPerRb * rbNum;
10084    while ((i < 9) && (rgTbSzTbl[0][i][rbNum - 1] <= bitsPer2Rb))
10085       i++;
10086
10087    (i <= 1)? (cellDl->dl.cmnChITbs.iTbs2Rbs = 0) :
10088       (cellDl->dl.cmnChITbs.iTbs2Rbs = i-1);
10089
10090    /* calculate the ITbs for 3 RBs. Initialize ITbs to MAX value */
10091    i = 0;
10092    rbNum = 3;
10093    bitsPer3Rb = bitsPerRb * rbNum;
10094    while ((i < 9) && (rgTbSzTbl[0][i][rbNum - 1] <= bitsPer3Rb))
10095          i++;
10096
10097    (i <= 1)? (cellDl->dl.cmnChITbs.iTbs3Rbs = 0) :
10098       (cellDl->dl.cmnChITbs.iTbs3Rbs = i-1);
10099
10100
10101    pdcchBits = 1 + /* Flag for format0/format1a differentiation */
10102       1 + /* Localized/distributed VRB assignment flag */
10103       5 + /* For mcs */
10104 #ifndef LTE_TDD
10105       3 + /* Harq process Id */
10106 #else
10107       4 + /* Harq process Id */
10108       2 + /* UL Index or DAI */
10109 #endif
10110       1 + /* New Data Indicator */
10111       2 + /* For RV */
10112       2 + /* For tpc */
10113       1 + rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
10114                (cell->bwCfg.dlTotalBw + 1))/2);
10115    /* Resource block assignment ceil[log2(bw(bw+1)/2)] : \
10116       Since VRB is local */
10117    /* For TDD consider DAI */
10118
10119    /* Convert the pdcchBits to actual pdcchBits required for transmission */
10120    if (dlCmnCodeRate->pdcchCodeRate != 0)
10121    {
10122       pdcchBits = (pdcchBits * 1024)/dlCmnCodeRate->pdcchCodeRate;
10123       if (pdcchBits <= 288) /* 288 : Num of pdcch bits for aggrLvl=4 */
10124       {
10125          cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL4;
10126       }
10127       else                  /* 576 : Num of pdcch bits for aggrLvl=8 */
10128       {
10129          cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL8;
10130       }
10131    }
10132    else
10133    {
10134       cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL4;
10135    }
10136    if (dlCmnCodeRate->ccchCqi == 0)
10137    {
10138       RETVALUE(RFAILED);
10139    }
10140    else
10141    {
10142       cellDl->dl.ccchCqi = dlCmnCodeRate->ccchCqi;
10143    }
10144    RETVALUE(ROK);
10145 }
10146
10147 #ifdef LTE_TDD
10148 /**
10149  * @brief This function handles the configuration of cell for the first
10150  *        time by the scheduler.
10151  *
10152  * @details
10153  *
10154  *     Function: rgSCHCmnDlRgrCellCfg
10155  *     Purpose:  Configuration received is stored into the data structures
10156  *               Also, update the scheduler with the number of frames of
10157  *               RACH preamble transmission.
10158  *
10159  *     Invoked by: BO and Scheduler
10160  *
10161  *  @param[in]  RgSchCellCb*     cell
10162  *  @param[in]  RgrCellCfg*      cfg
10163  *  @return     S16
10164  *
10165  **/
10166 #ifdef ANSI
10167 PRIVATE S16 rgSCHCmnDlRgrCellCfg
10168 (
10169 RgSchCellCb    *cell,
10170 RgrCellCfg     *cfg,
10171 RgSchErrInfo   *err
10172 )
10173 #else
10174 PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
10175 RgSchCellCb    *cell;
10176 RgrCellCfg     *cfg;
10177 RgSchErrInfo   *err;
10178 #endif
10179 {
10180    RgSchCmnCell         *cellSch;
10181    U8                   cp;
10182    U8                   sfCount;
10183    U8                   numPdcchSym;
10184    U8                   noSymPerSlot;
10185    U8                   maxDlSubfrms = cell->numDlSubfrms;
10186    U8                   splSubfrmIdx = cfg->spclSfCfgIdx;
10187    U8                   swPtCnt = 0;
10188    Bool                 isSplfrm;
10189    RgSchTddSubfrmInfo   subfrmInfo = rgSchTddMaxUlSubfrmTbl[cell->ulDlCfgIdx];
10190    S16                  ret;
10191    U8                   splSfIdx;
10192    U8                   antPortIdx;
10193    U8                   numCrs;
10194    U8                   cfi;  
10195    U8                   cfiIdx;
10196    RgSchDlSf            *sf;
10197    U8                   splSfCfi;
10198    U8                   mPhich;
10199
10200    TRC2(rgSCHCmnDlRgrCellCfg);
10201    
10202
10203    cellSch = RG_SCH_CMN_GET_CELL(cell);
10204    cellSch->dl.numRaSubFrms = rgRaPrmblToRaFrmTbl[cell->\
10205                                                   rachCfg.preambleFormat];
10206    /*[ccpu00138532]-ADD-fill the Msg4 Harq data */
10207    cell->dlHqCfg.maxMsg4HqTx = cfg->dlHqCfg.maxMsg4HqTx;                                                
10208    
10209    /* Msg4 Tx Delay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  + 
10210                        3 TTI (MAX L1+L2 processing delay at the UE) */
10211    cellSch->dl.msg4TxDelay = (cfg->dlHqCfg.maxMsg4HqTx-1) *
10212                                  rgSchCmnHarqRtt[cell->ulDlCfgIdx] + 3; 
10213    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10214    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10215    if (cfg->maxUePerDlSf == 0)
10216    {
10217       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10218    }
10219    if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
10220    {
10221       RETVALUE(RFAILED);
10222    }
10223
10224
10225    if (cell->bwCfg.dlTotalBw <= 10)
10226    {
10227       cfiIdx = 1;
10228       numPdcchSym = 2;
10229    }
10230    else
10231    {
10232       cfiIdx = 0;
10233       numPdcchSym = 1;
10234    }
10235    /* DwPTS Scheduling Changes Start */
10236    cellSch->dl.splSfCfg  = splSubfrmIdx;
10237  
10238    if (cfg->isCpDlExtend == TRUE)
10239    {
10240       if((0 == splSubfrmIdx) || (4 == splSubfrmIdx) ||
10241          (7 == splSubfrmIdx) || (8 == splSubfrmIdx)
10242         )
10243       {
10244          cell->splSubfrmCfg.isDlDataAllowed = FALSE; 
10245       }
10246       else
10247       {
10248          cell->splSubfrmCfg.isDlDataAllowed = TRUE; 
10249       }
10250    }
10251    else
10252    {
10253       /* Refer to 36.213 Section 7.1.7 */
10254       if((0 == splSubfrmIdx) || (5 == splSubfrmIdx))
10255       {
10256          cell->splSubfrmCfg.isDlDataAllowed = FALSE; 
10257       }
10258       else
10259       {
10260          cell->splSubfrmCfg.isDlDataAllowed = TRUE; 
10261       }
10262    }
10263    /* DwPTS Scheduling Changes End */  
10264
10265    splSfCfi = RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi);
10266    RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, splSfCfi);
10267    
10268    for (sfCount = 0; sfCount < maxDlSubfrms; sfCount++)
10269    {
10270       sf = cell->subFrms[sfCount];
10271       /* Sfcount matches the first special subframe occurs at Index 0
10272             * or subsequent special subframes */
10273       if(subfrmInfo.switchPoints == 1)
10274       {
10275          isSplfrm = rgSCHCmnIsSplSubfrm(swPtCnt, sfCount,
10276                                  RG_SCH_CMN_10_MS_PRD, &subfrmInfo);
10277       }
10278       else
10279       {
10280          isSplfrm = rgSCHCmnIsSplSubfrm(swPtCnt, sfCount,
10281                                  RG_SCH_CMN_5_MS_PRD, &subfrmInfo);
10282       }
10283       if(isSplfrm == TRUE)
10284       {
10285          swPtCnt++;
10286          /* DwPTS Scheduling Changes Start */        
10287          if (cell->splSubfrmCfg.isDlDataAllowed == TRUE)
10288          {
10289             sf->sfType = RG_SCH_SPL_SF_DATA;
10290          }
10291          else
10292          {
10293             sf->sfType = RG_SCH_SPL_SF_NO_DATA;
10294          }
10295          /* DwPTS Scheduling Changes End */
10296       }
10297       else
10298       {
10299          /* DwPTS Scheduling Changes Start */
10300          if (sf->sfNum != 0)
10301          {
10302             sf->sfType = RG_SCH_DL_SF;
10303          }
10304          else
10305          {
10306             sf->sfType = RG_SCH_DL_SF_0;
10307          }
10308          /* DwPTS Scheduling Changes End */
10309       }
10310       
10311       /* Calculate the number of CCEs per subframe in the cell */
10312       mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][sf->sfNum];
10313       if(cell->dynCfiCb.isDynCfiEnb == TRUE)
10314       {   
10315          /* In case if Dynamic CFI feature is enabled, default CFI 
10316           * value 1 is used  */
10317          sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][1];
10318       }
10319       else
10320       {
10321          if (sf->sfType == RG_SCH_SPL_SF_DATA)
10322          {
10323             sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][splSfCfi];
10324          }
10325          else
10326          {
10327             sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi)];
10328          }
10329       }   
10330    }
10331
10332    /* Intialize the RACH response scheduling related infromation */
10333    if(rgSCHCmnDlRachInfoInit(cell) != ROK)
10334    {
10335      RETVALUE(RFAILED);
10336    }
10337
10338    /* Allocate PRACH preamble list */
10339    rgSCHCmnDlCreateRachPrmLst(cell);
10340
10341    /* Initialize PHICH offset information */
10342    rgSCHCmnDlPhichOffsetInit(cell);
10343
10344    /* Update the size of HARQ ACK/NACK feedback table */
10345    /* The array size is increased by 2 to have enough free indices, where other
10346     * indices are busy waiting for HARQ feedback */
10347    cell->ackNackFdbkArrSize = rgSchTddANFdbkMapTbl[cell->ulDlCfgIdx] + 2; 
10348
10349    /* Initialize expected HARQ ACK/NACK feedback time */
10350    rgSCHCmnDlANFdbkInit(cell);
10351
10352    /* Initialize UL association set index */
10353    if(cell->ulDlCfgIdx != 0)
10354    {
10355       rgSCHCmnDlKdashUlAscInit(cell);
10356    }
10357
10358    if (cfg->isCpDlExtend == TRUE)
10359    {
10360       cp = RG_SCH_CMN_EXT_CP;
10361       noSymPerSlot = 6;
10362       cell->splSubfrmCfg.dwPts =
10363           rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlDwPts;
10364    
10365       if ( cell->splSubfrmCfg.dwPts == 0 )
10366       {
10367          cell->isDwPtsCnted = FALSE;
10368       }
10369       else
10370       {
10371          cell->isDwPtsCnted = TRUE;
10372       }
10373
10374       if(cfg->isCpUlExtend == TRUE)
10375       {
10376          cell->splSubfrmCfg.upPts =
10377             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlExtUpPts;
10378       }
10379       else
10380       {
10381          cell->splSubfrmCfg.upPts =
10382             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlNorUpPts;
10383       }
10384    }
10385    else
10386    {
10387       cp = RG_SCH_CMN_NOR_CP;
10388       noSymPerSlot = 7;
10389       cell->splSubfrmCfg.dwPts =
10390           rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlDwPts;
10391       cell->isDwPtsCnted = TRUE;
10392
10393       if(cfg->isCpUlExtend == TRUE)
10394       {
10395          cell->splSubfrmCfg.upPts =
10396             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlExtUpPts;
10397       }
10398       else
10399       {
10400          cell->splSubfrmCfg.upPts =
10401             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlNorUpPts;
10402       }
10403    }
10404
10405    /* Initializing the cqiToEffTbl and cqiToTbsTbl for every CFI value */
10406    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++,cfiIdx++)
10407    {   
10408       cellSch->dl.cqiToTbsTbl[0][cfi]   = rgSchCmnCqiToTbs[0][cp][cfiIdx];
10409       cellSch->dl.cqiToEffTbl[0][cfi]   = rgSchCmnEffTbl[0][cp][rgSchCmnAntIdx\
10410                                                  [cell->numTxAntPorts]][cfiIdx];
10411       cellSch->dl.cqiToTbsTbl[1][cfi]   = rgSchCmnCqiToTbs[1][cp][cfiIdx];
10412       cellSch->dl.cqiToEffTbl[1][cfi]   = rgSchCmnEffTbl[1][cp][rgSchCmnAntIdx\
10413                                                  [cell->numTxAntPorts]][cfiIdx];
10414    }
10415
10416    /* Initializing the values of CFI parameters */
10417    if(cell->dynCfiCb.isDynCfiEnb)
10418    {   
10419       /* If DCFI is enabled, current CFI value will start from 1 */
10420       cellSch->dl.currCfi = cellSch->dl.newCfi = 1;
10421    }
10422    else
10423    {
10424       /* If DCFI is disabled, current CFI value is set as default max allowed CFI value */
10425       cellSch->dl.currCfi = RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi);
10426       cellSch->dl.newCfi = cellSch->dl.currCfi;
10427    }   
10428
10429    /* Include CRS REs while calculating Efficiency
10430     * The number of Resource Elements occupied by CRS depends on Number of
10431     * Antenna Ports. Please refer to Section 6.10.1 of 3GPP TS 36.211 V8.8.0.
10432     * Also, please refer to Figures 6.10.1.2-1 and 6.10.1.2-2 for diagrammatic
10433     * details of the same. Please note that PDCCH overlap symbols would not
10434     * considered in CRS REs deduction */
10435    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, numPdcchSym++)
10436    {
10437       cellSch->dl.noResPerRb[cfi] = (((noSymPerSlot * RG_SCH_CMN_NUM_SLOTS_PER_SF)
10438             - numPdcchSym) *RB_SCH_CMN_NUM_SCS_PER_RB) - rgSchCmnNumResForCrs[cell->numTxAntPorts];
10439    }
10440
10441    /* DwPTS Scheduling Changes Start */
10442    antPortIdx = (cell->numTxAntPorts == 1)? 0: 
10443       ((cell->numTxAntPorts == 2)? 1: 2);     
10444
10445    if (cp == RG_SCH_CMN_NOR_CP)
10446    {
10447       splSfIdx = (splSubfrmIdx == 4)? 1: 0;   
10448    }
10449    else
10450    {
10451       splSfIdx = (splSubfrmIdx == 3)? 1: 0;
10452    }
10453
10454    numCrs = rgSchCmnDwptsCrs[splSfIdx][antPortIdx];
10455
10456    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI-1; cfi++)
10457    { 
10458       /* If CFI is 2 and Ant Port is 4, don't consider the sym 1 CRS REs */  
10459       if (antPortIdx == 2 && cfi == 2)
10460       {
10461          numCrs -= 4;      
10462       }
10463       cellSch->dl.numReDwPts[cfi]  =  ((cell->splSubfrmCfg.dwPts - cfi)*
10464                                   RB_SCH_CMN_NUM_SCS_PER_RB) - numCrs;
10465    }
10466    /* DwPTS Scheduling Changes End */
10467
10468    if (cfg->maxDlBwPerUe == 0)
10469    {
10470       cellSch->dl.maxDlBwPerUe = RG_SCH_CMN_MAX_DL_BW_PERUE;
10471    }
10472    else
10473    {
10474       cellSch->dl.maxDlBwPerUe = cfg->maxDlBwPerUe;
10475    }
10476    if (cfg->maxDlRetxBw == 0)
10477    {
10478       cellSch->dl.maxDlRetxBw = RG_SCH_CMN_MAX_DL_RETX_BW;
10479    }
10480    else
10481    {
10482       cellSch->dl.maxDlRetxBw = cfg->maxDlRetxBw;
10483    }
10484    /* Fix: MUE_PERTTI_DL*/
10485    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10486    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10487    if (cfg->maxUePerDlSf == 0)
10488    {
10489       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10490    }
10491    RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
10492    /*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
10493    if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
10494    {
10495       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
10496                       "Invalid configuration !: "
10497                       "maxCcchPerDlSf %u > maxUePerDlSf %u",
10498                    cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
10499
10500       RETVALUE(RFAILED);
10501    }
10502    else if (!cfg->maxCcchPerDlSf)
10503    {
10504       /* ccpu00143032: maxCcchPerDlSf 0 means not configured by application
10505        * hence setting to maxUePerDlSf. If maxCcchPerDlSf is 0 then scheduler
10506        * does't consider CCCH allocation in MaxUePerTti cap. Hence more than
10507        * 4UEs getting schduled & SCH expects >16 Hq PDUs in a TTI which causes
10508        * FLE crash in PHY as PHY has limit of 16 max*/
10509       cellSch->dl.maxCcchPerDlSf = cfg->maxUePerDlSf;
10510    }
10511    else
10512    {
10513       cellSch->dl.maxCcchPerDlSf = cfg->maxCcchPerDlSf;
10514    }
10515    if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
10516    {
10517       RETVALUE(RFAILED);
10518    }
10519
10520    /*ccpu00118273 - ADD - start */
10521    cmLListInit(&cellSch->dl.msg4RetxLst);
10522 #ifdef RGR_V1
10523    cmLListInit(&cellSch->dl.ccchSduRetxLst);
10524 #endif
10525
10526 #ifdef RG_PHASE2_SCHED
10527    if (cellSch->apisDlfs == NULLP) /* DFLS specific initialization */
10528    {
10529       cellSch->apisDlfs = &rgSchDlfsSchdTbl[cfg->dlfsSchdType];
10530    }
10531    if (cfg->dlfsCfg.isDlFreqSel)
10532    {
10533       ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
10534       if (ret != ROK)
10535       {
10536          RETVALUE(RFAILED);
10537       }
10538    }
10539    cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
10540 #endif
10541
10542    /* Power related configuration */
10543    ret = rgSCHPwrCellCfg(cell, cfg);
10544    if (ret != ROK)
10545    {
10546       RETVALUE(RFAILED);
10547    }
10548
10549    cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset; 
10550    cellSch->dl.pcchTxPwrOffset = cfg->pcchTxPwrOffset; 
10551    cellSch->dl.rarTxPwrOffset  = cfg->rarTxPwrOffset; 
10552    cellSch->dl.phichTxPwrOffset  = cfg->phichTxPwrOffset; 
10553    cellSch->dl.msg4pAVal        = cfg->msg4pAVal;
10554    RETVALUE(ROK);
10555 }
10556 #else /* LTE_TDD */
10557 /**
10558  * @brief This function handles the configuration of cell for the first
10559  *        time by the scheduler.
10560  *
10561  * @details
10562  *
10563  *     Function: rgSCHCmnDlRgrCellCfg
10564  *     Purpose:  Configuration received is stored into the data structures
10565  *               Also, update the scheduler with the number of frames of
10566  *               RACH preamble transmission.
10567  *
10568  *     Invoked by: BO and Scheduler
10569  *
10570  *  @param[in]  RgSchCellCb*   cell
10571  *  @param[in]  RgrCellCfg*    cfg
10572  *  @param[in]  RgSchErrInfo*  err
10573  *  @return     S16
10574  *
10575  **/
10576 #ifdef ANSI
10577 PRIVATE S16 rgSCHCmnDlRgrCellCfg
10578 (
10579 RgSchCellCb             *cell,
10580 RgrCellCfg              *cfg,
10581 RgSchErrInfo            *err
10582 )
10583 #else
10584 PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
10585 RgSchCellCb             *cell;
10586 RgrCellCfg              *cfg;
10587 RgSchErrInfo            *err;
10588 #endif
10589 {
10590    S16                 ret;
10591    RgSchCmnCell        *cellSch;
10592    U8                   cp;
10593    U8                   numPdcchSym;
10594    U8                   noSymPerSlot;
10595    U8                   cfi;  
10596    U8                   cfiIdx;
10597
10598    TRC2(rgSCHCmnDlRgrCellCfg);
10599
10600    cellSch = RG_SCH_CMN_GET_CELL(cell);
10601
10602    /* Initialize the parameters with the ones received in the */
10603    /* configuration.                                          */
10604
10605    /* Added matrix 'rgRaPrmblToRaFrmTbl' for computation of RA
10606     * sub-frames from preamble format */
10607    cellSch->dl.numRaSubFrms = rgRaPrmblToRaFrmTbl[cell->rachCfg.preambleFormat];
10608
10609    /*[ccpu00138532]-ADD-fill the Msg4 Harq data */
10610    cell->dlHqCfg.maxMsg4HqTx = cfg->dlHqCfg.maxMsg4HqTx;                                                
10611    
10612    /* Msg4 Tx Delay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  + 
10613                        3 TTI (MAX L1+L2 processing delay at the UE) */
10614    cellSch->dl.msg4TxDelay = (cfg->dlHqCfg.maxMsg4HqTx-1) *
10615                                  rgSchCmnHarqRtt[7] + 3; 
10616
10617    if (cell->bwCfg.dlTotalBw <= 10)
10618    {
10619       cfiIdx = 1;
10620       numPdcchSym = 2;
10621    }
10622    else
10623    {
10624       cfiIdx = 0;
10625       numPdcchSym = 1;
10626    }
10627
10628    if (cell->isCpDlExtend == TRUE)
10629    {
10630       cp = RG_SCH_CMN_EXT_CP;
10631       noSymPerSlot = 6;
10632    }
10633    else
10634    {
10635       cp = RG_SCH_CMN_NOR_CP;
10636       noSymPerSlot = 7;
10637    }
10638
10639    /* Initializing the cqiToEffTbl and cqiToTbsTbl for every CFI value */
10640    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, cfiIdx++)
10641    {   
10642       cellSch->dl.cqiToTbsTbl[0][cfi]   = rgSchCmnCqiToTbs[0][cp][cfiIdx];
10643 #ifdef EMTC_ENABLE      
10644       cellSch->dl.emtcCqiToTbsTbl[0][cfi]   = rgSchEmtcCmnCqiToTbs[0][cp][cfiIdx];
10645 #endif      
10646       cellSch->dl.cqiToEffTbl[0][cfi]   = rgSchCmnEffTbl[0][cp][rgSchCmnAntIdx\
10647                                                  [cell->numTxAntPorts]][cfiIdx];
10648       cellSch->dl.cqiToTbsTbl[1][cfi]   = rgSchCmnCqiToTbs[1][cp][cfiIdx];
10649 #ifdef EMTC_ENABLE      
10650       cellSch->dl.emtcCqiToTbsTbl[1][cfi]   = rgSchEmtcCmnCqiToTbs[1][cp][cfiIdx];
10651 #endif      
10652       cellSch->dl.cqiToEffTbl[1][cfi]   = rgSchCmnEffTbl[1][cp][rgSchCmnAntIdx\
10653                                                  [cell->numTxAntPorts]][cfiIdx];
10654    }
10655
10656    /* Initializing the values of CFI parameters */
10657    if(cell->dynCfiCb.isDynCfiEnb)
10658    {   
10659       /* If DCFI is enabled, current CFI value will start from 1 */
10660       cellSch->dl.currCfi = cellSch->dl.newCfi = 1;
10661    }
10662    else
10663    {
10664       /* If DCFI is disabled, current CFI value is set as default CFI value */
10665       cellSch->dl.currCfi = cellSch->cfiCfg.cfi;
10666       cellSch->dl.newCfi = cellSch->dl.currCfi;
10667    }   
10668
10669    /* Include CRS REs while calculating Efficiency
10670     * The number of Resource Elements occupied by CRS depends on Number of
10671     * Antenna Ports. Please refer to Section 6.10.1 of 3GPP TS 36.211 V8.8.0.
10672     * Also, please refer to Figures 6.10.1.2-1 and 6.10.1.2-2 for diagrammatic
10673     * details of the same. Please note that PDCCH overlap symbols would not
10674     * considered in CRS REs deduction */
10675    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, numPdcchSym++)
10676    {
10677        cellSch->dl.noResPerRb[cfi]    = (((noSymPerSlot * RG_SCH_CMN_NUM_SLOTS_PER_SF)
10678             - numPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - rgSchCmnNumResForCrs[cell->numTxAntPorts];
10679    }           
10680
10681    if (cfg->maxDlBwPerUe == 0)
10682    {
10683       cellSch->dl.maxDlBwPerUe = RG_SCH_CMN_MAX_DL_BW_PERUE;
10684    }
10685    else
10686    {
10687       cellSch->dl.maxDlBwPerUe = cfg->maxDlBwPerUe;
10688    }
10689    if (cfg->maxDlRetxBw == 0)
10690    {
10691       cellSch->dl.maxDlRetxBw = RG_SCH_CMN_MAX_DL_RETX_BW;
10692    }
10693    else
10694    {
10695       cellSch->dl.maxDlRetxBw = cfg->maxDlRetxBw;
10696    }
10697    
10698    /* Fix: MUE_PERTTI_DL*/
10699    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10700    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10701    if (cfg->maxUePerDlSf == 0)
10702    {
10703       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10704    }
10705    /* Fix: MUE_PERTTI_DL syed validating Cell Configuration */
10706    if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
10707    {
10708       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
10709             "FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
10710             cellSch->dl.maxUePerDlSf,
10711             cellSch->dl.maxUeNewTxPerTti);
10712       RETVALUE(RFAILED);
10713    }
10714    /*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
10715    if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
10716    {
10717       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid configuration !: "
10718             "maxCcchPerDlSf %u > maxUePerDlSf %u",
10719             cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
10720
10721       RETVALUE(RFAILED);
10722    }
10723    else if (!cfg->maxCcchPerDlSf)
10724    {
10725       /* ccpu00143032: maxCcchPerDlSf 0 means not configured by application
10726        * hence setting to maxUePerDlSf. If maxCcchPerDlSf is 0 then scheduler
10727        * does't consider CCCH allocation in MaxUePerTti cap. Hence more than
10728        * 4UEs getting schduled & SCH expects >16 Hq PDUs in a TTI which causes
10729        * FLE crash in PHY as PHY has limit of 16 max*/
10730       cellSch->dl.maxCcchPerDlSf = cfg->maxUePerDlSf;
10731    }
10732    else
10733    {
10734       cellSch->dl.maxCcchPerDlSf = cfg->maxCcchPerDlSf;
10735    }
10736
10737
10738    if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
10739    {
10740       RETVALUE(RFAILED);
10741    }
10742    cmLListInit(&cellSch->dl.msg4RetxLst);
10743 #ifdef RGR_V1
10744    cmLListInit(&cellSch->dl.ccchSduRetxLst);
10745 #endif
10746
10747 #ifdef RG_PHASE2_SCHED
10748    if (cellSch->apisDlfs == NULLP) /* DFLS specific initialization */
10749    {
10750       cellSch->apisDlfs = &rgSchDlfsSchdTbl[cfg->dlfsSchdType];
10751    }
10752    if (cfg->dlfsCfg.isDlFreqSel)
10753    {
10754       ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
10755       if (ret != ROK)
10756       {
10757          RETVALUE(RFAILED);
10758       }
10759    }
10760    cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
10761 #endif
10762
10763    /* Power related configuration */
10764    ret = rgSCHPwrCellCfg(cell, cfg);
10765    if (ret != ROK)
10766    {
10767       RETVALUE(RFAILED);
10768    }
10769
10770    cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset; 
10771    cellSch->dl.pcchTxPwrOffset = cfg->pcchTxPwrOffset; 
10772    cellSch->dl.rarTxPwrOffset  = cfg->rarTxPwrOffset; 
10773    cellSch->dl.phichTxPwrOffset  = cfg->phichTxPwrOffset; 
10774    RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
10775    RETVALUE(ROK);
10776 }
10777 #endif /* LTE_TDD */
10778
10779 /***********************************************************
10780  *
10781  *     Func : rgSCHCmnUlCalcReqRbCeil
10782  *
10783  *     Desc : Calculate RB required to satisfy 'bytes' for
10784  *            a given CQI.
10785  *            Returns number of RBs such that requirement
10786  *            is necessarily satisfied (does a 'ceiling'
10787  *            computation).
10788  *
10789  *     Ret  : Required RBs (U8)
10790  *
10791  *     Notes:
10792  *
10793  *     File :
10794  *
10795  **********************************************************/
10796 #ifdef ANSI
10797 PUBLIC U8 rgSCHCmnUlCalcReqRbCeil
10798 (
10799 U32            bytes,
10800 U8             cqi,
10801 RgSchCmnUlCell *cellUl
10802 )
10803 #else
10804 PUBLIC U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
10805 U32            bytes;
10806 U8             cqi;
10807 RgSchCmnUlCell *cellUl;
10808 #endif
10809 {
10810    U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
10811    TRC2(rgSCHCmnUlCalcReqRbCeil);
10812    RETVALUE((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
10813 }
10814
10815 /***********************************************************
10816  *
10817  *     Func : rgSCHCmnPrecompMsg3Vars
10818  *
10819  *     Desc : Precomputes the following for msg3 allocation:
10820  *            1. numSb and Imcs for msg size A
10821  *            2. numSb and Imcs otherwise
10822  *
10823  *     Ret  :
10824  *
10825  *     Notes: The corresponding vars in cellUl struct is filled
10826  *            up
10827  *
10828  *     File :
10829  *
10830  **********************************************************/
10831 #ifdef ANSI
10832 PRIVATE S16 rgSCHCmnPrecompMsg3Vars
10833 (
10834 RgSchCmnUlCell *cellUl,
10835 U8           ccchCqi,
10836 U16          msgSzA,
10837 U8           sbSize,
10838 Bool         isEcp
10839 )
10840 #else
10841 PRIVATE S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
10842 RgSchCmnUlCell *cellUl;
10843 U8           ccchCqi;
10844 U16          msgSzA;
10845 U8           sbSize;
10846 Bool         isEcp;
10847 #endif
10848 {
10849    U8 numSb;
10850    U8 ccchTbs;
10851    U8 ccchMcs;
10852    U8   numRb = 0;
10853    U8   iTbs = 0;
10854    U16  msg3GrntSz = 0;
10855
10856    TRC2(rgSCHCmnPrecompMsg3Vars);
10857
10858    if (ccchCqi > cellUl->max16qamCqi)
10859    {
10860       ccchCqi = cellUl->max16qamCqi;
10861    }
10862 /* #ifndef RG_SCH_CMN_EXP_CP_SUP For ECP Pick the index 1 */
10863    /* Fix */
10864    ccchTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
10865    ccchMcs = rgSCHCmnUlGetIMcsFrmITbs(ccchTbs, CM_LTE_UE_CAT_1);
10866    
10867    /* MCS should fit in 4 bits in RAR */
10868    if (ccchMcs >= 15)
10869    {
10870       ccchMcs = 15;
10871    }
10872    
10873    /* Limit the ccchMcs to 15 as it
10874     * can be inferred from 36.213, section 6.2 that msg3 imcs
10875     * field is 4 bits.
10876     * Since, UE doesn't exist right now, we use CAT_1 for ue
10877     * category*/
10878    while((ccchMcs = (rgSCHCmnUlGetIMcsFrmITbs(
10879                       rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
10880                     ) >
10881                  RG_SCH_CMN_MAX_MSG3_IMCS)
10882    {
10883       ccchCqi--;
10884    }
10885    
10886    iTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
10887    
10888    if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
10889    {
10890       RETVALUE(RFAILED);
10891    }
10892    numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(msgSzA, ccchCqi, cellUl), sbSize);
10893    
10894    numRb   = numSb * sbSize;
10895    msg3GrntSz = 8 * msgSzA;
10896
10897    while( (rgTbSzTbl[0][iTbs][numRb - 1]) < msg3GrntSz)
10898    {
10899       ++numSb;
10900       numRb   = numSb * sbSize;
10901    }
10902    while (rgSchCmnMult235Tbl[numSb].match != numSb)
10903    {
10904       ++numSb;
10905    }
10906    /* Reversed(Corrected) the assignment for preamble-GrpA
10907     * Refer- TG36.321- section- 5.1.2*/
10908    cellUl->ra.prmblBNumSb = numSb;
10909    cellUl->ra.prmblBIMcs  = ccchMcs;
10910    numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(RGSCH_MIN_MSG3_GRNT_SZ, \
10911                       ccchCqi, cellUl),
10912          sbSize);
10913
10914    numRb   = numSb * sbSize;
10915    msg3GrntSz = 8 * RGSCH_MIN_MSG3_GRNT_SZ;
10916    while( (rgTbSzTbl[0][iTbs][numRb - 1]) < msg3GrntSz)
10917    {
10918       ++numSb;
10919       numRb   = numSb * sbSize;
10920    }
10921    while (rgSchCmnMult235Tbl[numSb].match != numSb)
10922    {
10923       ++numSb;
10924    }
10925    /* Reversed(Corrected) the assignment for preamble-GrpA
10926     * Refer- TG36.321- section- 5.1.2*/
10927    cellUl->ra.prmblANumSb = numSb;
10928    cellUl->ra.prmblAIMcs  = ccchMcs;
10929    RETVALUE(ROK);
10930 }
10931
10932 PUBLIC U32 gPrntPucchDet=0;
10933
10934 #ifdef LTE_TDD
10935 /***********************************************************
10936  *
10937  *     Func : rgSCHCmnUlCalcAvailBw
10938  *
10939  *     Desc : Calculates bandwidth available for PUSCH scheduling.
10940  *
10941  *     Ret  : S16 (ROK/RFAILED)
10942  *
10943  *     Notes:
10944  *
10945  *     File :
10946  *
10947  **********************************************************/
10948 #ifdef ANSI
10949 PRIVATE S16 rgSCHCmnUlCalcAvailBw
10950 (
10951 RgSchCellCb    *cell,
10952 RgrCellCfg     *cellCfg,
10953 U8              cfi,
10954 U8             *rbStartRef,
10955 U8             *bwAvailRef
10956 )
10957 #else
10958 PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
10959 RgSchCellCb   *cell;
10960 RgrCellCfg    *cellCfg;
10961 U8             cfi;  
10962 U8            *rbStartRef;
10963 U8            *bwAvailRef;
10964 #endif
10965 {
10966    U8  c        = 3;
10967    U8  ulBw     = cell->bwCfg.ulTotalBw;
10968    U8  n2Rb     = cell->pucchCfg.resourceSize;
10969    U8  pucchDeltaShft = cell->pucchCfg.deltaShift;
10970    U16 n1Pucch  = cell->pucchCfg.n1PucchAn;
10971    U8  n1Cs     = cell->pucchCfg.cyclicShift;
10972
10973    U8  n1PerRb;
10974    U8  totalCce;
10975    U16 n1Max;
10976    U8  n1Rb;
10977    U32 mixedRb;
10978    U8  exclRb; /* RBs to exclude */
10979    U8  n1RbPart;
10980    U8  puschRbStart;
10981    /* To avoid PUCCH and PUSCH collision issue */
10982    U8  P;
10983    U8  n1PlusOne;
10984    U8  mi;
10985    /* Maximum value of M as per Table 10.1-1 */
10986    U8  M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
10987
10988    TRC2(rgSCHCmnUlCalcAvailBw);
10989
10990    if (cell->isCpUlExtend)
10991    {
10992       c = 2;
10993    }
10994
10995    n1PerRb  = c * 12 / pucchDeltaShft; /* 12/18/36 */
10996
10997    /* Considering the max no. of CCEs for PUSCH BW calculation 
10998     * based on min mi value */
10999    if (cell->ulDlCfgIdx == 0 || cell->ulDlCfgIdx == 6)
11000    {
11001       mi = 1;
11002    }
11003    else
11004    { 
11005       mi = 0;
11006    }
11007    
11008    totalCce = cell->dynCfiCb.cfi2NCceTbl[mi][cfi];
11009
11010    P        = rgSCHCmnGetPValFrmCCE(cell, totalCce-1);
11011    n1PlusOne = cell->rgSchTddNpValTbl[P + 1];
11012    n1Max    = (M[cell->ulDlCfgIdx] - 1)*n1PlusOne + (totalCce-1) + n1Pucch;
11013
11014    /* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in 
11015     * TS 36.211  */
11016    n1RbPart = (c*n1Cs)/pucchDeltaShft;
11017    n1Rb = (n1Max - n1RbPart)/ n1PerRb;
11018    mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
11019
11020    /* get the total Number of RB's to be excluded for PUSCH */
11021    /* ccpu00137339 */
11022    if(n1Pucch < n1RbPart)
11023    {
11024       exclRb = n2Rb;
11025    }
11026    else
11027    {
11028       exclRb = n2Rb + mixedRb + n1Rb; /* RBs to exclude */
11029    }
11030    puschRbStart = exclRb/2 + 1; 
11031
11032    /* Num of PUCCH RBs = puschRbStart*2 */
11033    if (puschRbStart * 2 >= ulBw)
11034    {
11035       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
11036       RETVALUE(RFAILED);
11037    }
11038
11039    *rbStartRef = puschRbStart;
11040    *bwAvailRef = ulBw -  puschRbStart * 2;
11041  
11042    if(cell->pucchCfg.maxPucchRb !=0 && 
11043          (puschRbStart * 2 > cell->pucchCfg.maxPucchRb))
11044    {
11045       cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
11046    }
11047     
11048    RETVALUE(ROK);
11049 }
11050 #else
11051
11052 /***********************************************************
11053  *
11054  *     Func : rgSCHCmnUlCalcAvailBw
11055  *
11056  *     Desc : Calculates bandwidth available for PUSCH scheduling.
11057  *
11058  *     Ret  : S16 (ROK/RFAILED)
11059  *
11060  *     Notes:
11061  *
11062  *     File :
11063  *
11064  **********************************************************/
11065 #ifdef ANSI
11066 PRIVATE S16 rgSCHCmnUlCalcAvailBw
11067 (
11068 RgSchCellCb    *cell,
11069 RgrCellCfg     *cellCfg,
11070 U8              cfi,
11071 U8             *rbStartRef,
11072 U8             *bwAvailRef
11073 )
11074 #else
11075 PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
11076 RgSchCellCb   *cell;
11077 RgrCellCfg    *cellCfg;
11078 U8             cfi;
11079 U8            *rbStartRef;
11080 U8            *bwAvailRef;
11081 #endif
11082 {
11083    U8  c        = 3;
11084    U8  ulBw     = cell->bwCfg.ulTotalBw;
11085    U8  n2Rb     = cell->pucchCfg.resourceSize;
11086    U8  pucchDeltaShft = cell->pucchCfg.deltaShift;
11087    U16 n1Pucch  = cell->pucchCfg.n1PucchAn;
11088    U8  n1Cs     = cell->pucchCfg.cyclicShift;
11089    U8  n1PerRb;
11090    U8  totalCce;
11091    U16 n1Max;
11092    U8  n1Rb;
11093    U32 mixedRb;
11094    U8  exclRb; /* RBs to exclude */
11095    U8  n1RbPart;
11096    U8  puschRbStart;
11097 #ifdef LTE_ADV
11098    U16 numOfN3PucchRb;
11099    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);  
11100 #endif
11101    
11102    TRC2(rgSCHCmnUlCalcAvailBw);
11103
11104    if (cell->isCpUlExtend)
11105    {
11106       c = 2;
11107    }
11108
11109    n1PerRb  = c * 12 / pucchDeltaShft; /* 12/18/36 */
11110
11111    totalCce = cell->dynCfiCb.cfi2NCceTbl[0][cfi];
11112
11113    n1Max    = n1Pucch + totalCce-1;
11114
11115    /* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in 
11116     * TS 36.211  */
11117    n1RbPart = (c*n1Cs)/pucchDeltaShft;
11118    n1Rb = (U8)((n1Max - n1RbPart) / n1PerRb);
11119    mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
11120
11121    /* get the total Number of RB's to be excluded for PUSCH */
11122    /* ccpu00137339 */
11123    if(n1Pucch < n1RbPart)
11124    {
11125       exclRb = n2Rb;
11126    }
11127    else
11128    {
11129       exclRb = n2Rb + mixedRb + n1Rb; /* RBs to exclude */
11130    }
11131    /*Support for PUCCH Format 3*/
11132 #ifdef LTE_ADV
11133    if (cell->isPucchFormat3Sptd)
11134    {
11135       numOfN3PucchRb = RGSCH_CEIL(cellSch->dl.maxUePerDlSf,5); 
11136       exclRb = exclRb + numOfN3PucchRb;
11137    }
11138 #endif
11139    puschRbStart = exclRb/2 + 1;
11140
11141    if(gPrntPucchDet)
11142    {
11143 #ifndef ALIGN_64BIT
11144            printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
11145         cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
11146 #else
11147            printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
11148         cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
11149 #endif
11150    }
11151
11152    if (puschRbStart*2 >= ulBw)
11153    {
11154       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
11155       RETVALUE(RFAILED);
11156    }
11157
11158    *rbStartRef = puschRbStart;
11159    *bwAvailRef = ulBw - puschRbStart * 2;
11160
11161    if(cell->pucchCfg.maxPucchRb !=0 && 
11162       (puschRbStart * 2 > cell->pucchCfg.maxPucchRb))
11163    {
11164       cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
11165    }
11166    
11167    RETVALUE(ROK);
11168 }
11169 #endif
11170
11171
11172
11173 /***********************************************************
11174  *
11175  *     Func : rgSCHCmnUlCellInit
11176  *
11177  *     Desc : Uplink scheduler initialisation for cell.
11178  *
11179  *     Ret  : S16
11180  *
11181  *     Notes:
11182  *
11183  *     File :
11184  *
11185  **********************************************************/
11186 #ifdef ANSI
11187 PRIVATE S16 rgSCHCmnUlCellInit
11188 (
11189  RgSchCellCb  *cell,
11190  RgrCellCfg   *cellCfg
11191  )
11192 #else
11193 PRIVATE S16 rgSCHCmnUlCellInit(cell, cellCfg)
11194    RgSchCellCb *cell;
11195    RgrCellCfg  *cellCfg;
11196 #endif
11197 {
11198    S16            ret;
11199    RgSchCmnUlCell *cellUl      = RG_SCH_CMN_GET_UL_CELL(cell);
11200    U8             maxUePerUlSf = cellCfg->maxUePerUlSf;
11201 #ifdef RGR_V1
11202    /* Added configuration for maximum number of MSG3s */
11203    U8             maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
11204 #endif
11205    U8             maxUlBwPerUe = cellCfg->maxUlBwPerUe;
11206    U8             sbSize       = cellCfg->puschSubBand.size;
11207    U8             i;
11208    U8             rbStart;
11209    U8             bwAvail;
11210    U8             cfi;  
11211    U8             maxSbPerUe;
11212    U8             numSb;
11213 #ifdef LTE_TDD
11214    U16            ulDlCfgIdx = cell->ulDlCfgIdx;
11215    /* [ccpu00127294]-MOD-Change the max Ul subfrms size in TDD */
11216    U8             maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx]; 
11217    U8             ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL  * 2 */
11218    U8             maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
11219                                            [RGSCH_NUM_SUB_FRAMES-1];
11220    U16             subfrm;
11221    S8             dlIdx;
11222 #else
11223    U8             maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
11224 #endif
11225 #ifdef LTE_L2_MEAS
11226    U8             idx;
11227 #endif
11228    U8  iTbs;
11229 #if (defined(LTE_L2_MEAS) )
11230    Inst           inst         = cell->instIdx;
11231 #endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
11232    RgSchCmnCell      *cellSch =  (RgSchCmnCell *)(cell->sc.sch);
11233    
11234    TRC2(rgSCHCmnUlCellInit);
11235
11236    cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
11237    if (maxUePerUlSf == 0)
11238    {
11239       maxUePerUlSf = RG_SCH_CMN_MAX_UE_PER_UL_SF;
11240    }
11241 #ifdef RGR_V1
11242    if (maxMsg3PerUlSf == 0)
11243    {
11244       maxMsg3PerUlSf = RG_SCH_CMN_MAX_MSG3_PER_UL_SF;
11245    }
11246    /*  fixed the problem while sending raRsp 
11247     * if maxMsg3PerUlSf is greater than 
11248     * RGSCH_MAX_RNTI_PER_RARNTI 
11249     * */
11250    if(maxMsg3PerUlSf > RGSCH_MAX_RNTI_PER_RARNTI)
11251    {
11252       maxMsg3PerUlSf = RGSCH_MAX_RNTI_PER_RARNTI; 
11253    } 
11254
11255    if(maxMsg3PerUlSf > maxUePerUlSf)
11256    {
11257       maxMsg3PerUlSf =  maxUePerUlSf;   
11258    }
11259    
11260    /*cellUl->maxAllocPerUlSf = maxUePerUlSf + maxMsg3PerUlSf;*/
11261    /*Max MSG3 should be a subset of Max UEs*/
11262    cellUl->maxAllocPerUlSf = maxUePerUlSf;
11263    cellUl->maxMsg3PerUlSf = maxMsg3PerUlSf;
11264 #else
11265    cellUl->maxAllocPerUlSf = maxUePerUlSf;
11266 #endif
11267    /* Fix: MUE_PERTTI_UL syed validating Cell Configuration */
11268    if (cellUl->maxAllocPerUlSf < cellUl->maxUeNewTxPerTti)
11269    {
11270       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
11271             "FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
11272             cellUl->maxAllocPerUlSf,
11273             cellUl->maxUeNewTxPerTti);
11274       RETVALUE(RFAILED);
11275    }
11276
11277 #ifdef LTE_L2_MEAS
11278 #ifdef LTE_TDD
11279    for(idx = 0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
11280 #else
11281    for(idx = 0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
11282 #endif
11283    {
11284
11285       ret = rgSCHUtlAllocSBuf(inst,  (Data **)&(cell->sfAllocArr[idx].
11286               ulUeInfo.ulAllocInfo), (cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc)));
11287       if (ret != ROK)
11288       {
11289             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
11290             RETVALUE(ret);
11291       }
11292    }
11293 #endif
11294    if (maxUlBwPerUe == 0)
11295    {
11296       /* ccpu00139362- Setting to configured UL BW instead of MAX BW(100)*/
11297       maxUlBwPerUe = cell->bwCfg.ulTotalBw;
11298    }
11299    cellUl->maxUlBwPerUe = maxUlBwPerUe;
11300
11301    /* FOR RG_SCH_CMN_EXT_CP_SUP */
11302    if (!cellCfg->isCpUlExtend)
11303    {
11304       cellUl->ulNumRePerRb = 12 * (14 - RGSCH_UL_SYM_DMRS_SRS);
11305    }
11306    else
11307    {
11308       cellUl->ulNumRePerRb = 12 * (12 - RGSCH_UL_SYM_DMRS_SRS);
11309    }
11310
11311    if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
11312    {
11313       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
11314       RETVALUE(RFAILED);
11315    }
11316         //Setting the subband size to 4 which is size of VRBG in 5GTF
11317 #ifdef RG_5GTF
11318         sbSize = MAX_5GTF_VRBG_SIZE;
11319 #endif
11320         
11321    maxSbPerUe = maxUlBwPerUe / sbSize;
11322    if (maxSbPerUe == 0)
11323    {
11324       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
11325          "maxUlBwPerUe/sbSize is zero");
11326       RETVALUE(RFAILED);
11327    }
11328    cellUl->maxSbPerUe = rgSchCmnMult235Tbl[maxSbPerUe].prvMatch;
11329
11330    /* CQI related updations */
11331    if ((!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->ulCmnCodeRate.ccchCqi))
11332          || (!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->trgUlCqi.trgCqi)))
11333    {
11334       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
11335          "Invalid cqi");
11336       RETVALUE(RFAILED);
11337    }
11338    cellUl->dfltUlCqi = cellCfg->ulCmnCodeRate.ccchCqi;
11339
11340    /* Changed the logic to determine maxUlCqi.
11341     * For a 16qam UE, maxUlCqi is the CQI Index at which
11342     * efficiency is as close as possible to RG_SCH_MAX_CODE_RATE_16QAM
11343     * Refer to 36.213-8.6.1 */
11344     for (i = RG_SCH_CMN_UL_NUM_CQI - 1;i > 0; --i)
11345    {
11346       RLOG_ARG2(L_INFO,DBG_CELLID,cell->cellId,
11347             "CQI %u:iTbs %u",
11348             i, 
11349             rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i]);
11350 #ifdef MAC_SCH_STATS
11351       /* ccpu00128489 ADD Update mcs in hqFailStats here instead of at CRC 
11352        * since CQI to MCS mapping does not change. The only exception is for 
11353        * ITBS = 19 where the MCS can be 20 or 21 based on the UE cat. We 
11354        * choose 20, instead of 21, ie UE_CAT_3 */
11355       iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
11356       RG_SCH_CMN_UL_TBS_TO_MCS(iTbs, hqFailStats.ulCqiStat[i - 1].mcs);
11357 #endif
11358    }
11359    for (i = RG_SCH_CMN_UL_NUM_CQI - 1; i != 0; --i)
11360    {
11361       /* Fix for ccpu00123912*/
11362       iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
11363       if (iTbs <= RGSCH_UL_16QAM_MAX_ITBS) /* corresponds to 16QAM */
11364       {
11365          RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,
11366                          "16 QAM CQI %u", i);
11367          cellUl->max16qamCqi = i;
11368          break;
11369       }
11370    }
11371
11372 #ifdef EMTC_ENABLE
11373    /* Precompute useful values for RA msg3 */
11374    ret = rgSCHCmnPrecompEmtcMsg3Vars(cellUl, cellCfg->ulCmnCodeRate.ccchCqi,
11375          cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
11376    if (ret != ROK)
11377    {
11378       RETVALUE(ret);
11379    }
11380 #endif   
11381
11382    /* Precompute useful values for RA msg3 */
11383    ret = rgSCHCmnPrecompMsg3Vars(cellUl, cellCfg->ulCmnCodeRate.ccchCqi,
11384          cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
11385    if (ret != ROK)
11386    {
11387       RETVALUE(ret);
11388    }
11389
11390    cellUl->sbSize  = sbSize;
11391    
11392 #ifdef LTE_TDD  
11393    cellUl->numUlSubfrms = maxSubfrms;
11394
11395    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cellUl->ulSfArr,
11396             cellUl->numUlSubfrms * sizeof(RgSchUlSf));
11397
11398    if (ret != ROK)
11399    {
11400       cellUl->numUlSubfrms = 0;
11401       RETVALUE(ret);
11402    }
11403
11404    /* store the DL subframe corresponding to the PUSCH offset
11405     * in their respective UL subframe */
11406    for(i=0; i < RGSCH_NUM_SUB_FRAMES; i++)
11407    {
11408       if(rgSchTddPuschTxKTbl[ulDlCfgIdx][i] != 0)
11409       {
11410          subfrm = (i + rgSchTddPuschTxKTbl[ulDlCfgIdx][i]) % \
11411                                  RGSCH_NUM_SUB_FRAMES;
11412          subfrm = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subfrm]-1;
11413          dlIdx = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][i]-1;
11414          RGSCH_ARRAY_BOUND_CHECK( cell->instIdx, ulToDlMap, subfrm);
11415          ulToDlMap[subfrm] = dlIdx;
11416       }
11417    }
11418    /* Copy the information in the remaining UL subframes based
11419     * on number of HARQ processes */
11420    for(i=maxUlsubfrms; i < maxSubfrms; i++)
11421    {
11422       subfrm = i-maxUlsubfrms;
11423       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, ulToDlMap, i);
11424       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, ulToDlMap, subfrm)
11425       ulToDlMap[i] = ulToDlMap[subfrm];
11426    }
11427 #endif
11428
11429    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++)
11430    {
11431 #ifdef LTE_TDD        
11432       ret = rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, &rbStart, &bwAvail); 
11433 #else
11434       ret = rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, &rbStart, &bwAvail); 
11435 #endif
11436       if (ret != ROK)
11437       {
11438          RETVALUE(ret);
11439       }
11440
11441       if (cfi == 1)
11442       {
11443          cell->ulAvailBw = bwAvail;
11444       }
11445
11446       numSb = bwAvail/sbSize; 
11447
11448       cell->dynCfiCb.bwInfo[cfi].startRb  = rbStart;
11449       cell->dynCfiCb.bwInfo[cfi].numSb    = numSb;
11450    }
11451
11452    if(0 == cell->dynCfiCb.maxCfi)
11453    {
11454       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId, 
11455                "Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
11456                cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi, 
11457                cell->pucchCfg.maxPucchRb);
11458             
11459       RETVALUE(RFAILED);
11460    }
11461
11462    /* DMRS values */
11463    cellUl->dmrsArrSize = cell->dynCfiCb.bwInfo[1].numSb;
11464    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cellUl->dmrsArr,
11465          cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11466    if (ret != ROK)
11467    {
11468       RETVALUE(ret);
11469    }
11470    for (i = 0; i < cellUl->dmrsArrSize; ++i)
11471    {
11472       cellUl->dmrsArr[i] = cellCfg->puschSubBand.dmrs[i];
11473    }
11474  
11475    /* Init subframes */
11476    for (i = 0; i < maxSubfrms; ++i)
11477    {
11478       ret = rgSCHUtlUlSfInit(cell, &cellUl->ulSfArr[i], i,
11479                              cellUl->maxAllocPerUlSf);
11480       if (ret != ROK)
11481       {
11482          for (; i != 0; --i)
11483          {
11484             rgSCHUtlUlSfDeinit(cell, &cellUl->ulSfArr[i-1]);
11485          }
11486          /* ccpu00117052 - MOD - Passing double pointer
11487             for proper NULLP assignment*/
11488          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(cellUl->dmrsArr)),
11489                cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11490 #ifdef LTE_TDD
11491          /* ccpu00117052 - MOD - Passing double pointer
11492             for proper NULLP assignment*/
11493          rgSCHUtlFreeSBuf(cell->instIdx,
11494             (Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
11495 #endif
11496          RETVALUE(ret);
11497       }
11498    }
11499    RG_SCH_RESET_HCSG_UL_PRB_CNTR(cellUl);
11500    RETVALUE(ROK);
11501 }
11502
11503 /**
11504  * @brief Scheduler processing on cell configuration.
11505  *
11506  * @details
11507  *
11508  *     Function : rgSCHCmnRgrCellCfg
11509  *
11510  *     This function does requisite initialisation
11511  *     and setup for scheduler1 when a cell is
11512  *     configured.
11513  *
11514  *  @param[in]  RgSchCellCb   *cell
11515  *  @param[in]  RgrCellCfg    *cellCfg
11516  *  @param[out] RgSchErrInfo  *err
11517  *  @return  S16
11518  *      -# ROK
11519  *      -# RFAILED
11520  **/
11521 #ifdef ANSI
11522 PUBLIC S16 rgSCHCmnRgrCellCfg
11523 (
11524 RgSchCellCb   *cell,
11525 RgrCellCfg    *cellCfg,
11526 RgSchErrInfo  *err
11527 )
11528 #else
11529 PUBLIC S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
11530 RgSchCellCb   *cell;
11531 RgrCellCfg    *cellCfg;
11532 RgSchErrInfo  *err;
11533 #endif
11534 {
11535    S16       ret;
11536    RgSchCmnCell *cellSch;
11537    TRC2(rgSCHCmnRgrCellCfg);
11538
11539    /* As part of RGR cell configuration, validate the CRGCellCfg
11540     * There is no trigger for crgCellCfg from SC1 */
11541    /* Removed failure check for Extended CP */
11542
11543    if (((ret = rgSCHUtlAllocSBuf(cell->instIdx,
11544       (Data**)&(cell->sc.sch), (sizeof(RgSchCmnCell)))) != ROK))
11545    {
11546       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  
11547          "Memory allocation FAILED");
11548       err->errCause = RGSCHERR_SCH_CFG;
11549       RETVALUE(ret);
11550    }
11551    cellSch = (RgSchCmnCell *)(cell->sc.sch);
11552    cellSch->cfiCfg = cellCfg->cfiCfg;
11553    cellSch->trgUlCqi.trgCqi = cellCfg->trgUlCqi.trgCqi;
11554    /* Initialize the scheduler refresh timer queues */
11555    cellSch->tmrTqCp.nxtEnt = 0;
11556    cellSch->tmrTqCp.tmrLen = RG_SCH_CMN_NUM_REFRESH_Q;
11557
11558    /* RACHO Intialize the RACH ded Preamble Information */
11559    rgSCHCmnCfgRachDedPrm(cell);
11560 #ifdef LTE_TDD
11561    /* Initialize 'Np' value for each 'p' used for
11562     * HARQ ACK/NACK reception */
11563    rgSCHCmnDlNpValInit(cell);
11564 #endif
11565
11566    /* Initialize 'Np' value for each 'p' used for
11567     * HARQ ACK/NACK reception */
11568 #ifdef LTE_TDD
11569    rgSCHCmnDlNpValInit(cell);
11570 #endif
11571
11572    /* Now perform uplink related initializations  */
11573    ret = rgSCHCmnUlCellInit(cell, cellCfg);
11574    if (ret != ROK)
11575    {
11576       /* There is no downlink deinit to be performed */
11577       err->errCause = RGSCHERR_SCH_CFG;
11578       RETVALUE(ret);
11579    }
11580    ret = rgSCHCmnDlRgrCellCfg(cell, cellCfg, err);
11581    if (ret != ROK)
11582    {
11583       err->errCause = RGSCHERR_SCH_CFG;
11584       RETVALUE(ret);
11585    }
11586    /* DL scheduler has no initializations to make */
11587    /* As of now DL scheduler always returns ROK   */
11588
11589    rgSCHCmnGetDciFrmtSizes(cell);
11590    rgSCHCmnGetCqiDciFrmt2AggrLvl(cell);
11591 #ifdef EMTC_ENABLE 
11592    rgSCHCmnGetEmtcDciFrmtSizes(cell);
11593    rgSCHCmnGetCqiEmtcDciFrmt2AggrLvl(cell);
11594 #endif /* EMTC_ENABLE  */
11595
11596 #ifdef EMTC_ENABLE   
11597    if(TRUE == cellCfg->emtcEnable)
11598    {
11599       cellSch->apisEmtcUl = &rgSchEmtcUlSchdTbl[0];
11600       ret = cellSch->apisEmtcUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
11601       if (ret != ROK)
11602       {
11603          RETVALUE(ret);
11604       }
11605    }
11606 #endif
11607    cellSch->apisUl = &rgSchUlSchdTbl[RG_SCH_CMN_GET_UL_SCHED_TYPE(cell)];
11608    ret = cellSch->apisUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
11609    if (ret != ROK)
11610    {
11611       RETVALUE(ret);
11612    }
11613 #ifdef EMTC_ENABLE   
11614    if(TRUE == cellCfg->emtcEnable)
11615    {
11616       cellSch->apisEmtcDl = &rgSchEmtcDlSchdTbl[0];
11617       ret = cellSch->apisEmtcDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
11618       if (ret != ROK)
11619       {
11620          RETVALUE(ret);
11621       }
11622    }
11623 #endif
11624    cellSch->apisDl = &rgSchDlSchdTbl[RG_SCH_CMN_GET_DL_SCHED_TYPE(cell)];
11625 #ifdef LTEMAC_SPS
11626    /* Perform SPS specific initialization for the cell */
11627    ret = rgSCHCmnSpsCellCfg(cell, cellCfg, err);
11628    if (ret != ROK)
11629    {
11630       RETVALUE(ret);
11631    }
11632 #endif
11633    ret = cellSch->apisDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
11634    if (ret != ROK)
11635    {
11636       RETVALUE(ret);
11637    }
11638    rgSCHCmnInitVars(cell);
11639
11640    RETVALUE(ROK);
11641 }  /* rgSCHCmnRgrCellCfg*/
11642
11643 \f
11644 /**
11645  * @brief This function handles the reconfiguration of cell.
11646  *
11647  * @details
11648  *
11649  *     Function: rgSCHCmnRgrCellRecfg
11650  *     Purpose:  Update the reconfiguration parameters.
11651  *
11652  *     Invoked by: Scheduler
11653  *
11654  *  @param[in]  RgSchCellCb*  cell
11655  *  @return  Void
11656  *
11657  **/
11658 #ifdef ANSI
11659 PUBLIC S16 rgSCHCmnRgrCellRecfg
11660 (
11661 RgSchCellCb             *cell,
11662 RgrCellRecfg            *recfg,
11663 RgSchErrInfo            *err
11664 )
11665 #else
11666 PUBLIC S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
11667 RgSchCellCb             *cell;
11668 RgrCellRecfg            *recfg;
11669 RgSchErrInfo            *err;
11670 #endif
11671 {
11672    S16                  ret;
11673    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
11674    RgSchCmnUlCell       *cellUl  = RG_SCH_CMN_GET_UL_CELL(cell);
11675
11676    TRC2(rgSCHCmnRgrCellRecfg);
11677
11678    if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
11679    {
11680       U8   oldCqi = cellUl->dfltUlCqi;
11681       if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
11682       {
11683          err->errCause = RGSCHERR_SCH_CFG;
11684          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
11685             "Invalid cqi");
11686          RETVALUE(RFAILED);
11687       }
11688       cellUl->dfltUlCqi = recfg->ulCmnCodeRate.ccchCqi;
11689       ret = rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
11690             cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
11691       if (ret != ROK)
11692       {
11693          cellUl->dfltUlCqi = oldCqi;
11694          rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
11695                cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
11696          RETVALUE(ret);
11697       }
11698    }
11699
11700    if (recfg->recfgTypes & RGR_CELL_DL_CMNRATE_RECFG)
11701    {
11702       if (rgSCHCmnDlCnsdrCmnRt(cell, &recfg->dlCmnCodeRate) != ROK)
11703       {
11704          err->errCause = RGSCHERR_SCH_CFG;
11705          RETVALUE(RFAILED);
11706       }
11707    }
11708  
11709 #ifdef EMTC_ENABLE  
11710    if(TRUE == cell->emtcEnable) 
11711    {
11712       /* Invoke UL sched for cell Recfg */
11713       ret = cellSch->apisEmtcUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
11714       if (ret != ROK)
11715       {
11716          RETVALUE(RFAILED);
11717       }
11718
11719       /* Invoke DL sched for cell Recfg */
11720       ret = cellSch->apisEmtcDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
11721       if (ret != ROK)
11722       {
11723          RETVALUE(RFAILED);
11724       }
11725    }
11726    else
11727 #endif
11728    {
11729    /* Invoke UL sched for cell Recfg */
11730    ret = cellSch->apisUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
11731    if (ret != ROK)
11732    {
11733       RETVALUE(RFAILED);
11734    }
11735
11736    /* Invoke DL sched for cell Recfg */
11737    ret = cellSch->apisDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
11738    if (ret != ROK)
11739    {
11740       RETVALUE(RFAILED);
11741    }
11742    }
11743
11744    if (recfg->recfgTypes & RGR_CELL_DLFS_RECFG)
11745    {
11746       ret = cellSch->apisDlfs->rgSCHDlfsCellRecfg(cell, recfg, err);
11747       if (ret != ROK)
11748       {
11749          RETVALUE(RFAILED);
11750       }
11751       cellSch->dl.isDlFreqSel = recfg->dlfsRecfg.isDlFreqSel;
11752    }
11753
11754    if (recfg->recfgTypes & RGR_CELL_PWR_RECFG)
11755    {
11756       ret = rgSCHPwrCellRecfg(cell, recfg);
11757       if (ret != ROK)
11758       {
11759          RETVALUE(RFAILED);
11760       }
11761    }
11762
11763    RETVALUE(ROK);
11764 }
11765
11766 /***********************************************************
11767  *
11768  *     Func : rgSCHCmnUlCellDeinit
11769  *
11770  *     Desc : Uplink scheduler de-initialisation for cell.
11771  *
11772  *     Ret  : S16
11773  *
11774  *     Notes:
11775  *
11776  *     File :
11777  *
11778  **********************************************************/
11779 #ifdef ANSI
11780 PRIVATE Void rgSCHCmnUlCellDeinit
11781 (
11782 RgSchCellCb *cell
11783 )
11784 #else
11785 PRIVATE Void rgSCHCmnUlCellDeinit(cell)
11786 RgSchCellCb *cell;
11787 #endif
11788 {
11789    RgSchCmnUlCell   *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
11790    U8               ulSfIdx;
11791 #ifdef LTE_TDD
11792    U8        maxSubfrms = cellUl->numUlSubfrms;
11793 #endif
11794 #ifdef LTE_L2_MEAS
11795    CmLList       *lnk = NULLP;
11796    RgSchL2MeasCb *measCb;
11797 #endif
11798    TRC2(rgSCHCmnUlCellDeinit);
11799 #ifdef LTE_L2_MEAS
11800 #ifdef LTE_TDD
11801    for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
11802 #else
11803    for(ulSfIdx = 0; ulSfIdx < RGSCH_NUM_SUB_FRAMES; ulSfIdx++)
11804 #endif
11805    {
11806       if(cell->sfAllocArr[ulSfIdx].ulUeInfo.ulAllocInfo != NULLP)
11807       {
11808          /* ccpu00117052 - MOD - Passing double pointer
11809             for proper NULLP assignment*/
11810          rgSCHUtlFreeSBuf(cell->instIdx,
11811          (Data **)(&(cell->sfAllocArr[ulSfIdx].ulUeInfo.ulAllocInfo)),
11812          cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc));
11813
11814          /* ccpu00117052 - DEL - removed explicit NULLP assignment
11815             as it is done in above utility function */
11816       }
11817    }
11818    /* Free the memory allocated to measCb */
11819    lnk = cell->l2mList.first;
11820    while(lnk != NULLP)
11821    {
11822       measCb = (RgSchL2MeasCb *)lnk->node;
11823       cmLListDelFrm(&cell->l2mList, lnk);
11824       lnk = lnk->next;
11825    /* ccpu00117052 - MOD - Passing double pointer
11826    for proper NULLP assignment*/
11827       rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,\
11828                           sizeof(RgSchL2MeasCb));
11829    }
11830 #endif
11831    if (cellUl->dmrsArr != NULLP)
11832    {
11833       /* ccpu00117052 - MOD - Passing double pointer
11834       for proper NULLP assignment*/
11835       rgSCHUtlFreeSBuf(cell->instIdx,(Data **)(&(cellUl->dmrsArr)),
11836                cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11837    }
11838    /* De-init subframes */
11839 #ifdef LTE_TDD
11840    for (ulSfIdx = 0; ulSfIdx < maxSubfrms; ++ulSfIdx)
11841 #else
11842    for (ulSfIdx = 0; ulSfIdx < RG_SCH_CMN_UL_NUM_SF; ++ulSfIdx)
11843 #endif
11844    {
11845       rgSCHUtlUlSfDeinit(cell, &cellUl->ulSfArr[ulSfIdx]);
11846    }
11847
11848 #ifdef LTE_TDD
11849    if (cellUl->ulSfArr != NULLP)
11850    {
11851       /* ccpu00117052 - MOD - Passing double pointer
11852       for proper NULLP assignment*/
11853       rgSCHUtlFreeSBuf(cell->instIdx,
11854          (Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
11855    }
11856 #endif
11857
11858    RETVOID;
11859 }
11860
11861 /**
11862  * @brief Scheduler processing for cell delete.
11863  *
11864  * @details
11865  *
11866  *     Function : rgSCHCmnCellDel
11867  *
11868  *     This functions de-initialises and frees memory
11869  *     taken up by scheduler1 for the entire cell.
11870  *
11871  *  @param[in]  RgSchCellCb  *cell
11872  *  @return  Void
11873  **/
11874 #ifdef ANSI
11875 PUBLIC Void rgSCHCmnCellDel
11876 (
11877 RgSchCellCb  *cell
11878 )
11879 #else
11880 PUBLIC Void rgSCHCmnCellDel(cell)
11881 RgSchCellCb  *cell;
11882 #endif
11883 {
11884    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
11885    TRC2(rgSCHCmnCellDel);
11886
11887 #ifdef LTE_L2_MEAS
11888    glblTtiCnt = 0;
11889 #endif
11890    if (cellSch == NULLP)
11891    {
11892       RETVOID;
11893    }
11894    /* Perform the deinit for the UL scheduler */
11895    rgSCHCmnUlCellDeinit(cell);
11896 #ifdef EMTC_ENABLE
11897    if(TRUE == cell->emtcEnable)
11898    {
11899       if (cellSch->apisEmtcUl)
11900       {
11901          cellSch->apisEmtcUl->rgSCHFreeUlCell(cell);
11902       }
11903    }
11904 #endif 
11905    if (cellSch->apisUl)
11906    {
11907       /* api pointer checks added (here and below in
11908        * this function). pl check. - antriksh */
11909       cellSch->apisUl->rgSCHFreeUlCell(cell);
11910    }
11911
11912    /* Perform the deinit for the DL scheduler */
11913    cmLListInit(&cellSch->dl.taLst);
11914    if (cellSch->apisDl)
11915    {
11916       cellSch->apisDl->rgSCHFreeDlCell(cell);
11917    }
11918 #ifdef EMTC_ENABLE
11919    if (cellSch->apisEmtcDl)
11920    {
11921       rgSCHEmtcInitTaLst(&cellSch->dl);
11922
11923       cellSch->apisEmtcDl->rgSCHFreeDlCell(cell);
11924    }
11925 #endif
11926
11927    /* DLFS de-initialization */
11928    if (cellSch->dl.isDlFreqSel && cellSch->apisDlfs)
11929    {
11930       cellSch->apisDlfs->rgSCHDlfsCellDel(cell);
11931    }
11932
11933    rgSCHPwrCellDel(cell);
11934 #ifdef LTEMAC_SPS
11935    rgSCHCmnSpsCellDel(cell);
11936 #endif
11937
11938    /* ccpu00117052 - MOD - Passing double pointer
11939    for proper NULLP assignment*/
11940    rgSCHUtlFreeSBuf(cell->instIdx,
11941       (Data**)(&(cell->sc.sch)), (sizeof(RgSchCmnCell)));
11942    RETVOID;
11943 }  /* rgSCHCmnCellDel */
11944
11945 \f
11946 /**
11947  * @brief This function validates QOS parameters for DL.
11948  *
11949  * @details
11950  *
11951  *     Function: rgSCHCmnValidateDlQos
11952  *     Purpose:  This function validates QOS parameters for DL.
11953  *
11954  *     Invoked by: Scheduler
11955  *
11956  *  @param[in] CrgLchQosCfg    *dlQos
11957  *  @return                    S16
11958  *
11959  **/
11960 #ifdef ANSI
11961 PRIVATE S16 rgSCHCmnValidateDlQos
11962 (
11963 RgrLchQosCfg            *dlQos
11964 )
11965 #else
11966 PRIVATE S16 rgSCHCmnValidateDlQos(dlQos)
11967 RgrLchQosCfg            *dlQos;
11968 #endif
11969 {
11970    U8 qci = dlQos->qci;
11971
11972    TRC2(rgSCHCmnValidateDlQos);
11973
11974    if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
11975    {
11976       RETVALUE(RFAILED);
11977    }
11978
11979    if ((qci >= RG_SCH_CMN_GBR_QCI_START) &&
11980        (qci <= RG_SCH_CMN_GBR_QCI_END))
11981    {
11982       if ((dlQos->mbr == 0) || (dlQos->mbr < dlQos->gbr))
11983       {
11984          RETVALUE(RFAILED);
11985       }
11986    }
11987    RETVALUE(ROK);
11988 }
11989
11990 /**
11991  * @brief Scheduler invocation on logical channel addition.
11992  *
11993  * @details
11994  *
11995  *     Function : rgSCHCmnRgrLchCfg
11996  *
11997  *     This functions does required processing when a new
11998  *     (dedicated) logical channel is added. Assumes lcg
11999  *     pointer in ulLc is set.
12000  *
12001  *  @param[in]  RgSchCellCb  *cell
12002  *  @param[in]  RgSchUeCb    *ue
12003  *  @param[in]  RgSchDlLcCb  *dlLc
12004  *  @param[int] RgrLchCfg    *lcCfg
12005  *  @param[out] RgSchErrInfo *err
12006  *  @return  S16
12007  *      -# ROK
12008  *      -# RFAILED
12009  **/
12010 #ifdef ANSI
12011 PUBLIC S16 rgSCHCmnRgrLchCfg
12012 (
12013 RgSchCellCb  *cell,
12014 RgSchUeCb    *ue,
12015 RgSchDlLcCb  *dlLc,
12016 RgrLchCfg *lcCfg,
12017 RgSchErrInfo *err
12018 )
12019 #else
12020 PUBLIC S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
12021 RgSchCellCb  *cell;
12022 RgSchUeCb    *ue;
12023 RgSchDlLcCb  *dlLc;
12024 RgrLchCfg *lcCfg;
12025 RgSchErrInfo *err;
12026 #endif
12027 {
12028    S16 ret;
12029
12030    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12031
12032    TRC2(rgSCHCmnRgrLchCfg);
12033
12034    ret = rgSCHUtlAllocSBuf(cell->instIdx,
12035       (Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
12036    if (ret != ROK)
12037    {
12038       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
12039          "SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12040       err->errCause = RGSCHERR_SCH_CFG;
12041       RETVALUE(ret);
12042    }
12043    if(lcCfg->lcType != CM_LTE_LCH_DCCH)
12044    {
12045       ret = rgSCHCmnValidateDlQos(&lcCfg->dlInfo.dlQos);
12046       if (ret != ROK)
12047       {
12048          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
12049             "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12050          err->errCause = RGSCHERR_SCH_CFG;
12051          RETVALUE(ret);
12052       }
12053       /* Perform DL service activation in the scheduler */
12054       ((RgSchCmnDlSvc *)(dlLc->sch))->qci = lcCfg->dlInfo.dlQos.qci;
12055       ((RgSchCmnDlSvc *)(dlLc->sch))->prio = rgSchCmnDlQciPrio[lcCfg->dlInfo.dlQos.qci - 1];
12056       ((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcCfg->dlInfo.dlQos.gbr * \
12057       RG_SCH_CMN_REFRESH_TIME)/100;
12058       ((RgSchCmnDlSvc *)(dlLc->sch))->mbr = (lcCfg->dlInfo.dlQos.mbr * \
12059       RG_SCH_CMN_REFRESH_TIME)/100;
12060    }
12061    else
12062    {
12063      /*assigning highest priority to DCCH */
12064     ((RgSchCmnDlSvc *)(dlLc->sch))->prio=RG_SCH_CMN_DCCH_PRIO; 
12065    }   
12066    dlLc->ue = ue;
12067    dlLc->lcType=lcCfg->lcType;
12068
12069 #ifdef EMTC_ENABLE
12070    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12071    {
12072       ret = cellSch->apisEmtcDl->rgSCHRgrDlLcCfg(cell, ue,dlLc ,lcCfg, err);
12073       if (ret != ROK)
12074       {
12075          RETVALUE(RFAILED);
12076       }
12077    }
12078    else
12079 #endif 
12080    {
12081       ret = cellSch->apisDl->rgSCHRgrDlLcCfg(cell, ue, dlLc, lcCfg, err);
12082       if (ret != ROK)
12083       {
12084          RETVALUE(RFAILED);
12085       }
12086    }
12087    
12088 #ifdef EMTC_ENABLE
12089    if(TRUE == ue->isEmtcUe)
12090    {
12091       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
12092       if (ret != ROK)
12093       {
12094          RETVALUE(RFAILED);
12095       }
12096    }
12097    else
12098 #endif 
12099    {
12100    ret = cellSch->apisUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
12101    if (ret != ROK)
12102    {
12103       RETVALUE(RFAILED);
12104    }
12105    }
12106    
12107 #ifdef LTE_ADV
12108    if (ue->numSCells)
12109    {
12110       rgSCHSCellDlLcCfg(cell, ue, dlLc);
12111    }
12112 #endif
12113
12114
12115 #ifdef LTEMAC_SPS
12116    if(lcCfg->dlInfo.dlSpsCfg.isSpsEnabled)
12117    {
12118       /* Invoke SPS module if SPS is enabled for the service */
12119       ret = rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err);
12120       if (ret != ROK)
12121       {
12122          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "rgSchCmnRgrLchCfg(): "
12123             "SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12124          err->errCause = RGSCHERR_SCH_CFG;
12125          RETVALUE(RFAILED);
12126       }
12127    }
12128 #endif
12129
12130    RETVALUE(ROK);
12131 }
12132
12133 /**
12134  * @brief Scheduler invocation on logical channel addition.
12135  *
12136  * @details
12137  *
12138  *     Function : rgSCHCmnRgrLchRecfg
12139  *
12140  *     This functions does required processing when an existing
12141  *     (dedicated) logical channel is reconfigured. Assumes lcg
12142  *     pointer in ulLc is set to the old value.
12143  *     Independent of whether new LCG is meant to be configured,
12144  *     the new LCG scheduler information is accessed and possibly modified.
12145  *
12146  *  @param[in]  RgSchCellCb  *cell
12147  *  @param[in]  RgSchUeCb    *ue
12148  *  @param[in]  RgSchDlLcCb  *dlLc
12149  *  @param[int] RgrLchRecfg  *lcRecfg
12150  *  @param[out] RgSchErrInfo *err
12151  *  @return  S16
12152  *      -# ROK
12153  *      -# RFAILED
12154  **/
12155 #ifdef ANSI
12156 PUBLIC S16 rgSCHCmnRgrLchRecfg
12157 (
12158 RgSchCellCb  *cell,
12159 RgSchUeCb    *ue,
12160 RgSchDlLcCb  *dlLc,
12161 RgrLchRecfg  *lcRecfg,
12162 RgSchErrInfo *err
12163 )
12164 #else
12165 PUBLIC S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
12166 RgSchCellCb  *cell;
12167 RgSchUeCb    *ue;
12168 RgSchDlLcCb  *dlLc;
12169 RgrLchRecfg  *lcRecfg;
12170 RgSchErrInfo *err;
12171 #endif
12172 {
12173    S16   ret;
12174    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12175
12176    TRC2(rgSCHCmnRgrLchRecfg)
12177
12178    if(dlLc->lcType != CM_LTE_LCH_DCCH)
12179    {
12180       ret = rgSCHCmnValidateDlQos(&lcRecfg->dlRecfg.dlQos);
12181    
12182       if (ret != ROK)
12183       {
12184          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
12185                "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12186          err->errCause = RGSCHERR_SCH_CFG;
12187          RETVALUE(ret);
12188       }
12189       if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
12190       {
12191          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
12192             "not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12193          err->errCause = RGSCHERR_SCH_CFG;
12194          RETVALUE(ret);
12195       }
12196       ((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcRecfg->dlRecfg.dlQos.gbr * \
12197       RG_SCH_CMN_REFRESH_TIME)/100;
12198       ((RgSchCmnDlSvc *)(dlLc->sch))->mbr = (lcRecfg->dlRecfg.dlQos.mbr * \
12199       RG_SCH_CMN_REFRESH_TIME)/100;
12200    }
12201    else
12202    {
12203       /*assigning highest priority to DCCH */
12204       ((RgSchCmnDlSvc *)(dlLc->sch))->prio = RG_SCH_CMN_DCCH_PRIO; 
12205    }
12206    
12207 #ifdef EMTC_ENABLE
12208    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12209    {
12210       ret = cellSch->apisEmtcDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12211       if (ret != ROK)
12212       {
12213          RETVALUE(RFAILED);
12214       }
12215       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
12216       if (ret != ROK)
12217       {
12218          RETVALUE(RFAILED);
12219       }
12220    }
12221    else
12222 #endif 
12223    {
12224    ret = cellSch->apisDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12225    if (ret != ROK)
12226    {
12227       RETVALUE(RFAILED);
12228    }
12229    ret = cellSch->apisUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
12230    if (ret != ROK)
12231    {
12232       RETVALUE(RFAILED);
12233    }
12234    }
12235     
12236 #ifdef LTEMAC_SPS
12237    if (lcRecfg->recfgTypes & RGR_DL_LC_SPS_RECFG)
12238    {
12239       /* Invoke SPS module if SPS is enabled for the service */
12240       if(lcRecfg->dlRecfg.dlSpsRecfg.isSpsEnabled)
12241       {
12242          ret = rgSCHCmnSpsDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12243          if (ret != ROK)
12244          {
12245             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"SPS re-configuration not "
12246                   "supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12247          }
12248       }
12249       RETVALUE(ROK);
12250    }
12251 #endif
12252
12253    RETVALUE(ROK);
12254 }
12255
12256 /**
12257  * @brief Scheduler invocation on logical channel addition.
12258  *
12259  * @details
12260  *
12261  *     Function : rgSCHCmnRgrLcgCfg
12262  *
12263  *     This functions does required processing when a new
12264  *     (dedicated) logical channel is added. Assumes lcg
12265  *     pointer in ulLc is set.
12266  *
12267  *  @param[in]  RgSchCellCb  *cell,
12268  *  @param[in]  RgSchUeCb    *ue,
12269  *  @param[in]  RgSchLcgCb   *lcg,
12270  *  @param[in]  RgrLcgCfg    *lcgCfg,
12271  *  @param[out] RgSchErrInfo *err
12272  *  @return  S16
12273  *      -# ROK
12274  *      -# RFAILED
12275  **/
12276 #ifdef ANSI
12277 PUBLIC S16 rgSCHCmnRgrLcgCfg
12278 (
12279 RgSchCellCb  *cell,
12280 RgSchUeCb    *ue,
12281 RgSchLcgCb   *lcg,
12282 RgrLcgCfg    *lcgCfg,
12283 RgSchErrInfo *err
12284 )
12285 #else
12286 PUBLIC S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
12287 RgSchCellCb  *cell;
12288 RgSchUeCb    *ue;
12289 RgSchLcgCb   *lcg;
12290 RgrLcgCfg    *lcgCfg;
12291 RgSchErrInfo *err;
12292 #endif
12293 {
12294    S16 ret;
12295    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12296    RgSchCmnLcg  *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
12297
12298    TRC2(rgSCHCmnRgrLcgCfg);
12299
12300    ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
12301    ulLcg->effGbr  = ulLcg->cfgdGbr;
12302    ulLcg->deltaMbr = ((lcgCfg->ulInfo.mbr - lcgCfg->ulInfo.gbr) * RG_SCH_CMN_REFRESH_TIME)/100;
12303    ulLcg->effDeltaMbr = ulLcg->deltaMbr;
12304
12305 #ifdef EMTC_ENABLE
12306    if(TRUE == ue->isEmtcUe)
12307    {
12308       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
12309       if (ret != ROK)
12310       {
12311          RETVALUE(RFAILED);
12312       }
12313    }
12314    else
12315 #endif
12316    {
12317    ret = cellSch->apisUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
12318    if (ret != ROK)
12319    {
12320       RETVALUE(RFAILED);
12321    }
12322    }
12323    if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
12324    {
12325       /* Indicate MAC that this LCG is GBR LCG */
12326       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcgCfg->ulInfo.lcgId, TRUE);
12327    }
12328    RETVALUE(ROK);
12329 }
12330
12331 /**
12332  * @brief Scheduler invocation on logical channel addition.
12333  *
12334  * @details
12335  *
12336  *     Function : rgSCHCmnRgrLcgRecfg
12337  *
12338  *     This functions does required processing when a new
12339  *     (dedicated) logical channel is added. Assumes lcg
12340  *     pointer in ulLc is set.
12341  *
12342  *  @param[in]  RgSchCellCb  *cell,
12343  *  @param[in]  RgSchUeCb    *ue,
12344  *  @param[in]  RgSchLcgCb   *lcg,
12345  *  @param[in]  RgrLcgRecfg  *reCfg,
12346  *  @param[out] RgSchErrInfo *err
12347  *  @return  S16
12348  *      -# ROK
12349  *      -# RFAILED
12350  **/
12351 #ifdef ANSI
12352 PUBLIC S16 rgSCHCmnRgrLcgRecfg
12353 (
12354 RgSchCellCb  *cell,
12355 RgSchUeCb    *ue,
12356 RgSchLcgCb   *lcg,
12357 RgrLcgRecfg  *reCfg,
12358 RgSchErrInfo *err
12359 )
12360 #else
12361 PUBLIC S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
12362 RgSchCellCb  *cell;
12363 RgSchUeCb    *ue;
12364 RgSchLcgCb   *lcg;
12365 RgrLcgRecfg  *reCfg;
12366 RgSchErrInfo *err;
12367 #endif
12368 {
12369    S16 ret;
12370    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12371    RgSchCmnLcg  *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
12372    
12373    TRC2(rgSCHCmnRgrLcgRecfg);
12374
12375    ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
12376    ulLcg->effGbr  = ulLcg->cfgdGbr;
12377    ulLcg->deltaMbr = ((reCfg->ulRecfg.mbr - reCfg->ulRecfg.gbr) * RG_SCH_CMN_REFRESH_TIME)/100;
12378    ulLcg->effDeltaMbr = ulLcg->deltaMbr;
12379  
12380 #ifdef EMTC_ENABLE
12381    if(TRUE == ue->isEmtcUe)
12382    {
12383       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
12384       if (ret != ROK)
12385       {
12386          RETVALUE(RFAILED);
12387       }
12388    }
12389    else
12390 #endif
12391    {
12392    ret = cellSch->apisUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
12393    if (ret != ROK)
12394    {
12395       RETVALUE(RFAILED);
12396    }
12397    }
12398    if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
12399    {
12400       /* Indicate MAC that this LCG is GBR LCG */
12401       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, TRUE);
12402    }
12403    else
12404    {
12405       /* In case of RAB modification */
12406       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, FALSE);
12407    }
12408    RETVALUE(ROK);
12409 }
12410
12411 /***********************************************************
12412  *
12413  *     Func : rgSCHCmnRgrLchDel
12414  *
12415  *     Desc : Scheduler handling for a (dedicated)
12416  *             uplink logical channel being deleted.
12417  *
12418  *     Ret  :
12419  *
12420  *     Notes:
12421  *
12422  *     File :
12423  **********************************************************/
12424 #ifdef ANSI
12425 PUBLIC S16 rgSCHCmnRgrLchDel 
12426 (
12427 RgSchCellCb   *cell,
12428 RgSchUeCb     *ue,
12429 CmLteLcId     lcId,
12430 U8            lcgId
12431 )
12432 #else
12433 PUBLIC S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
12434 RgSchCellCb   *cell;
12435 RgSchUeCb     *ue;
12436 CmLteLcId     lcId;
12437 U8            lcgId;
12438 #endif
12439 {
12440    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12441    TRC2(rgSCHCmnRgrLchDel);
12442 #ifdef EMTC_ENABLE
12443    if(TRUE == ue->isEmtcUe)
12444    {
12445       cellSch->apisEmtcUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
12446    }
12447    else
12448 #endif
12449    {
12450    cellSch->apisUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
12451    }
12452    RETVALUE(ROK);
12453 }
12454
12455 /***********************************************************
12456  *
12457  *     Func : rgSCHCmnLcgDel
12458  *
12459  *     Desc : Scheduler handling for a (dedicated)
12460  *             uplink logical channel being deleted.
12461  *
12462  *     Ret  :
12463  *
12464  *     Notes:
12465  *
12466  *     File :
12467  *
12468  **********************************************************/
12469 #ifdef ANSI
12470 PUBLIC Void rgSCHCmnLcgDel
12471 (
12472 RgSchCellCb   *cell,
12473 RgSchUeCb     *ue,
12474 RgSchLcgCb    *lcg
12475 )
12476 #else
12477 PUBLIC Void rgSCHCmnLcgDel(cell, ue, lcg)
12478 RgSchCellCb   *cell;
12479 RgSchUeCb     *ue;
12480 RgSchLcgCb    *lcg;
12481 #endif
12482 {
12483    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12484    RgSchCmnLcg  *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
12485    TRC2(rgSCHCmnLcgDel);
12486
12487    if (lcgCmn == NULLP)
12488    {
12489       RETVOID;
12490    }
12491
12492    if (RGSCH_IS_GBR_BEARER(lcgCmn->cfgdGbr))
12493    {
12494       /* Indicate MAC that this LCG is GBR LCG */
12495       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcg->lcgId, FALSE);
12496    }
12497
12498 #ifdef LTEMAC_SPS
12499    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
12500    {
12501       rgSCHCmnSpsUlLcgDel(cell, ue, lcg);
12502    }
12503 #endif /* LTEMAC_SPS */
12504
12505    lcgCmn->effGbr     = 0;
12506    lcgCmn->reportedBs = 0;
12507    lcgCmn->cfgdGbr    = 0;
12508    /* set lcg bs to 0. Deletion of control block happens
12509     * at the time of UE deletion. */
12510    lcgCmn->bs = 0;
12511 #ifdef EMTC_ENABLE
12512    if(TRUE == ue->isEmtcUe)
12513    {
12514       cellSch->apisEmtcUl->rgSCHFreeUlLcg(cell, ue, lcg);
12515    }
12516    else
12517 #endif
12518    {
12519    cellSch->apisUl->rgSCHFreeUlLcg(cell, ue, lcg);
12520    }
12521    RETVOID;
12522 }
12523
12524 \f
12525 /**
12526  * @brief This function deletes a service from scheduler.
12527  *
12528  * @details
12529  *
12530  *     Function: rgSCHCmnFreeDlLc
12531  *     Purpose:  This function is made available through a FP for
12532  *               making scheduler aware of a service being deleted from UE.
12533  *
12534  *     Invoked by: BO and Scheduler
12535  *
12536  *  @param[in]  RgSchCellCb*  cell
12537  *  @param[in]  RgSchUeCb*    ue
12538  *  @param[in]  RgSchDlLcCb*  svc
12539  *  @return  Void
12540  *
12541  **/
12542 #ifdef ANSI
12543 PUBLIC Void rgSCHCmnFreeDlLc
12544 (
12545 RgSchCellCb                *cell,
12546 RgSchUeCb                  *ue,
12547 RgSchDlLcCb                *svc
12548 )
12549 #else
12550 PUBLIC Void rgSCHCmnFreeDlLc(cell, ue, svc)
12551 RgSchCellCb                *cell;
12552 RgSchUeCb                  *ue;
12553 RgSchDlLcCb                *svc;
12554 #endif
12555 {
12556    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12557    TRC2(rgSCHCmnFreeDlLc);
12558    if (svc->sch == NULLP)
12559    {
12560       RETVOID;
12561    }
12562 #ifdef EMTC_ENABLE
12563     if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12564     {
12565       cellSch->apisEmtcDl->rgSCHFreeDlLc(cell, ue, svc);
12566     }
12567     else
12568 #endif
12569    {
12570       cellSch->apisDl->rgSCHFreeDlLc(cell, ue, svc);
12571    }
12572
12573 #ifdef LTE_ADV
12574    if (ue->numSCells)
12575    {
12576       rgSCHSCellDlLcDel(cell, ue, svc);
12577    }
12578 #endif
12579
12580 #ifdef LTEMAC_SPS
12581    /* If SPS service, invoke SPS module */
12582    if (svc->dlLcSpsCfg.isSpsEnabled)
12583    {
12584       rgSCHCmnSpsDlLcDel(cell, ue, svc);
12585    }
12586 #endif
12587
12588    /* ccpu00117052 - MOD - Passing double pointer
12589    for proper NULLP assignment*/
12590    rgSCHUtlFreeSBuf(cell->instIdx,
12591          (Data**)(&(svc->sch)), (sizeof(RgSchCmnDlSvc)));
12592
12593 #ifdef LTE_ADV
12594    rgSCHLaaDeInitDlLchCb(cell, svc);
12595 #endif
12596
12597    RETVOID;
12598 }
12599
12600 #ifdef RGR_V1
12601
12602 /**
12603  * @brief This function Processes the Final Allocations
12604  *        made by the RB Allocator against the requested
12605  *        CCCH SDURetx Allocations.
12606  *
12607  * @details
12608  *
12609  *     Function: rgSCHCmnDlCcchSduRetxFnlz
12610  *     Purpose:  This function Processes the Final Allocations
12611  *               made by the RB Allocator against the requested
12612  *               CCCH Retx Allocations.
12613  *               Scans through the scheduled list of ccchSdu retrans
12614  *               fills the corresponding pdcch, adds the hqProc to
12615  *               the corresponding SubFrm and removes the hqP from
12616  *               cells retx List.
12617  *
12618  *     Invoked by: Common Scheduler
12619  *
12620  *  @param[in]  RgSchCellCb           *cell
12621  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12622  *  @return  Void
12623  *
12624  **/
12625 #ifdef ANSI
12626 PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz
12627 (
12628 RgSchCellCb           *cell,
12629 RgSchCmnDlRbAllocInfo *allocInfo
12630 )
12631 #else
12632 PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo)
12633 RgSchCellCb           *cell;
12634 RgSchCmnDlRbAllocInfo *allocInfo;
12635 #endif
12636 {
12637    CmLList           *node;
12638    RgSchCmnDlCell    *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
12639    RgSchDlRbAlloc    *rbAllocInfo;
12640    RgSchDlHqProcCb   *hqP;
12641    RgSchUeCb         *ue;
12642    TRC2(rgSCHCmnDlCcchSduRetxFnlz);
12643
12644    /* Traverse through the Scheduled Retx List */
12645    node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
12646    while (node)
12647    {
12648       hqP = (RgSchDlHqProcCb *)(node->node);
12649       ue = hqP->hqE->ue;
12650       rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
12651       node = node->next;
12652       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12653
12654       /* Remove the HqP from cell's ccchSduRetxLst */
12655       cmLListDelFrm(&cmnCellDl->ccchSduRetxLst, &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
12656       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
12657
12658       /* Fix: syed dlAllocCb reset should be performed.
12659        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12660       rgSCHCmnDlUeResetTemp(ue, hqP);
12661    }
12662    /* Fix: syed dlAllocCb reset should be performed.
12663     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12664    node = allocInfo->ccchSduAlloc.nonSchdCcchSduRetxLst.first;
12665    while(node)
12666    {
12667       hqP = (RgSchDlHqProcCb *)(node->node);
12668       ue = hqP->hqE->ue;
12669       node = node->next;
12670       /* reset the UE allocation Information */
12671       rgSCHCmnDlUeResetTemp(ue, hqP);
12672    }
12673    RETVOID;
12674 }
12675 #endif
12676 /**
12677  * @brief This function Processes the Final Allocations
12678  *        made by the RB Allocator against the requested
12679  *        CCCH Retx Allocations.
12680  *
12681  * @details
12682  *
12683  *     Function: rgSCHCmnDlCcchRetxFnlz
12684  *     Purpose:  This function Processes the Final Allocations
12685  *               made by the RB Allocator against the requested
12686  *               CCCH Retx Allocations.
12687  *               Scans through the scheduled list of msg4 retrans
12688  *               fills the corresponding pdcch, adds the hqProc to
12689  *               the corresponding SubFrm and removes the hqP from
12690  *               cells retx List.
12691  *
12692  *     Invoked by: Common Scheduler
12693  *
12694  *  @param[in]  RgSchCellCb           *cell
12695  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12696  *  @return  Void
12697  *
12698  **/
12699 #ifdef ANSI
12700 PRIVATE Void rgSCHCmnDlCcchRetxFnlz
12701 (
12702 RgSchCellCb           *cell,
12703 RgSchCmnDlRbAllocInfo *allocInfo
12704 )
12705 #else
12706 PRIVATE Void rgSCHCmnDlCcchRetxFnlz(cell, allocInfo)
12707 RgSchCellCb           *cell;
12708 RgSchCmnDlRbAllocInfo *allocInfo;
12709 #endif
12710 {
12711    CmLList           *node;
12712    RgSchCmnDlCell    *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
12713    RgSchDlRbAlloc    *rbAllocInfo;
12714    RgSchDlHqProcCb   *hqP;
12715    RgSchRaCb         *raCb;
12716    TRC2(rgSCHCmnDlCcchRetxFnlz);
12717
12718    /* Traverse through the Scheduled Retx List */
12719    node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
12720    while (node)
12721    {
12722       hqP = (RgSchDlHqProcCb *)(node->node);
12723       raCb = hqP->hqE->raCb;
12724       rbAllocInfo = &raCb->rbAllocInfo;
12725       node = node->next;
12726       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12727
12728       /* Remove the HqP from cell's msg4RetxLst */
12729       cmLListDelFrm(&cmnCellDl->msg4RetxLst, &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
12730       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
12731       /* Fix: syed dlAllocCb reset should be performed.
12732        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12733       cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
12734       rgSCHCmnDlHqPResetTemp(hqP);
12735    }
12736    /* Fix: syed dlAllocCb reset should be performed.
12737     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12738    node = allocInfo->msg4Alloc.nonSchdMsg4RetxLst.first;
12739    while(node)
12740    {
12741       hqP = (RgSchDlHqProcCb *)(node->node);
12742       raCb = hqP->hqE->raCb;
12743       node = node->next;
12744       cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
12745       rgSCHCmnDlHqPResetTemp(hqP);
12746    }
12747    RETVOID;
12748 }
12749
12750 #ifdef RGR_V1
12751 /**
12752  * @brief This function Processes the Final Allocations
12753  *        made by the RB Allocator against the requested
12754  *        CCCH SDU tx Allocations.
12755  *
12756  * @details
12757  *
12758  *     Function: rgSCHCmnDlCcchSduTxFnlz
12759  *     Purpose:  This function Processes the Final Allocations
12760  *               made by the RB Allocator against the requested
12761  *               CCCH tx Allocations.
12762  *               Scans through the scheduled list of CCCH SDU trans
12763  *               fills the corresponding pdcch, adds the hqProc to
12764  *               the corresponding SubFrm and removes the hqP from
12765  *               cells tx List.
12766  *
12767  *     Invoked by: Common Scheduler
12768  *
12769  *  @param[in]  RgSchCellCb           *cell
12770  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12771  *  @return  Void
12772  *
12773  **/
12774 #ifdef ANSI
12775 PRIVATE Void rgSCHCmnDlCcchSduTxFnlz
12776 (
12777 RgSchCellCb           *cell,
12778 RgSchCmnDlRbAllocInfo *allocInfo
12779 )
12780 #else
12781 PRIVATE Void rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo)
12782 RgSchCellCb           *cell;
12783 RgSchCmnDlRbAllocInfo *allocInfo;
12784 #endif
12785 {
12786    CmLList           *node;
12787    RgSchUeCb         *ueCb;
12788    RgSchDlRbAlloc    *rbAllocInfo;
12789    RgSchDlHqProcCb   *hqP;
12790    RgSchLchAllocInfo  lchSchdData;
12791    TRC2(rgSCHCmnDlCcchSduTxFnlz);
12792
12793    /* Traverse through the Scheduled Retx List */
12794    node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
12795    while (node)
12796    {
12797       hqP = (RgSchDlHqProcCb *)(node->node);
12798       ueCb = hqP->hqE->ue;
12799       node = node->next;
12800       rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
12801
12802       /* fill the pdcch and HqProc */
12803       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12804
12805       /* Remove the raCb from cell's toBeSchdLst */
12806       cmLListDelFrm(&cell->ccchSduUeLst, &ueCb->ccchSduLnk);
12807       ueCb->ccchSduLnk.node = (PTR)NULLP;
12808
12809       /* Fix : Resetting this required to avoid complication
12810        * in reestablishment case */
12811       ueCb->dlCcchInfo.bo = 0;
12812
12813       /* Indicate DHM of the CCCH LC scheduling */
12814       hqP->tbInfo[0].contResCe = NOTPRSNT;
12815       lchSchdData.lcId     = 0;
12816       lchSchdData.schdData = hqP->tbInfo[0].ccchSchdInfo.totBytes -
12817                              (RGSCH_MSG4_HDRSIZE);
12818       rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, &hqP->tbInfo[0]);
12819
12820       /* Fix: syed dlAllocCb reset should be performed.
12821        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12822       rgSCHCmnDlUeResetTemp(ueCb, hqP);
12823    }
12824    /* Fix: syed dlAllocCb reset should be performed.
12825     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12826    node = allocInfo->ccchSduAlloc.nonSchdCcchSduTxLst.first;
12827    while(node)
12828    {
12829       hqP = (RgSchDlHqProcCb *)(node->node);
12830       ueCb = hqP->hqE->ue;
12831       node = node->next;
12832       /* Release HqProc */
12833       rgSCHDhmRlsHqpTb(hqP, 0, FALSE);
12834       /*Fix: Removing releasing of TB1 as it will not exist for CCCH SDU and hence caused a crash*/
12835       /*rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
12836       /* reset the UE allocation Information */
12837       rgSCHCmnDlUeResetTemp(ueCb, hqP);
12838    }
12839    RETVOID;
12840 }
12841
12842 #endif
12843 /**
12844  * @brief This function Processes the Final Allocations
12845  *        made by the RB Allocator against the requested
12846  *        CCCH tx Allocations.
12847  *
12848  * @details
12849  *
12850  *     Function: rgSCHCmnDlCcchTxFnlz
12851  *     Purpose:  This function Processes the Final Allocations
12852  *               made by the RB Allocator against the requested
12853  *               CCCH tx Allocations.
12854  *               Scans through the scheduled list of msg4 trans
12855  *               fills the corresponding pdcch, adds the hqProc to
12856  *               the corresponding SubFrm and removes the hqP from
12857  *               cells tx List.
12858  *
12859  *     Invoked by: Common Scheduler
12860  *
12861  *  @param[in]  RgSchCellCb           *cell
12862  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12863  *  @return  Void
12864  *
12865  **/
12866 #ifdef ANSI
12867 PRIVATE Void rgSCHCmnDlCcchTxFnlz
12868 (
12869 RgSchCellCb           *cell,
12870 RgSchCmnDlRbAllocInfo *allocInfo
12871 )
12872 #else
12873 PRIVATE Void rgSCHCmnDlCcchTxFnlz(cell, allocInfo)
12874 RgSchCellCb           *cell;
12875 RgSchCmnDlRbAllocInfo *allocInfo;
12876 #endif
12877 {
12878    CmLList           *node;
12879    RgSchRaCb         *raCb;
12880    RgSchDlRbAlloc    *rbAllocInfo;
12881    RgSchDlHqProcCb   *hqP;
12882    RgSchLchAllocInfo  lchSchdData;
12883    TRC2(rgSCHCmnDlCcchTxFnlz);
12884
12885    /* Traverse through the Scheduled Retx List */
12886    node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
12887    while (node)
12888    {
12889       hqP = (RgSchDlHqProcCb *)(node->node);
12890       raCb = hqP->hqE->raCb;
12891       node = node->next;
12892       rbAllocInfo = &raCb->rbAllocInfo;
12893
12894       /* fill the pdcch and HqProc */
12895       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12896       /* MSG4 Fix Start */
12897      
12898       rgSCHRamRmvFrmRaInfoSchdLst(cell, raCb);
12899       /* MSG4 Fix End */     
12900
12901       /* Indicate DHM of the CCCH LC scheduling */
12902       lchSchdData.lcId     = 0;
12903       lchSchdData.schdData = hqP->tbInfo[0].ccchSchdInfo.totBytes -
12904          (RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE);
12905       /* TRansmitting presence of cont Res CE across MAC-SCH interface to
12906        * identify CCCH SDU transmissions which need to be done
12907        * without the
12908        * contention resolution CE*/
12909       hqP->tbInfo[0].contResCe = PRSNT_NODEF;
12910       /*Dont add lc if only cont res CE is being transmitted*/
12911       if(raCb->dlCcchInfo.bo)
12912       {
12913          rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, &hqP->tbInfo[0]);
12914       }
12915       else
12916       {
12917       }
12918       /* Fix: syed dlAllocCb reset should be performed.
12919        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12920       cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
12921       rgSCHCmnDlHqPResetTemp(hqP);
12922    }
12923    node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
12924    while(node)
12925    {
12926       hqP = (RgSchDlHqProcCb *)(node->node);
12927       raCb = hqP->hqE->raCb;
12928       node = node->next;
12929       rbAllocInfo = &raCb->rbAllocInfo;
12930       /* Release HqProc */
12931       rgSCHDhmRlsHqpTb(hqP, 0, FALSE);
12932       /*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
12933       /*      rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
12934       /* reset the UE allocation Information */
12935       cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
12936       rgSCHCmnDlHqPResetTemp(hqP);
12937    }
12938
12939    RETVOID;
12940 }
12941 /* R8 Upgrade */
12942 /**
12943  * @brief This function calculates the BI Index to be sent in the Bi header
12944  * field.
12945  *
12946  * @details
12947  *     Function: rgSCHCmnGetBiIndex
12948  *     Purpose:  This function Processes utilizes the previous BI time value
12949  *     calculated and the difference last BI sent time and current time. To
12950  *     calculate the latest BI Index. It also considers the how many UE's
12951  *     Unserved in this subframe.
12952  *
12953  *     Invoked by: Common Scheduler
12954  *
12955  *  @param[in]  RgSchCellCb           *cell
12956  *  @param[in]  U32                   ueCount
12957  *  @return  U8
12958  *
12959  **/
12960 #ifdef ANSI
12961 PUBLIC U8 rgSCHCmnGetBiIndex
12962 (
12963 RgSchCellCb   *cell,
12964 U32           ueCount
12965 )
12966 #else
12967 PUBLIC U8 rgSCHCmnGetBiIndex(cell, ueCount)
12968 RgSchCellCb   *cell;
12969 U32           ueCount;
12970 #endif
12971 {
12972    S16  prevVal = 0;      /* To Store Intermediate Value */
12973    U16  newBiVal = 0;     /* To store Bi Value in millisecond */
12974    U8   idx = 0;
12975    U16  timeDiff = 0;
12976
12977    TRC2(rgSCHCmnGetBiIndex)
12978
12979    if (cell->biInfo.prevBiTime != 0)
12980    {
12981 #ifdef EMTC_ENABLE
12982       if(cell->emtcEnable == TRUE)
12983       {
12984          timeDiff =(RGSCH_CALC_SF_DIFF_EMTC(cell->crntTime, cell->biInfo.biTime));
12985       }
12986       else
12987 #endif
12988       {
12989          timeDiff =(RGSCH_CALC_SF_DIFF(cell->crntTime, cell->biInfo.biTime));
12990       }
12991
12992       prevVal = cell->biInfo.prevBiTime - timeDiff;
12993    }
12994    if (prevVal < 0)
12995    {
12996       prevVal = 0;
12997    }
12998    newBiVal = RG_SCH_CMN_GET_BI_VAL(prevVal,ueCount);
12999    /* To be used next time when BI is calculated */
13000 #ifdef EMTC_ENABLE
13001    if(cell->emtcEnable == TRUE)
13002    {
13003       RGSCHCPYTIMEINFO_EMTC(cell->crntTime, cell->biInfo.biTime)
13004    }
13005    else
13006 #endif
13007    {
13008       RGSCHCPYTIMEINFO(cell->crntTime, cell->biInfo.biTime)
13009    }
13010
13011   /* Search the actual BI Index from table Backoff Parameters Value  and
13012    * return that Index */
13013    do
13014    {
13015       if (rgSchCmnBiTbl[idx] > newBiVal)
13016       {
13017          break;
13018       }
13019       idx++;
13020    }while(idx < RG_SCH_CMN_NUM_BI_VAL-1);
13021    cell->biInfo.prevBiTime = rgSchCmnBiTbl[idx];
13022    /* For 16 Entries in Table 7.2.1 36.321.880 - 3 reserved so total 13 Entries */
13023    RETVALUE(idx); /* Returning reserved value from table UE treats it has 960 ms */
13024 } /* rgSCHCmnGetBiIndex */
13025
13026
13027 /**
13028  * @brief This function Processes the Final Allocations
13029  *        made by the RB Allocator against the requested
13030  *        RAR allocations. Assumption: The reuqested
13031  *        allocations are always satisfied completely.
13032  *        Hence no roll back.
13033  *
13034  * @details
13035  *
13036  *     Function: rgSCHCmnDlRaRspFnlz
13037  *     Purpose:  This function Processes the Final Allocations
13038  *               made by the RB Allocator against the requested.
13039  *               Takes care of PDCCH filling.
13040  *
13041  *     Invoked by: Common Scheduler
13042  *
13043  *  @param[in]  RgSchCellCb           *cell
13044  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
13045  *  @return  Void
13046  *
13047  **/
13048 #ifdef ANSI
13049 PRIVATE Void rgSCHCmnDlRaRspFnlz
13050 (
13051 RgSchCellCb           *cell,
13052 RgSchCmnDlRbAllocInfo *allocInfo
13053 )
13054 #else
13055 PRIVATE Void rgSCHCmnDlRaRspFnlz(cell, allocInfo)
13056 RgSchCellCb           *cell;
13057 RgSchCmnDlRbAllocInfo *allocInfo;
13058 #endif
13059 {
13060    U32            rarCnt = 0;
13061    RgSchDlRbAlloc *raRspAlloc;
13062    RgSchDlSf      *subFrm = NULLP;
13063    RgSchRaCb      *raCb;
13064    RgSchErrInfo   err;
13065    CmLListCp      *reqLst;
13066    RgSchRaReqInfo *raReq;
13067    Bool           preamGrpA;
13068    RgSchUlAlloc   *ulAllocRef=NULLP;
13069    RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
13070    U8              allocRapidCnt = 0;
13071 #ifdef LTE_TDD
13072    U32            msg3SchdIdx = 0;
13073    U8             ulDlCfgIdx = cell->ulDlCfgIdx;
13074    U8             msg3Subfrm;
13075 #endif
13076
13077    TRC2(rgSCHCmnDlRaRspFnlz);
13078
13079    for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
13080    {
13081       raRspAlloc = &allocInfo->raRspAlloc[rarCnt];
13082       /* Having likely condition first for optimization */
13083       if (!raRspAlloc->pdcch)
13084       {
13085          continue;
13086       }
13087       else
13088       {
13089          subFrm = raRspAlloc->dlSf;
13090          reqLst = &cell->raInfo.raReqLst[raRspAlloc->raIndex];
13091          /* Corrected RACH handling for multiple RAPIDs per RARNTI */
13092          allocRapidCnt = raRspAlloc->numRapids;
13093          while (allocRapidCnt)
13094          {
13095             raReq = (RgSchRaReqInfo *)(reqLst->first->node);
13096             /* RACHO: If dedicated preamble, then allocate UL Grant
13097              * (consequence of handover/pdcchOrder) and continue */
13098             if (RGSCH_IS_DEDPRM(cell, raReq->raReq.rapId))
13099             {
13100                rgSCHCmnHdlHoPo(cell, &subFrm->raRsp[rarCnt].contFreeUeLst,
13101                      raReq);
13102                cmLListDelFrm(reqLst, reqLst->first);
13103                allocRapidCnt--;
13104                /* ccpu00117052 - MOD - Passing double pointer
13105                for proper NULLP assignment*/
13106                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13107                      sizeof(RgSchRaReqInfo));
13108                continue;
13109             }
13110             /* ccpu00139815 */
13111             if(cell->overLoadBackOffEnab)
13112             {/* rach Overlaod conrol is triggerd, Skipping this rach */
13113                cmLListDelFrm(reqLst, reqLst->first);
13114                allocRapidCnt--;
13115                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13116                      sizeof(RgSchRaReqInfo));
13117                continue;
13118             }
13119             /* Attempt to include each RA request into the RSP */
13120             /* Any failure in the procedure is considered to   */
13121             /* affect futher allocations in the same TTI. When */
13122             /* a failure happens, we break out and complete    */
13123             /* the processing for random access                */
13124             if (rgSCHRamCreateRaCb(cell, &raCb, &err) != ROK)
13125             {
13126                break;
13127             }
13128             /* Msg3 allocation request to USM */
13129             if (raReq->raReq.rapId < cell->rachCfg.sizeRaPreambleGrpA)
13130                preamGrpA = TRUE;
13131             else
13132                preamGrpA = FALSE;
13133             /*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
13134             rgSCHCmnMsg3GrntReq(cell, raCb->tmpCrnti, preamGrpA, \
13135                   &(raCb->msg3HqProc), &ulAllocRef, &raCb->msg3HqProcId);
13136             if (ulAllocRef == NULLP)
13137             {
13138                rgSCHRamDelRaCb(cell, raCb, TRUE);
13139                break;
13140             }
13141             if (raReq->raReq.cqiPres)
13142             {
13143                raCb->ccchCqi = raReq->raReq.cqiIdx;
13144             }
13145             else
13146             {
13147                raCb->ccchCqi = cellDl->ccchCqi;
13148             }
13149             raCb->rapId = raReq->raReq.rapId;
13150             raCb->ta.pres    = TRUE;
13151             raCb->ta.val = raReq->raReq.ta;
13152             raCb->msg3Grnt = ulAllocRef->grnt;
13153             /* Populating the tpc value received */
13154             raCb->msg3Grnt.tpc = raReq->raReq.tpc;
13155             /* PHR handling for MSG3 */
13156             ulAllocRef->raCb = raCb;
13157 #ifndef LTE_TDD
13158             /* To the crntTime, add the MIN time at which UE will
13159              * actually send MSG3 i.e DL_DELTA+6 */
13160             raCb->msg3AllocTime = cell->crntTime;
13161             RGSCH_INCR_SUB_FRAME(raCb->msg3AllocTime, RG_SCH_CMN_MIN_MSG3_RECP_INTRVL);
13162 #else
13163             msg3SchdIdx = (cell->crntTime.slot+RG_SCH_CMN_DL_DELTA) % 
13164                                  RGSCH_NUM_SUB_FRAMES;
13165             /*[ccpu00134666]-MOD-Modify the check to schedule the RAR in
13166               special subframe */                       
13167             if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][msg3SchdIdx] != 
13168                         RG_SCH_TDD_UL_SUBFRAME)
13169             {
13170                RGSCHCMNADDTOCRNTTIME(cell->crntTime,raCb->msg3AllocTime,
13171                                        RG_SCH_CMN_DL_DELTA)
13172                msg3Subfrm = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][
13173                                        raCb->msg3AllocTime.slot];
13174                RGSCHCMNADDTOCRNTTIME(raCb->msg3AllocTime, raCb->msg3AllocTime, 
13175                                  msg3Subfrm);
13176             }
13177 #endif
13178             cmLListAdd2Tail(&subFrm->raRsp[rarCnt].raRspLst, &raCb->rspLnk);
13179             raCb->rspLnk.node = (PTR)raCb;
13180             cmLListDelFrm(reqLst, reqLst->first);
13181             allocRapidCnt--;
13182             /* ccpu00117052 - MOD - Passing double pointer
13183             for proper NULLP assignment*/
13184             rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13185                   sizeof(RgSchRaReqInfo));
13186
13187             /* SR_RACH_STATS : RAR scheduled */
13188             rgNumRarSched++;
13189
13190          }
13191          /* R8 Upgrade */
13192          /* Fill subframe data members */
13193          subFrm->raRsp[rarCnt].raRnti = raRspAlloc->rnti;
13194          subFrm->raRsp[rarCnt].pdcch  = raRspAlloc->pdcch;
13195          subFrm->raRsp[rarCnt].tbSz   = raRspAlloc->tbInfo[0].bytesAlloc;
13196          /* Fill PDCCH data members */
13197          rgSCHCmnFillPdcch(cell, subFrm->raRsp[rarCnt].pdcch, raRspAlloc);
13198
13199          /* ccpu00139815 */
13200          if(cell->overLoadBackOffEnab)
13201          {/* rach Overlaod conrol is triggerd, Skipping this rach */
13202             subFrm->raRsp[rarCnt].backOffInd.pres = PRSNT_NODEF;
13203             subFrm->raRsp[rarCnt].backOffInd.val  = cell->overLoadBackOffval;
13204             continue;
13205          }
13206          else
13207          {
13208             subFrm->raRsp[rarCnt].backOffInd.pres = NOTPRSNT;
13209          }
13210
13211          /*[ccpu00125212] Avoiding sending of empty RAR in case of RAR window
13212            is short and UE is sending unauthorised preamble.*/
13213          reqLst = &cell->raInfo.raReqLst[raRspAlloc->raIndex];
13214          if ((raRspAlloc->biEstmt) && (reqLst->count))
13215          {
13216             subFrm->raRsp[0].backOffInd.pres = PRSNT_NODEF;
13217             /* Added as part of Upgrade */
13218             subFrm->raRsp[0].backOffInd.val =
13219             rgSCHCmnGetBiIndex(cell, reqLst->count);
13220
13221             /* SR_RACH_STATS : Back Off Inds */
13222             rgNumBI++;
13223
13224          }
13225          else if ((subFrm->raRsp[rarCnt].raRspLst.first == NULLP) &&
13226                (subFrm->raRsp[rarCnt].contFreeUeLst.first == NULLP))
13227          {
13228             /* Return the grabbed PDCCH */
13229             rgSCHUtlPdcchPut(cell, &subFrm->pdcchInfo, raRspAlloc->pdcch);
13230             subFrm->raRsp[rarCnt].pdcch = NULLP;
13231             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
13232                   "Not even one RaReq.");
13233             RETVOID;
13234          }
13235       }
13236       RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, 
13237             "RNTI:%d Scheduled RAR @ (%u,%u) ",
13238             raRspAlloc->rnti, 
13239             cell->crntTime.sfn,
13240             cell->crntTime.slot);
13241    }
13242    RETVOID;
13243 }
13244
13245 /**
13246  * @brief This function computes rv.
13247  *
13248  * @details
13249  *
13250  *     Function: rgSCHCmnDlCalcRvForBcch
13251  *     Purpose:  This function computes rv.
13252  *
13253  *     Invoked by: Common Scheduler
13254  *
13255  *  @param[in]   RgSchCellCb     *cell
13256  *  @param[in]   Bool            si
13257  *  @param[in]   U16             i
13258  *  @return  U8
13259  *
13260  **/
13261 #ifdef ANSI
13262 PRIVATE U8 rgSCHCmnDlCalcRvForBcch
13263 (
13264 RgSchCellCb          *cell,
13265 Bool                 si,
13266 U16                  i
13267 )
13268 #else
13269 PRIVATE U8 rgSCHCmnDlCalcRvForBcch(cell, si, i)
13270 RgSchCellCb          *cell;
13271 Bool                 si;
13272 U16                  i;
13273 #endif
13274 {
13275    U8 k, rv;
13276    CmLteTimingInfo   frm;
13277    TRC2(rgSCHCmnDlCalcRvForBcch);
13278
13279    frm   = cell->crntTime;
13280    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
13281
13282    if(si)
13283    {
13284       k = i % 4;
13285    }
13286    else
13287    {
13288       k = (frm.sfn/2) % 4;
13289    }
13290    rv = RGSCH_CEIL(3*k, 2) % 4;
13291    RETVALUE(rv);
13292 }
13293
13294 /**
13295  * @brief This function Processes the Final Allocations
13296  *        made by the RB Allocator against the requested
13297  *        BCCH/PCCH allocations. Assumption: The reuqested
13298  *        allocations are always satisfied completely.
13299  *        Hence no roll back.
13300  *
13301  * @details
13302  *
13303  *     Function: rgSCHCmnDlBcchPcchFnlz
13304  *     Purpose:  This function Processes the Final Allocations
13305  *               made by the RB Allocator against the requested.
13306  *               Takes care of PDCCH filling.
13307  *
13308  *     Invoked by: Common Scheduler
13309  *
13310  *  @param[in]  RgSchCellCb           *cell
13311  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
13312  *  @return  Void
13313  *
13314  **/
13315 #ifdef ANSI
13316 PRIVATE Void rgSCHCmnDlBcchPcchFnlz
13317 (
13318 RgSchCellCb           *cell,
13319 RgSchCmnDlRbAllocInfo *allocInfo
13320 )
13321 #else
13322 PRIVATE Void rgSCHCmnDlBcchPcchFnlz(cell, allocInfo)
13323 RgSchCellCb           *cell;
13324 RgSchCmnDlRbAllocInfo *allocInfo;
13325 #endif
13326 {
13327    RgSchDlRbAlloc *rbAllocInfo;
13328    RgSchDlSf      *subFrm;
13329
13330 #ifdef LTE_TDD
13331    U8             nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
13332 #else
13333 #ifdef LTEMAC_HDFDD
13334    U8             nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13335 #else
13336    U8             nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13337 #endif
13338 #endif
13339
13340    /*  Moving variables to available scope for optimization */
13341    RgSchClcDlLcCb *pcch;
13342    RgSchClcBoRpt  *bo;
13343 #ifndef RGR_SI_SCH
13344    RgSchClcDlLcCb  *bcch;
13345    Bool           sendInd=TRUE;
13346 #endif
13347    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
13348
13349    TRC2(rgSCHCmnDlBcchPcchFnlz);
13350
13351    /* handle PCCH */
13352    rbAllocInfo = &allocInfo->pcchAlloc;
13353    if (rbAllocInfo->pdcch)
13354    {
13355       RgInfSfAlloc   *subfrmAlloc = &(cell->sfAllocArr[nextSfIdx]);
13356
13357       /* Added sfIdx calculation for TDD as well */
13358 #ifndef LTE_TDD
13359 #ifdef LTEMAC_HDFDD
13360       nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13361 #else
13362       nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13363 #endif
13364 #endif
13365       subFrm = rbAllocInfo->dlSf;
13366       pcch = rgSCHDbmGetPcch(cell);
13367       if(pcch == NULLP)
13368       {
13369          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
13370                "No Pcch Present");
13371          RETVOID;
13372       }
13373
13374       /* Added Dl TB count for paging message transmission*/
13375 #ifdef LTE_L2_MEAS
13376       cell->dlUlTbCnt.tbTransDlTotalCnt++;
13377 #endif      
13378       bo = (RgSchClcBoRpt *)pcch->boLst.first->node;
13379       cmLListDelFrm(&pcch->boLst, &bo->boLstEnt);
13380       /* ccpu00117052 - MOD - Passing double pointer
13381          for proper NULLP assignment*/
13382       rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
13383       /* Fill subframe data members */
13384       subFrm->pcch.tbSize = rbAllocInfo->tbInfo[0].bytesAlloc;
13385       subFrm->pcch.pdcch  = rbAllocInfo->pdcch;
13386       /* Fill PDCCH data members */
13387       rgSCHCmnFillPdcch(cell, subFrm->pcch.pdcch, rbAllocInfo);
13388       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, pcch->lcId, TRUE);
13389       /* ccpu00132314-ADD-Update the tx power allocation info  
13390          TODO-Need to add a check for max tx power per symbol */ 
13391       subfrmAlloc->cmnLcInfo.pcchInfo.txPwrOffset = cellDl->pcchTxPwrOffset;   
13392    }
13393
13394    /* handle BCCH */
13395    rbAllocInfo = &allocInfo->bcchAlloc;
13396    if (rbAllocInfo->pdcch)
13397    {
13398       RgInfSfAlloc   *subfrmAlloc = &(cell->sfAllocArr[nextSfIdx]);
13399 #ifndef LTE_TDD
13400 #ifdef LTEMAC_HDFDD
13401       nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13402 #else
13403       nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13404 #endif
13405 #endif
13406       subFrm = rbAllocInfo->dlSf;
13407
13408       /* Fill subframe data members */
13409       subFrm->bcch.tbSize = rbAllocInfo->tbInfo[0].bytesAlloc;
13410       subFrm->bcch.pdcch  = rbAllocInfo->pdcch;
13411       /* Fill PDCCH data members */
13412       rgSCHCmnFillPdcch(cell, subFrm->bcch.pdcch, rbAllocInfo);
13413
13414       if(rbAllocInfo->schdFirst)
13415       {
13416 #ifndef RGR_SI_SCH
13417          bcch = rgSCHDbmGetFirstBcchOnDlsch(cell);
13418          bo = (RgSchClcBoRpt *)bcch->boLst.first->node;
13419 #else
13420          /*Copy the SIB1 msg buff into interface buffer */
13421          SCpyMsgMsg(cell->siCb.crntSiInfo.sib1Info.sib1,
13422                rgSchCb[cell->instIdx].rgSchInit.region,
13423                rgSchCb[cell->instIdx].rgSchInit.pool,
13424                &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13425 #endif/*RGR_SI_SCH*/
13426          subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv =
13427             rgSCHCmnDlCalcRvForBcch(cell, FALSE, 0);
13428       }
13429       else
13430       {
13431          U16   i;
13432 #ifdef RGR_SI_SCH
13433          Buffer    *pdu;
13434
13435          i = cell->siCb.siCtx.i;
13436          /*Decrement the retransmission count */
13437          cell->siCb.siCtx.retxCntRem--;
13438
13439          /*Copy the SI msg buff into interface buffer */
13440          if(cell->siCb.siCtx.warningSiFlag == FALSE)
13441          {
13442             SCpyMsgMsg(cell->siCb.siArray[cell->siCb.siCtx.siId-1].si,
13443                   rgSchCb[cell->instIdx].rgSchInit.region,
13444                   rgSchCb[cell->instIdx].rgSchInit.pool,
13445                   &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13446          }
13447          else
13448          {
13449             pdu = rgSCHUtlGetWarningSiPdu(cell);
13450             RGSCH_NULL_CHECK(cell->instIdx, pdu);
13451             SCpyMsgMsg(pdu,
13452                   rgSchCb[cell->instIdx].rgSchInit.region,
13453                   rgSchCb[cell->instIdx].rgSchInit.pool,
13454                   &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13455             if(cell->siCb.siCtx.retxCntRem == 0)
13456             {  
13457                rgSCHUtlFreeWarningSiPdu(cell);
13458                cell->siCb.siCtx.warningSiFlag  = FALSE;
13459
13460             }
13461          }
13462 #else
13463          bcch = rgSCHDbmGetSecondBcchOnDlsch(cell);
13464          bo = (RgSchClcBoRpt *)bcch->boLst.first->node;
13465          bo->retxCnt--;
13466          if(bo->retxCnt != cell->siCfg.retxCnt-1)
13467          {
13468             sendInd=FALSE;
13469          }
13470          i = bo->i;
13471 #endif/*RGR_SI_SCH*/
13472          subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv =
13473             rgSCHCmnDlCalcRvForBcch(cell, TRUE, i);
13474       }
13475
13476       /* Added Dl TB count for SIB1 and SI messages transmission.
13477        * This counter will be incremented only for the first transmission
13478        * (with RV 0) of these messages*/
13479 #ifdef LTE_L2_MEAS
13480       if(subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv == 0)
13481       {   
13482          cell->dlUlTbCnt.tbTransDlTotalCnt++;
13483       }
13484 #endif      
13485 #ifndef RGR_SI_SCH
13486       if(bo->retxCnt == 0)
13487       {
13488          cmLListDelFrm(&bcch->boLst, &bo->boLstEnt);
13489          /* ccpu00117052 - MOD - Passing double pointer
13490             for proper NULLP assignment*/
13491          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
13492       }
13493       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, bcch->lcId, sendInd);
13494 #else
13495       /*Fill the interface info */
13496       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, NULLD, NULLD);
13497
13498       /* ccpu00132314-ADD-Update the tx power allocation info  
13499          TODO-Need to add a check for max tx power per symbol */ 
13500       subfrmAlloc->cmnLcInfo.bcchInfo.txPwrOffset = cellDl->bcchTxPwrOffset;   
13501
13502       /*mBuf has been already copied above */
13503 #endif/*RGR_SI_SCH*/
13504    }
13505
13506    RETVOID;
13507 }
13508
13509
13510 #if RG_UNUSED
13511 /**
13512  * @brief
13513  *
13514  * @details
13515  *
13516  *     Function: rgSCHCmnUlSetAllUnSched
13517  *     Purpose:
13518  *
13519  *     Invoked by: Common Scheduler
13520  *
13521  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13522  *  @return  Void
13523  *
13524  **/
13525 #ifdef ANSI
13526 PRIVATE Void rgSCHCmnUlSetAllUnSched
13527 (
13528 RgSchCmnUlRbAllocInfo *allocInfo
13529 )
13530 #else
13531 PRIVATE Void rgSCHCmnUlSetAllUnSched(allocInfo)
13532 RgSchCmnUlRbAllocInfo *allocInfo;
13533 #endif
13534 {
13535    CmLList            *node;
13536
13537    TRC2(rgSCHCmnUlSetAllUnSched);
13538
13539    node = allocInfo->contResLst.first;
13540    while (node)
13541    {
13542       rgSCHCmnUlMov2NonSchdCntResLst(allocInfo, (RgSchUeCb *)node->node);
13543       node = allocInfo->contResLst.first;
13544    }
13545
13546    node = allocInfo->retxUeLst.first;
13547    while (node)
13548    {
13549       rgSCHCmnUlMov2NonSchdRetxUeLst(allocInfo, (RgSchUeCb *)node->node);
13550       node = allocInfo->retxUeLst.first;
13551    }
13552
13553    node = allocInfo->ueLst.first;
13554    while (node)
13555    {
13556       rgSCHCmnUlMov2NonSchdUeLst(allocInfo, (RgSchUeCb *)node->node);
13557       node = allocInfo->ueLst.first;
13558    }
13559
13560    RETVOID;
13561 }
13562 #endif
13563
13564 /**
13565  * @brief
13566  *
13567  * @details
13568  *
13569  *     Function: rgSCHCmnUlAdd2CntResLst
13570  *     Purpose:
13571  *
13572  *     Invoked by: Common Scheduler
13573  *
13574  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13575  *  @param[in]  RgSchUeCb             *ue
13576  *  @return  Void
13577  *
13578  **/
13579 #ifdef ANSI
13580 PUBLIC Void rgSCHCmnUlAdd2CntResLst
13581 (
13582 RgSchCmnUlRbAllocInfo *allocInfo,
13583 RgSchUeCb             *ue
13584 )
13585 #else
13586 PUBLIC Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
13587 RgSchCmnUlRbAllocInfo *allocInfo;
13588 RgSchUeCb             *ue;
13589 #endif
13590 {
13591    RgSchCmnUeUlAlloc  *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
13592    TRC2(rgSCHCmnUlAdd2CntResLst);
13593    cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
13594    ulAllocInfo->reqLnk.node = (PTR)ue;
13595    RETVOID;
13596 }
13597
13598 /**
13599  * @brief
13600  *
13601  * @details
13602  *
13603  *     Function: rgSCHCmnUlAdd2UeLst
13604  *     Purpose:
13605  *
13606  *     Invoked by: Common Scheduler
13607  *
13608  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13609  *  @param[in]  RgSchUeCb             *ue
13610  *  @return  Void
13611  *
13612  **/
13613 #ifdef ANSI
13614 PUBLIC Void rgSCHCmnUlAdd2UeLst
13615 (
13616 RgSchCellCb           *cell,
13617 RgSchCmnUlRbAllocInfo *allocInfo,
13618 RgSchUeCb             *ue
13619 )
13620 #else
13621 PUBLIC Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
13622 RgSchCellCb           *cell;
13623 RgSchCmnUlRbAllocInfo *allocInfo;
13624 RgSchUeCb             *ue;
13625 #endif
13626 {
13627    RgSchCmnUeUlAlloc  *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
13628    TRC2(rgSCHCmnUlAdd2UeLst);
13629    if (ulAllocInfo->reqLnk.node == NULLP)
13630    {
13631       cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
13632       ulAllocInfo->reqLnk.node = (PTR)ue;
13633    }
13634    RETVOID;
13635 }
13636
13637 /**
13638  * @brief
13639  *
13640  * @details
13641  *
13642  *     Function: rgSCHCmnAllocUlRb
13643  *     Purpose:  To do RB allocations for uplink
13644  *
13645  *     Invoked by: Common Scheduler
13646  *
13647  *  @param[in]  RgSchCellCb           *cell
13648  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
13649  *  @return  Void
13650  **/
13651 #ifdef ANSI
13652 PUBLIC Void rgSCHCmnAllocUlRb
13653 (
13654 RgSchCellCb           *cell,
13655 RgSchCmnUlRbAllocInfo *allocInfo
13656 )
13657 #else
13658 PUBLIC Void rgSCHCmnAllocUlRb(cell, allocInfo)
13659 RgSchCellCb           *cell;
13660 RgSchCmnUlRbAllocInfo *allocInfo;
13661 #endif
13662 {
13663    RgSchUlSf         *sf = allocInfo->sf;
13664    TRC2(rgSCHCmnAllocUlRb);
13665
13666    /* Schedule for new transmissions */
13667    rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
13668          &allocInfo->ueLst, &allocInfo->schdUeLst,
13669          &allocInfo->nonSchdUeLst, (Bool)TRUE);
13670    RETVOID;
13671 }
13672
13673 /***********************************************************
13674  *
13675  *     Func : rgSCHCmnUlRbAllocForLst
13676  *
13677  *     Desc : Allocate for a list in cmn rb alloc information passed
13678  *            in a subframe.
13679  *
13680  *     Ret  :
13681  *
13682  *     Notes:
13683  *
13684  *     File :
13685  *
13686  **********************************************************/
13687 #ifdef ANSI
13688 PRIVATE Void rgSCHCmnUlRbAllocForLst
13689 (
13690 RgSchCellCb           *cell,
13691 RgSchUlSf             *sf,
13692 U32                   count,
13693 CmLListCp             *reqLst,
13694 CmLListCp             *schdLst,
13695 CmLListCp             *nonSchdLst,
13696 Bool                  isNewTx
13697 )
13698 #else
13699 PRIVATE Void rgSCHCmnUlRbAllocForLst(cell, sf, count, reqLst, schdLst,
13700                                      nonSchdLst, isNewTx)
13701 RgSchCellCb           *cell;
13702 RgSchUlSf             *sf;
13703 U32                   count;
13704 CmLListCp             *reqLst;
13705 CmLListCp             *schdLst;
13706 CmLListCp             *nonSchdLst;
13707 Bool                  isNewTx;
13708 #endif
13709 {
13710    CmLList          *lnk;
13711    RgSchUlHole      *hole;
13712 #ifdef LTE_L2_MEAS
13713 #ifdef LTE_TDD
13714    U8               k;
13715    CmLteTimingInfo  timeInfo;
13716 #endif    
13717 #endif    
13718    TRC2(rgSCHCmnUlRbAllocForLst);
13719
13720    if(schdLst->count == 0)
13721    {
13722       cmLListInit(schdLst);
13723    }
13724
13725    cmLListInit(nonSchdLst);
13726 #ifdef LTE_L2_MEAS
13727    if(isNewTx == TRUE)
13728    {
13729       cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (U8) count;
13730 #ifdef LTE_TDD
13731       RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, timeInfo, TFU_ULCNTRL_DLDELTA);
13732       k = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][timeInfo.subframe];
13733       RG_SCH_ADD_TO_CRNT_TIME(timeInfo,
13734           cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.timingInfo, k);
13735 #else
13736       RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime,cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.timingInfo,
13737                             (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
13738 #endif
13739    }
13740 #endif
13741
13742    for (lnk = reqLst->first; count; lnk = lnk->next, --count)
13743    {
13744       RgSchUeCb             *ue = (RgSchUeCb *)lnk->node;
13745       RgSchCmnUlUe          *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
13746       S16                   ret;
13747       U8                    maxRb;
13748
13749
13750       if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
13751       {
13752          break;
13753       }
13754
13755       ueUl->subbandShare = ueUl->subbandRequired;
13756       if(isNewTx == TRUE)
13757       {
13758          maxRb = RGSCH_MIN((ueUl->subbandRequired * MAX_5GTF_VRBG_SIZE), ue->ue5gtfCb.maxPrb);
13759       } 
13760       ret = rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole);
13761       if (ret == ROK)
13762       {
13763          rgSCHCmnUlRbAllocAddUeToLst(cell, ue, schdLst);
13764          rgSCHCmnUlUeFillAllocInfo(cell, ue);
13765       }
13766       else
13767       {
13768          gUl5gtfRbAllocFail++;
13769 #if defined (TENB_STATS) && defined (RG_5GTF)
13770          cell->tenbStats->sch.ul5gtfRbAllocFail++;
13771 #endif
13772          rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
13773          ue->isMsg4PdcchWithCrnti = FALSE;
13774          ue->isSrGrant = FALSE;
13775       }
13776 #ifdef LTE_L2_MEAS
13777       if(isNewTx == TRUE)
13778       {
13779          cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.
13780          ulAllocInfo[count - 1].rnti   = ue->ueId;
13781          cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.
13782          ulAllocInfo[count - 1].numPrb = ue->ul.nPrb;
13783       }
13784 #endif
13785       ueUl->subbandShare = 0; /* This reset will take care of
13786                                   * all scheduler types */
13787    }
13788    for (; count; lnk = lnk->next, --count)
13789    {
13790       RgSchUeCb             *ue = (RgSchUeCb *)lnk->node;
13791       rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
13792       ue->isMsg4PdcchWithCrnti = FALSE;
13793    }
13794    RETVOID;
13795 }
13796
13797 #ifdef TFU_UPGRADE
13798 /***********************************************************
13799  *
13800  *     Func : rgSCHCmnUlMdfyGrntForCqi
13801  *
13802  *     Desc : Modify UL Grant to consider presence of 
13803  *            CQI along with PUSCH Data.
13804  *
13805  *     Ret  :
13806  *
13807  *     Notes: 
13808  *          -  Scale down iTbs based on betaOffset and
13809  *             size of Acqi Size.
13810  *          -  Optionally attempt to increase numSb by 1
13811  *             if input payload size does not fit in due 
13812  *             to reduced tbSz as a result of iTbsNew.
13813  *
13814  *     File :
13815  *
13816  **********************************************************/
13817 #ifdef UNUSE_FUN
13818 #ifdef ANSI
13819 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi
13820 (
13821 RgSchCellCb  *cell,
13822 RgSchUeCb    *ue,
13823 U32          maxRb,
13824 U32          *numSb,
13825 U8           *iTbs,
13826 U32          hqSz,
13827 U32          stepDownItbs,
13828 U32          effTgt
13829 )
13830 #else
13831 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
13832 RgSchCellCb  *cell;
13833 RgSchUeCb    *ue;
13834 U32          maxRb;
13835 U32          *numSb;
13836 U8           *iTbs;
13837 U32          hqSz;
13838 U32          stepDownItbs;
13839 U32          effTgt;
13840 #endif
13841 {
13842    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(ue->cell);
13843    U32  nPrb;
13844    U32  totREs;
13845    U32  cqiRiREs;
13846    U32  hqREs;
13847    U32  remREsForPusch;
13848    U32  bitsPerRe;
13849    U32  tbSz;
13850    U32  betaOffVal = ue->ul.betaOffstVal;
13851    U32  cqiRiRptSz = ue->ul.cqiRiSz;
13852    U32  betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
13853    U32  resNumSb = *numSb;
13854    U32  puschEff = 1000;
13855    U8   modOdr;
13856    U8   iMcs;
13857    Bool mdfyiTbsFlg = FALSE;
13858    U8   resiTbs = *iTbs;
13859
13860    TRC2(rgSCHCmnUlMdfyGrntForCqi)
13861
13862    
13863    do
13864    {
13865       iMcs  = rgSCHCmnUlGetIMcsFrmITbs(resiTbs, RG_SCH_CMN_GET_UE_CTGY(ue));
13866       RG_SCH_UL_MCS_TO_MODODR(iMcs, modOdr);
13867       if (RG_SCH_CMN_GET_UE_CTGY(ue) != CM_LTE_UE_CAT_5)
13868       {
13869          modOdr = RGSCH_MIN(RGSCH_QM_QPSK, modOdr);
13870       }
13871       else
13872       {
13873          modOdr = RGSCH_MIN(RGSCH_QM_64QAM, modOdr);
13874       }
13875       nPrb = resNumSb * cellUl->sbSize;
13876       /* Restricting the minumum iTbs requried to modify to 10 */
13877       if ((nPrb >= maxRb) && (resiTbs <= 10))
13878       {
13879          /* Could not accomodate ACQI */
13880          RETVALUE(RFAILED);
13881       }
13882       totREs = nPrb * RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
13883       tbSz = rgTbSzTbl[0][resiTbs][nPrb-1];
13884       /*  totalREs/tbSz = num of bits perRE.  */
13885       cqiRiREs = (totREs * betaOffVal * cqiRiRptSz)/(1000 * tbSz); /* betaOffVal is represented 
13886                                                                    as parts per 1000 */
13887       hqREs = (totREs * betaOffHqVal * hqSz)/(1000 * tbSz);
13888       if ((cqiRiREs + hqREs) < totREs)
13889       {
13890          remREsForPusch = totREs - cqiRiREs - hqREs;
13891          bitsPerRe = (tbSz * 1000)/remREsForPusch; /* Multiplying by 1000 for Interger Oper */
13892          puschEff = bitsPerRe/modOdr;
13893       }
13894       if (puschEff < effTgt)
13895       {
13896           /* ensure resultant efficiency for PUSCH Data is within 0.93*/
13897           break;
13898       }
13899       else
13900       {
13901          /* Alternate between increasing SB or decreasing iTbs until eff is met */
13902          if (mdfyiTbsFlg == FALSE)
13903          {
13904             if (nPrb < maxRb)
13905             {
13906               resNumSb = resNumSb + 1;
13907             }
13908             mdfyiTbsFlg = TRUE;
13909          }
13910          else
13911          {
13912             if (resiTbs > 10)
13913             {
13914                resiTbs-= stepDownItbs;
13915             }
13916             mdfyiTbsFlg = FALSE;
13917          }
13918       }
13919    }while (1); /* Loop breaks if efficency is met 
13920                   or returns RFAILED if not able to meet the efficiency */
13921               
13922    *numSb = resNumSb;
13923    *iTbs = resiTbs;
13924
13925    RETVALUE(ROK);
13926 }
13927 #endif
13928 #endif
13929 /***********************************************************
13930  *
13931  *     Func : rgSCHCmnUlRbAllocForUe
13932  *
13933  *     Desc : Do uplink RB allocation for an UE.
13934  *
13935  *     Ret  :
13936  *
13937  *     Notes: Note that as of now, for retx, maxRb
13938  *            is not considered. Alternatives, such
13939  *            as dropping retx if it crosses maxRb
13940  *            could be considered.
13941  *
13942  *     File :
13943  *
13944  **********************************************************/
13945 #ifdef ANSI
13946 PRIVATE S16 rgSCHCmnUlRbAllocForUe
13947 (
13948 RgSchCellCb           *cell,
13949 RgSchUlSf             *sf,
13950 RgSchUeCb             *ue,
13951 U8                    maxRb,
13952 RgSchUlHole           *hole
13953 )
13954 #else
13955 PRIVATE S16 rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole)
13956 RgSchCellCb           *cell;
13957 RgSchUlSf             *sf;
13958 RgSchUeCb             *ue;
13959 U8                    maxRb;
13960 RgSchUlHole           *hole;
13961 #endif
13962 {
13963    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
13964    RgSchCmnUlUe    *ueUl    = RG_SCH_CMN_GET_UL_UE(ue, cell);
13965    RgSchUlAlloc     *alloc = NULLP;
13966    U32              nPrb = 0;
13967    U8               numVrbg;
13968    U8               iMcs;
13969    U8               iMcsCrnt;
13970 #ifndef RG_5GTF
13971    RgSchUlHqProcCb  *proc = &ueUl->hqEnt.hqProcCb[cellUl->schdHqProcIdx];
13972 #else
13973    RgSchUlHqProcCb  *proc = NULLP;
13974 #endif
13975    RgSchPdcch       *pdcch;
13976    U32              reqVrbg;
13977    U8               numVrbgTemp;
13978 #ifdef RG_5GTF
13979    TfuDciFormat     dciFrmt;
13980    U8               numLyr;
13981 #endif
13982
13983    TRC2(rgSCHCmnUlRbAllocForUe);
13984 #ifdef RG_5GTF
13985    rgSCHUhmGetAvlHqProc(cell, ue, &proc);
13986    if (proc == NULLP)
13987    {
13988       //printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
13989       RETVALUE(RFAILED);
13990    }
13991 #endif
13992
13993    if (ue->ue5gtfCb.rank == 2)
13994    {
13995       dciFrmt = TFU_DCI_FORMAT_A2;
13996       numLyr = 2;
13997    }
13998    else
13999    {
14000       dciFrmt = TFU_DCI_FORMAT_A1;
14001       numLyr = 1;
14002    }
14003    /* 5gtf TODO : To pass dci frmt to this function */
14004    pdcch = rgSCHCmnPdcchAllocCrntSf(cell, ue);
14005    if(pdcch == NULLP)
14006    {
14007       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId, 
14008          "rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
14009       RETVALUE(RFAILED);
14010    }
14011         gUl5gtfPdcchSchd++;
14012 #if defined (TENB_STATS) && defined (RG_5GTF)
14013    cell->tenbStats->sch.ul5gtfPdcchSchd++;
14014 #endif
14015
14016    //TODO_SID using configured prb as of now
14017    nPrb = ue->ue5gtfCb.maxPrb;
14018    reqVrbg = nPrb/MAX_5GTF_VRBG_SIZE;
14019    iMcs  = ue->ue5gtfCb.mcs; //gSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
14020    iMcsCrnt = iMcs;
14021    numVrbg = reqVrbg;
14022
14023    if((sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart > MAX_5GTF_VRBG)
14024          || (sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated > MAX_5GTF_VRBG))
14025    {
14026       printf("5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
14027             , sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated);
14028       int *p=NULLP;
14029       *p = 10;
14030    }
14031
14032    /*TODO_SID: Workaround for alloc. Currently alloc is ulsf based. To handle multiple beams, we need a different
14033      design. Now alloc are formed based on MAX_5GTF_UE_SCH macro. */
14034    numVrbgTemp = MAX_5GTF_VRBG/MAX_5GTF_UE_SCH;
14035    if(numVrbg)
14036    {
14037       alloc = rgSCHCmnUlSbAlloc(sf, numVrbgTemp,\
14038                                 hole);
14039    }
14040    if (alloc == NULLP)
14041    {
14042       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
14043          "rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
14044       rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
14045       RETVALUE(RFAILED);
14046    }
14047    gUl5gtfAllocAllocated++;
14048 #if defined (TENB_STATS) && defined (RG_5GTF)
14049    cell->tenbStats->sch.ul5gtfAllocAllocated++;
14050 #endif
14051    alloc->grnt.vrbgStart = sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart;
14052    alloc->grnt.numVrbg = numVrbg;
14053    alloc->grnt.numLyr = numLyr;
14054    alloc->grnt.dciFrmt = dciFrmt;
14055
14056    sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart += numVrbg;
14057    sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated += numVrbg;
14058
14059    //rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
14060 #ifdef LTE_L2_MEAS
14061    sf->totPrb  += alloc->grnt.numRb;
14062    ue->ul.nPrb = alloc->grnt.numRb;
14063 #endif
14064    if (ue->csgMmbrSta != TRUE)
14065    {
14066       cellUl->ncsgPrbCnt += alloc->grnt.numRb;
14067    }
14068    cellUl->totPrbCnt += (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
14069    alloc->pdcch = pdcch;
14070    alloc->grnt.iMcs = iMcs;
14071    alloc->grnt.iMcsCrnt = iMcsCrnt;
14072    alloc->grnt.hop = 0;
14073    /* Initial Num RBs support for UCI on PUSCH */
14074 #ifdef TFU_UPGRADE
14075    ue->initNumRbs = (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
14076 #endif
14077    alloc->forMsg3 = FALSE;
14078    //RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTb5gtfSzTbl[0], (iTbs)); 
14079
14080    //ueUl->alloc.allocdBytes = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
14081    /* TODO_SID Allocating based on configured MCS as of now.
14082          Currently for format A2. When doing multi grp per tti, need to update this. */
14083    ueUl->alloc.allocdBytes = (rgSch5gtfTbSzTbl[iMcs]/8) * ue->ue5gtfCb.rank;
14084
14085    alloc->grnt.datSz = ueUl->alloc.allocdBytes;
14086    //TODO_SID Need to check mod order.
14087    RG_SCH_CMN_TBS_TO_MODODR(iMcs, alloc->grnt.modOdr);
14088         //alloc->grnt.modOdr = 6;
14089    alloc->grnt.isRtx = FALSE;
14090
14091    alloc->grnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, alloc->grnt.vrbgStart, alloc->grnt.numVrbg);
14092    alloc->grnt.SCID = 0;
14093    alloc->grnt.xPUSCHRange = MAX_5GTF_XPUSCH_RANGE;
14094    alloc->grnt.PMI = 0;
14095    alloc->grnt.uciOnxPUSCH = 0;
14096    alloc->grnt.hqProcId = proc->procId;
14097
14098    alloc->hqProc = proc;
14099    alloc->hqProc->ulSfIdx = cellUl->schdIdx;
14100    alloc->ue = ue;
14101    /*commenting to retain the rnti used for transmission SPS/c-rnti */
14102    alloc->rnti = ue->ueId;
14103    ueUl->alloc.alloc = alloc;
14104    /*rntiwari-Adding the debug for generating the graph.*/
14105    /* No grant attr recorded now */
14106    RETVALUE(ROK);
14107 }
14108
14109 /***********************************************************
14110  *
14111  *     Func : rgSCHCmnUlRbAllocAddUeToLst
14112  *
14113  *     Desc : Add UE to list (scheduled/non-scheduled list)
14114  *            for UL RB allocation information.
14115  *
14116  *     Ret  :
14117  *
14118  *     Notes:
14119  *
14120  *     File :
14121  *
14122  **********************************************************/
14123 #ifdef ANSI
14124 PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst
14125 (
14126 RgSchCellCb           *cell,
14127 RgSchUeCb             *ue,
14128 CmLListCp             *lst
14129 )
14130 #else
14131 PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
14132 RgSchCellCb           *cell;
14133 RgSchUeCb             *ue;
14134 CmLListCp             *lst;
14135 #endif
14136 {
14137    RgSchCmnUlUe   *ueUl   = RG_SCH_CMN_GET_UL_UE(ue,cell);
14138    TRC2(rgSCHCmnUlRbAllocAddUeToLst);
14139    UNUSED(cell);
14140
14141    gUl5gtfUeRbAllocDone++;
14142 #if defined (TENB_STATS) && defined (RG_5GTF)
14143    cell->tenbStats->sch.ul5gtfUeRbAllocDone++;
14144 #endif
14145    cmLListAdd2Tail(lst, &ueUl->alloc.schdLstLnk);
14146    ueUl->alloc.schdLstLnk.node = (PTR)ue;
14147 }
14148
14149
14150 /**
14151  * @brief This function Processes the Final Allocations
14152  *        made by the RB Allocator against the requested.
14153  *
14154  * @details
14155  *
14156  *     Function: rgSCHCmnUlAllocFnlz
14157  *     Purpose:  This function Processes the Final Allocations
14158  *               made by the RB Allocator against the requested.
14159  *
14160  *     Invoked by: Common Scheduler
14161  *
14162  *  @param[in]  RgSchCellCb           *cell
14163  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
14164  *  @return  Void
14165  *
14166  **/
14167 #ifdef ANSI
14168 PRIVATE Void rgSCHCmnUlAllocFnlz
14169 (
14170 RgSchCellCb           *cell,
14171 RgSchCmnUlRbAllocInfo *allocInfo
14172 )
14173 #else
14174 PRIVATE Void rgSCHCmnUlAllocFnlz(cell, allocInfo)
14175 RgSchCellCb           *cell;
14176 RgSchCmnUlRbAllocInfo *allocInfo;
14177 #endif
14178 {
14179    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
14180    TRC2(rgSCHCmnUlAllocFnlz);
14181
14182    /* call scheduler specific Finalization */
14183    cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
14184
14185    RETVOID;
14186 }
14187
14188 /**
14189  * @brief This function Processes the Final Allocations
14190  *        made by the RB Allocator against the requested.
14191  *
14192  * @details
14193  *
14194  *     Function: rgSCHCmnDlAllocFnlz
14195  *     Purpose:  This function Processes the Final Allocations
14196  *               made by the RB Allocator against the requested.
14197  *
14198  *     Invoked by: Common Scheduler
14199  *
14200  *  @param[in]  RgSchCellCb           *cell
14201  *  @return  Void
14202  *
14203  **/
14204 #ifdef ANSI
14205 PUBLIC Void rgSCHCmnDlAllocFnlz
14206 (
14207 RgSchCellCb           *cell
14208 )
14209 #else
14210 PUBLIC Void rgSCHCmnDlAllocFnlz(cell)
14211 RgSchCellCb           *cell;
14212 #endif
14213 {
14214    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14215    RgSchCmnDlRbAllocInfo  *allocInfo = &cellSch->allocInfo; 
14216
14217    TRC2(rgSCHCmnDlAllocFnlz);
14218
14219    rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
14220    rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
14221 #ifdef RGR_V1
14222    /* Added below functions for handling CCCH SDU transmission received
14223     * after
14224     *     * guard timer expiry*/
14225    rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo);
14226    rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo);
14227 #endif
14228    rgSCHCmnDlRaRspFnlz(cell, allocInfo);
14229       /* call scheduler specific Finalization */
14230    cellSch->apisDl->rgSCHDlAllocFnlz(cell, allocInfo);
14231
14232    /* Stack Crash problem for TRACE5 Changes. Added the return below */
14233    RETVOID;
14234
14235 }
14236
14237 #ifdef RG_UNUSED
14238 /**
14239  * @brief Update an uplink subframe.
14240  *
14241  * @details
14242  *
14243  *     Function : rgSCHCmnUlUpdSf
14244  *
14245  *     For each allocation
14246  *      - if no more tx needed
14247  *         - Release allocation
14248  *      - else
14249  *         - Perform retransmission
14250  *
14251  *  @param[in]  RgSchUlSf *sf
14252  *  @return  Void
14253  **/
14254 #ifdef ANSI
14255 PRIVATE Void rgSCHCmnUlUpdSf
14256 (
14257 RgSchCellCb           *cell,
14258 RgSchCmnUlRbAllocInfo *allocInfo,
14259 RgSchUlSf *sf
14260 )
14261 #else
14262 PRIVATE Void rgSCHCmnUlUpdSf(cell, allocInfo, sf)
14263 RgSchCellCb           *cell;
14264 RgSchCmnUlRbAllocInfo *allocInfo;
14265 RgSchUlSf *sf;
14266 #endif
14267 {
14268    CmLList        *lnk;
14269    TRC2(rgSCHCmnUlUpdSf);
14270
14271    while ((lnk = sf->allocs.first))
14272    {
14273       RgSchUlAlloc  *alloc = (RgSchUlAlloc *)lnk->node;
14274       lnk = lnk->next;
14275
14276       if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
14277       {
14278       }
14279       else
14280       {
14281          /* If need to handle all retx together, run another loop separately */
14282          rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc);
14283       }
14284       rgSCHCmnUlRlsUlAlloc(cell, sf, alloc);
14285    }
14286
14287    /* By this time, all allocs would have been cleared and
14288     * SF is reset to be made ready for new allocations. */
14289    rgSCHCmnUlSfReset(cell, sf);
14290    /* In case there are timing problems due to msg3
14291     * allocations being done in advance, (which will
14292     * probably happen with the current FDD code that
14293     * handles 8 subframes) one solution
14294     * could be to hold the (recent) msg3 allocs in a separate
14295     * list, and then possibly add that to the actual
14296     * list later. So at this time while allocations are
14297     * traversed, the recent msg3 ones are not seen. Anytime after
14298     * this (a good time is when the usual allocations
14299     * are made), msg3 allocations could be transferred to the
14300     * normal list. Not doing this now as it is assumed
14301     * that incorporation of TDD shall take care of this.
14302     */
14303
14304
14305    RETVOID;
14306 }
14307
14308 /**
14309  * @brief Handle uplink allocation for retransmission.
14310  *
14311  * @details
14312  *
14313  *     Function : rgSCHCmnUlHndlAllocRetx
14314  *
14315  *     Processing Steps:
14316  *     - Add to queue for retx.
14317  *     - Do not release here, release happends as part
14318  *       of the loop that calls this function.
14319  *
14320  *  @param[in]  RgSchCellCb           *cell
14321  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
14322  *  @param[in]  RgSchUlSf *sf
14323  *  @param[in]  RgSchUlAlloc  *alloc
14324  *  @return  Void
14325  **/
14326 #ifdef ANSI
14327 PRIVATE Void rgSCHCmnUlHndlAllocRetx
14328 (
14329 RgSchCellCb           *cell,
14330 RgSchCmnUlRbAllocInfo *allocInfo,
14331 RgSchUlSf     *sf,
14332 RgSchUlAlloc  *alloc
14333 )
14334 #else
14335 PRIVATE Void rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc)
14336 RgSchCellCb           *cell;
14337 RgSchCmnUlRbAllocInfo *allocInfo;
14338 RgSchUlSf     *sf;
14339 RgSchUlAlloc  *alloc;
14340 #endif
14341 {
14342    U32            bytes;
14343    RgSchCmnUlUe   *ueUl;
14344    TRC2(rgSCHCmnUlHndlAllocRetx);
14345    bytes = \
14346       rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
14347                                      [alloc->grnt.numRb-1]/8;
14348    if (!alloc->forMsg3)
14349    {
14350       ueUl = RG_SCH_CMN_GET_UL_UE(alloc->ue);
14351       ueUl->alloc.reqBytes = bytes;
14352       rgSCHUhmRetx(alloc->hqProc);
14353       rgSCHCmnUlAdd2RetxUeLst(allocInfo, alloc->ue);
14354    }
14355    else
14356    {
14357       /* RACHO msg3 retx handling. Part of RACH procedure changes. */
14358       retxAlloc = rgSCHCmnUlGetUlAlloc(cell, sf, alloc->numSb);
14359       if (retxAlloc == NULLP)
14360       {
14361          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
14362                "rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
14363                alloc->rnti);
14364          RETVOID;
14365       }
14366       retxAlloc->grnt.iMcs = alloc->grnt.iMcs;
14367       retxAlloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl\
14368                                  [alloc->hqProc->rvIdx];
14369       retxAlloc->grnt.nDmrs    = 0;
14370       retxAlloc->grnt.hop      = 0;
14371       retxAlloc->grnt.delayBit = 0;
14372       retxAlloc->rnti          = alloc->rnti;
14373       retxAlloc->ue            = NULLP;
14374       retxAlloc->pdcch         = FALSE;
14375       retxAlloc->forMsg3       = TRUE;
14376       retxAlloc->raCb          = alloc->raCb;
14377       retxAlloc->hqProc        = alloc->hqProc;
14378       rgSCHUhmRetx(retxAlloc->hqProc);
14379    }
14380    RETVOID;
14381 }
14382 #endif
14383
14384 /**
14385  * @brief Uplink Scheduling Handler.
14386  *
14387  * @details
14388  *
14389  *     Function: rgSCHCmnUlAlloc
14390  *     Purpose:  This function Handles Uplink Scheduling.
14391  *
14392  *     Invoked by: Common Scheduler
14393  *
14394  *  @param[in]  RgSchCellCb *cell
14395  *  @return  Void
14396  **/
14397 /* ccpu00132653- The definition of this function made common for TDD and FDD*/
14398 #ifdef ANSI
14399 PRIVATE Void rgSCHCmnUlAlloc
14400 (
14401 RgSchCellCb  *cell
14402 )
14403 #else
14404 PRIVATE Void rgSCHCmnUlAlloc(cell)
14405 RgSchCellCb  *cell;
14406 #endif
14407 {
14408    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14409    RgSchCmnUlCell         *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
14410    RgSchCmnDlCell         *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
14411    RgSchCmnUlRbAllocInfo  allocInfo;
14412    RgSchCmnUlRbAllocInfo  *allocInfoRef = &allocInfo;
14413 #ifdef RG_5GTF
14414    U8 idx;
14415
14416 #endif
14417
14418    TRC2(rgSCHCmnUlAlloc);
14419
14420    /* Initializing RgSchCmnUlRbAllocInfo structure */
14421    rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
14422
14423    /* Get Uplink Subframe */
14424    allocInfoRef->sf = &cellUl->ulSfArr[cellUl->schdIdx];
14425 #ifdef LTE_L2_MEAS
14426    /* initializing the UL PRB count */
14427    allocInfoRef->sf->totPrb = 0;
14428 #endif
14429
14430 #ifdef LTEMAC_SPS
14431    rgSCHCmnSpsUlTti(cell, allocInfoRef);
14432 #endif
14433
14434    if(*allocInfoRef->sf->allocCountRef == 0)
14435    {            
14436       RgSchUlHole     *hole;
14437
14438       if ((hole = rgSCHUtlUlHoleFirst(allocInfoRef->sf)) != NULLP)
14439       {
14440          /* Sanity check of holeDb */
14441          if (allocInfoRef->sf->holeDb->count == 1 && hole->start == 0) 
14442          {
14443             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;   
14444             /* Re-Initialize available subbands because of CFI change*/
14445             allocInfoRef->sf->availSubbands = cell->dynCfiCb.\
14446                                               bwInfo[cellDl->currCfi].numSb;
14447             /*Currently initializing 5gtf ulsf specific initialization here.
14448               need to do at proper place */
14449 #ifdef RG_5GTF
14450        allocInfoRef->sf->numGrpPerTti = cell->cell5gtfCb.ueGrpPerTti;
14451        allocInfoRef->sf->numUePerGrp = cell->cell5gtfCb.uePerGrpPerTti;
14452             for(idx = 0; idx < MAX_5GTF_BEAMS; idx++)
14453             {
14454                allocInfoRef->sf->sfBeamInfo[idx].totVrbgAllocated = 0;
14455                allocInfoRef->sf->sfBeamInfo[idx].totVrbgRequired = 0;
14456                allocInfoRef->sf->sfBeamInfo[idx].vrbgStart = 0;
14457             }    
14458 #endif
14459          }
14460          else
14461          {
14462             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
14463                   "Error! holeDb sanity check failed");
14464          }
14465       }
14466    }
14467
14468    /* Fix: Adaptive re-transmissions prioritised over other transmissions */
14469    /* perform adaptive retransmissions */
14470    rgSCHCmnUlSfReTxAllocs(cell, allocInfoRef->sf);
14471
14472         g5gtfTtiCnt++;
14473
14474    /* Fix: syed Adaptive Msg3 Retx crash. Release all
14475     Harq processes for which adap Retx failed, to avoid 
14476     blocking. This step should be done before New TX 
14477     scheduling to make hqProc available. Right now we
14478     dont check if proc is in adap Retx list for considering
14479     it to be available. But now with this release that 
14480     functionality would be correct. */
14481 #ifndef RG_5GTF
14482    rgSCHCmnUlSfRlsRetxProcs(cell, allocInfoRef->sf);  
14483 #endif
14484
14485    /* Specific UL scheduler to perform UE scheduling */
14486    cellSch->apisUl->rgSCHUlSched(cell, allocInfoRef);
14487
14488    /* Call UL RB allocator module */
14489    rgSCHCmnAllocUlRb(cell, allocInfoRef);
14490
14491    /* Do group power control for PUSCH */
14492    rgSCHCmnGrpPwrCntrlPusch(cell, allocInfoRef->sf);
14493
14494    cell->sc.apis->rgSCHDrxStrtInActvTmrInUl(cell);
14495
14496    rgSCHCmnUlAllocFnlz(cell, allocInfoRef);
14497         if(5000 == g5gtfTtiCnt)
14498         {
14499       ul5gtfsidDlAlreadyMarkUl = 0;
14500                 ul5gtfsidDlSchdPass = 0;
14501                 ul5gtfsidUlMarkUl = 0;
14502       ul5gtfTotSchdCnt = 0;
14503                 g5gtfTtiCnt = 0;
14504         }
14505
14506    RETVOID;
14507 }
14508
14509 /**
14510  * @brief send Subframe Allocations.
14511  *
14512  * @details
14513  *
14514  *     Function: rgSCHCmnSndCnsldtInfo
14515  *     Purpose:  Send the scheduled
14516  *     allocations to MAC for StaInd generation to Higher layers and
14517  *     for MUXing. PST's RgInfSfAlloc to MAC instance.
14518  *
14519  *     Invoked by: Common Scheduler
14520  *
14521  *  @param[in]  RgSchCellCb *cell
14522  *  @return  Void
14523  **/
14524 #ifdef ANSI
14525 PUBLIC Void rgSCHCmnSndCnsldtInfo
14526 (
14527 RgSchCellCb  *cell
14528 )
14529 #else
14530 PUBLIC Void rgSCHCmnSndCnsldtInfo(cell)
14531 RgSchCellCb  *cell;
14532 #endif
14533 {
14534    RgInfSfAlloc           *subfrmAlloc;
14535    Pst                    pst;
14536    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14537
14538    TRC2(rgSCHCmnSndCnsldtInfo);
14539
14540    subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
14541
14542    /* Send the allocations to MAC for MUXing */
14543    rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
14544    subfrmAlloc->cellId = cell->cellId;
14545    /* Populate the List of UEs needing PDB-based Flow control */
14546    cellSch->apisDl->rgSCHDlFillFlwCtrlInfo(cell, subfrmAlloc);
14547 #ifdef LTE_L2_MEAS
14548    if((subfrmAlloc->rarInfo.numRaRntis) ||
14549 #ifdef EMTC_ENABLE
14550       (subfrmAlloc->emtcInfo.rarInfo.numRaRntis) ||
14551       (subfrmAlloc->emtcInfo.cmnLcInfo.bitMask)  ||
14552       (subfrmAlloc->emtcInfo.ueInfo.numUes) ||
14553 #endif
14554       (subfrmAlloc->ueInfo.numUes)      ||
14555       (subfrmAlloc->cmnLcInfo.bitMask)  ||
14556          (subfrmAlloc->ulUeInfo.numUes)    ||
14557          (subfrmAlloc->flowCntrlInfo.numUes))
14558 #else
14559    if((subfrmAlloc->rarInfo.numRaRntis) ||
14560 #ifdef EMTC_ENABLE
14561       (subfrmAlloc->emtcInfo.rarInfo.numRaRntis) ||
14562       (subfrmAlloc->emtcInfo.cmnLcInfo.bitMask)  ||
14563       (subfrmAlloc->emtcInfo.ueInfo.numUes) ||
14564 #endif
14565       (subfrmAlloc->ueInfo.numUes)      ||
14566             (subfrmAlloc->cmnLcInfo.bitMask)  ||
14567             (subfrmAlloc->flowCntrlInfo.numUes))
14568 #endif
14569    {
14570       RgSchMacSfAlloc(&pst, subfrmAlloc);
14571    }
14572 #ifndef LTE_TDD
14573    cell->crntSfIdx  = (cell->crntSfIdx + 1) % RGSCH_NUM_SUB_FRAMES;
14574 #else
14575    cell->crntSfIdx  = (cell->crntSfIdx + 1) % RGSCH_SF_ALLOC_SIZE;
14576 #endif
14577    
14578    RETVOID;
14579 }
14580 /**
14581  * @brief Consolidate Subframe Allocations.
14582  *
14583  * @details
14584  *
14585  *     Function: rgSCHCmnCnsldtSfAlloc
14586  *     Purpose:  Consolidate Subframe Allocations.
14587  *
14588  *     Invoked by: Common Scheduler
14589  *
14590  *  @param[in]  RgSchCellCb *cell
14591  *  @return  Void
14592  **/
14593 #ifdef ANSI
14594 PUBLIC Void rgSCHCmnCnsldtSfAlloc
14595 (
14596 RgSchCellCb  *cell
14597 )
14598 #else
14599 PUBLIC Void rgSCHCmnCnsldtSfAlloc(cell)
14600 RgSchCellCb  *cell;
14601 #endif
14602 {
14603    RgInfSfAlloc           *subfrmAlloc;
14604    CmLteTimingInfo        frm;
14605    RgSchDlSf              *dlSf;
14606    CmLListCp              dlDrxInactvTmrLst;
14607    CmLListCp              dlInActvLst;
14608    CmLListCp              ulInActvLst;
14609    RgSchCmnCell           *cellSch = NULLP;
14610
14611    TRC2(rgSCHCmnCnsldtSfAlloc);
14612
14613    cmLListInit(&dlDrxInactvTmrLst);
14614    cmLListInit(&dlInActvLst);
14615    cmLListInit(&ulInActvLst);
14616
14617    subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
14618
14619    /* Get Downlink Subframe */
14620    frm   = cell->crntTime;
14621    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
14622    dlSf = rgSCHUtlSubFrmGet(cell, frm);
14623
14624    /* Fill the allocation Info */
14625    rgSCHUtlFillRgInfRarInfo(dlSf, subfrmAlloc, cell);
14626
14627   /* CA dev Start */
14628    rgSCHUtlFillRgInfUeInfo(dlSf, cell, &dlDrxInactvTmrLst, 
14629                            &dlInActvLst, &ulInActvLst);
14630 #ifdef RG_PFS_STATS
14631    cell->totalPrb += dlSf->bwAssigned;
14632 #endif
14633    /* Mark the following Ues inactive for UL*/
14634    cellSch = RG_SCH_CMN_GET_CELL(cell);
14635
14636    /* Calling Scheduler specific function with DRX inactive UE list*/
14637    cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInActvLst);
14638    cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInActvLst);
14639     
14640   /* CA dev End */
14641    /*re/start DRX inactivity timer for the UEs*/
14642    (Void)rgSCHDrxStrtInActvTmr(cell,&dlDrxInactvTmrLst,RG_SCH_DRX_DL);
14643
14644    RETVOID;
14645 }
14646
14647 /**
14648  * @brief Initialize the DL Allocation Information Structure.
14649  *
14650  * @details
14651  *
14652  *     Function: rgSCHCmnInitDlRbAllocInfo
14653  *     Purpose:  Initialize the DL Allocation Information Structure.
14654  *
14655  *     Invoked by: Common Scheduler
14656  *
14657  *  @param[out]  RgSchCmnDlRbAllocInfo  *allocInfo
14658  *  @return  Void
14659  **/
14660 #ifdef ANSI
14661 PRIVATE Void rgSCHCmnInitDlRbAllocInfo
14662 (
14663 RgSchCmnDlRbAllocInfo  *allocInfo
14664 )
14665 #else
14666 PRIVATE Void rgSCHCmnInitDlRbAllocInfo(allocInfo)
14667 RgSchCmnDlRbAllocInfo  *allocInfo;
14668 #endif
14669 {
14670    TRC2(rgSCHCmnInitDlRbAllocInfo);
14671    cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
14672    cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
14673    cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
14674          RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
14675
14676    allocInfo->msg4Alloc.msg4DlSf = NULLP;
14677    cmLListInit(&allocInfo->msg4Alloc.msg4TxLst);
14678    cmLListInit(&allocInfo->msg4Alloc.msg4RetxLst);
14679    cmLListInit(&allocInfo->msg4Alloc.schdMsg4TxLst);
14680    cmLListInit(&allocInfo->msg4Alloc.schdMsg4RetxLst);
14681    cmLListInit(&allocInfo->msg4Alloc.nonSchdMsg4TxLst);
14682    cmLListInit(&allocInfo->msg4Alloc.nonSchdMsg4RetxLst);
14683 #ifdef RGR_V1
14684    allocInfo->ccchSduAlloc.ccchSduDlSf = NULLP;
14685    cmLListInit(&allocInfo->ccchSduAlloc.ccchSduTxLst);
14686    cmLListInit(&allocInfo->ccchSduAlloc.ccchSduRetxLst);
14687    cmLListInit(&allocInfo->ccchSduAlloc.schdCcchSduTxLst);
14688    cmLListInit(&allocInfo->ccchSduAlloc.schdCcchSduRetxLst);
14689    cmLListInit(&allocInfo->ccchSduAlloc.nonSchdCcchSduTxLst);
14690    cmLListInit(&allocInfo->ccchSduAlloc.nonSchdCcchSduRetxLst);
14691 #endif
14692
14693    allocInfo->dedAlloc.dedDlSf = NULLP;
14694    cmLListInit(&allocInfo->dedAlloc.txHqPLst);
14695    cmLListInit(&allocInfo->dedAlloc.retxHqPLst);
14696    cmLListInit(&allocInfo->dedAlloc.schdTxHqPLst);
14697    cmLListInit(&allocInfo->dedAlloc.schdRetxHqPLst);
14698    cmLListInit(&allocInfo->dedAlloc.nonSchdTxHqPLst);
14699    cmLListInit(&allocInfo->dedAlloc.nonSchdRetxHqPLst);
14700
14701    cmLListInit(&allocInfo->dedAlloc.txRetxHqPLst);
14702    cmLListInit(&allocInfo->dedAlloc.schdTxRetxHqPLst);
14703    cmLListInit(&allocInfo->dedAlloc.nonSchdTxRetxHqPLst);
14704 #ifdef LTEMAC_SPS
14705    cmLListInit(&allocInfo->dedAlloc.txSpsHqPLst);
14706    cmLListInit(&allocInfo->dedAlloc.retxSpsHqPLst);
14707    cmLListInit(&allocInfo->dedAlloc.schdTxSpsHqPLst);
14708    cmLListInit(&allocInfo->dedAlloc.schdRetxSpsHqPLst);
14709    cmLListInit(&allocInfo->dedAlloc.nonSchdTxSpsHqPLst);
14710    cmLListInit(&allocInfo->dedAlloc.nonSchdRetxSpsHqPLst);
14711 #endif
14712
14713 #ifdef LTE_ADV
14714    rgSCHLaaCmnInitDlRbAllocInfo (allocInfo);
14715 #endif
14716
14717    cmLListInit(&allocInfo->dedAlloc.errIndTxHqPLst);
14718    cmLListInit(&allocInfo->dedAlloc.schdErrIndTxHqPLst);
14719    cmLListInit(&allocInfo->dedAlloc.nonSchdErrIndTxHqPLst);
14720    RETVOID;
14721 }
14722
14723 /**
14724  * @brief Initialize the UL Allocation Information Structure.
14725  *
14726  * @details
14727  *
14728  *     Function: rgSCHCmnInitUlRbAllocInfo
14729  *     Purpose:  Initialize the UL Allocation Information Structure.
14730  *
14731  *     Invoked by: Common Scheduler
14732  *
14733  *  @param[out]  RgSchCmnUlRbAllocInfo  *allocInfo
14734  *  @return  Void
14735  **/
14736 #ifdef ANSI
14737 PUBLIC Void rgSCHCmnInitUlRbAllocInfo
14738 (
14739 RgSchCmnUlRbAllocInfo  *allocInfo
14740 )
14741 #else
14742 PUBLIC Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
14743 RgSchCmnUlRbAllocInfo  *allocInfo;
14744 #endif
14745 {
14746    TRC2(rgSCHCmnInitUlRbAllocInfo);
14747    allocInfo->sf = NULLP;
14748    cmLListInit(&allocInfo->contResLst);
14749    cmLListInit(&allocInfo->schdContResLst);
14750    cmLListInit(&allocInfo->nonSchdContResLst);
14751    cmLListInit(&allocInfo->ueLst);
14752    cmLListInit(&allocInfo->schdUeLst);
14753    cmLListInit(&allocInfo->nonSchdUeLst);
14754
14755    RETVOID;
14756 }
14757
14758 /**
14759  * @brief Scheduling for PUCCH group power control.
14760  *
14761  * @details
14762  *
14763  *     Function: rgSCHCmnGrpPwrCntrlPucch
14764  *     Purpose: This function does group power control for PUCCH
14765  *     corresponding to the subframe for which DL UE allocations
14766  *     have happended.
14767  *
14768  *     Invoked by: Common Scheduler
14769  *
14770  *  @param[in]  RgSchCellCb *cell
14771  *  @return  Void
14772  **/
14773 #ifdef ANSI
14774 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch
14775 (
14776 RgSchCellCb            *cell,
14777 RgSchDlSf              *dlSf
14778 )
14779 #else
14780 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch(cell, dlSf)
14781 RgSchCellCb            *cell;
14782 RgSchDlSf              *dlSf;
14783 #endif
14784 {
14785    TRC2(rgSCHCmnGrpPwrCntrlPucch);
14786
14787    rgSCHPwrGrpCntrlPucch(cell, dlSf);
14788
14789    RETVOID;
14790 }
14791
14792 /**
14793  * @brief Scheduling for PUSCH group power control.
14794  *
14795  * @details
14796  *
14797  *     Function: rgSCHCmnGrpPwrCntrlPusch
14798  *     Purpose: This function does group power control, for
14799  *     the subframe for which UL allocation has (just) happened.
14800  *
14801  *     Invoked by: Common Scheduler
14802  *
14803  *  @param[in]  RgSchCellCb *cell
14804  *  @param[in]  RgSchUlSf   *ulSf
14805  *  @return  Void
14806  **/
14807 #ifdef ANSI
14808 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch
14809 (
14810 RgSchCellCb            *cell,
14811 RgSchUlSf              *ulSf
14812 )
14813 #else
14814 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch(cell, ulSf)
14815 RgSchCellCb            *cell;
14816 RgSchUlSf              *ulSf;
14817 #endif
14818 {
14819    /*removed unused variable *cellSch*/
14820    CmLteTimingInfo        frm;
14821    RgSchDlSf              *dlSf;
14822
14823    TRC2(rgSCHCmnGrpPwrCntrlPusch);
14824
14825    /* Got to pass DL SF corresponding to UL SF, so get that first.
14826     * There is no easy way of getting dlSf by having the RgSchUlSf*,
14827     * so use the UL delta from current time to get the DL SF. */
14828    frm   = cell->crntTime;
14829
14830 #ifdef EMTC_ENABLE
14831    if(cell->emtcEnable == TRUE)
14832    {
14833       RGSCH_INCR_SUB_FRAME_EMTC(frm, TFU_DLCNTRL_DLDELTA);
14834    }
14835    else
14836 #endif
14837    {
14838       RGSCH_INCR_SUB_FRAME(frm, TFU_DLCNTRL_DLDELTA);
14839    }
14840    /* Del filling of dl.time */
14841    dlSf = rgSCHUtlSubFrmGet(cell, frm);
14842
14843    rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf);
14844
14845    RETVOID;
14846 }
14847
14848 /* Fix: syed align multiple UEs to refresh at same time */
14849 /***********************************************************
14850  *
14851  *     Func : rgSCHCmnApplyUeRefresh 
14852  *
14853  *     Desc : Apply UE refresh in CMN and Specific 
14854  *     schedulers. Data rates and corresponding 
14855  *     scratchpad variables are updated.
14856  *
14857  *     Ret  :
14858  *
14859  *     Notes:
14860  *
14861  *     File :
14862  *
14863  **********************************************************/
14864 #ifdef ANSI
14865 PRIVATE S16 rgSCHCmnApplyUeRefresh 
14866 (
14867 RgSchCellCb     *cell,
14868 RgSchUeCb       *ue
14869 )
14870 #else
14871 PRIVATE S16 rgSCHCmnApplyUeRefresh(cell, ue)
14872 RgSchCellCb     *cell;
14873 RgSchUeCb       *ue;
14874 #endif
14875 {
14876    RgSchCmnCell    *cellSch     = RG_SCH_CMN_GET_CELL(cell);
14877    U32             effGbrBsr    = 0;
14878    U32             effNonGbrBsr = 0;
14879    U32             lcgId;
14880
14881    TRC2(rgSCHCmnApplyUeRefresh);
14882
14883    /* Reset the refresh cycle variableCAP */
14884    ue->ul.effAmbr = ue->ul.cfgdAmbr;
14885
14886    for (lcgId = 1; lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
14887    {
14888       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
14889       {
14890          RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
14891
14892          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
14893          {
14894             cmnLcg->effGbr = cmnLcg->cfgdGbr;
14895             cmnLcg->effDeltaMbr = cmnLcg->deltaMbr;
14896             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
14897             /* Considering GBR LCG will be prioritised by UE */
14898             effGbrBsr += cmnLcg->bs;
14899          }/* Else no remaing BS so nonLcg0 will be updated when BSR will be received */
14900          else
14901          {
14902             effNonGbrBsr += cmnLcg->reportedBs;
14903             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
14904          }
14905       }
14906    }
14907    effNonGbrBsr = RGSCH_MIN(effNonGbrBsr,ue->ul.effAmbr);
14908    ue->ul.nonGbrLcgBs = effNonGbrBsr;
14909
14910    ue->ul.nonLcg0Bs = effGbrBsr + effNonGbrBsr;
14911    ue->ul.effBsr = ue->ul.nonLcg0Bs +\
14912                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
14913
14914
14915    /* call scheduler specific event handlers
14916     * for refresh timer expiry */
14917    cellSch->apisUl->rgSCHUlUeRefresh(cell, ue);
14918    cellSch->apisDl->rgSCHDlUeRefresh(cell, ue);
14919
14920    RETVALUE(ROK);
14921 }
14922
14923 /***********************************************************
14924  *
14925  *     Func : rgSCHCmnTmrExpiry
14926  *
14927  *     Desc : Adds an UE to refresh queue, so that the UE is
14928  *            periodically triggered to refresh it's GBR and
14929  *            AMBR values.
14930  *
14931  *     Ret  :
14932  *
14933  *     Notes:
14934  *
14935  *     File :
14936  *
14937  **********************************************************/
14938 #ifdef ANSI
14939 PRIVATE S16 rgSCHCmnTmrExpiry
14940 (
14941 PTR cb,               /* Pointer to timer control block */
14942 S16 tmrEvnt           /* Timer Event */
14943 )
14944 #else
14945 PRIVATE S16 rgSCHCmnTmrExpiry(cb, tmrEvnt)
14946 PTR cb;               /* Pointer to timer control block */
14947 S16 tmrEvnt;           /* Timer Event */
14948 #endif
14949 {
14950    RgSchUeCb       *ue = (RgSchUeCb *)cb;
14951    RgSchCellCb     *cell = ue->cell;
14952 #if (ERRCLASS & ERRCLS_DEBUG)
14953 #endif
14954
14955    TRC2(rgSCHCmnTmrExpiry);
14956
14957 #if (ERRCLASS & ERRCLS_DEBUG)
14958    if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
14959    {
14960       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
14961          "timer event CRNTI:%d",ue->ueId);
14962       RETVALUE(RFAILED);
14963    }
14964 #else
14965    UNUSED(tmrEvnt);
14966 #endif
14967
14968    rgSCHCmnApplyUeRefresh(cell, ue);
14969
14970    rgSCHCmnAddUeToRefreshQ(cell, ue, RG_SCH_CMN_REFRESH_TIME);
14971
14972    RETVALUE(ROK);
14973 }
14974
14975 /***********************************************************
14976  *
14977  *     Func : rgSCHCmnTmrProc
14978  *
14979  *     Desc : Timer entry point per cell. Timer
14980  *            processing is triggered at every frame boundary
14981  *            (every 10 ms).
14982  *
14983  *     Ret  :
14984  *
14985  *     Notes:
14986  *
14987  *     File :
14988  *
14989  **********************************************************/
14990 #ifdef ANSI
14991 PRIVATE S16 rgSCHCmnTmrProc
14992 (
14993 RgSchCellCb *cell
14994 )
14995 #else
14996 PRIVATE S16 rgSCHCmnTmrProc(cell)
14997 RgSchCellCb *cell;
14998 #endif
14999 {
15000    RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
15001    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
15002    /* Moving the assignment of scheduler pointer
15003      to available scope for optimization */
15004    TRC2(rgSCHCmnTmrProc);
15005
15006    if ((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES_5G) == 0)
15007    {
15008       /* Reset the counters periodically */
15009       if ((cell->crntTime.sfn % RG_SCH_CMN_CSG_REFRESH_TIME) == 0)
15010       {
15011          RG_SCH_RESET_HCSG_DL_PRB_CNTR(cmnDlCell);
15012          RG_SCH_RESET_HCSG_UL_PRB_CNTR(cmnUlCell);
15013       }
15014       if ((cell->crntTime.sfn % RG_SCH_CMN_OVRLDCTRL_REFRESH_TIME) == 0)
15015       {
15016
15017          cell->measurements.ulTpt =  ((cell->measurements.ulTpt * 95) + ( cell->measurements.ulBytesCnt * 5))/100;
15018          cell->measurements.dlTpt =  ((cell->measurements.dlTpt * 95) + ( cell->measurements.dlBytesCnt * 5))/100;
15019
15020          rgSCHUtlCpuOvrLdAdjItbsCap(cell);
15021          /* reset cell level tpt measurements for next cycle */
15022          cell->measurements.ulBytesCnt = 0;
15023          cell->measurements.dlBytesCnt = 0;
15024       }
15025       /* Comparing with Zero instead of % is being done for efficiency.
15026        * If Timer resolution changes then accordingly update the
15027        * macro RG_SCH_CMN_REFRESH_TIMERES */    
15028       RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
15029       cmPrcTmr(&sched->tmrTqCp, sched->tmrTq, (PFV)rgSCHCmnTmrExpiry);
15030    }
15031
15032    RETVALUE(ROK);
15033 }
15034
15035
15036 /***********************************************************
15037  *
15038  *     Func : rgSchCmnUpdCfiVal 
15039  *
15040  *     Desc : Update the CFI value if CFI switch was done 
15041  *
15042  *     Ret  :
15043  *
15044  *     Notes:
15045  *
15046  *     File :
15047  *
15048  **********************************************************/
15049 #ifdef ANSI
15050 PRIVATE Void rgSchCmnUpdCfiVal
15051 (
15052 RgSchCellCb     *cell,
15053 U8              delta
15054 )
15055 #else
15056 PRIVATE Void rgSchCmnUpdCfiVal(cell, delta)
15057 RgSchCellCb     *cell;
15058 U8              delta;
15059 #endif  
15060 {
15061    RgSchDlSf        *dlSf;
15062    CmLteTimingInfo  pdsch;
15063    RgSchCmnDlCell  *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell); 
15064    U8               dlIdx;
15065 #ifdef LTE_TDD
15066    U8               mPhich;
15067    RgSchDlSf        *tddSf;
15068    U8               idx;
15069    U8               splSfCfi = 0;
15070 #endif    
15071
15072    TRC2(rgSchCmnUpdCfiVal);
15073
15074    pdsch  = cell->crntTime;
15075    RGSCH_INCR_SUB_FRAME(pdsch, delta);
15076    dlSf = rgSCHUtlSubFrmGet(cell, pdsch);
15077    /* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
15078     *change happens in that SF then UL PDCCH allocation happens with old CFI
15079     *but CFI in control Req goes updated one since it was stored in the CELL
15080     */
15081    dlSf->pdcchInfo.currCfi = cellCmnDl->currCfi;
15082    if(cell->dynCfiCb.pdcchSfIdx != 0xFF) 
15083    {
15084 #ifdef LTE_TDD
15085       dlIdx = rgSCHUtlGetDlSfIdx(cell, &pdsch);
15086 #else
15087       dlIdx = (((pdsch.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (pdsch.slot % RGSCH_NUM_SUB_FRAMES));
15088       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
15089 #endif  
15090       /* If current downlink subframe index is same as pdcch SF index,
15091        * perform the switching of CFI in this subframe */
15092       if(cell->dynCfiCb.pdcchSfIdx == dlIdx)
15093       {
15094          cellCmnDl->currCfi  = cellCmnDl->newCfi;
15095          cell->dynCfiCb.pdcchSfIdx = 0xFF;
15096
15097          /* Updating the nCce value based on the new CFI */
15098 #ifdef LTE_TDD
15099          splSfCfi = cellCmnDl->newCfi;
15100          for(idx = 0; idx < cell->numDlSubfrms; idx++)
15101          {   
15102             tddSf = cell->subFrms[idx];
15103
15104             mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][tddSf->sfNum];
15105
15106             if(tddSf->sfType == RG_SCH_SPL_SF_DATA)
15107             {
15108                RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, splSfCfi);
15109
15110                tddSf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][splSfCfi];
15111             }
15112             else
15113             {   
15114                tddSf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][cellCmnDl->currCfi];
15115             }
15116          }
15117          /* Setting the switch over window length based on config index.
15118           * During switch over period all the UL trnsmissions are Acked 
15119           * to UEs */
15120          cell->dynCfiCb.switchOvrWinLen = 
15121                rgSchCfiSwitchOvrWinLen[cell->ulDlCfgIdx];
15122 #else
15123          cell->nCce = cell->dynCfiCb.cfi2NCceTbl[0][cellCmnDl->currCfi];
15124          /* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
15125           *change happens in that SF then UL PDCCH allocation happens with old CFI
15126           *but CFI in control Req goes updated one since it was stored in the CELL
15127           */
15128          dlSf->pdcchInfo.currCfi = cellCmnDl->currCfi;
15129          cell->dynCfiCb.switchOvrWinLen = rgSchCfiSwitchOvrWinLen[7];
15130 #endif
15131       }   
15132    }   
15133
15134    RETVOID;
15135 }
15136
15137 /***********************************************************
15138  *
15139  *     Func : rgSchCmnUpdtPdcchSfIdx 
15140  *
15141  *     Desc : Update the switch over window length
15142  *
15143  *     Ret  : void
15144  *
15145  *     Notes:
15146  *
15147  *     File :
15148  *
15149  **********************************************************/
15150 #ifdef LTE_TDD
15151 #ifdef ANSI
15152 PRIVATE Void rgSchCmnUpdtPdcchSfIdx 
15153 (
15154 RgSchCellCb     *cell,
15155 U8              dlIdx,
15156 U8              sfNum
15157 )
15158 #else
15159 PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
15160 RgSchCellCb     *cell;
15161 U8              dlIdx;
15162 U8              sfNum;
15163 #endif   
15164 #else
15165 #ifdef ANSI
15166 PRIVATE Void rgSchCmnUpdtPdcchSfIdx 
15167 (
15168 RgSchCellCb     *cell,
15169 U8              dlIdx
15170 )
15171 #else
15172 PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
15173 RgSchCellCb     *cell;
15174 U8              dlIdx;
15175 #endif    
15176 #endif
15177 {
15178    U8         idx;
15179
15180    TRC2(rgSchCmnUpdtPdcchSfIdx);
15181
15182    /* Resetting the parameters on CFI switching */
15183    cell->dynCfiCb.cceUsed = 0;
15184    cell->dynCfiCb.lowCceCnt = 0;
15185
15186    cell->dynCfiCb.cceFailSum = 0;
15187    cell->dynCfiCb.cceFailCnt = 0;
15188    cell->dynCfiCb.prevCceFailIdx = 0;
15189
15190    cell->dynCfiCb.switchOvrInProgress = TRUE;
15191
15192    for(idx = 0; idx < cell->dynCfiCb.numFailSamples; idx++)
15193    {
15194       cell->dynCfiCb.cceFailSamples[idx] = 0;
15195    }   
15196
15197    cell->dynCfiCb.ttiCnt = 0;
15198
15199    cell->dynCfiCb.cfiSwitches++;
15200    cfiSwitchCnt = cell->dynCfiCb.cfiSwitches;
15201
15202 #ifdef LTE_TDD 
15203    cell->dynCfiCb.pdcchSfIdx = (dlIdx + 
15204       rgSchTddPdcchSfIncTbl[cell->ulDlCfgIdx][sfNum]) % cell->numDlSubfrms;
15205 #else
15206    cell->dynCfiCb.pdcchSfIdx = (dlIdx + RG_SCH_CFI_APPLY_DELTA) % \
15207         RGSCH_NUM_DL_slotS;
15208 #endif
15209 }
15210
15211 /***********************************************************
15212  *
15213  *     Func : rgSchCmnUpdCfiDb 
15214  *
15215  *     Desc : Update the counters related to dynamic
15216  *            CFI feature in cellCb. 
15217  *
15218  *     Ret  :
15219  *
15220  *     Notes:
15221  *
15222  *     File :
15223  *
15224  **********************************************************/
15225 #ifdef ANSI
15226 PUBLIC Void rgSchCmnUpdCfiDb 
15227 (
15228 RgSchCellCb     *cell,
15229 U8              delta 
15230 )
15231 #else
15232 PUBLIC Void rgSchCmnUpdCfiDb(cell, delta)
15233 RgSchCellCb     *cell;
15234 U8              delta;
15235 #endif 
15236 {
15237    CmLteTimingInfo        frm;
15238    RgSchDlSf              *dlSf;
15239 #ifdef LTE_TDD
15240    U8                     mPhich;
15241    Bool                   isHiDci0; 
15242 #endif      
15243    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell); 
15244    U8                     nCceLowerCfi = 0;
15245    U8                     currCfi;
15246    U8                     cceFailIdx;
15247    U32                    totalCce;
15248    U8                     dlIdx;
15249    U16                    ttiMod;
15250
15251    TRC2(rgSchCmnUpdCfiDb);
15252
15253    /* Get Downlink Subframe */   
15254    frm   = cell->crntTime;
15255    RGSCH_INCR_SUB_FRAME(frm, delta);
15256
15257 #ifdef LTE_TDD
15258    dlIdx = rgSCHUtlGetDlSfIdx(cell, &frm);
15259    dlSf = cell->subFrms[dlIdx];
15260    isHiDci0 = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][dlSf->sfNum];
15261 #else
15262    /* Changing the idexing
15263       so that proper subframe is selected */
15264    dlIdx = (((frm.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (frm.slot % RGSCH_NUM_SUB_FRAMES));
15265    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
15266    dlSf = cell->subFrms[dlIdx];
15267 #endif 
15268
15269    currCfi = cellSch->dl.currCfi;
15270
15271    if(!cell->dynCfiCb.switchOvrInProgress)
15272    {   
15273       do{
15274          if(!cell->dynCfiCb.isDynCfiEnb)
15275          {
15276             if(currCfi != cellSch->cfiCfg.cfi)
15277             {
15278                if(currCfi < cellSch->cfiCfg.cfi)
15279                {
15280                   RG_SCH_CFI_STEP_UP(cell, cellSch, currCfi)
15281                   cfiIncr = cell->dynCfiCb.cfiIncr;   
15282                }
15283                else
15284                {
15285                   RG_SCH_CFI_STEP_DOWN(cell, cellSch, currCfi)
15286                   cfiDecr = cell->dynCfiCb.cfiDecr;
15287                }
15288             }
15289             break;
15290          }
15291
15292 #ifdef LTE_TDD         
15293          /* Setting ttiMod to 0 for ttiCnt > 1000 in case if this 
15294           * function was not called in UL subframe*/
15295          if(cell->dynCfiCb.ttiCnt > RGSCH_CFI_TTI_MON_INTRVL)
15296          {   
15297             ttiMod = 0;
15298          }
15299          else
15300 #endif
15301          {   
15302             ttiMod = cell->dynCfiCb.ttiCnt % RGSCH_CFI_TTI_MON_INTRVL;
15303          }
15304
15305          dlSf->dlUlBothCmplt++;
15306 #ifdef LTE_TDD      
15307          if((dlSf->dlUlBothCmplt == 2) || (!isHiDci0))
15308 #else
15309          if(dlSf->dlUlBothCmplt == 2)
15310 #endif         
15311          {
15312             /********************STEP UP CRITERIA********************/
15313             /* Updating the CCE failure count parameter */
15314             cell->dynCfiCb.cceFailCnt += dlSf->isCceFailure;
15315             cell->dynCfiCb.cceFailSum += dlSf->isCceFailure;
15316
15317             /* Check if cfi step up can be performed */
15318             if(currCfi < cell->dynCfiCb.maxCfi)
15319             {
15320                if(cell->dynCfiCb.cceFailSum >= cell->dynCfiCb.cfiStepUpTtiCnt) 
15321                {
15322                   RG_SCH_CFI_STEP_UP(cell, cellSch, currCfi)
15323                   cfiIncr = cell->dynCfiCb.cfiIncr;   
15324                   break;
15325                }
15326             } 
15327
15328             /********************STEP DOWN CRITERIA********************/
15329
15330             /* Updating the no. of CCE used in this dl subframe */
15331             cell->dynCfiCb.cceUsed += dlSf->cceCnt;
15332
15333             if(currCfi > RGSCH_MIN_CFI_VAL)
15334             {   
15335                /* calculating the number of CCE for next lower CFI */
15336 #ifdef LTE_TDD      
15337                mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][dlSf->sfNum];
15338                nCceLowerCfi = cell->dynCfiCb.cfi2NCceTbl[mPhich][currCfi-1];
15339 #else
15340                nCceLowerCfi = cell->dynCfiCb.cfi2NCceTbl[0][currCfi-1];
15341 #endif     
15342                if(dlSf->cceCnt < nCceLowerCfi)
15343                {
15344                   /* Updating the count of TTIs in which no. of CCEs
15345                    * used were less than the CCEs of next lower CFI */
15346                   cell->dynCfiCb.lowCceCnt++;
15347                }   
15348
15349                if(ttiMod == 0)
15350                {
15351                   totalCce = (nCceLowerCfi * cell->dynCfiCb.cfiStepDownTtiCnt * 
15352                         RGSCH_CFI_CCE_PERCNTG)/100;
15353
15354                   if((!cell->dynCfiCb.cceFailSum) && 
15355                         (cell->dynCfiCb.lowCceCnt >= 
15356                          cell->dynCfiCb.cfiStepDownTtiCnt) && 
15357                         (cell->dynCfiCb.cceUsed < totalCce))  
15358                   {
15359                      RG_SCH_CFI_STEP_DOWN(cell, cellSch, currCfi)
15360                      cfiDecr = cell->dynCfiCb.cfiDecr; 
15361                      break;
15362                   }
15363                }   
15364             }
15365
15366             cceFailIdx = ttiMod/cell->dynCfiCb.failSamplePrd;
15367
15368             if(cceFailIdx != cell->dynCfiCb.prevCceFailIdx)
15369             {   
15370                /* New sample period has started. Subtract the old count  
15371                 * from the new sample period */
15372                cell->dynCfiCb.cceFailSum -= cell->dynCfiCb.cceFailSamples[cceFailIdx];
15373
15374                /* Store the previous sample period data */
15375                cell->dynCfiCb.cceFailSamples[cell->dynCfiCb.prevCceFailIdx]
15376                   = cell->dynCfiCb.cceFailCnt;
15377
15378                cell->dynCfiCb.prevCceFailIdx = cceFailIdx;
15379
15380                /* Resetting the CCE failure count as zero for next sample period */
15381                cell->dynCfiCb.cceFailCnt = 0;  
15382             }
15383
15384             if(ttiMod == 0)
15385             {   
15386                /* Restting the parametrs after Monitoring Interval expired */
15387                cell->dynCfiCb.cceUsed = 0;
15388                cell->dynCfiCb.lowCceCnt = 0;
15389                cell->dynCfiCb.ttiCnt = 0;
15390             }
15391
15392             cell->dynCfiCb.ttiCnt++;
15393          }
15394       }while(0);
15395
15396       if(cellSch->dl.newCfi != cellSch->dl.currCfi)
15397       {
15398 #ifdef LTE_TDD      
15399          rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, dlSf->sfNum);
15400 #else
15401          rgSchCmnUpdtPdcchSfIdx(cell, dlIdx);
15402 #endif      
15403       }  
15404    }
15405 }   
15406
15407 /**
15408  * @brief Dl Scheduler for Broadcast and Common channel scheduling.
15409  *
15410  * @details
15411  *
15412  *     Function: rgSCHCmnDlCommonChSch
15413  *     Purpose:  This function schedules DL Common channels for LTE. 
15414  *               Invoked by TTI processing in TOM. Scheduling is done for 
15415  *               BCCH, PCCH, Msg4, CCCH SDU, RAR in that order 
15416  *
15417  *     Invoked by: TOM (TTI processing)
15418  *
15419  *  @param[in]  RgSchCellCb *cell
15420  *  @return  Void
15421  **/
15422 #ifdef ANSI
15423 PUBLIC Void rgSCHCmnDlCommonChSch
15424 (
15425 RgSchCellCb  *cell
15426 )
15427 #else
15428 PUBLIC Void rgSCHCmnDlCommonChSch(cell)
15429 RgSchCellCb  *cell;
15430 #endif
15431 {
15432    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
15433
15434    TRC2(rgSCHCmnDlCommonChSch);
15435
15436    cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
15437    rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
15438
15439    /* handle Inactive UEs for DL */
15440    rgSCHCmnHdlDlInactUes(cell);
15441
15442    /* Send a Tick to Refresh Timer */
15443    rgSCHCmnTmrProc(cell);
15444
15445    if (cell->isDlDataAllwd && (cell->stopSiSch == FALSE)) 
15446    {
15447       rgSCHCmnInitRbAlloc(cell); 
15448       /* Perform DL scheduling of BCCH, PCCH */
15449       rgSCHCmnDlBcchPcchAlloc(cell);
15450    }
15451    else
15452    {
15453       if(cell->siCb.inWindow != 0)
15454       {
15455          cell->siCb.inWindow--;
15456       }
15457    }
15458    if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
15459    {
15460       rgSCHCmnDlCcchRarAlloc(cell);
15461    }
15462    RETVOID;
15463 }
15464
15465 /**
15466  * @brief Scheduler invocation per TTI.
15467  *
15468  * @details
15469  *
15470  *     Function: rgSCHCmnUlSch
15471  *     Purpose:  This function implements UL scheduler alone. This is to
15472  *               be able to perform scheduling with more flexibility.
15473  *
15474  *     Invoked by: TOM (TTI processing)
15475  *
15476  *  @param[in]  RgSchCellCb *cell
15477  *  @return  Void
15478  **/
15479 #ifdef ANSI
15480 PUBLIC Void rgSCHCmnUlSch
15481 (
15482 RgSchCellCb  *cell
15483 )
15484 #else
15485 PUBLIC Void  rgSCHCmnUlSch(cell)
15486 RgSchCellCb  *cell;
15487 #endif
15488 {
15489    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
15490    
15491    TRC2(rgSCHCmnUlSch);
15492
15493 #ifdef LTE_ADV
15494    /* LAA_SCELL: */
15495    if(TRUE == rgSCHLaaSCellEnabled(cell))
15496    {
15497       RETVOID;   
15498    }
15499 #endif
15500    
15501    if(cellSch->ul.schdIdx != RGSCH_INVALID_INFO)
15502    {   
15503       rgSchCmnUpdCfiVal(cell, TFU_ULCNTRL_DLDELTA);
15504
15505       /* Handle Inactive UEs for UL */
15506       rgSCHCmnHdlUlInactUes(cell);
15507       /* Perform UL Scheduling EVERY TTI */
15508       rgSCHCmnUlAlloc(cell);
15509
15510       /* Calling function to update CFI parameters*/
15511       rgSchCmnUpdCfiDb(cell, TFU_ULCNTRL_DLDELTA);   
15512
15513       if(cell->dynCfiCb.switchOvrWinLen > 0)
15514       {
15515          /* Decrementing the switchover window length */
15516          cell->dynCfiCb.switchOvrWinLen--;
15517
15518          if(!cell->dynCfiCb.switchOvrWinLen)
15519          {   
15520             if(cell->dynCfiCb.dynCfiRecfgPend)
15521             {  
15522                /* Toggling the Dynamic CFI enabling */
15523                cell->dynCfiCb.isDynCfiEnb ^= 1;
15524                rgSCHDynCfiReCfg(cell, cell->dynCfiCb.isDynCfiEnb); 
15525                cell->dynCfiCb.dynCfiRecfgPend = FALSE;
15526             }   
15527             cell->dynCfiCb.switchOvrInProgress = FALSE;
15528          }
15529       }
15530    }
15531 #ifdef LTE_TDD
15532 #ifdef LTEMAC_SPS
15533    else
15534    {
15535       rgSCHCmnSpsUlTti(cell, NULLP); 
15536    }
15537 #endif
15538 #endif
15539
15540    RETVOID;
15541 }
15542
15543 \f
15544 /**
15545  * @brief This function updates the scheduler with service for an UE.
15546  *
15547  * @details
15548  *
15549  *     Function: rgSCHCmnDlDedBoUpd
15550  *     Purpose:  This function should be called whenever there is a
15551  *               change BO for a service.
15552  *
15553  *     Invoked by: BO and Scheduler
15554  *
15555  *  @param[in]  RgSchCellCb*  cell
15556  *  @param[in]  RgSchUeCb*    ue
15557  *  @param[in]  RgSchDlLcCb*  svc
15558  *  @return  Void
15559  *
15560  **/
15561 #ifdef ANSI
15562 PUBLIC Void rgSCHCmnDlDedBoUpd
15563 (
15564 RgSchCellCb                *cell,
15565 RgSchUeCb                  *ue,
15566 RgSchDlLcCb                *svc
15567 )
15568 #else
15569 PUBLIC Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
15570 RgSchCellCb                *cell;
15571 RgSchUeCb                  *ue;
15572 RgSchDlLcCb                *svc;
15573 #endif
15574 {
15575    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15576    TRC2(rgSCHCmnDlDedBoUpd);
15577
15578    /* RACHO : if UEs idle time exceeded and a BO update
15579     * is received, then add UE to the pdcch Order Q */
15580    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
15581    {
15582       RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue, cell);
15583       /* If PDCCH order is already triggered and we are waiting for
15584        * RACH from UE then do not add to PdcchOdrQ. */
15585       if (ueDl->rachInfo.rapIdLnk.node == NULLP)
15586       {
15587          rgSCHCmnDlAdd2PdcchOdrQ(cell, ue);
15588       }
15589    }
15590
15591 #ifdef LTEMAC_SPS
15592
15593    /* If SPS service, invoke SPS module */
15594    if (svc->dlLcSpsCfg.isSpsEnabled)
15595    {
15596       rgSCHCmnSpsDlDedBoUpd(cell, ue, svc);
15597       /* Note: Retrun from here, no update needed in other schedulers */
15598       RETVOID;
15599    }
15600 #endif
15601 #ifdef EMTC_ENABLE
15602    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
15603    {
15604       cellSch->apisEmtcDl->rgSCHDlDedBoUpd(cell, ue, svc);
15605       //printf("rgSCHEMTCDlDedBoUpd\n");
15606    }
15607    else
15608 #endif
15609    {
15610       cellSch->apisDl->rgSCHDlDedBoUpd(cell, ue, svc);
15611    }
15612 #ifdef LTE_ADV
15613    if (ue->numSCells)
15614    {
15615       rgSCHSCellDlDedBoUpd(cell, ue, svc);
15616    }
15617 #endif
15618    RETVOID;
15619 }
15620
15621 \f
15622 /**
15623  * @brief Removes an UE from Cell's TA List.
15624  *
15625  * @details
15626  *
15627  *     Function: rgSCHCmnRmvFrmTaLst
15628  *     Purpose:  Removes an UE from Cell's TA List.
15629  *
15630  *     Invoked by: Specific Scheduler
15631  *
15632  *  @param[in]  RgSchCellCb*     cell
15633  *  @param[in]  RgSchUeCb*       ue
15634  *  @return  Void
15635  *
15636  **/
15637 #ifdef ANSI
15638 PUBLIC Void rgSCHCmnRmvFrmTaLst
15639 (
15640 RgSchCellCb                *cell,
15641 RgSchUeCb                  *ue
15642 )
15643 #else
15644 PUBLIC Void rgSCHCmnRmvFrmTaLst(cell, ue)
15645 RgSchCellCb                *cell;
15646 RgSchUeCb                  *ue;
15647 #endif
15648 {
15649    RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
15650    TRC2(rgSCHCmnRmvFrmTaLst);
15651
15652 #ifdef EMTC_ENABLE
15653    if(cell->emtcEnable && ue->isEmtcUe)
15654    {
15655       rgSCHEmtcRmvFrmTaLst(cellCmnDl,ue);
15656    }
15657    else
15658 #endif
15659    {
15660       cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
15661       ue->dlTaLnk.node = (PTR)NULLP;
15662    }
15663    RETVOID;
15664 }
15665
15666 /* Fix: syed Remove the msg4Proc from cell
15667  * msg4Retx Queue. I have used CMN scheduler function
15668  * directly. Please define a new API and call this
15669  * function through that. */        
15670 \f
15671 /**
15672  * @brief This function removes MSG4 HARQ process from cell RETX Queues.
15673  *
15674  * @details
15675  *
15676  *     Function: rgSCHCmnDlMsg4ProcRmvFrmRetx
15677  *     Purpose:  This function removes MSG4 HARQ process from cell RETX Queues.
15678  *
15679  *     Invoked by: UE/RACB deletion. 
15680  *
15681  *  @param[in]  RgSchCellCb*     cell
15682  *  @param[in]  RgSchDlHqProc*   hqP
15683  *  @return  Void
15684  *
15685  **/
15686 #ifdef ANSI
15687 PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx 
15688 (
15689 RgSchCellCb                *cell,
15690 RgSchDlHqProcCb            *hqP
15691 )
15692 #else
15693 PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
15694 RgSchCellCb                *cell;
15695 RgSchDlHqProcCb            *hqP;
15696 #endif
15697 {
15698    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15699    TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
15700
15701    if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
15702    {
15703       if (hqP->hqE->msg4Proc == hqP)
15704       {
15705          cmLListDelFrm(&cellSch->dl.msg4RetxLst, \
15706                &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15707          hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
15708       }
15709 #ifdef RGR_V1
15710       else if(hqP->hqE->ccchSduProc == hqP)
15711       {
15712          cmLListDelFrm(&cellSch->dl.ccchSduRetxLst,
15713                &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15714          hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
15715       }
15716 #endif
15717    }
15718    RETVOID;
15719 }
15720
15721 \f
15722 /**
15723  * @brief This function adds a HARQ process for retx.
15724  *
15725  * @details
15726  *
15727  *     Function: rgSCHCmnDlProcAddToRetx
15728  *     Purpose:  This function adds a HARQ process to retransmission
15729  *               queue. This may be performed when a HARQ ack is
15730  *               unsuccessful.
15731  *
15732  *     Invoked by: HARQ feedback processing
15733  *
15734  *  @param[in]  RgSchCellCb*     cell
15735  *  @param[in]  RgSchDlHqProc*   hqP
15736  *  @return  Void
15737  *
15738  **/
15739 #ifdef ANSI
15740 PUBLIC Void rgSCHCmnDlProcAddToRetx
15741 (
15742 RgSchCellCb                *cell,
15743 RgSchDlHqProcCb            *hqP
15744 )
15745 #else
15746 PUBLIC Void rgSCHCmnDlProcAddToRetx(cell, hqP)
15747 RgSchCellCb                *cell;
15748 RgSchDlHqProcCb            *hqP;
15749 #endif
15750 {
15751    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15752    TRC2(rgSCHCmnDlProcAddToRetx);
15753
15754    if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
15755    {
15756       cmLListAdd2Tail(&cellSch->dl.msg4RetxLst, \
15757             &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15758       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)hqP;
15759    }
15760 #ifdef RGR_V1
15761    else if(hqP->hqE->ccchSduProc == hqP)
15762    {
15763       /*If CCCH SDU being transmitted without cont res CE*/
15764       cmLListAdd2Tail(&cellSch->dl.ccchSduRetxLst,
15765             &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15766       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)hqP;
15767    }
15768 #endif
15769    else
15770    {
15771 #ifdef LTEMAC_SPS
15772       if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
15773       {
15774          /* Invoke SPS module for SPS HARQ proc re-transmission handling */
15775          rgSCHCmnSpsDlProcAddToRetx(cell, hqP);
15776          RETVOID;
15777       }
15778 #endif /* LTEMAC_SPS */
15779 #ifdef EMTC_ENABLE      
15780       if((TRUE == cell->emtcEnable)
15781          && (TRUE == hqP->hqE->ue->isEmtcUe))
15782       {
15783          cellSch->apisEmtcDl->rgSCHDlProcAddToRetx(cell, hqP);
15784       }
15785       else
15786 #endif         
15787       {
15788          cellSch->apisDl->rgSCHDlProcAddToRetx(cell, hqP);
15789       }
15790    }
15791    RETVOID;
15792 }
15793
15794 \f
15795 /**
15796  * @brief This function performs RI validation and
15797  *        updates it to the ueCb.
15798  *
15799  * @details
15800  *
15801  *     Function: rgSCHCmnDlSetUeRi
15802  *     Purpose:  This function performs RI validation and
15803  *        updates it to the ueCb.
15804  *
15805  *     Invoked by: rgSCHCmnDlCqiInd
15806  *
15807  *  @param[in]  RgSchCellCb        *cell
15808  *  @param[in]  RgSchUeCb          *ue
15809  *  @param[in]  U8                 ri
15810  *  @param[in]  Bool               isPeriodic
15811  *  @return  Void
15812  *
15813  **/
15814 #ifdef ANSI
15815 PRIVATE Void rgSCHCmnDlSetUeRi
15816 (
15817 RgSchCellCb        *cell,
15818 RgSchUeCb          *ue,
15819 U8                 ri,
15820 Bool               isPer
15821 )
15822 #else
15823 PRIVATE Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
15824 RgSchCellCb        *cell;
15825 RgSchUeCb          *ue;
15826 U8                 ri;
15827 Bool               isPer;
15828 #endif
15829 {
15830    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
15831    RgSchCmnUeInfo    *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
15832    TRC2(rgSCHCmnDlSetUeRi);
15833    
15834 #ifdef TFU_UPGRADE
15835    RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
15836    UNUSED(isPer);
15837 #endif
15838
15839
15840    /* FIX for RRC Reconfiguration issue */
15841    /* ccpu00140894- During Tx Mode transition RI report will not entertained for 
15842     * specific during which SCH expecting UE can complete TX mode transition*/
15843    if (ue->txModeTransCmplt == FALSE)
15844    {
15845       RETVOID;
15846    }
15847
15848    /* Restrict the Number of TX layers to cell->numTxAntPorts.
15849     * Protection from invalid RI values. */
15850    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
15851    
15852    /* Special case of converting PMI to sane value when
15853     * there is a switch in RI from 1 to 2 and PMI reported 
15854     * for RI=1 is invalid for RI=2 */
15855    if ((cell->numTxAntPorts == 2) && (ue->mimoInfo.txMode == RGR_UE_TM_4))
15856    {
15857       if ((ri == 2) && ( ueDl->mimoInfo.ri == 1))
15858       {
15859          ueDl->mimoInfo.pmi = (ueDl->mimoInfo.pmi < 2)? 1:2;
15860       }
15861    }
15862
15863    /* Restrict the Number of TX layers according to the UE Category */
15864    ueDl->mimoInfo.ri = RGSCH_MIN(ri, rgUeCatTbl[ueSchCmn->ueCat].maxTxLyrs);
15865 #ifdef TENB_STATS
15866    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].riCnt[ueDl->mimoInfo.ri-1]++;
15867    cell->tenbStats->sch.riCnt[ueDl->mimoInfo.ri-1]++;
15868 #endif
15869
15870 #ifdef TENB_STATS
15871    ue->tenbStats->stats.nonPersistent.sch[0].riCnt[ueDl->mimoInfo.ri-1]++;
15872    cell->tenbStats->sch.riCnt[ueDl->mimoInfo.ri-1]++;
15873 #endif
15874
15875 #ifdef TFU_UPGRADE
15876    if (isPer)
15877    {
15878       /* If RI is from Periodic CQI report */
15879       cqiCb->perRiVal = ueDl->mimoInfo.ri;
15880       /* Reset at every Periodic RI Reception */ 
15881       cqiCb->invalidateCqi = FALSE;
15882    }
15883    else
15884    {
15885       /* If RI is from Aperiodic CQI report */
15886       if (cqiCb->perRiVal != ueDl->mimoInfo.ri)
15887       {
15888          /* if this aperRI is different from last reported
15889           * perRI then invalidate all CQI reports till next
15890           * perRI */
15891          cqiCb->invalidateCqi = TRUE;
15892       }
15893       else
15894       {
15895          cqiCb->invalidateCqi = FALSE;
15896       }
15897    }
15898 #endif   
15899
15900    if (ueDl->mimoInfo.ri > 1)
15901    {
15902       RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
15903    }
15904    else if (ue->mimoInfo.txMode == RGR_UE_TM_3) /* ri == 1 */
15905    {
15906       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
15907    }
15908
15909    RETVOID;
15910 }
15911
15912 \f
15913 /**
15914  * @brief This function performs PMI validation and
15915  *        updates it to the ueCb.
15916  *
15917  * @details
15918  *
15919  *     Function: rgSCHCmnDlSetUePmi
15920  *     Purpose:  This function performs PMI validation and
15921  *        updates it to the ueCb.
15922  *
15923  *     Invoked by: rgSCHCmnDlCqiInd
15924  *
15925  *  @param[in]  RgSchCellCb        *cell
15926  *  @param[in]  RgSchUeCb          *ue
15927  *  @param[in]  U8                 pmi
15928  *  @return  Void
15929  *
15930  **/
15931 #ifdef ANSI
15932 PRIVATE S16 rgSCHCmnDlSetUePmi
15933 (
15934 RgSchCellCb        *cell,
15935 RgSchUeCb          *ue,
15936 U8                 pmi
15937 )
15938 #else
15939 PRIVATE S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
15940 RgSchCellCb        *cell;
15941 RgSchUeCb          *ue;
15942 U8                 pmi;
15943 #endif
15944 {
15945    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
15946    TRC2(rgSCHCmnDlSetUePmi);
15947
15948    if (ue->txModeTransCmplt == FALSE)
15949    {
15950        RETVALUE(RFAILED);
15951    }
15952  
15953    if (cell->numTxAntPorts == 2)
15954    {
15955       if (pmi > 3)
15956       {
15957          RETVALUE(RFAILED);
15958       }
15959       if (ueDl->mimoInfo.ri == 2)
15960       {
15961          /*ccpu00118150 - MOD - changed pmi value validation from 0 to 2*/
15962          /* PMI 2 and 3 are invalid incase of 2 TxAnt and 2 Layered SM */
15963          if (pmi == 2 || pmi == 3)
15964          {
15965             RETVALUE(RFAILED);
15966          }
15967          ueDl->mimoInfo.pmi = pmi+1;
15968       }
15969       else
15970       {
15971          ueDl->mimoInfo.pmi = pmi;
15972       }
15973    }
15974    else if (cell->numTxAntPorts == 4)
15975    {
15976       if (pmi > 15)
15977       {
15978          RETVALUE(RFAILED);
15979       }
15980       ueDl->mimoInfo.pmi = pmi;
15981    }
15982    /* Reset the No PMI Flag in forceTD */
15983    RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
15984    RETVALUE(ROK);
15985 }
15986
15987 /**
15988  * @brief This function Updates the DL CQI on PUCCH for the UE.
15989  *
15990  * @details
15991  *
15992  *     Function: rgSCHCmnDlProcCqiMode10
15993  *
15994  *     This function updates the DL CQI on PUCCH for the UE.
15995  *
15996  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
15997  *
15998  *     Processing Steps:
15999  *
16000  *  @param[in] RgSchCellCb     *cell
16001  *  @param[in] RgSchUeCb       *ue
16002  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16003  *  @return  S16
16004  *      -# ROK
16005  *      -# RFAILED
16006  **/
16007 #ifdef RGR_CQI_REPT
16008 #ifdef ANSI
16009 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
16010 (
16011  RgSchCellCb        *cell,
16012  RgSchUeCb          *ue,
16013  TfuDlCqiPucch      *pucchCqi,
16014  Bool               *isCqiAvail
16015  )
16016 #else
16017 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail)
16018  RgSchCellCb        *cell;
16019  RgSchUeCb          *ue;
16020  TfuDlCqiPucch      *pucchCqi;
16021  Bool               *isCqiAvail;
16022 #endif
16023 #else
16024 #ifdef ANSI
16025 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
16026 (
16027  RgSchCellCb        *cell,
16028  RgSchUeCb          *ue,
16029  TfuDlCqiPucch      *pucchCqi
16030  )
16031 #else
16032 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi)
16033  RgSchCellCb        *cell;
16034  RgSchUeCb          *ue;
16035  TfuDlCqiPucch      *pucchCqi;
16036 #endif
16037 #endif
16038 {
16039    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16040    TRC2(rgSCHCmnDlProcCqiMode10);
16041
16042    if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
16043    {
16044       /*ccpu00109787 - ADD - Check for non-zero CQI*/
16045       /* Checking whether the decoded CQI is a value between 1 and 15*/
16046       if((pucchCqi->u.mode10Info.u.cqi) && (pucchCqi->u.mode10Info.u.cqi
16047                < RG_SCH_CMN_MAX_CQI))
16048       {
16049          ueDl->cqiFlag = TRUE;
16050          ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode10Info.u.cqi;
16051          ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16052          /* ccpu00117452 - MOD - Changed macro name from
16053             RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16054 #ifdef RGR_CQI_REPT
16055          *isCqiAvail = TRUE;
16056 #endif
16057       }
16058       else
16059       {
16060          RETVOID;
16061       }
16062    }
16063    else if (pucchCqi->u.mode10Info.type == TFU_RPT_RI)
16064    {
16065       if ( RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode10Info.u.ri) )
16066       {
16067          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode10Info.u.ri,
16068                            TRUE);
16069       }
16070       else
16071       {
16072          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16073             pucchCqi->u.mode10Info.u.ri,ue->ueId);
16074          RETVOID;
16075       }
16076    }
16077 }
16078
16079 /**
16080  * @brief This function Updates the DL CQI on PUCCH for the UE.
16081  *
16082  * @details
16083  *
16084  *     Function: rgSCHCmnDlProcCqiMode11
16085  *
16086  *     This function updates the DL CQI on PUCCH for the UE.
16087  *
16088  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16089  *
16090  *     Processing Steps:
16091  *       Process CQI MODE 11
16092  *  @param[in] RgSchCellCb     *cell
16093  *  @param[in] RgSchUeCb       *ue
16094  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16095  *  @return  S16
16096  *      -# ROK
16097  *      -# RFAILED
16098  **/
16099 #ifdef RGR_CQI_REPT
16100 #ifdef ANSI
16101 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
16102 (
16103  RgSchCellCb        *cell,
16104  RgSchUeCb          *ue,
16105  TfuDlCqiPucch      *pucchCqi,
16106  Bool               *isCqiAvail,
16107  Bool               *is2ndCwCqiAvail
16108  )
16109 #else
16110 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
16111  RgSchCellCb        *cell;
16112  RgSchUeCb          *ue;
16113  TfuDlCqiPucch      *pucchCqi;
16114  Bool               *isCqiAvail;
16115  Bool               *is2ndCwCqiAvail;
16116 #endif
16117 #else
16118 #ifdef ANSI
16119 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
16120 (
16121  RgSchCellCb        *cell,
16122  RgSchUeCb          *ue,
16123  TfuDlCqiPucch      *pucchCqi
16124  )
16125 #else
16126 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi)
16127  RgSchCellCb        *cell;
16128  RgSchUeCb          *ue;
16129  TfuDlCqiPucch      *pucchCqi;
16130 #endif
16131 #endif
16132 {
16133    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16134    TRC2(rgSCHCmnDlProcCqiMode11);
16135
16136    if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
16137    {
16138       ue->mimoInfo.puschFdbkVld  = FALSE;
16139       /*ccpu00109787 - ADD - Check for non-zero CQI*/
16140       if((pucchCqi->u.mode11Info.u.cqi.cqi) &&
16141             (pucchCqi->u.mode11Info.u.cqi.cqi < RG_SCH_CMN_MAX_CQI))
16142       {
16143          ueDl->cqiFlag = TRUE;
16144          /* ccpu00117452 - MOD - Changed macro name from
16145             RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16146 #ifdef RGR_CQI_REPT
16147          *isCqiAvail = TRUE;
16148 #endif
16149          ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode11Info.u.cqi.cqi;
16150          if (pucchCqi->u.mode11Info.u.cqi.wideDiffCqi.pres)
16151          {
16152             RG_SCH_UPDT_CW2_CQI(ueDl->mimoInfo.cwInfo[0].cqi, \
16153                                      ueDl->mimoInfo.cwInfo[1].cqi, \
16154                                      pucchCqi->u.mode11Info.u.cqi.wideDiffCqi.val);
16155 #ifdef RGR_CQI_REPT
16156             /* ccpu00117259 - ADD - Considering second codeword CQI info
16157                incase of MIMO for CQI Reporting */
16158             *is2ndCwCqiAvail = TRUE;
16159 #endif
16160          }
16161       }
16162       else
16163       {
16164          RETVOID;
16165       }
16166       rgSCHCmnDlSetUePmi(cell, ue, \
16167             pucchCqi->u.mode11Info.u.cqi.pmi);
16168    }
16169    else if (pucchCqi->u.mode11Info.type == TFU_RPT_RI)
16170    {
16171       if( RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode11Info.u.ri))
16172       {
16173          rgSCHCmnDlSetUeRi(cell, ue,  pucchCqi->u.mode11Info.u.ri,
16174                            TRUE);
16175       }
16176       else
16177       {
16178          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid RI value(%x) CRNTI:%d",
16179             pucchCqi->u.mode11Info.u.ri,ue->ueId);
16180          RETVOID;
16181       }
16182    }
16183 }
16184
16185 /**
16186  * @brief This function Updates the DL CQI on PUCCH for the UE.
16187  *
16188  * @details
16189  *
16190  *     Function: rgSCHCmnDlProcCqiMode20
16191  *
16192  *     This function updates the DL CQI on PUCCH for the UE.
16193  *
16194  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16195  *
16196  *     Processing Steps:
16197  *       Process CQI MODE 20
16198  *  @param[in] RgSchCellCb     *cell
16199  *  @param[in] RgSchUeCb       *ue
16200  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16201  *  @return  S16
16202  *      -# ROK
16203  *      -# RFAILED
16204  **/
16205 #ifdef RGR_CQI_REPT
16206 #ifdef ANSI
16207 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
16208 (
16209  RgSchCellCb        *cell,
16210  RgSchUeCb          *ue,
16211  TfuDlCqiPucch      *pucchCqi,
16212  Bool               *isCqiAvail
16213  )
16214 #else
16215 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail )
16216  RgSchCellCb        *cell;
16217  RgSchUeCb          *ue;
16218  TfuDlCqiPucch      *pucchCqi;
16219  Bool               *isCqiAvail;
16220 #endif
16221 #else
16222 #ifdef ANSI
16223 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
16224 (
16225  RgSchCellCb        *cell,
16226  RgSchUeCb          *ue,
16227  TfuDlCqiPucch      *pucchCqi
16228  )
16229 #else
16230 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi)
16231  RgSchCellCb        *cell;
16232  RgSchUeCb          *ue;
16233  TfuDlCqiPucch      *pucchCqi;
16234 #endif
16235 #endif
16236 {
16237    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16238    TRC2(rgSCHCmnDlProcCqiMode20);
16239
16240    if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
16241    {
16242       if (pucchCqi->u.mode20Info.u.cqi.isWideband)
16243       {
16244          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16245          if((pucchCqi->u.mode20Info.u.cqi.u.wideCqi) &&
16246                (pucchCqi->u.mode20Info.u.cqi.u.wideCqi < RG_SCH_CMN_MAX_CQI))
16247          {
16248             ueDl->cqiFlag = TRUE;
16249             ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode20Info.u.cqi.\
16250                                            u.wideCqi;
16251             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16252             /* ccpu00117452 - MOD - Changed macro name from
16253                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16254 #ifdef RGR_CQI_REPT
16255             *isCqiAvail = TRUE;
16256 #endif
16257          }
16258          else
16259          {
16260             RETVOID;
16261          }
16262       }
16263    }
16264    else if (pucchCqi->u.mode20Info.type == TFU_RPT_RI)
16265    {
16266       if(RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode20Info.u.ri))
16267       {
16268          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode20Info.u.ri, 
16269                            TRUE);
16270       }
16271       else
16272       {
16273          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16274             pucchCqi->u.mode20Info.u.ri,ue->ueId);
16275          RETVOID;
16276       }
16277    }
16278 }
16279
16280
16281 /**
16282  * @brief This function Updates the DL CQI on PUCCH for the UE.
16283  *
16284  * @details
16285  *
16286  *     Function: rgSCHCmnDlProcCqiMode21
16287  *
16288  *     This function updates the DL CQI on PUCCH for the UE.
16289  *
16290  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16291  *
16292  *     Processing Steps:
16293  *       Process CQI MODE 21
16294  *  @param[in] RgSchCellCb     *cell
16295  *  @param[in] RgSchUeCb       *ue
16296  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16297  *  @return  S16
16298  *      -# ROK
16299  *      -# RFAILED
16300  **/
16301 #ifdef RGR_CQI_REPT
16302 #ifdef ANSI
16303 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
16304 (
16305  RgSchCellCb        *cell,
16306  RgSchUeCb          *ue,
16307  TfuDlCqiPucch      *pucchCqi,
16308  Bool               *isCqiAvail,
16309  Bool               *is2ndCwCqiAvail
16310  )
16311 #else
16312 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
16313    RgSchCellCb        *cell;
16314    RgSchUeCb          *ue;
16315  TfuDlCqiPucch        *pucchCqi;
16316    TfuDlCqiRpt        *dlCqiRpt;
16317    Bool               *isCqiAvail;
16318    Bool               *is2ndCwCqiAvail;
16319 #endif
16320 #else
16321 #ifdef ANSI
16322 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
16323 (
16324  RgSchCellCb        *cell,
16325  RgSchUeCb          *ue,
16326  TfuDlCqiPucch      *pucchCqi
16327  )
16328 #else
16329 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi)
16330  RgSchCellCb        *cell;
16331  RgSchUeCb          *ue;
16332  TfuDlCqiPucch      *pucchCqi;
16333 #endif
16334 #endif
16335 {
16336    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16337    TRC2(rgSCHCmnDlProcCqiMode21);
16338
16339    if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
16340    {
16341       ue->mimoInfo.puschFdbkVld  = FALSE;
16342       if (pucchCqi->u.mode21Info.u.cqi.isWideband)
16343       {
16344          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16345          if((pucchCqi->u.mode21Info.u.cqi.u.wideCqi.cqi) &&
16346                (pucchCqi->u.mode21Info.u.cqi.u.wideCqi.cqi < RG_SCH_CMN_MAX_CQI))
16347          {
16348             ueDl->cqiFlag = TRUE;
16349             ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode21Info.u.cqi.\
16350                                            u.wideCqi.cqi;
16351             if (pucchCqi->u.mode21Info.u.cqi.u.wideCqi.diffCqi.pres)
16352             {
16353                RG_SCH_UPDT_CW2_CQI(ueDl->mimoInfo.cwInfo[0].cqi, \
16354                                      ueDl->mimoInfo.cwInfo[1].cqi, \
16355                                      pucchCqi->u.mode21Info.u.cqi.u.wideCqi.diffCqi.val);
16356 #ifdef RGR_CQI_REPT
16357                /* ccpu00117259 - ADD - Considering second codeword CQI info
16358                   incase of MIMO for CQI Reporting */
16359                *is2ndCwCqiAvail = TRUE;
16360 #endif
16361             }
16362             /* ccpu00117452 - MOD - Changed macro name from
16363                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16364 #ifdef RGR_CQI_REPT
16365             *isCqiAvail = TRUE;
16366 #endif
16367          }
16368          else
16369          {
16370             RETVOID;
16371          }
16372          rgSCHCmnDlSetUePmi(cell, ue, \
16373                pucchCqi->u.mode21Info.u.cqi.u.wideCqi.pmi);
16374       }
16375    }
16376    else if (pucchCqi->u.mode21Info.type == TFU_RPT_RI)
16377    {
16378       if(RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode21Info.u.ri))
16379       {
16380          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode21Info.u.ri,
16381                            TRUE);
16382       }
16383       else
16384       {
16385          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid RI value(%x) CRNTI:%d",
16386             pucchCqi->u.mode21Info.u.ri,ue->ueId);
16387          RETVOID;
16388       }
16389    }
16390 }
16391
16392
16393 /**
16394  * @brief This function Updates the DL CQI on PUCCH for the UE.
16395  *
16396  * @details
16397  *
16398  *     Function: rgSCHCmnDlCqiOnPucchInd
16399  *
16400  *     This function updates the DL CQI on PUCCH for the UE.
16401  *
16402  *     Invoked by: rgSCHCmnDlCqiInd
16403  *
16404  *     Processing Steps:
16405  *     - Depending on the reporting mode of the PUCCH, the CQI/PMI/RI values
16406  *       are updated and stored for each UE
16407  *
16408  *  @param[in] RgSchCellCb     *cell
16409  *  @param[in] RgSchUeCb       *ue
16410  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16411  *  @return  S16
16412  *      -# ROK
16413  *      -# RFAILED
16414  **/
16415 #ifdef RGR_CQI_REPT
16416 #ifdef ANSI
16417 PRIVATE Void rgSCHCmnDlCqiOnPucchInd
16418 (
16419  RgSchCellCb        *cell,
16420  RgSchUeCb          *ue,
16421  TfuDlCqiPucch      *pucchCqi,
16422  RgrUeCqiRept       *ueCqiRept,
16423  Bool               *isCqiAvail,
16424  Bool               *is2ndCwCqiAvail
16425  )
16426 #else
16427 PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
16428  RgSchCellCb        *cell;
16429  RgSchUeCb          *ue;
16430  TfuDlCqiPucch      *pucchCqi;
16431  RgrUeCqiRept       *ueCqiRept;
16432  Bool               *isCqiAvail;
16433  Bool               *is2ndCwCqiAvail;
16434 #endif
16435 #else
16436 #ifdef ANSI
16437 PRIVATE Void rgSCHCmnDlCqiOnPucchInd
16438 (
16439  RgSchCellCb        *cell,
16440  RgSchUeCb          *ue,
16441  TfuDlCqiPucch      *pucchCqi
16442  )
16443 #else
16444 PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi)
16445  RgSchCellCb        *cell;
16446  RgSchUeCb          *ue;
16447  TfuDlCqiPucch      *pucchCqi;
16448 #endif
16449 #endif
16450 {
16451    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16452    TRC2(rgSCHCmnDlCqiOnPucchInd);
16453
16454    /* ccpu00117452 - MOD - Changed
16455       RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16456 #ifdef RGR_CQI_REPT
16457    /* Save CQI mode information in the report */
16458    ueCqiRept->cqiMode = pucchCqi->mode;
16459 #endif
16460
16461    switch(pucchCqi->mode)
16462    {
16463       case TFU_PUCCH_CQI_MODE10:
16464 #ifdef RGR_CQI_REPT
16465          rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail);
16466 #else
16467          rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi);
16468 #endif
16469          ueDl->cqiFlag = TRUE;
16470          break;
16471       case TFU_PUCCH_CQI_MODE11:
16472 #ifdef RGR_CQI_REPT
16473          rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail,
16474                 is2ndCwCqiAvail);
16475 #else
16476          rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi);
16477 #endif
16478          ueDl->cqiFlag = TRUE;
16479          break;
16480       case TFU_PUCCH_CQI_MODE20:
16481 #ifdef RGR_CQI_REPT
16482          rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail);
16483 #else
16484          rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi);
16485 #endif
16486          ueDl->cqiFlag = TRUE;
16487          break;
16488       case TFU_PUCCH_CQI_MODE21:
16489 #ifdef RGR_CQI_REPT
16490          rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail,
16491                 is2ndCwCqiAvail);
16492 #else
16493          rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi);
16494 #endif
16495          ueDl->cqiFlag = TRUE;
16496          break;
16497       default:
16498          {
16499             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unknown CQI Mode %d",
16500                pucchCqi->mode,ue->ueId);
16501             /* ccpu00117452 - MOD - Changed macro name from
16502                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16503 #ifdef RGR_CQI_REPT
16504             *isCqiAvail = FALSE;
16505 #endif
16506          }
16507          break;
16508    }
16509
16510   RETVOID;
16511 }  /* rgSCHCmnDlCqiOnPucchInd */
16512
16513
16514 /**
16515  * @brief This function Updates the DL CQI on PUSCH for the UE.
16516  *
16517  * @details
16518  *
16519  *     Function: rgSCHCmnDlCqiOnPuschInd
16520  *
16521  *     This function updates the DL CQI on PUSCH for the UE.
16522  *
16523  *     Invoked by: rgSCHCmnDlCqiInd
16524  *
16525  *     Processing Steps:
16526  *     - Depending on the reporting mode of the PUSCH, the CQI/PMI/RI values
16527  *       are updated and stored for each UE
16528  *
16529  *  @param[in] RgSchCellCb     *cell
16530  *  @param[in] RgSchUeCb       *ue
16531  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16532  *  @return  S16
16533  *      -# ROK
16534  *      -# RFAILED
16535  **/
16536 #ifdef RGR_CQI_REPT
16537 #ifdef ANSI
16538 PRIVATE Void rgSCHCmnDlCqiOnPuschInd
16539 (
16540  RgSchCellCb        *cell,
16541  RgSchUeCb          *ue,
16542  TfuDlCqiPusch      *puschCqi,
16543  RgrUeCqiRept       *ueCqiRept,
16544  Bool               *isCqiAvail,
16545  Bool               *is2ndCwCqiAvail
16546  )
16547 #else
16548 PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
16549  RgSchCellCb        *cell;
16550  RgSchUeCb          *ue;
16551  TfuDlCqiPusch      *puschCqi;
16552  RgrUeCqiRept       *ueCqiRept;
16553  Bool               *isCqiAvail;
16554  Bool               *is2ndCwCqiAvail;
16555 #endif
16556 #else
16557 #ifdef ANSI
16558 PRIVATE Void rgSCHCmnDlCqiOnPuschInd
16559 (
16560  RgSchCellCb        *cell,
16561  RgSchUeCb          *ue,
16562  TfuDlCqiPusch      *puschCqi
16563  )
16564 #else
16565 PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi)
16566    RgSchCellCb        *cell;
16567    RgSchUeCb          *ue;
16568    TfuDlCqiPusch      *puschCqi;
16569 #endif
16570 #endif
16571 {
16572    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16573    U32 prevRiVal = 0; 
16574    TRC2(rgSCHCmnDlCqiOnPuschInd);
16575    if (puschCqi->ri.pres == PRSNT_NODEF)
16576    {
16577       if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
16578       {
16579          /* Saving the previous ri value to revert back
16580             in  case PMI update failed */
16581          if (RGR_UE_TM_4 == ue->mimoInfo.txMode ) /* Cheking for TM4. TM8 check later */
16582          {
16583             prevRiVal = ueDl->mimoInfo.ri;
16584          }
16585          rgSCHCmnDlSetUeRi(cell, ue, puschCqi->ri.val, FALSE);
16586       }
16587       else
16588       {
16589          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16590             puschCqi->ri.val,ue->ueId);
16591          RETVOID;
16592       }
16593    }
16594    ue->mimoInfo.puschFdbkVld  = FALSE;
16595    /* ccpu00117452 - MOD - Changed macro name from
16596       RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16597 #ifdef RGR_CQI_REPT
16598    /* Save CQI mode information in the report */
16599    ueCqiRept->cqiMode = puschCqi->mode;
16600    /* ccpu00117259 - DEL - removed default setting of isCqiAvail to TRUE */
16601 #endif
16602
16603    switch(puschCqi->mode)
16604    {
16605       case TFU_PUSCH_CQI_MODE_20:
16606          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16607          /* Checking whether the decoded CQI is a value between 1 and 15*/
16608          if((puschCqi->u.mode20Info.wideBandCqi) &&
16609                (puschCqi->u.mode20Info.wideBandCqi < RG_SCH_CMN_MAX_CQI))
16610          {
16611             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode20Info.wideBandCqi;
16612             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16613             /* ccpu00117452 - MOD - Changed macro name from
16614                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16615 #ifdef RGR_CQI_REPT
16616            *isCqiAvail = TRUE;
16617 #endif
16618          }
16619          else
16620          {
16621             RETVOID;
16622          }
16623          break;
16624       case TFU_PUSCH_CQI_MODE_30:
16625          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16626          if((puschCqi->u.mode30Info.wideBandCqi) &&
16627                (puschCqi->u.mode30Info.wideBandCqi < RG_SCH_CMN_MAX_CQI))
16628          {
16629             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode30Info.wideBandCqi;
16630             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16631             /* ccpu00117452 - MOD - Changed macro name from
16632                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16633 #ifdef RGR_CQI_REPT
16634             *isCqiAvail = TRUE;
16635 #endif
16636 #ifdef CA_DBG
16637             {
16638                extern U32 gACqiRcvdCount;
16639                gACqiRcvdCount++;
16640             
16641             }
16642 #endif
16643          }
16644          else
16645          {
16646             RETVOID;
16647          }
16648          break;
16649       case TFU_PUSCH_CQI_MODE_12:
16650          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16651          if((puschCqi->u.mode12Info.cqiIdx[0]) &&
16652                (puschCqi->u.mode12Info.cqiIdx[0] < RG_SCH_CMN_MAX_CQI))
16653          {
16654             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode12Info.cqiIdx[0];
16655             /* ccpu00117452 - MOD - Changed macro name from
16656                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16657 #ifdef RGR_CQI_REPT
16658             *isCqiAvail = TRUE;
16659 #endif
16660          }
16661          else
16662          {
16663             RETVOID;
16664          }
16665          if((puschCqi->u.mode12Info.cqiIdx[1]) &&
16666                (puschCqi->u.mode12Info.cqiIdx[1] < RG_SCH_CMN_MAX_CQI))
16667          {
16668             ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode12Info.cqiIdx[1];
16669             /* ccpu00117452 - MOD - Changed macro name from
16670                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16671 #ifdef RGR_CQI_REPT
16672             /* ccpu00117259 - ADD - Considering second codeword CQI info
16673                incase of MIMO for CQI Reporting */
16674             *is2ndCwCqiAvail = TRUE;
16675 #endif
16676          }
16677          else
16678          {
16679             RETVOID;
16680          }
16681          ue->mimoInfo.puschFdbkVld  = TRUE;
16682          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_12;
16683          ue->mimoInfo.puschPmiInfo.u.mode12Info = puschCqi->u.mode12Info;
16684          /*  : resetting this is time based. Make use of CQI reporting
16685           * periodicity, DELTA's in determining the exact time at which this
16686           * need to be reset. */
16687          break;
16688       case TFU_PUSCH_CQI_MODE_22:
16689          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16690          if((puschCqi->u.mode22Info.wideBandCqi[0]) &&
16691                (puschCqi->u.mode22Info.wideBandCqi[0] < RG_SCH_CMN_MAX_CQI))
16692          {
16693             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode22Info.wideBandCqi[0];
16694             /* ccpu00117452 - MOD - Changed macro name from
16695                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16696 #ifdef RGR_CQI_REPT
16697             *isCqiAvail = TRUE;
16698 #endif
16699          }
16700          else
16701          {
16702             RETVOID;
16703          }
16704          if((puschCqi->u.mode22Info.wideBandCqi[1]) &&
16705                (puschCqi->u.mode22Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
16706          {
16707             ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode22Info.wideBandCqi[1];
16708             /* ccpu00117452 - MOD - Changed macro name from
16709                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16710 #ifdef RGR_CQI_REPT
16711             /* ccpu00117259 - ADD - Considering second codeword CQI info
16712                incase of MIMO for CQI Reporting */
16713             *is2ndCwCqiAvail = TRUE;
16714 #endif
16715          }
16716          else
16717          {
16718             RETVOID;
16719          }
16720          rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode22Info.wideBandPmi);
16721          ue->mimoInfo.puschFdbkVld  = TRUE;
16722          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_22;
16723          ue->mimoInfo.puschPmiInfo.u.mode22Info = puschCqi->u.mode22Info;
16724          break;
16725       case TFU_PUSCH_CQI_MODE_31:
16726          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16727          if((puschCqi->u.mode31Info.wideBandCqi[0]) &&
16728                (puschCqi->u.mode31Info.wideBandCqi[0] < RG_SCH_CMN_MAX_CQI))
16729          {
16730             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode31Info.wideBandCqi[0];
16731             /* ccpu00117452 - MOD - Changed macro name from
16732                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16733 #ifdef RGR_CQI_REPT
16734             *isCqiAvail = TRUE;
16735 #endif
16736          }
16737          if (ueDl->mimoInfo.ri > 1)
16738          {
16739            if((puschCqi->u.mode31Info.wideBandCqi[1]) &&
16740                (puschCqi->u.mode31Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
16741            {
16742              ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode31Info.wideBandCqi[1];
16743             /* ccpu00117452 - MOD - Changed macro name from
16744                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16745 #ifdef RGR_CQI_REPT
16746             /* ccpu00117259 - ADD - Considering second codeword CQI info
16747                incase of MIMO for CQI Reporting */
16748              *is2ndCwCqiAvail = TRUE;
16749 #endif
16750            }
16751          }
16752          if (rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode31Info.pmi) != ROK)
16753          {
16754             /* To avoid Rank and PMI inconsistency */
16755             if ((puschCqi->ri.pres == PRSNT_NODEF) &&
16756                 (RGR_UE_TM_4 == ue->mimoInfo.txMode)) /* checking for TM4. TM8 check later */
16757             {
16758                ueDl->mimoInfo.ri = prevRiVal;
16759             }
16760          }
16761          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_31;
16762          ue->mimoInfo.puschPmiInfo.u.mode31Info = puschCqi->u.mode31Info;
16763          break;
16764       default:
16765          {
16766             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Unknown CQI Mode %d CRNTI:%d",
16767                puschCqi->mode,ue->ueId);
16768             /*  CQI decoding failed revert the RI to previous value */
16769             if ((puschCqi->ri.pres == PRSNT_NODEF) &&
16770                 (RGR_UE_TM_4 == ue->mimoInfo.txMode)) /* checking for TM4. TM8 check later */
16771             {
16772                ueDl->mimoInfo.ri = prevRiVal;
16773             }
16774             /* ccpu00117452 - MOD - Changed macro name from
16775                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16776 #ifdef RGR_CQI_REPT
16777            *isCqiAvail = FALSE;
16778             /* ccpu00117259 - ADD - Considering second codeword CQI info
16779                incase of MIMO for CQI Reporting */
16780             *is2ndCwCqiAvail = FALSE;
16781 #endif
16782          }
16783          break;
16784    }
16785
16786    RETVOID;
16787 }  /* rgSCHCmnDlCqiOnPuschInd */
16788
16789 \f
16790 /**
16791  * @brief This function Updates the DL CQI for the UE.
16792  *
16793  * @details
16794  *
16795  *     Function: rgSCHCmnDlCqiInd
16796  *     Purpose:  Updates the DL CQI for the UE
16797  *
16798  *     Invoked by: TOM
16799  *
16800  *  @param[in]  RgSchCellCb        *cell
16801  *  @param[in]  RgSchUeCb          *ue
16802  *  @param[in]  TfuDlCqiRpt        *dlCqi
16803  *  @return  Void
16804  *
16805  **/
16806 #ifdef ANSI
16807 PUBLIC Void rgSCHCmnDlCqiInd
16808 (
16809 RgSchCellCb        *cell,
16810 RgSchUeCb          *ue,
16811 Bool               isPucchInfo,
16812 Void               *dlCqi,
16813 CmLteTimingInfo    timingInfo
16814 )
16815 #else
16816 PUBLIC Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
16817 RgSchCellCb        *cell;
16818 RgSchUeCb          *ue;
16819 Bool               isPucchInfo;
16820 Void               *dlCqi;
16821 CmLteTimingInfo    timingInfo;
16822 #endif
16823 {
16824    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
16825 /* ccpu00117452 - MOD - Changed macro name from
16826    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16827 #ifdef RGR_CQI_REPT
16828    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16829    RgrUeCqiRept   ueCqiRept = {{0}};
16830    Bool           isCqiAvail = FALSE;
16831    /* ccpu00117259 - ADD - Considering second codeword CQI info
16832       incase of MIMO for CQI Reporting */
16833    Bool           is2ndCwCqiAvail = FALSE;
16834 #endif
16835
16836    TRC2(rgSCHCmnDlCqiInd);
16837
16838 #ifdef RGR_CQI_REPT
16839    if (isPucchInfo)
16840    {
16841       rgSCHCmnDlCqiOnPucchInd(cell, ue, (TfuDlCqiPucch *)dlCqi, &ueCqiRept, &isCqiAvail, &is2ndCwCqiAvail);
16842    }
16843    else
16844    {
16845       rgSCHCmnDlCqiOnPuschInd(cell, ue, (TfuDlCqiPusch *)dlCqi, &ueCqiRept,  &isCqiAvail, &is2ndCwCqiAvail);
16846    }
16847 #else
16848    if (isPucchInfo)
16849    {
16850       rgSCHCmnDlCqiOnPucchInd(cell, ue, (TfuDlCqiPucch *)dlCqi);
16851    }
16852    else
16853    {
16854       rgSCHCmnDlCqiOnPuschInd(cell, ue, (TfuDlCqiPusch *)dlCqi);
16855    }
16856 #endif
16857
16858 #ifdef CQI_CONFBITMASK_DROP
16859    if(!ue->cqiConfBitMask)
16860    {
16861       if (ueDl->mimoInfo.cwInfo[0].cqi >15)
16862       {
16863          ueDl->mimoInfo.cwInfo[0].cqi = ue->prevCqi;
16864          ueDl->mimoInfo.cwInfo[1].cqi = ue->prevCqi;
16865       }
16866       else if ( ueDl->mimoInfo.cwInfo[0].cqi >= ue->prevCqi)
16867       {
16868          ue->prevCqi = ueDl->mimoInfo.cwInfo[0].cqi;
16869       }
16870       else
16871       {
16872          U8 dlCqiDeltaPrev = 0;
16873          dlCqiDeltaPrev = ue->prevCqi - ueDl->mimoInfo.cwInfo[0].cqi;
16874          if (dlCqiDeltaPrev > 3)
16875             dlCqiDeltaPrev = 3;
16876          if ((ue->prevCqi - dlCqiDeltaPrev) < 6)
16877          {
16878             ue->prevCqi = 6;
16879          }
16880          else 
16881          {
16882             ue->prevCqi = ue->prevCqi - dlCqiDeltaPrev;
16883          }
16884          ueDl->mimoInfo.cwInfo[0].cqi = ue->prevCqi;
16885          ueDl->mimoInfo.cwInfo[1].cqi = ue->prevCqi;
16886
16887       }
16888    }
16889 #endif
16890
16891 /* ccpu00117452 - MOD - Changed macro name from
16892    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16893 #ifdef RGR_CQI_REPT
16894    /* ccpu00117259 - ADD - Considering second codeword CQI info
16895       incase of MIMO for CQI Reporting - added is2ndCwCqiAvail\
16896       in 'if' condition*/
16897    if (RG_SCH_CQIR_IS_PUSHNCQI_ENBLE(ue) && (isCqiAvail || is2ndCwCqiAvail))
16898    {
16899       ueCqiRept.cqi[0] = ueDl->mimoInfo.cwInfo[0].cqi;
16900
16901    /* ccpu00117259 - ADD - Considering second codeword CQI info
16902       incase of MIMO for CQI Reporting - added is2ndCwCqiAvail
16903       in 'if' condition*/
16904       ueCqiRept.cqi[1] = 0;
16905       if(is2ndCwCqiAvail)
16906       {
16907          ueCqiRept.cqi[1] = ueDl->mimoInfo.cwInfo[1].cqi;
16908       }
16909       rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, &ueCqiRept);
16910
16911    }
16912 #endif
16913 #ifdef DL_LA
16914    rgSCHCmnDlSetUeAllocLmtLa(cell, ue);
16915    rgSCHCheckAndSetTxScheme(cell, ue);
16916 #else
16917 #ifdef EMTC_ENABLE   
16918    rgSCHCmnDlSetUeAllocLmt(cell, RG_SCH_CMN_GET_DL_UE(ue,cell), ue->isEmtcUe);
16919 #else 
16920    rgSCHCmnDlSetUeAllocLmt(cell, RG_SCH_CMN_GET_DL_UE(ue,cell), FALSE);
16921 #endif   
16922 #endif
16923
16924    if (cellSch->dl.isDlFreqSel)
16925    {
16926       cellSch->apisDlfs->rgSCHDlfsDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo);
16927    }
16928 #ifdef LTEMAC_SPS
16929    /* Call SPS module to update CQI indication */
16930    rgSCHCmnSpsDlCqiIndHndlr(cell, ue, timingInfo);
16931 #endif
16932    /* Call Specific scheduler to process on dlCqiInd */
16933 #ifdef EMTC_ENABLE
16934    if((TRUE == cell->emtcEnable) && (TRUE == ue->isEmtcUe))
16935    {
16936       cellSch->apisEmtcDl->rgSCHDlCqiInd(cell, ue, isPucchInfo, dlCqi);
16937    }
16938    else
16939 #endif
16940    {
16941       cellSch->apisDl->rgSCHDlCqiInd(cell, ue, isPucchInfo, dlCqi);
16942    }
16943
16944 #ifdef RG_PFS_STATS
16945    ue->pfsStats.cqiStats[(RG_SCH_GET_SCELL_INDEX(ue, cell))].avgCqi += 
16946       ueDl->mimoInfo.cwInfo[0].cqi;
16947    ue->pfsStats.cqiStats[(RG_SCH_GET_SCELL_INDEX(ue, cell))].totalCqiOcc++; 
16948 #endif
16949
16950 #ifdef SCH_STATS
16951    ueDl->avgCqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16952    ueDl->numCqiOccns++;
16953    if (ueDl->mimoInfo.ri == 1)
16954    {
16955       ueDl->numRi1++;
16956    }
16957    else
16958    {
16959       ueDl->numRi2++;
16960    }
16961 #endif
16962
16963 #ifdef TENB_STATS
16964    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlSumCw0Cqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16965    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlSumCw1Cqi +=  ueDl->mimoInfo.cwInfo[1].cqi;
16966    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlNumCw0Cqi ++;
16967    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlNumCw1Cqi ++;
16968    cell->tenbStats->sch.dlSumCw0Cqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16969    cell->tenbStats->sch.dlSumCw1Cqi +=  ueDl->mimoInfo.cwInfo[1].cqi;
16970    cell->tenbStats->sch.dlNumCw0Cqi ++;
16971    cell->tenbStats->sch.dlNumCw1Cqi ++;
16972 #endif
16973    RETVOID;
16974 }
16975
16976 #ifdef TFU_UPGRADE
16977 /**
16978  * @brief This function calculates the wideband CQI from SNR
16979  *            reported for each RB.
16980  *
16981  * @details
16982  *
16983  *     Function: rgSCHCmnCalcWcqiFrmSnr
16984  *     Purpose:  Wideband CQI calculation from SNR
16985  *
16986  *     Invoked by: RG SCH
16987  *
16988  *  @param[in]  RgSchCellCb        *cell
16989  *  @param[in]  TfuSrsRpt        *srsRpt,
16990  *  @return  Wideband CQI
16991  *
16992  **/
16993 #ifdef ANSI
16994 PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr
16995 (
16996  RgSchCellCb        *cell,
16997  TfuSrsRpt        *srsRpt
16998  )
16999 #else
17000 PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
17001    RgSchCellCb        *cell;
17002    TfuSrsRpt            *srsRpt;
17003 #endif
17004 {
17005    U8 wideCqi=1; /*Calculated value from SNR*/
17006    TRC2(rgSCHCmnCalcWcqiFrmSnr);
17007    /*Need to map a certain SNR with a WideCQI value.
17008     * The CQI calculation is still primitive. Further, need to
17009     * use a improvized method for calculating WideCQI from SNR*/
17010        if (srsRpt->snr[0] <=50)
17011        {
17012            wideCqi=3;
17013        }
17014        else if (srsRpt->snr[0]>=51 && srsRpt->snr[0] <=100)
17015        {
17016            wideCqi=6;
17017        }
17018        else if (srsRpt->snr[0]>=101 && srsRpt->snr[0] <=150)
17019        {
17020            wideCqi=9;
17021        }
17022        else if (srsRpt->snr[0]>=151 && srsRpt->snr[0] <=200)
17023        {
17024            wideCqi=12;
17025        }
17026        else if (srsRpt->snr[0]>=201 && srsRpt->snr[0] <=250)
17027        {
17028            wideCqi=14;
17029        }
17030        else
17031        {
17032            wideCqi=15;
17033        }
17034    RETVALUE(wideCqi);
17035 }/*rgSCHCmnCalcWcqiFrmSnr*/
17036
17037
17038 /**
17039  * @brief This function Updates the SRS for the UE.
17040  *
17041  * @details
17042  *
17043  *     Function: rgSCHCmnSrsInd
17044  *     Purpose:  Updates the UL SRS for the UE
17045  *
17046  *     Invoked by: TOM
17047  *
17048  *  @param[in]  RgSchCellCb        *cell
17049  *  @param[in]  RgSchUeCb          *ue
17050  *  @param[in]  TfuSrsRpt        *srsRpt,
17051  *  @return  Void
17052  *
17053  **/
17054 #ifdef ANSI
17055 PUBLIC Void rgSCHCmnSrsInd
17056 (
17057  RgSchCellCb        *cell,
17058  RgSchUeCb          *ue,
17059  TfuSrsRpt        *srsRpt,
17060  CmLteTimingInfo    timingInfo
17061  )
17062 #else
17063 PUBLIC Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
17064     RgSchCellCb        *cell;
17065     RgSchUeCb          *ue;
17066     TfuSrsRpt            *srsRpt;
17067     CmLteTimingInfo    timingInfo;
17068 #endif
17069 {
17070     U8 wideCqi; /*Calculated value from SNR*/
17071     U32 recReqTime; /*Received Time in TTI*/
17072     TRC2(rgSCHCmnSrsInd);
17073
17074     recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
17075     ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
17076     if(srsRpt->wideCqiPres)
17077     {
17078         wideCqi = srsRpt->wideCqi;
17079     }
17080     else
17081     {
17082         wideCqi = rgSCHCmnCalcWcqiFrmSnr(cell, srsRpt);
17083     }
17084     rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi);
17085     RETVOID;
17086 }/*rgSCHCmnSrsInd*/
17087 #endif
17088
17089 \f
17090 /**
17091  * @brief This function is a handler for TA report for an UE.
17092  *
17093  * @details
17094  *
17095  *     Function: rgSCHCmnDlTARpt
17096  *     Purpose:  Determine based on UE_IDLE_TIME threshold,
17097  *     whether UE needs to be Linked to the scheduler's TA list OR
17098  *     if it needs a PDCCH Order.
17099  *
17100  *
17101  *     Invoked by: TOM
17102  *
17103  *  @param[in]  RgSchCellCb        *cell
17104  *  @param[in]  RgSchUeCb          *ue
17105  *  @return  Void
17106  *
17107  **/
17108 #ifdef ANSI
17109 PUBLIC Void rgSCHCmnDlTARpt
17110 (
17111 RgSchCellCb        *cell,
17112 RgSchUeCb          *ue
17113 )
17114 #else
17115 PUBLIC Void rgSCHCmnDlTARpt(cell, ue)
17116 RgSchCellCb        *cell;
17117 RgSchUeCb          *ue;
17118 #endif
17119 {
17120    RgSchCmnCell    *cellSch = RG_SCH_CMN_GET_CELL(cell);
17121    RgSchCmnDlCell  *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
17122    RgSchCmnDlUe    *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
17123    CmLListCp       poInactvLst;
17124
17125    TRC2(rgSCHCmnDlTARpt);
17126
17127    /* RACHO: If UE idle time is more than threshold, then
17128     * set its poInactv pdcch order inactivity  */
17129    /* Fix : syed Ignore if TaTmr is not configured */
17130    if ((ue->dl.taCb.cfgTaTmr) && (rgSCHCmnUeIdleExdThrsld(cell, ue) == ROK))
17131    {
17132       U32 prevDlMsk = ue->dl.dlInactvMask;
17133       U32 prevUlMsk = ue->ul.ulInactvMask;
17134       ue->dl.dlInactvMask |= RG_PDCCHODR_INACTIVE;
17135       ue->ul.ulInactvMask |= RG_PDCCHODR_INACTIVE;
17136       /* Indicate Specific scheduler for this UEs inactivity */
17137       cmLListInit(&poInactvLst);
17138       cmLListAdd2Tail(&poInactvLst, &ueDl->rachInfo.inActUeLnk);
17139       ueDl->rachInfo.inActUeLnk.node = (PTR)ue;
17140       /* Send inactivate ind only if not already sent */
17141       if (prevDlMsk == 0)
17142       {
17143          cellSch->apisDl->rgSCHDlInactvtUes(cell, &poInactvLst);
17144       }
17145       if (prevUlMsk == 0)
17146       {
17147          cellSch->apisUl->rgSCHUlInactvtUes(cell, &poInactvLst);
17148       }
17149    }
17150    else
17151    {
17152       /* Fix: ccpu00124009 Fix for loop in the linked list "cellDl->taLst" */
17153       if (!ue->dlTaLnk.node)
17154       {
17155 #ifdef EMTC_ENABLE
17156          if(cell->emtcEnable)
17157          {
17158             if(ue->isEmtcUe)
17159             {
17160                rgSCHEmtcAddToTaLst(cellDl,ue);
17161             }
17162          }
17163          else
17164 #endif
17165          {
17166
17167             cmLListAdd2Tail(&cellDl->taLst, &ue->dlTaLnk);
17168             ue->dlTaLnk.node = (PTR)ue;
17169          }
17170       }
17171       else
17172       {
17173          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
17174                "<TA>TA duplicate entry attempt failed: UEID:%u", 
17175                ue->ueId);
17176       }
17177    }
17178    RETVOID;
17179 }
17180
17181 #ifdef TFU_UPGRADE
17182 /**
17183  * @brief Indication of UL CQI.
17184  *
17185  * @details
17186  *
17187  *     Function : rgSCHCmnFindUlCqiUlTxAnt
17188  *
17189  *     - Finds the Best Tx Antenna amongst the CQIs received
17190  *         from Two Tx Antennas.
17191  *
17192  *  @param[in]  RgSchCellCb         *cell
17193  *  @param[in]  RgSchUeCb           *ue
17194  *  @param[in]   U8                 wideCqi
17195  *  @return  Void
17196  **/
17197 #ifdef ANSI
17198 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt
17199 (
17200 RgSchCellCb     *cell,
17201 RgSchUeCb       *ue,
17202 U8              wideCqi
17203 )
17204 #else
17205 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
17206 RgSchCellCb     *cell;
17207 RgSchUeCb       *ue;
17208 U8              wideCqi;
17209 #endif
17210 {
17211    ue->validTxAnt = 1;
17212    RETVOID;
17213 }  /* rgSCHCmnFindUlCqiUlTxAnt */
17214 #endif
17215
17216 /**
17217  * @brief Indication of UL CQI.
17218  *
17219  * @details
17220  *
17221  *     Function : rgSCHCmnUlCqiInd
17222  *
17223  *     - Updates uplink CQI information for the UE. Computes and
17224  *       stores the lowest CQI of CQIs reported in all subbands.
17225  *
17226  *  @param[in]  RgSchCellCb         *cell
17227  *  @param[in]  RgSchUeCb           *ue
17228  *  @param[in]  TfuUlCqiRpt         *ulCqiInfo
17229  *  @return  Void
17230  **/
17231 #ifdef ANSI
17232 PUBLIC Void rgSCHCmnUlCqiInd
17233 (
17234 RgSchCellCb          *cell,
17235 RgSchUeCb            *ue,
17236 TfuUlCqiRpt          *ulCqiInfo
17237 )
17238 #else
17239 PUBLIC Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
17240 RgSchCellCb          *cell;
17241 RgSchUeCb            *ue;
17242 TfuUlCqiRpt          *ulCqiInfo;
17243 #endif
17244 {
17245    RgSchCmnUlUe  *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
17246    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
17247 #ifdef UL_LA
17248    U8            iTbsNew;
17249    S32           previTbs;
17250 #endif
17251 #if (defined(SCH_STATS) || defined(TENB_STATS))
17252      CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
17253 #endif   
17254                   
17255    TRC2(rgSCHCmnUlCqiInd);
17256    /*  consider inputs from SRS handlers about SRS occassions
17257     * in determining the UL TX Antenna selection */
17258    ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
17259 #ifdef TFU_UPGRADE
17260    ueUl->validUlCqi = ueUl->crntUlCqi[0];
17261    ue->validTxAnt = 0;
17262 #ifdef UL_LA
17263    iTbsNew  =  rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][ueUl->validUlCqi];
17264    previTbs =  (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
17265
17266    if (RG_ITBS_DIFF(iTbsNew, previTbs) > 5)
17267    {
17268       /* Ignore this iTBS report and mark that last iTBS report was */
17269       /* ignored so that subsequently we reset the LA algorithm     */
17270       ueUl->ulLaCb.lastiTbsIgnored = TRUE;
17271    }
17272    else
17273    {
17274       if (ueUl->ulLaCb.lastiTbsIgnored != TRUE)
17275       {
17276          ueUl->ulLaCb.cqiBasediTbs = ((20 * iTbsNew * 100) +
17277                                        (80 * ueUl->ulLaCb.cqiBasediTbs))/100;
17278       }
17279       else
17280       {
17281          /* Reset the LA as iTbs in use caught up with the value   */
17282          /* reported by UE.                                        */
17283          ueUl->ulLaCb.cqiBasediTbs = ((20 * iTbsNew * 100) +
17284                                         (80 * previTbs * 100))/100;
17285          ueUl->ulLaCb.deltaiTbs = 0;
17286          ueUl->ulLaCb.lastiTbsIgnored = FALSE;
17287       }
17288    }
17289 #endif 
17290 #endif
17291    rgSCHPwrUlCqiInd(cell, ue);
17292 #ifdef LTEMAC_SPS
17293    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
17294    {
17295       rgSCHCmnSpsUlCqiInd(cell, ue);
17296    }
17297 #endif
17298    /* Applicable to only some schedulers */
17299 #ifdef EMTC_ENABLE
17300    if((TRUE == cell->emtcEnable) && (TRUE == ue->isEmtcUe))
17301    {
17302       cellSch->apisEmtcUl->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
17303    }
17304    else
17305 #endif
17306    {
17307       cellSch->apisUl->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
17308    }
17309
17310 #ifdef SCH_STATS
17311    ueUl->numCqiOccns++;
17312    ueUl->avgCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17313 #endif
17314
17315 #ifdef TENB_STATS
17316    {
17317       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulSumCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17318       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulNumCqi ++;
17319       cell->tenbStats->sch.ulSumCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17320       cell->tenbStats->sch.ulNumCqi ++;
17321    }
17322 #endif
17323
17324    RETVOID;
17325 }  /* rgSCHCmnUlCqiInd */
17326
17327 /**
17328  * @brief Returns HARQ proc for which data expected now.
17329  *
17330  * @details
17331  *
17332  *     Function: rgSCHCmnUlHqProcForUe
17333  *     Purpose:  This function returns the harq process for
17334  *               which data is expected in the current subframe.
17335  *               It does not validate that the HARQ process
17336  *               has an allocation.
17337  *
17338  *     Invoked by: TOM
17339  *
17340  *  @param[in]  RgSchCellCb        *cell
17341  *  @param[in]  CmLteTimingInfo    frm
17342  *  @param[in]  RgSchUeCb          *ue
17343  *  @param[out] RgSchUlHqProcCb    **procRef
17344  *  @return  Void
17345  **/
17346 #ifdef ANSI
17347 PUBLIC Void rgSCHCmnUlHqProcForUe
17348 (
17349 RgSchCellCb         *cell,
17350 CmLteTimingInfo     frm,
17351 RgSchUeCb           *ue,
17352 RgSchUlHqProcCb     **procRef
17353 )
17354 #else
17355 PUBLIC Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
17356 RgSchCellCb         *cell;
17357 CmLteTimingInfo     frm;
17358 RgSchUeCb           *ue;
17359 RgSchUlHqProcCb     **procRef;
17360 #endif
17361 {
17362 #ifndef RG_5GTF
17363    U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
17364 #endif
17365    TRC2(rgSCHCmnUlHqProcForUe);
17366 #ifndef RG_5GTF
17367    *procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
17368 #else
17369    *procRef = rgSCHUhmGetUlProcByTime(cell, ue, frm);
17370 #endif
17371    RETVOID;
17372 }
17373
17374 #ifdef RG_UNUSED
17375 /**
17376  * @brief Update harq process for allocation.
17377  *
17378  * @details
17379  *
17380  *     Function : rgSCHCmnUpdUlHqProc
17381  *
17382  *     This function is invoked when harq process
17383  *     control block is now in a new memory location
17384  *     thus requiring a pointer/reference update.
17385  *
17386  *  @param[in] RgSchCellCb      *cell
17387  *  @param[in] RgSchUlHqProcCb  *curProc
17388  *  @param[in] RgSchUlHqProcCb  *oldProc
17389  *  @return  S16
17390  *      -# ROK
17391  *      -# RFAILED
17392  **/
17393 #ifdef ANSI
17394 PUBLIC S16 rgSCHCmnUpdUlHqProc
17395 (
17396 RgSchCellCb      *cell,
17397 RgSchUlHqProcCb  *curProc,
17398 RgSchUlHqProcCb  *oldProc
17399 )
17400 #else
17401 PUBLIC S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
17402 RgSchCellCb      *cell;
17403 RgSchUlHqProcCb  *curProc;
17404 RgSchUlHqProcCb  *oldProc;
17405 #endif
17406 {
17407    TRC2(rgSCHCmnUpdUlHqProc);
17408
17409    UNUSED(cell);
17410    UNUSED(oldProc);
17411 #if (ERRCLASS & ERRCLS_DEBUG)
17412    if (curProc->alloc == NULLP)
17413    {
17414       RETVALUE(RFAILED);
17415    }
17416 #endif
17417    curProc->alloc->hqProc = curProc;
17418    RETVALUE(ROK);
17419 }  /* rgSCHCmnUpdUlHqProc */
17420 #endif
17421
17422 /*MS_WORKAROUND for CR FIXME */
17423 /**
17424  * @brief Hsndles BSR timer expiry
17425  *
17426  * @details
17427  *
17428  *     Function : rgSCHCmnBsrTmrExpry
17429  *
17430  *     This function is invoked when periodic BSR timer expires for a UE.
17431  *
17432  *  @param[in] RgSchUeCb        *ue
17433  *  @return  S16
17434  *      -# ROK
17435  *      -# RFAILED
17436  **/
17437 #ifdef ANSI
17438 PUBLIC S16 rgSCHCmnBsrTmrExpry
17439 (
17440 RgSchUeCb  *ueCb
17441 )
17442 #else
17443 PUBLIC S16 rgSCHCmnBsrTmrExpry(ueCb)
17444 RgSchUeCb  *ueCb;
17445 #endif
17446 {
17447    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
17448
17449    TRC2(rgSCHCmnBsrTmrExpry)
17450
17451    ueCb->isSrGrant = TRUE;
17452
17453 #ifdef EMTC_ENABLE
17454    emtcStatsUlBsrTmrTxp++;
17455 #endif
17456
17457 #ifdef EMTC_ENABLE
17458    if(ueCb->cell->emtcEnable)
17459    {
17460       if(ueCb->isEmtcUe)
17461       {
17462          cellSch->apisEmtcUl->rgSCHSrRcvd(ueCb->cell, ueCb);
17463          RETVALUE(ROK);
17464       }
17465    }
17466    else
17467 #endif
17468    {
17469       cellSch->apisUl->rgSCHSrRcvd(ueCb->cell, ueCb);
17470    }
17471
17472    RETVALUE (ROK);
17473 }
17474
17475 /**
17476  * @brief Short BSR update.
17477  *
17478  * @details
17479  *
17480  *     Function : rgSCHCmnUpdBsrShort
17481  *
17482  *     This functions does requisite updates to handle short BSR reporting.
17483  *
17484  *  @param[in]  RgSchCellCb  *cell
17485  *  @param[in]  RgSchUeCb    *ue
17486  *  @param[in]  RgSchLcgCb *ulLcg
17487  *  @param[in]  U8           bsr
17488  *  @param[out] RgSchErrInfo *err
17489  *  @return  S16
17490  *      -# ROK
17491  *      -# RFAILED
17492  **/
17493 #ifdef ANSI
17494 PUBLIC S16 rgSCHCmnUpdBsrShort
17495 (
17496 RgSchCellCb  *cell,
17497 RgSchUeCb    *ue,
17498 RgSchLcgCb *ulLcg,
17499 U8           bsr,
17500 RgSchErrInfo *err
17501 )
17502 #else
17503 PUBLIC S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
17504 RgSchCellCb  *cell;
17505 RgSchUeCb    *ue;
17506 RgSchLcgCb *ulLcg;
17507 U8           bsr;
17508 RgSchErrInfo *err;
17509 #endif
17510 {
17511    U8  lcgCnt;
17512 #ifdef LTE_L2_MEAS
17513    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
17514 #endif
17515    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17516    RgSchCmnLcg  *cmnLcg  = NULLP;
17517
17518 #ifdef LTE_L2_MEAS
17519    U8             idx;
17520 #endif
17521    TRC2(rgSCHCmnUpdBsrShort);
17522
17523    if (!RGSCH_LCG_ISCFGD(ulLcg))
17524    {
17525       err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
17526       RETVALUE(RFAILED);
17527    }
17528    for (lcgCnt=0; lcgCnt<4; lcgCnt++)
17529    {
17530 #ifdef LTE_L2_MEAS
17531       /* Set BS of all other LCGs to Zero.
17532          If Zero BSR is reported in Short BSR include this LCG too */
17533       if ((lcgCnt != ulLcg->lcgId) ||
17534             (!bsr && !ueUl->hqEnt.numBusyHqProcs))
17535       {
17536          /* If old BO is zero do nothing */
17537          if(((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->bs != 0)
17538          {
17539             for(idx = 0; idx < ue->ul.lcgArr[lcgCnt].numLch; idx++)
17540             {
17541                if((ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->ulUeCount) &&
17542                  (ue->ulActiveLCs & (1 << 
17543                   (ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->qci -1))))
17544                {
17545           /* L2_COUNTER */
17546                  ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->ulUeCount--;
17547                  ue->ulActiveLCs &= ~(1 << 
17548                   (ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->qci -1));
17549                }
17550             }
17551          }
17552       }
17553 #endif
17554       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgCnt]))
17555       {
17556          ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->bs = 0;
17557          ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->reportedBs = 0;
17558       }
17559    }
17560
17561 #ifdef LTE_L2_MEAS
17562    if(ulLcg->lcgId && bsr && (((RgSchCmnLcg *)(ulLcg->sch))->bs == 0))
17563    {
17564       for(idx = 0; idx < ulLcg->numLch; idx++)
17565       {
17566           /* L2_COUNTER */
17567           if (!(ue->ulActiveLCs & (1 << (ulLcg->lcArray[idx]->qciCb->qci -1))))
17568           {
17569              ulLcg->lcArray[idx]->qciCb->ulUeCount++;
17570              ue->ulActiveLCs |= (1 << (ulLcg->lcArray[idx]->qciCb->qci -1));
17571           }
17572       }
17573    }
17574 #endif
17575    /* Resetting the nonGbrLcgBs info here */
17576    ue->ul.nonGbrLcgBs = 0;
17577    ue->ul.nonLcg0Bs = 0;
17578
17579    cmnLcg = ((RgSchCmnLcg *)(ulLcg->sch));
17580    
17581    if (TRUE == ue->ul.useExtBSRSizes)
17582    {
17583       cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsr];
17584    }
17585    else
17586    {
17587       cmnLcg->reportedBs = rgSchCmnBsrTbl[bsr];
17588    }
17589    if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17590    {
17591       /* TBD check for effGbr != 0 */    
17592       cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17593    }
17594    else if (0 == ulLcg->lcgId) 
17595    {
17596       /* This is added for handling LCG0 */
17597       cmnLcg->bs = cmnLcg->reportedBs;
17598    }
17599    else 
17600    {
17601       /* Update non GBR LCG's BS*/
17602       ue->ul.nonGbrLcgBs = RGSCH_MIN(cmnLcg->reportedBs,ue->ul.effAmbr);
17603       cmnLcg->bs     = ue->ul.nonGbrLcgBs;
17604    }
17605    ue->ul.totalBsr = cmnLcg->bs;
17606
17607 #ifdef RGR_V1
17608    if ((ue->bsrTmr.tmrEvnt != TMR_NONE) && (bsr == 0))
17609    {
17610       rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
17611    }
17612 #endif
17613 #ifdef LTEMAC_SPS
17614    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
17615    {
17616       rgSCHCmnSpsBsrRpt(cell, ue, ulLcg);
17617    }
17618 #endif
17619    rgSCHCmnUpdUlCompEffBsr(ue);
17620
17621 #ifdef EMTC_ENABLE
17622    if(cell->emtcEnable)
17623    {
17624       if(ue->isEmtcUe)
17625       {
17626          cellSch->apisEmtcUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
17627          RETVALUE(ROK);
17628       }
17629    }
17630    else
17631 #endif
17632    {
17633    cellSch->apisUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
17634    }
17635
17636 #ifdef LTE_ADV
17637    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17638    {
17639       for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
17640       {
17641 #ifndef PAL_ENABLE_UL_CA
17642          if((ue->cellInfo[sCellIdx] != NULLP) &&
17643                (ue->cellInfo[sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
17644 #else
17645          if(ue->cellInfo[sCellIdx] != NULLP)
17646 #endif
17647          {
17648             cellSch->apisUl->rgSCHUpdBsrShort(ue->cellInfo[sCellIdx]->cell, 
17649                   ue, ulLcg, bsr);
17650          }
17651       }
17652    }
17653 #endif 
17654
17655    RETVALUE(ROK);
17656 }
17657
17658 /**
17659  * @brief Truncated BSR update.
17660  *
17661  * @details
17662  *
17663  *     Function : rgSCHCmnUpdBsrTrunc
17664  *
17665  *     This functions does required updates to handle truncated BSR report.
17666  *
17667  *
17668  *  @param[in]  RgSchCellCb  *cell
17669  *  @param[in]  RgSchUeCb    *ue
17670  *  @param[in]  RgSchLcgCb *ulLcg
17671  *  @param[in]  U8           bsr
17672  *  @param[out] RgSchErrInfo *err
17673  *  @return  S16
17674  *      -# ROK
17675  *      -# RFAILED
17676  **/
17677 #ifdef ANSI
17678 PUBLIC S16 rgSCHCmnUpdBsrTrunc
17679 (
17680 RgSchCellCb  *cell,
17681 RgSchUeCb    *ue,
17682 RgSchLcgCb *ulLcg,
17683 U8           bsr,
17684 RgSchErrInfo *err
17685 )
17686 #else
17687 PUBLIC S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
17688 RgSchCellCb  *cell;
17689 RgSchUeCb    *ue;
17690 RgSchLcgCb *ulLcg;
17691 U8           bsr;
17692 RgSchErrInfo *err;
17693 #endif
17694 {
17695    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17696    RgSchCmnLcg  *cmnLcg = NULLP;
17697    S32          cnt;
17698 #ifdef LTE_L2_MEAS
17699    U8     idx;
17700 #endif
17701
17702    TRC2(rgSCHCmnUpdBsrTrunc);
17703
17704    if (!RGSCH_LCG_ISCFGD(ulLcg))
17705    {
17706       err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
17707       RETVALUE(RFAILED);
17708    }
17709    /* set all higher prio lcgs bs to 0 and update this lcgs bs and
17710       total bsr= sumofall lcgs bs */
17711    if (ulLcg->lcgId)
17712    {
17713       for (cnt = ulLcg->lcgId-1; cnt >= 0; cnt--)
17714       {
17715 #ifdef LTE_L2_MEAS
17716          /* If Existing BO is zero the don't do anything */
17717          if(((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs != 0)
17718          {
17719             for(idx = 0; idx < ue->ul.lcgArr[cnt].numLch; idx++)
17720             {
17721                /* L2_COUNTERS */
17722                if((ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount) &&
17723                      (ue->ulActiveLCs & (1 << 
17724                                          (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1))))
17725                {
17726                   ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount--;
17727                   ue->ulActiveLCs &= ~(1 << 
17728                         (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1));
17729                }
17730             }
17731          }
17732 #endif
17733          ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs = 0;
17734          ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->reportedBs = 0;
17735       }
17736    }
17737
17738 #ifdef LTE_L2_MEAS
17739    for (cnt = ulLcg->lcgId; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
17740    {
17741       if (ulLcg->lcgId == 0)
17742       {
17743          continue;
17744       }
17745       /* If Existing BO is zero the don't do anything */
17746       if(((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs == 0)
17747       {
17748          for(idx = 0; idx < ue->ul.lcgArr[cnt].numLch; idx++)
17749          {
17750             /* L2_COUNTERS */
17751             if (!(ue->ulActiveLCs & (1 << 
17752                (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1))))
17753             {
17754                ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount++;
17755                ue->ulActiveLCs |= (1 << 
17756                      (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1));
17757             }
17758          }
17759       }
17760    }
17761 #endif
17762    ue->ul.nonGbrLcgBs = 0;
17763    ue->ul.nonLcg0Bs = 0;
17764    cmnLcg = ((RgSchCmnLcg *)(ulLcg->sch));
17765    if (TRUE == ue->ul.useExtBSRSizes)
17766    {
17767       cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsr];
17768    }
17769    else
17770    {
17771       cmnLcg->reportedBs = rgSchCmnBsrTbl[bsr];
17772    }
17773    if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17774    {
17775       cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17776    }
17777    else if(ulLcg->lcgId == 0)
17778    {
17779       /* This is for handeling LCG0 */
17780       cmnLcg->bs = cmnLcg->reportedBs;
17781    }
17782    else
17783    {
17784       ue->ul.nonGbrLcgBs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
17785       cmnLcg->bs = ue->ul.nonGbrLcgBs;
17786    }
17787    ue->ul.totalBsr = cmnLcg->bs;
17788
17789    for (cnt = ulLcg->lcgId+1; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
17790    {
17791       /* TODO: The bs for the other LCGs may be stale because some or all of
17792        * the part of bs may have been already scheduled/data received. Please 
17793        * consider this when truncated BSR is tested/implemented */
17794       ue->ul.totalBsr += ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs;
17795    }
17796
17797    rgSCHCmnUpdUlCompEffBsr(ue);
17798
17799 #ifdef EMTC_ENABLE
17800    if(cell->emtcEnable)
17801    {
17802       if(ue->isEmtcUe)
17803       {
17804          cellSch->apisEmtcUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
17805          RETVALUE(ROK);
17806       }
17807    }
17808    else
17809 #endif
17810    {
17811       cellSch->apisUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
17812    }
17813
17814 #ifdef LTE_ADV
17815    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17816    {
17817       for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
17818       {
17819 #ifndef PAL_ENABLE_UL_CA
17820          if((ue->cellInfo[sCellIdx] != NULLP) &&
17821                (ue->cellInfo[sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
17822 #else
17823          if(ue->cellInfo[sCellIdx] != NULLP)
17824 #endif
17825          {
17826             cellSch->apisUl->rgSCHUpdBsrTrunc(ue->cellInfo[sCellIdx]->cell, ue, ulLcg, bsr);
17827          }
17828       }
17829    }
17830 #endif 
17831
17832    RETVALUE(ROK);
17833 }
17834
17835 /**
17836  * @brief Long BSR update.
17837  *
17838  * @details
17839  *
17840  *     Function : rgSCHCmnUpdBsrLong
17841  *
17842  *     - Update BSRs for all configured LCGs.
17843  *     - Update priority of LCGs if needed.
17844  *     - Update UE's position within/across uplink scheduling queues.
17845  *
17846  *
17847  *  @param[in]  RgSchCellCb  *cell
17848  *  @param[in]  RgSchUeCb    *ue
17849  *  @param[in]  U8 bsArr[]
17850  *  @param[out] RgSchErrInfo *err
17851  *  @return  S16
17852  *      -# ROK
17853  *      -# RFAILED
17854  **/
17855 #ifdef ANSI
17856 PUBLIC S16 rgSCHCmnUpdBsrLong
17857 (
17858 RgSchCellCb  *cell,
17859 RgSchUeCb    *ue,
17860 U8           *bsArr,
17861 RgSchErrInfo *err
17862 )
17863 #else
17864 PUBLIC S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
17865 RgSchCellCb  *cell;
17866 RgSchUeCb    *ue;
17867 U8           *bsArr;
17868 RgSchErrInfo *err;
17869 #endif
17870 {
17871    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17872    U32           tmpBsArr[4] = {0, 0, 0, 0};
17873    U32           nonGbrBs = 0;
17874 #ifdef LTE_L2_MEAS
17875    U8            idx1;
17876    U8            idx2;
17877 #endif
17878    U32           lcgId;
17879
17880    TRC2(rgSCHCmnUpdBsrLong);
17881
17882 #ifdef LTE_L2_MEAS
17883    for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
17884    {
17885      /* If Old BO is non zero then do nothing */
17886      if ((((RgSchCmnLcg *)(ue->ul.lcgArr[idx1].sch))->bs == 0)
17887         && bsArr[idx1] )
17888      {
17889        for(idx2 = 0; idx2 < ue->ul.lcgArr[idx1].numLch; idx2++)
17890        {
17891           /* L2_COUNTERS */
17892           if (!(ue->ulActiveLCs & (1 << 
17893              (ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->qci -1))))
17894           {
17895              ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->ulUeCount++;
17896              ue->ulActiveLCs |= (1 << 
17897                (ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->qci -1));
17898           }
17899        }
17900      }
17901    }
17902 #endif
17903    ue->ul.nonGbrLcgBs = 0;
17904    ue->ul.nonLcg0Bs = 0;
17905
17906    if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[0]))
17907    {
17908       if (TRUE == ue->ul.useExtBSRSizes)
17909       {
17910          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = rgSchCmnExtBsrTbl[bsArr[0]];
17911          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->reportedBs = rgSchCmnExtBsrTbl[bsArr[0]];
17912          tmpBsArr[0] = rgSchCmnExtBsrTbl[bsArr[0]];
17913       }
17914       else
17915       {
17916          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = rgSchCmnBsrTbl[bsArr[0]];
17917          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->reportedBs = rgSchCmnBsrTbl[bsArr[0]];
17918          tmpBsArr[0] = rgSchCmnBsrTbl[bsArr[0]];
17919       }
17920    }
17921    for (lcgId = 1; lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
17922    {
17923       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
17924       {
17925          RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
17926
17927          if (TRUE == ue->ul.useExtBSRSizes)
17928          {
17929             cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsArr[lcgId]];
17930          }
17931          else
17932          {
17933             cmnLcg->reportedBs = rgSchCmnBsrTbl[bsArr[lcgId]];
17934          }
17935          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17936          {
17937             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17938             tmpBsArr[lcgId] = cmnLcg->bs;
17939          }
17940          else
17941          {
17942             nonGbrBs += cmnLcg->reportedBs;
17943             tmpBsArr[lcgId] = cmnLcg->reportedBs;
17944             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs,ue->ul.effAmbr);
17945          }
17946       }
17947    }
17948    ue->ul.nonGbrLcgBs = RGSCH_MIN(nonGbrBs,ue->ul.effAmbr);
17949
17950    ue->ul.totalBsr = tmpBsArr[0] + tmpBsArr[1] + tmpBsArr[2] + tmpBsArr[3];
17951 #ifdef RGR_V1
17952    if ((ue->bsrTmr.tmrEvnt != TMR_NONE) && (ue->ul.totalBsr == 0))
17953    {
17954       rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
17955    }
17956 #endif
17957
17958 #ifdef LTEMAC_SPS
17959    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE) /* SPS_FIX */
17960    {
17961      if(ue->ul.totalBsr - tmpBsArr[1] == 0)
17962      {/* Updaing the BSR to SPS only if LCG1 BS is present in sps active state */
17963         rgSCHCmnSpsBsrRpt(cell, ue, &ue->ul.lcgArr[1]);
17964      }
17965    }
17966 #endif
17967    rgSCHCmnUpdUlCompEffBsr(ue);
17968
17969 #ifdef EMTC_ENABLE
17970    if(cell->emtcEnable)
17971    {
17972       if(ue->isEmtcUe)
17973       {
17974          cellSch->apisEmtcUl->rgSCHUpdBsrLong(cell, ue, bsArr);
17975          RETVALUE(ROK);
17976       }
17977    }
17978    else
17979 #endif
17980    {
17981    cellSch->apisUl->rgSCHUpdBsrLong(cell, ue, bsArr);
17982    }
17983
17984 #ifdef LTE_ADV
17985    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17986    {
17987       for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
17988       {
17989 #ifndef PAL_ENABLE_UL_CA
17990          if((ue->cellInfo[idx] != NULLP) &&
17991                (ue->cellInfo[idx]->sCellState == RG_SCH_SCELL_ACTIVE))
17992 #else
17993          if(ue->cellInfo[idx] != NULLP)
17994 #endif
17995          {
17996             cellSch->apisUl->rgSCHUpdBsrLong(ue->cellInfo[idx]->cell, ue, bsArr);
17997          }
17998       }
17999    }
18000 #endif 
18001
18002    RETVALUE(ROK);
18003 }
18004
18005 /**
18006  * @brief PHR update.
18007  *
18008  * @details
18009  *
18010  *     Function : rgSCHCmnUpdExtPhr
18011  *
18012  *     Updates extended power headroom information for an UE.
18013  *
18014  *  @param[in]  RgSchCellCb  *cell
18015  *  @param[in]  RgSchUeCb    *ue
18016  *  @param[in]  U8           phr
18017  *  @param[out] RgSchErrInfo *err
18018  *  @return  S16
18019  *      -# ROK
18020  *      -# RFAILED
18021  **/
18022 #ifdef ANSI
18023 PUBLIC S16 rgSCHCmnUpdExtPhr
18024 (
18025 RgSchCellCb    *cell,
18026 RgSchUeCb      *ue,
18027 RgInfExtPhrCEInfo *extPhr,
18028 RgSchErrInfo   *err
18029 )
18030 #else
18031 PUBLIC S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
18032 RgSchCellCb    *cell;
18033 RgSchUeCb      *ue;
18034 RgInfExtPhrCEInfo *extPhr;
18035 RgSchErrInfo   *err;
18036 #endif
18037 {
18038    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18039    RgSchCmnAllocRecord *allRcd;
18040    CmLList             *node = ueUl->ulAllocLst.last;
18041
18042 #ifdef LTEMAC_SPS
18043    RgSchCmnUlUeSpsInfo   *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
18044 #endif
18045    TRC2(rgSCHCmnUpdExtPhr);
18046
18047    UNUSED(err);
18048
18049    while (node)
18050    {
18051       allRcd = (RgSchCmnAllocRecord *)node->node;
18052       node = node->prev;
18053       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18054       {
18055          rgSCHPwrUpdExtPhr(cell, ue, extPhr, allRcd);
18056          break;
18057       }
18058    }
18059 #ifdef LTEMAC_SPS
18060    if(ulSpsUe->isUlSpsActv)
18061    {
18062       rgSCHCmnSpsPhrInd(cell,ue);
18063    }
18064 #endif
18065
18066    RETVALUE(ROK);
18067 }  /* rgSCHCmnUpdExtPhr */
18068
18069
18070
18071
18072 /**
18073  * @brief PHR update.
18074  *
18075  * @details
18076  *
18077  *     Function : rgSCHCmnUpdPhr
18078  *
18079  *     Updates power headroom information for an UE.
18080  *
18081  *  @param[in]  RgSchCellCb  *cell
18082  *  @param[in]  RgSchUeCb    *ue
18083  *  @param[in]  U8           phr
18084  *  @param[out] RgSchErrInfo *err
18085  *  @return  S16
18086  *      -# ROK
18087  *      -# RFAILED
18088  **/
18089 #ifdef ANSI
18090 PUBLIC S16 rgSCHCmnUpdPhr
18091 (
18092 RgSchCellCb    *cell,
18093 RgSchUeCb      *ue,
18094 U8             phr,
18095 RgSchErrInfo   *err
18096 )
18097 #else
18098 PUBLIC S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
18099 RgSchCellCb    *cell;
18100 RgSchUeCb      *ue;
18101 U8             phr;
18102 RgSchErrInfo   *err;
18103 #endif
18104 {
18105    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18106    RgSchCmnAllocRecord *allRcd;
18107    CmLList             *node = ueUl->ulAllocLst.last;
18108
18109 #ifdef LTEMAC_SPS
18110    RgSchCmnUlUeSpsInfo   *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
18111 #endif
18112    TRC2(rgSCHCmnUpdPhr);
18113
18114    UNUSED(err);
18115
18116    while (node)
18117    {
18118       allRcd = (RgSchCmnAllocRecord *)node->node;
18119       node = node->prev;
18120       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18121       {
18122          rgSCHPwrUpdPhr(cell, ue, phr, allRcd, RG_SCH_CMN_PWR_USE_CFG_MAX_PWR);
18123          break;
18124       }
18125    }
18126 #ifdef LTEMAC_SPS
18127    if(ulSpsUe->isUlSpsActv)
18128    {
18129       rgSCHCmnSpsPhrInd(cell,ue);
18130    }
18131 #endif
18132
18133    RETVALUE(ROK);
18134 }  /* rgSCHCmnUpdPhr */
18135
18136 /**
18137  * @brief UL grant for contention resolution.
18138  *
18139  * @details
18140  *
18141  *     Function : rgSCHCmnContResUlGrant
18142  *
18143  *     Add UE to another queue specifically for CRNTI based contention
18144  *     resolution.
18145  *
18146  *
18147  *  @param[in]  RgSchUeCb    *ue
18148  *  @param[out] RgSchErrInfo *err
18149  *  @return  S16
18150  *      -# ROK
18151  *      -# RFAILED
18152  **/
18153 #ifdef ANSI
18154 PUBLIC S16 rgSCHCmnContResUlGrant
18155 (
18156 RgSchCellCb  *cell,
18157 RgSchUeCb    *ue,
18158 RgSchErrInfo *err
18159 )
18160 #else
18161 PUBLIC S16 rgSCHCmnContResUlGrant(cell, ue, err)
18162 RgSchCellCb  *cell;
18163 RgSchUeCb    *ue;
18164 RgSchErrInfo *err;
18165 #endif
18166 {
18167    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
18168    TRC2(rgSCHCmnContResUlGrant);
18169
18170    #ifdef EMTC_ENABLE
18171    if(cell->emtcEnable)
18172    {
18173       if(ue->isEmtcUe)
18174       {
18175          cellSch->apisEmtcUl->rgSCHContResUlGrant(cell, ue);
18176          RETVALUE(ROK);
18177       }
18178    }
18179    else
18180 #endif
18181    {
18182       cellSch->apisUl->rgSCHContResUlGrant(cell, ue);
18183    }
18184    RETVALUE(ROK);
18185 }
18186
18187 /**
18188  * @brief SR reception handling.
18189  *
18190  * @details
18191  *
18192  *     Function : rgSCHCmnSrRcvd
18193  *
18194  *     - Update UE's position within/across uplink scheduling queues
18195  *     - Update priority of LCGs if needed.
18196  *
18197  *  @param[in]  RgSchCellCb  *cell
18198  *  @param[in]  RgSchUeCb    *ue
18199  *  @param[in]  CmLteTimingInfo frm
18200  *  @param[out] RgSchErrInfo *err
18201  *  @return  S16
18202  *      -# ROK
18203  *      -# RFAILED
18204  **/
18205 #ifdef ANSI
18206 PUBLIC S16 rgSCHCmnSrRcvd
18207 (
18208 RgSchCellCb  *cell,
18209 RgSchUeCb    *ue,
18210 CmLteTimingInfo frm,
18211 RgSchErrInfo *err
18212 )
18213 #else
18214 PUBLIC S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
18215 RgSchCellCb  *cell;
18216 RgSchUeCb    *ue;
18217 CmLteTimingInfo frm;
18218 RgSchErrInfo *err;
18219 #endif
18220 {
18221    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
18222    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
18223    CmLList      *node    = ueUl->ulAllocLst.last;
18224
18225    TRC2(rgSCHCmnSrRcvd);
18226
18227 #ifdef EMTC_ENABLE
18228    emtcStatsUlTomSrInd++;
18229 #endif
18230
18231    RGSCH_INCR_SUB_FRAME(frm, 1); /* 1 TTI after the time SR was sent */
18232    while (node)
18233    {
18234       RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)node->node;
18235       if (RGSCH_TIMEINFO_SAME(frm, allRcd->allocTime))
18236       {
18237          break;
18238       }
18239       node = node->prev;
18240    }
18241    //TODO_SID Need to check when it is getting triggered
18242    ue->isSrGrant = TRUE;
18243 #ifdef EMTC_ENABLE
18244    if(cell->emtcEnable)
18245    {
18246       if(ue->isEmtcUe)
18247       {
18248          cellSch->apisEmtcUl->rgSCHSrRcvd(cell, ue);
18249          RETVALUE(ROK);
18250       }
18251    }
18252    else
18253 #endif
18254    {
18255       cellSch->apisUl->rgSCHSrRcvd(cell, ue);
18256    }
18257    RETVALUE(ROK);
18258 }
18259
18260 /**
18261  * @brief Returns first uplink allocation to send reception
18262  *        request to PHY.
18263  *
18264  * @details
18265  *
18266  *     Function: rgSCHCmnFirstRcptnReq(cell)
18267  *     Purpose:  This function returns the first uplink allocation
18268  *               (or NULLP if there is none) in the subframe
18269  *               in which is expected to prepare and send reception
18270  *               request to PHY.
18271  *
18272  *     Invoked by: TOM
18273  *
18274  *  @param[in]  RgSchCellCb      *cell
18275  *  @return  RgSchUlAlloc*
18276  **/
18277 #ifdef ANSI
18278 PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq
18279 (
18280 RgSchCellCb      *cell
18281 )
18282 #else
18283 PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
18284 RgSchCellCb      *cell;
18285 #endif
18286 {
18287    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18288 /* ACC_TDD */
18289    RgSchUlAlloc* alloc = NULLP;
18290
18291    TRC2(rgSCHCmnFirstRcptnReq);
18292
18293    if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
18294    {
18295            RgSchUlSf* sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18296            alloc = rgSCHUtlUlAllocFirst(sf);
18297
18298            if (alloc && alloc->hqProc == NULLP)
18299            {
18300                    alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18301            }
18302    }
18303
18304    RETVALUE(alloc);
18305 }
18306
18307 /**
18308  * @brief Returns first uplink allocation to send reception
18309  *        request to PHY.
18310  *
18311  * @details
18312  *
18313  *     Function: rgSCHCmnNextRcptnReq(cell)
18314  *     Purpose:  This function returns the next uplink allocation
18315  *               (or NULLP if there is none) in the subframe
18316  *               in which is expected to prepare and send reception
18317  *               request to PHY.
18318  *
18319  *     Invoked by: TOM
18320  *
18321  *  @param[in]  RgSchCellCb      *cell
18322  *  @return  RgSchUlAlloc*
18323  **/
18324 #ifdef ANSI
18325 PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq
18326 (
18327 RgSchCellCb      *cell,
18328 RgSchUlAlloc     *alloc
18329 )
18330 #else
18331 PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
18332 RgSchCellCb      *cell;
18333 RgSchUlAlloc     *alloc;
18334 #endif
18335 {
18336    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18337 /* ACC-TDD */
18338    //RgSchUlSf      *sf   = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18339
18340    TRC2(rgSCHCmnNextRcptnReq);
18341 /* ACC-TDD */
18342    if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
18343    {
18344            RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18345
18346            alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18347            if (alloc && alloc->hqProc == NULLP)
18348            {
18349                    alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18350            }
18351    }
18352    else
18353    {
18354            alloc = NULLP;
18355    }
18356
18357    RETVALUE(alloc);
18358 }
18359 /**
18360  * @brief Collates DRX enabled UE's scheduled in this SF
18361  *
18362  * @details
18363  *
18364  *     Function: rgSCHCmnDrxStrtInActvTmrInUl(cell)
18365  *     Purpose:  This function collates the link
18366  *               of UE's scheduled in this SF who
18367  *               have drx enabled. It then calls
18368  *               DRX specific function to start/restart
18369  *               inactivity timer in Ul
18370  *
18371  *     Invoked by: TOM
18372  *
18373  *  @param[in]  RgSchCellCb      *cell
18374  *  @return Void
18375  **/
18376 #ifdef ANSI
18377 PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl
18378 (
18379 RgSchCellCb      *cell
18380 )
18381 #else
18382 PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
18383 RgSchCellCb      *cell;
18384 #endif
18385 {
18386    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18387    RgSchUlSf      *sf     = &(cellUl->ulSfArr[cellUl->schdIdx]);
18388    RgSchUlAlloc   *alloc  = rgSCHUtlUlAllocFirst(sf);
18389    CmLListCp       ulUeLst;
18390    RgSchUeCb       *ueCb;
18391
18392
18393    TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
18394
18395    cmLListInit(&ulUeLst);
18396
18397    while(alloc)
18398    {
18399       ueCb = alloc->ue;
18400
18401       if (ueCb)
18402       {
18403          if (!(alloc->grnt.isRtx) && ueCb->isDrxEnabled && !(ueCb->isSrGrant)
18404 #ifdef LTEMAC_SPS
18405              /* ccpu00139513- DRX inactivity timer should not be started for 
18406               * UL SPS occasions */
18407              && (alloc->hqProc->isSpsOccnHqP == FALSE) 
18408 #endif
18409              )
18410          {
18411             cmLListAdd2Tail(&ulUeLst,&(ueCb->ulDrxInactvTmrLnk));
18412             ueCb->ulDrxInactvTmrLnk.node = (PTR)ueCb;
18413          }
18414       }
18415
18416       alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18417    }/*while(alloc)*/
18418
18419    (Void)rgSCHDrxStrtInActvTmr(cell,&ulUeLst,RG_SCH_DRX_UL);
18420
18421    RETVOID;
18422 }
18423
18424
18425 /**
18426  * @brief Returns first uplink allocation to send HARQ feedback
18427  *        request to PHY.
18428  *
18429  * @details
18430  *
18431  *     Function: rgSCHCmnFirstHqFdbkAlloc
18432  *     Purpose:  This function returns the first uplink allocation
18433  *               (or NULLP if there is none) in the subframe
18434  *               for which it is expected to prepare and send HARQ
18435  *               feedback to PHY.
18436  *
18437  *     Invoked by: TOM
18438  *
18439  *  @param[in]  RgSchCellCb      *cell
18440  *  @param[in]  U8               idx
18441  *  @return  RgSchUlAlloc*
18442  **/
18443 #ifdef ANSI
18444 PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
18445 (
18446 RgSchCellCb      *cell,
18447 U8               idx 
18448 )
18449 #else
18450 PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
18451 RgSchCellCb      *cell;
18452 U8               idx;
18453 #endif
18454 {
18455    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18456 /* ACC-TDD */
18457    RgSchUlAlloc  *alloc = NULLP;
18458
18459    TRC2(rgSCHCmnFirstHqFdbkAlloc);
18460
18461    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
18462    {
18463           RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
18464           alloc    = rgSCHUtlUlAllocFirst(sf);
18465
18466           while (alloc && (alloc->hqProc == NULLP))
18467           {
18468                   alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18469           }
18470    }
18471
18472    RETVALUE(alloc);
18473 }
18474
18475 /**
18476  * @brief Returns next allocation to send HARQ feedback for.
18477  *
18478  * @details
18479  *
18480  *     Function: rgSCHCmnNextHqFdbkAlloc(cell)
18481  *     Purpose:  This function returns the next uplink allocation
18482  *               (or NULLP if there is none) in the subframe
18483  *               for which HARQ feedback needs to be sent.
18484  *
18485  *     Invoked by: TOM
18486  *
18487  *  @param[in]  RgSchCellCb      *cell
18488  *  @return  RgSchUlAlloc*
18489  **/
18490 #ifdef ANSI
18491 PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
18492 (
18493 RgSchCellCb      *cell,
18494 RgSchUlAlloc     *alloc,
18495 U8               idx 
18496 )
18497 #else
18498 PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
18499 RgSchCellCb      *cell;
18500 RgSchUlAlloc     *alloc;
18501 U8               idx; 
18502 #endif
18503 {
18504    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18505    TRC2(rgSCHCmnNextHqFdbkAlloc);
18506
18507    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
18508    {
18509       RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
18510
18511       alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18512       while (alloc && (alloc->hqProc == NULLP))
18513       {
18514          alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18515       }
18516    }
18517    else
18518    {
18519           alloc = NULLP;
18520    }
18521    RETVALUE(alloc);
18522 }
18523
18524 /***********************************************************
18525  *
18526  *     Func : rgSCHCmnUlGetITbsFrmIMcs
18527  *
18528  *     Desc : Returns the Itbs that is mapped to an Imcs
18529  *            for the case of uplink.
18530  *
18531  *     Ret  :
18532  *
18533  *     Notes:
18534  *
18535  *     File :
18536  *
18537  **********************************************************/
18538 #ifdef ANSI
18539 PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs
18540 (
18541 U8          iMcs
18542 )
18543 #else
18544 PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
18545 U8          iMcs;
18546 #endif
18547 {
18548    TRC2(rgSCHCmnUlGetITbsFrmIMcs);
18549
18550    RETVALUE(rgUlIMcsTbl[iMcs].iTbs);
18551 }
18552
18553 /***********************************************************
18554  *
18555  *     Func : rgSCHCmnUlGetIMcsFrmITbs
18556  *
18557  *     Desc : Returns the Imcs that is mapped to an Itbs
18558  *            for the case of uplink.
18559  *
18560  *     Ret  :
18561  *
18562  *     Notes: For iTbs 19, iMcs is dependant on modulation order.
18563  *            Refer to 36.213, Table 8.6.1-1 and 36.306 Table 4.1-2
18564  *            for UE capability information
18565  *
18566  *     File :
18567  *
18568  **********************************************************/
18569 #ifdef ANSI
18570 PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs
18571 (
18572 U8                iTbs,
18573 CmLteUeCategory   ueCtg
18574 )
18575 #else
18576 PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
18577 U8                iTbs;
18578 CmLteUeCategory   ueCtg;
18579 #endif
18580 {
18581    U8 iMcs;
18582    TRC2(rgSCHCmnUlGetIMcsFrmITbs);
18583
18584    if (iTbs <= 10)
18585    {
18586       iMcs = iTbs;
18587    }
18588    /*a higher layer can force a 64QAM UE to transmit at 16QAM.
18589     * We currently do not support this. Once the support for such
18590     * is added, ueCtg should be replaced by current transmit
18591     * modulation configuration.Refer to 36.213 -8.6.1
18592     */
18593    else if ( iTbs < 19 )
18594    {
18595       iMcs = iTbs + 1;
18596    }
18597    else if ((iTbs == 19) && (ueCtg != CM_LTE_UE_CAT_5))
18598    {
18599       iMcs = iTbs + 1;
18600    }
18601    else
18602    {
18603       iMcs = iTbs + 2;
18604    }
18605
18606 #ifdef LTE_TDD
18607    /* This is a Temp fix, done for TENBPLUS-3898, ULSCH SDU corruption
18608       was seen when IMCS exceeds 20  on T2k TDD*/
18609    if (iMcs > 20)
18610    {
18611       iMcs = 20;
18612    }
18613 #endif
18614
18615    RETVALUE(iMcs);
18616 }
18617
18618 /***********************************************************
18619  *
18620  *     Func : rgSCHCmnUlMinTbBitsForITbs
18621  *
18622  *     Desc : Returns the minimum number of bits that can
18623  *            be given as grant for a specific CQI.
18624  *
18625  *     Ret  :
18626  *
18627  *     Notes:
18628  *
18629  *     File :
18630  *
18631  **********************************************************/
18632 #ifdef ANSI
18633 PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs
18634 (
18635 RgSchCmnUlCell     *cellUl,
18636 U8                 iTbs
18637 )
18638 #else
18639 PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
18640 RgSchCmnUlCell   *cellUl;
18641 U8               iTbs;
18642 #endif
18643 {
18644    TRC2(rgSCHCmnUlMinTbBitsForITbs);
18645
18646    RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs); 
18647
18648    RETVALUE(rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
18649 }
18650
18651 /***********************************************************
18652  *
18653  *     Func : rgSCHCmnUlSbAlloc
18654  *
18655  *     Desc : Given a required 'number of subbands' and a hole,
18656  *            returns a suitable alloc such that the subband
18657  *            allocation size is valid
18658  *
18659  *     Ret  :
18660  *
18661  *     Notes: Does not assume either passed numSb or hole size
18662  *            to be valid for allocation, and hence arrives at
18663  *            an acceptable value.
18664  *     File :
18665  *
18666  **********************************************************/
18667 #ifdef ANSI
18668 PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc
18669 (
18670 RgSchUlSf       *sf,
18671 U8              numSb,
18672 RgSchUlHole     *hole
18673 )
18674 #else
18675 PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
18676 RgSchUlSf       *sf;
18677 U8              numSb;
18678 RgSchUlHole     *hole;
18679 #endif
18680 {
18681    U8           holeSz; /* valid hole size */
18682    RgSchUlAlloc *alloc;
18683    TRC2(rgSCHCmnUlSbAlloc);
18684
18685    if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
18686    {
18687       numSb = rgSchCmnMult235Tbl[numSb].match;
18688       if (numSb >= holeSz)
18689       {
18690          alloc = rgSCHUtlUlAllocGetCompHole(sf, hole);
18691       }
18692       else
18693       {
18694          alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
18695       }
18696    }
18697    else
18698    {
18699       if (numSb < holeSz)
18700       {
18701          numSb = rgSchCmnMult235Tbl[numSb].match;
18702       }
18703       else
18704       {
18705          numSb = rgSchCmnMult235Tbl[numSb].prvMatch;
18706       }
18707
18708       if ( numSb >= holeSz )
18709       {
18710          numSb = holeSz;
18711       }
18712       alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
18713    }
18714    RETVALUE(alloc);
18715 }
18716
18717 /**
18718  * @brief To fill the RgSchCmnUeUlAlloc structure of UeCb.
18719  *
18720  * @details
18721  *
18722  *     Function: rgSCHCmnUlUeFillAllocInfo
18723  *     Purpose:  Specific scheduler to call this API to fill the alloc
18724  *               information.
18725  *
18726  *     Invoked by: Scheduler
18727  *
18728  *  @param[in]  RgSchCellCb      *cell
18729  *  @param[out] RgSchUeCb        *ue
18730  *  @return   Void
18731  **/
18732 #ifdef ANSI
18733 PUBLIC Void rgSCHCmnUlUeFillAllocInfo
18734 (
18735 RgSchCellCb      *cell,
18736 RgSchUeCb        *ue
18737 )
18738 #else
18739 PUBLIC Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
18740 RgSchCellCb      *cell;
18741 RgSchUeCb        *ue;
18742 #endif
18743 {
18744    RgSchCmnUlCell     *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18745    RgSchCmnUeUlAlloc  *ulAllocInfo;
18746    RgSchCmnUlUe       *ueUl;
18747
18748    TRC2(rgSCHCmnUlUeFillAllocInfo);
18749
18750    ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18751    ulAllocInfo = &ueUl->alloc;
18752
18753    /* Fill alloc structure */
18754    rgSCHCmnUlAllocFillTpc(cell, ue, ulAllocInfo->alloc);
18755    rgSCHCmnUlAllocFillNdmrs(cellUl, ulAllocInfo->alloc);
18756    rgSCHCmnUlAllocLnkHqProc(ue, ulAllocInfo->alloc, ulAllocInfo->alloc->hqProc,
18757                      ulAllocInfo->alloc->hqProc->isRetx);
18758    /* Fill PDCCH */
18759    rgSCHCmnUlFillPdcchWithAlloc(ulAllocInfo->alloc->pdcch,
18760          ulAllocInfo->alloc, ue);
18761    /* Recording information about this allocation */
18762    rgSCHCmnUlRecordUeAlloc(cell, ue);
18763
18764    /* Update the UE's outstanding allocation */
18765    if (!ulAllocInfo->alloc->hqProc->isRetx)
18766    {
18767       rgSCHCmnUlUpdOutStndAlloc(cell, ue, ulAllocInfo->allocdBytes);
18768    }
18769
18770    RETVOID;
18771 }
18772
18773 /**
18774  * @brief Update the UEs outstanding alloc based on the BSR report's timing.
18775  *
18776  *
18777  * @details
18778  *
18779  *     Function: rgSCHCmnUpdUlCompEffBsr
18780  *     Purpose:  Clear off all the allocations from outstanding allocation that
18781  *     are later than or equal to BSR timing information (stored in UEs datIndTime).
18782  *
18783  *     Invoked by: Scheduler
18784  *
18785  *  @param[in]  RgSchUeCb *ue
18786  *  @return  Void
18787  **/
18788 #ifdef ANSI
18789 PRIVATE Void rgSCHCmnUpdUlCompEffBsr
18790 (
18791 RgSchUeCb *ue
18792 )
18793 #else
18794 PRIVATE Void rgSCHCmnUpdUlCompEffBsr(ue)
18795 RgSchUeCb *ue;
18796 #endif
18797 {
18798    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,ue->cell);
18799    CmLList   *node = ueUl->ulAllocLst.last;
18800    RgSchCmnAllocRecord *allRcd;
18801    U32 outStndAlloc=0;
18802    U32 nonLcg0OutStndAllocBs=0;
18803    U32 nonLcg0Bsr=0;
18804    U8  lcgId;
18805    RgSchCmnLcg *cmnLcg = NULLP;
18806    TRC2(rgSCHCmnUpdUlCompEffBsr);
18807
18808    while (node)
18809    {
18810       allRcd = (RgSchCmnAllocRecord *)node->node;
18811       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18812       {
18813          node = node->next;
18814          break;
18815       }
18816       node = node->prev;
18817    }
18818    while (node)
18819    {
18820       allRcd = (RgSchCmnAllocRecord *)node->node;
18821       node = node->next;
18822       outStndAlloc += allRcd->alloc;
18823    }
18824  
18825    cmnLcg = (RgSchCmnLcg *)(ue->ul.lcgArr[0].sch);
18826    /* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
18827    if (cmnLcg->bs > outStndAlloc)
18828    {
18829       cmnLcg->bs -= outStndAlloc;
18830       ue->ul.minReqBytes = cmnLcg->bs;
18831       outStndAlloc = 0;
18832    }
18833    else
18834    {
18835       nonLcg0OutStndAllocBs = outStndAlloc - cmnLcg->bs;
18836       cmnLcg->bs = 0;
18837    }
18838
18839    for(lcgId = 1;lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
18840    {
18841       if(RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
18842       {
18843          cmnLcg = ((RgSchCmnLcg *) (ue->ul.lcgArr[lcgId].sch));
18844          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
18845          {
18846             nonLcg0Bsr += cmnLcg->bs;
18847          }
18848       }
18849    }
18850    nonLcg0Bsr += ue->ul.nonGbrLcgBs;  
18851    if (nonLcg0OutStndAllocBs > nonLcg0Bsr)
18852    {
18853       nonLcg0Bsr = 0;
18854    }
18855    else
18856    {
18857       nonLcg0Bsr -= nonLcg0OutStndAllocBs;
18858    }
18859    ue->ul.nonLcg0Bs = nonLcg0Bsr;
18860    /* Cap effBsr with nonLcg0Bsr and append lcg0 bs.
18861     * nonLcg0Bsr limit applies only to lcg1,2,3 */
18862    /* better be handled in individual scheduler */
18863    ue->ul.effBsr = nonLcg0Bsr +\
18864                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
18865    RETVOID;
18866 }
18867
18868 /**
18869  * @brief  Records information about the current allocation.
18870  *
18871  * @details
18872  *
18873  *     Function: rgSCHCmnUlRecordUeAlloc
18874  *     Purpose:  Records information about the curent allocation.
18875  *               This includes the allocated bytes, as well
18876  *               as some power information.
18877  *
18878  *     Invoked by: Scheduler
18879  *
18880  *  @param[in]  RgSchCellCb *cell
18881  *  @param[in]  RgSchUeCb   *ue
18882  *  @return  Void
18883  **/
18884 #ifdef ANSI
18885 PUBLIC Void rgSCHCmnUlRecordUeAlloc
18886 (
18887 RgSchCellCb *cell,
18888 RgSchUeCb   *ue
18889 )
18890 #else
18891 PUBLIC Void rgSCHCmnUlRecordUeAlloc(cell, ue)
18892 RgSchCellCb *cell;
18893 RgSchUeCb   *ue;
18894 #endif
18895 {
18896 #ifdef LTE_TDD
18897    RgSchCmnUlCell     *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18898 #endif
18899    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18900    CmLListCp           *lst = &ueUl->ulAllocLst;
18901    CmLList             *node = ueUl->ulAllocLst.first;
18902    RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
18903    RgSchCmnUeUlAlloc  *ulAllocInfo = &ueUl->alloc;
18904    CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
18905    TRC2(rgSCHCmnUlRecordUeAlloc);
18906
18907    cmLListDelFrm(lst, &allRcd->lnk);
18908 #ifndef LTE_TDD
18909    /* To the crntTime, add the MIN time at which UE will
18910     * actually send the BSR i.e DELTA+4 */
18911    allRcd->allocTime = cell->crntTime;
18912    /*ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
18913 #ifdef EMTC_ENABLE
18914    if(ue->isEmtcUe == TRUE)
18915    {
18916       RGSCH_INCR_SUB_FRAME_EMTC(allRcd->allocTime,
18917                            (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
18918    }
18919    else
18920 #endif
18921    {
18922       RGSCH_INCR_SUB_FRAME(allRcd->allocTime,
18923                            (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
18924    }
18925 #else
18926    allRcd->allocTime = cellUl->schdTime;
18927 #endif
18928    cmLListAdd2Tail(lst, &allRcd->lnk);
18929
18930    /* Filling in the parameters to be recorded */
18931    allRcd->alloc = ulAllocInfo->allocdBytes;
18932    //allRcd->numRb = ulAllocInfo->alloc->grnt.numRb;
18933    allRcd->numRb = (ulAllocInfo->alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
18934    /*Recording the UL CQI derived from the maxUlCqi */
18935    allRcd->cqi   = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
18936    allRcd->tpc   = ulAllocInfo->alloc->grnt.tpc;
18937
18938    rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
18939
18940    cell->measurements.ulBytesCnt += ulAllocInfo->allocdBytes;
18941
18942    RETVOID;
18943 }
18944
18945 /** PHR handling for MSG3
18946  * @brief  Records allocation information of msg3 in the the UE.
18947  *
18948  * @details
18949  *
18950  *     Function: rgSCHCmnUlRecMsg3Alloc
18951  *     Purpose:  Records information about msg3 allocation.
18952  *               This includes the allocated bytes, as well
18953  *               as some power information.
18954  *
18955  *     Invoked by: Scheduler
18956  *
18957  *  @param[in]  RgSchCellCb *cell
18958  *  @param[in]  RgSchUeCb   *ue
18959  *  @param[in]  RgSchRaCb   *raCb
18960  *  @return  Void
18961  **/
18962 #ifdef ANSI
18963 PUBLIC Void rgSCHCmnUlRecMsg3Alloc
18964 (
18965 RgSchCellCb *cell,
18966 RgSchUeCb   *ue,
18967 RgSchRaCb   *raCb
18968 )
18969 #else
18970 PUBLIC Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
18971 RgSchCellCb *cell;
18972 RgSchUeCb   *ue;
18973 RgSchRaCb   *raCb;
18974 #endif
18975 {
18976    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18977    CmLListCp           *lst = &ueUl->ulAllocLst;
18978    CmLList             *node = ueUl->ulAllocLst.first;
18979    RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
18980
18981    /* Stack Crash problem for TRACE5 changes */
18982    TRC2(rgSCHCmnUlRecMsg3Alloc);
18983
18984    cmLListDelFrm(lst, node);
18985    allRcd->allocTime = raCb->msg3AllocTime;
18986    cmLListAdd2Tail(lst, node);
18987
18988    /* Filling in the parameters to be recorded */
18989    allRcd->alloc = raCb->msg3Grnt.datSz;
18990    allRcd->numRb = raCb->msg3Grnt.numRb;
18991    allRcd->cqi   = raCb->ccchCqi;
18992    allRcd->tpc   = raCb->msg3Grnt.tpc;
18993
18994    rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
18995
18996    RETVOID;
18997 }
18998 /**
18999  * @brief Keeps track of the most recent RG_SCH_CMN_MAX_ALLOC_TRACK
19000  * allocations to track. Adds this allocation to the ueUl's ulAllocLst.
19001  *
19002  *
19003  * @details
19004  *
19005  *     Function: rgSCHCmnUlUpdOutStndAlloc
19006  *     Purpose:  Recent Allocation shall be at First Pos'n.
19007  *               Remove the last node, update the fields
19008  *                with the new allocation and add at front.
19009  *
19010  *     Invoked by: Scheduler
19011  *
19012  *  @param[in]  RgSchCellCb *cell
19013  *  @param[in]  RgSchUeCb   *ue
19014  *  @param[in]  U32 alloc
19015  *  @return  Void
19016  **/
19017 #ifdef ANSI
19018 PUBLIC Void rgSCHCmnUlUpdOutStndAlloc
19019 (
19020 RgSchCellCb *cell,
19021 RgSchUeCb   *ue,
19022 U32 alloc
19023 )
19024 #else
19025 PUBLIC Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
19026 RgSchCellCb *cell;
19027 RgSchUeCb   *ue;
19028 U32 alloc;
19029 #endif
19030 {
19031    U32                 nonLcg0Alloc=0;
19032    TRC2(rgSCHCmnUlUpdOutStndAlloc);
19033
19034    /* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
19035    if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
19036    {
19037       ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs -= alloc;
19038    }
19039    else
19040    {
19041       nonLcg0Alloc = alloc - ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
19042       ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = 0;
19043    }
19044
19045    if (nonLcg0Alloc >= ue->ul.nonLcg0Bs)
19046    {
19047       ue->ul.nonLcg0Bs  = 0;
19048    }
19049    else
19050    {
19051       ue->ul.nonLcg0Bs  -= nonLcg0Alloc;
19052    }
19053    /* Cap effBsr with effAmbr and append lcg0 bs.
19054     * effAmbr limit applies only to lcg1,2,3 non GBR LCG's*/
19055    /* better be handled in individual scheduler */
19056    ue->ul.effBsr = ue->ul.nonLcg0Bs +\
19057                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
19058 #ifdef RGR_V1
19059    if (ue->ul.effBsr == 0)
19060    {
19061       if (ue->bsrTmr.tmrEvnt != TMR_NONE)
19062       {
19063          rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
19064       }
19065       /* ccpu00133008 */
19066       if (FALSE == ue->isSrGrant)
19067       {
19068          if (ue->ul.bsrTmrCfg.isPrdBsrTmrPres)
19069          {
19070             /*
19071             rgSCHTmrStartTmr(cell, ue, RG_SCH_TMR_BSR,
19072                   ue->ul.bsrTmrCfg.prdBsrTmr);
19073             */
19074          }
19075       }
19076    }
19077 #endif
19078    /* Resetting UEs lower Cap */
19079    ue->ul.minReqBytes = 0;
19080
19081    RETVOID;
19082 }
19083
19084
19085 /**
19086  * @brief Returns the "Itbs" for a given UE.
19087  *
19088  * @details
19089  *
19090  *     Function: rgSCHCmnUlGetITbs
19091  *     Purpose:  This function returns the "Itbs" for a given UE.
19092  *
19093  *     Invoked by: Scheduler
19094  *
19095  *  @param[in]  RgSchUeCb        *ue
19096  *  @return     U8
19097  **/
19098 #ifdef ANSI
19099 PUBLIC U8 rgSCHCmnUlGetITbs
19100 (
19101 RgSchCellCb      *cell,
19102 RgSchUeCb        *ue,
19103 Bool             isEcp
19104 )
19105 #else
19106 PUBLIC U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
19107 RgSchCellCb      *cell;
19108 RgSchUeCb        *ue;
19109 Bool             isEcp;
19110 #endif
19111 {
19112    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
19113    /* CQI will be capped to maxUlCqi for 16qam UEs */
19114    CmLteUeCategory  ueCtgy = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
19115    U8            cqi;
19116 #ifdef UL_LA
19117    S32            iTbs;
19118    U8            maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi]; 
19119 #endif
19120
19121    TRC2(rgSCHCmnUlGetITbs);
19122
19123    /* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
19124 #ifdef TFU_UPGRADE
19125    if ( (ueCtgy != CM_LTE_UE_CAT_5) &&
19126         (ueUl->validUlCqi > ueUl->maxUlCqi)
19127       )
19128    {
19129       cqi = ueUl->maxUlCqi;
19130    }
19131    else
19132    {
19133       cqi = ueUl->validUlCqi;
19134    }
19135
19136 #ifdef UL_LA
19137    iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
19138
19139    RG_SCH_CHK_ITBS_RANGE(iTbs, maxiTbs); 
19140
19141    iTbs = RGSCH_MIN(iTbs,  ue->cell->thresholds.maxUlItbs);
19142
19143 #ifdef LTE_TDD
19144    /* This is a Temp fix, done for TENBPLUS-3898, ULSCH SDU corruption
19145       was seen when IMCS exceeds 20 on T2k TDD */
19146    if (iTbs > 19)
19147    {
19148       iTbs = 19;
19149    }
19150 #endif
19151    RETVALUE(iTbs);
19152 #endif 
19153 #else
19154    if ( (ueCtgy != CM_LTE_UE_CAT_5) && (ueUl->crntUlCqi[0] > ueUl->maxUlCqi ))
19155    {
19156       cqi = ueUl->maxUlCqi;
19157    }
19158    else
19159    {
19160       cqi = ueUl->crntUlCqi[0];
19161    }
19162 #endif
19163    RETVALUE(rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
19164 }
19165
19166 /**
19167  * @brief This function adds the UE to DLRbAllocInfo TX lst.
19168  *
19169  * @details
19170  *
19171  *     Function: rgSCHCmnDlRbInfoAddUeTx
19172  *     Purpose:  This function adds the UE to DLRbAllocInfo TX lst.
19173  *
19174  *     Invoked by: Common Scheduler
19175  *
19176  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19177  *  @param[in]  RgSchUeCb             *ue
19178  *  @param[in]  RgSchDlHqProcCb       *hqP
19179  *  @return  Void
19180  *
19181  **/
19182 #ifdef ANSI
19183 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx
19184 (
19185 RgSchCellCb        *cell,
19186 RgSchCmnDlRbAllocInfo *allocInfo,
19187 RgSchUeCb             *ue,
19188 RgSchDlHqProcCb       *hqP
19189 )
19190 #else
19191 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx(cell, allocInfo, ue, hqP)
19192 RgSchCellCb        *cell;
19193 RgSchCmnDlRbAllocInfo *allocInfo;
19194 RgSchUeCb             *ue;
19195 RgSchDlHqProcCb       *hqP;
19196 #endif
19197 {
19198    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
19199
19200    TRC2(rgSCHCmnDlRbInfoAddUeTx);
19201
19202    if (hqP->reqLnk.node == NULLP)
19203    {
19204       if (cellSch->dl.isDlFreqSel)
19205       {
19206          cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19207            &allocInfo->dedAlloc.txHqPLst, hqP);
19208       }
19209       else
19210       {
19211          {
19212             cmLListAdd2Tail(&allocInfo->dedAlloc.txHqPLst, &hqP->reqLnk);
19213          }
19214          hqP->reqLnk.node = (PTR)hqP;
19215       }
19216    }
19217    RETVOID;
19218 }
19219
19220 /**
19221  * @brief This function adds the UE to DLRbAllocInfo RETX lst.
19222  *
19223  * @details
19224  *
19225  *     Function: rgSCHCmnDlRbInfoAddUeRetx
19226  *     Purpose:  This function adds the UE to DLRbAllocInfo RETX lst.
19227  *
19228  *     Invoked by: Common Scheduler
19229  *
19230  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19231  *  @param[in]  RgSchUeCb             *ue
19232  *  @param[in]  RgSchDlHqProcCb       *hqP
19233  *  @return  Void
19234  *
19235  **/
19236 #ifdef ANSI
19237 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx
19238 (
19239 RgSchCellCb        *cell,
19240 RgSchCmnDlRbAllocInfo *allocInfo,
19241 RgSchUeCb             *ue,
19242 RgSchDlHqProcCb       *hqP
19243 )
19244 #else
19245 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx(cell, allocInfo, ue, hqP)
19246 RgSchCellCb        *cell;
19247 RgSchCmnDlRbAllocInfo *allocInfo;
19248 RgSchUeCb             *ue;
19249 RgSchDlHqProcCb       *hqP;
19250 #endif
19251 {
19252    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
19253
19254    TRC2(rgSCHCmnDlRbInfoAddUeRetx);
19255
19256    if (cellSch->dl.isDlFreqSel)
19257    {
19258       cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19259         &allocInfo->dedAlloc.retxHqPLst, hqP);
19260    }
19261    else
19262    {
19263       /* checking UE's presence in this lst is unnecessary */
19264       cmLListAdd2Tail(&allocInfo->dedAlloc.retxHqPLst, &hqP->reqLnk);
19265       hqP->reqLnk.node = (PTR)hqP;
19266    }
19267    RETVOID;
19268 }
19269
19270 /**
19271  * @brief This function adds the UE to DLRbAllocInfo TX-RETX lst.
19272  *
19273  * @details
19274  *
19275  *     Function: rgSCHCmnDlRbInfoAddUeRetxTx
19276  *     Purpose:  This adds the UE to DLRbAllocInfo TX-RETX lst.
19277  *
19278  *     Invoked by: Common Scheduler
19279  *
19280  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19281  *  @param[in]  RgSchUeCb             *ue
19282  *  @param[in]  RgSchDlHqProcCb       *hqP
19283  *  @return  Void
19284  *
19285  **/
19286 #ifdef ANSI
19287 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx
19288 (
19289 RgSchCellCb        *cell,
19290 RgSchCmnDlRbAllocInfo *allocInfo,
19291 RgSchUeCb             *ue,
19292 RgSchDlHqProcCb       *hqP
19293 )
19294 #else
19295 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx(allocInfo, ue, hqP)
19296 RgSchCellCb        *cell;
19297 RgSchCmnDlRbAllocInfo *allocInfo;
19298 RgSchUeCb             *ue;
19299 RgSchDlHqProcCb       *hqP;
19300 #endif
19301 {
19302    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
19303
19304    TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
19305
19306    if (cellSch->dl.isDlFreqSel)
19307    {
19308       cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19309         &allocInfo->dedAlloc.txRetxHqPLst, hqP);
19310    }
19311    else
19312    {
19313       cmLListAdd2Tail(&allocInfo->dedAlloc.txRetxHqPLst, &hqP->reqLnk);
19314       hqP->reqLnk.node = (PTR)hqP;
19315    }
19316    RETVOID;
19317 }
19318
19319 /**
19320  * @brief This function adds the UE to DLRbAllocInfo NonSchdRetxLst.
19321  *
19322  * @details
19323  *
19324  *     Function: rgSCHCmnDlAdd2NonSchdRetxLst 
19325  *     Purpose:  During RB estimation for RETX, if allocation fails
19326  *               then appending it to NonSchdRetxLst, the further
19327  *               action is taken as part of Finalization in
19328  *               respective schedulers.
19329  *
19330  *     Invoked by: Common Scheduler
19331  *
19332  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19333  *  @param[in]  RgSchUeCb             *ue
19334  *  @param[in]  RgSchDlHqProcCb       *hqP
19335  *  @return  Void
19336  *
19337  **/
19338 #ifdef ANSI
19339 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst 
19340 (
19341 RgSchCmnDlRbAllocInfo *allocInfo,
19342 RgSchUeCb             *ue,
19343 RgSchDlHqProcCb       *hqP
19344 )
19345 #else
19346 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst(allocInfo, ue, hqP)
19347 RgSchCmnDlRbAllocInfo *allocInfo;
19348 RgSchUeCb             *ue;
19349 RgSchDlHqProcCb       *hqP;
19350 #endif
19351 {
19352    CmLList         *schdLnkNode;
19353
19354    TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
19355
19356 #ifdef LTEMAC_SPS
19357    if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) && 
19358          (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP)))
19359    {
19360       RETVOID;
19361    }
19362 #endif
19363
19364    schdLnkNode = &hqP->schdLstLnk;
19365    RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
19366    cmLListAdd2Tail(&allocInfo->dedAlloc.nonSchdRetxHqPLst, schdLnkNode);
19367
19368    RETVOID;
19369 }
19370
19371
19372
19373 /**
19374  * @brief This function adds the UE to DLRbAllocInfo NonSchdTxRetxLst.
19375  *
19376  * @details
19377  *
19378  *     Function: rgSCHCmnDlAdd2NonSchdTxRetxLst 
19379  *     Purpose:  During RB estimation for TXRETX, if allocation fails
19380  *               then appending it to NonSchdTxRetxLst, the further
19381  *               action is taken as part of Finalization in
19382  *               respective schedulers.
19383  *
19384  *     Invoked by: Common Scheduler
19385  *
19386  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19387  *  @param[in]  RgSchUeCb             *ue
19388  *  @param[in]  RgSchDlHqProcCb       *hqP
19389  *  @return  Void
19390  *
19391  **/
19392 #ifdef LTE_TDD
19393 /**
19394  * @brief This function handles the initialisation of DL HARQ/ACK feedback
19395  *        timing information for eaach DL subframe.
19396  *
19397  * @details
19398  *
19399  *     Function: rgSCHCmnDlANFdbkInit
19400  *     Purpose:  Each DL subframe stores the sfn and subframe
19401  *               information of UL subframe in which it expects
19402  *               HARQ ACK/NACK feedback for this subframe.It
19403  *               generates the information based on Downlink
19404  *               Association Set Index table.
19405  *
19406  *     Invoked by: Scheduler
19407  *
19408  *  @param[in]  RgSchCellCb*     cell
19409  *  @return     S16
19410  *
19411  **/
19412 #ifdef ANSI
19413 PRIVATE S16 rgSCHCmnDlANFdbkInit
19414 (
19415 RgSchCellCb                *cell
19416 )
19417 #else
19418 PRIVATE S16 rgSCHCmnDlANFdbkInit(cell)
19419 RgSchCellCb                *cell;
19420 #endif
19421 {
19422  U8                   sfCount;
19423  U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19424  U8                   maxDlSubfrms = cell->numDlSubfrms;
19425  U8                   sfNum;
19426  U8                   idx;
19427  U8                   dlIdx;
19428  U8                   calcSfnOffset;
19429  S8                   calcSfNum;
19430  U8                   ulSfCnt =0;
19431  RgSchTddSubfrmInfo   ulSubfrmInfo;
19432  U8                   maxUlSubfrms;
19433
19434    TRC2(rgSCHCmnDlANFdbkInit);
19435
19436    ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19437    maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19438
19439    /* Generate HARQ ACK/NACK feedback information for each DL sf in a radio frame
19440     * Calculate this information based on DL Association set Index table */
19441    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19442    {
19443       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19444             RG_SCH_TDD_UL_SUBFRAME)
19445       {
19446          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19447       }
19448       ulSfCnt++;
19449
19450       for(idx=0; idx < rgSchTddDlAscSetIdxKTbl[ulDlCfgIdx][sfNum].\
19451             numFdbkSubfrms; idx++)
19452       {
19453          calcSfNum = sfNum - rgSchTddDlAscSetIdxKTbl[ulDlCfgIdx][sfNum].\
19454                      subfrmNum[idx];
19455          if(calcSfNum < 0)
19456          {
19457             calcSfnOffset = RGSCH_CEIL(-calcSfNum, RGSCH_NUM_SUB_FRAMES);
19458          }
19459          else
19460          {
19461             calcSfnOffset = 0;
19462          }
19463
19464          calcSfNum = ((RGSCH_NUM_SUB_FRAMES * calcSfnOffset) + calcSfNum)\
19465                      % RGSCH_NUM_SUB_FRAMES;
19466
19467          if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19468          {
19469             dlIdx = calcSfNum;
19470          }
19471          else if((ulSubfrmInfo.switchPoints == 2) && (calcSfNum <= \
19472                   RG_SCH_CMN_SPL_SUBFRM_6))
19473          {
19474             dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19475          }
19476          else
19477          {
19478             dlIdx = calcSfNum - maxUlSubfrms;
19479          }
19480
19481          cell->subFrms[dlIdx]->dlFdbkInfo.subframe = sfNum;
19482          cell->subFrms[dlIdx]->dlFdbkInfo.sfnOffset = calcSfnOffset;
19483          cell->subFrms[dlIdx]->dlFdbkInfo.m = idx;
19484       }
19485       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19486    }
19487
19488    /* DL subframes in the subsequent radio frames are initialized
19489     * with the previous radio frames  */
19490    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms; dlIdx < maxDlSubfrms;\
19491          dlIdx++)
19492    {
19493       sfNum = dlIdx - rgSchTddNumDlSubfrmTbl[ulDlCfgIdx]\
19494               [RGSCH_NUM_SUB_FRAMES-1];
19495       cell->subFrms[dlIdx]->dlFdbkInfo.subframe = \
19496                                                   cell->subFrms[sfNum]->dlFdbkInfo.subframe;
19497       cell->subFrms[dlIdx]->dlFdbkInfo.sfnOffset = \
19498                                                    cell->subFrms[sfNum]->dlFdbkInfo.sfnOffset;
19499       cell->subFrms[dlIdx]->dlFdbkInfo.m = cell->subFrms[sfNum]->dlFdbkInfo.m;
19500    }
19501    RETVALUE(ROK);
19502 }
19503
19504 /**
19505  * @brief This function handles the initialization of uplink association
19506  *        set information for each DL subframe.
19507  *
19508  *
19509  * @details
19510  *
19511  *     Function: rgSCHCmnDlKdashUlAscInit
19512  *     Purpose:  Each DL sf stores the sfn and sf information of UL sf
19513  *               in which it expects HQ ACK/NACK trans. It generates the information
19514  *               based on k` in UL association set index table.
19515  *
19516  *     Invoked by: Scheduler
19517  *
19518  *  @param[in]  RgSchCellCb*     cell
19519  *  @return     S16
19520  *
19521  **/
19522 #ifdef ANSI
19523 PRIVATE S16 rgSCHCmnDlKdashUlAscInit
19524 (
19525 RgSchCellCb                *cell
19526 )
19527 #else
19528 PRIVATE S16 rgSCHCmnDlKdashUlAscInit(cell)
19529 RgSchCellCb                *cell;
19530 #endif
19531 {
19532  U8                   sfCount;
19533  U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19534  U8                   maxDlSubfrms = cell->numDlSubfrms;
19535  U8                   sfNum;
19536  U8                   dlIdx;
19537  S8                   calcSfnOffset;
19538  S8                   calcSfNum;
19539  U8                   ulSfCnt =0;
19540  RgSchTddSubfrmInfo   ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19541  U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19542                                      [RGSCH_NUM_SUB_FRAMES-1];
19543  U8                   dlPres = 0;
19544
19545    TRC2(rgSCHCmnDlKdashUlAscInit);
19546
19547    /* Generate ACK/NACK offset information for each DL subframe in a radio frame
19548     * Calculate this information based on K` in UL Association Set table */
19549    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19550    {
19551       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19552             RG_SCH_TDD_UL_SUBFRAME)
19553       {
19554          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19555       }
19556       ulSfCnt++;
19557
19558       calcSfNum = (sfNum - rgSchTddUlAscIdxKDashTbl[ulDlCfgIdx-1][sfNum] + \
19559             RGSCH_NUM_SUB_FRAMES) % RGSCH_NUM_SUB_FRAMES;
19560       calcSfnOffset = sfNum - rgSchTddUlAscIdxKDashTbl[ulDlCfgIdx-1][sfNum];
19561       if(calcSfnOffset < 0)
19562       {
19563          calcSfnOffset = RGSCH_CEIL(-calcSfnOffset, RGSCH_NUM_SUB_FRAMES);
19564       }
19565       else
19566       {
19567          calcSfnOffset = 0;
19568       }
19569
19570       if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19571       {
19572          dlIdx = calcSfNum;
19573       }
19574       else if((ulSubfrmInfo.switchPoints == 2) &&
19575             (calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_6))
19576       {
19577          dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19578       }
19579       else
19580       {
19581          dlIdx = calcSfNum - maxUlSubfrms;
19582       }
19583
19584       cell->subFrms[dlIdx]->ulAscInfo.subframe = sfNum;
19585       cell->subFrms[dlIdx]->ulAscInfo.sfnOffset = calcSfnOffset;
19586
19587       /* set dlIdx for which ulAscInfo is updated */
19588       dlPres = dlPres | (1 << dlIdx);
19589       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19590    }
19591
19592    /* Set Invalid information for which ulAscInfo is not present */
19593    for (sfCount = 0;
19594          sfCount < rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19595          sfCount++)
19596    {
19597       /* If dlPres is 0, ulAscInfo is not present in that DL index */
19598       if(! ((dlPres >> sfCount)&0x01))
19599       {
19600          cell->subFrms[sfCount]->ulAscInfo.sfnOffset =
19601             RGSCH_INVALID_INFO;
19602          cell->subFrms[sfCount]->ulAscInfo.subframe =
19603             RGSCH_INVALID_INFO;
19604       }
19605    }
19606
19607    /* DL subframes in the subsequent radio frames are initialized
19608     * with the previous radio frames  */
19609    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms; dlIdx < maxDlSubfrms;
19610          dlIdx++)
19611    {
19612       sfNum = dlIdx - \
19613               rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19614       cell->subFrms[dlIdx]->ulAscInfo.subframe =
19615          cell->subFrms[sfNum]->ulAscInfo.subframe;
19616       cell->subFrms[dlIdx]->ulAscInfo.sfnOffset =
19617          cell->subFrms[sfNum]->ulAscInfo.sfnOffset;
19618    }
19619    RETVALUE(ROK);
19620 }
19621
19622
19623 /**
19624  * @brief This function initialises the 'Np' value for 'p'
19625  *
19626  * @details
19627  *
19628  *     Function: rgSCHCmnDlNpValInit
19629  *     Purpose:  To initialise the 'Np' value for each 'p'. It is used
19630  *               to find the mapping between nCCE and 'p' and used in
19631  *               HARQ ACK/NACK reception.
19632  *
19633  *     Invoked by: Scheduler
19634  *
19635  *  @param[in]  RgSchCellCb*     cell
19636  *  @return     S16
19637  *
19638  **/
19639 #ifdef ANSI
19640 PRIVATE S16 rgSCHCmnDlNpValInit
19641 (
19642 RgSchCellCb                *cell
19643 )
19644 #else
19645 PRIVATE S16 rgSCHCmnDlNpValInit(cell)
19646 RgSchCellCb                *cell;
19647 #endif
19648 {
19649    U8    idx;
19650    U16   np;
19651    TRC2(rgSCHCmnDlNpValInit);
19652
19653    /* Always Np is 0 for p=0 */
19654    cell->rgSchTddNpValTbl[0] = 0;
19655
19656    for(idx=1; idx < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; idx++)
19657    {
19658       np = cell->bwCfg.dlTotalBw * (idx * RG_SCH_CMN_NUM_SUBCAR - 4);
19659       cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
19660    }
19661
19662    RETVALUE(ROK);
19663 }
19664
19665 /**
19666  * @brief This function handles the creation of RACH preamble
19667  *        list to queue the preambles and process at the scheduled
19668  *        time.
19669  *
19670  * @details
19671  *
19672  *     Function: rgSCHCmnDlCreateRachPrmLst
19673  *     Purpose:  To create RACH preamble list based on RA window size.
19674  *               It is used to queue the preambles and process it at the
19675  *               scheduled time.
19676  *
19677  *     Invoked by: Scheduler
19678  *
19679  *  @param[in]  RgSchCellCb*     cell
19680  *  @return     S16
19681  *
19682  **/
19683 #ifdef ANSI
19684 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst
19685 (
19686 RgSchCellCb                *cell
19687 )
19688 #else
19689 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst(cell)
19690 RgSchCellCb                *cell;
19691 #endif
19692 {
19693  U8       raArrSz;
19694  S16       ret;
19695  U8       lstSize;
19696
19697    TRC2(rgSCHCmnDlCreateRachPrmLst);
19698
19699    RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
19700
19701    lstSize = raArrSz * RGSCH_MAX_RA_RNTI_PER_SUBFRM * RGSCH_NUM_SUB_FRAMES;
19702
19703    cell->raInfo.maxRaSize = raArrSz;
19704    ret = rgSCHUtlAllocSBuf(cell->instIdx,
19705          (Data **)(&cell->raInfo.raReqLst), (Size)(lstSize * sizeof(CmLListCp)));
19706    if (ret != ROK)
19707    {
19708       RETVALUE(ret);
19709    }
19710
19711    cell->raInfo.lstSize = lstSize;
19712
19713    RETVALUE(ROK);
19714 }
19715
19716
19717 /**
19718  * @brief This function handles the initialization of RACH Response
19719  *        information at each DL subframe.
19720  *
19721  * @details
19722  *
19723  *     Function: rgSCHCmnDlRachInfoInit
19724  *     Purpose:  Each DL subframe stores the sfn and subframe information of
19725  *               possible RACH response allowed for UL subframes. It generates
19726  *               the information based on PRACH configuration.
19727  *
19728  *     Invoked by: Scheduler
19729  *
19730  *  @param[in]  RgSchCellCb*     cell
19731  *  @return     S16
19732  *
19733  **/
19734 #ifdef ANSI
19735 PRIVATE S16 rgSCHCmnDlRachInfoInit
19736 (
19737 RgSchCellCb                *cell
19738 )
19739 #else
19740 PRIVATE S16 rgSCHCmnDlRachInfoInit(cell)
19741 RgSchCellCb                *cell;
19742 #endif
19743 {
19744    U8                   sfCount;
19745    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19746    U8                   sfNum;
19747    U8                   ulSfCnt =0;
19748    U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19749                                        [RGSCH_NUM_SUB_FRAMES-1];
19750    U8                   raArrSz;
19751    RgSchTddRachRspLst   rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
19752    U8                   startWin;
19753    U8                   endWin;
19754    U8                   sfnIdx;
19755    U8                   subfrmIdx;
19756    U8                   endSubfrmIdx;
19757    U8                   startSubfrmIdx;
19758    S16                   ret;
19759    RgSchTddRachDelInfo  *delInfo;
19760    S8                   sfnOffset;
19761    U8                   numSubfrms;
19762
19763    TRC2(rgSCHCmnDlRachInfoInit);
19764
19765    cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
19766
19767    RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
19768
19769    /* Include Special subframes */
19770    maxUlSubfrms = maxUlSubfrms + \
19771                   rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx].switchPoints;
19772    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19773    {
19774       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] ==
19775             RG_SCH_TDD_DL_SUBFRAME)
19776       {
19777          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19778       }
19779       ulSfCnt++;
19780
19781       startWin = (sfNum + RG_SCH_CMN_RARSP_WAIT_PRD + \
19782             ((RgSchCmnCell *)cell->sc.sch)->dl.numRaSubFrms);
19783       endWin = (startWin + cell->rachCfg.raWinSize - 1);
19784       startSubfrmIdx =
19785          rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][startWin%RGSCH_NUM_SUB_FRAMES];
19786       /* Find the next DL subframe starting from Subframe 0 */
19787       if((startSubfrmIdx % RGSCH_NUM_SUB_FRAMES) == 0)
19788       {
19789          startWin = RGSCH_CEIL(startWin, RGSCH_NUM_SUB_FRAMES);
19790          startWin = startWin * RGSCH_NUM_SUB_FRAMES;
19791       }
19792
19793       endSubfrmIdx =
19794          rgSchTddLowDlSubfrmIdxTbl[ulDlCfgIdx][endWin%RGSCH_NUM_SUB_FRAMES];
19795       endWin = (endWin/RGSCH_NUM_SUB_FRAMES) * RGSCH_NUM_SUB_FRAMES \
19796                + endSubfrmIdx;
19797       if(startWin > endWin)
19798       {
19799          continue;
19800       }
19801       /* Find all the possible RACH Response transmission
19802        * time within the RA window size */
19803       startSubfrmIdx = startWin%RGSCH_NUM_SUB_FRAMES;
19804       for(sfnIdx = startWin/RGSCH_NUM_SUB_FRAMES;
19805             sfnIdx <= endWin/RGSCH_NUM_SUB_FRAMES; sfnIdx++)
19806       {
19807          if(sfnIdx == endWin/RGSCH_NUM_SUB_FRAMES)
19808          {
19809             endSubfrmIdx = endWin%RGSCH_NUM_SUB_FRAMES;
19810          }
19811          else
19812          {
19813             endSubfrmIdx = RGSCH_NUM_SUB_FRAMES-1;
19814          }
19815
19816          /* Find all the possible RACH Response transmission
19817           * time within radio frame */
19818          for(subfrmIdx = startSubfrmIdx;
19819                subfrmIdx <= endSubfrmIdx; subfrmIdx++)
19820          {
19821             if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][subfrmIdx] ==
19822                   RG_SCH_TDD_UL_SUBFRAME)
19823             {
19824                continue;
19825             }
19826             subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][subfrmIdx];
19827             /* Find the next DL subframe starting from Subframe 0 */
19828             if(subfrmIdx == RGSCH_NUM_SUB_FRAMES)
19829             {
19830                break;
19831             }
19832             RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rachRspLst[sfnIdx], subfrmIdx);
19833             numSubfrms =
19834                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
19835             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].sfnOffset = sfnIdx;
19836             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].subframe[numSubfrms]
19837                = sfNum;
19838             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms++;
19839          }
19840          startSubfrmIdx = RG_SCH_CMN_SUBFRM_0;
19841       }
19842       /* Update the subframes to be deleted at this subframe */
19843       /* Get the subframe after the end of RA window size */
19844       endWin++;
19845       endSubfrmIdx++;
19846       sfnOffset = endWin/RGSCH_NUM_SUB_FRAMES;
19847       if(sfnOffset < 0)
19848       {
19849          sfnOffset += raArrSz;
19850       }
19851       sfnIdx = (endWin/RGSCH_NUM_SUB_FRAMES) % raArrSz;
19852
19853       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx],endSubfrmIdx-1);
19854       if((endSubfrmIdx == RGSCH_NUM_SUB_FRAMES) ||
19855             (rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][endSubfrmIdx] ==
19856              RGSCH_NUM_SUB_FRAMES))
19857       {
19858          subfrmIdx =
19859             rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][RG_SCH_CMN_SUBFRM_0];
19860       }
19861       else
19862       {
19863          subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][endSubfrmIdx];
19864       }
19865
19866       delInfo = &rachRspLst[sfnIdx][subfrmIdx].delInfo;
19867       delInfo->sfnOffset = sfnOffset;
19868       delInfo->subframe[delInfo->numSubfrms] = sfNum;
19869       delInfo->numSubfrms++;
19870
19871       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19872    }
19873
19874    ret = rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz);
19875    if (ret != ROK)
19876    {
19877       RETVALUE(ret);
19878    }
19879
19880    RETVALUE(ROK);
19881 }
19882
19883 /**
19884  * @brief This function handles the initialization of PHICH information
19885  *        for each DL subframe based on PHICH table.
19886  *
19887  * @details
19888  *
19889  *     Function: rgSCHCmnDlPhichOffsetInit
19890  *     Purpose:  Each DL subf stores the sfn and subf information of UL subframe
19891  *               for which it trnsmts PHICH in this subframe. It generates the information
19892  *               based on PHICH table.
19893  *
19894  *     Invoked by: Scheduler
19895  *
19896  *  @param[in]  RgSchCellCb*     cell
19897  *  @return     S16
19898  *
19899  **/
19900 #ifdef ANSI
19901 PRIVATE S16 rgSCHCmnDlPhichOffsetInit
19902 (
19903 RgSchCellCb                *cell
19904 )
19905 #else
19906 PRIVATE S16 rgSCHCmnDlPhichOffsetInit(cell)
19907 RgSchCellCb                *cell;
19908 #endif
19909 {
19910    U8                   sfCount;
19911    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19912    U8                   maxDlSubfrms = cell->numDlSubfrms;
19913    U8                   sfNum;
19914    U8                   dlIdx;
19915    U8                   dlPres = 0;
19916    U8                   calcSfnOffset;
19917    U8                   calcSfNum;
19918    U8                   ulSfCnt =0;
19919    RgSchTddSubfrmInfo   ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19920    U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19921                                        [RGSCH_NUM_SUB_FRAMES-1];
19922
19923    TRC2(rgSCHCmnDlPhichOffsetInit);
19924
19925    /* Generate PHICH offset information for each DL subframe in a radio frame
19926     * Calculate this information based on K in PHICH table */
19927    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19928    {
19929       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19930             RG_SCH_TDD_UL_SUBFRAME)
19931       {
19932          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19933       }
19934       ulSfCnt++;
19935
19936       calcSfNum = (rgSchTddKPhichTbl[ulDlCfgIdx][sfNum] + sfNum) % \
19937                   RGSCH_NUM_SUB_FRAMES;
19938       calcSfnOffset = (rgSchTddKPhichTbl[ulDlCfgIdx][sfNum] + sfNum) / \
19939                       RGSCH_NUM_SUB_FRAMES;
19940
19941       if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19942       {
19943          dlIdx = calcSfNum;
19944       }
19945       else if((ulSubfrmInfo.switchPoints == 2) &&
19946             (calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_6))
19947       {
19948          dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19949       }
19950       else
19951       {
19952          dlIdx = calcSfNum - maxUlSubfrms;
19953       }
19954
19955       cell->subFrms[dlIdx]->phichOffInfo.subframe = sfNum;
19956       cell->subFrms[dlIdx]->phichOffInfo.numSubfrms = 1;
19957
19958       cell->subFrms[dlIdx]->phichOffInfo.sfnOffset = calcSfnOffset;
19959
19960       /* set dlIdx for which phich offset is updated */
19961       dlPres = dlPres | (1 << dlIdx);
19962       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19963    }
19964
19965    /* Set Invalid information for which phich offset is not present */
19966    for (sfCount = 0;
19967          sfCount < rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19968          sfCount++)
19969    {
19970       /* If dlPres is 0, phich offset is not present in that DL index */
19971       if(! ((dlPres >> sfCount)&0x01))
19972       {
19973          cell->subFrms[sfCount]->phichOffInfo.sfnOffset =
19974             RGSCH_INVALID_INFO;
19975          cell->subFrms[sfCount]->phichOffInfo.subframe =
19976             RGSCH_INVALID_INFO;
19977          cell->subFrms[sfCount]->phichOffInfo.numSubfrms = 0;
19978       }
19979    }
19980
19981    /* DL subframes in the subsequent radio frames are
19982     * initialized with the previous radio frames  */
19983    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms;
19984          dlIdx < maxDlSubfrms; dlIdx++)
19985    {
19986       sfNum = dlIdx - \
19987               rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19988
19989       cell->subFrms[dlIdx]->phichOffInfo.subframe =
19990          cell->subFrms[sfNum]->phichOffInfo.subframe;
19991
19992       cell->subFrms[dlIdx]->phichOffInfo.sfnOffset =
19993          cell->subFrms[sfNum]->phichOffInfo.sfnOffset;
19994    }
19995    RETVALUE(ROK);
19996 }
19997
19998
19999 /**
20000  * @brief Updation of Sch vars per TTI.
20001  *
20002  * @details
20003  *
20004  *     Function: rgSCHCmnUpdVars
20005  *     Purpose:  Updation of Sch vars per TTI.
20006  *
20007  *  @param[in]  RgSchCellCb *cell
20008  *  @return  Void
20009  *
20010  **/
20011 #ifdef ANSI
20012 PUBLIC Void rgSCHCmnUpdVars
20013 (
20014 RgSchCellCb *cell
20015 )
20016 #else
20017 PUBLIC Void rgSCHCmnUpdVars(cell)
20018 RgSchCellCb *cell;
20019 #endif
20020 {
20021    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
20022    CmLteTimingInfo   timeInfo;
20023    U8                idx;
20024    U8                ulSubframe;
20025    U8                ulDlCfgIdx = cell->ulDlCfgIdx;
20026    U8                msg3Subfrm;
20027    U8                Mval;
20028    TRC2(rgSCHCmnUpdVars);
20029  
20030    /* ccpu00132654-ADD- Initializing all the indices in every subframe*/ 
20031    rgSCHCmnInitVars(cell);
20032
20033    idx = (cell->crntTime.slot + TFU_ULCNTRL_DLDELTA) % RGSCH_NUM_SUB_FRAMES;
20034    /* Calculate the UL scheduling subframe idx based on the 
20035       Pusch k table */
20036    if(rgSchTddPuschTxKTbl[ulDlCfgIdx][idx] != 0)
20037    {
20038       /* PUSCH transmission is based on offset from DL
20039        * PDCCH scheduling */
20040       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo, TFU_ULCNTRL_DLDELTA); 
20041       ulSubframe = rgSchTddPuschTxKTbl[ulDlCfgIdx][timeInfo.subframe];
20042       /* Add the DCI-0 to PUSCH time to get the time of UL subframe */
20043       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, ulSubframe);
20044 #ifdef LTEMAC_SPS
20045       cellUl->schdTti = timeInfo.sfn * 10 + timeInfo.subframe;
20046 #endif
20047       /* Fetch the corresponding  UL subframe Idx in UL sf array */ 
20048       cellUl->schdIdx = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20049       /* Fetch the corresponding  UL Harq Proc ID */ 
20050       cellUl->schdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
20051       cellUl->schdTime = timeInfo;
20052    }
20053    Mval = rgSchTddPhichMValTbl[ulDlCfgIdx][idx]; 
20054    if(Mval)
20055    {
20056       /* Fetch the tx time for DL HIDCI-0 */
20057       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo, TFU_ULCNTRL_DLDELTA);
20058       /* Fetch the corresponding n-k tx time of PUSCH */
20059       cellUl->hqFdbkIdx[0] = rgSCHCmnGetPhichUlSfIdx(&timeInfo, cell);
20060       /* Retx will happen according to the Pusch k table */
20061       cellUl->reTxIdx[0] = cellUl->schdIdx;
20062       
20063       if(ulDlCfgIdx == 0) 
20064       {
20065          /* Calculate the ReTxIdx corresponding to hqFdbkIdx[0] */
20066          cellUl->reTxIdx[0] = rgSchUtlCfg0ReTxIdx(cell,timeInfo,
20067                                                 cellUl->hqFdbkIdx[0]);
20068          if(Mval == 2)
20069          {
20070             /* At Idx 1 store the UL SF adjacent(left) to the UL SF
20071                given at idx 0 */  
20072             cellUl->hqFdbkIdx[1] = (cellUl->hqFdbkIdx[0]-1 + 
20073                                    cellUl->numUlSubfrms) % cellUl->numUlSubfrms;
20074             /* Calculate the ReTxIdx corresponding to hqFdbkIdx[1] */
20075             cellUl->reTxIdx[1] = rgSchUtlCfg0ReTxIdx(cell,timeInfo,
20076                                                 cellUl->hqFdbkIdx[1]);
20077          }                               
20078       }
20079    }
20080
20081    idx = (cell->crntTime.slot + TFU_RECPREQ_DLDELTA) % RGSCH_NUM_SUB_FRAMES;
20082    if (rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][idx] == RG_SCH_TDD_UL_SUBFRAME)
20083    {
20084       RGSCHCMNADDTOCRNTTIME(cell->crntTime, timeInfo, TFU_RECPREQ_DLDELTA)
20085       cellUl->rcpReqIdx   = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20086    }
20087    idx = (cell->crntTime.slot+RG_SCH_CMN_DL_DELTA) % RGSCH_NUM_SUB_FRAMES;
20088    
20089    /*[ccpu00134666]-MOD-Modify the check to schedule the RAR in
20090      special subframe */                       
20091    if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][idx] != RG_SCH_TDD_UL_SUBFRAME)
20092    {
20093       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
20094       msg3Subfrm = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
20095       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, msg3Subfrm);
20096       cellUl->msg3SchdIdx     = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20097       cellUl->msg3SchdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
20098    }
20099 #ifdef LTEMAC_SPS
20100    if(!rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][idx])
20101    {
20102       cellUl->spsUlRsrvIdx = RGSCH_INVALID_INFO;
20103    }
20104    else
20105    {
20106       /* introduce some reuse with above code? */
20107       U8    offst;
20108       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
20109       //offst = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
20110       offst = rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][timeInfo.subframe];
20111       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, offst);
20112       cellUl->spsUlRsrvIdx     = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20113       /* The harq proc continues to be accessed and used the same delta before
20114        * actual data occurance, and hence use the same idx */
20115       cellUl->spsUlRsrvHqProcIdx = cellUl->schdHqProcIdx;
20116    }
20117 #endif
20118
20119    /* RACHO: update cmn sched specific RACH variables,
20120     * mainly the prachMaskIndex */
20121    rgSCHCmnUpdRachParam(cell);
20122
20123    RETVOID;
20124 }
20125
20126 /**
20127  * @brief To get 'p' value from nCCE.
20128  *
20129  * @details
20130  *
20131  *     Function: rgSCHCmnGetPValFrmCCE
20132  *     Purpose:  Gets 'p' value for HARQ ACK/NACK reception from CCE.
20133  *
20134  *  @param[in]  RgSchCellCb   *cell
20135  *  @param[in]  U8            cce
20136  *  @return U8
20137  *
20138  **/
20139 #ifdef ANSI
20140 PUBLIC U8  rgSCHCmnGetPValFrmCCE
20141 (
20142 RgSchCellCb *cell,
20143 U8          cce
20144 )
20145 #else
20146 PUBLIC U8  rgSCHCmnGetPValFrmCCE(cell, cce)
20147 RgSchCellCb *cell;
20148 U8          cce;
20149 #endif
20150 {
20151    U8 i;
20152    TRC2(rgSCHCmnGetPValFrmCCE);
20153
20154    for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
20155    {
20156       if(cce < cell->rgSchTddNpValTbl[i])
20157       {
20158          RETVALUE(i-1);
20159       }
20160    }
20161    RETVALUE(0);
20162 }
20163 #endif
20164
20165 /***********************************************************
20166  *
20167  *     Func : rgSCHCmnUlAdapRetx
20168  *
20169  *     Desc : Adaptive retransmission for an allocation.
20170  *
20171  *     Ret  :
20172  *
20173  *     Notes:
20174  *
20175  *     File :
20176  *
20177  **********************************************************/
20178 #ifdef ANSI
20179 PRIVATE Void rgSCHCmnUlAdapRetx
20180 (
20181 RgSchUlAlloc    *alloc,
20182 RgSchUlHqProcCb *proc
20183 )
20184 #else
20185 PRIVATE Void rgSCHCmnUlAdapRetx(alloc, proc)
20186 RgSchUlAlloc    *alloc;
20187 RgSchUlHqProcCb *proc;
20188 #endif
20189 {
20190    TRC2(rgSCHCmnUlAdapRetx);
20191
20192    rgSCHUhmRetx(proc, alloc);
20193 #ifndef RG_5GTF
20194    if (proc->rvIdx != 0)
20195    {
20196       alloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl[proc->rvIdx];
20197    }
20198    else
20199 #endif
20200    {
20201       alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
20202    }
20203    RETVOID;
20204 }
20205
20206 /**
20207  * @brief Scheduler invocation per TTI.
20208  *
20209  * @details
20210  *
20211  *     Function: rgSCHCmnHdlUlInactUes
20212  *     Purpose:
20213  *
20214  *     Invoked by: Common Scheduler
20215  *
20216  *  @param[in]  RgSchCellCb *cell
20217  *  @return  Void
20218  **/
20219 #ifdef ANSI
20220 PRIVATE Void rgSCHCmnHdlUlInactUes
20221 (
20222 RgSchCellCb  *cell
20223 )
20224 #else
20225 PRIVATE Void rgSCHCmnHdlUlInactUes(cell)
20226 RgSchCellCb  *cell;
20227 #endif
20228 {
20229    RgSchCmnCell  *cellSch  = RG_SCH_CMN_GET_CELL(cell);
20230    CmLListCp     ulInactvLst;
20231    TRC2(rgSCHCmnHdlUlInactUes);
20232    /* Get a List of Inactv UEs for UL*/
20233    cmLListInit(&ulInactvLst);
20234
20235    /* Trigger Spfc Schedulers with Inactive UEs */
20236    rgSCHMeasGapANRepGetUlInactvUe (cell, &ulInactvLst);
20237    /* take care of this in UL retransmission */
20238    cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
20239
20240    RETVOID;
20241 }
20242
20243 /**
20244  * @brief Scheduler invocation per TTI.
20245  *
20246  * @details
20247  *
20248  *     Function: rgSCHCmnHdlDlInactUes
20249  *     Purpose:
20250  *
20251  *     Invoked by: Common Scheduler
20252  *
20253  *  @param[in]  RgSchCellCb *cell
20254  *  @return  Void
20255  **/
20256 #ifdef ANSI
20257 PRIVATE Void rgSCHCmnHdlDlInactUes
20258 (
20259 RgSchCellCb  *cell
20260 )
20261 #else
20262 PRIVATE Void rgSCHCmnHdlDlInactUes(cell)
20263 RgSchCellCb  *cell;
20264 #endif
20265 {
20266    RgSchCmnCell *cellSch  = RG_SCH_CMN_GET_CELL(cell);
20267    CmLListCp    dlInactvLst;
20268    TRC2(rgSCHCmnHdlDlInactUes);
20269    /* Get a List of Inactv UEs for DL */
20270    cmLListInit(&dlInactvLst);
20271
20272    /* Trigger Spfc Schedulers with Inactive UEs */
20273    rgSCHMeasGapANRepGetDlInactvUe (cell, &dlInactvLst);
20274
20275    cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
20276    RETVOID;
20277 }
20278
20279 /* RACHO: Rach handover functions start here */
20280 /***********************************************************
20281  *
20282  *     Func : rgSCHCmnUeIdleExdThrsld
20283  *
20284  *     Desc : RETURN ROK if UE has been idle more
20285  *            than threshold.
20286  *
20287  *     Ret  :
20288  *
20289  *     Notes:
20290  *
20291  *     File :
20292  *
20293  **********************************************************/
20294 #ifdef ANSI
20295 PRIVATE S16 rgSCHCmnUeIdleExdThrsld
20296 (
20297 RgSchCellCb     *cell,
20298 RgSchUeCb       *ue
20299 )
20300 #else
20301 PRIVATE S16 rgSCHCmnUeIdleExdThrsld(cell, ue)
20302 RgSchCellCb     *cell;
20303 RgSchUeCb       *ue;
20304 #endif
20305 {
20306    /* Time difference in subframes */
20307    U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
20308
20309    TRC2(rgSCHCmnUeIdleExdThrsld);
20310
20311    if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
20312    {
20313       RETVALUE(ROK);
20314    }
20315    else
20316    {
20317       RETVALUE(RFAILED);
20318    }
20319 }
20320
20321 \f
20322 /**
20323  * @brief Scheduler processing for Ded Preambles on cell configuration.
20324  *
20325  * @details
20326  *
20327  *     Function : rgSCHCmnCfgRachDedPrm
20328  *
20329  *     This function does requisite initialisation
20330  *     for RACH Ded Preambles.
20331  *
20332  *
20333  *  @param[in]  RgSchCellCb   *cell
20334  *  @return  Void
20335  **/
20336 #ifdef ANSI
20337 PRIVATE Void rgSCHCmnCfgRachDedPrm
20338 (
20339 RgSchCellCb   *cell
20340 )
20341 #else
20342 PRIVATE Void rgSCHCmnCfgRachDedPrm(cell)
20343 RgSchCellCb   *cell;
20344 #endif
20345 {
20346    RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20347    U32          gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
20348    U32          sfDiff;
20349    U8           cnt;
20350    TRC2(rgSCHCmnCfgRachDedPrm);
20351
20352    if (cell->macPreambleSet.pres == NOTPRSNT)
20353    {
20354       RETVOID;
20355    }
20356    cellSch->rachCfg.numDedPrm = cell->macPreambleSet.size;
20357    cellSch->rachCfg.dedPrmStart = cell->macPreambleSet.start;
20358    /* Initialize handover List */
20359    cmLListInit(&cellSch->rachCfg.hoUeLst);
20360    /* Initialize pdcch Order List */
20361    cmLListInit(&cellSch->rachCfg.pdcchOdrLst);
20362
20363    /* Intialize the rapId to UE mapping structure */
20364    for (cnt = 0; cnt<cellSch->rachCfg.numDedPrm; cnt++)
20365    {
20366       cellSch->rachCfg.rapIdMap[cnt].rapId = cellSch->rachCfg.dedPrmStart + \
20367                                              cnt;
20368       cmLListInit(&cellSch->rachCfg.rapIdMap[cnt].assgndUes);
20369    }
20370    /* Perform Prach Mask Idx, remDedPrm, applFrm initializations */
20371    /* Set remDedPrm as numDedPrm */
20372    cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
20373    /* Initialize applFrm */
20374    cellSch->rachCfg.prachMskIndx = 0;
20375    if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_EVEN)
20376    {
20377       cellSch->rachCfg.applFrm.sfn = (cell->crntTime.sfn + \
20378             (cell->crntTime.sfn % 2)) % RGSCH_MAX_SFN;
20379    }
20380 #ifdef LTE_TDD
20381    else if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ODD)
20382    {
20383       if((cell->crntTime.sfn%2) == 0)
20384       {
20385          cellSch->rachCfg.applFrm.sfn = (cell->crntTime.sfn + 1)\
20386                                         % RGSCH_MAX_SFN;
20387       }
20388    }
20389 #endif
20390    else /* ANY sfn */
20391    {
20392       cellSch->rachCfg.applFrm.sfn = cell->crntTime.sfn;
20393    }
20394    /* Initialize cellSch->rachCfg.applFrm as >= crntTime.
20395     * This is because of RGSCH_CALC_SF_DIFF logic */
20396    if (cellSch->rachCfg.applFrm.sfn == cell->crntTime.sfn)
20397    {
20398       while (cellSch->rachCfg.prachMskIndx < cell->rachCfg.raOccasion.size)
20399       {
20400          if (cell->crntTime.slot <\
20401                cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx])
20402          {
20403             break;
20404          }
20405          cellSch->rachCfg.prachMskIndx++;
20406       }
20407       if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size)
20408       {
20409          if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ANY)
20410          {
20411             cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+1) %\
20412                                            RGSCH_MAX_SFN;
20413          }
20414          else
20415          {
20416             cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+2) %\
20417                                            RGSCH_MAX_SFN;
20418          }
20419          cellSch->rachCfg.prachMskIndx = 0;
20420       }
20421       cellSch->rachCfg.applFrm.slot = \
20422                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20423    }
20424    else
20425    {
20426       cellSch->rachCfg.applFrm.slot = \
20427                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20428    }
20429
20430    /* Note first param to this macro should always be the latest in time */
20431    sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
20432    while (sfDiff <= gap)
20433    {
20434       rgSCHCmnUpdNxtPrchMskIdx(cell);
20435       sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
20436    }
20437
20438    RETVOID;
20439 }
20440
20441 /**
20442  * @brief Updates the PRACH MASK INDEX.
20443  *
20444  * @details
20445  *
20446  *     Function: rgSCHCmnUpdNxtPrchMskIdx
20447  *     Purpose:  Ensures the "applFrm" field of Cmn Sched RACH
20448  *     CFG is always >= "n"+"DELTA", where "n" is the crntTime
20449  *     of the cell. If not, applFrm is updated to the next avl
20450  *     PRACH oppurtunity as per the PRACH Cfg Index configuration.
20451  *
20452  *
20453  *     Invoked by: Common Scheduler
20454  *
20455  *  @param[in]  RgSchCellCb *cell
20456  *  @return  Void
20457  **/
20458 #ifdef ANSI
20459 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx
20460 (
20461 RgSchCellCb  *cell
20462 )
20463 #else
20464 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx(cell)
20465 RgSchCellCb  *cell;
20466 #endif
20467 {
20468    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20469    TRC2(rgSCHCmnUpdNxtPrchMskIdx);
20470
20471    /* Determine the next prach mask Index */
20472    if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
20473    {
20474       /* PRACH within applFrm.sfn are done, go to next AVL sfn */
20475       cellSch->rachCfg.prachMskIndx = 0;
20476       if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ANY)
20477       {
20478          cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+1) % \
20479                                         RGSCH_MAX_SFN;
20480       }
20481       else/* RGR_SFN_EVEN or RGR_SFN_ODD */
20482       {
20483          cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+2) % \
20484                                         RGSCH_MAX_SFN;
20485       }
20486       cellSch->rachCfg.applFrm.slot = cell->rachCfg.raOccasion.\
20487                                           subFrameNum[0];
20488    }
20489    else /* applFrm.sfn is still valid */
20490    {
20491       cellSch->rachCfg.prachMskIndx += 1;
20492       if ( cellSch->rachCfg.prachMskIndx < RGR_MAX_SUBFRAME_NUM )
20493       {
20494          cellSch->rachCfg.applFrm.slot = \
20495                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20496       }
20497    }
20498    RETVOID;
20499 }
20500
20501 /**
20502  * @brief Updates the Ded preamble RACH parameters
20503  *        every TTI.
20504  *
20505  * @details
20506  *
20507  *     Function: rgSCHCmnUpdRachParam
20508  *     Purpose:  Ensures the "applFrm" field of Cmn Sched RACH
20509  *     CFG is always >= "n"+"6"+"DELTA", where "n" is the crntTime
20510  *     of the cell. If not, applFrm is updated to the next avl
20511  *     PRACH oppurtunity as per the PRACH Cfg Index configuration,
20512  *     accordingly the "remDedPrm" is reset to "numDedPrm" and
20513  *     "prachMskIdx" field is updated as per "applFrm".
20514  *
20515  *
20516  *     Invoked by: Common Scheduler
20517  *
20518  *  @param[in]  RgSchCellCb *cell
20519  *  @return  Void
20520  **/
20521 #ifdef ANSI
20522 PRIVATE Void rgSCHCmnUpdRachParam
20523 (
20524 RgSchCellCb  *cell
20525 )
20526 #else
20527 PRIVATE Void rgSCHCmnUpdRachParam(cell)
20528 RgSchCellCb  *cell;
20529 #endif
20530 {
20531
20532    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20533    U32             gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
20534    U32             sfDiff;
20535    TRC2(rgSCHCmnUpdRachParam);
20536
20537    if (cell->macPreambleSet.pres == NOTPRSNT)
20538    {
20539       RETVOID;
20540    }
20541    sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, \
20542          cell->crntTime);
20543    if (sfDiff > gap)
20544    {
20545       /* applFrm is still a valid next Prach Oppurtunity */
20546       RETVOID;
20547    }
20548    rgSCHCmnUpdNxtPrchMskIdx(cell);
20549    /* Reset remDedPrm as numDedPrm */
20550    cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
20551
20552    RETVOID;
20553 }
20554
20555 /**
20556  * @brief Dedicated Preamble allocation function.
20557  *
20558  * @details
20559  *
20560  *     Function: rgSCHCmnAllocPOParam
20561  *     Purpose:  Allocate pdcch, rapId and PrachMskIdx.
20562  *     Set mapping of UE with the allocated rapId.
20563  *
20564  *     Invoked by: Common Scheduler
20565  *
20566  *  @param[in]   RgSchCellCb *cell
20567  *  @param[in]   RgSchDlSf   *dlSf
20568  *  @param[in]   RgSchUeCb   *ue
20569  *  @param[out]  RgSchPdcch  **pdcch
20570  *  @param[out]  U8          *rapId
20571  *  @param[out]  U8          *prachMskIdx
20572  *  @return  Void
20573  **/
20574 #ifdef ANSI
20575 PRIVATE S16 rgSCHCmnAllocPOParam
20576 (
20577 RgSchCellCb  *cell,
20578 RgSchDlSf    *dlSf,
20579 RgSchUeCb    *ue,
20580 RgSchPdcch   **pdcch,
20581 U8           *rapId,
20582 U8           *prachMskIdx
20583 )
20584 #else
20585 PRIVATE S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
20586 RgSchCellCb  *cell;
20587 RgSchDlSf    *dlSf;
20588 RgSchUeCb    *ue;
20589 RgSchPdcch   **pdcch;
20590 U8           *rapId;
20591 U8           *prachMskIdx;
20592 #endif
20593 {
20594
20595    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20596    RgSchCmnDlUe    *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20597
20598    TRC2(rgSCHCmnAllocPOParam);
20599
20600    if (cell->macPreambleSet.pres == PRSNT_NODEF)
20601    {
20602       if (cellSch->rachCfg.remDedPrm == 0)
20603       {
20604          RETVALUE(RFAILED);
20605       }
20606       /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
20607       if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
20608       {
20609          RETVALUE(RFAILED);
20610       }
20611       /* The stored prachMskIdx is the index of PRACH Oppurtunities in
20612        * raOccasions.subframes[].
20613        * Converting the same to the actual PRACHMskIdx to be transmitted. */
20614       *prachMskIdx = cellSch->rachCfg.prachMskIndx + 1;
20615       /* Distribution starts from dedPrmStart till dedPrmStart + numDedPrm */
20616       *rapId =  cellSch->rachCfg.dedPrmStart +
20617          cellSch->rachCfg.numDedPrm - cellSch->rachCfg.remDedPrm;
20618       cellSch->rachCfg.remDedPrm--;
20619       /* Map UE with the allocated RapId */
20620       ueDl->rachInfo.asgnOppr = cellSch->rachCfg.applFrm;
20621       RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, cellSch->rachCfg.rapIdMap, (*rapId - cellSch->rachCfg.dedPrmStart));
20622       cmLListAdd2Tail(&cellSch->rachCfg.rapIdMap[*rapId - cellSch->rachCfg.dedPrmStart].assgndUes, 
20623              &ueDl->rachInfo.rapIdLnk);
20624       ueDl->rachInfo.rapIdLnk.node = (PTR)ue;
20625       ueDl->rachInfo.poRapId = *rapId;
20626    }
20627    else /* if dedicated preambles not configured */
20628    {
20629       /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
20630       if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
20631       {
20632          RETVALUE(RFAILED);
20633       }
20634       *prachMskIdx = 0;
20635       *rapId       = 0;
20636    }
20637
20638    RETVALUE(ROK);
20639 }
20640
20641 /**
20642  * @brief Dowlink Scheduling Handler.
20643  *
20644  * @details
20645  *
20646  *     Function: rgSCHCmnGenPdcchOrder
20647  *     Purpose:  For each UE in PO Q, grab a PDCCH,
20648  *     get an available ded RapId and fill PDCCH
20649  *     with PO information.
20650  *
20651  *     Invoked by: Common Scheduler
20652  *
20653  *  @param[in]  RgSchCellCb *cell
20654  *  @param[in]  RgSchDlSf   *dlSf
20655  *  @return  Void
20656  **/
20657 #ifdef ANSI
20658 PRIVATE Void rgSCHCmnGenPdcchOrder
20659 (
20660 RgSchCellCb  *cell,
20661 RgSchDlSf    *dlSf
20662 )
20663 #else
20664 PRIVATE Void rgSCHCmnGenPdcchOrder(cell, dlSf)
20665 RgSchCellCb  *cell;
20666 RgSchDlSf    *dlSf;
20667 #endif
20668 {
20669    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
20670    CmLList           *node = cellSch->rachCfg.pdcchOdrLst.first;
20671    RgSchUeCb         *ue;
20672    U8                rapId;
20673    U8                prachMskIdx;
20674    RgSchPdcch        *pdcch = NULLP;
20675
20676    TRC2(rgSCHCmnGenPdcchOrder);
20677
20678    while (node)
20679    {
20680       ue = (RgSchUeCb *)node->node;
20681       node = node->next;
20682       /* Skip sending for this subframe is Measuring or inActive in UL due
20683        * to MeasGap or inactie due to DRX
20684        */
20685       if  ((ue->measGapCb.isMeasuring == TRUE) ||
20686            (ue->ul.ulInactvMask & RG_MEASGAP_INACTIVE) ||
20687            (ue->isDrxEnabled &&
20688              ue->dl.dlInactvMask & RG_DRX_INACTIVE)
20689            )
20690       {
20691          continue;
20692       }
20693       if (rgSCHCmnAllocPOParam(cell, dlSf, ue, &pdcch, &rapId,\
20694                &prachMskIdx) != ROK)
20695       {
20696          /* No More rapIds left for the valid next avl Oppurtunity.
20697           * Unsatisfied UEs here would be given a chance, when the
20698           * prach Mask Index changes as per rachUpd every TTI */
20699
20700          /* PDDCH can also be ordered with rapId=0, prachMskIdx=0
20701           * so that UE triggers a RACH procedure with non-dedicated preamble.
20702           * But the implementation here does not do this. Instead, the "break"
20703           * here implies, that PDCCH Odr always given with valid rapId!=0,
20704           * prachMskIdx!=0 if dedicated preambles are configured.
20705           * If not configured, then trigger a PO with rapId=0,prchMskIdx=0*/
20706          break;
20707       }
20708       /* Fill pdcch with pdcch odr information */
20709       rgSCHCmnFillPdcchOdr2Sf(cell, ue, pdcch, rapId, prachMskIdx);
20710       /* Remove this UE from the PDCCH ORDER QUEUE */
20711       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
20712       /* Reset UE's power state */
20713       rgSCHPwrUeReset(cell, ue);
20714    }
20715    RETVOID;
20716 }
20717
20718 \f
20719 /**
20720  * @brief This function add UE to PdcchOdr Q if not already present.
20721  *
20722  * @details
20723  *
20724  *     Function: rgSCHCmnDlAdd2PdcchOdrQ
20725  *     Purpose:
20726  *
20727  *     Invoked by: CMN Scheduler
20728  *
20729  *  @param[in]  RgSchCellCb*  cell
20730  *  @param[in]  RgSchUeCb*    ue
20731  *  @return  Void
20732  *
20733  **/
20734 #ifdef ANSI
20735 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ
20736 (
20737 RgSchCellCb                *cell,
20738 RgSchUeCb                  *ue
20739 )
20740 #else
20741 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ(cell, ue)
20742 RgSchCellCb                *cell;
20743 RgSchUeCb                  *ue;
20744 #endif
20745 {
20746    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20747    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20748
20749    TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
20750
20751    if (ueDl->rachInfo.poLnk.node == NULLP)
20752    {
20753       cmLListAdd2Tail(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
20754       ueDl->rachInfo.poLnk.node = (PTR)ue;
20755    }
20756    RETVOID;
20757 }
20758
20759 \f
20760 /**
20761  * @brief This function rmvs UE to PdcchOdr Q if not already present.
20762  *
20763  * @details
20764  *
20765  *     Function: rgSCHCmnDlRmvFrmPdcchOdrQ
20766  *     Purpose:
20767  *
20768  *     Invoked by: CMN Scheduler
20769  *
20770  *  @param[in]  RgSchCellCb*  cell
20771  *  @param[in]  RgSchUeCb*    ue
20772  *  @return  Void
20773  *
20774  **/
20775 #ifdef ANSI
20776 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ
20777 (
20778 RgSchCellCb                *cell,
20779 RgSchUeCb                  *ue
20780 )
20781 #else
20782 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue)
20783 RgSchCellCb                *cell;
20784 RgSchUeCb                  *ue;
20785 #endif
20786 {
20787    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20788    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20789
20790    TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
20791
20792    cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
20793    ueDl->rachInfo.poLnk.node = NULLP;
20794    RETVOID;
20795 }
20796
20797 /**
20798  * @brief Fill pdcch with PDCCH order information.
20799  *
20800  * @details
20801  *
20802  *     Function: rgSCHCmnFillPdcchOdr2Sf
20803  *     Purpose:  Fill PDCCH with PDCCH order information,
20804  *
20805  *     Invoked by: Common Scheduler
20806  *
20807  *  @param[in]  RgSchUeCb   *ue
20808  *  @param[in]  RgSchPdcch  *pdcch
20809  *  @param[in]  U8          rapId
20810  *  @param[in]  U8          prachMskIdx
20811  *  @return  Void
20812  **/
20813 #ifdef ANSI
20814 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf
20815 (
20816 RgSchCellCb *cell,
20817 RgSchUeCb   *ue,
20818 RgSchPdcch  *pdcch,
20819 U8          rapId,
20820 U8          prachMskIdx
20821 )
20822 #else
20823 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
20824 RgSchCellCb *cell;
20825 RgSchUeCb   *ue;
20826 RgSchPdcch  *pdcch;
20827 U8          rapId;
20828 U8          prachMskIdx;
20829 #endif
20830 {
20831    RgSchUeACqiCb  *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell); 
20832
20833    TRC2(rgSCHCmnFillPdcchOdr2Sf);
20834
20835    pdcch->rnti                                         = ue->ueId;
20836    pdcch->dci.dciFormat                                = TFU_DCI_FORMAT_1A;
20837    pdcch->dci.u.format1aInfo.isPdcchOrder = TRUE;
20838    pdcch->dci.u.format1aInfo.t.pdcchOrder.preambleIdx  = rapId;
20839    pdcch->dci.u.format1aInfo.t.pdcchOrder.prachMaskIdx = prachMskIdx;
20840
20841    /* Request for APer CQI immediately after PDCCH Order */
20842    /* CR ccpu00144525 */
20843 #ifdef TFU_UPGRADE
20844    if(ue->dl.ueDlCqiCfg.aprdCqiCfg.pres)
20845    {
20846       ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
20847       acqiCb->aCqiTrigWt = 0;
20848    }
20849 #endif   
20850
20851    RETVOID;
20852 }
20853
20854 \f
20855 /**
20856  * @brief UE deletion for scheduler.
20857  *
20858  * @details
20859  *
20860  *     Function : rgSCHCmnDelRachInfo
20861  *
20862  *     This functions deletes all scheduler information
20863  *     pertaining to an UE.
20864  *
20865  *  @param[in]  RgSchCellCb  *cell
20866  *  @param[in]  RgSchUeCb    *ue
20867  *  @return  Void
20868  **/
20869 #ifdef ANSI
20870 PRIVATE Void rgSCHCmnDelRachInfo
20871 (
20872 RgSchCellCb  *cell,
20873 RgSchUeCb    *ue
20874 )
20875 #else
20876 PRIVATE Void rgSCHCmnDelRachInfo(cell, ue)
20877 RgSchCellCb  *cell;
20878 RgSchUeCb    *ue;
20879 #endif
20880 {
20881    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20882    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20883    U8            rapIdIdx;
20884
20885    TRC2(rgSCHCmnDelRachInfo);
20886
20887    if (ueDl->rachInfo.poLnk.node)
20888    {
20889       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
20890    }
20891    if (ueDl->rachInfo.hoLnk.node)
20892    {
20893       cmLListDelFrm(&cellSch->rachCfg.hoUeLst, &ueDl->rachInfo.hoLnk);
20894       ueDl->rachInfo.hoLnk.node = NULLP;
20895    }
20896    if (ueDl->rachInfo.rapIdLnk.node)
20897    {
20898       rapIdIdx = ueDl->rachInfo.poRapId - cellSch->rachCfg.dedPrmStart;
20899       cmLListDelFrm(&cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes, 
20900           &ueDl->rachInfo.rapIdLnk);
20901       ueDl->rachInfo.rapIdLnk.node = NULLP;
20902    }
20903    RETVOID;
20904 }
20905
20906 /**
20907  * @brief This function retrieves the ue which has sent this raReq
20908  * and it allocates grant for UEs undergoing (for which RAR
20909  * is being generated) HandOver/PdcchOrder.
20910  *
20911  *
20912  * @details
20913  *
20914  *     Function: rgSCHCmnHdlHoPo
20915  *     Purpose:  This function  retrieves the ue which has sent this raReq
20916  *               and it allocates grant for UEs undergoing (for which RAR
20917  *               is being generated) HandOver/PdcchOrder.
20918  *
20919  *     Invoked by: Common Scheduler
20920  *
20921  *  @param[in]  RgSchCellCb           *cell
20922  *  @param[out] CmLListCp             *raRspLst
20923  *  @param[in]  RgSchRaReqInfo        *raReq
20924  *  @return  Void
20925  *
20926  **/
20927 #ifdef ANSI
20928 PRIVATE Void rgSCHCmnHdlHoPo
20929 (
20930 RgSchCellCb           *cell,
20931 CmLListCp             *raRspLst,
20932 RgSchRaReqInfo        *raReq
20933 )
20934 #else
20935 PRIVATE Void rgSCHCmnHdlHoPo(cell, raRspLst, raReq)
20936 RgSchCellCb           *cell;
20937 CmLListCp             *raRspLst;
20938 RgSchRaReqInfo        *raReq;
20939 #endif
20940 {
20941    RgSchUeCb             *ue = raReq->ue;
20942    TRC2(rgSCHCmnHdlHoPo);
20943
20944    if ( ue->isDrxEnabled )
20945    {
20946       rgSCHDrxDedRa(cell,ue);
20947    }
20948    rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq);
20949    RETVOID;
20950 }
20951
20952 /**
20953  * @brief This function retrieves the UE which has sent this raReq
20954  * for handover case.
20955  *
20956  *
20957  * @details
20958  *
20959  *     Function: rgSCHCmnGetHoUe
20960  *     Purpose:  This function retrieves the UE which has sent this raReq
20961  *     for handover case.
20962  *
20963  *     Invoked by: Common Scheduler
20964  *
20965  *  @param[in]  RgSchCellCb           *cell
20966  *  @param[in]  RgSchRaReqInfo        *raReq
20967  *  @return  RgSchUeCb*
20968  *
20969  **/
20970 #ifdef ANSI
20971 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe
20972 (
20973 RgSchCellCb           *cell,
20974 U16                   rapId
20975 )
20976 #else
20977 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
20978 RgSchCellCb           *cell;
20979 U16                   rapId
20980 #endif
20981 {
20982    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20983    CmLList               *node;
20984    CmLListCp             *ueLst;
20985    RgSchUeCb             *ue;
20986    RgSchCmnDlUe          *ueDl;
20987    TRC2(rgSCHCmnGetHoUe);
20988
20989    ueLst = &cellSch->rachCfg.hoUeLst;
20990    node = ueLst->first;
20991    while (node)
20992    {
20993       ue = (RgSchUeCb *)node->node;
20994       node = node->next;
20995       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20996       if (ueDl->rachInfo.hoRapId == rapId)
20997       {
20998          RETVALUE(ue);
20999       }
21000    }
21001    RETVALUE(NULLP);
21002 }
21003
21004 #ifdef ANSI
21005 PRIVATE Void rgSCHCmnDelDedPreamble
21006 (
21007 RgSchCellCb           *cell,
21008 U8                    preambleId
21009 )
21010 #else
21011 PRIVATE rgSCHCmnDelDedPreamble(cell, preambleId)
21012 RgSchCellCb           *cell;
21013 U8                    preambleId;
21014 #endif
21015 {
21016    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
21017    CmLList               *node;
21018    CmLListCp             *ueLst;
21019    RgSchUeCb             *ue;
21020    RgSchCmnDlUe          *ueDl;
21021    TRC2(rgSCHCmnDelDedPreamble);
21022
21023    ueLst = &cellSch->rachCfg.hoUeLst;
21024    node = ueLst->first;
21025    while (node)
21026    {
21027       ue = (RgSchUeCb *)node->node;
21028       node = node->next;
21029       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
21030       if (ueDl->rachInfo.hoRapId == preambleId)
21031       {
21032          cmLListDelFrm(ueLst, &ueDl->rachInfo.hoLnk);
21033          ueDl->rachInfo.hoLnk.node = (PTR)NULLP;
21034       }
21035    }
21036 }
21037
21038 /**
21039  * @brief This function retrieves the UE which has sent this raReq
21040  * for PDCCh Order case.
21041  *
21042  *
21043  * @details
21044  *
21045  *     Function: rgSCHCmnGetPoUe
21046  *     Purpose:  This function retrieves the UE which has sent this raReq
21047  *     for PDCCH Order case.
21048  *
21049  *     Invoked by: Common Scheduler
21050  *
21051  *  @param[in]  RgSchCellCb           *cell
21052  *  @param[in]  RgSchRaReqInfo        *raReq
21053  *  @return  RgSchUeCb*
21054  *
21055  **/
21056 #ifdef ANSI
21057 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe
21058 (
21059 RgSchCellCb           *cell,
21060 U16                   rapId,
21061 CmLteTimingInfo       timingInfo
21062 )
21063 #else
21064 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
21065 RgSchCellCb           *cell;
21066 U16                   rapId;
21067 CmLteTimingInfo       timingInfo;
21068 #endif
21069 {
21070    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
21071    CmLList               *node;
21072    CmLListCp             *ueLst;
21073    RgSchUeCb             *ue;
21074    RgSchCmnDlUe          *ueDl;
21075    U8                    rapIdIdx;
21076    TRC2(rgSCHCmnGetPoUe);
21077
21078    rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
21079    ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
21080    node = ueLst->first;
21081    while (node)
21082    {
21083       ue = (RgSchUeCb *)node->node;
21084       node = node->next;
21085       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
21086       /* Remove UEs irrespective.
21087        * Old UE associations are removed.*/
21088       cmLListDelFrm(ueLst, &ueDl->rachInfo.rapIdLnk);
21089       ueDl->rachInfo.rapIdLnk.node = (PTR)NULLP;
21090       if (RGSCH_TIMEINFO_SAME(ueDl->rachInfo.asgnOppr, timingInfo))
21091       {
21092          RETVALUE(ue);
21093       }
21094    }
21095
21096    RETVALUE(NULLP);
21097 }
21098
21099
21100 /**
21101  * @brief This function returns the valid UL cqi for a given UE.
21102  *
21103  * @details
21104  *
21105  *     Function: rgSCHCmnUlGetCqi
21106  *     Purpose:  This function returns the "valid UL cqi" for a given UE
21107  *               based on UE category
21108  *
21109  *     Invoked by: Scheduler
21110  *     
21111  *  @param[in]  RgSchUeCb        *ue
21112  *  @param[in]  U8               ueCtgy
21113  *  @return     U8 
21114  **/
21115 #ifdef ANSI
21116 PUBLIC U8 rgSCHCmnUlGetCqi
21117 (
21118 RgSchCellCb      *cell,
21119 RgSchUeCb        *ue,
21120 CmLteUeCategory  ueCtgy
21121 )
21122 #else
21123 PUBLIC U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
21124 RgSchCellCb      *cell;
21125 RgSchUeCb        *ue;
21126 CmLteUeCategory  ueCtgy;
21127 #endif
21128 {
21129    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
21130    U8            cqi;
21131
21132    TRC2(rgSCHCmnUlGetCqi);
21133    
21134    cqi = ueUl->maxUlCqi;
21135 #ifdef TFU_UPGRADE
21136    if (!((ueCtgy != CM_LTE_UE_CAT_5) && 
21137         (ueUl->validUlCqi > ueUl->maxUlCqi)))
21138    {
21139       cqi = ueUl->validUlCqi;
21140    }
21141 #else   
21142    if (!((ueCtgy != CM_LTE_UE_CAT_5) && 
21143          (ueUl->crntUlCqi[0] > ueUl->maxUlCqi )))
21144    {
21145       cqi = ueUl->crntUlCqi[0];
21146    }
21147 #endif    
21148    RETVALUE(cqi);
21149 }/* End of rgSCHCmnUlGetCqi */
21150
21151 /***********************************************************
21152  *
21153  *     Func : rgSCHCmnUlRbAllocForPoHoUe
21154  *
21155  *     Desc : Do uplink RB allocation for a HO/PO UE.
21156  *
21157  *     Ret  :
21158  *
21159  *     Notes: Note that as of now, for retx, maxRb
21160  *            is not considered. Alternatives, such
21161  *            as dropping retx if it crosses maxRb
21162  *            could be considered.
21163  *
21164  *     File :
21165  *
21166  **********************************************************/
21167 #ifdef ANSI
21168 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe
21169 (
21170 RgSchCellCb           *cell,
21171 RgSchUlSf             *sf,
21172 RgSchUeCb             *ue,
21173 U8                    maxRb
21174 )
21175 #else
21176 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
21177 RgSchCellCb           *cell;
21178 RgSchUlSf             *sf;
21179 RgSchUeCb             *ue;
21180 U8                    maxRb;
21181 #endif
21182 {
21183    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21184    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
21185    U8           sbSize  = cellUl->sbSize;
21186    U32          maxBits = ue->ul.maxBytesPerUePerTti*8;
21187    U32          bits;
21188    RgSchUlAlloc *alloc;
21189    U32          nPrb;
21190    U8           iTbs;
21191    U32          eff;
21192    U32          numSb;
21193    U8           iMcs;
21194    U8           iMcsCrnt;
21195    U8           cqi;
21196    U8           modOdr;
21197    RgSchUlHole      *hole;
21198    RgSchUlHqProcCb  *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
21199    CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
21200
21201    TRC2(rgSCHCmnUlRbAllocForPoHoUe);
21202    if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
21203    {
21204       RETVALUE(RFAILED);
21205    }
21206    /*MS_WORKAROUND for HO ccpu00121116*/
21207    cqi   = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
21208    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend], cqi);
21209    iTbs  = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
21210    iMcs  = rgSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
21211    while(iMcs > RG_SCH_CMN_MAX_MSG3_IMCS)
21212    {
21213        cqi--;
21214        iTbs  = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
21215        iMcs  = rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg);
21216    }
21217    /* Filling the modorder in the grant structure*/
21218    RG_SCH_UL_MCS_TO_MODODR(iMcs,modOdr);
21219    if (!cell->isCpUlExtend)
21220    {
21221       eff   = rgSchCmnNorUlEff[0][iTbs];
21222    }
21223    else
21224    {
21225       eff   = rgSchCmnExtUlEff[0][iTbs];
21226    }
21227
21228    bits = ueUl->alloc.reqBytes * 8;
21229
21230 #if (ERRCLASS & ERRCLS_DEBUG)
21231    if (!bits)
21232    {
21233       RETVALUE(RFAILED);
21234    }
21235 #endif
21236
21237    if (bits < rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs))
21238    {
21239       numSb = 1;
21240       nPrb = numSb * sbSize;
21241    }
21242    else
21243    {
21244       if (bits > maxBits)
21245       {
21246          bits  = maxBits;
21247          nPrb  = bits * 1024 / eff / RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
21248          if (nPrb > maxRb)
21249          {
21250             nPrb = maxRb;
21251          }
21252          numSb = nPrb / sbSize;
21253       }
21254       else
21255       {
21256          /*ccpu00128775:MOD-Change to get upper threshold nPrb*/
21257          nPrb = RGSCH_CEIL((RGSCH_CEIL(bits * 1024, eff)),
21258                   RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl));
21259          if (nPrb > maxRb)
21260          {
21261             nPrb = maxRb;
21262          }
21263          numSb = RGSCH_DIV_ROUND(nPrb, sbSize);
21264       }
21265    }
21266    iMcsCrnt = iMcs;
21267
21268    alloc = rgSCHCmnUlSbAlloc(sf, (U8)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
21269                              hole);
21270    if (alloc == NULLP)
21271    {
21272       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
21273          "rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
21274       RETVALUE(RFAILED);
21275    }
21276    rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
21277    
21278    /* Filling the modorder in the grant structure start*/
21279    alloc->grnt.modOdr = (TfuModScheme) modOdr;
21280    alloc->grnt.iMcs = iMcs;
21281    alloc->grnt.iMcsCrnt = iMcsCrnt;
21282    alloc->grnt.hop = 0;
21283    /* Fix for ccpu00123915*/
21284    alloc->forMsg3 = TRUE;
21285    alloc->hqProc = proc;
21286    alloc->hqProc->ulSfIdx = cellUl->msg3SchdIdx;
21287    alloc->ue = ue;
21288    alloc->rnti = ue->ueId;
21289    /* updating initNumRbs in case of HO */
21290 #ifdef TFU_UPGRADE
21291    ue->initNumRbs = alloc->grnt.numRb;
21292 #endif
21293    ueUl->alloc.alloc = alloc;
21294    iTbs = rgSCHCmnUlGetITbsFrmIMcs(iMcs);
21295    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[0], iTbs);
21296    alloc->grnt.datSz    = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
21297    /* MS_WORKAROUND for HO ccpu00121124*/
21298    /*[Adi temp change] Need to fil modOdr */
21299    RG_SCH_UL_MCS_TO_MODODR(alloc->grnt.iMcsCrnt,alloc->grnt.modOdr);
21300    rgSCHUhmNewTx(proc, ueUl->hqEnt.maxHqRetx, alloc);
21301    /* No grant attr recorded now */
21302    RETVALUE(ROK);
21303 }
21304
21305 /**
21306  * @brief This function allocates grant for UEs undergoing (for which RAR
21307  * is being generated) HandOver/PdcchOrder.
21308  *
21309  *
21310  * @details
21311  *
21312  *     Function: rgSCHCmnAllocPoHoGrnt
21313  *     Purpose:  This function allocates grant for UEs undergoing (for which RAR
21314  *               is being generated) HandOver/PdcchOrder.
21315  *
21316  *     Invoked by: Common Scheduler
21317  *
21318  *  @param[in]  RgSchCellCb           *cell
21319  *  @param[out] CmLListCp             *raRspLst,
21320  *  @param[in]  RgSchUeCb             *ue
21321  *  @param[in]  RgSchRaReqInfo        *raReq
21322  *  @return  Void
21323  *
21324  **/
21325 #ifdef ANSI
21326 PRIVATE Void rgSCHCmnAllocPoHoGrnt
21327 (
21328 RgSchCellCb           *cell,
21329 CmLListCp             *raRspLst,
21330 RgSchUeCb             *ue,
21331 RgSchRaReqInfo        *raReq
21332 )
21333 #else
21334 PRIVATE Void rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq)
21335 RgSchCellCb           *cell;
21336 CmLListCp             *raRspLst;
21337 RgSchUeCb             *ue;
21338 RgSchRaReqInfo        *raReq;
21339 #endif
21340 {
21341    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21342    RgSchCmnUlUe    *ueUl   = RG_SCH_CMN_GET_UL_UE(ue,cell);
21343    RgSchUlGrnt     *grnt;
21344    RgSchUlSf       *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
21345
21346    TRC2(rgSCHCmnAllocPoHoGrnt);
21347
21348    /* Clearing previous allocs if any*/
21349    rgSCHCmnUlUeDelAllocs(cell, ue);
21350    /* Fix : syed allocs are limited */
21351    if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
21352    {
21353       RETVOID;
21354    }
21355    ueUl->alloc.reqBytes = RG_SCH_MIN_GRNT_HOPO;
21356    if (rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, RGSCH_MAX_UL_RB) != ROK)
21357    {
21358       RETVOID;
21359    }
21360
21361    /* Fill grant information */
21362    grnt = &ueUl->alloc.alloc->grnt;
21363
21364    /* KWork fix */
21365    if (grnt == NULLP)
21366    {
21367       RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx,  "Failed to get"
21368         "the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
21369       RETVOID;
21370    }
21371    ue->ul.rarGrnt.rapId = raReq->raReq.rapId;
21372    ue->ul.rarGrnt.hop = grnt->hop;
21373    ue->ul.rarGrnt.rbStart = grnt->rbStart;
21374    ue->ul.rarGrnt.numRb = grnt->numRb;
21375    ue->ul.rarGrnt.tpc = grnt->tpc;
21376    ue->ul.rarGrnt.iMcsCrnt = grnt->iMcsCrnt;
21377    ue->ul.rarGrnt.ta.pres = TRUE;
21378    ue->ul.rarGrnt.ta.val = raReq->raReq.ta;
21379    ue->ul.rarGrnt.datSz = grnt->datSz;
21380    if((sf->numACqiCount < RG_SCH_MAX_ACQI_PER_ULSF) && (RG_SCH_APCQI_NO != ue->dl.reqForCqi)) 
21381    {
21382 #ifdef LTE_ADV
21383       U8    idx = 0; 
21384       /* Send two bits cqireq field if more than one cells are configured else one*/
21385       for (idx = 1;idx < CM_LTE_MAX_CELLS;idx++)
21386       {
21387          if (ue->cellInfo[idx] != NULLP)
21388          {
21389             ue->ul.rarGrnt.cqiReqBit = ue->dl.reqForCqi;
21390             break;
21391          }
21392       }
21393       if (idx == CM_LTE_MAX_CELLS)
21394 #endif
21395       {
21396          ue->ul.rarGrnt.cqiReqBit = ue->dl.reqForCqi;
21397       }
21398       ue->dl.reqForCqi = RG_SCH_APCQI_NO;
21399       sf->numACqiCount++;
21400    }
21401    else
21402    {
21403       ue->ul.rarGrnt.cqiReqBit = 0;
21404    }
21405    /* Attach Ho/Po allocation to RAR Rsp cont free Lst */
21406    cmLListAdd2Tail(raRspLst, &ue->ul.rarGrnt.raRspLnk);
21407    ue->ul.rarGrnt.raRspLnk.node = (PTR)ue;
21408
21409    RETVOID;
21410 }
21411
21412 /**
21413  * @brief This is a utility function to set the fields in
21414  * an UL harq proc which is identified for non-adaptive retx
21415  *
21416  * @details
21417  *
21418  *     Function: rgSCHCmnUlNonadapRetx 
21419  *     Purpose:  Sets the fields in UL Harq  proc for non-adaptive retx 
21420  *
21421  * @param[in]  RgSchCmnUlCell  *cellUl 
21422  * @param[out] RgSchUlAlloc    *alloc
21423  * @param[in]  U8              idx 
21424  * @return  Void
21425  *
21426  **/
21427 #ifdef UNUSE_FUN
21428 #ifdef ANSI
21429 PRIVATE Void rgSCHCmnUlNonadapRetx
21430 (
21431 RgSchCmnUlCell  *cellUl,
21432 RgSchUlAlloc    *alloc,
21433 U8              idx
21434 )
21435 #else
21436 PRIVATE Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
21437 RgSchCmnUlCell  *cellUl;
21438 RgSchUlAlloc    *alloc;
21439 U8              idx;
21440 #endif
21441 {
21442    TRC2(rgSCHCmnUlNonadapRetx);
21443    rgSCHUhmRetx(alloc->hqProc, alloc);
21444
21445    /* Update alloc to retx */
21446    alloc->hqProc->isRetx = TRUE;
21447    alloc->hqProc->ulSfIdx = cellUl->reTxIdx[idx];
21448
21449    if (alloc->hqProc->rvIdx != 0)
21450    {
21451       alloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl[alloc->hqProc->rvIdx];
21452    }
21453    else
21454    {
21455       alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
21456    }
21457    alloc->grnt.isRtx = TRUE;
21458    alloc->pdcch = NULLP;
21459    RETVOID;
21460 }
21461 #endif
21462 /**
21463  * @brief Check if 2 allocs overlap
21464  *
21465  * @details
21466  *
21467  *     Function : rgSCHCmnUlAllocsOvrLap
21468  *
21469  *      - Return TRUE if alloc1 and alloc2 overlap.
21470  *
21471  *  @param[in]  RgSchUlAlloc  *alloc1
21472  *  @param[in]  RgSchUlAlloc  *alloc2
21473  *  @return  Bool
21474  **/
21475 #ifdef UNUSE_FUN
21476 #ifdef ANSI
21477 PRIVATE Bool rgSCHCmnUlAllocsOvrLap
21478 (
21479 RgSchUlAlloc    *alloc1,
21480 RgSchUlAlloc    *alloc2
21481 )
21482 #else
21483 PRIVATE Bool rgSCHCmnUlAllocsOvrLap(alloc1, alloc2)
21484 RgSchUlAlloc    *alloc1;
21485 RgSchUlAlloc    *alloc2;
21486 #endif
21487 {
21488
21489    TRC2(rgSCHCmnUlAllocsOvrLap);
21490
21491    if (((alloc1->sbStart >= alloc2->sbStart) &&
21492          (alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
21493         ((alloc2->sbStart >= alloc1->sbStart) &&
21494          (alloc2->sbStart <= alloc1->sbStart + alloc1->numSb-1)))
21495    {
21496       RETVALUE(TRUE);
21497    }
21498    RETVALUE(FALSE);
21499 }
21500 #endif
21501 /**
21502  * @brief Copy allocation Info from src to dst.
21503  *
21504  * @details
21505  *
21506  *     Function : rgSCHCmnUlCpyAllocInfo
21507  *
21508  *      - Copy allocation Info from src to dst.
21509  *
21510  *  @param[in]  RgSchUlAlloc  *srcAlloc
21511  *  @param[in]  RgSchUlAlloc  *dstAlloc
21512  *  @return  Void
21513  **/
21514 #ifdef UNUSE_FUN
21515 #ifdef ANSI
21516 PRIVATE Void rgSCHCmnUlCpyAllocInfo
21517 (
21518 RgSchCellCb     *cell,
21519 RgSchUlAlloc    *srcAlloc,
21520 RgSchUlAlloc    *dstAlloc
21521 )
21522 #else
21523 PRIVATE Void rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc)
21524 RgSchCellCb     *cell;
21525 RgSchUlAlloc    *srcAlloc;
21526 RgSchUlAlloc    *dstAlloc;
21527 #endif
21528 {
21529    RgSchCmnUlUe *ueUl;
21530    TRC2(rgSCHCmnUlCpyAllocInfo);
21531
21532    dstAlloc->grnt = srcAlloc->grnt;
21533    dstAlloc->hqProc = srcAlloc->hqProc;
21534    /* Fix : syed During UE context release, hqProc->alloc
21535     * was pointing to srcAlloc instead of dstAlloc and
21536     * freeing from incorrect sf->allocDb was
21537     * corrupting the list. */
21538     /* In case of SPS Occasion Allocation is done in advance and 
21539        at a later time Hq Proc is linked. Hence HqProc
21540        pointer in alloc shall be NULL */
21541 #ifdef LTEMAC_SPS
21542    if (dstAlloc->hqProc)
21543 #endif
21544    {
21545       dstAlloc->hqProc->alloc = dstAlloc;
21546    }
21547    dstAlloc->ue = srcAlloc->ue;
21548    dstAlloc->rnti = srcAlloc->rnti;
21549    dstAlloc->forMsg3 = srcAlloc->forMsg3;
21550    dstAlloc->raCb  = srcAlloc->raCb;
21551    dstAlloc->pdcch = srcAlloc->pdcch;
21552    /* Fix : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
21553    if (dstAlloc->ue)
21554    {
21555       ueUl = RG_SCH_CMN_GET_UL_UE(dstAlloc->ue,cell);
21556       ueUl->alloc.alloc = dstAlloc;
21557 #ifdef LTEMAC_SPS
21558       if (dstAlloc->ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
21559       {
21560          if((dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc != NULLP)
21561                && (dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc == srcAlloc))
21562          {
21563             dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc = dstAlloc;
21564          }
21565       }
21566 #endif
21567    }
21568
21569    RETVOID;
21570 }
21571 #endif
21572
21573 /**
21574  * @brief Update TX and RETX subframe's allocation
21575  *        markings.
21576  *
21577  * @details
21578  *
21579  *     Function : rgSCHCmnUlInsAllocFrmNewSf2OldSf
21580  *
21581  *      - Release all preassigned allocations of newSf and merge
21582  *        them to oldSf.
21583  *      - If alloc of newSf collide with one or more allocs of oldSf
21584  *        - mark all such allocs of oldSf for Adaptive Retx.
21585  *      - Swap the alloc and hole DB references of oldSf and newSf.
21586  *
21587  *  @param[in]  RgSchCellCb   *cell
21588  *  @param[in]  RgSchUlSf     *newSf
21589  *  @param[in]  RgSchUlSf     *oldSf
21590  *  @param[in]  RgSchUlAlloc  *srcAlloc
21591  *  @return  Void
21592  **/
21593 #ifdef UNUSE_FUN
21594 #ifdef ANSI
21595 PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf
21596 (
21597 RgSchCellCb     *cell,
21598 RgSchUlSf       *newSf,
21599 RgSchUlSf       *oldSf,
21600 RgSchUlAlloc    *srcAlloc
21601 )
21602 #else
21603 PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, srcAlloc)
21604 RgSchCellCb     *cell;
21605 RgSchUlSf       *newSf;
21606 RgSchUlSf       *oldSf;
21607 RgSchUlAlloc    *srcAlloc;
21608 #endif
21609 {
21610    RgSchUlAlloc   *alloc, *dstAlloc, *nxtAlloc;
21611
21612    /* MS_WORKAROUND ccpu00120827 */
21613    RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
21614    U8 remAllocs;
21615    TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
21616
21617    if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
21618    {
21619       do
21620       {
21621          nxtAlloc = rgSCHUtlUlAllocNxt(oldSf, alloc);
21622          /* If there is an overlap between alloc and srcAlloc
21623           * then alloc is marked for Adaptive retx and it is released
21624           * from txSf */
21625          if (rgSCHCmnUlAllocsOvrLap(alloc, srcAlloc) == TRUE)
21626          {
21627             rgSCHCmnUlUpdAllocRetx(cell, alloc);
21628             rgSCHUtlUlAllocRls(oldSf, alloc);
21629          }
21630          /* No further allocs spanning the srcAlloc subbands */
21631          if (srcAlloc->sbStart + srcAlloc->numSb - 1  <= alloc->sbStart)
21632          {
21633             break;
21634          }
21635       } while ((alloc = nxtAlloc) != NULLP);
21636    }
21637
21638    /* After freeing all the colliding allocs, request for an allocation
21639     * specifying the start and numSb with in txSf. This function should
21640     * always return positively with a nonNULL dstAlloc */
21641     /* MS_WORKAROUND ccpu00120827 */
21642    remAllocs = schCmnCell->ul.maxAllocPerUlSf - *oldSf->allocCountRef;
21643    if (!remAllocs)
21644    {
21645       /* Fix : If oldSf already has max Allocs then release the
21646        * old RETX alloc to make space for new alloc of newSf.
21647        * newSf allocs(i.e new Msg3s) are given higher priority
21648        * over retx allocs. */      
21649       if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
21650       {
21651          do
21652          {
21653             nxtAlloc = rgSCHUtlUlAllocNxt(oldSf, alloc);           
21654             if (!alloc->mrgdNewTxAlloc)
21655             {
21656                /* If alloc is for RETX */                   
21657                /* TODO: Incase of this ad also in case of choosing
21658                 * and alloc for ADAP RETX, we need to send ACK for
21659                 * the corresponding alloc in PHICH */               
21660 #ifndef EMTC_ENABLE
21661                rgSCHCmnUlFreeAllocation(cell, oldSf, alloc);
21662 #else
21663                rgSCHCmnUlFreeAllocation(cell, oldSf, alloc,FALSE);
21664 #endif
21665                break;
21666             }               
21667          }while((alloc = nxtAlloc) != NULLP);
21668       }
21669    }
21670    dstAlloc = rgSCHUtlUlGetSpfcAlloc(oldSf, srcAlloc->sbStart, srcAlloc->numSb);
21671 #ifdef ERRCLS_KW
21672    /* This should never happen */
21673    if (dstAlloc == NULLP)
21674    {
21675       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
21676          "rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
21677          srcAlloc->rnti);
21678       RETVOID;
21679    }
21680 #endif
21681    /* Copy the srcAlloc's state information in to dstAlloc */
21682    rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc);
21683    /* Set new Tx merged Alloc Flag to TRUE, indicating that this
21684     * alloc shall not be processed for non-adaptive retransmission */
21685    dstAlloc->mrgdNewTxAlloc = TRUE;
21686    RETVOID;
21687 }
21688 #endif
21689 /**
21690  * @brief Merge all allocations of newSf to oldSf.
21691  *
21692  * @details
21693  *
21694  *     Function : rgSCHCmnUlMergeSfAllocs
21695  *
21696  *      - Merge all allocations of newSf to oldSf.
21697  *      - If newSf's alloc collides with oldSf's alloc
21698  *        then oldSf's alloc is marked for adaptive Retx
21699  *        and is released from oldSf to create space for
21700  *        newSf's alloc.
21701  *
21702  *  @param[in]  RgSchCellCb  *cell
21703  *  @param[in]  RgSchUlSf    *oldSf
21704  *  @param[in]  RgSchUlSf    *newSf
21705  *  @return  Void
21706  **/
21707 #ifdef UNUSE_FUN
21708 #ifdef ANSI
21709 PRIVATE Void rgSCHCmnUlMergeSfAllocs
21710 (
21711 RgSchCellCb  *cell,
21712 RgSchUlSf    *oldSf,
21713 RgSchUlSf    *newSf
21714 )
21715 #else
21716 PRIVATE Void rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf)
21717 RgSchCellCb  *cell;
21718 RgSchUlSf    *oldSf;
21719 RgSchUlSf    *newSf;
21720 #endif
21721 {
21722    RgSchUlAlloc    *alloc, *nxtAlloc;
21723    TRC2(rgSCHCmnUlMergeSfAllocs);
21724    UNUSED(cell);
21725
21726    /* Merge each alloc of newSf in to oldSf
21727     * and release it from newSf */
21728    if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
21729    {
21730       do
21731       {
21732          nxtAlloc = rgSCHUtlUlAllocNxt(newSf, alloc);
21733          rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, alloc);
21734          rgSCHUtlUlAllocRls(newSf, alloc);
21735       } while((alloc = nxtAlloc) != NULLP);
21736    }
21737    RETVOID;
21738 }
21739 #endif
21740 /**
21741  * @brief Swap Hole/Alloc DB context of newSf and oldSf.
21742  *
21743  * @details
21744  *
21745  *     Function : rgSCHCmnUlSwapSfAllocs
21746  *
21747  *      - Swap Hole/Alloc DB context of newSf and oldSf.
21748  *
21749  *  @param[in]  RgSchCellCb  *cell
21750  *  @param[in]  RgSchUlSf    *oldSf
21751  *  @param[in]  RgSchUlSf    *newSf
21752  *  @return  Void
21753  **/
21754 #ifdef UNUSE_FUN
21755 #ifdef ANSI
21756 PRIVATE Void rgSCHCmnUlSwapSfAllocs
21757 (
21758 RgSchCellCb  *cell,
21759 RgSchUlSf    *oldSf,
21760 RgSchUlSf    *newSf
21761 )
21762 #else
21763 PRIVATE Void rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf)
21764 RgSchCellCb  *cell;
21765 RgSchUlSf    *oldSf;
21766 RgSchUlSf    *newSf;
21767 #endif
21768 {
21769    RgSchUlAllocDb *tempAllocDb  = newSf->allocDb;
21770    RgSchUlHoleDb  *tempHoleDb   = newSf->holeDb;
21771    U8              tempAvailSbs = newSf->availSubbands;
21772
21773    TRC2(rgSCHCmnUlSwapSfAllocs);
21774    UNUSED(cell);
21775
21776    newSf->allocDb       = oldSf->allocDb;
21777    newSf->holeDb        = oldSf->holeDb;
21778    newSf->availSubbands = oldSf->availSubbands;
21779
21780    oldSf->allocDb = tempAllocDb;
21781    oldSf->holeDb  = tempHoleDb;
21782    oldSf->availSubbands = tempAvailSbs;
21783       
21784    /* Fix ccpu00120610*/
21785    newSf->allocCountRef = &newSf->allocDb->count;
21786    oldSf->allocCountRef = &oldSf->allocDb->count;
21787    RETVOID;
21788 }
21789 #endif
21790 /**
21791  * @brief Perform non-adaptive RETX for non-colliding allocs.
21792  *
21793  * @details
21794  *
21795  *     Function : rgSCHCmnUlPrcNonAdptRetx
21796  *
21797  *      - Perform non-adaptive RETX for non-colliding allocs.
21798  *
21799  *  @param[in]  RgSchCellCb  *cell
21800  *  @param[in]  RgSchUlSf    *newSf
21801  *  @param[in]  U8           idx
21802  *  @return  Void
21803  **/
21804 #ifdef UNUSE_FUN
21805 #ifdef ANSI
21806 PRIVATE Void rgSCHCmnUlPrcNonAdptRetx
21807 (
21808 RgSchCellCb  *cell,
21809 RgSchUlSf    *newSf,
21810 U8           idx
21811 )
21812 #else
21813 PRIVATE Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
21814 RgSchCellCb  *cell;
21815 RgSchUlSf    *newSf;
21816 U8           idx;
21817 #endif
21818 {
21819    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21820    RgSchUlAlloc    *alloc, *nxtAlloc;
21821    TRC2(rgSCHCmnUlPrcNonAdptRetx);
21822
21823    /* perform non-adaptive retx allocation(adjustment) */
21824    if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
21825    {
21826       do
21827       {
21828          nxtAlloc = rgSCHUtlUlAllocNxt(newSf, alloc);
21829          /* A merged new TX alloc, reset the state and skip */
21830          if (alloc->mrgdNewTxAlloc)
21831          {
21832             alloc->mrgdNewTxAlloc = FALSE;
21833             continue;
21834          }
21835          
21836
21837          rgSCHCmnUlNonadapRetx(cellUl, alloc, idx);
21838
21839       } while((alloc = nxtAlloc) != NULLP);
21840    }
21841    RETVOID;
21842 }
21843 #endif
21844 /**
21845  * @brief Update TX and RETX subframe's allocation
21846  *        markings.
21847  *
21848  * @details
21849  *
21850  *     Function : rgSCHCmnUlPrfmSfMerge
21851  *
21852  *      - Release all preassigned allocations of newSf and merge
21853  *        them to oldSf.
21854  *      - If alloc of newSf collide with one or more allocs of oldSf
21855  *        - mark all such allocs of oldSf for Adaptive Retx.
21856  *      - Swap the alloc and hole DB references of oldSf and newSf.
21857  *      - The allocs which did not collide with pre-assigned msg3
21858  *        allocs are marked for non-adaptive RETX.
21859  *
21860  *  @param[in]  RgSchCellCb  *cell
21861  *  @param[in]  RgSchUlSf    *oldSf
21862  *  @param[in]  RgSchUlSf    *newSf
21863  *  @param[in]  U8           idx 
21864  *  @return  Void
21865  **/
21866 #ifdef UNUSE_FUN
21867 #ifdef ANSI
21868 PRIVATE Void rgSCHCmnUlPrfmSfMerge
21869 (
21870 RgSchCellCb  *cell,
21871 RgSchUlSf    *oldSf,
21872 RgSchUlSf    *newSf,
21873 U8           idx
21874 )
21875 #else
21876 PRIVATE Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
21877 RgSchCellCb  *cell;
21878 RgSchUlSf    *oldSf;
21879 RgSchUlSf    *newSf;
21880 U8           idx;
21881 #endif
21882 {
21883    TRC2(rgSCHCmnUlPrfmSfMerge);
21884    /* Preassigned resources for msg3 in newSf.
21885     * Hence do adaptive retx for all NACKED TXs */
21886    rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
21887    /* swap alloc and hole DBs of oldSf and newSf. */
21888    rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf);
21889    /* Here newSf has the resultant merged allocs context */
21890    /* Perform non-adaptive RETX for non-colliding allocs */
21891    rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx);
21892    
21893    RETVOID;
21894 }
21895 #endif
21896 /**
21897  * @brief Update TX and RETX subframe's allocation
21898  *        markings.
21899  *
21900  * @details
21901  *
21902  *     Function : rgSCHCmnUlRmvCmpltdAllocs
21903  *
21904  *      - Free all Transmission which are ACKED
21905  *        OR for which MAX retransmission have
21906  *        occurred.
21907  *
21908  *
21909  *  @param[in]  RgSchCellCb    *cell,
21910  *  @param[in]  RgSchUlSf      *sf
21911  *  @return  Void
21912  **/
21913 #ifdef ANSI
21914 PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs
21915 (
21916 RgSchCellCb    *cell,
21917 RgSchUlSf      *sf
21918 )
21919 #else
21920 PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs(cell, sf)
21921 RgSchCellCb    *cell;
21922 RgSchUlSf      *sf;
21923 #endif
21924 {
21925    RgSchUlAlloc    *alloc, *nxtAlloc;
21926    TRC2(rgSCHCmnUlRmvCmpltdAllocs);
21927
21928    if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
21929    {
21930       RETVOID;
21931    }
21932    do
21933    {
21934       nxtAlloc = rgSCHUtlUlAllocNxt(sf, alloc);
21935 #ifdef UL_ADPT_DBG      
21936       printf("rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.slot,alloc->hqProc->remTx, alloc->grnt.hqProcId);
21937 #endif
21938       alloc->hqProc->rcvdCrcInd = TRUE;
21939       if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
21940       {
21941
21942         /* SR_RACH_STATS : MSG 3 MAX RETX FAIL*/
21943          if ((alloc->forMsg3 == TRUE) && (alloc->hqProc->remTx == 0))
21944          {
21945             rgNumMsg3FailMaxRetx++;
21946 #ifdef TENB_STATS
21947             cell->tenbStats->sch.msg3Fail++;
21948 #endif
21949          }
21950
21951 #ifdef MAC_SCH_STATS
21952     if(alloc->ue != NULLP)
21953     {
21954        /* access from ulHarqProc*/
21955        RgSchUeCb       *ueCb  = alloc->ue;
21956        RgSchCmnUe      *cmnUe = (RgSchCmnUe*)ueCb->sch;
21957        RgSchCmnUlUe    *ulUe  = &(cmnUe->ul);
21958        U8              cqi    = ulUe->crntUlCqi[0];  
21959        U16             numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
21960
21961        hqRetxStats.ulCqiStat[(cqi - 1)].mcs = alloc->grnt.iMcs;
21962
21963        switch (numUlRetx)
21964        {
21965           case 1:
21966              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_1++;
21967              break;
21968           case 2:
21969              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_2++;
21970              break;
21971          case 3:
21972             hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_3++;
21973             break;
21974          case 4:
21975             hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_4++;
21976             break;
21977       }
21978       hqRetxStats.ulCqiStat[(cqi - 1)].totalTx = \
21979              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_1 + \
21980             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_2 * 2) + \
21981             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_3 * 3) + \
21982             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_4 * 4);
21983    }
21984
21985 #endif /*MAC_SCH_STATS*/
21986          rgSCHCmnUlFreeAllocation(cell, sf, alloc);
21987       }
21988       /*ccpu00106104 MOD added check for AckNackRep */
21989       /*added check for acknack so that adaptive retx considers ue
21990        inactivity due to ack nack repetition*/
21991       else if((alloc->ue != NULLP) && (TRUE != alloc->forMsg3))
21992       {
21993         rgSCHCmnUlUpdAllocRetx(cell, alloc);
21994         rgSCHUtlUlAllocRls(sf, alloc);
21995       }
21996    } while ((alloc = nxtAlloc) != NULLP);
21997
21998    RETVOID;
21999 }
22000
22001 /**
22002  * @brief Update an uplink subframe.
22003  *
22004  * @details
22005  *
22006  *     Function : rgSCHCmnRlsUlSf
22007  *
22008  *     For each allocation
22009  *      - if no more tx needed
22010  *         - Release allocation
22011  *      - else
22012  *         - Perform retransmission
22013  *
22014  *  @param[in]  RgSchUlSf *sf
22015  *  @param[in]  U8        idx 
22016  *  @return  Void
22017  **/
22018 #ifdef ANSI
22019 PUBLIC Void rgSCHCmnRlsUlSf
22020 (
22021 RgSchCellCb    *cell,
22022 U8              idx
22023 )
22024 #else
22025 PUBLIC Void rgSCHCmnRlsUlSf(cell, idx)
22026 RgSchCellCb    *cell;
22027 U8              idx;
22028 #endif
22029 {
22030    TRC2(rgSCHCmnRlsUlSf);
22031
22032    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22033    
22034    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO) 
22035    {
22036       RgSchUlSf   *oldSf  = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
22037
22038       /* Initialize the reTxLst of UL HqProcs for RETX subframe */
22039       if (rgSCHUtlUlAllocFirst(oldSf) == NULLP)
22040       {
22041          RETVOID;
22042       }
22043       /* Release all completed TX allocs from sf */
22044       rgSCHCmnUlRmvCmpltdAllocs(cell, oldSf);
22045
22046       oldSf->numACqiCount = 0;
22047    }
22048    RETVOID;
22049 }
22050
22051 /**
22052  * @brief Handle uplink allocation for retransmission.
22053  *
22054  * @details
22055  *
22056  *     Function : rgSCHCmnUlUpdAllocRetx
22057  *
22058  *     - Perform adaptive retransmission
22059  *
22060  *  @param[in]  RgSchUlSf *sf
22061  *  @param[in]  RgSchUlAlloc  *alloc
22062  *  @return  Void
22063  **/
22064 #ifdef ANSI
22065 PRIVATE Void rgSCHCmnUlUpdAllocRetx
22066 (
22067 RgSchCellCb    *cell,
22068 RgSchUlAlloc   *alloc
22069 )
22070 #else
22071 PRIVATE Void rgSCHCmnUlUpdAllocRetx(cell, alloc)
22072 RgSchCellCb    *cell;
22073 RgSchUlAlloc   *alloc;
22074 #endif
22075 {
22076    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
22077
22078    TRC2(rgSCHCmnUlUpdAllocRetx);
22079
22080    alloc->hqProc->reTxAlloc.rnti    =  alloc->rnti;
22081    alloc->hqProc->reTxAlloc.numSb   =  alloc->numSb;
22082    alloc->hqProc->reTxAlloc.iMcs   =  alloc->grnt.iMcs;
22083 #ifdef RG_5GTF
22084    alloc->hqProc->reTxAlloc.dciFrmt =  alloc->grnt.dciFrmt;
22085    alloc->hqProc->reTxAlloc.numLyr   =  alloc->grnt.numLyr;
22086    alloc->hqProc->reTxAlloc.vrbgStart =  alloc->grnt.vrbgStart;
22087    alloc->hqProc->reTxAlloc.numVrbg   =  alloc->grnt.numVrbg;
22088    alloc->hqProc->reTxAlloc.modOdr   =  alloc->grnt.modOdr;
22089 #endif
22090    //iTbs = rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs);
22091    //iTbs = alloc->grnt.iMcs;
22092    //RGSCH_ARRAY_BOUND_CHECK( 0, rgTbSzTbl[0], iTbs);
22093    alloc->hqProc->reTxAlloc.tbSz = alloc->grnt.datSz;
22094       //rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1]/8;
22095    alloc->hqProc->reTxAlloc.ue      = alloc->ue;
22096    alloc->hqProc->reTxAlloc.forMsg3 = alloc->forMsg3;
22097    alloc->hqProc->reTxAlloc.raCb = alloc->raCb;
22098
22099    /* Set as retransmission is pending */
22100    alloc->hqProc->isRetx = TRUE;
22101    alloc->hqProc->alloc = NULLP;
22102    alloc->hqProc->ulSfIdx = RGSCH_INVALID_INFO;
22103 #ifdef UL_ADPT_DBG  
22104    printf("Adding Harq Proc Id in the retx list  hqProcId %d \n",alloc->grnt.hqProcId); 
22105 #endif
22106    cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
22107    alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
22108    RETVOID;
22109 }
22110
22111 /**
22112  * @brief Attempts allocation for msg3s for which ADAP retransmissions
22113  *     are required.
22114  *
22115  * @details
22116  *
22117  *     Function : rgSCHCmnUlAdapRetxAlloc
22118  *
22119  *     Attempts allocation for msg3s for which ADAP retransmissions
22120  *     are required.
22121  *
22122  *  @param[in]  RgSchCellCb       *cell
22123  *  @param[in]  RgSchUlSf         *sf
22124  *  @param[in]  RgSchUlHqProcCb   *proc;
22125  *  @param[in]  RgSchUlHole       *hole;
22126  *  @return  U8
22127  **/
22128 #ifdef ANSI
22129 PRIVATE Bool rgSCHCmnUlAdapRetxAlloc
22130 (
22131 RgSchCellCb       *cell,
22132 RgSchUlSf         *sf,
22133 RgSchUlHqProcCb   *proc,
22134 RgSchUlHole       *hole
22135 )
22136 #else
22137 PRIVATE Bool rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole)
22138 RgSchCellCb       *cell;
22139 RgSchUlSf         *sf;
22140 RgSchUlHqProcCb   *proc;
22141 RgSchUlHole       *hole;
22142 #endif
22143 {
22144    U8              numSb = proc->reTxAlloc.numSb;
22145    U8              iMcs  = proc->reTxAlloc.iMcs;
22146    CmLteTimingInfo frm = cell->crntTime;
22147    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22148    RgSchDlSf       *dlSf;
22149    RgSchPdcch      *pdcch;
22150    RgSchUlAlloc    *alloc;
22151    TRC2(rgSCHCmnUlAdapRetxAlloc);
22152
22153    /* Fetch PDCCH for msg3 */
22154    /* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
22155    /* Introduced timing delta for UL control */
22156    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
22157    dlSf = rgSCHUtlSubFrmGet(cell, frm);
22158    pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
22159    if (pdcch == NULLP)
22160    {
22161       RETVALUE(FALSE);
22162    }
22163
22164    /* Fetch UL Alloc for msg3 */
22165    if (numSb <= hole->num)
22166    {
22167       alloc                = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
22168       
22169       /* KWork fix */
22170          if(alloc == NULLP)
22171          {
22172             rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
22173             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
22174                   "UL Alloc fail for msg3 retx for rnti: %d\n", 
22175                   proc->reTxAlloc.rnti);
22176             RETVALUE(FALSE);
22177          }
22178
22179       rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
22180       alloc->grnt.iMcs     = iMcs;
22181       alloc->grnt.datSz    = proc->reTxAlloc.tbSz;
22182 #ifdef RG_5GTF
22183 #else
22184       //RG_SCH_UL_MCS_TO_MODODR(iMcs, alloc->grnt.modOdr);
22185 #endif
22186       /* Fill UL Alloc for msg3 */
22187       /* RACHO : setting nDmrs to 0 and UlDelaybit to 0*/
22188       alloc->grnt.nDmrs    = 0;
22189       alloc->grnt.hop      = 0;
22190       alloc->grnt.delayBit = 0;
22191       alloc->grnt.isRtx    = TRUE;
22192       proc->ulSfIdx        = cellUl->schdIdx;
22193 #ifdef RG_5GTF
22194       proc->schdTime = cellUl->schdTime;
22195       alloc->grnt.hqProcId = proc->procId;
22196       alloc->grnt.dciFrmt = proc->reTxAlloc.dciFrmt;
22197       alloc->grnt.numLyr = proc->reTxAlloc.numLyr;
22198       alloc->grnt.vrbgStart = proc->reTxAlloc.vrbgStart;
22199       alloc->grnt.numVrbg = proc->reTxAlloc.numVrbg;
22200       alloc->grnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, alloc->grnt.vrbgStart, alloc->grnt.numVrbg);
22201       alloc->grnt.modOdr = proc->reTxAlloc.modOdr;
22202
22203       /* TODO : Hardcoding these as of now */
22204       alloc->grnt.hop = 0;
22205       alloc->grnt.SCID = 0;
22206       alloc->grnt.xPUSCHRange = MAX_5GTF_XPUSCH_RANGE;
22207       alloc->grnt.PMI = 0;
22208       alloc->grnt.uciOnxPUSCH = 0;
22209 #endif
22210       alloc->rnti          = proc->reTxAlloc.rnti;
22211       /* Fix : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
22212       alloc->ue            = proc->reTxAlloc.ue;
22213       alloc->pdcch         = pdcch;
22214       alloc->forMsg3       = proc->reTxAlloc.forMsg3;
22215       alloc->raCb          = proc->reTxAlloc.raCb;
22216       alloc->hqProc        = proc;
22217       alloc->isAdaptive    = TRUE;
22218 #ifdef LTE_L2_MEAS
22219       sf->totPrb  += alloc->grnt.numRb;
22220 #endif
22221       /* FIX : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
22222       if (alloc->raCb)
22223       {
22224          alloc->raCb->msg3Grnt= alloc->grnt;
22225 #ifndef LTE_TDD
22226          /* To the crntTime, add the time at which UE will
22227           * actually send MSG3 */
22228          alloc->raCb->msg3AllocTime = cell->crntTime;
22229          RGSCH_INCR_SUB_FRAME(alloc->raCb->msg3AllocTime, RG_SCH_CMN_MIN_RETXMSG3_RECP_INTRVL);
22230 #else
22231          alloc->raCb->msg3AllocTime =  cellUl->schdTime;
22232 #endif
22233          rgSCHCmnUlAdapRetx(alloc, proc);
22234          /* Fill PDCCH with alloc info */
22235          pdcch->rnti                           = alloc->rnti;
22236          pdcch->dci.dciFormat                  = TFU_DCI_FORMAT_0;
22237          pdcch->dci.u.format0Info.hoppingEnbld = alloc->grnt.hop;
22238          pdcch->dci.u.format0Info.rbStart      = alloc->grnt.rbStart;
22239          pdcch->dci.u.format0Info.numRb        = alloc->grnt.numRb;
22240          pdcch->dci.u.format0Info.mcs          = alloc->grnt.iMcsCrnt;
22241          pdcch->dci.u.format0Info.ndi          = alloc->hqProc->ndi;
22242          pdcch->dci.u.format0Info.nDmrs        = alloc->grnt.nDmrs;
22243          pdcch->dci.u.format0Info.tpcCmd       = alloc->grnt.tpc;
22244
22245 #ifdef LTE_TDD
22246 #ifdef TFU_TDD
22247          /* ulIdx setting for cfg 0 shall be appropriately fixed thru ccpu00109015 */
22248          pdcch->dci.u.format0Info.ulIdx = RG_SCH_ULIDX_MSB;
22249          pdcch->dci.u.format0Info.dai = RG_SCH_MAX_DAI_IDX;
22250 #endif
22251 #endif
22252          pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_0];
22253       }
22254       else
22255       {
22256          RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(alloc->ue,cell);
22257 #ifdef TFU_UPGRADE
22258          alloc->ue->initNumRbs = (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
22259 #endif
22260 #ifdef LTE_L2_MEAS
22261          ue->ul.nPrb = alloc->grnt.numRb;
22262 #endif
22263          ueUl->alloc.alloc = alloc;
22264          /* FIx: Removed the call to rgSCHCmnUlAdapRetx */
22265          rgSCHCmnUlUeFillAllocInfo(cell, alloc->ue);
22266          /* Setting csireq as false for Adaptive Retx*/
22267          ueUl->alloc.alloc->pdcch->dci.u.format0Info.cqiReq = RG_SCH_APCQI_NO;
22268          pdcch->dciNumOfBits = alloc->ue->dciSize.cmnSize[TFU_DCI_FORMAT_0];
22269       }
22270       /* Reset as retransmission is done */
22271       proc->isRetx = FALSE;
22272    }
22273    else /* Intg fix */
22274    {
22275       rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
22276       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
22277                "Num SB not suffiecient for adap retx for rnti: %d", 
22278                proc->reTxAlloc.rnti);
22279       RETVALUE(FALSE);
22280    }
22281    RETVALUE(TRUE);
22282 }
22283
22284 /* Fix: syed Adaptive Msg3 Retx crash. */
22285 /**
22286  * @brief Releases all Adaptive Retx HqProcs which failed for
22287  *        allocations in this scheduling occassion.
22288  *
22289  * @details
22290  *
22291  *     Function : rgSCHCmnUlSfRlsRetxProcs
22292  *
22293  *
22294  *  @param[in]  RgSchCellCb *cell
22295  *  @param[in]  RgSchUlSf   *sf
22296  *  @return  U8
22297  **/
22298 #ifdef UNUSE_FUN
22299 #ifdef ANSI
22300 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs
22301 (
22302 RgSchCellCb *cell,
22303 RgSchUlSf   *sf
22304 )
22305 #else
22306 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs(cell, sf)
22307 RgSchCellCb *cell;
22308 RgSchUlSf   *sf;
22309 #endif
22310 {
22311    CmLListCp         *cp;
22312    CmLList           *node;
22313    RgSchUlHqProcCb   *proc;
22314    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22315
22316    TRC2(rgSCHCmnUlSfRlsRetxProcs);
22317
22318    cp = &(cellUl->reTxLst);
22319    node = cp->first;
22320    while (node)
22321    {
22322       proc  = (RgSchUlHqProcCb *)node->node;
22323       node = node->next;
22324       /* ccpu00137834 : Deleting reTxLnk from the respective reTxLst */
22325       cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
22326       proc->reTxLnk.node = (PTR)NULLP;
22327    }
22328    RETVOID;
22329 }
22330 #endif   
22331
22332 /**
22333  * @brief Attempts allocation for UEs for which retransmissions
22334  *     are required.
22335  *
22336  * @details
22337  *
22338  *     Function : rgSCHCmnUlSfReTxAllocs
22339  *
22340  *     Attempts allocation for UEs for which retransmissions
22341  *     are required.
22342  *
22343  *  @param[in]  RgSchCellCb *cell
22344  *  @param[in]  RgSchUlSf   *sf
22345  *  @return  U8
22346  **/
22347 #ifdef ANSI
22348 PRIVATE Void rgSCHCmnUlSfReTxAllocs
22349 (
22350 RgSchCellCb *cell,
22351 RgSchUlSf   *sf
22352 )
22353 #else
22354 PRIVATE Void rgSCHCmnUlSfReTxAllocs(cell, sf)
22355 RgSchCellCb *cell;
22356 RgSchUlSf   *sf;
22357 #endif
22358 {
22359    CmLListCp         *cp;
22360    CmLList           *node;
22361    RgSchUlHqProcCb   *proc;
22362    RgSchUlHole       *hole;
22363    RgSchUeCb         *ue;
22364    RgSchCmnCell      *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
22365    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22366    TRC2(rgSCHCmnUlSfReTxAllocs);
22367
22368    cp = &(cellUl->reTxLst);
22369    node = cp->first;
22370    while ((node))
22371    {
22372       proc  = (RgSchUlHqProcCb *)node->node;
22373       ue = proc->reTxAlloc.ue;
22374       node = node->next;
22375       /*ccpu00106104 MOD added check for AckNackRep */
22376       /*added check for acknack so that adaptive retx considers ue
22377        inactivity due to ack nack repetition*/
22378       if((ue != NULLP) &&
22379             ((ue->measGapCb.isMeasuring == TRUE)||
22380                (ue->ackNakRepCb.isAckNakRep == TRUE)))
22381       {
22382          continue;
22383       }
22384       /* Fix for ccpu00123917: Check if maximum allocs per UL sf have been exhausted */
22385       if (((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
22386             || (sf->allocDb->count == schCmnCell->ul.maxAllocPerUlSf))
22387       {
22388          /* No more UL BW then return */
22389          break;
22390       }
22391       /* perform adaptive retx for UE's */
22392       if (rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole) == FALSE)
22393       {
22394          continue;
22395       }
22396       /* ccpu00137834 : Deleting reTxLnk from the respective reTxLst */
22397       cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
22398       /* Fix: syed Adaptive Msg3 Retx crash. */
22399       proc->reTxLnk.node = (PTR)NULLP;
22400    }
22401    RETVOID;
22402 }
22403
22404 /**
22405  * @brief Handles RB allocation for downlink.
22406  *
22407  * @details
22408  *
22409  *     Function : rgSCHCmnDlRbAlloc
22410  *
22411  *     Invoking Module Processing:
22412  *     - This function is invoked for DL RB allocation
22413  *
22414  *     Processing Steps:
22415  *     - If cell is frequency selecive,
22416  *       - Call rgSCHDlfsAllocRb().
22417  *     - else,
22418  *       - Call rgSCHCmnNonDlfsRbAlloc().
22419  *
22420  *  @param[in]  RgSchCellCb        *cell
22421  *  @param[in]  RgSchDlRbAllocInfo *allocInfo
22422  *  @return  Void
22423  **/
22424
22425 #ifdef ANSI
22426 PRIVATE Void rgSCHCmnDlRbAlloc
22427 (
22428 RgSchCellCb           *cell,
22429 RgSchCmnDlRbAllocInfo *allocInfo
22430 )
22431 #else
22432 PRIVATE Void rgSCHCmnDlRbAlloc(cell, allocInfo)
22433 RgSchCellCb           *cell;
22434 RgSchCmnDlRbAllocInfo *allocInfo;
22435 #endif
22436 {
22437    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
22438    TRC2(rgSCHCmnDlRbAlloc);
22439
22440    if (cellSch->dl.isDlFreqSel)
22441    {
22442       printf("5GTF_ERROR DLFS SCH Enabled\n");
22443       cellSch->apisDlfs->rgSCHDlfsAllocRb(cell, allocInfo);
22444    }
22445    else
22446    {
22447       rgSCHCmnNonDlfsRbAlloc(cell, allocInfo);
22448    }
22449    RETVOID;
22450 }
22451
22452 #ifdef LTEMAC_SPS
22453
22454 /**
22455  * @brief Determines number of RBGs and RBG subset sizes for the given DL
22456  * bandwidth and rbgSize
22457  *
22458  * @details
22459  *     Function : rgSCHCmnDlGetRbgInfo
22460  *
22461  *
22462  *     Processing Steps:
22463  *     - Fill-up rbgInfo data structure for given DL bandwidth and rbgSize
22464  *
22465  *   @param[in]  U8             dlTotalBw
22466  *   @param[in]  U8             dlSubsetBw
22467  *   @param[in]  U8             maxRaType1SubsetBw
22468  *   @param[in]  U8             rbgSize
22469  *   @param[out] RgSchBwRbgInfo *rbgInfo
22470  *  @return Void
22471  **/
22472 #ifdef ANSI
22473 PUBLIC Void rgSCHCmnDlGetRbgInfo
22474 (
22475 U8             dlTotalBw,
22476 U8             dlSubsetBw,
22477 U8             maxRaType1SubsetBw,
22478 U8             rbgSize,
22479 RgSchBwRbgInfo *rbgInfo
22480 )
22481 #else
22482 PUBLIC Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
22483       rbgSize, rbgInfo)
22484 U8             dlTotalBw;
22485 U8             dlSubsetBw;
22486 U8             maxRaType1SubsetBw;
22487 U8             rbgSize;
22488 RgSchBwRbgInfo *rbgInfo;
22489 #endif
22490 {
22491 #ifdef RGSCH_SPS_UNUSED
22492    U8    idx           = 0;
22493    U8    lastRbgIdx    = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
22494    U8    currRbgSize   = rbgSize;
22495    U8    subsetSizeIdx = 0;
22496    U8    subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
22497    U8    lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
22498    U8    numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
22499 #endif
22500
22501    /* Compute maximum number of SPS RBGs for the cell */
22502    rbgInfo->numRbgs =  ((dlSubsetBw + rbgSize - 1)/rbgSize);
22503
22504 #ifdef RGSCH_SPS_UNUSED
22505    /* Distribute RBGs across subsets except last RBG */
22506    for (;idx < numRaType1Rbgs - 1; ++idx)
22507    {
22508       subsetSize[subsetSizeIdx] += currRbgSize;
22509       subsetSizeIdx = (subsetSizeIdx + 1) % rbgSize;
22510    }
22511
22512    /* Computation for last RBG */
22513    if (idx == lastRbgIdx)
22514    {
22515       currRbgSize = lastRbgSize;
22516    }
22517    subsetSize[subsetSizeIdx] += currRbgSize;
22518    subsetSizeIdx = (subsetSizeIdx + 1) % rbgSize;
22519 #endif
22520
22521    /* Update the computed sizes */
22522 #ifdef RGSCH_SPS_UNUSED
22523    rbgInfo->lastRbgSize = currRbgSize;
22524 #endif
22525    rbgInfo->lastRbgSize = rbgSize - 
22526             (dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
22527 #ifdef RGSCH_SPS_UNUSED
22528    cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
22529 #endif
22530    rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
22531       dlTotalBw:(rbgInfo->numRbgs * rbgSize);
22532    rbgInfo->rbgSize = rbgSize;
22533 }
22534
22535 /**
22536  * @brief Handles RB allocation for Resource allocation type 0
22537  *
22538  * @details
22539  *
22540  *     Function : rgSCHCmnDlRaType0Alloc
22541  *
22542  *     Invoking Module Processing:
22543  *     - This function is invoked for DL RB allocation for resource allocation
22544  *     type 0
22545  *
22546  *     Processing Steps:
22547  *     - Determine the available positions in the rbgMask.
22548  *     - Allocate RBGs in the available positions.
22549  *     - Update RA Type 0, RA Type 1 and RA type 2 masks.
22550  *
22551  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22552  *  @param[in]   U8             rbsReq
22553  *  @param[in]   RgSchBwRbgInfo *rbgInfo
22554  *  @param[out]  U8             *numAllocRbs
22555  *  @param[out]  RgSchDlSfAllocInfo *resAllocInfo
22556  *  @param[in]   Bool           isPartialAlloc
22557  *
22558  *  @return  Void
22559  **/
22560
22561 #ifdef ANSI
22562 PUBLIC U8 rgSCHCmnDlRaType0Alloc
22563 (
22564 RgSchDlSfAllocInfo *allocedInfo,
22565 U8                 rbsReq,
22566 RgSchBwRbgInfo     *rbgInfo,
22567 U8                 *numAllocRbs,
22568 RgSchDlSfAllocInfo *resAllocInfo,
22569 Bool               isPartialAlloc
22570 )
22571 #else
22572 PUBLIC U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
22573       numAllocRbs, resAllocInfo, isPartialAlloc)
22574 RgSchDlSfAllocInfo *allocedInfo;
22575 U8                 rbsReq;
22576 RgSchBwRbgInfo     *rbgInfo;
22577 U8                 *numAllocRbs;
22578 RgSchDlSfAllocInfo *resAllocInfo;
22579 Bool               isPartialAlloc;
22580 #endif
22581 {
22582    /* Note: This function atttempts allocation only full allocation */
22583    U32      remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
22584    U8       type2MaskIdx, cnt, rbIdx;
22585    U8       maskSize, rbg;
22586    U8       bestNumAvailRbs = 0;
22587    U8       usedRbs = 0;
22588    U8       numAllocRbgs = 0;
22589    U8       rbgSize = rbgInfo->rbgSize;
22590    U32      *rbgMask = &(resAllocInfo->raType0Mask);
22591 #ifdef RGSCH_SPS_UNUSED
22592    U8       rbgSubset;
22593    U32      ueRaType1Mask;
22594    U32      *raType1Mask = resAllocInfo->raType1Mask;
22595    U32      *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22596 #endif
22597    U32      *raType2Mask = resAllocInfo->raType2Mask;
22598
22599    U32      allocedMask = allocedInfo->raType0Mask;
22600
22601    maskSize = rbgInfo->numRbgs;
22602
22603    *numAllocRbs = 0;
22604    RG_SCH_CMN_DL_COUNT_ONES(allocedMask, maskSize, &usedRbs);
22605    if (maskSize == usedRbs)
22606    {
22607       /* All RBGs are allocated, including the last one */
22608       remNumRbs = 0;
22609    }
22610    else
22611    {
22612       remNumRbs = (maskSize - usedRbs - 1) * rbgSize; /* vamsee: removed minus 1 */
22613
22614       /* If last RBG is available, add last RBG size */
22615       if (!(allocedMask & (1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(maskSize - 1))))
22616       {
22617          remNumRbs += rbgInfo->lastRbgSize;
22618       }
22619    }
22620
22621    /* If complete allocation is needed, check if total requested RBs are available else
22622     * check the best available RBs */
22623    if (!isPartialAlloc)
22624    {
22625       if (remNumRbs >= rbsReq)
22626       {
22627          bestNumAvailRbs = rbsReq;
22628       }
22629    }
22630    else
22631    {
22632       bestNumAvailRbs = remNumRbs > rbsReq ? rbsReq : remNumRbs;
22633    }
22634
22635    /* Allocate for bestNumAvailRbs */
22636    if (bestNumAvailRbs)
22637    {
22638       for (rbg = 0; rbg < maskSize - 1; ++rbg)
22639       {
22640          rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22641          if (!(allocedMask & rbgPosInRbgMask))
22642          {
22643             /* Update RBG mask */
22644             *rbgMask |= rbgPosInRbgMask;
22645
22646             /* Compute RB index of the first RB of the RBG allocated */
22647             rbIdx = rbg * rbgSize;
22648
22649             for (cnt = 0; cnt < rbgSize; ++cnt)
22650             {
22651 #ifdef RGSCH_SPS_UNUSED
22652                ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22653 #endif
22654                ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22655 #ifdef RGSCH_SPS_UNUSED
22656                /* Update RBG mask for RA type 1 */
22657                raType1Mask[rbgSubset] |= ueRaType1Mask;
22658                raType1UsedRbs[rbgSubset]++;
22659 #endif
22660                /* Update RA type 2 mask */
22661                raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22662                rbIdx++;
22663             }
22664             *numAllocRbs += rbgSize;
22665             remNumRbs -= rbgSize;
22666             ++numAllocRbgs;
22667             if (*numAllocRbs >= bestNumAvailRbs)
22668             {
22669                break;
22670             }
22671          }
22672       }
22673       /* If last RBG available and allocation is not completed, allocate
22674        * last RBG */
22675       if (*numAllocRbs < bestNumAvailRbs)
22676       {
22677          rbgPosInRbgMask =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22678          *rbgMask |= rbgPosInRbgMask;
22679          *numAllocRbs += rbgInfo->lastRbgSize;
22680
22681          /* Compute RB index of the first RB of the last RBG */
22682          rbIdx = ((rbgInfo->numRbgs - 1 ) * rbgSize ); /* removed minus 1  vamsee */
22683
22684          for (cnt = 0; cnt < rbgInfo->lastRbgSize; ++cnt)
22685          {
22686 #ifdef RGSCH_SPS_UNUSED
22687             ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22688 #endif
22689             ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22690 #ifdef RGSCH_SPS_UNUSED
22691             /* Update RBG mask for RA type 1 */
22692             raType1Mask[rbgSubset] |=  ueRaType1Mask;
22693             raType1UsedRbs[rbgSubset]++;
22694 #endif
22695             /* Update RA type 2 mask */
22696             raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22697             rbIdx++;
22698          }
22699          remNumRbs -= rbgInfo->lastRbgSize;
22700          ++numAllocRbgs;
22701       }
22702       /* Note: this should complete allocation, not checking for the
22703        * same */
22704    }
22705
22706    RETVALUE(numAllocRbgs);
22707 }
22708
22709 #ifdef RGSCH_SPS_UNUSED
22710 /**
22711  * @brief Handles RB allocation for Resource allocation type 1
22712  *
22713  * @details
22714  *
22715  *     Function : rgSCHCmnDlRaType1Alloc
22716  *
22717  *     Invoking Module Processing:
22718  *     - This function is invoked for DL RB allocation for resource allocation
22719  *     type 1
22720  *
22721  *     Processing Steps:
22722  *     - Determine the available positions in the subsets.
22723  *     - Allocate RB in the available subset.
22724  *     - Update RA Type1, RA type 0 and RA type 2 masks.
22725  *
22726  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22727  *  @param[in]   U8                 rbsReq
22728  *  @param[in]   RgSchBwRbgInfo     *rbgInfo
22729  *  @param[in]   U8                 startRbgSubset
22730  *  @param[in]   U8                 *allocRbgSubset
22731  *  @param[out]  rgSchDlSfAllocInfo *resAllocInfo
22732  *  @param[in]   Bool               isPartialAlloc
22733  *
22734  *  @return  U8
22735  *  Number of allocated RBs
22736  **/
22737
22738 #ifdef ANSI
22739 PUBLIC U8 rgSCHCmnDlRaType1Alloc
22740 (
22741 RgSchDlSfAllocInfo *allocedInfo,
22742 U8                 rbsReq,
22743 RgSchBwRbgInfo     *rbgInfo,
22744 U8                 startRbgSubset,
22745 U8                 *allocRbgSubset,
22746 RgSchDlSfAllocInfo *resAllocInfo,
22747 Bool               isPartialAlloc
22748 )
22749 #else
22750 PUBLIC U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
22751       allocRbgSubset, resAllocInfo, isPartialAlloc)
22752 RgSchDlSfAllocInfo *allocedInfo;
22753 U8                 rbsReq;
22754 RgSchBwRbgInfo     *rbgInfo;
22755 U8                 startRbgSubset;
22756 U8                 *allocRbgSubset;
22757 RgSchDlSfAllocInfo *resAllocInfo;
22758 Bool               isPartialAlloc;
22759 #endif
22760 {
22761    /* Note: This function atttempts only full allocation */
22762    U8          *rbgSubsetSzArr;
22763    U8          type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
22764    U8          offset, rbg, maskSize, bestSubsetIdx;
22765    U8          startPos = 0;
22766    U8          bestNumAvailRbs = 0;
22767    U8          numAllocRbs = 0;
22768    U32         ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
22769    U32         remNumRbs, allocedMask;
22770    U8          usedRbs = 0;
22771    U8          rbgSize = rbgInfo->rbgSize;
22772    U8          rbgSubset = startRbgSubset;
22773    U32         *rbgMask = &resAllocInfo->raType0Mask;
22774    U32         *raType1Mask = resAllocInfo->raType1Mask;
22775    U32         *raType2Mask = resAllocInfo->raType2Mask;
22776    U32         *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22777    U32         *allocMask = allocedInfo->raType1Mask;
22778
22779    /* Initialize the subset size Array */
22780    rbgSubsetSzArr = rbgInfo->rbgSubsetSize;
22781
22782    /* Perform allocation for RA type 1 */
22783    for (subsetIdx = 0;subsetIdx < rbgSize; ++subsetIdx)
22784    {
22785       allocedMask = allocMask[rbgSubset];
22786       maskSize = rbgSubsetSzArr[rbgSubset];
22787
22788       /* Determine number of available RBs in the subset */
22789       usedRbs = allocedInfo->raType1UsedRbs[subsetIdx];
22790       remNumRbs = maskSize - usedRbs;
22791
22792       if (remNumRbs >= rbsReq)
22793       {
22794          bestNumAvailRbs = rbsReq;
22795          bestSubsetIdx = rbgSubset;
22796          break;
22797       }
22798       else if (isPartialAlloc && (remNumRbs > bestNumAvailRbs))
22799       {
22800          bestNumAvailRbs = remNumRbs;
22801          bestSubsetIdx = rbgSubset;
22802       }
22803
22804       rbgSubset = (rbgSubset + 1) % rbgSize;
22805    } /* End of for (each rbgsubset) */
22806
22807    if (bestNumAvailRbs)
22808    {
22809       /* Initialize alloced mask and subsetSize depending on the RBG
22810        * subset of allocation */
22811       U8        startIdx = 0;
22812       maskSize = rbgSubsetSzArr[bestSubsetIdx];
22813       allocedMask = allocMask[bestSubsetIdx];
22814       RG_SCH_CMN_DL_GET_START_POS(allocedMask, maskSize,
22815             &startPos);
22816       for (; startIdx < rbgSize; ++startIdx, ++startPos)
22817       {
22818          for (rbInSubset = startPos; rbInSubset < maskSize;
22819                rbInSubset = rbInSubset + rbgSize)
22820          {
22821             rbPosInSubset =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
22822             if (!(allocedMask & rbPosInSubset))
22823             {
22824                raType1Mask[bestSubsetIdx] |= rbPosInSubset;
22825                raType1UsedRbs[bestSubsetIdx]++;
22826
22827                /* Compute RB index value for the RB being allocated */
22828                rbgInSubset = rbInSubset /rbgSize;
22829                offset = rbInSubset % rbgSize;
22830                rbg = (rbgInSubset * rbgSize) + bestSubsetIdx;
22831                rbIdx = (rbg * rbgSize) + offset;
22832
22833                /* Update RBG mask for RA type 0 allocation */
22834                ueRaType0Mask = rgSCHCmnGetRaType0Mask(rbIdx, rbgSize);
22835                *rbgMask |= ueRaType0Mask;
22836
22837                /* Update RA type 2 mask */
22838                ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22839                raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22840
22841                /* Update the counters */
22842                numAllocRbs++;
22843                remNumRbs--;
22844                if (numAllocRbs == bestNumAvailRbs)
22845                {
22846                   break;
22847                }
22848             }
22849          } /* End of for (each position in the subset mask) */
22850          if (numAllocRbs == bestNumAvailRbs)
22851          {
22852             break;
22853          }
22854       } /* End of for startIdx = 0 to rbgSize */
22855
22856       *allocRbgSubset = bestSubsetIdx;
22857    } /* End of if (bestNumAvailRbs) */
22858
22859    RETVALUE(numAllocRbs);
22860 }
22861 #endif
22862 /**
22863  * @brief Handles RB allocation for Resource allocation type 2
22864  *
22865  * @details
22866  *
22867  *     Function : rgSCHCmnDlRaType2Alloc
22868  *
22869  *     Invoking Module Processing:
22870  *     - This function is invoked for DL RB allocation for resource allocation
22871  *     type 2
22872  *
22873  *     Processing Steps:
22874  *     - Determine the available positions in the mask
22875  *     - Allocate best fit cosecutive RBs.
22876  *     - Update RA Type2, RA type 1 and RA type 0 masks.
22877  *
22878  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22879  *  @param[in]   U8             rbsReq
22880  *  @param[in]   RgSchBwRbgInfo *rbgInfo
22881  *  @param[out]  U8             *rbStart
22882  *  @param[out]  rgSchDlSfAllocInfo *resAllocInfo
22883  *  @param[in]   Bool           isPartialAlloc
22884  *
22885  *  @return  U8
22886  *  Number of allocated RBs
22887  **/
22888
22889 #ifdef ANSI
22890 PUBLIC U8 rgSCHCmnDlRaType2Alloc
22891 (
22892 RgSchDlSfAllocInfo *allocedInfo,
22893 U8                 rbsReq,
22894 RgSchBwRbgInfo     *rbgInfo,
22895 U8                 *rbStart,
22896 RgSchDlSfAllocInfo *resAllocInfo,
22897 Bool               isPartialAlloc
22898 )
22899 #else
22900 PUBLIC U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
22901       resAllocInfo, isPartialAlloc)
22902 RgSchDlSfAllocInfo *allocedInfo;
22903 U8                 rbsReq;
22904 RgSchBwRbgInfo     *rbgInfo;
22905 U8                 *rbStart;
22906 RgSchDlSfAllocInfo *resAllocInfo;
22907 Bool               isPartialAlloc;
22908 #endif
22909 {
22910    U8          numAllocRbs = 0;
22911    U8          rbIdx;
22912    U8          rbgSize = rbgInfo->rbgSize;
22913    U32         *rbgMask = &resAllocInfo->raType0Mask;
22914 #ifdef RGSCH_SPS_UNUSED
22915    U32         *raType1Mask = resAllocInfo->raType1Mask;
22916 #endif
22917    U32         *raType2Mask = resAllocInfo->raType2Mask;
22918 #ifdef RGSCH_SPS_UNUSED
22919    U32         *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22920 #endif
22921    U32         *allocedMask = allocedInfo->raType2Mask;
22922
22923    /* Note: This function atttempts only full allocation */
22924    rgSCHCmnDlGetBestFitHole(allocedMask, rbgInfo->numRbs,
22925          raType2Mask, rbsReq, rbStart, &numAllocRbs, isPartialAlloc);
22926    if (numAllocRbs)
22927    {
22928       /* Update the allocation in RA type 0 and RA type 1 masks */
22929       U8 rbCnt = numAllocRbs;
22930 #ifdef RGSCH_SPS_UNUSED
22931       U8 rbgSubset;
22932       U32 ueRaType1Mask;
22933 #endif
22934       U32 ueRaType0Mask;
22935       rbIdx = *rbStart;
22936
22937       while(rbCnt)
22938       {
22939          /* Update RBG mask for RA type 0 allocation */
22940          ueRaType0Mask = rgSCHCmnGetRaType0Mask(rbIdx, rbgSize);
22941          *rbgMask |= ueRaType0Mask;
22942
22943 #ifdef RGSCH_SPS_UNUSED
22944          /* Update RBG mask for RA type 1 */
22945          ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22946          raType1Mask[rbgSubset] |= ueRaType1Mask;
22947          raType1UsedRbs[rbgSubset]++;
22948 #endif
22949          /* Update the counters */
22950          --rbCnt;
22951          rbIdx++;
22952       }
22953    }
22954
22955    RETVALUE(numAllocRbs);
22956 }
22957
22958 /**
22959  * @brief Determines RA type 0 mask from given RB index.
22960  *
22961  * @details
22962  *
22963  *     Function : rgSCHCmnGetRaType0Mask
22964  *
22965  *
22966  *     Processing Steps:
22967  *     - Determine RA Type 0 mask for given rbIdex and rbg size.
22968  *
22969  *  @param[in]  U8          rbIdx
22970  *  @param[in]  U8          rbgSize
22971  *  @return  U32 RA type 0 mask
22972  **/
22973 #ifdef ANSI
22974 PRIVATE U32 rgSCHCmnGetRaType0Mask
22975 (
22976 U8                rbIdx,
22977 U8                rbgSize
22978 )
22979 #else
22980 PRIVATE U32 rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
22981 U8                rbIdx;
22982 U8                rbgSize;
22983 #endif
22984 {
22985    U8 rbg;
22986    U32 rbgPosInRbgMask = 0;
22987
22988    rbg = rbIdx/rbgSize;
22989    rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22990
22991    RETVALUE(rbgPosInRbgMask);
22992 }
22993
22994 #ifdef RGSCH_SPS_UNUSED
22995 /**
22996  * @brief Determines RA type 1 mask from given RB index.
22997  *
22998  * @details
22999  *
23000  *     Function : rgSCHCmnGetRaType1Mask
23001  *
23002  *
23003  *     Processing Steps:
23004  *     - Determine RA Type 1 mask for given rbIdex and rbg size.
23005  *
23006  *  @param[in]  U8          rbIdx
23007  *  @param[in]  U8          rbgSize
23008  *  @param[out] U8          *type1Subset
23009  *  @return  U32 RA type 1 mask
23010  **/
23011 #ifdef ANSI
23012 PRIVATE U32 rgSCHCmnGetRaType1Mask
23013 (
23014 U8                rbIdx,
23015 U8                rbgSize,
23016 U8                *type1Subset
23017 )
23018 #else
23019 PRIVATE U32 rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
23020 U8                rbIdx;
23021 U8                rbgSize;
23022 U8                *type1Subset;
23023 #endif
23024 {
23025    U8 rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
23026    U32 rbPosInSubset;
23027
23028    rbg = rbIdx/rbgSize;
23029    rbgSubset = rbg % rbgSize;
23030    rbgInSubset = rbg/rbgSize;
23031    offset = rbIdx % rbgSize;
23032    rbInSubset = rbgInSubset * rbgSize + offset;
23033    rbPosInSubset =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
23034
23035    *type1Subset = rbgSubset;
23036    RETVALUE(rbPosInSubset);
23037 } 
23038 #endif /* RGSCH_SPS_UNUSED */
23039 /**
23040  * @brief Determines RA type 2 mask from given RB index.
23041  *
23042  * @details
23043  *
23044  *     Function : rgSCHCmnGetRaType2Mask
23045  *
23046  *
23047  *     Processing Steps:
23048  *     - Determine RA Type 2 mask for given rbIdx and rbg size.
23049  *
23050  *  @param[in]  U8          rbIdx
23051  *  @param[out] U8          *maskIdx
23052  *  @return  U32 RA type 2 mask
23053  **/
23054 #ifdef ANSI
23055 PRIVATE U32 rgSCHCmnGetRaType2Mask
23056 (
23057 U8                rbIdx,
23058 U8                *maskIdx
23059 )
23060 #else
23061 PRIVATE U32 rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
23062 U8                rbIdx;
23063 U8                *maskIdx;
23064 #endif
23065 {
23066    U32 rbPosInType2;
23067
23068    *maskIdx = rbIdx / 32;
23069    rbPosInType2 =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
23070
23071    RETVALUE(rbPosInType2);
23072 }
23073
23074 /**
23075  * @brief Performs resource allocation for a non-SPS UE in SPS bandwidth
23076  *
23077  * @details
23078  *
23079  *     Function : rgSCHCmnAllocUeInSpsBw
23080  *
23081  *
23082  *     Processing Steps:
23083  *       - Determine allocation for the UE.
23084  *       - Use resource allocation type 0, 1 and 2 for allocation
23085  *         within maximum SPS bandwidth.
23086  *
23087  *  @param[in]  RgSchDlSf       *dlSf
23088  *  @param[in]  RgSchCellCb     *cell
23089  *  @param[in]  RgSchUeCb       *ue
23090  *  @param[in]  RgSchDlRbAlloc  *rbAllocInfo
23091  *  @param[in]  Bool            isPartialAlloc
23092  *  @return  Bool
23093  *             ROK      success
23094  *             RFAILED  failed
23095  **/
23096 #ifdef ANSI
23097 PUBLIC Bool rgSCHCmnAllocUeInSpsBw
23098 (
23099 RgSchDlSf           *dlSf,
23100 RgSchCellCb         *cell,
23101 RgSchUeCb           *ue,
23102 RgSchDlRbAlloc      *rbAllocInfo,
23103 Bool                isPartialAlloc
23104 )
23105 #else
23106 PUBLIC Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
23107 RgSchDlSf           *dlSf;
23108 RgSchCellCb         *cell;
23109 RgSchUeCb           *ue;
23110 RgSchDlRbAlloc      *rbAllocInfo;
23111 Bool                isPartialAlloc;
23112 #endif
23113 {
23114    U8                  rbgSize = cell->rbgSize;
23115    U8                  numAllocRbs = 0;
23116    U8                  numAllocRbgs = 0;
23117    U8                  rbStart = 0;
23118    U8                  idx, noLyr, iTbs;
23119    RgSchCmnDlUe        *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
23120    RgSchDlSfAllocInfo  *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
23121    RgSchBwRbgInfo      *spsRbgInfo = &cell->spsBwRbgInfo;
23122
23123    /* SPS_FIX : Check if this Hq proc is scheduled */
23124    if ((0 == rbAllocInfo->tbInfo[0].schdlngForTb) &&
23125          (0 == rbAllocInfo->tbInfo[1].schdlngForTb))
23126    {
23127       RETVALUE(TRUE);
23128    }
23129
23130    /* Check if the requirement can be accomodated in SPS BW */
23131    if (dlSf->spsAllocdBw == spsRbgInfo->numRbs)
23132    {
23133       /* SPS Bandwidth has been exhausted: no further allocations possible */
23134       RETVALUE(FALSE);
23135    }
23136    if (!isPartialAlloc)
23137    {
23138       if((dlSf->spsAllocdBw + rbAllocInfo->rbsReq) > spsRbgInfo->numRbs)
23139       {
23140          RETVALUE(TRUE);
23141       }
23142    }
23143
23144    /* Perform allocation for RA type 0 if rbsReq is multiple of RBG size (also
23145     * if RBG size = 1) */
23146    if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23147    {
23148       rbAllocInfo->rbsReq += (rbgSize - rbAllocInfo->rbsReq % rbgSize);
23149       numAllocRbgs = rgSCHCmnDlRaType0Alloc(dlSfAlloc,
23150             rbAllocInfo->rbsReq, spsRbgInfo, &numAllocRbs,
23151             &rbAllocInfo->resAllocInfo, isPartialAlloc);
23152    }
23153 #ifdef RGSCH_SPS_UNUSED
23154    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE1)
23155    {
23156       /* If no RBS could be allocated, attempt RA TYPE 1 */
23157
23158       numAllocRbs = rgSCHCmnDlRaType1Alloc(dlSfAlloc,
23159             rbAllocInfo->rbsReq, spsRbgInfo, (U8)dlSfAlloc->nxtRbgSubset,
23160             &rbAllocInfo->allocInfo.raType1.rbgSubset,
23161             &rbAllocInfo->resAllocInfo, isPartialAlloc);
23162
23163       if(numAllocRbs)
23164       {
23165          dlSfAlloc->nxtRbgSubset =
23166             (rbAllocInfo->allocInfo.raType1.rbgSubset + 1 ) % rbgSize;
23167       }
23168    }
23169 #endif
23170    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23171    {
23172       numAllocRbs = rgSCHCmnDlRaType2Alloc(dlSfAlloc,
23173             rbAllocInfo->rbsReq, spsRbgInfo,
23174             &rbStart, &rbAllocInfo->resAllocInfo, isPartialAlloc);
23175    }
23176    if (!numAllocRbs)
23177    {
23178       RETVALUE(TRUE);
23179    }
23180
23181    if (!(rbAllocInfo->pdcch =
23182             rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi,\
23183                rbAllocInfo->dciFormat, FALSE)))
23184    {
23185       /* Note: Returning TRUE since PDCCH might be available for another UE */
23186       RETVALUE(TRUE);
23187    }
23188
23189    /* Update Tb info for each scheduled TB */
23190    iTbs = rbAllocInfo->tbInfo[0].iTbs;
23191    noLyr = rbAllocInfo->tbInfo[0].noLyr;
23192    rbAllocInfo->tbInfo[0].bytesAlloc =
23193       rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;
23194
23195    if (rbAllocInfo->tbInfo[1].schdlngForTb)
23196    {
23197       iTbs = rbAllocInfo->tbInfo[1].iTbs;
23198       noLyr = rbAllocInfo->tbInfo[1].noLyr;
23199       rbAllocInfo->tbInfo[1].bytesAlloc =
23200          rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;;
23201    }
23202
23203    /* Update rbAllocInfo with the allocation information */
23204    if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23205    {
23206       rbAllocInfo->allocInfo.raType0.dlAllocBitMask =
23207          rbAllocInfo->resAllocInfo.raType0Mask;
23208       rbAllocInfo->allocInfo.raType0.numDlAlloc = numAllocRbgs;
23209    }
23210 #ifdef RGSCH_SPS_UNUSED
23211    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE1)
23212    {
23213       rbAllocInfo->allocInfo.raType1.dlAllocBitMask =
23214          rbAllocInfo->resAllocInfo.raType1Mask[rbAllocInfo->allocInfo.raType1.rbgSubset];
23215       rbAllocInfo->allocInfo.raType1.numDlAlloc = numAllocRbs;
23216       rbAllocInfo->allocInfo.raType1.shift = 0;
23217    }
23218 #endif
23219    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23220    {
23221       rbAllocInfo->allocInfo.raType2.isLocal = TRUE;
23222       rbAllocInfo->allocInfo.raType2.rbStart = rbStart;
23223       rbAllocInfo->allocInfo.raType2.numRb = numAllocRbs;
23224    }
23225
23226    rbAllocInfo->rbsAlloc = numAllocRbs;
23227    rbAllocInfo->tbInfo[0].schdlngForTb = TRUE;
23228
23229    /* Update allocation masks for RA types 0, 1 and 2 in DL SF */
23230
23231    /* Update type 0 allocation mask */
23232    dlSfAlloc->raType0Mask |= rbAllocInfo->resAllocInfo.raType0Mask;
23233 #ifdef RGSCH_SPS_UNUSED
23234    /* Update type 1 allocation masks */
23235    for (idx = 0; idx < RG_SCH_NUM_RATYPE1_32BIT_MASK; ++idx)
23236    {
23237       dlSfAlloc->raType1Mask[idx] |= rbAllocInfo->resAllocInfo.raType1Mask[idx];
23238       dlSfAlloc->raType1UsedRbs[idx] +=
23239          rbAllocInfo->resAllocInfo.raType1UsedRbs[idx];
23240    }
23241 #endif
23242    /* Update type 2 allocation masks */
23243    for (idx = 0; idx < RG_SCH_NUM_RATYPE2_32BIT_MASK; ++idx)
23244    {
23245       dlSfAlloc->raType2Mask[idx] |= rbAllocInfo->resAllocInfo.raType2Mask[idx];
23246    }
23247
23248    dlSf->spsAllocdBw += numAllocRbs;
23249    RETVALUE(TRUE);
23250 }
23251
23252 /***********************************************************
23253  *
23254  *     Func : rgSCHCmnDlGetBestFitHole
23255  *
23256  *
23257  *     Desc : Converts the best fit hole into allocation and returns the
23258  *     allocation information.
23259  *
23260  *
23261  *     Ret  : Void
23262  *
23263  *
23264  *     Notes:
23265  *
23266  *     File :
23267  *
23268  **********************************************************/
23269 #ifdef ANSI
23270 PRIVATE Void rgSCHCmnDlGetBestFitHole
23271 (
23272 U32         *allocMask,
23273 U8          numMaskRbs,
23274 U32         *crntAllocMask,
23275 U8          rbsReq,
23276 U8          *allocStart,
23277 U8          *allocNumRbs,
23278 Bool        isPartialAlloc
23279 )
23280 #else
23281 PRIVATE  Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
23282         crntAllocMask, rbsReq, allocStart, allocNumRbs, isPartialAlloc)
23283 U32         *allocMask;
23284 U8          numMaskRbs;
23285 U32         *crntAllocMask;
23286 U8          rbsReq;
23287 U8          *allocStart;
23288 U8          *allocNumRbs;
23289 Bool        isPartialAlloc;
23290 #endif
23291 {
23292    U8 maskSz = (numMaskRbs + 31)/32;
23293    U8 maxMaskPos = (numMaskRbs % 32);
23294    U8 maskIdx, maskPos;
23295    U8 numAvailRbs = 0;
23296    U8 bestAvailNumRbs = 0;
23297    S8 bestStartPos = -1;
23298    S8 startPos = -1;
23299    U32 tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
23300    U32 bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
23301
23302    *allocNumRbs = numAvailRbs;
23303    *allocStart = 0;
23304
23305    for (maskIdx = 0; maskIdx < maskSz; ++maskIdx)
23306    {
23307       maxMaskPos = 31;
23308       if (maskIdx == (maskSz - 1))
23309       {
23310          if (numMaskRbs % 32)
23311          {
23312             maxMaskPos = numMaskRbs % 32;
23313          }
23314       }
23315       for (maskPos = 0; maskPos < maxMaskPos; ++maskPos)
23316       {
23317          if (!(allocMask[maskIdx] & (1 << (31 - maskPos))))
23318          {
23319             tmpMask[maskIdx] |= (1 << (31 - maskPos));
23320             if (startPos == -1)
23321             {
23322                startPos = maskIdx * 32 + maskPos;
23323             }
23324             ++numAvailRbs;
23325             if (numAvailRbs == rbsReq)
23326             {
23327                *allocStart = (U8)startPos;
23328                *allocNumRbs = rbsReq;
23329                break;
23330             }
23331          }
23332          else
23333          {
23334             if (numAvailRbs > bestAvailNumRbs)
23335             {
23336                bestAvailNumRbs = numAvailRbs;
23337                bestStartPos = startPos;
23338                cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
23339             }
23340             numAvailRbs = 0;
23341             startPos = -1;
23342             cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
23343          }
23344       }
23345       if (*allocNumRbs == rbsReq)
23346       {
23347          break;
23348       }
23349    }
23350
23351    if (*allocNumRbs == rbsReq)
23352    {
23353       /* Convert the hole into allocation */
23354       cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
23355       RETVOID;
23356    }
23357    else
23358    {
23359       if (bestAvailNumRbs && isPartialAlloc)
23360       {
23361          /* Partial allocation could have been done */
23362          *allocStart = (U8)bestStartPos;
23363          *allocNumRbs = bestAvailNumRbs;
23364          /* Convert the hole into allocation */
23365          cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
23366       }
23367    }
23368
23369    RETVOID;
23370 }
23371 #endif /* LTEMAC_SPS */
23372
23373 /***************************************************************************
23374  *
23375  * NON-DLFS Allocation functions
23376  *
23377  * *************************************************************************/
23378 #ifndef LTE_TDD
23379 #ifdef DEBUGP
23380 /**
23381  * @brief Function to find out code rate
23382  *
23383  * @details
23384  *
23385  *     Function : rgSCHCmnFindCodeRate
23386  *
23387  *     Processing Steps:
23388  *
23389  *  @param[in]      RgSchCellCb     *cell
23390  *  @param[in]      RgSchDlSf       *dlSf
23391  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23392  *  @return  void
23393  **/
23394 #ifdef UNUSE_FUN
23395 #ifdef ANSI
23396 PRIVATE Void rgSCHCmnFindCodeRate
23397 (
23398 RgSchCellCb           *cell,
23399 RgSchDlSf             *dlSf,
23400 RgSchDlRbAlloc        *allocInfo,
23401 U8                    idx
23402 )
23403 #else
23404 PRIVATE Void rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,idx)
23405 RgSchCellCb           *cell;
23406 RgSchDlSf             *dlSf;
23407 RgSchDlRbAlloc        *allocInfo;
23408 U8                    idx;
23409 #endif
23410 {
23411     RETVOID;
23412
23413 }
23414 #endif
23415
23416 /* Adjust the Imcs and bytes allocated also with respect to the adjusted
23417    RBs - Here we will find out the Imcs by identifying first Highest
23418    number of bits compared to the original bytes allocated.  */
23419 /**
23420  * @brief Adjust IMCS according to tbSize and ITBS
23421  *
23422  * @details
23423  *
23424  *     Function : rgSCHCmnNonDlfsPbchTbImcsAdj
23425  *
23426  *     Processing Steps:
23427  *      - Adjust Imcs according to tbSize and ITBS.
23428  *
23429  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23430  *  @param[in]      U8              *idx
23431  *  @return  void
23432  **/
23433 #ifdef ANSI
23434 PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj
23435 (
23436 RgSchCellCb      *cell,
23437 RgSchDlRbAlloc   *allocInfo,
23438 U8               idx,
23439 U8               rbsReq
23440 )
23441 #else
23442 PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj(cell,allocInfo, idx, rbsReq)
23443 RgSchCellCb      *cell;
23444 RgSchDlRbAlloc   *allocInfo;
23445 U8               idx;
23446 U8               rbsReq;
23447 #endif
23448 {
23449    U8             noLyrs = 0;
23450    U8             tbs = 0;
23451    U32            origBytesReq;
23452    U8             noRbgs = 0;
23453    U8             noRbs = 0;
23454    RgSchDlSf     *dlSf = allocInfo->dlSf;
23455
23456    RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
23457    noLyrs = allocInfo->tbInfo[idx].noLyr;
23458
23459    if((allocInfo->raType == RG_SCH_CMN_RA_TYPE0))
23460    {
23461       noRbgs = RGSCH_CEIL((allocInfo->rbsReq + dlSf->lstRbgDfct), cell->rbgSize);
23462       noRbs = (noRbgs * cell->rbgSize) - dlSf->lstRbgDfct;
23463    }
23464    else
23465    {
23466        noRbs = allocInfo->rbsReq;
23467    }
23468
23469    /* This line will help in case if tbs is zero and reduction in MCS is not possible */
23470    if (allocInfo->rbsReq == 0 )
23471    {
23472       RETVOID;
23473    }
23474    origBytesReq = rgTbSzTbl[noLyrs - 1][tbs][rbsReq - 1]/8;
23475
23476    /* Find out the ITbs & Imcs by identifying first Highest
23477       number of bits compared to the original bytes allocated.*/
23478    if(tbs > 0)
23479    {
23480       if(((rgTbSzTbl[noLyrs - 1][0][noRbs - 1])/8) < origBytesReq)
23481       {
23482           RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[noLyrs - 1], tbs);
23483           while(((rgTbSzTbl[noLyrs - 1][tbs][noRbs - 1])/8) > origBytesReq)
23484           {
23485               tbs--;
23486           }
23487       }
23488       else
23489       {
23490           tbs = 0;
23491       }
23492       allocInfo->tbInfo[idx].bytesReq = rgTbSzTbl[noLyrs - 1][tbs][noRbs - 1]/8;
23493       allocInfo->tbInfo[idx].iTbs = tbs;
23494       RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
23495    }
23496
23497    RETVOID;
23498 }
23499 /* Added funcion to adjust TBSize*/
23500 /**
23501  * @brief Function to adjust the tbsize in case of subframe 0 & 5 when
23502  * we were not able to do RB alloc adjustment by adding extra required Rbs
23503  *
23504  * @details
23505  *
23506  *     Function : rgSCHCmnNonDlfsPbchTbSizeAdj
23507  *
23508  *     Processing Steps:
23509  *
23510  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23511  *  @param[in]      U8            numOvrlapgPbchRb
23512  *  @param[in]      U8            idx
23513  *  @param[in]      U8            pbchSsRsSym
23514  *  @return  void
23515  **/
23516 #ifdef ANSI
23517 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj
23518 (
23519 RgSchDlRbAlloc        *allocInfo,
23520 U8                    numOvrlapgPbchRb,
23521 U8                    pbchSsRsSym,
23522 U8                    idx,
23523 U32                   bytesReq
23524 )
23525 #else
23526 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,idx,bytesReq)
23527 RgSchDlRbAlloc        *allocInfo;
23528 U8                    numOvrlapgPbchRb;
23529 U8                    pbchSsRsSym;
23530 U8                    idx;
23531 U32                   bytesReq;
23532 #endif
23533 {
23534    U32             reducedTbs = 0;
23535    U8              noLyrs = 0;
23536    U8              tbs = 0;
23537
23538    noLyrs = allocInfo->tbInfo[idx].noLyr;
23539
23540    RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
23541
23542    reducedTbs = bytesReq - (((U32)numOvrlapgPbchRb * (U32)pbchSsRsSym * 6)/8);
23543
23544    /* find out the ITbs & Imcs by identifying first Highest
23545     number of bits compared with reduced bits considering the bits that are
23546     reserved for PBCH/PSS/SSS */
23547    if(((rgTbSzTbl[noLyrs - 1][0][allocInfo->rbsReq - 1])/8) < reducedTbs)
23548    {
23549        while(((rgTbSzTbl[noLyrs - 1][tbs][allocInfo->rbsReq - 1])/8) > reducedTbs)
23550        {
23551            tbs--;
23552        }
23553    }
23554    else
23555    {
23556        tbs = 0;
23557    }
23558    allocInfo->tbInfo[idx].bytesReq = rgTbSzTbl[noLyrs - 1][tbs][allocInfo->rbsReq - 1]/8;
23559    allocInfo->tbInfo[idx].iTbs = tbs;
23560    RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
23561
23562    RETVOID;
23563 }
23564
23565 /* Added this function to find num of ovrlapping PBCH rb*/
23566 /**
23567  * @brief Function to find out how many additional rbs are available
23568  *    in the entire bw which can be allocated to a UE
23569  * @details
23570  *
23571  *     Function : rgSCHCmnFindNumAddtlRbsAvl
23572  *
23573  *     Processing Steps:
23574  *      - Calculates number of additinal rbs available
23575  *
23576  *  @param[in]      RgSchCellCb     *cell
23577  *  @param[in]      RgSchDlSf       *dlSf
23578  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23579  *  @param[out]      U8            addtlRbsAvl
23580  *  @return  void
23581  **/
23582 #ifdef ANSI
23583 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl
23584 (
23585 RgSchCellCb           *cell,
23586 RgSchDlSf             *dlSf,
23587 RgSchDlRbAlloc        *allocInfo
23588 )
23589 #else
23590 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
23591 RgSchCellCb           *cell;
23592 RgSchDlSf             *dlSf;
23593 RgSchDlRbAlloc        *allocInfo;
23594 #endif
23595 {
23596     U8 addtlRbsAvl = 0;
23597
23598     TRC2(rgSCHCmnFindNumAddtlRbsAvl)
23599
23600     if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23601     {
23602          addtlRbsAvl = (((dlSf->type0End - dlSf->type2End + 1)*\
23603                         cell->rbgSize) - dlSf->lstRbgDfct) - allocInfo->rbsReq;
23604     }
23605     else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23606     {
23607        addtlRbsAvl = (dlSf->bw - dlSf->bwAlloced) - allocInfo->rbsReq;
23608     }
23609
23610     RETVALUE(addtlRbsAvl);
23611
23612 }
23613 /* Added this function to find num of ovrlapping PBCH rb*/
23614 /**
23615  * @brief Function to find out how many of the requested RBs are
23616  *        falling in the center 6 RBs of the downlink bandwidth.
23617  * @details
23618  *
23619  *     Function : rgSCHCmnFindNumPbchOvrlapRbs
23620  *
23621  *     Processing Steps:
23622  *      - Calculates number of overlapping rbs
23623  *
23624  *  @param[in]      RgSchCellCb     *cell
23625  *  @param[in]      RgSchDlSf       *dlSf
23626  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23627  *  @param[out]      U8*            numOvrlapgPbchRb
23628  *  @return  void
23629  **/
23630 #ifdef ANSI
23631 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs
23632 (
23633 RgSchCellCb           *cell,
23634 RgSchDlSf             *dlSf,
23635 RgSchDlRbAlloc        *allocInfo,
23636 U8                    *numOvrlapgPbchRb
23637 )
23638 #else
23639 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,numOvrlapgPbchRb)
23640 RgSchCellCb           *cell;
23641 RgSchDlSf             *dlSf;
23642 RgSchDlRbAlloc        *allocInfo;
23643 U8                    *numOvrlapgPbchRb;
23644 #endif
23645 {
23646     *numOvrlapgPbchRb = 0;
23647     TRC2(rgSCHCmnFindNumPbchOvrlapRbs)
23648    /*Find if we have already crossed the start boundary for PBCH 6 RBs,
23649     * if yes then lets find the number of RBs which are getting overlapped
23650     * with this allocation.*/
23651    if(dlSf->bwAlloced <= (cell->pbchRbStart))
23652    {
23653       /*We have not crossed the start boundary of PBCH RBs. Now we need
23654        * to know that if take this allocation then how much PBCH RBs
23655        * are overlapping with this allocation.*/
23656       /* Find out the overlapping RBs in the centre 6 RBs */
23657        if((dlSf->bwAlloced + allocInfo->rbsReq) > cell->pbchRbStart)
23658        {
23659            *numOvrlapgPbchRb = (dlSf->bwAlloced + allocInfo->rbsReq) - (cell->pbchRbStart);
23660            if(*numOvrlapgPbchRb > 6)
23661                 *numOvrlapgPbchRb = 6;
23662        }
23663    }
23664    else if ((dlSf->bwAlloced > (cell->pbchRbStart)) &&
23665          (dlSf->bwAlloced < (cell->pbchRbEnd)))
23666    {
23667       /*We have already crossed the start boundary of PBCH RBs.We need to
23668        * find that if we take this allocation then how much of the RBs for
23669        * this allocation will overlap with PBCH RBs.*/
23670       /* Find out the overlapping RBs in the centre 6 RBs */
23671       if(dlSf->bwAlloced + allocInfo->rbsReq < (cell->pbchRbEnd))
23672       {
23673          /*If we take this allocation then also we are not crossing the
23674           * end boundary of PBCH 6 RBs.*/
23675          *numOvrlapgPbchRb = allocInfo->rbsReq;
23676       }
23677       else
23678       {
23679          /*If we take this allocation then we are crossing the
23680           * end boundary of PBCH 6 RBs.*/
23681          *numOvrlapgPbchRb = (cell->pbchRbEnd) - dlSf->bwAlloced;
23682       }
23683    }
23684     RETVOID;
23685
23686 }
23687 /**
23688  * @brief Performs RB allocation adjustment if the requested RBs are
23689  *        falling in the center 6 RBs of the downlink bandwidth.
23690  * @details
23691  *
23692  *     Function : rgSCHCmnNonDlfsPbchRbAllocAdj
23693  *
23694  *     Processing Steps:
23695  *      - Allocate consecutively available RBs.
23696  *
23697  *  @param[in]      RgSchCellCb     *cell
23698  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23699  *  @param[in]      U8               pbchSsRsSym
23700  *  @return  void
23701  **/
23702 #ifdef ANSI
23703 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj
23704 (
23705 RgSchCellCb      *cell,
23706 RgSchDlRbAlloc   *allocInfo,
23707 U8               pbchSsRsSym,
23708 Bool             isBcchPcch
23709 )
23710 #else
23711 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo,pbchSsRsSym)
23712 RgSchCellCb      *cell;
23713 RgSchDlRbAlloc   *allocInfo;
23714 U8               pbchSsRsSym;
23715 Bool             isBcchPcch;
23716 #endif
23717 {
23718    RgSchDlSf     *dlSf = allocInfo->dlSf;
23719    U8             numOvrlapgPbchRb = 0;
23720    U8             numOvrlapgAdtlPbchRb = 0;
23721    U8             totSym;
23722    U8             addtlRbsReq = 0;
23723    U8             moreAddtlRbsReq = 0;
23724    U8             addtlRbsAdd = 0;
23725    U8             moreAddtlRbsAdd = 0;
23726    U8             tbs;
23727    U8             origRbsReq = 0;
23728    U32            bytesReq;
23729    U8             noLyr;
23730    U8             divResult;
23731
23732
23733    TRC2(rgSCHCmnNonDlfsPbchRbAllocAdj);
23734
23735
23736    origRbsReq = allocInfo->rbsReq;
23737    rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,&numOvrlapgPbchRb);
23738
23739   totSym =  (cell->isCpDlExtend) ? RGSCH_TOT_NUM_SYM_EXTCP : RGSCH_TOT_NUM_SYM_NORCP;
23740
23741    /* Additional RBs are allocated by considering the loss due to
23742       the reserved symbols for CFICH, PBCH, PSS, SSS and cell specific RS */
23743
23744    divResult = (numOvrlapgPbchRb * pbchSsRsSym)/totSym;
23745    if((numOvrlapgPbchRb * pbchSsRsSym) % totSym)
23746    {
23747       divResult++;
23748    }
23749    addtlRbsReq = divResult;
23750
23751    RG_SCH_CMN_UPD_RBS_TO_ADD(cell, dlSf, allocInfo, addtlRbsReq, addtlRbsAdd)
23752
23753    /*Now RBs requires is original requested RBs + these additional RBs to make
23754     * up for PSS/SSS/BCCH.*/
23755    allocInfo->rbsReq = allocInfo->rbsReq + addtlRbsAdd;
23756
23757    /*Check if with these additional RBs we have taken up, these are also falling
23758     * under PBCH RBs range, if yes then we would need to account for
23759     * PSS/BSS/BCCH for these additional RBs too.*/
23760    if(addtlRbsAdd && ((dlSf->bwAlloced + allocInfo->rbsReq - addtlRbsAdd) < (cell->pbchRbEnd)))
23761    {
23762       if((dlSf->bwAlloced + allocInfo->rbsReq) <= (cell->pbchRbEnd))
23763       {
23764       /*With additional RBs taken into account, we are not crossing the
23765        * PBCH RB end boundary.Thus here we need to account just for
23766        * overlapping PBCH RBs for these additonal RBs.*/
23767           divResult = (addtlRbsAdd * pbchSsRsSym)/totSym;
23768           if((addtlRbsAdd * pbchSsRsSym) % totSym)
23769           {
23770             divResult++;
23771           }
23772
23773           moreAddtlRbsReq = divResult;
23774
23775           RG_SCH_CMN_UPD_RBS_TO_ADD(cell, dlSf, allocInfo, moreAddtlRbsReq, moreAddtlRbsAdd)
23776
23777           allocInfo->rbsReq = allocInfo->rbsReq + moreAddtlRbsAdd;
23778       }
23779       else
23780       {
23781
23782          /*Here we have crossed the PBCH RB end boundary, thus we need to take
23783           * into account the overlapping RBs for additional RBs which will be
23784           * subset of addtlRbs.*/
23785           numOvrlapgAdtlPbchRb = (cell->pbchRbEnd) - ((dlSf->bwAlloced + allocInfo->rbsReq) -  addtlRbsAdd);
23786
23787           divResult = (numOvrlapgAdtlPbchRb * pbchSsRsSym)/totSym;
23788           if((numOvrlapgAdtlPbchRb * pbchSsRsSym) % totSym)
23789           {
23790              divResult++;
23791           }
23792
23793           moreAddtlRbsReq =  divResult;
23794
23795           RG_SCH_CMN_UPD_RBS_TO_ADD(cell, dlSf, allocInfo, moreAddtlRbsReq, moreAddtlRbsAdd)
23796
23797           allocInfo->rbsReq = allocInfo->rbsReq + moreAddtlRbsAdd;
23798       }
23799    }
23800    if (isBcchPcch == TRUE)
23801    {
23802       RETVOID;
23803    }
23804
23805    RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
23806    if(tbs == 6)
23807    {
23808       /* This case might be for Imcs value 6 and NPrb = 1 case  - Not
23809          Adjusting either RBs or Imcs or Bytes Allocated */
23810       allocInfo->rbsReq = allocInfo->rbsReq - addtlRbsAdd - moreAddtlRbsAdd;
23811    }
23812    else if(tbs && ((0 == addtlRbsAdd) && (moreAddtlRbsAdd == 0)))
23813    {
23814        /*In case of a situation where we the entire bandwidth is already occupied
23815         * and we dont have room to add additional Rbs then in order to decrease the
23816         * code rate we reduce the tbsize such that we reduce the present calculated
23817         * tbsize by number of bytes that would be occupied by PBCH/PSS/SSS in overlapping
23818         * rbs and find the nearest tbsize which would be less than this deduced value*/
23819
23820       rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,&numOvrlapgPbchRb);
23821
23822       noLyr = allocInfo->tbInfo[0].noLyr;
23823       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[noLyr - 1], tbs);
23824       bytesReq = rgTbSzTbl[noLyr - 1][tbs][allocInfo->rbsReq - 1]/8;
23825
23826       rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,0,bytesReq);
23827
23828       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23829       {
23830           noLyr = allocInfo->tbInfo[1].noLyr;
23831           bytesReq = rgTbSzTbl[noLyr - 1][tbs][allocInfo->rbsReq - 1]/8;
23832           rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,1,bytesReq);
23833       }
23834
23835    }
23836    else if(tbs && ((addtlRbsAdd != addtlRbsReq) ||
23837           (addtlRbsAdd && (moreAddtlRbsReq != moreAddtlRbsAdd))))
23838    {
23839        /*In case of a situation where we were not able to add required number of
23840         * additional RBs then we adjust the Imcs based on original RBs requested.
23841         * Doing this would comensate for the few extra Rbs we have added but inorder
23842         * to comensate for number of RBS we couldnt add we again do the TBSize adjustment*/
23843
23844       rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 0 , origRbsReq);
23845
23846       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23847       {
23848           rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 1 , origRbsReq);
23849       }
23850
23851       rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,&numOvrlapgPbchRb);
23852       numOvrlapgPbchRb = numOvrlapgPbchRb - (addtlRbsAdd + moreAddtlRbsAdd);
23853
23854       rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,0,allocInfo->tbInfo[0].bytesReq);
23855
23856       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23857       {
23858           rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,1,allocInfo->tbInfo[1].bytesReq);
23859       }
23860
23861    }
23862    else
23863    {
23864        /*We hit this code when we were able to add the required additional RBS
23865         * hence we should adjust the IMcs based on orignals RBs requested*/
23866
23867       rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 0 , origRbsReq);
23868
23869       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23870       {
23871           rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 1 , origRbsReq);
23872       }
23873    }
23874
23875    RETVOID;
23876 } /* end of rgSCHCmnNonDlfsPbchRbAllocAdj */
23877 #endif
23878 #endif
23879 /**
23880  * @brief Performs RB allocation for frequency non-selective cell.
23881  *
23882  * @details
23883  *
23884  *     Function : rgSCHCmnNonDlfsCmnRbAlloc
23885  *
23886  *     Processing Steps:
23887  *      - Allocate consecutively available RBs for BCCH/PCCH/RAR.
23888  *
23889  *  @param[in]      RgSchCellCb     *cell
23890  *  @param[in, out] RgSchDlRbAlloc  *allocInfo
23891  *  @return  S16
23892  *      -# ROK
23893  *      -# RFAILED
23894  **/
23895 #ifdef ANSI
23896 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc
23897 (
23898 RgSchCellCb      *cell,
23899 RgSchDlRbAlloc   *allocInfo
23900 )
23901 #else
23902 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
23903 RgSchCellCb      *cell;
23904 RgSchDlRbAlloc   *allocInfo;
23905 #endif
23906 {
23907 #ifndef LTE_TDD
23908 #ifdef LTEMAC_SPS
23909 #endif
23910    U8 pbchSsRsSym = 0;
23911    U8 pbchFrame = 0;
23912    U8  tbs = 0;
23913    RgSchCmnDlCell   *cellDl    = RG_SCH_CMN_GET_DL_CELL(cell); 
23914 #endif
23915    RgSchDlSf     *dlSf   = allocInfo->dlSf;
23916 #ifdef LTEMAC_SPS
23917    U8                  rbStart = 0;
23918    U8                  spsRbsAlloc = 0;
23919    RgSchDlSfAllocInfo  *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
23920 #endif
23921    TRC2(rgSCHCmnNonDlfsCmnRbAlloc);
23922
23923    allocInfo->tbInfo[0].noLyr = 1;
23924
23925 #ifdef LTEMAC_SPS
23926    /* Note: Initialize the masks to 0, this might not be needed since alloInfo
23927     * is initialized to 0 at the beginning of allcoation */
23928    allocInfo->resAllocInfo.raType0Mask = 0;
23929    cmMemset((U8*)allocInfo->resAllocInfo.raType1Mask, 0,
23930          RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
23931    cmMemset((U8*)allocInfo->resAllocInfo.raType2Mask, 0,
23932          RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
23933
23934    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
23935          (dlSf->bwAlloced == dlSf->bw))
23936 #else
23937    if(dlSf->bwAlloced == dlSf->bw)
23938 #endif
23939    {
23940       RETVALUE(RFAILED);
23941    }
23942 #ifndef LTE_TDD
23943    if (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced))
23944    {
23945 #ifdef LTEMAC_SPS
23946       if ((allocInfo->tbInfo[0].imcs < 29) && (dlSf->bwAlloced < dlSf->bw))
23947 #else
23948       if(allocInfo->tbInfo[0].imcs < 29)
23949 #endif
23950       {
23951          /* set the remaining RBs for the requested UE */
23952          allocInfo->rbsReq = dlSf->bw - dlSf->bwAlloced;
23953          RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
23954          allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[0][tbs][allocInfo->rbsReq - 1]/8;
23955       }
23956       else
23957       {
23958 #ifdef LTEMAC_SPS
23959          /* Attempt RA Type 2 allocation in SPS Bandwidth */
23960          if (dlSf->spsAllocdBw < cell->spsBwRbgInfo.numRbs) 
23961          {
23962             spsRbsAlloc =
23963                rgSCHCmnDlRaType2Alloc(dlSfAlloc,
23964                      allocInfo->rbsReq, &cell->spsBwRbgInfo, &rbStart,
23965                      &allocInfo->resAllocInfo, FALSE);
23966             /* rbsAlloc assignment moved from line 16671 to here to avoid
23967              * compilation error. Recheck */
23968             dlSf->spsAllocdBw += spsRbsAlloc;
23969          }
23970          if (!spsRbsAlloc)
23971 #endif /* LTEMAC_SPS */
23972          {
23973             RETVALUE(RFAILED);
23974          }
23975       }
23976    }
23977 #endif
23978
23979    /* Update allocation information */
23980    allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
23981    if (allocInfo->pdcch == NULLP)
23982    {
23983       RETVALUE(RFAILED);
23984    }
23985    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
23986    allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
23987    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
23988    allocInfo->allocInfo.raType2.isLocal = TRUE;
23989 #ifdef LTEMAC_SPS
23990    if (spsRbsAlloc) 
23991    {
23992       allocInfo->allocInfo.raType2.rbStart = rbStart;
23993       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
23994       allocInfo->rbsAlloc = allocInfo->rbsReq;
23995    }
23996 #endif
23997
23998 #ifdef LTEMAC_SPS
23999    if (!spsRbsAlloc)
24000    {
24001 #endif
24002 #ifndef LTE_TDD
24003       if(dlSf->sfNum)
24004       {
24005          if(!(dlSf->sfNum == 5))
24006          {
24007             /* case for subframes 1 to 9 except 5 */
24008 #ifdef LTEMAC_SPS
24009             allocInfo->allocInfo.raType2.rbStart = rbStart;
24010 #else
24011             /*Fix for ccpu00123918*/
24012             allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
24013 #endif
24014          }
24015          else
24016          {
24017             pbchFrame = 1; /* case for subframe 5 */
24018             /* In subframe 5, symbols are reserved for PSS and SSS and CFICH
24019                and Cell Specific Reference Signals */
24020             pbchSsRsSym = (((cellDl->currCfi) + RGSCH_NUM_PSS_SSS_SYM) *
24021                   RGSCH_NUM_SC_IN_RB + cell->numCellRSPerSf);
24022          }
24023       }
24024       else
24025       {
24026          pbchFrame = 1;
24027          /* In subframe 0, symbols are reserved for PSS, SSS, PBCH, CFICH and
24028             and Cell Specific Reference signals */
24029          pbchSsRsSym = (((cellDl->currCfi) + RGSCH_NUM_PBCH_SYM +
24030                   RGSCH_NUM_PSS_SSS_SYM) * RGSCH_NUM_SC_IN_RB +
24031                cell->numCellRSPerSf);
24032       } /* end of outer else */
24033
24034       if((pbchFrame) &&
24035             (((dlSf->bwAlloced + allocInfo->rbsReq) - cell->pbchRbStart) > 0)&&
24036             (dlSf->bwAlloced < cell->pbchRbEnd))
24037       {
24038          if(allocInfo->tbInfo[0].imcs < 29)
24039          {
24040             rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo, pbchSsRsSym, TRUE);
24041          }
24042       }
24043 #endif
24044 #ifdef LTEMAC_SPS
24045    }
24046 #endif
24047
24048 #ifdef LTEMAC_SPS
24049    if (!spsRbsAlloc)
24050    {  
24051 #endif
24052       /*Fix for ccpu00123918*/
24053       allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
24054       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
24055       allocInfo->rbsAlloc = allocInfo->rbsReq;
24056
24057       /* LTE_ADV_FLAG_REMOVED_START */
24058 #ifndef LTE_TDD
24059       if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
24060       {
24061          rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, \
24062                allocInfo->allocInfo.raType2.rbStart, \
24063                allocInfo->allocInfo.raType2.numRb);
24064       }
24065       else
24066 #endif
24067       {
24068          rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, \
24069                allocInfo->allocInfo.raType2.rbStart, \
24070                allocInfo->allocInfo.raType2.numRb);
24071       }
24072
24073 #ifdef LTEMAC_SPS
24074    }
24075 #endif
24076    /* LTE_ADV_FLAG_REMOVED_END */
24077    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
24078
24079
24080 #ifdef LTEMAC_SPS
24081    if (spsRbsAlloc)
24082    {
24083       U8    idx;
24084       /* Update type 0, 1 and 2 masks */
24085       dlSfAlloc->raType0Mask    |= allocInfo->resAllocInfo.raType0Mask;
24086 #ifdef RGSCH_SPS_UNUSED
24087       for (idx = 0; idx < RG_SCH_NUM_RATYPE1_32BIT_MASK; ++idx)
24088       {
24089          dlSfAlloc->raType1Mask[idx] |=
24090             allocInfo->resAllocInfo.raType1Mask[idx];
24091          dlSfAlloc->raType1UsedRbs[idx] +=
24092             allocInfo->resAllocInfo.raType1UsedRbs[idx];
24093       }
24094 #endif
24095       for (idx = 0; idx < RG_SCH_NUM_RATYPE2_32BIT_MASK; ++idx)
24096       {
24097          dlSfAlloc->raType2Mask[idx] |=
24098             allocInfo->resAllocInfo.raType2Mask[idx];
24099       }
24100    }
24101 #endif
24102
24103    RETVALUE(ROK);
24104 }
24105
24106
24107 /**
24108  * @brief Performs RB allocation for frequency non-selective cell.
24109  *
24110  * @details
24111  *
24112  *     Function : rgSCHCmnNonDlfsCmnRbAllocRar
24113  *
24114  *     Processing Steps:
24115  *      - Allocate consecutively available RBs for BCCH/PCCH/RAR.
24116  *
24117  *  @param[in]      RgSchCellCb     *cell
24118  *  @param[in, out] RgSchDlRbAlloc  *allocInfo
24119  *  @return  S16
24120  *      -# ROK
24121  *      -# RFAILED
24122  **/
24123 #ifdef ANSI
24124 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAllocRar
24125 (
24126  RgSchCellCb      *cell,
24127  RgSchDlRbAlloc   *allocInfo
24128  )
24129 #else
24130 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
24131    RgSchCellCb      *cell;
24132    RgSchDlRbAlloc   *allocInfo;
24133 #endif
24134 {
24135    RgSchDlSf     *dlSf   = allocInfo->dlSf;
24136    TRC2(rgSCHCmnNonDlfsCmnRbAllocRar);
24137
24138
24139    if(dlSf->bwAlloced == dlSf->bw)
24140    {
24141       RETVALUE(RFAILED);
24142    }
24143
24144    allocInfo->tbInfo[0].noLyr = 1;
24145 #ifndef RG_5GTF
24146    /* Update allocation information */
24147    allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
24148    if (allocInfo->pdcch == NULLP)
24149    {
24150       RETVALUE(RFAILED);
24151    }
24152    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
24153    allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
24154    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
24155    allocInfo->allocInfo.raType2.isLocal = TRUE;
24156
24157    /*Fix for ccpu00123918*/
24158    allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
24159    allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
24160    allocInfo->rbsAlloc = allocInfo->rbsReq;
24161
24162    /* LTE_ADV_FLAG_REMOVED_END */
24163    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
24164
24165 #else
24166    allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, NULLP, dlSf, 13, TFU_DCI_FORMAT_B1, FALSE);
24167    if (allocInfo->pdcch == NULLP)
24168    {
24169       RETVALUE(RFAILED);
24170    }
24171    RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[0]);
24172    if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
24173    {
24174       printf("5GTF_ERROR vrbg allocated > 25\n");
24175       RETVALUE(RFAILED);
24176    }
24177
24178    allocInfo->tbInfo[0].cmnGrnt.vrbgStart = beamInfo->vrbgStart;
24179    allocInfo->tbInfo[0].cmnGrnt.numVrbg = allocInfo->vrbgReq;
24180
24181    /* Update allocation information */
24182    allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
24183
24184    allocInfo->tbInfo[0].cmnGrnt.xPDSCHRange = 1;  
24185    allocInfo->tbInfo[0].cmnGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
24186          allocInfo->tbInfo[0].cmnGrnt.vrbgStart, allocInfo->tbInfo[0].cmnGrnt.numVrbg);
24187
24188    allocInfo->tbInfo[0].cmnGrnt.rbStrt = (allocInfo->tbInfo[0].cmnGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
24189    allocInfo->tbInfo[0].cmnGrnt.numRb = (allocInfo->tbInfo[0].cmnGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
24190
24191    beamInfo->vrbgStart += allocInfo->tbInfo[0].cmnGrnt.numVrbg;
24192    beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].cmnGrnt.numVrbg;
24193    allocInfo->tbInfo[0].cmnGrnt.rv = 0;
24194    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
24195
24196 #endif
24197    printf("\n[%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
24198          __func__,allocInfo->tbInfo[0].bytesAlloc,allocInfo->vrbgReq);
24199
24200    RETVALUE(ROK);
24201 }
24202
24203
24204 /* LTE_ADV_FLAG_REMOVED_START */
24205 #ifndef LTE_TDD
24206 /**
24207  * @brief To check if DL BW available for non-DLFS allocation.
24208  *
24209  * @details
24210  *
24211  *     Function : rgSCHCmnNonDlfsBwAvlbl
24212  *
24213  *     Processing Steps:
24214  *      - Determine availability based on RA Type.
24215  *
24216  *  @param[in]  RgSchCellCb     *cell
24217  *  @param[in]  RgSchDlSf       *dlSf
24218  *  @param[in]  RgSchDlRbAlloc  *allocInfo
24219  *
24220  *  @return Bool
24221  *      -# TRUE
24222  *      -# FALSE
24223  **/
24224 #ifdef UNUSE_FUN
24225 #ifdef ANSI
24226 PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl
24227 (
24228 RgSchCellCb        *cell,
24229 RgSchSFRPoolInfo   **sfrpoolInfo,
24230 RgSchDlSf          *dlSf,
24231 RgSchDlRbAlloc     *allocInfo,
24232 Bool               isUeCellEdge
24233 )
24234 #else
24235 PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl(cell, sfrpoolInfo, dlSf, allocInfo, isUeCellEdge)
24236 RgSchCellCb        *cell;
24237 RgSchSFRPoolInfo   **sfrpoolInfo;
24238 RgSchDlSf          *dlSf;
24239 RgSchDlRbAlloc     *allocInfo;
24240 Bool               isUeCellEdge;
24241 #endif
24242 {
24243    CmLListCp   *l;
24244    CmLListCp   *l1;
24245    CmLList     *n;
24246    CmLList     *n1;
24247    RgSchSFRPoolInfo  *sfrPool;
24248    RgSchSFRPoolInfo  *sfrCEPool;
24249
24250    U8 tbs;
24251    U8 noLyrs;
24252    RgSchSFRPoolInfo *poolWithMaxAvlblBw = NULLP;
24253    U32 bwAvlbl = 0;
24254    U32 addtnlPRBs = 0;
24255
24256    if (dlSf->bw <= dlSf->bwAlloced)
24257    {
24258       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
24259             "BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
24260       return FALSE;
24261    }
24262
24263    if (dlSf->sfrTotalPoolInfo.ccBwFull == TRUE)
24264    {
24265       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
24266             "BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
24267       return FALSE;
24268    }
24269
24270    if ((dlSf->sfrTotalPoolInfo.ceBwFull == TRUE) && (isUeCellEdge))
24271    {
24272       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
24273             "BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
24274       return FALSE;
24275    }  
24276
24277    /* We first check if the ue scheduled is a cell edge or cell centre and accordingly check the avaialble
24278       memory in their pool. If the cell centre UE doesnt have Bw available in its pool, then it will check
24279       Bw availability in cell edge pool but the other way around is NOT possible.   */
24280    if(isUeCellEdge)
24281    {   
24282       l = &dlSf->sfrTotalPoolInfo.cePool;
24283    }
24284    else
24285    {
24286       l = &dlSf->sfrTotalPoolInfo.ccPool; 
24287    }     
24288
24289    n = cmLListFirst(l);
24290
24291    while(n)       
24292    {
24293       if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
24294       {
24295          sfrPool = (RgSchSFRPoolInfo*)(n->node);
24296
24297          /* MS_FIX for ccpu00123919 : Number of RBs in case of RETX should be same as that of initial transmission. */
24298          if(allocInfo->tbInfo[0].tbCb->txCntr)
24299          {
24300             /* If RB assignment is being done for RETX. Then if reqRbs are   a multiple of rbgSize then ignore lstRbgDfct. If reqRbs is 
24301              * not a multiple of rbgSize then check if lsgRbgDfct exists */
24302             if (allocInfo->rbsReq % cell->rbgSize == 0)
24303             {
24304                if ((sfrPool->type2End == dlSf->type2End) && dlSf->lstRbgDfct)
24305                {
24306                   /* In this scenario we are wasting the last RBG for this dlSf */
24307                   sfrPool->type0End--;
24308                   sfrPool->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24309
24310                   dlSf->lstRbgDfct = 0;
24311
24312                   /*ABHINAV To check if these variables need to be taken care of*/
24313                   dlSf->type0End--;
24314                   dlSf->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24315                }
24316             }
24317             else
24318             {
24319                if (dlSf->lstRbgDfct)
24320                {
24321                   /* Check if type0 allocation can cater to this RETX requirement */
24322                   if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
24323                   {
24324                      RETVALUE(FALSE);
24325                   }
24326                   else
24327                   {
24328                      if (sfrPool->type2End != dlSf->type2End)   /*Search again for some pool which has the END RBG of the BandWidth*/
24329                      {
24330                         continue;                                       
24331                      }  
24332                   }
24333                }
24334                else
24335                {
24336                   /* cannot allocate same number of required RBs */
24337                   RETVALUE(FALSE);                   
24338                }
24339             }
24340          }
24341
24342          /*rg002.301 ccpu00120391 MOD condition is modified approprialtely to find if rbsReq is less than available RBS*/
24343          if(allocInfo->rbsReq <= (((sfrPool->type0End - sfrPool->type2End + 1)*\
24344                      cell->rbgSize) - dlSf->lstRbgDfct))
24345          {
24346             *sfrpoolInfo = sfrPool;
24347             RETVALUE(TRUE);
24348          }
24349          else
24350          {
24351             if (sfrPool->bw <= sfrPool->bwAlloced + cell->rbgSize)
24352             {
24353                n = cmLListNext(l);
24354                /* If the ue is cell centre then it will simply check the memory available in next pool.
24355                   But if there are no more memory pools available, then cell centre Ue will try to look for memory in cell edge pool */
24356
24357                if((!isUeCellEdge) && (!n->node))
24358                {
24359                   l = &dlSf->sfrTotalPoolInfo.cePool;
24360                   n = cmLListFirst(l);
24361                }
24362
24363                continue; 
24364             }    
24365
24366             /* MS_FIX: Number of RBs in case of RETX should be same as that of initial transmission */
24367             if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24368             {
24369                /*rg002.301 ccpu00120391 MOD setting the remaining RBs  for the requested UE*/
24370                allocInfo->rbsReq = (((sfrPool->type0End - sfrPool->type2End + 1)*\
24371                         cell->rbgSize) - dlSf->lstRbgDfct);
24372                RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24373                noLyrs = allocInfo->tbInfo[0].noLyr;
24374                allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24375                *sfrpoolInfo = sfrPool;
24376                RETVALUE(TRUE);
24377             }
24378             else
24379             {
24380                n = cmLListNext(l);
24381
24382                /* If the ue is cell centre then it will simply check the memory available in next pool.
24383                   But if there are no more memory pools available, then cell centre Ue will try to look for memory in cell edge pool */
24384                if((!isUeCellEdge) && (!n->node))
24385                {
24386                   l = &dlSf->sfrTotalPoolInfo.cePool;
24387                   n = cmLListFirst(l);
24388                }
24389
24390                continue;
24391             }
24392
24393          //   RETVALUE(FALSE);
24394          }
24395       }
24396       else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
24397       {
24398          sfrPool = (RgSchSFRPoolInfo*)(n->node);
24399          /* This is a Case where a UE was CC and had more RBs allocated than present in CE pool.
24400             In case this UE whn become CE with retx going on, then BW is not sufficient for Retx */
24401          if ((isUeCellEdge) &&
24402             (allocInfo->tbInfo[0].tbCb->txCntr != 0))
24403          {
24404             if(allocInfo->rbsReq > (sfrPool->bw - sfrPool->bwAlloced))
24405             {
24406                /* Adjust CE BW such that Retx alloc is successful */
24407                /* Check if merging CE with adjacent CC pool will be sufficient to process Retx */
24408
24409                /* If no Type 0 allocations are made from this pool */
24410                if (sfrPool->type0End == (((sfrPool->poolendRB + 1) / cell->rbgSize) - 1))
24411                {
24412                   if (sfrPool->adjCCPool &&
24413                         (sfrPool->adjCCPool->type2Start == sfrPool->poolendRB + 1) &&
24414                         (allocInfo->rbsReq <= ((sfrPool->bw - sfrPool->bwAlloced) + 
24415                                                ((sfrPool->adjCCPool->bw - sfrPool->adjCCPool->bwAlloced)))))
24416                   {
24417                      addtnlPRBs = allocInfo->rbsReq - (sfrPool->bw - sfrPool->bwAlloced);
24418
24419                      /* Adjusting CE Pool Info */
24420                      sfrPool->bw += addtnlPRBs;
24421                      sfrPool->type0End = ((sfrPool->poolendRB + addtnlPRBs + 1) /
24422                            cell->rbgSize) - 1;
24423
24424                      /* Adjusting CC Pool Info */
24425                      sfrPool->adjCCPool->type2Start += addtnlPRBs;
24426                      sfrPool->adjCCPool->type2End = RGSCH_CEIL(sfrPool->adjCCPool->type2Start, 
24427                            cell->rbgSize);
24428                      sfrPool->adjCCPool->bw -= addtnlPRBs;
24429                      *sfrpoolInfo = sfrPool;
24430                      RETVALUE(TRUE);
24431                   }
24432                }
24433             }
24434          }
24435
24436          /* Check if CC pool is one of the following:
24437           * 1. |CE| + |CC "CCPool2Exists" = TRUE|
24438           * 2. |CC "CCPool2Exists" = FALSE| + |CE| + |CC "CCPool2Exists" = TRUE|
24439           */ 
24440          if(TRUE == sfrPool->CCPool2Exists)
24441          {
24442             l1 = &dlSf->sfrTotalPoolInfo.cePool;
24443             n1 = cmLListFirst(l1); 
24444             sfrCEPool = (RgSchSFRPoolInfo*)(n1->node);
24445             if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced))
24446             {
24447                *sfrpoolInfo = sfrCEPool;
24448                RETVALUE(TRUE);
24449             }
24450             else if(allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))  
24451             {
24452                *sfrpoolInfo = sfrPool;
24453                RETVALUE(TRUE);
24454             }
24455             /* Check if CE and CC boundary has unallocated prbs */
24456             else if ((sfrPool->poolstartRB == sfrPool->type2Start) &&
24457                   (sfrCEPool->type0End  == ((sfrCEPool->poolendRB + 1) / cell->rbgSize) - 1))
24458             {
24459                if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced) + 
24460                      (sfrPool->bw - sfrPool->bwAlloced))
24461                {
24462                   /* Checking if BW can be allocated partly from CE pool and partly
24463                    * from CC pool
24464                    */
24465                   addtnlPRBs = allocInfo->rbsReq - (sfrPool->bw - sfrPool->bwAlloced);
24466                   /* Updating CE and CC  type2 parametrs based on the RBs allocated
24467                    * from these pools*/
24468                   sfrPool->type2Start -= addtnlPRBs;
24469                   sfrPool->type2End = RGSCH_CEIL(sfrPool->type2Start, cell->rbgSize);
24470                   sfrPool->bw += addtnlPRBs;
24471                   if (addtnlPRBs == (sfrCEPool->bw - sfrCEPool->bwAlloced))
24472                   {
24473                      sfrCEPool->bwAlloced  = sfrCEPool->bw; 
24474                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE;
24475                   }
24476                   else
24477                   {
24478                      sfrCEPool->bw -= addtnlPRBs;
24479                      sfrCEPool->type0End = ((sfrCEPool->poolendRB + 1 - addtnlPRBs) / cell->rbgSize) - 1;
24480                   }
24481                   *sfrpoolInfo = sfrPool;
24482                   RETVALUE(TRUE);
24483                }
24484                else if ( bwAvlbl < 
24485                      ((sfrCEPool->bw - sfrCEPool->bwAlloced) +
24486                       (sfrPool->bw - sfrPool->bwAlloced)))
24487                {
24488                   /* All the Prbs from CE BW shall be allocated */
24489                   if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24490                   {
24491                      sfrPool->type2Start   = sfrCEPool->type2Start;
24492                      sfrPool->bw          += sfrCEPool->bw - sfrCEPool->bwAlloced;
24493                      sfrCEPool->type2Start = sfrCEPool->poolendRB + 1;
24494                      sfrCEPool->bwAlloced  = sfrCEPool->bw; 
24495                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE;
24496
24497                      /* set the remaining RBs for the requested UE */
24498                      allocInfo->rbsReq = (sfrPool->bw - sfrPool->bwAlloced);
24499                      RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24500                      noLyrs = allocInfo->tbInfo[0].noLyr;
24501                      allocInfo->tbInfo[0].bytesReq = 
24502                         rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24503                      *sfrpoolInfo = sfrPool;               
24504                      RETVALUE(TRUE);
24505                   }
24506                   else
24507                   {
24508                      RETVALUE(FALSE);
24509                   }
24510                }
24511             }
24512          } 
24513
24514          /* Checking if no. of RBs required can be allocated from
24515           * SFR pool. 
24516           * 1. If available return the SFR pool.
24517           * 2. Else update the RBs required parameter based on the 
24518           *    BW available in the pool 
24519           * 3. Return FALSE if no B/W is available. 
24520           */
24521          if (allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
24522          {
24523             *sfrpoolInfo = sfrPool;
24524             RETVALUE(TRUE);
24525          }
24526          else
24527          {
24528             if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24529             {
24530                if (bwAvlbl < sfrPool->bw - sfrPool->bwAlloced)
24531                {
24532                   if (isUeCellEdge)
24533                   {
24534                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE; 
24535                   }
24536                   bwAvlbl = sfrPool->bw - sfrPool->bwAlloced;
24537                   poolWithMaxAvlblBw = sfrPool;
24538                }
24539                n = cmLListNext(l);
24540
24541                if ((isUeCellEdge == FALSE) && (n == NULLP))
24542                {
24543                   if(l != &dlSf->sfrTotalPoolInfo.cePool)
24544                   {
24545                      l = &dlSf->sfrTotalPoolInfo.cePool;
24546                      n = cmLListFirst(l);                          
24547                   }
24548                }
24549
24550                if (n == NULLP)
24551                {
24552                   if (bwAvlbl == 0)
24553                   {                                                             
24554                      if (isUeCellEdge)
24555                      {
24556                         dlSf->sfrTotalPoolInfo.ceBwFull = TRUE; 
24557                      }
24558                      else
24559                      {
24560                         dlSf->sfrTotalPoolInfo.ccBwFull = TRUE;  
24561                      }
24562                      RETVALUE(FALSE);
24563                   }
24564                   else
24565                   {
24566                      /* set the remaining RBs for the requested UE */
24567                      allocInfo->rbsReq = poolWithMaxAvlblBw->bw - 
24568                         poolWithMaxAvlblBw->bwAlloced;
24569                      RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24570                      noLyrs = allocInfo->tbInfo[0].noLyr;
24571                      allocInfo->tbInfo[0].bytesReq = 
24572                         rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24573                      *sfrpoolInfo = poolWithMaxAvlblBw;            
24574                      RETVALUE(TRUE);
24575                   }
24576                }                          
24577             }
24578             else
24579             {                   
24580                n = cmLListNext(l);
24581
24582                if ((isUeCellEdge == FALSE) && (n == NULLP))
24583                {
24584                   if(l != &dlSf->sfrTotalPoolInfo.cePool)
24585                   {
24586                      l = &dlSf->sfrTotalPoolInfo.cePool;
24587                      n = cmLListFirst(l);                          
24588                   }
24589                }
24590
24591                if (n == NULLP)
24592                {
24593                   RETVALUE(FALSE);
24594                }
24595             }
24596
24597          }
24598       }   
24599    } 
24600    RETVALUE(FALSE);
24601 }
24602 #endif
24603 #endif /* end of ifndef LTE_TDD*/
24604 /* LTE_ADV_FLAG_REMOVED_END */
24605
24606 /**
24607  * @brief To check if DL BW available for non-DLFS allocation.
24608  *
24609  * @details
24610  *
24611  *     Function : rgSCHCmnNonDlfsUeRbAlloc
24612  *
24613  *     Processing Steps:
24614  *      - Determine availability based on RA Type.
24615  *
24616  *  @param[in]  RgSchCellCb     *cell
24617  *  @param[in]  RgSchDlSf       *dlSf
24618  *  @param[in]  RgSchDlRbAlloc  *allocInfo
24619  *
24620  *  @return Bool
24621  *      -# TRUE
24622  *      -# FALSE
24623  **/
24624 #ifdef UNUSE_FUN
24625 #ifdef ANSI
24626 PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl
24627 (
24628 RgSchCellCb        *cell,
24629 RgSchDlSf          *dlSf,
24630 RgSchDlRbAlloc     *allocInfo
24631 )
24632 #else
24633 PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl(cell, dlSf, allocInfo)
24634 RgSchCellCb        *cell;
24635 RgSchDlSf          *dlSf;
24636 RgSchDlRbAlloc     *allocInfo;
24637 #endif
24638 {
24639    U8 tbs;
24640    U8 noLyrs;
24641    U8 ignoredDfctRbg = FALSE;
24642
24643    TRC2(rgSCHCmnNonDlfsBwAvlbl);
24644    if (dlSf->bw <= dlSf->bwAlloced)
24645    {
24646       RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
24647          dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
24648       RETVALUE(FALSE);
24649    }
24650    if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
24651    {
24652        /* Fix for ccpu00123919 : Number of RBs in case of RETX should be same as 
24653         * that of initial transmission. */
24654        if(allocInfo->tbInfo[0].tbCb->txCntr)
24655        {
24656           /* If RB assignment is being done for RETX. Then if reqRbs are 
24657            * a multiple of rbgSize then ignore lstRbgDfct. If reqRbs is 
24658            * not a multiple of rbgSize then check if lsgRbgDfct exists */
24659           if (allocInfo->rbsReq % cell->rbgSize == 0)
24660           {
24661              if (dlSf->lstRbgDfct)
24662              {
24663                 /* In this scenario we are wasting the last RBG for this dlSf */
24664                 
24665                 dlSf->type0End--;
24666                 dlSf->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24667                 /* Fix: MUE_PERTTI_DL */
24668                 dlSf->lstRbgDfct = 0;
24669                 ignoredDfctRbg = TRUE;
24670                 
24671              }
24672           }
24673           else
24674           {
24675              if (dlSf->lstRbgDfct)
24676              {
24677                 /* Check if type0 allocation can cater to this RETX requirement */
24678                 if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
24679                 {
24680                    RETVALUE(FALSE);
24681                 }
24682              }
24683              else
24684              {
24685                 /* cannot allocate same number of required RBs */
24686                 RETVALUE(FALSE);                     
24687              }
24688           }
24689        }
24690
24691        /* Condition is modified approprialtely to find
24692         * if rbsReq is less than available RBS*/
24693       if(allocInfo->rbsReq <= (((dlSf->type0End - dlSf->type2End + 1)*\
24694                cell->rbgSize) - dlSf->lstRbgDfct))
24695       {
24696          RETVALUE(TRUE);
24697       }
24698       /* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB 
24699        * allocation in TDD when requested RBs are more than available RBs*/
24700       else
24701       {
24702           /* MS_WORKAROUND for ccpu00122022 */
24703          if (dlSf->bw < dlSf->bwAlloced + cell->rbgSize)
24704          {
24705             /* ccpu00132358- Re-assigning the values which were updated above 
24706              * if it is RETX and Last  RBG available*/
24707             if(ignoredDfctRbg == TRUE)
24708             {
24709                dlSf->type0End++;
24710                dlSf->bwAlloced -= (cell->rbgSize - dlSf->lstRbgDfct);
24711                dlSf->lstRbgDfct = 1;
24712             }
24713
24714
24715             RETVALUE(FALSE);
24716          }
24717          /* Fix: Number of RBs in case of RETX should be same as 
24718           * that of initial transmission. */
24719          if(allocInfo->tbInfo[0].tbCb->txCntr == 0 
24720 #ifdef LTE_ADV
24721             && (FALSE == rgSCHLaaIsLaaTB(allocInfo))
24722 #endif
24723             )
24724          {
24725             /* Setting the remaining RBs for the requested UE*/
24726             allocInfo->rbsReq = (((dlSf->type0End - dlSf->type2End + 1)*\
24727                         cell->rbgSize) - dlSf->lstRbgDfct);
24728             RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24729             noLyrs = allocInfo->tbInfo[0].noLyr;
24730             allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24731             /* DwPts Scheduling Changes Start */
24732 #if LTE_TDD
24733             if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
24734             {   
24735                allocInfo->tbInfo[0].bytesReq = 
24736                         rgTbSzTbl[noLyrs-1][tbs][RGSCH_MAX(allocInfo->rbsReq*3/4,1) - 1]/8; 
24737             }
24738 #endif            
24739             /* DwPts Scheduling Changes End */
24740          }
24741          else
24742          {
24743                     /* ccpu00132358- Re-assigning the values which were updated above 
24744              * if it is RETX and Last  RBG available*/
24745             if(ignoredDfctRbg == TRUE)
24746             {
24747                dlSf->type0End++;
24748                dlSf->bwAlloced -= (cell->rbgSize - dlSf->lstRbgDfct);
24749                dlSf->lstRbgDfct = 1;
24750             }
24751
24752             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
24753                   allocInfo->rnti);
24754             printf ("RB Alloc failed for LAA TB type 0\n");
24755             RETVALUE(FALSE);
24756          }
24757          RETVALUE(TRUE);
24758       }
24759    }
24760    else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
24761    {
24762       if (allocInfo->rbsReq <= (dlSf->bw - dlSf->bwAlloced))
24763       {
24764          RETVALUE(TRUE);
24765       }
24766       /* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB 
24767        * allocation in TDD when requested RBs are more than available RBs*/
24768       else
24769       {
24770          /* Fix: Number of RBs in case of RETX should be same as 
24771           * that of initial transmission. */
24772          if((allocInfo->tbInfo[0].tbCb->txCntr == 0) 
24773 #ifdef LTE_ADV
24774             && (FALSE == rgSCHLaaIsLaaTB(allocInfo))
24775 #endif
24776             )
24777          {
24778             /* set the remaining RBs for the requested UE */
24779             allocInfo->rbsReq = dlSf->bw - dlSf->bwAlloced;
24780             RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24781             noLyrs = allocInfo->tbInfo[0].noLyr;
24782             allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24783             /* DwPts Scheduling Changes Start */
24784 #ifdef LTE_TDD
24785             if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
24786             {   
24787                allocInfo->tbInfo[0].bytesReq = 
24788                         rgTbSzTbl[noLyrs-1][tbs][RGSCH_MAX(allocInfo->rbsReq*3/4,1) - 1]/8; 
24789             }
24790 #endif            
24791             /* DwPts Scheduling Changes End */
24792          }
24793          else
24794          {
24795             printf ("RB Alloc failed for LAA TB type 2\n");
24796             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
24797             RETVALUE(FALSE);
24798          }
24799          /* Fix: Number of RBs in case of RETX should be same as 
24800           * that of initial transmission. */
24801          RETVALUE(TRUE);
24802       }
24803    }
24804    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
24805    RETVALUE(FALSE);
24806 }
24807 #endif
24808 /* LTE_ADV_FLAG_REMOVED_START */
24809 #ifndef LTE_TDD
24810 /**
24811  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24812  *
24813  * @details
24814  *
24815  *     Function : rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
24816  *
24817  *     Processing Steps:
24818  *
24819  *  @param[in]  RgSchCellCb     *cell
24820  *  @param[in]  RgSchDlSf       *dlSf
24821  *  @param[in]  U8              rbStrt
24822  *  @param[in]  U8              numRb
24823  *
24824  *  @return Void
24825  **/
24826 #ifdef ANSI
24827 PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
24828 (
24829 RgSchCellCb        *cell,
24830 RgSchDlSf          *dlSf,
24831 U8                 rbStrt,
24832 U8                 numRb
24833 )
24834 #else
24835 PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
24836 RgSchCellCb        *cell;
24837 RgSchDlSf          *dlSf;
24838 U8                 rbStrt;
24839 U8                 numRb;
24840 #endif
24841 { 
24842    CmLListCp   *l;
24843    CmLList     *n;
24844    RgSchSFRPoolInfo  *sfrPool;
24845    TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
24846    
24847    l = &dlSf->sfrTotalPoolInfo.ccPool;
24848      
24849    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
24850    dlSf->bwAlloced += numRb;
24851    dlSf->type2Start += numRb;
24852    n = cmLListFirst(l);
24853         
24854    while(n->node)
24855    {
24856         sfrPool = (RgSchSFRPoolInfo*)(n->node);
24857         n = cmLListNext(l);
24858          
24859          /* If the pool contains some RBs allocated in this allocation, e.g: Pool is [30.50]. Pool->type2Start is 40 , dlSf->type2Start is 45. then update the variables in pool   */
24860         if((sfrPool->poolendRB >= dlSf->type2Start) && (sfrPool->type2Start < dlSf->type2Start))
24861         {
24862                 sfrPool->type2End   =  dlSf->type2End;
24863                 sfrPool->bwAlloced  =  dlSf->type2Start - sfrPool->poolstartRB; 
24864                 sfrPool->type2Start =  dlSf->type2Start;
24865         }          
24866         else 
24867         { 
24868                 /* If the pool contains all RBs allocated in this allocation*/
24869                 if(dlSf->type2Start > sfrPool->poolendRB)
24870                 {                
24871                         sfrPool->type2End   =  sfrPool->type0End + 1;
24872                         sfrPool->bwAlloced  =  sfrPool->bw; 
24873                         sfrPool->type2Start =  sfrPool->poolendRB + 1;             
24874                 }  
24875         }
24876       if (!n)
24877       { 
24878          if (l != &dlSf->sfrTotalPoolInfo.cePool)
24879          {
24880             l = &dlSf->sfrTotalPoolInfo.cePool;   
24881             n = cmLListFirst(l);
24882          }
24883          else
24884             RETVOID;
24885       }
24886    }
24887    RETVOID;
24888 }
24889
24890 /**
24891  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24892  *
24893  * @details
24894  *
24895  *     Function : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
24896  *
24897  *     Processing Steps:
24898  *
24899  *  @param[in]  RgSchCellCb     *cell
24900  *  @param[in]  RgSchDlSf       *dlSf
24901  *  @param[in]  U8              rbStrt
24902  *  @param[in]  U8              numRb
24903  *
24904  *  @return Void
24905  **/
24906 #ifdef UNUSE_FUN
24907 #ifdef ANSI
24908 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
24909 (
24910 RgSchCellCb        *cell,
24911 RgSchUeCb          *ue,
24912 RgSchDlSf          *dlSf,
24913 U8                 rbStrt,
24914 U8                 numRb
24915 )
24916 #else
24917 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
24918 RgSchCellCb        *cell;
24919 RgSchUeCb          *ue;
24920 RgSchDlSf          *dlSf;
24921 U8                 rbStrt;
24922 U8                 numRb;
24923 #endif
24924 {
24925    CmLListCp   *l;
24926    CmLList     *n;
24927    RgSchSFRPoolInfo  *sfrCCPool1 = NULL;
24928    RgSchSFRPoolInfo  *sfrCCPool2 = NULL;
24929    S16 ret = RFAILED;
24930
24931    TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
24932    /* Move the type2End pivot forward */
24933    
24934    
24935    l = &dlSf->sfrTotalPoolInfo.ccPool;
24936    n = cmLListFirst(l);
24937    while(n)
24938    {
24939       sfrCCPool1 = (RgSchSFRPoolInfo*)(n->node);
24940       /* KWork fix */
24941       if (sfrCCPool1 ==  NULLP)
24942             {
24943                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
24944                         "sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
24945                RETVALUE(RFAILED);
24946             }
24947       n = cmLListNext(l);
24948       if(n)
24949       {
24950           sfrCCPool2 = (RgSchSFRPoolInfo*)(n->node);
24951           n = cmLListNext(l);
24952       }
24953       if((sfrCCPool1) && (sfrCCPool2))
24954       { 
24955           /* Based on RNTP info, the CC user is assigned high power per subframe basis */
24956           if(((dlSf->type2Start >= sfrCCPool1->pwrHiCCRange.startRb) &&
24957               (dlSf->type2Start + numRb < sfrCCPool1->pwrHiCCRange.endRb)) || 
24958              ((dlSf->type2Start >= sfrCCPool2->pwrHiCCRange.startRb) &&
24959               (dlSf->type2Start + numRb < sfrCCPool2->pwrHiCCRange.endRb)))
24960           {
24961                ue->lteAdvUeCb.isCCUePHigh = TRUE;
24962
24963                /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
24964                ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
24965                if (ret != ROK)
24966                {
24967                     RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
24968                       "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
24969                     RETVALUE(RFAILED);
24970                }
24971            }
24972       }
24973       else
24974       {
24975          if((dlSf->type2Start >= sfrCCPool1->pwrHiCCRange.startRb) &&
24976                (dlSf->type2Start + numRb < sfrCCPool1->pwrHiCCRange.endRb))
24977          {
24978             ue->lteAdvUeCb.isCCUePHigh = TRUE;
24979
24980             /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
24981             ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
24982             if (ret != ROK)
24983             {
24984                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,   "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():" 
24985                         "rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
24986                RETVALUE(RFAILED);
24987             }
24988          }
24989       }
24990    }
24991    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
24992 #ifndef LTEMAC_SPS
24993    dlSf->bwAlloced += numRb;
24994    /*MS_FIX for ccpu00123918*/
24995    dlSf->type2Start += numRb;
24996 #endif
24997    RETVALUE(ROK);
24998
24999 }
25000 #endif
25001 #endif /* end of ifndef LTE_TDD*/
25002 /* LTE_ADV_FLAG_REMOVED_END */
25003 /**
25004  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
25005  *
25006  * @details
25007  *
25008  *     Function : rgSCHCmnNonDlfsUpdTyp2Alloc
25009  *
25010  *     Processing Steps:
25011  *
25012  *  @param[in]  RgSchCellCb     *cell
25013  *  @param[in]  RgSchDlSf       *dlSf
25014  *  @param[in]  U8              rbStrt
25015  *  @param[in]  U8              numRb
25016  *
25017  *  @return Void
25018  **/
25019 #ifdef ANSI
25020 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc
25021 (
25022 RgSchCellCb        *cell,
25023 RgSchDlSf          *dlSf,
25024 U8                 rbStrt,
25025 U8                 numRb
25026 )
25027 #else
25028 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
25029 RgSchCellCb        *cell;
25030 RgSchDlSf          *dlSf;
25031 U8                 rbStrt;
25032 U8                 numRb;
25033 #endif
25034 {
25035    TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
25036    /* Move the type2End pivot forward */
25037    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25038 //#ifndef LTEMAC_SPS
25039    dlSf->bwAlloced += numRb;
25040    /*Fix for ccpu00123918*/
25041    dlSf->type2Start += numRb;
25042 //#endif
25043    RETVOID;
25044 }
25045
25046 /**
25047  * @brief To do DL allocation using TYPE0 RA.
25048  *
25049  * @details
25050  *
25051  *     Function : rgSCHCmnNonDlfsType0Alloc
25052  *
25053  *     Processing Steps:
25054  *      - Perform TYPE0 allocation using the RBGs between
25055  *        type0End and type2End.
25056  *      - Build the allocation mask as per RBG positioning.
25057  *      - Update the allocation parameters.
25058  *
25059  *  @param[in]  RgSchCellCb     *cell
25060  *  @param[in]  RgSchDlSf       *dlSf
25061  *  @param[in]  RgSchDlRbAlloc  *allocInfo
25062  *
25063  *  @return Void
25064  **/
25065 #ifdef UNUSE_FUN
25066 #ifdef ANSI
25067 PRIVATE Void rgSCHCmnNonDlfsType0Alloc
25068 (
25069 RgSchCellCb        *cell,
25070 RgSchDlSf          *dlSf,
25071 RgSchDlRbAlloc     *allocInfo,
25072 RgSchUeCb          *ue
25073 )
25074 #else
25075 PRIVATE Void rgSCHCmnNonDlfsType0Alloc(cell, dlSf, allocInfo, dlUe)
25076 RgSchCellCb        *cell;
25077 RgSchDlSf          *dlSf;
25078 RgSchDlRbAlloc     *allocInfo;
25079 RgSchUeCb          *ue;
25080 #endif
25081 {
25082    U32 dlAllocMsk = 0;
25083    U8  rbgFiller = dlSf->lstRbgDfct;
25084    U8  noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
25085    //U8  noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
25086    U8  noRbs;
25087    U8  noLyr;
25088    U8  iTbs;
25089    U32          tb1BytesAlloc = 0;
25090    U32          tb2BytesAlloc = 0;
25091    RgSchCmnDlUe *dlUe         = RG_SCH_CMN_GET_DL_UE(ue,cell);
25092
25093    TRC2(rgSCHCmnNonDlfsType0Alloc);
25094    //if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
25095
25096    /* Fix for ccpu00123919*/
25097    noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25098    if (dlSf->bwAlloced + noRbs > dlSf->bw)
25099    {
25100       if (--noRbgs == 0)
25101       {
25102          RETVOID;
25103       }
25104       noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25105    }
25106
25107    /* Fix for ccpu00138701: Ceilling is using to derive num of RBGs, Therefore, 
25108    *  after this operation,checking Max TB size and Max RBs are not crossed
25109    * if it is crossed then decrement num of RBGs. */
25110    //if((noRbs + rbgFiller) % cell->rbgSize)
25111    if((noRbs > allocInfo->rbsReq) &&
25112          (allocInfo->rbsReq + rbgFiller) % cell->rbgSize)
25113    {/* considering ue category limitation
25114      * due to ceiling */
25115
25116 #ifdef LTE_ADV
25117       if (rgSCHLaaIsLaaTB(allocInfo)== FALSE)
25118 #endif
25119       {
25120          if ((allocInfo->tbInfo[0].schdlngForTb) && (!allocInfo->tbInfo[0].tbCb->txCntr))
25121          {
25122             iTbs = allocInfo->tbInfo[0].iTbs;
25123             noLyr = allocInfo->tbInfo[0].noLyr;
25124             tb1BytesAlloc = rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25125          }
25126
25127          if ((allocInfo->tbInfo[1].schdlngForTb) && (!allocInfo->tbInfo[1].tbCb->txCntr))
25128          {
25129             iTbs = allocInfo->tbInfo[1].iTbs;
25130             noLyr = allocInfo->tbInfo[1].noLyr;
25131             tb2BytesAlloc = rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25132          }
25133       }
25134       
25135       /* Only Check for New Tx No need for Retx */
25136       if (tb1BytesAlloc || tb2BytesAlloc)
25137       {
25138          if (( ue->dl.aggTbBits >= dlUe->maxTbBits) ||
25139                (tb1BytesAlloc >= dlUe->maxTbSz/8) ||
25140                (tb2BytesAlloc >= dlUe->maxTbSz/8) ||
25141                (noRbs >= dlUe->maxRb))
25142          {
25143             if (--noRbgs == 0)
25144             {
25145                RETVOID;
25146             }
25147             noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25148          }
25149       }
25150    }
25151    /* type0End would have been initially (during subfrm Init) at the bit position
25152     * (cell->noOfRbgs - 1), 0 being the most significant.
25153     * Getting DlAllocMsk for noRbgs and at the appropriate position */
25154    dlAllocMsk |= (((1 << noRbgs) - 1) << (31 - dlSf->type0End));
25155    /* Move backwards the type0End pivot */
25156    dlSf->type0End -= noRbgs;
25157    /*Fix for ccpu00123919*/
25158    /*noRbs = (noRbgs * cell->rbgSize) - rbgFiller;*/
25159    /* Update the bwAlloced field accordingly */
25160 //#ifndef LTEMAC_SPS    /* ccpu00129474*/
25161    dlSf->bwAlloced += noRbs;
25162 //#endif
25163    /* Update Type0 Alloc Info */
25164    allocInfo->allocInfo.raType0.numDlAlloc = noRbgs;
25165    allocInfo->allocInfo.raType0.dlAllocBitMask |= dlAllocMsk;
25166    allocInfo->rbsAlloc = noRbs;
25167
25168    /* Update Tb info for each scheduled TB */
25169    iTbs = allocInfo->tbInfo[0].iTbs;
25170    noLyr = allocInfo->tbInfo[0].noLyr;
25171    /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant.
25172     * RETX TB Size is same as Init TX TB Size */
25173    if (allocInfo->tbInfo[0].tbCb->txCntr)
25174    {
25175       allocInfo->tbInfo[0].bytesAlloc =
25176          allocInfo->tbInfo[0].bytesReq;
25177    }
25178    else
25179    {
25180       allocInfo->tbInfo[0].bytesAlloc =
25181          rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25182       /* DwPts Scheduling Changes Start */
25183 #ifdef LTE_TDD
25184       if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
25185       {
25186          allocInfo->tbInfo[0].bytesAlloc =
25187             rgTbSzTbl[noLyr - 1][iTbs][RGSCH_MAX(noRbs*3/4,1) - 1]/8;
25188       }
25189 #endif      
25190       /* DwPts Scheduling Changes End */
25191    }
25192
25193    if (allocInfo->tbInfo[1].schdlngForTb)
25194    {
25195       iTbs = allocInfo->tbInfo[1].iTbs;
25196       noLyr = allocInfo->tbInfo[1].noLyr;
25197       /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant
25198        * RETX TB Size is same as Init TX TB Size */
25199       if (allocInfo->tbInfo[1].tbCb->txCntr)
25200       {
25201          allocInfo->tbInfo[1].bytesAlloc =
25202             allocInfo->tbInfo[1].bytesReq;
25203       }
25204       else
25205       {
25206          allocInfo->tbInfo[1].bytesAlloc =
25207             rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
25208          /* DwPts Scheduling Changes Start */
25209 #ifdef LTE_TDD
25210          if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
25211          {
25212             allocInfo->tbInfo[1].bytesAlloc =
25213                rgTbSzTbl[noLyr - 1][iTbs][RGSCH_MAX(noRbs*3/4,1) - 1]/8;
25214          }
25215 #endif      
25216          /* DwPts Scheduling Changes End */
25217       }
25218    }
25219
25220    /* The last RBG which can be smaller than the RBG size is consedered
25221     * only for the first time allocation of TYPE0 UE */
25222    dlSf->lstRbgDfct = 0;
25223    RETVOID;
25224 }
25225 #endif
25226 #ifndef LTE_TDD
25227
25228 /**
25229  * @brief To prepare RNTP value from the PRB allocation (P-High -> 1 and P-Low -> 0)
25230  *
25231  * @details
25232  *
25233  *     Function : rgSCHCmnBuildRntpInfo
25234  *
25235  *     Processing Steps:
25236  *
25237  *  @param[in]  U8                 *rntpPtr
25238  *  @param[in]  U8                 startRb
25239  *  @param[in]  U8                 numRb
25240  *
25241  *  @return Void
25242  **/
25243 #ifdef UNUSE_FUN
25244 #ifdef ANSI
25245 PRIVATE S16 rgSCHCmnBuildRntpInfo
25246 (
25247 RgSchCellCb        *cell,
25248 U8                 *rntpPtr,
25249 U8                            startRb,
25250 U8                  nmbRb,
25251 U16                 bw
25252 )
25253 #else
25254 PRIVATE S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
25255 RgSchCellCb        *cell;
25256 U8                 *rntpPtr;
25257 U8                            startRb;
25258 U8                  nmbRb;
25259 U16                 bw;
25260 #endif
25261 {
25262    U16 rbPtrStartIdx;              /* Start Index of Octete Buffer to be filled */
25263    U16 rbPtrEndIdx;                /* End Index of Octete Buffer to be filled */
25264    U16 rbBitLoc;                   /* Bit Location to be set as 1 in the current Byte */
25265    U16 nmbRbPerByte;               /* PRB's to be set in the current Byte (in case of multiple Bytes) */
25266
25267    TRC2(rgSCHCmnBuildRntpInfo);
25268
25269    rbPtrStartIdx = (startRb)/8;
25270    rbPtrEndIdx   = (startRb + nmbRb)/8;
25271
25272    if (rntpPtr == NULLP)
25273    {
25274       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
25275                "rgSCHCmnBuildRntpInfo():"
25276                "rntpPtr can't be NULLP (Memory Allocation Failed)");
25277       RETVALUE(RFAILED);
25278    }
25279
25280    while(rbPtrStartIdx <= rbPtrEndIdx)
25281    {
25282       rbBitLoc = (startRb)%8;
25283
25284       /* case 1: startRb and endRb lies in same Byte */
25285       if (rbPtrStartIdx == rbPtrEndIdx)
25286       {
25287          rntpPtr[rbPtrStartIdx] = rntpPtr[rbPtrStartIdx]
25288                                      | (((1<<nmbRb)-1)<<rbBitLoc);
25289       }
25290
25291       /* case 2: startRb and endRb lies in different Byte */
25292       if (rbPtrStartIdx != rbPtrEndIdx)
25293       {
25294          nmbRbPerByte = 8 - rbBitLoc;
25295          nmbRb        = nmbRb - nmbRbPerByte;
25296          rntpPtr[rbPtrStartIdx] = rntpPtr[rbPtrStartIdx]
25297                                      | (((1<<nmbRbPerByte)-1)<<rbBitLoc);
25298          startRb = startRb + nmbRbPerByte;
25299       }
25300
25301       rbPtrStartIdx++;
25302    }
25303
25304    /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Adding Debug logs */
25305
25306    /* dsfr_pal_fixes ** 25-March-2013 ** SKS ** Adding Debug logs to print RNTP */
25307
25308    RETVALUE(ROK);
25309 }
25310 #endif
25311
25312 /**
25313  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
25314  *
25315  * @details
25316  *
25317  *     Function : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
25318  *
25319  *     Processing Steps:
25320  *
25321  *  @param[in]  RgSchCellCb     *cell
25322  *  @param[in]  RgSchDlSf       *dlSf
25323  *  @param[in]  U8              rbStrt
25324  *  @param[in]  U8              numRb
25325  *
25326  *  @return Void
25327  **/
25328 #ifdef UNUSE_FUN
25329 #ifdef ANSI
25330 PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
25331 (
25332 RgSchCellCb        *cell,
25333 RgSchUeCb                  *ue,
25334 RgSchDlSf          *dlSf,
25335 RgSchSFRPoolInfo   *sfrPool,
25336 U8                 rbStrt,
25337 U8                 numRb
25338 )
25339 #else
25340 PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
25341 RgSchCellCb        *cell;
25342 RgSchUeCb          *ue;
25343 RgSchDlSf          *dlSf;
25344 RgSchSFRPoolInfo   *sfrPool;
25345 U8                 rbStrt;
25346 U8                 numRb;
25347 #endif
25348 {
25349 #ifndef LTEMAC_SPS
25350    S16 ret;
25351 #endif
25352
25353    TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
25354    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25355    sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25356    
25357 #ifndef LTEMAC_SPS
25358    dlSf->type2Start += numRb;
25359    dlSf->bwAlloced += numRb;
25360    
25361    if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
25362    {
25363       /* Based on RNTP info, the CC user is assigned high power per subframe basis */
25364       if(FALSE == ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge)
25365       {
25366          if((sfrPool->type2Start >= sfrPool->pwrHiCCRange.startRb) &&
25367                (sfrPool->type2Start + numRb < sfrPool->pwrHiCCRange.endRb))
25368          {
25369             ue->lteAdvUeCb.isCCUePHigh = TRUE;
25370
25371             /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
25372             ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
25373             if (ret != ROK)
25374             {
25375                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
25376                         "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
25377                RETVALUE(RFAILED);
25378             }
25379          }
25380       }
25381       else
25382       {
25383          /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
25384          ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
25385          if (ret != ROK)
25386          {
25387             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
25388                      "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
25389             RETVALUE(RFAILED);
25390          }
25391       }
25392    }
25393    sfrPool->type2Start += numRb;
25394    sfrPool->bwAlloced += numRb;
25395 #endif 
25396
25397    RETVALUE(ROK);
25398 }
25399 #endif
25400 /**
25401  * @brief To do DL allocation using TYPE0 RA.
25402  *
25403  * @details
25404  *
25405  *     Function : rgSCHCmnNonDlfsSFRPoolType0Alloc
25406  *
25407  *     Processing Steps:
25408  *      - Perform TYPE0 allocation using the RBGs between type0End and type2End.
25409  *      - Build the allocation mask as per RBG positioning.
25410  *      - Update the allocation parameters.
25411  *
25412  *  @param[in]  RgSchCellCb     *cell
25413  *  @param[in]  RgSchDlSf       *dlSf
25414  *  @param[in]  RgSchDlRbAlloc  *allocInfo
25415  *
25416  *  @return Void
25417  **/
25418 #ifdef UNUSE_FUN
25419 #ifdef ANSI
25420 PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc
25421 (
25422 RgSchCellCb        *cell,
25423 RgSchDlSf          *dlSf,
25424 RgSchSFRPoolInfo   *poolInfo,
25425 RgSchDlRbAlloc     *allocInfo
25426 )
25427 #else
25428 PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, poolInfo, allocInfo)
25429 RgSchCellCb        *cell;
25430 RgSchDlSf          *dlSf;
25431 RgSchSFRPoolInfo   *poolInfo;
25432 RgSchDlRbAlloc     *allocInfo;
25433 #endif
25434 {
25435    U32 dlAllocMsk = 0;
25436    U8  rbgFiller = 0;
25437    U8  noRbgs = 0;
25438    U8  noRbs;
25439    U8  noLyr;
25440    U8  iTbs;
25441
25442    TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
25443
25444    if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
25445    {
25446                 if (poolInfo->type0End == dlSf->bw/4)
25447                 {
25448                         rbgFiller = dlSf->lstRbgDfct;
25449                         /* The last RBG which can be smaller than the RBG size is consedered
25450                         * only for the first time allocation of TYPE0 UE */
25451                         dlSf->lstRbgDfct = 0;
25452                 }
25453    }
25454
25455    noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
25456
25457    /* Abhinav to-do start */
25458    /* MS_FIX for ccpu00123919*/
25459    noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25460    if (dlSf->bwAlloced + noRbs > dlSf->bw)
25461    {
25462       if (--noRbgs == 0)
25463       {
25464          RETVOID;
25465       }
25466       noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25467    }
25468    /* Abhinav to-do end */
25469
25470
25471    
25472    /* type0End would have been initially (during subfrm Init) at the bit position
25473     * (cell->noOfRbgs - 1), 0 being the most significant.
25474     * Getting DlAllocMsk for noRbgs and at the appropriate position */
25475    dlAllocMsk |= (((1 << noRbgs) - 1) << (31 - poolInfo->type0End));
25476    /* Move backwards the type0End pivot */
25477    poolInfo->type0End -= noRbgs;
25478    /*MS_FIX for ccpu00123919*/
25479    /*noRbs = (noRbgs * cell->rbgSize) - rbgFiller;*/
25480    /* Update the bwAlloced field accordingly */
25481    poolInfo->bwAlloced += noRbs + dlSf->lstRbgDfct;
25482    dlSf->bwAlloced += noRbs + dlSf->lstRbgDfct;
25483    
25484    /* Update Type0 Alloc Info */
25485    allocInfo->allocInfo.raType0.numDlAlloc = noRbgs;
25486    allocInfo->allocInfo.raType0.dlAllocBitMask |= dlAllocMsk;
25487    allocInfo->rbsAlloc = noRbs;
25488
25489    /* Update Tb info for each scheduled TB */
25490    iTbs = allocInfo->tbInfo[0].iTbs;
25491    noLyr = allocInfo->tbInfo[0].noLyr;
25492    /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant.
25493     * RETX TB Size is same as Init TX TB Size */
25494    if (allocInfo->tbInfo[0].tbCb->txCntr)
25495    {
25496       allocInfo->tbInfo[0].bytesAlloc =
25497          allocInfo->tbInfo[0].bytesReq;
25498    }
25499    else
25500    {
25501       allocInfo->tbInfo[0].bytesAlloc =
25502          rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25503    }
25504
25505    if (allocInfo->tbInfo[1].schdlngForTb)
25506    {
25507       iTbs = allocInfo->tbInfo[1].iTbs;
25508       noLyr = allocInfo->tbInfo[1].noLyr;
25509       /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant
25510        * RETX TB Size is same as Init TX TB Size */
25511       if (allocInfo->tbInfo[1].tbCb->txCntr)
25512       {
25513          allocInfo->tbInfo[1].bytesAlloc =
25514             allocInfo->tbInfo[1].bytesReq;
25515       }
25516       else
25517       {
25518          allocInfo->tbInfo[1].bytesAlloc =
25519             rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
25520       }
25521    }
25522
25523    /* The last RBG which can be smaller than the RBG size is consedered
25524     * only for the first time allocation of TYPE0 UE */
25525    dlSf->lstRbgDfct = 0;
25526    RETVOID;
25527 }
25528 #endif
25529 /**
25530  * @brief Computes RNTP Info for a subframe.
25531  *
25532  * @details
25533  *
25534  *     Function :  rgSCHCmnNonDlfsDsfrRntpComp 
25535  *
25536  *     Processing Steps:
25537  *      - Computes RNTP info from individual pools.
25538  *
25539  *  @param[in]  RgSchDlSf       *dlSf
25540  *
25541  *  @return  void
25542  
25543  **/
25544 #ifdef ANSI
25545 PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp
25546 (
25547 RgSchCellCb         *cell,
25548 RgSchDlSf          *dlSf
25549 )
25550 #else
25551 PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp(cell, dlSf)
25552 RgSchCellCb         *cell;
25553 RgSchDlSf          *dlSf;
25554 #endif
25555 {
25556    PRIVATE U16 samples = 0;
25557    U16 i;
25558    U16 bwBytes = (dlSf->bw-1)/8;
25559    RgrLoadInfIndInfo *rgrLoadInf;
25560    U16 len;
25561    U16 ret     = ROK;
25562
25563    TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
25564
25565    len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
25566
25567    /* RNTP info is ORed every TTI and the sample is stored in cell control block */ 
25568    for(i = 0; i <= bwBytes; i++)
25569    {
25570      cell->rntpAggrInfo.val[i] |= dlSf->rntpInfo.val[i];
25571    }
25572    samples = samples + 1;
25573    /* After every 1000 ms, the RNTP info will be sent to application to be further sent to all neighbouring eNB
25574          informing them about the load indication for cell edge users */
25575    if(RG_SCH_MAX_RNTP_SAMPLES == samples)
25576    {
25577       /* ccpu00134492 */
25578       ret = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&rgrLoadInf,
25579                sizeof(RgrLoadInfIndInfo));
25580       if (ret != ROK)
25581       {
25582          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
25583             "allocate memory for sending LoadInfo");
25584          RETVOID;  
25585       }
25586      
25587       rgrLoadInf->u.rntpInfo.pres = cell->rntpAggrInfo.pres;
25588       /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
25589       rgrLoadInf->u.rntpInfo.len  = len;
25590
25591       /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
25592       rgrLoadInf->u.rntpInfo.val = cell->rntpAggrInfo.val; 
25593       rgrLoadInf->cellId = cell->cellId;
25594
25595       /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
25596       rgrLoadInf->bw = dlSf->bw;
25597       rgrLoadInf->type = RGR_SFR;
25598
25599       ret = rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf);
25600       if(ret == RFAILED)
25601       {
25602          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsDsfrRntpComp():"
25603                   "rgSCHUtlRgrLoadInfInd() returned RFAILED");
25604       }
25605
25606       cmMemset(cell->rntpAggrInfo.val,0,len);
25607       samples = 0;
25608    }
25609  } 
25610 /* LTE_ADV_FLAG_REMOVED_END */
25611
25612 /* LTE_ADV_FLAG_REMOVED_START */
25613 /**
25614  * @brief Performs RB allocation per UE from a pool.
25615  *
25616  * @details
25617  *
25618  *     Function : rgSCHCmnSFRNonDlfsUeRbAlloc
25619  *
25620  *     Processing Steps:
25621  *      - Allocate consecutively available RBs.
25622  *
25623  *  @param[in]  RgSchCellCb     *cell
25624  *  @param[in]  RgSchUeCb       *ue
25625  *  @param[in]  RgSchDlSf       *dlSf
25626  *  @param[out] U8              *isDlBwAvail
25627  *
25628  *  @return  S16
25629  *      -# ROK
25630  *      -# RFAILED
25631  **/
25632 #ifdef UNUSE_FUN
25633 #ifdef ANSI
25634 PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc
25635 (
25636 RgSchCellCb        *cell,
25637 RgSchUeCb          *ue,
25638 RgSchDlSf          *dlSf,
25639 U8                 *isDlBwAvail
25640 )
25641 #else
25642 PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
25643 RgSchCellCb        *cell;
25644 RgSchUeCb          *ue;
25645 RgSchDlSf          *dlSf;
25646 U8                 *isDlBwAvail;
25647 #endif
25648 {
25649    RgSchDlRbAlloc  *allocInfo;
25650    RgSchCmnDlUe    *dlUe;
25651    Bool isUECellEdge;
25652    RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
25653
25654    TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
25655
25656    isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
25657
25658    dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
25659    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
25660    *isDlBwAvail = TRUE;
25661
25662    /*Find which pool is available for this UE*/
25663    if (rgSCHCmnNonDlfsSFRBwAvlbl(cell,  &sfrpoolInfo, dlSf, allocInfo, isUECellEdge) != TRUE)
25664    {
25665       /* SFR_FIX - If this is CE UE there may be BW available in CC Pool
25666          So CC UEs will be scheduled */
25667       if (isUECellEdge)
25668       {
25669          *isDlBwAvail = TRUE;
25670       }
25671       else
25672       {
25673          *isDlBwAvail = FALSE;
25674       }
25675       RETVALUE(RFAILED);
25676    }
25677
25678    if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX || dlUe->proc->tbInfo[1].isAckNackDtx)
25679    {
25680       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat, TRUE);
25681    }
25682    else
25683    {
25684       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat,FALSE);
25685    }
25686    
25687    if (!(allocInfo->pdcch))
25688    {
25689       /* Returning ROK since PDCCH might be available for another UE and further allocations could be done */
25690       RETVALUE(RFAILED);
25691    }
25692    
25693 #ifdef LTEMAC_SPS
25694    allocInfo->rnti = ue->ueId;
25695 #endif
25696
25697    if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
25698    {
25699       allocInfo->allocInfo.raType2.isLocal = TRUE;
25700       /* rg004.201 patch - ccpu00109921 fix end */
25701       /* MS_FIX for ccpu00123918*/
25702       allocInfo->allocInfo.raType2.rbStart = (U8)sfrpoolInfo->type2Start;
25703       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
25704       /* rg007.201 - Changes for MIMO feature addition */
25705       /* rg008.201 - Removed dependency on MIMO compile-time flag */
25706       rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrpoolInfo, \
25707             allocInfo->allocInfo.raType2.rbStart, \
25708             allocInfo->allocInfo.raType2.numRb);
25709       allocInfo->rbsAlloc = allocInfo->rbsReq;
25710       allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25711    }
25712    else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
25713    {
25714       rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, sfrpoolInfo, allocInfo);
25715    }
25716 #ifndef LTE_TDD
25717 #ifdef DEBUGP
25718    rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,0);
25719    if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
25720    {
25721       rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,1);
25722    }
25723 #endif
25724 #endif
25725
25726 #if defined(LTEMAC_SPS)
25727    /* Update the sub-frame with new allocation */
25728    dlSf->bwAlloced += allocInfo->rbsReq;
25729 #endif
25730
25731    RETVALUE(ROK);
25732 }
25733 #endif
25734 /* LTE_ADV_FLAG_REMOVED_END */
25735 #endif /* LTE_TDD */
25736
25737 /**
25738  * @brief Performs RB allocation per UE for frequency non-selective cell.
25739  *
25740  * @details
25741  *
25742  *     Function : rgSCHCmnNonDlfsUeRbAlloc
25743  *
25744  *     Processing Steps:
25745  *      - Allocate consecutively available RBs.
25746  *
25747  *  @param[in]  RgSchCellCb     *cell
25748  *  @param[in]  RgSchUeCb       *ue
25749  *  @param[in]  RgSchDlSf       *dlSf
25750  *  @param[out] U8              *isDlBwAvail
25751  *
25752  *  @return  S16
25753  *      -# ROK
25754  *      -# RFAILED
25755  **/
25756 #ifdef ANSI
25757 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc
25758 (
25759 RgSchCellCb        *cell,
25760 RgSchUeCb          *ue,
25761 RgSchDlSf          *dlSf,
25762 U8                 *isDlBwAvail
25763 )
25764 #else
25765 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
25766 RgSchCellCb        *cell;
25767 RgSchUeCb          *ue;
25768 RgSchDlSf          *dlSf;
25769 U8                 *isDlBwAvail;
25770 #endif
25771 {
25772    RgSchDlRbAlloc  *allocInfo;
25773    RgSchCmnDlUe    *dlUe;
25774 #ifdef LAA_DBG
25775    U32            dbgRbsReq = 0;
25776 #endif
25777    TRC2(rgSCHCmnNonDlfsUeRbAlloc);
25778
25779 #ifdef RG_5GTF
25780    RgSch5gtfUeCb  *ue5gtfCb = &(ue->ue5gtfCb);
25781         RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[ue5gtfCb->BeamId]);
25782 #endif
25783    dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
25784    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
25785    *isDlBwAvail = TRUE;
25786
25787         if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
25788         {
25789            RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
25790          "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
25791          ue->ueId);
25792            printf("5GTF_ERROR vrbg allocated > 25\n");
25793                 RETVALUE(RFAILED);
25794         }
25795
25796    if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX 
25797        || dlUe->proc->tbInfo[1].isAckNackDtx)
25798    {
25799       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat, TRUE);
25800    }
25801    else
25802    {
25803       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat,FALSE);
25804    }
25805    if (!(allocInfo->pdcch))
25806    {
25807       /* Returning ROK since PDCCH might be available for another UE and
25808        * further allocations could be done */
25809       RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
25810          "5GTF_ERROR : PDCCH allocation failed :ue (%u)",
25811          ue->ueId);
25812            printf("5GTF_ERROR PDCCH allocation failed\n");
25813       RETVALUE(RFAILED);
25814    }
25815 #ifdef RG_5GTF
25816         //maxPrb = RGSCH_MIN((allocInfo->vrbgReq * MAX_5GTF_VRBG_SIZE), ue5gtfCb->maxPrb);
25817    //maxPrb = RGSCH_MIN(maxPrb, 
25818                 //((beamInfo->totVrbgAvail - beamInfo->vrbgStart)* MAX_5GTF_VRBG_SIZE)));
25819         //TODO_SID Need to check for vrbg available after scheduling for same beam.
25820         allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart = beamInfo->vrbgStart;
25821         allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg = allocInfo->vrbgReq;
25822         //TODO_SID: Setting for max TP
25823         allocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange = 1;      
25824         allocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
25825          allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart, allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg);
25826         allocInfo->tbInfo[0].tbCb->dlGrnt.SCID = 0;
25827         allocInfo->tbInfo[0].tbCb->dlGrnt.dciFormat = allocInfo->dciFormat;
25828    //Filling temporarily
25829    allocInfo->tbInfo[0].tbCb->dlGrnt.rbStrt = (allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
25830    allocInfo->tbInfo[0].tbCb->dlGrnt.numRb = (allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
25831
25832         beamInfo->vrbgStart += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg;
25833         beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg; 
25834         allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25835 #endif
25836
25837    RETVALUE(ROK);
25838 }
25839
25840 #ifdef RGR_V1
25841 /**
25842  * @brief Performs RB allocation for Msg4 for frequency non-selective cell.
25843  *
25844  * @details
25845  *
25846  *     Function : rgSCHCmnNonDlfsCcchSduAlloc
25847  *
25848  *     Processing Steps:
25849  *     - For each element in the list, Call rgSCHCmnNonDlfsCcchSduRbAlloc().
25850  *        - If allocation is successful, add the ueCb to scheduled list of CCCH
25851  *        SDU.
25852  *        - else, add UeCb to non-scheduled list.
25853  *
25854  *  @param[in]      RgSchCellCb         *cell
25855  *  @param[in, out] RgSchCmnCcchSduRbAlloc *allocInfo
25856  *  @param[in]      U8                  isRetx
25857  *
25858  *  @return  Void
25859  **/
25860 #ifdef ANSI
25861 PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc
25862 (
25863 RgSchCellCb         *cell,
25864 RgSchCmnCcchSduRbAlloc *allocInfo,
25865 U8                  isRetx
25866 )
25867 #else
25868 PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
25869 RgSchCellCb         *cell;
25870 RgSchCmnCcchSduRbAlloc *allocInfo;
25871 U8                  isRetx;
25872 #endif
25873 {
25874    S16             ret;
25875    CmLListCp       *ccchSduLst        = NULLP;
25876    CmLListCp       *schdCcchSduLst    = NULLP;
25877    CmLListCp       *nonSchdCcchSduLst = NULLP;
25878    CmLList         *schdLnkNode    = NULLP;
25879    CmLList         *toBeSchdLnk    = NULLP;
25880    RgSchDlSf       *dlSf           = allocInfo->ccchSduDlSf;
25881    RgSchUeCb       *ueCb           = NULLP;
25882    RgSchDlHqProcCb *hqP            = NULLP;
25883    TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
25884
25885    if (isRetx)
25886    {
25887       /* Initialize re-transmitting lists */
25888       ccchSduLst = &(allocInfo->ccchSduRetxLst);
25889       schdCcchSduLst = &(allocInfo->schdCcchSduRetxLst);
25890       nonSchdCcchSduLst = &(allocInfo->nonSchdCcchSduRetxLst);
25891    }
25892    else
25893    {
25894       /* Initialize transmitting lists */
25895       ccchSduLst = &(allocInfo->ccchSduTxLst);
25896       schdCcchSduLst = &(allocInfo->schdCcchSduTxLst);
25897       nonSchdCcchSduLst = &(allocInfo->nonSchdCcchSduTxLst);
25898    }
25899
25900    /* Perform allocaations  for the list */
25901    toBeSchdLnk = cmLListFirst(ccchSduLst);
25902    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
25903    {
25904       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
25905       ueCb = hqP->hqE->ue;
25906       schdLnkNode = &hqP->schdLstLnk;
25907       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
25908       ret = rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf);
25909       if (ret != ROK)
25910       {
25911          /* Allocation failed: Add remaining MSG4 nodes to non-scheduled
25912           * list and return */
25913          do
25914          {
25915             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
25916             ueCb = hqP->hqE->ue;
25917             schdLnkNode = &hqP->schdLstLnk;
25918             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
25919             cmLListAdd2Tail(nonSchdCcchSduLst, schdLnkNode);
25920             toBeSchdLnk = toBeSchdLnk->next;
25921          } while(toBeSchdLnk);
25922          RETVOID;
25923       }
25924
25925       /* Allocation successful: Add UE to the scheduled list */
25926       cmLListAdd2Tail(schdCcchSduLst, schdLnkNode);
25927    }
25928
25929
25930    RETVOID;
25931 }
25932
25933 /**
25934  * @brief Performs RB allocation for CcchSdu for frequency non-selective cell.
25935  *
25936  * @details
25937  *
25938  *     Function : rgSCHCmnNonDlfsCcchSduRbAlloc
25939  *
25940  *     Processing Steps:
25941  *     - Fetch PDCCH
25942  *     - Allocate consecutively available RBs
25943  *
25944  *  @param[in] RgSchCellCb     *cell
25945  *  @param[in] RgSchUeCb       *ueCb
25946  *  @param[in] RgSchDlSf       *dlSf
25947  *  @return  S16
25948  *      -# ROK
25949  *      -# RFAILED
25950  **/
25951 #ifdef ANSI
25952 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc
25953 (
25954 RgSchCellCb        *cell,
25955 RgSchUeCb          *ueCb,
25956 RgSchDlSf          *dlSf
25957 )
25958 #else
25959 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf)
25960 RgSchCellCb        *cell;
25961 RgSchUeCb          *ueCb;
25962 RgSchDlSf          *dlSf;
25963 #endif
25964 {
25965    RgSchDlRbAlloc  *allocInfo;
25966    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
25967
25968    TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
25969
25970
25971    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
25972
25973    /* [ccpu00138802]-MOD-If Bw is less than required, return fail
25974       It will be allocated in next TTI */
25975 #ifdef LTEMAC_SPS
25976    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
25977          (dlSf->bwAlloced == dlSf->bw))
25978 #else
25979    if((dlSf->bwAlloced == dlSf->bw) ||
25980       (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
25981 #endif
25982    {
25983       RETVALUE(RFAILED);
25984    }
25985    /* Retrieve PDCCH */
25986    /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
25987    if (ueDl->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX)
25988    {
25989       /*      allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, dlSf, y, ueDl->cqi,
25990        *      TFU_DCI_FORMAT_1A, TRUE);*/
25991       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ueCb, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, TRUE);
25992    }
25993    else
25994    {
25995       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ueCb, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE);
25996    }
25997    if (!(allocInfo->pdcch))
25998    {
25999       /* Returning RFAILED since PDCCH not available for any CCCH allocations */
26000       RETVALUE(RFAILED);
26001    }
26002
26003    /* Update allocation information */
26004    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
26005    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
26006    allocInfo->allocInfo.raType2.isLocal = TRUE;
26007
26008       /*Fix for ccpu00123918*/
26009       /* Push this harq process back to the free queue */
26010       allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
26011       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
26012       allocInfo->rbsAlloc = allocInfo->rbsReq;
26013       allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26014       /* Update the sub-frame with new allocation */
26015       /* ccpu00129469 */
26016       /* LTE_ADV_FLAG_REMOVED_START */
26017 #ifndef LTE_TDD
26018       if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
26019       {
26020          rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf,
26021                allocInfo->allocInfo.raType2.rbStart,
26022                allocInfo->allocInfo.raType2.numRb);
26023       }
26024       else
26025 #endif /* end of ifndef LTE_TDD*/
26026       {
26027          rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, 
26028                allocInfo->allocInfo.raType2.rbStart, 
26029                allocInfo->allocInfo.raType2.numRb);
26030       }
26031
26032    /* LTE_ADV_FLAG_REMOVED_END */
26033    /* ccpu00131941 - bwAlloced is updated from SPS bandwidth */  
26034
26035
26036    RETVALUE(ROK);
26037 }
26038 #endif
26039
26040 /**
26041  * @brief Performs RB allocation for Msg4 for frequency non-selective cell.
26042  *
26043  * @details
26044  *
26045  *     Function : rgSCHCmnNonDlfsMsg4RbAlloc
26046  *
26047  *     Processing Steps:
26048  *     - Fetch PDCCH
26049  *     - Allocate consecutively available RBs
26050  *
26051  *  @param[in] RgSchCellCb     *cell
26052  *  @param[in] RgSchRaCb       *raCb
26053  *  @param[in] RgSchDlSf       *dlSf
26054  *  @return  S16
26055  *      -# ROK
26056  *      -# RFAILED
26057  **/
26058 #ifdef ANSI
26059 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc
26060 (
26061 RgSchCellCb        *cell,
26062 RgSchRaCb          *raCb,
26063 RgSchDlSf          *dlSf
26064 )
26065 #else
26066 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf)
26067 RgSchCellCb        *cell;
26068 RgSchRaCb          *raCb;
26069 RgSchDlSf          *dlSf;
26070 #endif
26071 {
26072    RgSchDlRbAlloc  *allocInfo;
26073    TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
26074
26075
26076    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
26077
26078 #ifdef RG_5GTF
26079         RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[0]);
26080         if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
26081         {
26082            RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
26083          "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
26084          raCb->ue->ueId);
26085            printf("5GTF_ERROR vrbg allocated > 25\n");
26086                 RETVALUE(RFAILED);
26087         }
26088 #endif
26089 #ifdef LTEMAC_SPS
26090    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
26091          (dlSf->bwAlloced == dlSf->bw))
26092 #else
26093    if((dlSf->bwAlloced == dlSf->bw) ||
26094             (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
26095 #endif
26096    {
26097
26098       RETVALUE(RFAILED);
26099    }
26100
26101    /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
26102    if (raCb->dlHqE->msg4Proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX)
26103    {
26104       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, raCb->ue, dlSf, raCb->ccchCqi, TFU_DCI_FORMAT_B1, TRUE);
26105    }
26106    else
26107    {
26108       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, raCb->ue, dlSf, raCb->ccchCqi, TFU_DCI_FORMAT_B1, FALSE);
26109    }
26110    if (!(allocInfo->pdcch))
26111    {
26112       /* Returning RFAILED since PDCCH not available for any CCCH allocations */
26113       RETVALUE(RFAILED);
26114    }
26115    
26116 #ifndef RG_5GTF
26117  /* SR_RACH_STATS : MSG4 TX Failed */
26118    allocInfo->pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4 = TRUE;
26119
26120    /* Update allocation information */
26121    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
26122    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
26123    allocInfo->allocInfo.raType2.isLocal = TRUE;
26124
26125
26126         /*Fix for ccpu00123918*/
26127         allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
26128         allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
26129         /* LTE_ADV_FLAG_REMOVED_START */
26130 #ifndef LTE_TDD
26131         if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
26132         {
26133           rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, \
26134                 allocInfo->allocInfo.raType2.rbStart, \
26135                 allocInfo->allocInfo.raType2.numRb);
26136         }
26137         else
26138 #endif /* end of ifndef LTE_TDD */
26139         {
26140           rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, \
26141                 allocInfo->allocInfo.raType2.rbStart, \
26142                 allocInfo->allocInfo.raType2.numRb);
26143         }
26144         /* LTE_ADV_FLAG_REMOVED_END */
26145
26146    allocInfo->rbsAlloc = allocInfo->rbsReq;
26147    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26148
26149 #else
26150
26151   allocInfo->pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4 = TRUE;
26152
26153         allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart = beamInfo->vrbgStart;
26154         allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg = allocInfo->vrbgReq;
26155
26156    /* Update allocation information */
26157    allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
26158
26159         allocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange = 1;      
26160         allocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
26161          allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart, allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg);
26162
26163    allocInfo->tbInfo[0].tbCb->dlGrnt.rbStrt = (allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
26164    allocInfo->tbInfo[0].tbCb->dlGrnt.numRb = (allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
26165
26166
26167         beamInfo->vrbgStart += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg;
26168         beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg; 
26169         allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26170
26171 #endif
26172
26173    RETVALUE(ROK);
26174 }
26175
26176 /**
26177  * @brief Performs RB allocation for Msg4 lists of frequency non-selective cell.
26178  *
26179  * @details
26180  *
26181  *     Function : rgSCHCmnNonDlfsMsg4Alloc
26182  *
26183  *     Processing Steps:
26184  *     - For each element in the list, Call rgSCHCmnNonDlfsMsg4RbAlloc().
26185  *        - If allocation is successful, add the raCb to scheduled list of MSG4.
26186  *        - else, add RaCb to non-scheduled list.
26187  *
26188  *  @param[in]      RgSchCellCb         *cell
26189  *  @param[in, out] RgSchCmnMsg4RbAlloc *allocInfo
26190  *  @param[in]      U8                  isRetx
26191  *
26192  *  @return  Void
26193  **/
26194 #ifdef ANSI
26195 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc
26196 (
26197 RgSchCellCb         *cell,
26198 RgSchCmnMsg4RbAlloc *allocInfo,
26199 U8                  isRetx
26200 )
26201 #else
26202 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
26203 RgSchCellCb         *cell;
26204 RgSchCmnMsg4RbAlloc *allocInfo;
26205 U8                  isRetx;
26206 #endif
26207 {
26208    S16             ret;
26209    CmLListCp       *msg4Lst        = NULLP;
26210    CmLListCp       *schdMsg4Lst    = NULLP;
26211    CmLListCp       *nonSchdMsg4Lst = NULLP;
26212    CmLList         *schdLnkNode    = NULLP;
26213    CmLList         *toBeSchdLnk    = NULLP;
26214    RgSchDlSf       *dlSf           = allocInfo->msg4DlSf;
26215    RgSchRaCb       *raCb           = NULLP;
26216    RgSchDlHqProcCb *hqP            = NULLP;
26217    TRC2(rgSCHCmnNonDlfsMsg4Alloc);
26218
26219    if (isRetx)
26220    {
26221       /* Initialize re-transmitting lists */
26222       msg4Lst = &(allocInfo->msg4RetxLst);
26223       schdMsg4Lst = &(allocInfo->schdMsg4RetxLst);
26224       nonSchdMsg4Lst = &(allocInfo->nonSchdMsg4RetxLst);
26225    }
26226    else
26227    {
26228       /* Initialize transmitting lists */
26229       msg4Lst = &(allocInfo->msg4TxLst);
26230       schdMsg4Lst = &(allocInfo->schdMsg4TxLst);
26231       nonSchdMsg4Lst = &(allocInfo->nonSchdMsg4TxLst);
26232    }
26233
26234    /* Perform allocaations  for the list */
26235    toBeSchdLnk = cmLListFirst(msg4Lst);
26236    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
26237    {
26238       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26239       raCb = hqP->hqE->raCb;
26240       schdLnkNode = &hqP->schdLstLnk;
26241       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26242       ret = rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf);
26243       if (ret != ROK)
26244       {
26245          /* Allocation failed: Add remaining MSG4 nodes to non-scheduled
26246           * list and return */
26247          do
26248          {
26249             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26250             raCb = hqP->hqE->raCb;
26251             schdLnkNode = &hqP->schdLstLnk;
26252             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26253             cmLListAdd2Tail(nonSchdMsg4Lst, schdLnkNode);
26254             toBeSchdLnk = toBeSchdLnk->next;
26255          } while(toBeSchdLnk);
26256          RETVOID;
26257       }
26258
26259       /* Allocation successful: Add UE to the scheduled list */
26260       cmLListAdd2Tail(schdMsg4Lst, schdLnkNode);
26261       if (isRetx)
26262       {
26263       }
26264    }
26265
26266
26267    RETVOID;
26268 }
26269
26270 /**
26271  * @brief Performs RB allocation for the list of UEs of a frequency
26272  * non-selective cell.
26273  *
26274  * @details
26275  *
26276  *     Function : rgSCHCmnNonDlfsDedRbAlloc
26277  *
26278  *     Processing Steps:
26279  *     - For each element in the list, Call rgSCHCmnNonDlfsUeRbAlloc().
26280  *        - If allocation is successful, add the ueCb to scheduled list of UEs.
26281  *        - else, add ueCb to non-scheduled list of UEs.
26282  *
26283  *  @param[in]      RgSchCellCb        *cell
26284  *  @param[in, out] RgSchCmnUeRbAlloc  *allocInfo
26285  *  @param[in]      CmLListCp          *ueLst,
26286  *  @param[in, out] CmLListCp          *schdHqPLst,
26287  *  @param[in, out] CmLListCp          *nonSchdHqPLst
26288  *
26289  *  @return  Void
26290  **/
26291 #ifdef ANSI
26292 PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc
26293 (
26294 RgSchCellCb        *cell,
26295 RgSchCmnUeRbAlloc  *allocInfo,
26296 CmLListCp          *ueLst,
26297 CmLListCp          *schdHqPLst,
26298 CmLListCp          *nonSchdHqPLst
26299 )
26300 #else
26301 PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
26302         schdHqPLst, nonSchdHqPLst)
26303 RgSchCellCb        *cell;
26304 RgSchCmnUeRbAlloc  *allocInfo;
26305 CmLListCp          *ueLst;
26306 CmLListCp          *schdHqPLst;
26307 CmLListCp          *nonSchdHqPLst;
26308 #endif
26309 {
26310    S16             ret;
26311    CmLList         *schdLnkNode  = NULLP;
26312    CmLList         *toBeSchdLnk  = NULLP;
26313    RgSchDlSf       *dlSf         = allocInfo->dedDlSf;
26314    RgSchUeCb       *ue           = NULLP;
26315    RgSchDlHqProcCb *hqP          = NULLP;
26316    U8              isDlBwAvail;
26317    TRC2(rgSCHCmnNonDlfsDedRbAlloc);
26318
26319
26320    /* Perform allocaations  for the list */
26321    toBeSchdLnk = cmLListFirst(ueLst);
26322    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
26323    {
26324       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26325       ue = hqP->hqE->ue;
26326       schdLnkNode = &hqP->schdLstLnk;
26327       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26328
26329       ret = rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, &isDlBwAvail);
26330       if (!isDlBwAvail)
26331       {
26332          /* Allocation failed: Add remaining UEs to non-scheduled
26333           * list and return */
26334          do
26335          {
26336             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26337             ue = hqP->hqE->ue;
26338             schdLnkNode = &hqP->schdLstLnk;
26339             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26340             cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
26341             toBeSchdLnk = toBeSchdLnk->next;
26342          } while(toBeSchdLnk);
26343          break; 
26344       }
26345
26346       if (ret == ROK)
26347       {
26348 #if defined (TENB_STATS) && defined (RG_5GTF)
26349          cell->tenbStats->sch.dl5gtfRbAllocPass++;
26350 #endif
26351          /* Allocation successful: Add UE to the scheduled list */
26352          cmLListAdd2Tail(schdHqPLst, schdLnkNode);
26353       }
26354       else
26355       {
26356 #if defined (TENB_STATS) && defined (RG_5GTF)
26357          cell->tenbStats->sch.dl5gtfRbAllocFail++;
26358 #endif
26359          /* Allocation failed : Add UE to the non-scheduled list */
26360                         printf("5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
26361          cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
26362       }
26363    }
26364
26365    RETVOID;
26366 }
26367
26368 /**
26369  * @brief Handles RB allocation for frequency non-selective cell.
26370  *
26371  * @details
26372  *
26373  *     Function : rgSCHCmnNonDlfsRbAlloc
26374  *
26375  *     Invoking Module Processing:
26376  *      - SCH shall invoke this if downlink frequency selective is disabled for
26377  *        the cell for RB allocation.
26378  *      - MAX C/I/PFS/RR shall provide the requiredBytes, required RBs
26379  *        estimate and subframe for each allocation to be made to SCH.
26380  *
26381  *     Processing Steps:
26382  *     - Allocate sequentially for common channels.
26383  *     - For transmitting and re-transmitting UE list.
26384  *      - For each UE:
26385  *       - Perform wide-band allocations for UE in increasing order of
26386  *         frequency.
26387  *       - Determine Imcs for the allocation.
26388  *       - Determine RA type.
26389  *       - Determine DCI format.
26390  *
26391  *  @param[in]  RgSchCellCb        *cell
26392  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
26393  *  @return  Void
26394  **/
26395
26396 #ifdef ANSI
26397 PUBLIC Void rgSCHCmnNonDlfsRbAlloc
26398 (
26399 RgSchCellCb           *cell,
26400 RgSchCmnDlRbAllocInfo *allocInfo
26401 )
26402 #else
26403 PUBLIC Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
26404 RgSchCellCb           *cell;
26405 RgSchCmnDlRbAllocInfo *allocInfo;
26406 #endif
26407 {
26408    U8                 raRspCnt = 0;
26409    RgSchDlRbAlloc     *reqAllocInfo;
26410    TRC2(rgSCHCmnNonDlfsRbAlloc);
26411
26412    /* Allocate for MSG4 retransmissions */
26413    if (allocInfo->msg4Alloc.msg4RetxLst.count)
26414    {
26415       printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
26416       rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), TRUE);
26417    }
26418
26419    /* Allocate for MSG4 transmissions */
26420    /* Assuming all the nodes in the list need allocations: rbsReq is valid */
26421    if (allocInfo->msg4Alloc.msg4TxLst.count)
26422    {
26423       printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
26424       rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), FALSE);
26425    }
26426 #ifdef RGR_V1
26427    /* Allocate for CCCH SDU (received after guard timer expiry)
26428     * retransmissions */
26429    if (allocInfo->ccchSduAlloc.ccchSduRetxLst.count)
26430    {
26431       printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
26432       rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), TRUE);
26433    }
26434
26435    /* Allocate for CCCD SDU transmissions */
26436    /* Allocate for CCCH SDU (received after guard timer expiry) transmissions */
26437    if (allocInfo->ccchSduAlloc.ccchSduTxLst.count)
26438    {
26439       printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
26440       rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), FALSE);
26441    }
26442 #endif
26443
26444    /* Allocate for Random access response */
26445    for (raRspCnt = 0; raRspCnt < RG_SCH_CMN_MAX_CMN_PDCCH; ++raRspCnt)
26446    {
26447       /* Assuming that the requests will be filled in sequentially */
26448       reqAllocInfo = &(allocInfo->raRspAlloc[raRspCnt]);
26449       if (!reqAllocInfo->rbsReq)
26450       {
26451          break;
26452       }
26453       printf("5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
26454    //   if ((rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo)) != ROK)
26455       if ((rgSCHCmnNonDlfsCmnRbAllocRar(cell, reqAllocInfo)) != ROK)
26456       {
26457          break;
26458       }
26459    }
26460
26461    /* Allocate for RETX+TX UEs */
26462    if(allocInfo->dedAlloc.txRetxHqPLst.count)
26463    {
26464       printf("5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
26465       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26466             &(allocInfo->dedAlloc.txRetxHqPLst),
26467             &(allocInfo->dedAlloc.schdTxRetxHqPLst),
26468             &(allocInfo->dedAlloc.nonSchdTxRetxHqPLst));
26469    }
26470
26471    if((allocInfo->dedAlloc.retxHqPLst.count))
26472    {
26473       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26474             &(allocInfo->dedAlloc.retxHqPLst),
26475             &(allocInfo->dedAlloc.schdRetxHqPLst),
26476             &(allocInfo->dedAlloc.nonSchdRetxHqPLst));
26477    }
26478
26479    /* Allocate for transmitting UEs */
26480    if((allocInfo->dedAlloc.txHqPLst.count))
26481    {
26482       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26483             &(allocInfo->dedAlloc.txHqPLst),
26484             &(allocInfo->dedAlloc.schdTxHqPLst),
26485             &(allocInfo->dedAlloc.nonSchdTxHqPLst));
26486    }
26487    {
26488       RgSchCmnCell  *cmnCell = RG_SCH_CMN_GET_CELL(cell);
26489       if ((allocInfo->dedAlloc.txRetxHqPLst.count + 
26490                allocInfo->dedAlloc.retxHqPLst.count + 
26491                allocInfo->dedAlloc.txHqPLst.count) > 
26492             cmnCell->dl.maxUePerDlSf)
26493       {
26494 #ifndef ALIGN_64BIT
26495          RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
26496                   " scheduler exceed maximumUePerDlSf(%u)tx-retx %ld retx %ld tx %ld\n",
26497                   cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
26498                   allocInfo->dedAlloc.retxHqPLst.count,
26499                   allocInfo->dedAlloc.txHqPLst.count));
26500 #else
26501          RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
26502                   " scheduler exceed maximumUePerDlSf(%u)tx-retx %d retx %d tx %d\n",
26503                   cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
26504                   allocInfo->dedAlloc.retxHqPLst.count,
26505                   allocInfo->dedAlloc.txHqPLst.count));
26506 #endif
26507       }
26508    }
26509 #ifndef LTE_TDD
26510    /* LTE_ADV_FLAG_REMOVED_START */
26511    if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
26512    {    
26513       printf("5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
26514       rgSCHCmnNonDlfsDsfrRntpComp(cell, allocInfo->dedAlloc.dedDlSf); 
26515    }  
26516    /* LTE_ADV_FLAG_REMOVED_END */
26517 #endif /* LTE_TDD */
26518    RETVOID;
26519 }
26520
26521 /***********************************************************
26522  *
26523  *     Func : rgSCHCmnCalcRiv
26524  *
26525  *     Desc : This function calculates RIV.
26526  *
26527  *     Ret  : None.
26528  *
26529  *     Notes: None.
26530  *
26531  *     File : rg_sch_utl.c
26532  *
26533  **********************************************************/
26534 #ifdef LTEMAC_SPS
26535 #ifdef ANSI
26536 PUBLIC U32 rgSCHCmnCalcRiv
26537 (
26538 U8           bw,
26539 U8           rbStart,
26540 U8           numRb
26541 )
26542 #else
26543 PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
26544 U8           bw;
26545 U8           rbStart;
26546 U8           numRb;
26547 #endif
26548 #else
26549 #ifdef ANSI
26550 PUBLIC U32 rgSCHCmnCalcRiv
26551 (
26552 U8           bw,
26553 U8           rbStart,
26554 U8           numRb
26555 )
26556 #else
26557 PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
26558 U8           bw;
26559 U8           rbStart;
26560 U8           numRb;
26561 #endif
26562 #endif
26563 {
26564    U8           numRbMinus1 = numRb - 1;
26565    U32          riv;
26566
26567    TRC2(rgSCHCmnCalcRiv);
26568
26569    if (numRbMinus1 <= bw/2)
26570    {
26571       riv = bw * numRbMinus1 + rbStart;
26572    }
26573    else
26574    {
26575       riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
26576    }
26577    RETVALUE(riv);
26578 } /* rgSCHCmnCalcRiv */
26579
26580 #ifdef LTE_TDD
26581 /**
26582  * @brief This function allocates and copies the RACH response scheduling
26583  *        related information into cell control block.
26584  *
26585  * @details
26586  *
26587  *     Function: rgSCHCmnDlCpyRachInfo
26588  *     Purpose:  This function allocates and copies the RACH response
26589  *               scheduling related information into cell control block
26590  *               for each DL subframe.
26591  *
26592  *
26593  *     Invoked by: Scheduler
26594  *
26595  *  @param[in]  RgSchCellCb*           cell
26596  *  @param[in]  RgSchTddRachRspLst     rachRspLst[][RGSCH_NUM_SUB_FRAMES]
26597  *  @param[in]  U8                     raArrSz
26598  *  @return     S16
26599  *
26600  **/
26601 #ifdef ANSI
26602 PRIVATE S16 rgSCHCmnDlCpyRachInfo
26603 (
26604 RgSchCellCb                *cell,
26605 RgSchTddRachRspLst         rachRspLst[][RGSCH_NUM_SUB_FRAMES],
26606 U8                         raArrSz
26607 )
26608 #else
26609 PRIVATE S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
26610 RgSchCellCb                *cell;
26611 RgSchTddRachRspLst         rachRspLst[][RGSCH_NUM_SUB_FRAMES];
26612 U8                         raArrSz;
26613 #endif
26614 {
26615    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
26616    U8                   sfNum;
26617    S16                  sfnIdx;
26618    U16                  subfrmIdx;
26619    U8                   numRfs;
26620    U8                   numSubfrms;
26621    U8                   sfcount;
26622    S16                   ret;
26623
26624    TRC2(rgSCHCmnDlCpyRachInfo);
26625
26626    /* Allocate RACH response information for each DL
26627     * subframe in a radio frame */
26628    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cell->rachRspLst,
26629          rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1] *
26630          sizeof(RgSchTddRachRspLst));
26631    if (ret != ROK)
26632    {
26633       RETVALUE(ret);
26634    }
26635
26636    for(sfnIdx=raArrSz-1; sfnIdx>=0; sfnIdx--)
26637    {
26638       for(subfrmIdx=0; subfrmIdx < RGSCH_NUM_SUB_FRAMES; subfrmIdx++)
26639       {
26640          subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][subfrmIdx];
26641          if(subfrmIdx == RGSCH_NUM_SUB_FRAMES)
26642          {
26643             break;
26644          }
26645
26646          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rachRspLst[sfnIdx],subfrmIdx);
26647          numSubfrms =
26648             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
26649
26650          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchTddNumDlSubfrmTbl[ulDlCfgIdx],subfrmIdx);
26651          sfNum = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][subfrmIdx]-1;
26652          numRfs = cell->rachRspLst[sfNum].numRadiofrms;
26653          /* For each DL subframe in which RACH response can
26654           * be sent is updated */
26655          if(numSubfrms > 0)
26656          {
26657             cell->rachRspLst[sfNum].rachRsp[numRfs].sfnOffset =
26658                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].sfnOffset;
26659             for(sfcount=0; sfcount < numSubfrms; sfcount++)
26660             {
26661                cell->rachRspLst[sfNum].rachRsp[numRfs].\
26662                   subframe[sfcount] =
26663                   rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].\
26664                   subframe[sfcount];
26665             }
26666             cell->rachRspLst[sfNum].rachRsp[numRfs].numSubfrms =
26667                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
26668             cell->rachRspLst[sfNum].numRadiofrms++;
26669          }
26670
26671          /* Copy the subframes to be deleted at ths subframe */
26672          numSubfrms =
26673             rachRspLst[sfnIdx][subfrmIdx].delInfo.numSubfrms;
26674          if(numSubfrms > 0)
26675          {
26676             cell->rachRspLst[sfNum].delInfo.sfnOffset =
26677                rachRspLst[sfnIdx][subfrmIdx].delInfo.sfnOffset;
26678             for(sfcount=0; sfcount < numSubfrms; sfcount++)
26679             {
26680                cell->rachRspLst[sfNum].delInfo.subframe[sfcount] =
26681                   rachRspLst[sfnIdx][subfrmIdx].delInfo.subframe[sfcount];
26682             }
26683             cell->rachRspLst[sfNum].delInfo.numSubfrms =
26684                rachRspLst[sfnIdx][subfrmIdx].delInfo.numSubfrms;
26685          }
26686       }
26687    }
26688    RETVALUE(ROK);
26689 }
26690 #endif
26691 /**
26692  * @brief This function determines the iTbs based on the new CFI, 
26693  *        CQI and BLER based delta iTbs 
26694  *
26695  * @details
26696  *
26697  *     Function: rgSchCmnFetchItbs
26698  *     Purpose:  Fetch the new iTbs when CFI changes.
26699  *
26700  *  @param[in]  RgSchCellCb           *cell
26701  *  @param[in]  RgSchCmnDlUe          *ueDl
26702  *  @param[in]  U8                    cqi
26703  *
26704  *  @return S32 iTbs
26705  *
26706  **/
26707 #ifdef LTE_TDD
26708 #ifdef ANSI
26709 PRIVATE S32 rgSchCmnFetchItbs 
26710 (
26711 RgSchCellCb        *cell,
26712 RgSchCmnDlUe       *ueDl,
26713 RgSchDlSf          *subFrm,
26714 U8                 cqi,
26715 U8                 cfi,
26716 U8                 cwIdx,
26717 U8                 noLyr
26718 )
26719 #else
26720 PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
26721 RgSchCellCb        *cell;
26722 RgSchCmnDlUe       *ueDl; 
26723 RgSchDlSf          *subFrm;
26724 U8                 cqi;
26725 U8                 cfi;
26726 U8                 cwIdx;
26727 U8                 noLyr;
26728 #endif
26729 #else
26730 #ifdef ANSI
26731 PRIVATE S32 rgSchCmnFetchItbs 
26732 (
26733 RgSchCellCb        *cell,
26734 RgSchCmnDlUe       *ueDl,
26735 U8                 cqi,
26736 U8                 cfi,
26737 U8                 cwIdx,
26738 U8                 noLyr
26739 )
26740 #else
26741 PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
26742 RgSchCellCb        *cell;
26743 RgSchCmnDlUe       *ueDl; 
26744 U8                 cqi;
26745 U8                 cfi;
26746 U8                 cwIdx;
26747 U8                 noLyr;
26748 #endif 
26749 #endif
26750 {
26751
26752    RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
26753    S32 iTbs = 0;
26754
26755    TRC2(rgSchCmnFetchItbs);
26756
26757 #ifdef LTE_TDD      
26758    /* Special Handling for Spl Sf when CFI is 3 as 
26759     * CFI in Spl Sf will be max 2 */
26760    if(subFrm->sfType == RG_SCH_SPL_SF_DATA) 
26761    {
26762       if((cellDl->currCfi == 3) || 
26763             ((cell->bwCfg.dlTotalBw <= 10) && (cellDl->currCfi == 1)))
26764       {    
26765          /* Use CFI 2 in this case */
26766          iTbs = (ueDl->laCb[cwIdx].deltaiTbs + 
26767                ((*(RgSchCmnCqiToTbs *)(cellDl->cqiToTbsTbl[0][2]))[cqi])* 100)/100;
26768
26769          RG_SCH_CHK_ITBS_RANGE(iTbs, RGSCH_NUM_ITBS - 1);
26770       }
26771       else
26772       {
26773          iTbs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[noLyr - 1];
26774       }
26775       iTbs = RGSCH_MIN(iTbs, cell->thresholds.maxDlItbs);
26776    }   
26777    else /* CFI Changed. Update with new iTbs Reset the BLER*/
26778 #endif         
26779    {
26780       S32 tmpiTbs  = (*(RgSchCmnCqiToTbs *)(cellDl->cqiToTbsTbl[0][cfi]))[cqi];
26781       
26782       iTbs = (ueDl->laCb[cwIdx].deltaiTbs + tmpiTbs*100)/100;
26783
26784       RG_SCH_CHK_ITBS_RANGE(iTbs, tmpiTbs);     
26785
26786       iTbs = RGSCH_MIN(iTbs, cell->thresholds.maxDlItbs);
26787
26788       ueDl->mimoInfo.cwInfo[cwIdx].iTbs[noLyr - 1] = iTbs;
26789
26790       ueDl->lastCfi = cfi;
26791       ueDl->laCb[cwIdx].deltaiTbs = 0;
26792    }
26793
26794    RETVALUE(iTbs);
26795 } 
26796 \f
26797 /**
26798  * @brief This function determines the RBs and Bytes required for BO
26799  *        transmission for UEs configured with TM 1/2/6/7.
26800  *
26801  * @details
26802  *
26803  *     Function: rgSCHCmnDlAllocTxRb1Tb1Cw
26804  *     Purpose:  Allocate TB1 on CW1.
26805  *
26806  *               Reference Parameter effBo is filled with alloced bytes.
26807  *               Returns RFAILED if BO not satisfied at all.
26808  *
26809  *     Invoked by: rgSCHCmnDlAllocTxRbTM1/2/6/7
26810  *
26811  *  @param[in]  RgSchCellCb           *cell
26812  *  @param[in]  RgSchDlSf             *subFrm
26813  *  @param[in]  RgSchUeCb             *ue
26814  *  @param[in]  U32                   bo
26815  *  @param[out] U32                   *effBo
26816  *  @param[in]  RgSchDlHqProcCb       *proc
26817  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26818  *  @return  Void
26819  *
26820  **/
26821 #ifdef ANSI
26822 PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw
26823 (
26824 RgSchCellCb                *cell,
26825 RgSchDlSf                  *subFrm,
26826 RgSchUeCb                  *ue,
26827 U32                        bo,
26828 U32                        *effBo,
26829 RgSchDlHqProcCb            *proc,
26830 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26831 )
26832 #else
26833 PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26834 RgSchCellCb                *cell;
26835 RgSchDlSf                  *subFrm;
26836 RgSchUeCb                  *ue;
26837 U32                        bo;
26838 U32                        *effBo;
26839 RgSchDlHqProcCb            *proc;
26840 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26841 #endif
26842 {
26843    RgSchDlRbAlloc   *allocInfo;
26844    S16              ret;
26845    U8               numRb;
26846    TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
26847
26848    ret = ROK;
26849    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
26850 #ifdef RG_5GTF
26851    if (ue->ue5gtfCb.rank == 2)
26852    {
26853       allocInfo->dciFormat = TFU_DCI_FORMAT_B2;
26854    }
26855    else
26856    {
26857       allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
26858    }
26859 #else
26860    allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
26861          allocInfo->raType);
26862 #endif
26863    ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
26864          bo, &numRb, effBo);
26865    if (ret == RFAILED)
26866    {
26867       /* If allocation couldn't be made then return */
26868       RETVOID;
26869    }
26870    /* Adding UE to RbAllocInfo TX Lst */
26871    rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
26872    /* Fill UE alloc Info */
26873    allocInfo->rbsReq = numRb;
26874    allocInfo->dlSf   = subFrm;
26875 #ifdef RG_5GTF
26876    allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
26877 #endif
26878
26879    RETVOID;
26880 }
26881
26882 \f
26883 /**
26884  * @brief This function determines the RBs and Bytes required for BO
26885  *        retransmission for UEs configured with TM 1/2/6/7.
26886  *
26887  * @details
26888  *
26889  *     Function: rgSCHCmnDlAllocRetxRb1Tb1Cw
26890  *     Purpose:  Allocate TB1 on CW1.
26891  *
26892  *               Reference Parameter effBo is filled with alloced bytes.
26893  *               Returns RFAILED if BO not satisfied at all.
26894  *
26895  *     Invoked by: rgSCHCmnDlAllocRetxRbTM1/2/6/7
26896  *
26897  *  @param[in]  RgSchCellCb           *cell
26898  *  @param[in]  RgSchDlSf             *subFrm
26899  *  @param[in]  RgSchUeCb             *ue
26900  *  @param[in]  U32                   bo
26901  *  @param[out] U32                   *effBo
26902  *  @param[in]  RgSchDlHqProcCb       *proc
26903  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26904  *  @return  Void
26905  *
26906  **/
26907 #ifdef ANSI
26908 PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw
26909 (
26910 RgSchCellCb                *cell,
26911 RgSchDlSf                  *subFrm,
26912 RgSchUeCb                  *ue,
26913 U32                        bo,
26914 U32                        *effBo,
26915 RgSchDlHqProcCb            *proc,
26916 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26917 )
26918 #else
26919 PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26920 RgSchCellCb                *cell;
26921 RgSchDlSf                  *subFrm;
26922 RgSchUeCb                  *ue;
26923 U32                        bo;
26924 U32                        *effBo;
26925 RgSchDlHqProcCb            *proc;
26926 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26927 #endif
26928 {
26929    RgSchDlRbAlloc   *allocInfo;
26930    S16              ret;
26931    U8               numRb;
26932    TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
26933
26934    ret = ROK;
26935    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
26936
26937 #ifndef RG_5GTF
26938    /* 5GTF: RETX DCI format same as TX */
26939    allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
26940       &allocInfo->raType);
26941 #endif
26942
26943    /* Get the Allocation in terms of RBs that are required for
26944     * this retx of TB1 */
26945    ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, &proc->tbInfo[0],
26946          1, &numRb, effBo);
26947    if (ret == RFAILED)
26948    {
26949       /* Allocation couldn't be made for Retx */
26950       /* Fix : syed If TxRetx allocation failed then add the UE along with the proc
26951        * to the nonSchdTxRetxUeLst and let spfc scheduler take care of it during
26952        * finalization. */        
26953       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
26954       RETVOID;
26955    }
26956    rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
26957    /* Fill UE alloc Info */
26958    allocInfo->rbsReq = numRb;
26959    allocInfo->dlSf   = subFrm;
26960 #ifdef RG_5GTF
26961    allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
26962 #endif
26963
26964    RETVOID;
26965 }
26966
26967 \f
26968 /**
26969  * @brief This function determines the RBs and Bytes required for BO
26970  *        transmission for UEs configured with TM 2.
26971  *
26972  * @details
26973  *
26974  *     Function: rgSCHCmnDlAllocTxRbTM1
26975  *     Purpose:
26976  *
26977  *               Reference Parameter effBo is filled with alloced bytes.
26978  *               Returns RFAILED if BO not satisfied at all.
26979  *
26980  *     Invoked by: rgSCHCmnDlAllocTxRb
26981  *
26982  *  @param[in]  RgSchCellCb           *cell
26983  *  @param[in]  RgSchDlSf             *subFrm
26984  *  @param[in]  RgSchUeCb             *ue
26985  *  @param[in]  U32                   bo
26986  *  @param[out] U32                   *effBo
26987  *  @param[in]  RgSchDlHqProcCb       *proc
26988  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26989  *  @return Void
26990  *
26991  **/
26992 #ifdef ANSI
26993 PRIVATE Void rgSCHCmnDlAllocTxRbTM1
26994 (
26995 RgSchCellCb                *cell,
26996 RgSchDlSf                  *subFrm,
26997 RgSchUeCb                  *ue,
26998 U32                        bo,
26999 U32                        *effBo,
27000 RgSchDlHqProcCb            *proc,
27001 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27002 )
27003 #else
27004 PRIVATE Void rgSCHCmnDlAllocTxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27005 RgSchCellCb                *cell;
27006 RgSchDlSf                  *subFrm;
27007 RgSchUeCb                  *ue;
27008 U32                        bo;
27009 U32                        *effBo;
27010 RgSchDlHqProcCb            *proc;
27011 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27012 #endif
27013 {
27014    TRC2(rgSCHCmnDlAllocTxRbTM1);
27015    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27016    RETVOID;
27017 }
27018
27019 \f
27020 /**
27021  * @brief This function determines the RBs and Bytes required for BO
27022  *        retransmission for UEs configured with TM 2.
27023  *
27024  * @details
27025  *
27026  *     Function: rgSCHCmnDlAllocRetxRbTM1
27027  *     Purpose:
27028  *
27029  *               Reference Parameter effBo is filled with alloced bytes.
27030  *               Returns RFAILED if BO not satisfied at all.
27031  *
27032  *     Invoked by: rgSCHCmnDlAllocRetxRb
27033  *
27034  *  @param[in]  RgSchCellCb           *cell
27035  *  @param[in]  RgSchDlSf             *subFrm
27036  *  @param[in]  RgSchUeCb             *ue
27037  *  @param[in]  U32                   bo
27038  *  @param[out] U32                   *effBo
27039  *  @param[in]  RgSchDlHqProcCb       *proc
27040  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27041  *  @return Void
27042  *
27043  **/
27044 #ifdef ANSI
27045 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1
27046 (
27047 RgSchCellCb                *cell,
27048 RgSchDlSf                  *subFrm,
27049 RgSchUeCb                  *ue,
27050 U32                        bo,
27051 U32                        *effBo,
27052 RgSchDlHqProcCb            *proc,
27053 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27054 )
27055 #else
27056 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27057 RgSchCellCb                *cell;
27058 RgSchDlSf                  *subFrm;
27059 RgSchUeCb                  *ue;
27060 U32                        bo;
27061 U32                        *effBo;
27062 RgSchDlHqProcCb            *proc;
27063 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27064 #endif
27065 {
27066    TRC2(rgSCHCmnDlAllocRetxRbTM1);
27067    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27068    RETVOID;
27069 }
27070
27071 \f
27072 /**
27073  * @brief This function determines the RBs and Bytes required for BO
27074  *        transmission for UEs configured with TM 2.
27075  *
27076  * @details
27077  *
27078  *     Function: rgSCHCmnDlAllocTxRbTM2
27079  *     Purpose:
27080  *
27081  *               Reference Parameter effBo is filled with alloced bytes.
27082  *               Returns RFAILED if BO not satisfied at all.
27083  *
27084  *     Invoked by: rgSCHCmnDlAllocTxRb
27085  *
27086  *  @param[in]  RgSchCellCb           *cell
27087  *  @param[in]  RgSchDlSf             *subFrm
27088  *  @param[in]  RgSchUeCb             *ue
27089  *  @param[in]  U32                   bo
27090  *  @param[out] U32                   *effBo
27091  *  @param[in]  RgSchDlHqProcCb       *proc
27092  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27093  *  @return Void
27094  *
27095  **/
27096 #ifdef ANSI
27097 PRIVATE Void rgSCHCmnDlAllocTxRbTM2
27098 (
27099 RgSchCellCb                *cell,
27100 RgSchDlSf                  *subFrm,
27101 RgSchUeCb                  *ue,
27102 U32                        bo,
27103 U32                        *effBo,
27104 RgSchDlHqProcCb            *proc,
27105 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27106 )
27107 #else
27108 PRIVATE Void rgSCHCmnDlAllocTxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27109 RgSchCellCb                *cell;
27110 RgSchDlSf                  *subFrm;
27111 RgSchUeCb                  *ue;
27112 U32                        bo;
27113 U32                        *effBo;
27114 RgSchDlHqProcCb            *proc;
27115 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27116 #endif
27117 {
27118    TRC2(rgSCHCmnDlAllocTxRbTM2);
27119    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27120    RETVOID;
27121 }
27122
27123 \f
27124 /**
27125  * @brief This function determines the RBs and Bytes required for BO
27126  *        retransmission for UEs configured with TM 2.
27127  *
27128  * @details
27129  *
27130  *     Function: rgSCHCmnDlAllocRetxRbTM2
27131  *     Purpose:
27132  *
27133  *               Reference Parameter effBo is filled with alloced bytes.
27134  *               Returns RFAILED if BO not satisfied at all.
27135  *
27136  *     Invoked by: rgSCHCmnDlAllocRetxRb
27137  *
27138  *  @param[in]  RgSchCellCb           *cell
27139  *  @param[in]  RgSchDlSf             *subFrm
27140  *  @param[in]  RgSchUeCb             *ue
27141  *  @param[in]  U32                   bo
27142  *  @param[out] U32                   *effBo
27143  *  @param[in]  RgSchDlHqProcCb       *proc
27144  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27145  *  @return Void
27146  *
27147  **/
27148 #ifdef ANSI
27149 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2
27150 (
27151 RgSchCellCb                *cell,
27152 RgSchDlSf                  *subFrm,
27153 RgSchUeCb                  *ue,
27154 U32                        bo,
27155 U32                        *effBo,
27156 RgSchDlHqProcCb            *proc,
27157 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27158 )
27159 #else
27160 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27161 RgSchCellCb                *cell;
27162 RgSchDlSf                  *subFrm;
27163 RgSchUeCb                  *ue;
27164 U32                        bo;
27165 U32                        *effBo;
27166 RgSchDlHqProcCb            *proc;
27167 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27168 #endif
27169 {
27170    TRC2(rgSCHCmnDlAllocRetxRbTM2);
27171    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27172    RETVOID;
27173 }
27174
27175 \f
27176 /**
27177  * @brief This function determines the RBs and Bytes required for BO
27178  *        transmission for UEs configured with TM 3.
27179  *
27180  * @details
27181  *
27182  *     Function: rgSCHCmnDlAllocTxRbTM3
27183  *     Purpose:
27184  *
27185  *               Reference Parameter effBo is filled with alloced bytes.
27186  *               Returns RFAILED if BO not satisfied at all.
27187  *
27188  *     Invoked by: rgSCHCmnDlAllocTxRb
27189  *
27190  *  @param[in]  RgSchCellCb           *cell
27191  *  @param[in]  RgSchDlSf             *subFrm
27192  *  @param[in]  RgSchUeCb             *ue
27193  *  @param[in]  U32                   bo
27194  *  @param[out] U32                   *effBo
27195  *  @param[in]  RgSchDlHqProcCb       *proc
27196  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27197  *  @return Void
27198  *
27199  **/
27200 #ifdef ANSI
27201 PRIVATE Void rgSCHCmnDlAllocTxRbTM3
27202 (
27203 RgSchCellCb                *cell,
27204 RgSchDlSf                  *subFrm,
27205 RgSchUeCb                  *ue,
27206 U32                        bo,
27207 U32                        *effBo,
27208 RgSchDlHqProcCb            *proc,
27209 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27210 )
27211 #else
27212 PRIVATE Void rgSCHCmnDlAllocTxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27213 RgSchCellCb                *cell;
27214 RgSchDlSf                  *subFrm;
27215 RgSchUeCb                  *ue;
27216 U32                        bo;
27217 U32                        *effBo;
27218 RgSchDlHqProcCb            *proc;
27219 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27220 #endif
27221 {
27222
27223    TRC2(rgSCHCmnDlAllocTxRbTM3);
27224
27225    /* Both TBs free for TX allocation */
27226    rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
27227          proc, cellWdAllocInfo);
27228
27229    RETVOID;
27230 }
27231
27232 \f
27233 /**
27234  * @brief This function determines the RBs and Bytes required for BO
27235  *        retransmission for UEs configured with TM 3.
27236  *
27237  * @details
27238  *
27239  *     Function: rgSCHCmnDlAllocRetxRbTM3
27240  *     Purpose:
27241  *
27242  *               Reference Parameter effBo is filled with alloced bytes.
27243  *               Returns RFAILED if BO not satisfied at all.
27244  *
27245  *     Invoked by: rgSCHCmnDlAllocRetxRb
27246  *
27247  *  @param[in]  RgSchCellCb           *cell
27248  *  @param[in]  RgSchDlSf             *subFrm
27249  *  @param[in]  RgSchUeCb             *ue
27250  *  @param[in]  U32                   bo
27251  *  @param[out] U32                   *effBo
27252  *  @param[in]  RgSchDlHqProcCb       *proc
27253  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27254  *  @return Void
27255  *
27256  **/
27257 #ifdef ANSI
27258 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3
27259 (
27260 RgSchCellCb                *cell,
27261 RgSchDlSf                  *subFrm,
27262 RgSchUeCb                  *ue,
27263 U32                        bo,
27264 U32                        *effBo,
27265 RgSchDlHqProcCb            *proc,
27266 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27267 )
27268 #else
27269 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27270 RgSchCellCb                *cell;
27271 RgSchDlSf                  *subFrm;
27272 RgSchUeCb                  *ue;
27273 U32                        bo;
27274 U32                        *effBo;
27275 RgSchDlHqProcCb            *proc;
27276 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27277 #endif
27278 {
27279
27280    TRC2(rgSCHCmnDlAllocRetxRbTM3);
27281
27282    if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
27283          (proc->tbInfo[1].state == HQ_TB_NACKED))
27284    {
27285 #ifdef LAA_DBG_LOG
27286       printf ("RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
27287 #endif
27288       /* Both TBs require RETX allocation */
27289       rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo,\
27290             proc, cellWdAllocInfo);
27291    }
27292    else
27293    {
27294       /* One of the TBs need RETX allocation. Other TB may/maynot
27295        * be available for new TX allocation. */
27296       rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo,\
27297             proc, cellWdAllocInfo);
27298    }
27299
27300    RETVOID;
27301 }
27302
27303 \f
27304 /**
27305  * @brief This function performs the DCI format selection in case of
27306  *        Transmit Diversity scheme where there can be more
27307  *        than 1 option for DCI format selection.
27308  *
27309  * @details
27310  *
27311  *     Function: rgSCHCmnSlctPdcchFrmt
27312  *     Purpose:  1. If DLFS is enabled, then choose TM specific
27313  *                  DCI format for Transmit diversity. All the
27314  *                  TM Specific DCI Formats support Type0 and/or
27315  *                  Type1 resource allocation scheme. DLFS
27316  *                  supports only Type-0&1 Resource allocation.
27317  *               2. If DLFS is not enabled, select a DCI format
27318  *                  which is of smaller size. Since Non-DLFS
27319  *                  scheduler supports all Resource allocation
27320  *                  schemes, selection is based on efficiency.
27321  *
27322  *     Invoked by: DL UE Allocation by Common Scheduler.
27323  *
27324  *  @param[in]  RgSchCellCb      *cell
27325  *  @param[in]  RgSchUeCb        *ue
27326  *  @param[out] U8               *raType
27327  *  @return  TfuDciFormat
27328  *
27329  **/
27330 #ifdef ANSI
27331 PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt
27332 (
27333 RgSchCellCb                *cell,
27334 RgSchUeCb                  *ue,
27335 U8                         *raType
27336 )
27337 #else
27338 PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
27339 RgSchCellCb                *cell;
27340 RgSchUeCb                  *ue;
27341 U8                         *raType;
27342 #endif
27343 {
27344    RgSchCmnCell   *cellSch = RG_SCH_CMN_GET_CELL(cell);
27345
27346    TRC2(rgSCHCmnSlctPdcchFrmt);
27347
27348    /* ccpu00140894- Selective DCI Format and RA type should be selected only 
27349     * after TX Mode transition is completed*/
27350    if ((cellSch->dl.isDlFreqSel) && (ue->txModeTransCmplt))
27351    {
27352       *raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciRAType;
27353       RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
27354    }
27355    else
27356    {
27357       *raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciRAType;
27358       RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
27359    }
27360 }
27361
27362 \f
27363 /**
27364  * @brief This function handles Retx allocation in case of TM3 UEs
27365  *        where both the TBs were NACKED previously.
27366  *
27367  * @details
27368  *
27369  *     Function: rgSCHCmnDlTM3RetxRetx
27370  *     Purpose:  If forceTD flag enabled
27371  *                  TD for TB1 on CW1.
27372  *               Else
27373  *                  DCI Frmt 2A and RA Type 0
27374  *                  RI layered SM of both TBs on 2 CWs
27375  *               Add UE to cell Alloc Info.
27376  *               Fill UE alloc Info.
27377  *
27378  *
27379  *               Successful allocation is indicated by non-zero effBo value.
27380  *
27381  *     Invoked by: rgSCHCmnDlAllocRbTM3
27382  *
27383  *  @param[in]  RgSchCellCb           *cell
27384  *  @param[in]  RgSchDlSf             *subFrm
27385  *  @param[in]  RgSchUeCb             *ue
27386  *  @param[in]  U32                   bo
27387  *  @param[out] U32                   *effBo
27388  *  @param[in]  RgSchDlHqProcCb       *proc
27389  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27390  *  @return  Void
27391  *
27392  **/
27393 #ifdef ANSI
27394 PRIVATE Void rgSCHCmnDlTM3RetxRetx
27395 (
27396 RgSchCellCb                *cell,
27397 RgSchDlSf                  *subFrm,
27398 RgSchUeCb                  *ue,
27399 U32                        bo,
27400 U32                        *effBo,
27401 RgSchDlHqProcCb            *proc,
27402 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27403 )
27404 #else
27405 PRIVATE Void rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27406 RgSchCellCb                *cell;
27407 RgSchDlSf                  *subFrm;
27408 RgSchUeCb                  *ue;
27409 U32                        bo;
27410 U32                        *effBo;
27411 RgSchDlHqProcCb            *proc;
27412 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27413 #endif
27414 {
27415    S16           ret;
27416    RgSchDlRbAlloc *allocInfo;
27417    U8            numRb;
27418    Bool          swpFlg;
27419    U8            precInfo;
27420    U8            noTxLyrs;
27421    U8            precInfoAntIdx;
27422
27423    TRC2(rgSCHCmnDlTM3RetxRetx);
27424
27425    ret = ROK;
27426    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
27427    swpFlg = FALSE;
27428 /* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
27429    {
27430       allocInfo->dciFormat = TFU_DCI_FORMAT_2A;
27431       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
27432
27433       ret = rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc, &numRb, &swpFlg,\
27434             effBo);
27435       if (ret == RFAILED)
27436       {
27437          /* Allocation couldn't be made for Retx */
27438          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
27439          RETVOID;
27440       }
27441       /* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
27442       noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
27443 #ifdef FOUR_TX_ANTENNA
27444       /*Chandra: For 4X4 MIM RETX with noTxLyrs=3, CW0 should be 1-LyrTB and CW1 should
27445        * have 2-LyrTB as per Table 6.3.3.2-1 of 36.211  */
27446       if(noTxLyrs == 3 &&  proc->tbInfo[0].numLyrs==2)
27447       {
27448          swpFlg = TRUE;
27449          proc->cwSwpEnabled = TRUE;
27450       }
27451 #endif
27452       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
27453       precInfo = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
27454    }
27455
27456 #ifdef LTEMAC_SPS
27457    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
27458 #endif
27459    {
27460       /* Adding UE to allocInfo RETX Lst */
27461       rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
27462    }
27463    /* Fill UE alloc Info scratch pad */
27464    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
27465          precInfo, noTxLyrs, subFrm);
27466
27467    RETVOID;
27468 }
27469
27470 \f
27471 /**
27472  * @brief This function handles Retx allocation in case of TM4 UEs
27473  *        where both the TBs were NACKED previously.
27474  *
27475  * @details
27476  *
27477  *     Function: rgSCHCmnDlTM4RetxRetx
27478  *     Purpose:  If forceTD flag enabled
27479  *                  TD for TB1 on CW1.
27480  *               Else
27481  *                  DCI Frmt 2 and RA Type 0
27482  *                  If RI == 1
27483  *                     1 layer SM of TB1 on CW1.
27484  *                  Else
27485  *                     RI layered SM of both TBs on 2 CWs
27486  *               Add UE to cell Alloc Info.
27487  *               Fill UE alloc Info.
27488  *
27489  *
27490  *               Successful allocation is indicated by non-zero effBo value.
27491  *
27492  *     Invoked by: rgSCHCmnDlAllocRbTM4
27493  *
27494  *  @param[in]  RgSchCellCb           *cell
27495  *  @param[in]  RgSchDlSf             *subFrm
27496  *  @param[in]  RgSchUeCb             *ue
27497  *  @param[in]  U32                   bo
27498  *  @param[out] U32                   *effBo
27499  *  @param[in]  RgSchDlHqProcCb       *proc
27500  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27501  *  @return  Void
27502  *
27503  **/
27504 #ifdef ANSI
27505 PRIVATE Void rgSCHCmnDlTM4RetxRetx
27506 (
27507 RgSchCellCb                *cell,
27508 RgSchDlSf                  *subFrm,
27509 RgSchUeCb                  *ue,
27510 U32                        bo,
27511 U32                        *effBo,
27512 RgSchDlHqProcCb            *proc,
27513 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27514 )
27515 #else
27516 PRIVATE Void rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27517 RgSchCellCb                *cell;
27518 RgSchDlSf                  *subFrm;
27519 RgSchUeCb                  *ue;
27520 U32                        bo;
27521 U32                        *effBo;
27522 RgSchDlHqProcCb            *proc;
27523 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27524 #endif
27525 {
27526    S16            ret;
27527    RgSchDlRbAlloc *allocInfo;
27528    U8             numRb;
27529    Bool           swpFlg = FALSE;
27530    U8             precInfo;
27531 #ifdef FOUR_TX_ANTENNA
27532    U8             precInfoAntIdx;
27533 #endif
27534    U8             noTxLyrs;
27535
27536    TRC2(rgSCHCmnDlTM4RetxRetx);
27537
27538    ret = ROK;
27539    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
27540                        
27541    /* Irrespective of RI Schedule both CWs */
27542    allocInfo->dciFormat = TFU_DCI_FORMAT_2;
27543    allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
27544
27545    ret = rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc, &numRb, &swpFlg,\
27546          effBo);
27547    if (ret == RFAILED)
27548    {
27549       /* Allocation couldn't be made for Retx */
27550       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
27551       RETVOID;
27552    }
27553    noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
27554    precInfo = 0; 
27555 #ifdef FOUR_TX_ANTENNA
27556    /*Chandra: For 4X4 MIM RETX with noTxLyrs=3, CW0 should be 1-LyrTB and CW1
27557     * should have 2-LyrTB as per Table 6.3.3.2-1 of 36.211  */
27558    if(noTxLyrs == 3 &&  proc->tbInfo[0].numLyrs==2)
27559    {
27560       swpFlg = TRUE;
27561       proc->cwSwpEnabled = TRUE;
27562 }
27563 precInfoAntIdx = cell->numTxAntPorts/2 - 1;
27564 precInfo = (getPrecInfoFunc[1][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
27565 #endif
27566
27567 #ifdef LTEMAC_SPS
27568    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
27569 #endif
27570    {
27571       /* Adding UE to allocInfo RETX Lst */
27572       rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
27573    }
27574    /* Fill UE alloc Info scratch pad */
27575    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
27576          precInfo, noTxLyrs, subFrm);
27577
27578    RETVOID;
27579 }
27580
27581
27582 \f
27583 /**
27584  * @brief This function determines Transmission attributes
27585  *        incase of Spatial multiplexing for TX and RETX TBs.
27586  *
27587  * @details
27588  *
27589  *     Function: rgSCHCmnDlSMGetAttrForTxRetx
27590  *     Purpose:  1. Reached here for a TM3/4 UE's HqP whose one of the TBs is
27591  *                  NACKED and the other TB is either NACKED or WAITING.
27592  *               2. Select the NACKED TB for RETX allocation.
27593  *               3. Allocation preference for RETX TB by mapping it to a better
27594  *                  CW (better in terms of efficiency).
27595  *               4. Determine the state of the other TB.
27596  *                  Determine if swapFlag were to be set.
27597  *                  Swap flag would be set if Retx TB is cross
27598  *                  mapped to a CW.
27599  *               5. If UE has new data available for TX and if the other TB's state
27600  *                  is ACKED then set furtherScope as TRUE.
27601  *
27602  *     Invoked by: rgSCHCmnDlTM3[4]TxRetx
27603  *
27604  *  @param[in]  RgSchUeCb        *ue
27605  *  @param[in]  RgSchDlHqProcCb  *proc
27606  *  @param[out] RgSchDlHqTbCb    **retxTb
27607  *  @param[out] RgSchDlHqTbCb    **txTb
27608  *  @param[out] Bool             *frthrScp
27609  *  @param[out] Bool             *swpFlg
27610  *  @return  Void
27611  *
27612  **/
27613 #ifdef ANSI
27614 PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx
27615 (
27616 RgSchUeCb                  *ue,
27617 RgSchDlHqProcCb            *proc,
27618 RgSchDlHqTbCb              **retxTb,
27619 RgSchDlHqTbCb              **txTb,
27620 Bool                       *frthrScp,
27621 Bool                       *swpFlg
27622 )
27623 #else
27624 PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, frthrScp,\
27625         swpFlg)
27626 RgSchUeCb                  *ue;
27627 RgSchDlHqProcCb            *proc;
27628 RgSchDlHqTbCb              **retxTb;
27629 RgSchDlHqTbCb              **txTb;
27630 Bool                       *frthrScp;
27631 Bool                       *swpFlg;
27632 #endif
27633 {
27634    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
27635    RgSchDlRbAlloc  *allocInfo;
27636
27637    TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
27638
27639    if (proc->tbInfo[0].state == HQ_TB_NACKED)
27640    {
27641       *retxTb = &proc->tbInfo[0];
27642       *txTb = &proc->tbInfo[1];
27643       /* TENB_BRDCM_TM4- Currently disabling swapflag for TM3/TM4, since 
27644        * HqFeedback processing does not consider a swapped hq feedback */
27645       if ((ue->mimoInfo.txMode == RGR_UE_TM_4) && (ueDl->mimoInfo.btrCwIdx == 1))
27646       {
27647          *swpFlg = TRUE;
27648          proc->cwSwpEnabled = TRUE;
27649       }
27650       if (proc->tbInfo[1].state == HQ_TB_ACKED)
27651       {
27652          allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, proc->hqE->cell);
27653          *frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
27654       }
27655    }
27656    else
27657    {
27658       *retxTb = &proc->tbInfo[1];
27659       *txTb = &proc->tbInfo[0];
27660       /* TENB_BRDCM_TM4 - Currently disabling swapflag for TM3/TM4, since 
27661        * HqFeedback processing does not consider a swapped hq feedback */
27662       if ((ue->mimoInfo.txMode == RGR_UE_TM_4) && (ueDl->mimoInfo.btrCwIdx == 0))
27663       {
27664          *swpFlg = TRUE;
27665          proc->cwSwpEnabled = TRUE;
27666       }
27667       if (proc->tbInfo[0].state == HQ_TB_ACKED)
27668       {
27669          allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, proc->hqE->cell);
27670          *frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
27671       }
27672    }
27673    RETVOID;
27674 }
27675
27676 \f
27677 /**
27678  * @brief Determine Precoding information for TM3 2 TX Antenna.
27679  *
27680  * @details
27681  *
27682  *     Function: rgSCHCmnDlTM3PrecInf2
27683  *     Purpose:
27684  *
27685  *     Invoked by: rgSCHCmnDlGetAttrForTM3
27686  *
27687  *  @param[in]  RgSchUeCb        *ue
27688  *  @param[in]  U8               numTxLyrs
27689  *  @param[in]  Bool             bothCwEnbld
27690  *  @return  U8
27691  *
27692  **/
27693 #ifdef ANSI
27694 PRIVATE U8 rgSCHCmnDlTM3PrecInf2
27695 (
27696 RgSchCellCb                *cell,
27697 RgSchUeCb                  *ue,
27698 U8                         numTxLyrs,
27699 Bool                       bothCwEnbld
27700 )
27701 #else
27702 PRIVATE U8 rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
27703 RgSchCellCb                *cell;
27704 RgSchUeCb                  *ue;
27705 U8                         numTxLyrs;
27706 Bool                       bothCwEnbld;
27707 #endif
27708 {
27709    TRC2(rgSCHCmnDlTM3PrecInf2);
27710
27711    RETVALUE(0);
27712 }
27713
27714 \f
27715 /**
27716  * @brief Determine Precoding information for TM4 2 TX Antenna.
27717  *
27718  * @details
27719  *
27720  *     Function: rgSCHCmnDlTM4PrecInf2
27721  *     Purpose:  To determine a logic of deriving precoding index
27722  *               information from 36.212 table 5.3.3.1.5-4
27723  *
27724  *     Invoked by: rgSCHCmnDlGetAttrForTM4
27725  *
27726  *  @param[in]  RgSchUeCb        *ue
27727  *  @param[in]  U8               numTxLyrs
27728  *  @param[in]  Bool             bothCwEnbld
27729  *  @return  U8
27730  *
27731  **/
27732 #ifdef ANSI
27733 PRIVATE U8 rgSCHCmnDlTM4PrecInf2
27734 (
27735 RgSchCellCb                *cell,
27736 RgSchUeCb                  *ue,
27737 U8                         numTxLyrs,
27738 Bool                       bothCwEnbld
27739 )
27740 #else
27741 PRIVATE U8 rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
27742 RgSchCellCb                *cell;
27743 RgSchUeCb                  *ue;
27744 U8                         numTxLyrs;
27745 Bool                       bothCwEnbld;
27746 #endif
27747 {
27748    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27749    U8            precIdx;
27750
27751    TRC2(rgSCHCmnDlTM4PrecInf2);
27752
27753    if (ueDl->mimoInfo.ri == numTxLyrs)
27754    {
27755       if (ueDl->mimoInfo.ri == 2)
27756       {
27757          /* PrecInfo corresponding to 2 CW
27758            Transmission */
27759          if (ue->mimoInfo.puschFdbkVld)
27760          {
27761             precIdx = 2;
27762          }
27763          else 
27764          {
27765             precIdx = ueDl->mimoInfo.pmi - 1;
27766          }
27767       }
27768       else
27769       {
27770          /* PrecInfo corresponding to 1 CW
27771           * Transmission */
27772          if (ue->mimoInfo.puschFdbkVld)
27773          {
27774             precIdx =  5;
27775          }
27776          else
27777          {
27778             precIdx =  ueDl->mimoInfo.pmi + 1;
27779          }
27780       }
27781    }
27782    else if (ueDl->mimoInfo.ri > numTxLyrs)
27783    {
27784       /* In case of choosing among the columns of a
27785        * precoding matrix, choose the column corresponding
27786        * to the MAX-CQI */
27787       if (ue->mimoInfo.puschFdbkVld)
27788       {
27789          precIdx = 5;
27790       }
27791       else
27792       {
27793          precIdx = (ueDl->mimoInfo.pmi- 1)* 2  + 1;
27794       }
27795    }
27796    else /* if RI < numTxLyrs */
27797    {
27798       precIdx = (ueDl->mimoInfo.pmi < 2)? 0:1;
27799    }
27800    RETVALUE(precIdx);
27801 }
27802
27803 \f
27804 /**
27805  * @brief Determine Precoding information for TM3 4 TX Antenna.
27806  *
27807  * @details
27808  *
27809  *     Function: rgSCHCmnDlTM3PrecInf4
27810  *     Purpose:  To determine a logic of deriving precoding index
27811  *               information from 36.212 table 5.3.3.1.5A-2
27812  *
27813  *     Invoked by: rgSCHCmnDlGetAttrForTM3
27814  *
27815  *  @param[in]  RgSchUeCb        *ue
27816  *  @param[in]  U8               numTxLyrs
27817  *  @param[in]  Bool             bothCwEnbld
27818  *  @return  U8
27819  *
27820  **/
27821 #ifdef ANSI
27822 PRIVATE U8 rgSCHCmnDlTM3PrecInf4
27823 (
27824 RgSchCellCb                *cell,
27825 RgSchUeCb                  *ue,
27826 U8                         numTxLyrs,
27827 Bool                       bothCwEnbld
27828 )
27829 #else
27830 PRIVATE U8 rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
27831 RgSchCellCb                *cell;
27832 RgSchUeCb                  *ue;
27833 U8                         numTxLyrs;
27834 Bool                       bothCwEnbld;
27835 #endif
27836 {
27837    U8            precIdx;
27838
27839    TRC2(rgSCHCmnDlTM3PrecInf4);
27840
27841    if (bothCwEnbld)
27842    {
27843       precIdx = numTxLyrs - 2;
27844    }
27845    else /* one 1 CW transmission */
27846    {
27847       precIdx = 1;
27848    }
27849    RETVALUE(precIdx);
27850 }
27851
27852 \f
27853 /**
27854  * @brief Determine Precoding information for TM4 4 TX Antenna.
27855  *
27856  * @details
27857  *
27858  *     Function: rgSCHCmnDlTM4PrecInf4
27859  *     Purpose:  To determine a logic of deriving precoding index
27860  *               information from 36.212 table 5.3.3.1.5-5
27861  *
27862  *     Invoked by: rgSCHCmnDlGetAttrForTM4
27863  *
27864  *  @param[in]  RgSchUeCb        *ue
27865  *  @param[in]  U8               numTxLyrs
27866  *  @param[in]  Bool             bothCwEnbld
27867  *  @return  U8
27868  *
27869  **/
27870 #ifdef ANSI
27871 PRIVATE U8 rgSCHCmnDlTM4PrecInf4
27872 (
27873 RgSchCellCb                *cell,
27874 RgSchUeCb                  *ue,
27875 U8                         numTxLyrs,
27876 Bool                       bothCwEnbld
27877 )
27878 #else
27879 PRIVATE U8 rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
27880 RgSchCellCb                *cell;
27881 RgSchUeCb                  *ue;
27882 U8                         numTxLyrs;
27883 Bool                       bothCwEnbld;
27884 #endif
27885 {
27886    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27887    U8            precInfoBaseIdx, precIdx;
27888
27889    TRC2(rgSCHCmnDlTM4PrecInf4);
27890
27891    precInfoBaseIdx  = (ue->mimoInfo.puschFdbkVld)? (16):
27892       (ueDl->mimoInfo.pmi);
27893    if (bothCwEnbld)
27894    {
27895       precIdx = precInfoBaseIdx + (numTxLyrs-2)*17;
27896    }
27897    else /* one 1 CW transmission */
27898    {
27899       precInfoBaseIdx += 1;
27900       precIdx = precInfoBaseIdx + (numTxLyrs-1)*17;
27901    }
27902    RETVALUE(precIdx);
27903 }
27904
27905 \f
27906 /**
27907  * @brief This function determines Transmission attributes
27908  *        incase of TM3 scheduling.
27909  *
27910  * @details
27911  *
27912  *     Function: rgSCHCmnDlGetAttrForTM3
27913  *     Purpose:  Determine retx TB and tx TB based on TB states.
27914  *               If forceTD enabled
27915  *                  perform only retx TB allocation.
27916  *                  If retxTB == TB2 then DCI Frmt = 2A, RA Type = 0.
27917  *                  Else DCI Frmt and RA Type based on cell->isDlfsEnbld
27918  *               If RI == 1
27919  *                  perform retxTB allocation on CW1.
27920  *               Else if RI > 1
27921  *                  Determine further Scope and Swap Flag attributes
27922  *                  assuming a 2 CW transmission of RetxTB and new Tx TB.
27923  *                  If no further scope for new TX allocation
27924  *                     Allocate only retx TB using 2 layers if
27925  *                     this TB was previously transmitted using 2 layers AND
27926  *                     number of Tx antenna ports == 4.
27927  *                     otherwise do single layer precoding.
27928  *
27929  *     Invoked by: rgSCHCmnDlTM3TxRetx
27930  *
27931  *  @param[in]  RgSchUeCb        *ue
27932  *  @param[in]  RgSchDlHqProcCb  *proc
27933  *  @param[out] U8               *numTxLyrs
27934  *  @param[out] Bool             *isTraDiv
27935  *  @param[out] U8               *prcdngInf
27936  *  @param[out] U8               *raType
27937  *  @return  Void
27938  *
27939  **/
27940 #ifdef ANSI
27941 PRIVATE Void rgSCHCmnDlGetAttrForTM3
27942 (
27943 RgSchCellCb                *cell,
27944 RgSchUeCb                  *ue,
27945 RgSchDlHqProcCb            *proc,
27946 U8                         *numTxLyrs,
27947 TfuDciFormat               *dciFrmt,
27948 U8                         *prcdngInf,
27949 RgSchDlHqTbCb              **retxTb,
27950 RgSchDlHqTbCb              **txTb,
27951 Bool                       *frthrScp,
27952 Bool                       *swpFlg,
27953 U8                         *raType
27954 )
27955 #else
27956 PRIVATE Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
27957         prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
27958 RgSchCellCb                *cell;
27959 RgSchUeCb                  *ue;
27960 RgSchDlHqProcCb            *proc;
27961 U8                         *numTxLyrs;
27962 TfuDciFormat               *dciFrmt;
27963 U8                         *prcdngInf;
27964 RgSchDlHqTbCb              **retxTb;
27965 RgSchDlHqTbCb              **txTb;
27966 Bool                       *frthrScp;
27967 Bool                       *swpFlg;
27968 U8                         *raType;
27969 #endif
27970 {
27971    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27972    U8            precInfoAntIdx;
27973
27974    TRC2(rgSCHCmnDlGetAttrForTM3);
27975
27976    /* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with 
27977       HQP */
27978    /* Integration_fix: SPS Proc shall always have only one Cw */
27979 #ifdef LTEMAC_SPS
27980    if (((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
27981          (ueDl->mimoInfo.forceTD)) 
27982 #ifdef LTE_ADV
27983      ||(TRUE == rgSCHLaaSCellEnabled(cell))
27984 #endif
27985       )
27986 #else
27987    if ((ueDl->mimoInfo.forceTD) 
27988 #ifdef LTE_ADV
27989        || (TRUE == rgSCHLaaSCellEnabled(cell))
27990 #endif
27991       )
27992 #endif
27993    {
27994       /* Transmit Diversity. Format based on dlfsEnabled
27995        * No further scope */
27996       if (proc->tbInfo[0].state == HQ_TB_NACKED)
27997       {
27998          *retxTb = &proc->tbInfo[0];
27999          *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28000       }
28001       else
28002       {
28003          *retxTb = &proc->tbInfo[1];
28004          *dciFrmt = TFU_DCI_FORMAT_2A;
28005          *raType = RG_SCH_CMN_RA_TYPE0;
28006       }
28007       *numTxLyrs = 1;
28008       *frthrScp = FALSE;
28009       *prcdngInf = 0;
28010       RETVOID;
28011    }
28012
28013    /* Determine the 2 TB transmission attributes */
28014    rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, \
28015          frthrScp, swpFlg);
28016    if (*frthrScp)
28017    {
28018       /* Prefer allocation of RETX TB over 2 layers rather than combining
28019        * it with a new TX. */
28020       if ((ueDl->mimoInfo.ri == 2)
28021             && ((*retxTb)->numLyrs == 2) && (cell->numTxAntPorts == 4))
28022       {
28023          /* Allocate TB on CW1, using 2 Lyrs,
28024           * Format 2, precoding accordingly */
28025          *numTxLyrs = 2;
28026          *frthrScp = FALSE;
28027       }
28028       else
28029       {
28030          *numTxLyrs=  ((*retxTb)->numLyrs + ueDl->mimoInfo.cwInfo[!(ueDl->mimoInfo.btrCwIdx)].noLyr);
28031
28032          if((*retxTb)->tbIdx == 0 && ((*retxTb)->numLyrs == 2 ) && *numTxLyrs ==3)
28033          {
28034             *swpFlg = TRUE;
28035             proc->cwSwpEnabled = TRUE;
28036          }
28037          else if((*retxTb)->tbIdx == 1 && ((*retxTb)->numLyrs == 1) && *numTxLyrs ==3)
28038          {
28039             *swpFlg = TRUE;
28040             proc->cwSwpEnabled = TRUE;
28041          }
28042       }
28043
28044       precInfoAntIdx = cell->numTxAntPorts/2 - 1; 
28045       *prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])\
28046                    (cell, ue, ueDl->mimoInfo.ri, *frthrScp);
28047       *dciFrmt = TFU_DCI_FORMAT_2A;
28048       *raType = RG_SCH_CMN_RA_TYPE0;
28049    }
28050    else /* frthrScp == FALSE */
28051    {
28052       if (cell->numTxAntPorts == 2)
28053       {
28054          /*  Transmit Diversity  */
28055          *numTxLyrs = 1;
28056          if ((*retxTb)->tbIdx == 0)
28057          {
28058             *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28059          }
28060          else
28061          {
28062             /* If retxTB is TB2 then use format 2A */
28063             *dciFrmt = TFU_DCI_FORMAT_2A;
28064             *raType = RG_SCH_CMN_RA_TYPE0;
28065          }
28066          *prcdngInf = 0;
28067          RETVOID;
28068       }
28069       else /* NumAntPorts == 4 */
28070       {
28071          if ((*retxTb)->numLyrs == 2)
28072          {
28073             /* Allocate TB on CW1, using 2 Lyrs,
28074              * Format 2A, precoding accordingly */
28075             *numTxLyrs = 2;
28076             *dciFrmt = TFU_DCI_FORMAT_2A;
28077             *raType = RG_SCH_CMN_RA_TYPE0;
28078             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28079             *prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, *numTxLyrs, *frthrScp);
28080             RETVOID;
28081          }
28082          else
28083          {
28084             /*  Transmit Diversity  */
28085             *numTxLyrs = 1;
28086             if ((*retxTb)->tbIdx == 0)
28087             {
28088                *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28089             }
28090             else
28091             {
28092                /* If retxTB is TB2 then use format 2A */
28093                *dciFrmt = TFU_DCI_FORMAT_2A;
28094                *raType = RG_SCH_CMN_RA_TYPE0;
28095             }
28096             *prcdngInf = 0;
28097             RETVOID;
28098          }
28099       }
28100    }
28101
28102    RETVOID;
28103 }
28104
28105
28106 \f
28107 /**
28108  * @brief This function determines Transmission attributes
28109  *        incase of TM4 scheduling.
28110  *
28111  * @details
28112  *
28113  *     Function: rgSCHCmnDlGetAttrForTM4
28114  *     Purpose:  Determine retx TB and tx TB based on TB states.
28115  *               If forceTD enabled
28116  *                  perform only retx TB allocation.
28117  *                  If retxTB == TB2 then DCI Frmt = 2, RA Type = 0.
28118  *                  Else DCI Frmt and RA Type based on cell->isDlfsEnbld
28119  *               If RI == 1
28120  *                  perform retxTB allocation on CW1.
28121  *               Else if RI > 1
28122  *                  Determine further Scope and Swap Flag attributes
28123  *                  assuming a 2 CW transmission of RetxTB and new Tx TB.
28124  *                  If no further scope for new TX allocation
28125  *                     Allocate only retx TB using 2 layers if
28126  *                     this TB was previously transmitted using 2 layers AND
28127  *                     number of Tx antenna ports == 4.
28128  *                     otherwise do single layer precoding.
28129  *
28130  *     Invoked by: rgSCHCmnDlTM4TxRetx
28131  *
28132  *  @param[in]  RgSchUeCb        *ue
28133  *  @param[in]  RgSchDlHqProcCb  *proc
28134  *  @param[out] U8               *numTxLyrs
28135  *  @param[out] Bool             *isTraDiv
28136  *  @param[out] U8               *prcdngInf
28137  *  @param[out] U8               *raType
28138  *  @return  Void
28139  *
28140  **/
28141 #ifdef ANSI
28142 PRIVATE Void rgSCHCmnDlGetAttrForTM4
28143 (
28144 RgSchCellCb                *cell,
28145 RgSchUeCb                  *ue,
28146 RgSchDlHqProcCb            *proc,
28147 U8                         *numTxLyrs,
28148 TfuDciFormat               *dciFrmt,
28149 U8                         *prcdngInf,
28150 RgSchDlHqTbCb              **retxTb,
28151 RgSchDlHqTbCb              **txTb,
28152 Bool                       *frthrScp,
28153 Bool                       *swpFlg,
28154 U8                         *raType
28155 )
28156 #else
28157 PRIVATE Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
28158         prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
28159 RgSchCellCb                *cell;
28160 RgSchUeCb                  *ue;
28161 RgSchDlHqProcCb            *proc;
28162 U8                         *numTxLyrs;
28163 TfuDciFormat               *dciFrmt;
28164 U8                         *prcdngInf;
28165 RgSchDlHqTbCb              **retxTb;
28166 RgSchDlHqTbCb              **txTb;
28167 Bool                       *frthrScp;
28168 Bool                       *swpFlg;
28169 U8                         *raType;
28170 #endif
28171 {
28172    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
28173    U8 precInfoAntIdx;
28174
28175    TRC2(rgSCHCmnDlGetAttrForTM4);
28176
28177    *frthrScp = FALSE;
28178    /* Integration_fix: SPS Proc shall always have only one Cw */
28179 #ifdef LTEMAC_SPS
28180    if (((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28181          (ueDl->mimoInfo.forceTD)) 
28182 #ifdef LTE_ADV
28183      ||(TRUE == rgSCHLaaSCellEnabled(cell))
28184 #endif
28185       )
28186 #else
28187    if ((ueDl->mimoInfo.forceTD) 
28188 #ifdef LTE_ADV
28189        || (TRUE == rgSCHLaaSCellEnabled(cell))
28190 #endif
28191       )
28192 #endif
28193    {
28194       /* Transmit Diversity. Format based on dlfsEnabled
28195        * No further scope */
28196       if (proc->tbInfo[0].state == HQ_TB_NACKED)
28197       {
28198          *retxTb = &proc->tbInfo[0];
28199          *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28200       }
28201       else
28202       {
28203          *retxTb = &proc->tbInfo[1];
28204          *dciFrmt = TFU_DCI_FORMAT_2;
28205          *raType = RG_SCH_CMN_RA_TYPE0;
28206       }
28207       *numTxLyrs = 1;
28208       *frthrScp = FALSE;
28209       *prcdngInf = 0;
28210       RETVOID;
28211    }
28212
28213    if (ueDl->mimoInfo.ri == 1)
28214    {
28215       /* single layer precoding. Format 2.
28216        * No further scope */
28217       if (proc->tbInfo[0].state == HQ_TB_NACKED)
28218       {
28219          *retxTb = &proc->tbInfo[0];
28220       }
28221       else
28222       {
28223          *retxTb = &proc->tbInfo[1];
28224       }
28225       *numTxLyrs = 1;
28226       *dciFrmt = TFU_DCI_FORMAT_2;
28227       *raType = RG_SCH_CMN_RA_TYPE0;
28228       *frthrScp = FALSE;
28229       *prcdngInf = 0; /*When RI= 1*/
28230       RETVOID;
28231    }
28232
28233    /* Determine the 2 TB transmission attributes */
28234    rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, \
28235          frthrScp, swpFlg);
28236    *dciFrmt = TFU_DCI_FORMAT_2;
28237    *raType = RG_SCH_CMN_RA_TYPE0;
28238    if (*frthrScp)
28239    {
28240       /* Prefer allocation of RETX TB over 2 layers rather than combining
28241        * it with a new TX. */
28242       if ((ueDl->mimoInfo.ri == 2)
28243             && ((*retxTb)->numLyrs == 2) && (cell->numTxAntPorts == 4))
28244       {
28245          /* Allocate TB on CW1, using 2 Lyrs,
28246           * Format 2, precoding accordingly */
28247          *numTxLyrs = 2;
28248          *frthrScp = FALSE;
28249       }
28250       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28251       *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])
28252                    (cell, ue, ueDl->mimoInfo.ri, *frthrScp);
28253    }
28254    else /* frthrScp == FALSE */
28255    {
28256       if (cell->numTxAntPorts == 2)
28257       {
28258          /* single layer precoding. Format 2. */
28259          *numTxLyrs = 1;
28260          *prcdngInf = (getPrecInfoFunc[1][cell->numTxAntPorts/2 - 1])\
28261                       (cell, ue, *numTxLyrs, *frthrScp);
28262          RETVOID;
28263       }
28264       else /* NumAntPorts == 4 */
28265       {
28266          if ((*retxTb)->numLyrs == 2)
28267          {
28268             /* Allocate TB on CW1, using 2 Lyrs,
28269              * Format 2, precoding accordingly */
28270             *numTxLyrs = 2;
28271             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28272             *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
28273                          (cell, ue, *numTxLyrs, *frthrScp);
28274             RETVOID;
28275          }
28276          else
28277          {
28278             /* Allocate TB with 1 lyr precoding,
28279              * Format 2, precoding info accordingly */
28280             *numTxLyrs = 1;
28281             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28282             *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
28283                          (cell, ue, *numTxLyrs, *frthrScp);
28284             RETVOID;
28285          }
28286       }
28287    }
28288
28289    RETVOID;
28290 }
28291
28292 \f
28293 /**
28294  * @brief This function handles Retx allocation in case of TM3 UEs
28295  *        where previously one of the TBs was NACKED and the other
28296  *        TB is either ACKED/WAITING.
28297  *
28298  * @details
28299  *
28300  *     Function: rgSCHCmnDlTM3TxRetx
28301  *     Purpose:  Determine the TX attributes for TM3 TxRetx Allocation.
28302  *               If futher Scope for New Tx Allocation on other TB
28303  *                  Perform RETX alloc'n on 1 CW and TX alloc'n on other.
28304  *                  Add UE to cell wide RetxTx List.
28305  *               Else
28306  *                  Perform only RETX alloc'n on CW1.
28307  *                  Add UE to cell wide Retx List.
28308  *
28309  *               effBo is set to a non-zero value if allocation is
28310  *               successful.
28311  *
28312  *     Invoked by: rgSCHCmnDlAllocRbTM3
28313  *
28314  *  @param[in]  RgSchCellCb           *cell
28315  *  @param[in]  RgSchDlSf             *subFrm
28316  *  @param[in]  RgSchUeCb             *ue
28317  *  @param[in]  U32                   bo
28318  *  @param[out] U32                   *effBo
28319  *  @param[in]  RgSchDlHqProcCb       *proc
28320  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28321  *  @return  Void
28322  *
28323  **/
28324 #ifdef ANSI
28325 PRIVATE Void rgSCHCmnDlTM3TxRetx
28326 (
28327 RgSchCellCb                *cell,
28328 RgSchDlSf                  *subFrm,
28329 RgSchUeCb                  *ue,
28330 U32                        bo,
28331 U32                        *effBo,
28332 RgSchDlHqProcCb            *proc,
28333 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28334 )
28335 #else
28336 PRIVATE Void rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28337 RgSchCellCb                *cell;
28338 RgSchDlSf                  *subFrm;
28339 RgSchUeCb                  *ue;
28340 U32                        bo;
28341 U32                        *effBo;
28342 RgSchDlHqProcCb            *proc;
28343 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28344 #endif
28345 {
28346    S16              ret;
28347    RgSchDlRbAlloc   *allocInfo;
28348    U8               numRb;
28349    RgSchDlHqTbCb    *retxTb, *txTb;
28350    Bool             frthrScp;
28351    Bool             swpFlg;
28352    U8               prcdngInf;
28353    U8               numTxLyrs;
28354
28355    TRC2(rgSCHCmnDlTM3TxRetx);
28356    frthrScp = FALSE;
28357
28358    ret = ROK;
28359    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28360    swpFlg = FALSE;
28361
28362    /* Determine the transmission attributes */
28363    rgSCHCmnDlGetAttrForTM3(cell, ue, proc, &numTxLyrs, &allocInfo->dciFormat,\
28364          &prcdngInf, &retxTb, &txTb, &frthrScp, &swpFlg,\
28365          &allocInfo->raType);
28366
28367    if (frthrScp)
28368    {
28369 #ifdef LAA_DBG_LOG
28370       printf ("TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
28371 #endif
28372       ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
28373             &numRb, effBo);
28374       if (ret == RFAILED)
28375       {
28376          /* Allocation couldn't be made for Retx */
28377          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28378          RETVOID;
28379       }
28380       /* Adding UE to RbAllocInfo RETX-TX Lst */
28381       rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
28382    }
28383    else
28384    {
28385       ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, retxTb,
28386             numTxLyrs, &numRb, effBo);
28387       if (ret == RFAILED)
28388       {
28389          /* Allocation couldn't be made for Retx */
28390          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28391          RETVOID;
28392       }
28393 #ifdef LTEMAC_SPS
28394       if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28395 #endif
28396       {
28397          /* Adding UE to allocInfo RETX Lst */
28398          rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
28399       }
28400    }
28401    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
28402          prcdngInf, numTxLyrs, subFrm);
28403
28404    RETVOID;
28405 }
28406
28407 \f
28408 /**
28409  * @brief This function handles Retx allocation in case of TM4 UEs
28410  *        where previously one of the TBs was NACKED and the other
28411  *        TB is either ACKED/WAITING.
28412  *
28413  * @details
28414  *
28415  *     Function: rgSCHCmnDlTM4TxRetx
28416  *     Purpose:  Determine the TX attributes for TM4 TxRetx Allocation.
28417  *               If futher Scope for New Tx Allocation on other TB
28418  *                  Perform RETX alloc'n on 1 CW and TX alloc'n on other.
28419  *                  Add UE to cell wide RetxTx List.
28420  *               Else
28421  *                  Perform only RETX alloc'n on CW1.
28422  *                  Add UE to cell wide Retx List.
28423  *
28424  *               effBo is set to a non-zero value if allocation is
28425  *               successful.
28426  *
28427  *     Invoked by: rgSCHCmnDlAllocRbTM4
28428  *
28429  *  @param[in]  RgSchCellCb           *cell
28430  *  @param[in]  RgSchDlSf             *subFrm
28431  *  @param[in]  RgSchUeCb             *ue
28432  *  @param[in]  U32                   bo
28433  *  @param[out] U32                   *effBo
28434  *  @param[in]  RgSchDlHqProcCb       *proc
28435  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28436  *  @return  Void
28437  *
28438  **/
28439 #ifdef ANSI
28440 PRIVATE Void rgSCHCmnDlTM4TxRetx
28441 (
28442 RgSchCellCb                *cell,
28443 RgSchDlSf                  *subFrm,
28444 RgSchUeCb                  *ue,
28445 U32                        bo,
28446 U32                        *effBo,
28447 RgSchDlHqProcCb            *proc,
28448 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28449 )
28450 #else
28451 PRIVATE Void rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28452 RgSchCellCb                *cell;
28453 RgSchDlSf                  *subFrm;
28454 RgSchUeCb                  *ue;
28455 U32                        bo;
28456 U32                        *effBo;
28457 RgSchDlHqProcCb            *proc;
28458 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28459 #endif
28460 {
28461    S16              ret;
28462    RgSchDlRbAlloc   *allocInfo;
28463    U8               numRb;
28464    RgSchDlHqTbCb    *retxTb, *txTb;
28465    Bool             frthrScp;
28466    Bool             swpFlg;
28467    U8               prcdngInf;
28468    U8               numTxLyrs;
28469
28470    TRC2(rgSCHCmnDlTM4TxRetx);
28471
28472    ret = ROK;
28473    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28474    swpFlg = FALSE;
28475
28476    /* Determine the transmission attributes */
28477    rgSCHCmnDlGetAttrForTM4(cell, ue, proc, &numTxLyrs, &allocInfo->dciFormat,\
28478          &prcdngInf, &retxTb, &txTb, &frthrScp, &swpFlg,\
28479          &allocInfo->raType);
28480
28481    if (frthrScp)
28482    {
28483       ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
28484             &numRb, effBo);
28485       if (ret == RFAILED)
28486       {
28487          /* Fix : syed If TxRetx allocation failed then add the UE along 
28488           * with the proc to the nonSchdTxRetxUeLst and let spfc scheduler
28489           *  take care of it during finalization. */       
28490          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28491          RETVOID;
28492       }
28493       /* Adding UE to RbAllocInfo RETX-TX Lst */
28494       rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
28495    }
28496    else
28497    {
28498       ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, retxTb,
28499             numTxLyrs, &numRb, effBo);
28500       if (ret == RFAILED)
28501       {
28502          /* Allocation couldn't be made for Retx */
28503          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28504          RETVOID;
28505       }
28506 #ifdef LTEMAC_SPS
28507       if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28508 #endif
28509       {
28510          /* Adding UE to allocInfo RETX Lst */
28511          rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
28512       }
28513    }
28514    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
28515          prcdngInf, numTxLyrs, subFrm)
28516
28517       RETVOID;
28518 }
28519
28520 \f
28521 /**
28522  * @brief This function handles Retx allocation in case of TM4 UEs
28523  *        where previously both the TBs were ACKED and ACKED
28524  *        respectively.
28525  *
28526  * @details
28527  *
28528  *     Function: rgSCHCmnDlTM3TxTx
28529  *     Purpose:  Reached here for a TM3 UE's HqP's fresh allocation
28530  *                  where both the TBs are free for TX scheduling.
28531  *               If forceTD flag is set
28532  *                  perform TD on CW1 with TB1.
28533  *                  precInfo = 0
28534  *               else
28535  *                  DCI Format = 2A.
28536  *                  RA Type = Type0.
28537  *                  RI layered precoding 2 TB on 2 CW.
28538  *                  Set precoding info.
28539  *               Add UE to cellAllocInfo.
28540  *               Fill ueAllocInfo.
28541  *
28542  *              effBo is set to a non-zero value if allocation is
28543  *              successful.
28544  *
28545  *     Invoked by: rgSCHCmnDlAllocRbTM3
28546  *
28547  *  @param[in]  RgSchCellCb           *cell
28548  *  @param[in]  RgSchDlSf             *subFrm
28549  *  @param[in]  RgSchUeCb             *ue
28550  *  @param[in]  U32                   bo
28551  *  @param[out] U32                   *effBo
28552  *  @param[in]  RgSchDlHqProcCb       *proc
28553  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28554  *  @return  Void
28555  *
28556  **/
28557 #ifdef ANSI
28558 PRIVATE Void rgSCHCmnDlTM3TxTx
28559 (
28560 RgSchCellCb                *cell,
28561 RgSchDlSf                  *subFrm,
28562 RgSchUeCb                  *ue,
28563 U32                        bo,
28564 U32                        *effBo,
28565 RgSchDlHqProcCb            *proc,
28566 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28567 )
28568 #else
28569 PRIVATE Void rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28570 RgSchCellCb                *cell;
28571 RgSchDlSf                  *subFrm;
28572 RgSchUeCb                  *ue;
28573 U32                        bo;
28574 U32                        *effBo;
28575 RgSchDlHqProcCb            *proc;
28576 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28577 #endif
28578 {
28579    RgSchCmnDlUe     *ueDl;
28580    RgSchDlRbAlloc   *allocInfo;
28581    U8               numRb;
28582    U8               noTxLyrs;
28583    U8               precInfo;
28584    S16              ret;
28585    U8               precInfoAntIdx;
28586
28587    TRC2(rgSCHCmnDlTM3TxTx);
28588
28589    ret = ROK;
28590    ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
28591    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28592
28593    /* Integration_fix: SPS Proc shall always have only one Cw */
28594 #ifdef LTEMAC_SPS
28595 #ifdef FOUR_TX_ANTENNA
28596       if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28597                      (ueDl->mimoInfo.forceTD) || proc->hasDcch) /*Chandra Avoid DCCH to be SM */
28598 #else
28599    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28600          (ueDl->mimoInfo.forceTD))
28601 #endif
28602 #else
28603    if (ueDl->mimoInfo.forceTD) /* Transmit Diversity (TD) */
28604 #endif
28605    {
28606       allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
28607             &allocInfo->raType);
28608       ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28609             bo, &numRb, effBo);
28610       if (ret == RFAILED)
28611       {
28612          /* If allocation couldn't be made then return */
28613          RETVOID;
28614       }
28615       noTxLyrs = 1;
28616       precInfo = 0; /* TD */
28617    }
28618    else /* Precoding */
28619    {
28620       allocInfo->dciFormat = TFU_DCI_FORMAT_2A;
28621       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
28622
28623       /* Spatial Multiplexing using 2 CWs */
28624       ret = rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, &numRb, effBo);
28625       if (ret == RFAILED)
28626       {
28627          /* If allocation couldn't be made then return */
28628          RETVOID;
28629       }
28630       noTxLyrs = ueDl->mimoInfo.ri;
28631       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28632       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, getPrecInfoFunc[0], precInfoAntIdx);
28633       precInfo = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
28634    }
28635
28636 #ifdef LTEMAC_SPS
28637    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28638 #endif
28639    {
28640       /* Adding UE to RbAllocInfo TX Lst */
28641       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
28642    }
28643    /* Fill UE allocInfo scrath pad */
28644    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
28645          precInfo, noTxLyrs, subFrm);
28646
28647    RETVOID;
28648 }
28649
28650 \f
28651 /**
28652  * @brief This function handles Retx allocation in case of TM4 UEs
28653  *        where previously both the TBs were ACKED and ACKED
28654  *        respectively.
28655  *
28656  * @details
28657  *
28658  *     Function: rgSCHCmnDlTM4TxTx
28659  *     Purpose:  Reached here for a TM4 UE's HqP's fresh allocation
28660  *                  where both the TBs are free for TX scheduling.
28661  *               If forceTD flag is set
28662  *                  perform TD on CW1 with TB1.
28663  *                  precInfo = 0
28664  *               else
28665  *                  DCI Format = 2.
28666  *                  RA Type = Type0.
28667  *                  If Rank == 1
28668  *                     Single layer precoding of TB1 on CW1.
28669  *                     Set precoding info.
28670  *                  else
28671  *                     RI layered precoding 2 TB on 2 CW.
28672  *                     Set precoding info.
28673  *               Add UE to cellAllocInfo.
28674  *               Fill ueAllocInfo.
28675  *
28676  *              effBo is set to a non-zero value if allocation is
28677  *              successful.
28678  *
28679  *     Invoked by: rgSCHCmnDlAllocRbTM4
28680  *
28681  *  @param[in]  RgSchCellCb           *cell
28682  *  @param[in]  RgSchDlSf             *subFrm
28683  *  @param[in]  RgSchUeCb             *ue
28684  *  @param[in]  U32                   bo
28685  *  @param[out] U32                   *effBo
28686  *  @param[in]  RgSchDlHqProcCb       *proc
28687  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28688  *  @return  Void
28689  *
28690  **/
28691 #ifdef ANSI
28692 PRIVATE Void rgSCHCmnDlTM4TxTx
28693 (
28694 RgSchCellCb                *cell,
28695 RgSchDlSf                  *subFrm,
28696 RgSchUeCb                  *ue,
28697 U32                        bo,
28698 U32                        *effBo,
28699 RgSchDlHqProcCb            *proc,
28700 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28701 )
28702 #else
28703 PRIVATE Void rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28704 RgSchCellCb                *cell;
28705 RgSchDlSf                  *subFrm;
28706 RgSchUeCb                  *ue;
28707 U32                        bo;
28708 U32                        *effBo;
28709 RgSchDlHqProcCb            *proc;
28710 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28711 #endif
28712 {
28713    RgSchCmnDlUe     *ueDl;
28714    RgSchDlRbAlloc   *allocInfo;
28715    U8               numRb;
28716    U8               precInfo;
28717    U8               noTxLyrs;
28718    U8               precInfoAntIdx;
28719    S16              ret;
28720
28721    TRC2(rgSCHCmnDlTM4TxTx);
28722
28723    ret       = ROK;
28724    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
28725    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28726
28727    /* Integration_fix: SPS Proc shall always have only one Cw */
28728 #ifdef LTEMAC_SPS
28729 #ifdef FOUR_TX_ANTENNA
28730    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28731                   (ueDl->mimoInfo.forceTD) || proc->hasDcch) /*Chandra Avoid DCCH to be SM */
28732 #else
28733    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28734          (ueDl->mimoInfo.forceTD))
28735 #endif
28736 #else
28737    if (ueDl->mimoInfo.forceTD) /* Transmit Diversity (TD) */
28738 #endif
28739    {
28740       allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
28741             &allocInfo->raType);
28742
28743       ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28744             bo, &numRb, effBo);
28745       if (ret == RFAILED)
28746       {
28747          /* If allocation couldn't be made then return */
28748          RETVOID;
28749       }
28750       noTxLyrs = 1;
28751       precInfo = 0; /* TD */
28752    }
28753    else /* Precoding */
28754    {
28755       allocInfo->dciFormat = TFU_DCI_FORMAT_2;
28756       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
28757
28758       if (ueDl->mimoInfo.ri == 1)
28759       {
28760          /* Single Layer SM using FORMAT 2 */
28761          ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28762                bo, &numRb, effBo);
28763          if (ret == RFAILED)
28764          {
28765             /* If allocation couldn't be made then return */
28766             RETVOID;
28767          }
28768          noTxLyrs = 1;
28769          precInfo = 0; /* PrecInfo as 0 for RI=1*/
28770       }
28771       else
28772       {
28773          /* Spatial Multiplexing using 2 CWs */
28774          ret = rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, &numRb, effBo);
28775          if (ret == RFAILED)
28776          {
28777             /* If allocation couldn't be made then return */
28778             RETVOID;
28779          }
28780          noTxLyrs = ueDl->mimoInfo.ri;
28781          precInfoAntIdx = cell->numTxAntPorts/2 - 1; 
28782          precInfo = (getPrecInfoFunc[1][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
28783       }
28784    }
28785
28786    
28787 #ifdef LTEMAC_SPS
28788    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28789 #endif
28790    {
28791       /* Adding UE to RbAllocInfo TX Lst */
28792       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
28793    }
28794
28795    /* Fill UE allocInfo scrath pad */
28796    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
28797          precInfo, noTxLyrs, subFrm);
28798
28799    RETVOID;
28800 }
28801
28802 \f
28803 /**
28804  * @brief This function determines the RBs and Bytes required for BO
28805  *        transmission for UEs configured with TM 4.
28806  *
28807  * @details
28808  *
28809  *     Function: rgSCHCmnDlAllocTxRbTM4
28810  *     Purpose:  Invokes the functionality particular to the
28811  *               current state of the TBs of the "proc".
28812  *
28813  *               Reference Parameter effBo is filled with alloced bytes.
28814  *               Returns RFAILED if BO not satisfied at all.
28815  *
28816  *     Invoked by: rgSCHCmnDlAllocTxRb
28817  *
28818  *  @param[in]  RgSchCellCb           *cell
28819  *  @param[in]  RgSchDlSf             *subFrm
28820  *  @param[in]  RgSchUeCb             *ue
28821  *  @param[in]  U32                   bo
28822  *  @param[out] U32                   *effBo
28823  *  @param[in]  RgSchDlHqProcCb       *proc
28824  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28825  *  @return  Void
28826  *
28827  **/
28828 #ifdef ANSI
28829 PRIVATE Void rgSCHCmnDlAllocTxRbTM4
28830 (
28831 RgSchCellCb                *cell,
28832 RgSchDlSf                  *subFrm,
28833 RgSchUeCb                  *ue,
28834 U32                        bo,
28835 U32                        *effBo,
28836 RgSchDlHqProcCb            *proc,
28837 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28838 )
28839 #else
28840 PRIVATE Void rgSCHCmnDlAllocTxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28841 RgSchCellCb                *cell;
28842 RgSchDlSf                  *subFrm;
28843 RgSchUeCb                  *ue;
28844 U32                        bo;
28845 U32                        *effBo;
28846 RgSchDlHqProcCb            *proc;
28847 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28848 #endif
28849 {
28850    TRC2(rgSCHCmnDlAllocTxRbTM4);
28851
28852    /* Both TBs free for TX allocation */
28853    rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
28854          proc, cellWdAllocInfo);
28855
28856    RETVOID;
28857 }
28858
28859 \f
28860 /**
28861  * @brief This function determines the RBs and Bytes required for BO
28862  *        retransmission for UEs configured with TM 4.
28863  *
28864  * @details
28865  *
28866  *     Function: rgSCHCmnDlAllocRetxRbTM4
28867  *     Purpose:  Invokes the functionality particular to the
28868  *               current state of the TBs of the "proc".
28869  *
28870  *               Reference Parameter effBo is filled with alloced bytes.
28871  *               Returns RFAILED if BO not satisfied at all.
28872  *
28873  *     Invoked by: rgSCHCmnDlAllocRetxRb
28874  *
28875  *  @param[in]  RgSchCellCb           *cell
28876  *  @param[in]  RgSchDlSf             *subFrm
28877  *  @param[in]  RgSchUeCb             *ue
28878  *  @param[in]  U32                   bo
28879  *  @param[out] U32                   *effBo
28880  *  @param[in]  RgSchDlHqProcCb       *proc
28881  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28882  *  @return  Void
28883  *
28884  **/
28885 #ifdef ANSI
28886 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4
28887 (
28888 RgSchCellCb                *cell,
28889 RgSchDlSf                  *subFrm,
28890 RgSchUeCb                  *ue,
28891 U32                        bo,
28892 U32                        *effBo,
28893 RgSchDlHqProcCb            *proc,
28894 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28895 )
28896 #else
28897 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28898 RgSchCellCb                *cell;
28899 RgSchDlSf                  *subFrm;
28900 RgSchUeCb                  *ue;
28901 U32                        bo;
28902 U32                        *effBo;
28903 RgSchDlHqProcCb            *proc;
28904 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28905 #endif
28906 {
28907    TRC2(rgSCHCmnDlAllocRetxRbTM4);
28908
28909    if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
28910          (proc->tbInfo[1].state == HQ_TB_NACKED))
28911    {
28912       /* Both TBs require RETX allocation */
28913       rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo,\
28914             proc, cellWdAllocInfo);
28915    }
28916    else
28917    {
28918       /* One of the TBs need RETX allocation. Other TB may/maynot
28919        * be available for new TX allocation. */
28920       rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo,\
28921             proc, cellWdAllocInfo);
28922    }
28923
28924    RETVOID;
28925 }
28926
28927 #ifdef RG_UNUSED
28928 \f
28929 /**
28930  * @brief This function determines the RBs and Bytes required for BO
28931  *        transmission for UEs configured with TM 5.
28932  *
28933  * @details
28934  *
28935  *     Function: rgSCHCmnDlAllocTxRbTM5
28936  *     Purpose:
28937  *
28938  *               Reference Parameter effBo is filled with alloced bytes.
28939  *               Returns RFAILED if BO not satisfied at all.
28940  *
28941  *     Invoked by: rgSCHCmnDlAllocTxRb
28942  *
28943  *  @param[in]  RgSchCellCb           *cell
28944  *  @param[in]  RgSchDlSf             *subFrm
28945  *  @param[in]  RgSchUeCb             *ue
28946  *  @param[in]  U32                   bo
28947  *  @param[out] U32                   *effBo
28948  *  @param[in]  RgSchDlHqProcCb       *proc
28949  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28950  *  @return Void
28951  *
28952  **/
28953 #ifdef ANSI
28954 PRIVATE Void rgSCHCmnDlAllocTxRbTM5
28955 (
28956 RgSchCellCb                *cell,
28957 RgSchDlSf                  *subFrm,
28958 RgSchUeCb                  *ue,
28959 U32                        bo,
28960 U32                        *effBo,
28961 RgSchDlHqProcCb            *proc,
28962 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28963 )
28964 #else
28965 PRIVATE Void rgSCHCmnDlAllocTxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28966 RgSchCellCb                *cell;
28967 RgSchDlSf                  *subFrm;
28968 RgSchUeCb                  *ue;
28969 U32                        bo;
28970 U32                        *effBo;
28971 RgSchDlHqProcCb            *proc;
28972 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28973 #endif
28974 {
28975    TRC2(rgSCHCmnDlAllocTxRbTM5);
28976 #if (ERRCLASS & ERRCLS_DEBUG)
28977    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
28978 #endif
28979    RETVOID;
28980 }
28981
28982 \f
28983 /**
28984  * @brief This function determines the RBs and Bytes required for BO
28985  *        retransmission for UEs configured with TM 5.
28986  *
28987  * @details
28988  *
28989  *     Function: rgSCHCmnDlAllocRetxRbTM5
28990  *     Purpose:
28991  *
28992  *               Reference Parameter effBo is filled with alloced bytes.
28993  *               Returns RFAILED if BO not satisfied at all.
28994  *
28995  *     Invoked by: rgSCHCmnDlAllocRetxRb
28996  *
28997  *  @param[in]  RgSchCellCb           *cell
28998  *  @param[in]  RgSchDlSf             *subFrm
28999  *  @param[in]  RgSchUeCb             *ue
29000  *  @param[in]  U32                   bo
29001  *  @param[out] U32                   *effBo
29002  *  @param[in]  RgSchDlHqProcCb       *proc
29003  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29004  *  @return Void
29005  *
29006  **/
29007 #ifdef ANSI
29008 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5
29009 (
29010 RgSchCellCb                *cell,
29011 RgSchDlSf                  *subFrm,
29012 RgSchUeCb                  *ue,
29013 U32                        bo,
29014 U32                        *effBo,
29015 RgSchDlHqProcCb            *proc,
29016 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29017 )
29018 #else
29019 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29020 RgSchCellCb                *cell;
29021 RgSchDlSf                  *subFrm;
29022 RgSchUeCb                  *ue;
29023 U32                        bo;
29024 U32                        *effBo;
29025 RgSchDlHqProcCb            *proc;
29026 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29027 #endif
29028 {
29029    TRC2(rgSCHCmnDlAllocRetxRbTM5);
29030 #if (ERRCLASS & ERRCLS_DEBUG)
29031    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
29032 #endif
29033    RETVOID;
29034 }
29035 #endif
29036
29037 \f
29038 /**
29039  * @brief This function determines the RBs and Bytes required for BO
29040  *        transmission for UEs configured with TM 6.
29041  *
29042  * @details
29043  *
29044  *     Function: rgSCHCmnDlAllocTxRbTM6
29045  *     Purpose:
29046  *
29047  *               Reference Parameter effBo is filled with alloced bytes.
29048  *               Returns RFAILED if BO not satisfied at all.
29049  *
29050  *     Invoked by: rgSCHCmnDlAllocTxRb
29051  *
29052  *  @param[in]  RgSchCellCb           *cell
29053  *  @param[in]  RgSchDlSf             *subFrm
29054  *  @param[in]  RgSchUeCb             *ue
29055  *  @param[in]  U32                   bo
29056  *  @param[out] U32                   *effBo
29057  *  @param[in]  RgSchDlHqProcCb       *proc
29058  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29059  *  @return Void
29060  *
29061  **/
29062 #ifdef ANSI
29063 PRIVATE Void rgSCHCmnDlAllocTxRbTM6
29064 (
29065 RgSchCellCb                *cell,
29066 RgSchDlSf                  *subFrm,
29067 RgSchUeCb                  *ue,
29068 U32                        bo,
29069 U32                        *effBo,
29070 RgSchDlHqProcCb            *proc,
29071 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29072 )
29073 #else
29074 PRIVATE Void rgSCHCmnDlAllocTxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29075 RgSchCellCb                *cell;
29076 RgSchDlSf                  *subFrm;
29077 RgSchUeCb                  *ue;
29078 U32                        bo;
29079 U32                        *effBo;
29080 RgSchDlHqProcCb            *proc;
29081 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29082 #endif
29083 {
29084    RgSchDlRbAlloc *allocInfo;
29085    RgSchCmnDlUe   *ueDl;
29086    S16            ret;
29087    U8             numRb;
29088
29089    TRC2(rgSCHCmnDlAllocTxRbTM6);
29090
29091    ret       = ROK;
29092    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29093    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29094
29095    if (ueDl->mimoInfo.forceTD)
29096    {
29097       allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
29098       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29099    }
29100    else
29101    {
29102       allocInfo->dciFormat = TFU_DCI_FORMAT_1B;
29103       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29104       /* Fill precoding information for FORMAT 1B */
29105       /* First 4 least significant bits to indicate PMI.
29106        * 4th most significant corresponds to pmi Confirmation.
29107        */
29108       allocInfo->mimoAllocInfo.precIdxInfo |= ue->mimoInfo.puschFdbkVld << 4;
29109       allocInfo->mimoAllocInfo.precIdxInfo |= ueDl->mimoInfo.pmi;
29110    }
29111    ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
29112          bo, &numRb, effBo);
29113    if (ret == RFAILED)
29114    {
29115       /* If allocation couldn't be made then return */
29116       RETVOID;
29117    }
29118    
29119 #ifdef LTEMAC_SPS
29120    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
29121 #endif
29122    {
29123       /* Adding UE to RbAllocInfo TX Lst */
29124       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
29125    }
29126    /* Fill UE alloc Info */
29127    allocInfo->rbsReq = numRb;
29128    allocInfo->dlSf   = subFrm;
29129    RETVOID;
29130 }
29131
29132 \f
29133 /**
29134  * @brief This function determines the RBs and Bytes required for BO
29135  *        retransmission for UEs configured with TM 6.
29136  *
29137  * @details
29138  *
29139  *     Function: rgSCHCmnDlAllocRetxRbTM6
29140  *     Purpose:
29141  *
29142  *               Reference Parameter effBo is filled with alloced bytes.
29143  *               Returns RFAILED if BO not satisfied at all.
29144  *
29145  *     Invoked by: rgSCHCmnDlAllocRetxRb
29146  *
29147  *  @param[in]  RgSchCellCb           *cell
29148  *  @param[in]  RgSchDlSf             *subFrm
29149  *  @param[in]  RgSchUeCb             *ue
29150  *  @param[in]  U32                   bo
29151  *  @param[out] U32                   *effBo
29152  *  @param[in]  RgSchDlHqProcCb       *proc
29153  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29154  *  @return Void
29155  *
29156  **/
29157 #ifdef ANSI
29158 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6
29159 (
29160 RgSchCellCb                *cell,
29161 RgSchDlSf                  *subFrm,
29162 RgSchUeCb                  *ue,
29163 U32                        bo,
29164 U32                        *effBo,
29165 RgSchDlHqProcCb            *proc,
29166 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29167 )
29168 #else
29169 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29170 RgSchCellCb                *cell;
29171 RgSchDlSf                  *subFrm;
29172 RgSchUeCb                  *ue;
29173 U32                        bo;
29174 U32                        *effBo;
29175 RgSchDlHqProcCb            *proc;
29176 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29177 #endif
29178 {
29179    RgSchDlRbAlloc *allocInfo;
29180    RgSchCmnDlUe   *ueDl;
29181    S16            ret;
29182    U8             numRb;
29183
29184    TRC2(rgSCHCmnDlAllocRetxRbTM6);
29185
29186    ret       = ROK;
29187    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29188    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29189
29190    if (ueDl->mimoInfo.forceTD)
29191    {
29192       allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
29193       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29194    }
29195    else
29196    {
29197       allocInfo->dciFormat = TFU_DCI_FORMAT_1B;
29198       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29199       /* Fill precoding information for FORMAT 1B */
29200       /* First 4 least significant bits to indicate PMI.
29201        * 4th most significant corresponds to pmi Confirmation.
29202        */
29203       allocInfo->mimoAllocInfo.precIdxInfo |= ue->mimoInfo.puschFdbkVld << 4;
29204       allocInfo->mimoAllocInfo.precIdxInfo |= ueDl->mimoInfo.pmi;
29205    }
29206
29207    /* Get the Allocation in terms of RBs that are required for
29208     * this retx of TB1 */
29209    ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, &proc->tbInfo[0],
29210          1, &numRb, effBo);
29211    if (ret == RFAILED)
29212    {
29213       /* Allocation couldn't be made for Retx */
29214       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
29215       RETVOID;
29216    }
29217    /* Adding UE to allocInfo RETX Lst */
29218    rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
29219    /* Fill UE alloc Info */
29220    allocInfo->rbsReq = numRb;
29221    allocInfo->dlSf   = subFrm;
29222    RETVOID;
29223 }
29224
29225 \f
29226 /**
29227  * @brief This function determines the RBs and Bytes required for BO
29228  *        transmission for UEs configured with TM 7.
29229  *
29230  * @details
29231  *
29232  *     Function: rgSCHCmnDlAllocTxRbTM7
29233  *     Purpose:
29234  *
29235  *               Reference Parameter effBo is filled with alloced bytes.
29236  *               Returns RFAILED if BO not satisfied at all.
29237  *
29238  *     Invoked by: rgSCHCmnDlAllocTxRb
29239  *
29240  *  @param[in]  RgSchCellCb           *cell
29241  *  @param[in]  RgSchDlSf             *subFrm
29242  *  @param[in]  RgSchUeCb             *ue
29243  *  @param[in]  U32                   bo
29244  *  @param[out] U32                   *effBo
29245  *  @param[in]  RgSchDlHqProcCb       *proc
29246  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29247  *  @return Void
29248  *
29249  **/
29250 #ifdef ANSI
29251 PRIVATE Void rgSCHCmnDlAllocTxRbTM7
29252 (
29253 RgSchCellCb                *cell,
29254 RgSchDlSf                  *subFrm,
29255 RgSchUeCb                  *ue,
29256 U32                        bo,
29257 U32                        *effBo,
29258 RgSchDlHqProcCb            *proc,
29259 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29260 )
29261 #else
29262 PRIVATE Void rgSCHCmnDlAllocTxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29263 RgSchCellCb                *cell;
29264 RgSchDlSf                  *subFrm;
29265 RgSchUeCb                  *ue;
29266 U32                        bo;
29267 U32                        *effBo;
29268 RgSchDlHqProcCb            *proc;
29269 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29270 #endif
29271 {
29272    TRC2(rgSCHCmnDlAllocTxRbTM7);
29273    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
29274    RETVOID;
29275 }
29276
29277 \f
29278 /**
29279  * @brief This function determines the RBs and Bytes required for BO
29280  *        retransmission for UEs configured with TM 7.
29281  *
29282  * @details
29283  *
29284  *     Function: rgSCHCmnDlAllocRetxRbTM7
29285  *     Purpose:
29286  *
29287  *               Reference Parameter effBo is filled with alloced bytes.
29288  *               Returns RFAILED if BO not satisfied at all.
29289  *
29290  *     Invoked by: rgSCHCmnDlAllocRetxRb
29291  *
29292  *  @param[in]  RgSchCellCb           *cell
29293  *  @param[in]  RgSchDlSf             *subFrm
29294  *  @param[in]  RgSchUeCb             *ue
29295  *  @param[in]  U32                   bo
29296  *  @param[out] U32                   *effBo
29297  *  @param[in]  RgSchDlHqProcCb       *proc
29298  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29299  *  @return Void
29300  *
29301  **/
29302 #ifdef ANSI
29303 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7
29304 (
29305 RgSchCellCb                *cell,
29306 RgSchDlSf                  *subFrm,
29307 RgSchUeCb                  *ue,
29308 U32                        bo,
29309 U32                        *effBo,
29310 RgSchDlHqProcCb            *proc,
29311 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29312 )
29313 #else
29314 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29315 RgSchCellCb                *cell;
29316 RgSchDlSf                  *subFrm;
29317 RgSchUeCb                  *ue;
29318 U32                        bo;
29319 U32                        *effBo;
29320 RgSchDlHqProcCb            *proc;
29321 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29322 #endif
29323 {
29324    TRC2(rgSCHCmnDlAllocRetxRbTM7);
29325    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
29326    RETVOID;
29327 }
29328
29329 \f
29330 /**
29331  * @brief This function invokes the TM specific DL TX RB Allocation routine.
29332  *
29333  * @details
29334  *
29335  *     Function: rgSCHCmnDlAllocTxRb
29336  *     Purpose:  This function invokes the TM specific
29337  *               DL TX RB Allocation routine.
29338  *
29339  *     Invoked by: Specific Schedulers
29340  *
29341  *  @param[in]  RgSchCellCb           *cell
29342  *  @param[in]  RgSchDlSf             *subFrm
29343  *  @param[in]  RgSchUeCb             *ue
29344  *  @param[in]  U32                   bo
29345  *  @param[out] U32                   *effBo
29346  *  @param[in]  RgSchDlHqProcCb       *proc
29347  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29348  *  @return  S16
29349  *
29350  **/
29351 #ifdef ANSI
29352 PUBLIC S16 rgSCHCmnDlAllocTxRb
29353 (
29354 RgSchCellCb                *cell,
29355 RgSchDlSf                  *subFrm,
29356 RgSchUeCb                  *ue,
29357 U32                        bo,
29358 U32                        *effBo,
29359 RgSchDlHqProcCb            *proc,
29360 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29361 )
29362 #else
29363 PUBLIC S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29364 RgSchCellCb                *cell;
29365 RgSchDlSf                  *subFrm;
29366 RgSchUeCb                  *ue;
29367 U32                        bo;
29368 U32                        *effBo;
29369 RgSchDlHqProcCb            *proc;
29370 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29371 #endif
29372 {
29373    U32                     newSchBits = 0;
29374    U32                     prevSchBits = 0;
29375    RgSchDlRbAlloc          *allocInfo;
29376
29377    TRC2(rgSCHCmnDlAllocTxRb);
29378
29379    if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
29380    {
29381       ue->dl.aggTbBits = 0;
29382    }
29383    *effBo = 0;
29384
29385    /* Calculate totals bits previously allocated */
29386    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29387    if (allocInfo->tbInfo[0].schdlngForTb)
29388    {
29389       prevSchBits += allocInfo->tbInfo[0].bytesReq;
29390    }
29391    if (allocInfo->tbInfo[1].schdlngForTb)
29392    {
29393       prevSchBits += allocInfo->tbInfo[1].bytesReq;
29394    }
29395
29396    /* Call TM specific RB allocation routine */
29397    (dlAllocTxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
29398          proc, cellWdAllocInfo);
29399
29400    if (*effBo)
29401    {
29402       /* Calculate totals bits newly allocated */
29403       if (allocInfo->tbInfo[0].schdlngForTb)
29404       {
29405          newSchBits += allocInfo->tbInfo[0].bytesReq;
29406       }
29407       if (allocInfo->tbInfo[1].schdlngForTb)
29408       {
29409          newSchBits += allocInfo->tbInfo[1].bytesReq;
29410       }
29411       if (newSchBits > prevSchBits)
29412       {
29413          ue->dl.aggTbBits += ((newSchBits - prevSchBits) * 8);
29414          RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
29415       }
29416    }
29417
29418    RETVALUE(ROK);
29419 }
29420
29421 /* DwPTS Scheduling Changes Start */
29422 #ifdef LTE_TDD
29423 /**
29424  * @brief Retransmit decision for TDD. Retx is avoided in below cases
29425  *        1) DL Sf       -> Spl Sf
29426  *        2) DL SF       -> DL SF 0 
29427  *
29428  * @details
29429  *
29430  *     Function: rgSCHCmnRetxAvoidTdd 
29431  *     Purpose: Avoid allocating RETX for cases 1, 2 
29432  * 
29433  *     Invoked by: rgSCHCmnRetxAvoidTdd 
29434  *
29435  *  @param[in]  RgSchDlSf             *curSf
29436  *  @param[in]  RgSchCellCb           *cell
29437  *  @param[in]  RgSchDlHqProcCb       *proc
29438  *  @return  Bool 
29439  *
29440  **/
29441 #ifdef ANSI
29442 PUBLIC Bool rgSCHCmnRetxAvoidTdd 
29443 (
29444 RgSchDlSf                  *curSf,
29445 RgSchCellCb                *cell,
29446 RgSchDlHqProcCb            *proc
29447 )
29448 #else
29449 PUBLIC Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
29450 RgSchDlSf                  *curSf;
29451 RgSchCellCb                *cell;
29452 RgSchDlHqProcCb            *proc;
29453 #endif
29454 {
29455    RgSchTddSfType   txSfType = 0;
29456
29457    TRC2(rgSCHCmnRetxAvoidTdd);
29458
29459    /* Get the RBs of TB that will be retransmitted */
29460    if (proc->tbInfo[0].state == HQ_TB_NACKED)
29461    {
29462       txSfType = proc->tbInfo[0].sfType;
29463
29464 #ifdef XEON_SPECIFIC_CHANGES
29465 #ifndef XEON_TDD_SPCL
29466       /* Avoid re-transmission on Normal SF when the corresponding TB wss transmitted on SPCL SF */
29467       if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
29468       {
29469          RETVALUE(TRUE);
29470       }
29471 #endif
29472 #endif
29473    }
29474    if (proc->tbInfo[1].state == HQ_TB_NACKED) 
29475    {
29476       /* Select the TxSf with the highest num of possible REs 
29477        * In ascending order -> 1) SPL SF 2) DL_SF_0 3) DL_SF */
29478       txSfType = RGSCH_MAX(txSfType, proc->tbInfo[1].sfType);
29479
29480 #ifdef XEON_SPECIFIC_CHANGES
29481 #ifndef XEON_TDD_SPCL
29482       /* Avoid re-transmission on Normal SF when the corresponding TB wss tranmitted on SPCL SF */
29483       if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
29484       {
29485          RETVALUE(TRUE);
29486       }
29487 #endif
29488 #endif
29489    }
29490
29491    if (txSfType > curSf->sfType)
29492    {
29493       /* Avoid retx */
29494       RETVALUE(TRUE);
29495    }
29496    
29497    /* Allow Retx */
29498    RETVALUE(FALSE);
29499 }
29500
29501 #else
29502 /* DwPTS Scheduling Changes End */
29503 \f
29504 /**
29505  * @brief Avoid allocating RETX incase of collision
29506  * with reserved resources for BCH/PSS/SSS occassions.
29507  *
29508  * @details
29509  *
29510  *     Function: rgSCHCmnRetxAllocAvoid 
29511  *     Purpose: Avoid allocating RETX incase of collision
29512  * with reserved resources for BCH/PSS/SSS occassions 
29513  *
29514  *     Invoked by: rgSCHCmnDlAllocRetxRb 
29515  *
29516  *  @param[in]  RgSchDlSf             *subFrm
29517  *  @param[in]  RgSchUeCb             *ue
29518  *  @param[in]  RgSchDlHqProcCb       *proc
29519  *  @return  Bool 
29520  *
29521  **/
29522 #ifdef ANSI
29523 PUBLIC Bool rgSCHCmnRetxAllocAvoid 
29524 (
29525 RgSchDlSf                  *subFrm,
29526 RgSchCellCb                *cell,
29527 RgSchDlHqProcCb            *proc
29528 )
29529 #else
29530 PUBLIC Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
29531 RgSchDlSf                  *subFrm;
29532 RgSchCellCb                *cell;
29533 RgSchDlHqProcCb            *proc;
29534 #endif
29535 {
29536    U8          reqRbs;
29537
29538    TRC2(rgSCHCmnRetxAllocAvoid);
29539
29540    if (proc->tbInfo[0].state == HQ_TB_NACKED)
29541    {
29542       reqRbs = proc->tbInfo[0].dlGrnt.numRb;    
29543    }
29544    else
29545    {
29546       reqRbs = proc->tbInfo[1].dlGrnt.numRb;    
29547    }
29548    /* Consider the dlGrnt.numRb of the Retransmitting proc->tbInfo
29549     * and current available RBs to determine if this RETX TB
29550     * will collide with the BCH/PSS/SSS occassion */
29551    if (subFrm->sfNum % 5 == 0)
29552    {
29553       if ((subFrm->bwAssigned < cell->pbchRbEnd) &&
29554           (((subFrm->bwAssigned + reqRbs) - cell->pbchRbStart) > 0))
29555       {
29556          RETVALUE(TRUE);
29557       }
29558    }
29559    RETVALUE(FALSE);
29560 }
29561
29562 #endif
29563
29564 \f
29565 /**
29566  * @brief This function invokes the TM specific DL RETX RB Allocation routine.
29567  *
29568  * @details
29569  *
29570  *     Function: rgSCHCmnDlAllocRetxRb
29571  *     Purpose:  This function invokes the TM specific
29572  *               DL RETX RB Allocation routine.
29573  *
29574  *     Invoked by: Specific Schedulers
29575  *
29576  *  @param[in]  RgSchCellCb           *cell
29577  *  @param[in]  RgSchDlSf             *subFrm
29578  *  @param[in]  RgSchUeCb             *ue
29579  *  @param[in]  U32                   bo
29580  *  @param[out] U32                   *effBo
29581  *  @param[in]  RgSchDlHqProcCb       *proc
29582  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29583  *  @return  S16
29584  *
29585  **/
29586 #ifdef ANSI
29587 PUBLIC S16 rgSCHCmnDlAllocRetxRb
29588 (
29589 RgSchCellCb                *cell,
29590 RgSchDlSf                  *subFrm,
29591 RgSchUeCb                  *ue,
29592 U32                        bo,
29593 U32                        *effBo,
29594 RgSchDlHqProcCb            *proc,
29595 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29596 )
29597 #else
29598 PUBLIC S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29599 RgSchCellCb                *cell;
29600 RgSchDlSf                  *subFrm;
29601 RgSchUeCb                  *ue;
29602 U32                        bo;
29603 U32                        *effBo;
29604 RgSchDlHqProcCb            *proc;
29605 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29606 #endif
29607 {
29608    U32                     newSchBits = 0;
29609    RgSchDlRbAlloc          *allocInfo;
29610
29611    TRC2(rgSCHCmnDlAllocRetxRb);
29612
29613    if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
29614    {
29615       ue->dl.aggTbBits = 0;
29616    }
29617  
29618    *effBo = 0;
29619    /* Check for DL BW exhaustion */
29620    if (subFrm->bw <= subFrm->bwAssigned)
29621    {
29622       RETVALUE(RFAILED);
29623    }
29624    /* Call TM specific RB allocation routine */
29625    (dlAllocRetxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
29626          proc, cellWdAllocInfo);
29627
29628    if (*effBo)
29629    {
29630       allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29631       /* Calculate totals bits newly allocated */
29632       if (allocInfo->tbInfo[0].schdlngForTb)
29633       {
29634          newSchBits += allocInfo->tbInfo[0].bytesReq;
29635       }
29636       if (allocInfo->tbInfo[1].schdlngForTb)
29637       {
29638          newSchBits += allocInfo->tbInfo[1].bytesReq;
29639       }
29640       ue->dl.aggTbBits += (newSchBits * 8);
29641       RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
29642    }
29643    
29644    RETVALUE(ROK);
29645 }
29646
29647 \f
29648 /**
29649  * @brief This function determines the RBs and Bytes required for
29650  *        Transmission on 1 CW.
29651  *
29652  * @details
29653  *
29654  *     Function: rgSCHCmnDlAlloc1CwTxRb
29655  *     Purpose:  This function determines the RBs and Bytes required
29656  *               for Transmission of DL SVC BO on 1 CW.
29657  *               Also, takes care of SVC by SVC allocation by tracking
29658  *               previous SVCs allocations.
29659  *               Returns RFAILED if BO not satisfied at all.
29660  *
29661  *     Invoked by: DL UE Allocation
29662  *
29663  *  @param[in]  RgSchCellCb      *cell
29664  *  @param[in]  RgSchDlSf        *subFrm
29665  *  @param[in]  RgSchUeCb        *ue
29666  *  @param[in]  RgSchDlHqTbCb    *tbInfo
29667  *  @param[in]  U32              bo
29668  *  @param[out] U8               *numRb
29669  *  @param[out] U32              *effBo
29670  *  @return  S16
29671  *
29672  **/
29673 #ifdef ANSI
29674 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb
29675 (
29676 RgSchCellCb                *cell,
29677 RgSchDlSf                  *subFrm,
29678 RgSchUeCb                  *ue,
29679 RgSchDlHqTbCb              *tbInfo,
29680 U32                        bo,
29681 U8                         *numRb,
29682 U32                        *effBo
29683 )
29684 #else
29685 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
29686 RgSchCellCb                *cell;
29687 RgSchDlSf                  *subFrm;
29688 RgSchUeCb                  *ue;
29689 RgSchDlHqTbCb              *tbInfo;
29690 U32                        bo;
29691 U8                         *numRb;
29692 U32                        *effBo;
29693 #endif
29694 {
29695    U32                tbSz;
29696    U8                 imcs;
29697    U8                 iTbs;
29698    RgSchCmnDlUe       *ueDl;
29699    RgSchDlRbAlloc     *allocInfo;
29700    U32                oldReq;
29701    U32                reqBytes;
29702    /* Correcting wrap around issue.
29703     * This change has been done at mutliple places in this function.*/
29704    U32                tempNumRb;
29705    TRC2(rgSCHCmnDlAlloc1CwTxRb);
29706
29707    reqBytes  = bo;
29708    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29709    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29710    oldReq    = ueDl->outStndAlloc;
29711
29712 #ifdef RG_5GTF
29713    //TODO_SID: Currently setting max Tb size wrt to 5GTF TM3
29714    iTbs = ue->ue5gtfCb.mcs;
29715    ueDl->maxTbSz = MAX_5GTF_TB_SIZE * ue->ue5gtfCb.rank;
29716    ueDl->maxRb = MAX_5GTF_PRBS;
29717 #endif
29718    ueDl->outStndAlloc += bo;
29719    /* consider Cumulative amount of this BO and bytes so far allocated */
29720    bo = RGSCH_MIN(ueDl->outStndAlloc, ueDl->maxTbSz/8);
29721    /* Get the number of REs needed for this bo. */
29722    //noRes = ((bo * 8 * 1024) / eff);
29723
29724    /* Get the number of RBs needed for this transmission */
29725    /* Number of RBs = No of REs / No of REs per RB       */
29726    //tempNumRb = RGSCH_CEIL(noRes, cellDl->noResPerRb[cfi]);
29727    tempNumRb = MAX_5GTF_PRBS;
29728    tbSz = RGSCH_MIN(bo, (rgSch5gtfTbSzTbl[iTbs]/8) * ue->ue5gtfCb.rank);
29729
29730    /* DwPts Scheduling Changes End */
29731    *effBo = RGSCH_MIN(tbSz - oldReq, reqBytes);
29732
29733 #ifdef RG_5GTF
29734    //RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs);
29735    imcs = iTbs;
29736 #endif
29737
29738
29739    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbSz, \
29740          iTbs, imcs, tbInfo, ue->ue5gtfCb.rank);
29741    *numRb = (U8) tempNumRb;
29742    
29743    /* Update the subframe Allocated BW field */
29744    subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
29745    
29746    RETVALUE(ROK);
29747 }
29748
29749 \f
29750 /**
29751  * @brief This function is invoked in the event of any TB's allocation
29752  *  being underutilized by the specific scheduler. Here we reduce iMcs
29753  *  to increase redundancy and hence increase reception quality at UE.
29754  *
29755  * @details
29756  *
29757  *     Function: rgSCHCmnRdcImcsTxTb
29758  *     Purpose:  This function shall reduce the iMcs in accordance with
29759  *               the total consumed bytes by the UE at allocation
29760  *               finalization.
29761  *
29762  *     Invoked by: UE DL Allocation finalization routine
29763  *                 of specific scheduler.
29764  *
29765  *  @param[in]  RgSchDlRbAlloc   *allocInfo
29766  *  @param[in]  U8               tbInfoIdx
29767  *  @param[in]  U32              cnsmdBytes
29768  *  @return  Void
29769  *
29770  **/
29771 #ifdef ANSI
29772 PUBLIC Void rgSCHCmnRdcImcsTxTb
29773 (
29774 RgSchDlRbAlloc   *allocInfo,
29775 U8               tbInfoIdx,
29776 U32              cnsmdBytes
29777 )
29778 #else
29779 PUBLIC Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
29780 RgSchDlRbAlloc   *allocInfo;
29781 U8               tbInfoIdx;
29782 U32              cnsmdBytes;
29783 #endif
29784 {
29785    RETVOID;
29786    /*The below functionality is not needed.*/
29787    U8                 noLyr;
29788    U8                 iTbs;
29789    U16                numRb;
29790
29791    TRC2(rgSCHCmnRdcImcsTxTb);
29792
29793    iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
29794    noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
29795    numRb = allocInfo->rbsAlloc;
29796    if ( numRb > 0)
29797    {
29798       if ((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) == cnsmdBytes)
29799       {
29800          RETVOID;
29801       }
29802    }
29803    /* Get iTbs as suitable for the consumed bytes */
29804    while((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) > cnsmdBytes)
29805    {
29806       if (iTbs == 0)
29807       {
29808          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].\
29809                tbCb->dlGrnt.iMcs);
29810          RETVOID;
29811       }
29812       iTbs--;
29813    }
29814    iTbs++;
29815    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].tbCb->dlGrnt.iMcs);
29816
29817    RETVOID;
29818 }
29819
29820 \f
29821 /**
29822  * @brief This function determines the RBs and Bytes required for
29823  *        Transmission on 2 CWs.
29824  *
29825  * @details
29826  *
29827  *     Function: rgSCHCmnDlAlloc2CwTxRb
29828  *     Purpose:  This function determines the RBs and Bytes required
29829  *               for Transmission of DL SVC BO on 2 CWs.
29830  *               Also, takes care of SVC by SVC allocation by tracking
29831  *               previous SVCs allocations.
29832  *               Returns RFAILED if BO not satisfied at all.
29833  *
29834  *     Invoked by: TM3 and TM4 DL UE Allocation
29835  *
29836  *  @param[in]  RgSchCellCb      *cell
29837  *  @param[in]  RgSchDlSf        *subFrm
29838  *  @param[in]  RgSchUeCb        *ue
29839  *  @param[in]  RgSchDlHqProcCb  *proc
29840  *  @param[in]  RgSchDlHqProcCb  bo
29841  *  @param[out] U8               *numRb
29842  *  @param[out] U32              *effBo
29843  *  @return  Void
29844  *
29845  **/
29846 #ifdef ANSI
29847 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb
29848 (
29849 RgSchCellCb                *cell,
29850 RgSchDlSf                  *subFrm,
29851 RgSchUeCb                  *ue,
29852 RgSchDlHqProcCb            *proc,
29853 U32                        bo,
29854 U8                         *numRbRef,
29855 U32                        *effBo
29856 )
29857 #else
29858 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
29859 RgSchCellCb                *cell;
29860 RgSchDlSf                  *subFrm;
29861 RgSchUeCb                  *ue;
29862 RgSchDlHqProcCb            *proc;
29863 U32                        bo;
29864 U8                         *numRbRef;
29865 U32                        *effBo;
29866 #endif
29867 {
29868    U32                noRes;
29869    U32                eff1, eff2;
29870    U32                tb1Sz, tb2Sz;
29871    U8                 imcs1, imcs2;
29872    U8                 noLyr1, noLyr2;
29873    U8                 iTbs1, iTbs2;
29874    RgSchCmnDlCell     *cellDl;
29875    RgSchCmnDlUe       *ueDl;
29876    RgSchDlRbAlloc     *allocInfo;
29877    U32                oldReq;
29878    U32                reqBytes;
29879    /* Fix: MUE_PERTTI_DL */
29880    U32                numRb;
29881    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
29882    U8                 cfi = cellSch->dl.currCfi;
29883    S16                availBw; 
29884    U32                availBits = 0;
29885 #ifdef LTE_ADV
29886    U32                boTmp = bo;
29887 #endif
29888
29889    TRC2(rgSCHCmnDlAlloc2CwTxRb);
29890
29891    reqBytes  = bo;
29892    cellDl    = RG_SCH_CMN_GET_DL_CELL(cell);
29893    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29894    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29895    oldReq    = ueDl->outStndAlloc;
29896
29897    
29898    if (ueDl->maxTbBits > ue->dl.aggTbBits)
29899    {
29900       availBits = ueDl->maxTbBits - ue->dl.aggTbBits;
29901    }
29902    /* check if we can further allocate to this UE */
29903    if ((ue->dl.aggTbBits >= ueDl->maxTbBits) ||
29904          (allocInfo->tbInfo[0].bytesReq >= ueDl->maxTbSz/8) ||
29905          (allocInfo->tbInfo[1].bytesReq >= ueDl->maxTbSz/8) ||
29906          (allocInfo->rbsReq >= ueDl->maxRb))
29907    {
29908       RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
29909             "rgSCHCmnDlAllocRb(): UEs max allocation exceed");
29910       RETVALUE(RFAILED);
29911    }
29912
29913    noLyr1 = ueDl->mimoInfo.cwInfo[0].noLyr;
29914    noLyr2 = ueDl->mimoInfo.cwInfo[1].noLyr;
29915
29916    /* If there is no CFI change, continue to use the BLER based
29917     * iTBS value */
29918    if (ueDl->lastCfi == cfi)
29919    {   
29920       iTbs1  = ueDl->mimoInfo.cwInfo[0].iTbs[noLyr1 - 1];
29921       iTbs2  = ueDl->mimoInfo.cwInfo[1].iTbs[noLyr2 - 1];
29922    }
29923    else
29924    {  
29925       U8 cqi = ueDl->mimoInfo.cwInfo[0].cqi;
29926 #ifdef LTE_TDD      
29927       iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
29928 #else      
29929       iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
29930 #endif         
29931
29932       cqi = ueDl->mimoInfo.cwInfo[1].cqi;
29933 #ifdef LTE_TDD      
29934       iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
29935 #else      
29936       iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
29937 #endif         
29938    } 
29939
29940    /*ccpu00131191 and ccpu00131317 - Fix for RRC Reconfig failure
29941     * issue for VoLTE call */
29942    //if ((proc->hasDcch)  || (TRUE == rgSCHLaaSCellEnabled(cell)))
29943    if (proc->hasDcch)
29944    {
29945       if (iTbs1 > 5)
29946       {
29947          iTbs1  = iTbs1 - 5;
29948       }
29949       else
29950       {
29951          iTbs1  = 0; 
29952       }
29953       if (iTbs2 > 5)
29954       {
29955          iTbs2  = iTbs2 - 5;
29956       }
29957       else
29958       {
29959          iTbs2  = 0; 
29960       }
29961    }
29962    else if(!cellSch->dl.isDlFreqSel)
29963    {
29964 #ifdef LTE_TDD
29965       /* for Tdd reduce iTbs only for SF0. SF5 contains only 
29966        * SSS and can be ignored */
29967       if (subFrm->sfNum == 0)
29968       {
29969          (iTbs1 > 1)? (iTbs1 -= 1) : (iTbs1 = 0);
29970          (iTbs2 > 1)? (iTbs2 -= 1) : (iTbs2 = 0);
29971       }
29972       /* For SF 3 and 8 CRC is getting failed in DL.
29973          Need to do proper fix after the replay from 
29974          BRCM PHY team*/
29975 #ifdef CA_PHY_BRDCM_61765      
29976       if ((subFrm->sfNum == 3) || (subFrm->sfNum == 8))
29977       {
29978          (iTbs1 > 2)? (iTbs1 -= 2) : (iTbs1 = 0);
29979          (iTbs2 > 2)? (iTbs2 -= 2) : (iTbs2 = 0);
29980       }
29981 #endif
29982 #else
29983 #endif
29984    }
29985
29986 #ifdef LTE_TDD
29987    if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
29988    {
29989       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
29990    }
29991 #endif 
29992
29993    eff1 = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[noLyr1 - 1][cfi]))[iTbs1];
29994    eff2 = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[noLyr2 - 1][cfi]))[iTbs2];
29995
29996
29997    bo = RGSCH_MIN(bo,availBits/8);
29998    ueDl->outStndAlloc += bo;
29999    /* consider Cumulative amount of this BO and bytes so far allocated */
30000    bo = RGSCH_MIN(ueDl->outStndAlloc, ueDl->maxTbBits/8);
30001    bo = RGSCH_MIN(RGSCH_MAX(RGSCH_CMN_MIN_GRNT_HDR, (bo*eff1)/(eff1+eff2)), 
30002                   ueDl->maxTbSz/8) +
30003         RGSCH_MIN(RGSCH_MAX(RGSCH_CMN_MIN_GRNT_HDR, (bo*eff2)/(eff1+eff2)), 
30004                   (ueDl->maxTbSz)/8) +
30005         1; /* Add 1 to adjust the truncation at weighted averaging */
30006    /* Get the number of REs needed for this bo. */
30007    noRes = ((bo * 8 * 1024) / (eff1 + eff2));
30008
30009    /* Get the number of RBs needed for this transmission */
30010    /* Number of RBs = No of REs / No of REs per RB       */
30011    numRb = RGSCH_CEIL(noRes, cellDl->noResPerRb[cfi]);
30012    /* Cannot exceed the maximum number of RBs per UE */
30013    if (numRb > ueDl->maxRb)
30014    {
30015       numRb = ueDl->maxRb;
30016    }
30017    else
30018    {
30019 #ifdef LTE_ADV
30020       if(RFAILED == rgSCHLaaCmn2CwAdjustPrb(allocInfo,  boTmp, &numRb, ueDl, noLyr1, noLyr2, iTbs1, iTbs2))
30021 #endif
30022       {
30023          while ((numRb <= ueDl->maxRb) &&
30024                (rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1] <= ueDl->maxTbSz) &&
30025                (rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1] <= ueDl->maxTbSz) &&
30026                ((rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1]/8 +
30027                  rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1]/8) <= bo))
30028          {
30029             (numRb)++;
30030          }
30031       }
30032    }
30033    availBw = subFrm->bw - subFrm->bwAssigned;
30034    /* Cannot exceed the total number of RBs in the cell */
30035    if ((S16)(numRb - allocInfo->rbsReq) > availBw)
30036    {
30037       numRb = availBw + allocInfo->rbsReq;
30038    }
30039    tb1Sz = rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1]/8;
30040    tb2Sz = rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1]/8;
30041    /* DwPts Scheduling Changes Start */
30042 #ifdef LTE_TDD
30043    if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
30044    { 
30045       /* Max Rb for Special Sf is approximated as 4/3 of maxRb */
30046       rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (U8*)&numRb,  ueDl->maxRb*4/3, 
30047                                 &iTbs1, &iTbs2, noLyr1, 
30048                                 noLyr2, &tb1Sz, &tb2Sz, cfi);   
30049       /* Check for available Bw */
30050       if ((S16)numRb - allocInfo->rbsReq > availBw)
30051       {
30052          numRb = availBw + allocInfo->rbsReq;
30053          tb1Sz = rgTbSzTbl[noLyr1-1][iTbs1][RGSCH_MAX(numRb*3/4,1)-1]/8;
30054          tb2Sz = rgTbSzTbl[noLyr2-1][iTbs2][RGSCH_MAX(numRb*3/4,1)-1]/8;
30055       }
30056    }
30057 #endif
30058    /* DwPts Scheduling Changes End */
30059    /* Update the subframe Allocated BW field */
30060    subFrm->bwAssigned = subFrm->bwAssigned + numRb - \
30061                         allocInfo->rbsReq;
30062
30063    *effBo = RGSCH_MIN((tb1Sz + tb2Sz) - oldReq, reqBytes);
30064
30065 #ifdef LTE_ADV
30066    if (ROK != rgSCHLaaCmn2TBPrbCheck(allocInfo, tb1Sz, tb2Sz, boTmp, effBo, iTbs1, iTbs2, numRb, proc))
30067    {
30068       RETVALUE(RFAILED);
30069    }
30070 #endif
30071
30072    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs1, imcs1);
30073    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs2, imcs2);
30074    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tb1Sz, \
30075          iTbs1, imcs1, &proc->tbInfo[0], noLyr1);
30076    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
30077          iTbs2, imcs2, &proc->tbInfo[1], noLyr2);
30078    *numRbRef = (U8)numRb;
30079
30080
30081    RETVALUE(ROK);
30082 }
30083
30084 \f
30085 /**
30086  * @brief This function determines the RBs and Bytes required for
30087  *        Transmission & Retransmission on 2 CWs.
30088  *
30089  * @details
30090  *
30091  *     Function: rgSCHCmnDlAlloc2CwTxRetxRb
30092  *     Purpose:  This function determines the RBs and Bytes required
30093  *               for Transmission & Retransmission on 2 CWs. Allocate
30094  *               RETX TB on a better CW and restrict new TX TB by
30095  *               RETX allocation.
30096  *               Returns RFAILED if BO not satisfied at all.
30097  *
30098  *     Invoked by: TM3 and TM4 DL UE Allocation
30099  *
30100  *  @param[in]  RgSchCellCb      *cell
30101  *  @param[in]  RgSchDlSf        *subFrm
30102  *  @param[in]  RgSchUeCb        *ue
30103  *  @param[in]  RgSchDlHqTbCb    *reTxTb
30104  *  @param[in]  RgSchDlHqTbCb    *txTb
30105  *  @param[out] U8               *numRb
30106  *  @param[out] U32              *effBo
30107  *  @return  Void
30108  *
30109  **/
30110 #ifdef ANSI
30111 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb
30112 (
30113 RgSchCellCb                *cell,
30114 RgSchDlSf                  *subFrm,
30115 RgSchUeCb                  *ue,
30116 RgSchDlHqTbCb              *reTxTb,
30117 RgSchDlHqTbCb              *txTb,
30118 U8                         *numRb,
30119 U32                        *effBo
30120 )
30121 #else
30122 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
30123         effBo)
30124 RgSchCellCb                *cell;
30125 RgSchDlSf                  *subFrm;
30126 RgSchUeCb                  *ue;
30127 RgSchDlHqTbCb              *reTxTb;
30128 RgSchDlHqTbCb              *txTb;
30129 U8                         *numRb;
30130 U32                        *effBo;
30131 #endif
30132 {
30133    RgSchCmnDlUe       *ueDl;
30134    RgSchDlRbAlloc     *allocInfo;
30135    U8                 imcs1, imcs2;
30136    U8                  noLyr2;
30137    U16                 tb2Sz;
30138    RgSchCmnDlUeCwInfo *otherCw;
30139    S16                 availBw;
30140    RgSchCmnDlCell     *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
30141    U8                 cfi = cellDl->currCfi; 
30142    U8                 iTbs;
30143
30144    TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
30145
30146    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
30147    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30148    otherCw   = &ueDl->mimoInfo.cwInfo[!(ueDl->mimoInfo.btrCwIdx)];
30149
30150
30151    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30152     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30153     * MCS.  */
30154    availBw = subFrm->bw - subFrm->bwAssigned; 
30155    *numRb = reTxTb->dlGrnt.numRb;
30156
30157 #ifdef XEON_TDD_SPCL
30158    *numRb = (reTxTb->initTxNumRbs);
30159    if(reTxTb->sfType == RG_SCH_SPL_SF_DATA && subFrm->sfType != RG_SCH_SPL_SF_DATA)
30160    {
30161       *numRb = (reTxTb->initTxNumRbs*3/4);
30162
30163       if(*numRb <= 3)
30164       {
30165          RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
30166          RETVALUE(RFAILED);
30167       }
30168    }
30169 #endif
30170
30171    if ((S16)*numRb > availBw)
30172    {
30173       RETVALUE(RFAILED);
30174    }
30175    /* Update the subframe Allocated BW field */
30176    subFrm->bwAssigned += *numRb;
30177    noLyr2 = otherCw->noLyr;
30178    RG_SCH_CMN_GET_MCS_FOR_RETX(reTxTb, imcs1);
30179
30180    /* If there is no CFI change, continue to use the BLER based
30181     * iTBS value */
30182    if (ueDl->lastCfi == cfi)
30183    {   
30184       iTbs = otherCw->iTbs[noLyr2-1];
30185    }
30186    else
30187    {  
30188 #ifdef LTE_TDD      
30189       iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi, 
30190                                       !(ueDl->mimoInfo.btrCwIdx), noLyr2);
30191 #else      
30192       iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi, 
30193                                       !(ueDl->mimoInfo.btrCwIdx), noLyr2);
30194 #endif 
30195    } 
30196    tb2Sz = rgTbSzTbl[noLyr2-1][iTbs][*numRb-1]/8;
30197    /* DwPts Scheduling Changes Start */
30198 #ifdef LTE_TDD
30199 #endif
30200    /* DwPts Scheduling Changes End */
30201    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs2);
30202    
30203    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], reTxTb->tbSz, \
30204                               0, imcs1, reTxTb, reTxTb->numLyrs);
30205    
30206    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
30207                               iTbs, imcs2, txTb, noLyr2);
30208    
30209    *effBo = reTxTb->tbSz + tb2Sz;
30210
30211    RETVALUE(ROK);
30212 }
30213
30214 \f
30215 /**
30216  * @brief This function determines the RBs and Bytes required for BO
30217  *        Retransmission on 2 CWs.
30218  *
30219  * @details
30220  *
30221  *     Function: rgSCHCmnDlAlloc2CwRetxRb
30222  *     Purpose:  This function determines the RBs and Bytes required
30223  *               for BO Retransmission on 2 CWs. Allocate larger TB
30224  *               on a better CW and check if the smaller TB can be
30225  *               accomodated on the other CW.
30226  *               Returns RFAILED if BO not satisfied at all.
30227  *
30228  *     Invoked by: Common Scheduler
30229  *
30230  *  @param[in]  RgSchCellCb      *cell
30231  *  @param[in]  RgSchDlSf        *subFrm
30232  *  @param[in]  RgSchUeCb        *ue
30233  *  @param[in]  RgSchDlHqProcCb  *proc
30234  *  @param[out] U8               *numRb
30235  *  @param[out] Bool             *swpFlg
30236  *  @param[out] U32              *effBo
30237  *  @return  Void
30238  *
30239  **/
30240 #ifdef ANSI
30241 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb
30242 (
30243 RgSchCellCb                *cell,
30244 RgSchDlSf                  *subFrm,
30245 RgSchUeCb                  *ue,
30246 RgSchDlHqProcCb            *proc,
30247 U8                         *numRb,
30248 Bool                       *swpFlg,
30249 U32                        *effBo
30250 )
30251 #else
30252 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
30253         numRb, swpFlg, effBo)
30254 RgSchCellCb                *cell;
30255 RgSchDlSf                  *subFrm;
30256 RgSchUeCb                  *ue;
30257 RgSchDlHqProcCb            *proc;
30258 U8                         *numRb;
30259 Bool                       *swpFlg;
30260 U32                        *effBo;
30261 #endif
30262 {
30263    RgSchDlRbAlloc     *allocInfo;
30264    U8                 imcs1;
30265    U8                 imcs2;
30266    RgSchDlHqTbCb      *lrgTbInfo, *othrTbInfo;
30267
30268    TRC2(rgSCHCmnDlAlloc2CwRetxRb);
30269
30270    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30271
30272
30273    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30274     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30275     * MCS.  */
30276    lrgTbInfo  = &proc->tbInfo[0];
30277    othrTbInfo = &proc->tbInfo[1];
30278    *numRb = lrgTbInfo->dlGrnt.numRb;
30279 #ifdef XEON_TDD_SPCL
30280    if((lrgTbInfo->sfType == RG_SCH_SPL_SF_DATA || othrTbInfo->sfType == RG_SCH_SPL_SF_DATA))
30281    {
30282       if(lrgTbInfo->sfType == RG_SCH_SPL_SF_DATA)
30283       {       
30284           *numRb = (lrgTbInfo->initTxNumRbs);
30285       }
30286       else
30287       {
30288           *numRb = (othrTbInfo->initTxNumRbs);
30289       }
30290
30291       if(subFrm->sfType != RG_SCH_SPL_SF_DATA)
30292       {
30293          *numRb = (*numRb)*3/4;
30294       }
30295        
30296       if(*numRb <= 3)
30297       {
30298          RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
30299          RETVALUE(RFAILED);
30300       }
30301    }
30302 #endif
30303    if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
30304    {
30305       RETVALUE(RFAILED);
30306    }
30307    /* Update the subframe Allocated BW field */
30308    subFrm->bwAssigned += *numRb;
30309    RG_SCH_CMN_GET_MCS_FOR_RETX(lrgTbInfo, imcs1);
30310    RG_SCH_CMN_GET_MCS_FOR_RETX(othrTbInfo, imcs2);
30311    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], lrgTbInfo->tbSz, \
30312          0, imcs1, lrgTbInfo, lrgTbInfo->numLyrs);
30313    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], othrTbInfo->tbSz, \
30314          0, imcs2, othrTbInfo, othrTbInfo->numLyrs);
30315    *effBo = lrgTbInfo->tbSz + othrTbInfo->tbSz;
30316
30317
30318
30319    RETVALUE(ROK);
30320 }
30321
30322 \f
30323 /**
30324  * @brief This function determines the RBs and Bytes required for BO
30325  *        Retransmission on 1 CW.
30326  *
30327  * @details
30328  *
30329  *     Function: rgSCHCmnDlAlloc1CwRetxRb
30330  *     Purpose:  This function determines the RBs and Bytes required
30331  *               for BO Retransmission on 1 CW, the first CW.
30332  *               Returns RFAILED if BO not satisfied at all.
30333  *
30334  *     Invoked by: Common Scheduler
30335  *
30336  *  @param[in]  RgSchCellCb      *cell
30337  *  @param[in]  RgSchDlSf        *subFrm
30338  *  @param[in]  RgSchUeCb        *ue
30339  *  @param[in]  RgSchDlHqTbCb    *tbInfo
30340  *  @param[in]  U8               noLyr
30341  *  @param[out] U8               *numRb
30342  *  @param[out] U32              *effBo
30343  *  @return  S16
30344  *
30345  **/
30346 #ifdef ANSI
30347 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb
30348 (
30349 RgSchCellCb                *cell,
30350 RgSchDlSf                  *subFrm,
30351 RgSchUeCb                  *ue,
30352 RgSchDlHqTbCb              *tbInfo,
30353 U8                         noLyr,
30354 U8                         *numRb,
30355 U32                        *effBo
30356 )
30357 #else
30358 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
30359         numRb, effBo)
30360 RgSchCellCb                *cell;
30361 RgSchDlSf                  *subFrm;
30362 RgSchUeCb                  *ue;
30363 RgSchDlHqTbCb              *tbInfo;
30364 U8                         noLyr;
30365 U8                         *numRb;
30366 U32                        *effBo;
30367 #endif
30368 {
30369    RgSchDlRbAlloc  *allocInfo;
30370    U8              imcs;
30371
30372    TRC2(rgSCHCmnDlAlloc1CwRetxRb);
30373
30374    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30375
30376
30377    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30378     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30379     * MCS.  */
30380    *numRb = tbInfo->dlGrnt.numRb;
30381    if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
30382    {
30383       RETVALUE(RFAILED);
30384    }
30385    /* Update the subframe Allocated BW field */
30386    subFrm->bwAssigned += *numRb;
30387    imcs = tbInfo->dlGrnt.iMcs;
30388    allocInfo->dciFormat = tbInfo->dlGrnt.dciFormat; 
30389    /* Fix: For a RETX TB the iTbs is irrelevant, hence setting 0 */
30390    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbInfo->tbSz, \
30391          0, imcs, tbInfo, tbInfo->numLyrs);
30392    *effBo = tbInfo->tbSz;
30393
30394    RETVALUE(ROK);
30395 }
30396
30397 #ifdef LTEMAC_SPS
30398
30399 /**
30400  * @brief This function is called to handle Release PDCCH feedback for SPS UE
30401  *
30402  * @details
30403  *
30404  *     Function: rgSCHCmnDlRelPdcchFbk
30405  *     Purpose:  Invokes SPS module to handle release PDCCH feedback
30406  *
30407  *     Invoked by: DHM
30408  *
30409  *  @param[in]   RgSchCellCb     *cell
30410  *  @param[in]   RgSchUeCb       *ue
30411  *  @param[in]   Bool            isAck
30412  *  @return  Void
30413  *
30414  **/
30415 #ifdef ANSI
30416 PUBLIC Void rgSCHCmnDlRelPdcchFbk
30417 (
30418 RgSchCellCb        *cell,
30419 RgSchUeCb          *ue,
30420 Bool               isAck
30421 )
30422 #else
30423 PUBLIC Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
30424 RgSchCellCb        *cell;
30425 RgSchUeCb          *ue;
30426 Bool               isAck;
30427 #endif
30428 {
30429
30430    TRC2(rgSCHCmnDlRelPdcchFbk);
30431    rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
30432    RETVOID;
30433
30434 }
30435
30436
30437 /**
30438  * @brief This function is invoked to handle Ack processing for a HARQ proc.
30439  *
30440  * @details
30441  *
30442  *     Function: rgSCHCmnDlProcAck
30443  *     Purpose:  DTX processing for HARQ proc
30444  *
30445  *     Invoked by: DHM
30446  *
30447  *  @param[in]   RgSchCellCb     *cell
30448  *  @param[in]   RgSchDlHqProcCb *hqP
30449  *  @return  Void
30450  *
30451  **/
30452 #ifdef ANSI
30453 PUBLIC Void rgSCHCmnDlProcAck
30454 (
30455 RgSchCellCb        *cell,
30456 RgSchDlHqProcCb    *hqP
30457 )
30458 #else
30459 PUBLIC Void rgSCHCmnDlProcAck(cell, hqP)
30460 RgSchCellCb        *cell;
30461 RgSchDlHqProcCb    *hqP;
30462 #endif
30463 {
30464
30465    TRC2(rgSCHCmnDlProcAck);
30466
30467    if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
30468    {
30469       /* Invoke SPS module if SPS service was scheduled for this HARQ proc */
30470       rgSCHCmnSpsDlProcAck(cell, hqP);
30471    }
30472    RETVOID;
30473 }
30474 #ifdef RGSCH_SPS_STATS
30475 extern U32 rgSchStatCrntiCeRcvCnt;
30476 #endif
30477 /**
30478  * @brief This function is invoked to handle CRNTI CE reception for an UE
30479  *
30480  * @details
30481  *
30482  *     Function: rgSCHCmnHdlCrntiCE
30483  *     Purpose:  Handle CRNTI CE reception
30484  *
30485  *     Invoked by: DHM
30486  *
30487  *  @param[in]   RgSchCellCb     *cell
30488  *  @param[in]   RgSchDlHqProcCb *hqP
30489  *  @return  Void
30490  *
30491  **/
30492 #ifdef ANSI
30493 PUBLIC Void rgSCHCmnHdlCrntiCE
30494 (
30495 RgSchCellCb        *cell,
30496 RgSchUeCb          *ue
30497 )
30498 #else
30499 PUBLIC Void rgSCHCmnHdlCrntiCE(cell, ue)
30500 RgSchCellCb        *cell;
30501 RgSchUeCb          *ue;
30502 #endif
30503 {
30504
30505    TRC2(rgSCHCmnHdlCrntiCE);
30506 #ifdef RGSCH_SPS_STATS   
30507    rgSchStatCrntiCeRcvCnt++;
30508 #endif
30509
30510    /* When UL sync lost happened due to TA timer expiry UE is being moved to 
30511       PDCCH order inactivity list.But when CRNTI CE received in msg3 from UE
30512       we are not moving UE into active state due to that RRC Reconfiguration is
30513       not happening.
30514       So here we are moving UE to active list whenever we receive the CRNTI CE and
30515       UE is inactive */
30516    /* CR ccpu00144525 */      
30517    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
30518    {
30519        /* Activate this UE if it was inactive */
30520        RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
30521        RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
30522    }
30523
30524    /* Handling is same as reception of UE RESET for both DL and UL */
30525    if (ue->dl.dlSpsCfg.isDlSpsEnabled)
30526    {
30527       rgSCHCmnSpsDlUeReset(cell, ue);
30528    }
30529    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30530    {
30531       rgSCHCmnSpsUlUeReset(cell, ue);
30532    }
30533    
30534    RETVOID;
30535 }
30536
30537
30538 /**
30539  * @brief This function is called to handle relInd from MAC for a UE
30540  *
30541  * @details
30542  *
30543  *     Function: rgSCHCmnUlSpsRelInd
30544  *     Purpose:  Invokes SPS module to handle UL SPS release for a UE
30545  *
30546  *     Invoked by: SCH_UTL
30547  *
30548  *  @param[in]   RgSchCellCb        *cell
30549  *  @param[in]   RgSchUeCb          *ue
30550  *  @param[in]   Bool               isExplRel
30551  *  @return  Void
30552  *
30553  **/
30554 #ifdef ANSI
30555 PUBLIC Void rgSCHCmnUlSpsRelInd
30556 (
30557 RgSchCellCb        *cell,
30558 RgSchUeCb          *ue,
30559 Bool               isExplRel
30560 )
30561 #else
30562 PUBLIC Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
30563 RgSchCellCb        *cell;
30564 RgSchUeCb          *ue;
30565 Bool               isExplRel;
30566 #endif
30567 {
30568
30569    TRC2(rgSCHCmnUlSpsRelInd);
30570    rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
30571    RETVOID;
30572
30573 } /* end of rgSCHCmnUlSpsRelInd */
30574
30575 /**
30576  * @brief This function is called to handle SPS Activate Ind from MAC for a UE
30577  *
30578  * @details
30579  *
30580  *     Function: rgSCHCmnUlSpsActInd
30581  *     Purpose:  Invokes SPS module to handle UL SPS activate for a UE
30582  *
30583  *     Invoked by: SCH_UTL
30584  *
30585  *  @param[in]   RgSchCellCb        *cell
30586  *  @param[in]   RgSchUeCb          *ue
30587  *  @return  Void
30588  *
30589  **/
30590 #ifdef ANSI
30591 PUBLIC Void rgSCHCmnUlSpsActInd
30592 (
30593 RgSchCellCb        *cell,
30594 RgSchUeCb          *ue,
30595 U16                spsSduSize
30596 )
30597 #else
30598 PUBLIC Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
30599 RgSchCellCb        *cell;
30600 RgSchUeCb          *ue;
30601 U16                spsSduSize;
30602 #endif
30603 {
30604
30605    TRC2(rgSCHCmnUlSpsActInd);
30606
30607    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30608    {
30609       rgSCHCmnSpsUlProcActInd(cell, ue,spsSduSize);
30610    }
30611    RETVOID;
30612
30613 } /* end of rgSCHCmnUlSpsActInd */
30614
30615 /**
30616  * @brief This function is called to handle CRC in UL for UEs
30617  * undergoing SPS release
30618  *
30619  * @details
30620  *
30621  *     Function: rgSCHCmnUlCrcInd
30622  *     Purpose:  Invokes SPS module to handle CRC in UL for SPS UE
30623  *
30624  *     Invoked by: SCH_UTL
30625  *
30626  *  @param[in]   RgSchCellCb        *cell
30627  *  @param[in]   RgSchUeCb          *ue
30628  *  @param[in]   CmLteTimingInfo    crcTime
30629  *  @return  Void
30630  *
30631  **/
30632 #ifdef ANSI
30633 PUBLIC Void rgSCHCmnUlCrcInd
30634 (
30635 RgSchCellCb        *cell,
30636 RgSchUeCb          *ue,
30637 CmLteTimingInfo    crcTime
30638 )
30639 #else
30640 PUBLIC Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
30641 RgSchCellCb        *cell;
30642 RgSchUeCb          *ue;
30643 CmLteTimingInfo    crcTime;
30644 #endif
30645 {
30646
30647    TRC2(rgSCHCmnUlCrcInd);
30648    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30649    {
30650       rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
30651    }
30652    RETVOID;
30653
30654 } /* end of rgSCHCmnUlCrcFailInd */
30655
30656 /**
30657  * @brief This function is called to handle CRC failure in UL
30658  *
30659  * @details
30660  *
30661  *     Function: rgSCHCmnUlCrcFailInd
30662  *     Purpose:  Invokes SPS module to handle CRC failure in UL for SPS UE
30663  *
30664  *     Invoked by: SCH_UTL
30665  *
30666  *  @param[in]   RgSchCellCb        *cell
30667  *  @param[in]   RgSchUeCb          *ue
30668  *  @param[in]   CmLteTimingInfo    crcTime
30669  *  @return  Void
30670  *
30671  **/
30672 #ifdef ANSI
30673 PUBLIC Void rgSCHCmnUlCrcFailInd
30674 (
30675 RgSchCellCb        *cell,
30676 RgSchUeCb          *ue,
30677 CmLteTimingInfo    crcTime
30678 )
30679 #else
30680 PUBLIC Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
30681 RgSchCellCb        *cell;
30682 RgSchUeCb          *ue;
30683 CmLteTimingInfo    crcTime;
30684 #endif
30685 {
30686
30687    TRC2(rgSCHCmnUlCrcFailInd);
30688    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30689    {
30690       rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
30691    }
30692    RETVOID;
30693
30694 } /* end of rgSCHCmnUlCrcFailInd */
30695
30696 #endif /* LTEMAC_SPS */
30697
30698 /**
30699  * @brief BCH,BCCH,PCCH Dowlink Scheduling Handler.
30700  *
30701  * @details
30702  *
30703  *     Function: rgSCHCmnDlBcchPcchAlloc
30704  *     Purpose:  This function calls common scheduler APIs to
30705  *     schedule for BCCH/PCCH.
30706  *     It then invokes Allocator for actual RB
30707  *     allocations. It processes on the actual resources allocated
30708  *     against requested to the allocator module.
30709  *
30710  *     Invoked by: Common Scheduler
30711  *
30712  *  @param[in]  RgSchCellCb *cell
30713  *  @return  Void
30714  **/
30715 #ifdef ANSI
30716 PRIVATE Void rgSCHCmnDlBcchPcchAlloc
30717 (
30718 RgSchCellCb  *cell
30719 )
30720 #else
30721 PRIVATE Void rgSCHCmnDlBcchPcchAlloc(cell)
30722 RgSchCellCb  *cell;
30723 #endif
30724 {
30725 #ifdef LTE_TDD
30726    U8           nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
30727 #else
30728 #ifdef LTEMAC_HDFDD
30729    U8           nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
30730 #else
30731    U8           nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
30732 #endif
30733 #endif
30734    RgInfSfAlloc *nextsfAlloc = &(cell->sfAllocArr[nextSfIdx]);
30735    RgSchCmnCell           *cellSch   = RG_SCH_CMN_GET_CELL(cell);
30736    RgSchCmnDlRbAllocInfo  *allocInfo = &cellSch->allocInfo;  
30737    
30738    TRC2(rgSCHCmnDlBcchPcchAlloc);
30739
30740
30741    /*Reset the bitmask for BCCH/PCCH*/
30742    rgSCHUtlResetSfAlloc(nextsfAlloc,TRUE,FALSE);
30743 #ifndef DISABLE_MIB_SIB /* Not sending MIB and SIB to CL */
30744 #ifdef RGR_SI_SCH
30745    rgSCHChkNUpdSiCfg(cell);
30746    rgSCHSelectSi(cell);
30747 #endif
30748
30749    /*Perform the scheduling for BCCH,PCCH*/
30750    rgSCHCmnDlBcchPcch(cell, allocInfo, nextsfAlloc);
30751
30752    /* Call common allocator for RB Allocation */
30753    rgSCHBcchPcchDlRbAlloc(cell, allocInfo);
30754
30755    /* Finalize the Allocations for reqested Against alloced */
30756    rgSCHCmnDlBcchPcchFnlz(cell, allocInfo);
30757 #endif /* DISABLE_MIB_SIB */
30758    RETVOID;
30759 }
30760
30761 /**
30762  * @brief Handles RB allocation for BCCH/PCCH for downlink.
30763  *
30764  * @details
30765  *
30766  *     Function : rgSCHBcchPcchDlRbAlloc
30767  *
30768  *     Invoking Module Processing:
30769  *     - This function is invoked for DL RB allocation of BCCH/PCCH
30770  *
30771  *     Processing Steps:
30772  *     - If cell is frequency selecive,
30773  *       - Call rgSCHDlfsBcchPcchAllocRb().
30774  *     - else,
30775  *       - Do the processing
30776  *
30777  *  @param[in]  RgSchCellCb        *cell
30778  *  @param[in]  RgSchDlRbAllocInfo *allocInfo
30779  *  @return  Void
30780  **/
30781
30782 #ifdef ANSI
30783 PRIVATE Void rgSCHBcchPcchDlRbAlloc
30784 (
30785 RgSchCellCb           *cell,
30786 RgSchCmnDlRbAllocInfo *allocInfo
30787 )
30788 #else
30789 PRIVATE Void rgSCHBcchPcchDlRbAlloc(cell, allocInfo)
30790 RgSchCellCb           *cell;
30791 RgSchCmnDlRbAllocInfo *allocInfo;
30792 #endif
30793 {
30794    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
30795
30796    TRC2(rgSCHBcchPcchDlRbAlloc);
30797
30798
30799    if (cellSch->dl.isDlFreqSel)
30800    {
30801       cellSch->apisDlfs->rgSCHDlfsBcchPcchAllocRb(cell, allocInfo);
30802    }
30803    else
30804    {
30805       rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo);
30806    }
30807
30808    RETVOID;
30809 }
30810
30811 /**
30812  * @brief Handles RB allocation for BCCH,PCCH for frequency
30813  *  non-selective cell.
30814  *
30815  * @details
30816  *
30817  *     Function : rgSCHCmnNonDlfsBcchPcchRbAlloc
30818  *
30819  *     Invoking Module Processing:
30820  *      - SCH shall invoke this if downlink frequency selective is disabled for
30821  *        the cell for RB allocation.
30822  *      - MAX C/I/PFS/RR shall provide the requiredBytes, required RBs
30823  *        estimate and subframe for each allocation to be made to SCH.
30824  *
30825  *     Processing Steps:
30826  *     - Allocate sequentially for BCCH,PCCH common channels.
30827  *
30828  *  @param[in]  RgSchCellCb        *cell
30829  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
30830  *  @return  Void
30831  **/
30832
30833 #ifdef ANSI
30834 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc
30835 (
30836 RgSchCellCb           *cell,
30837 RgSchCmnDlRbAllocInfo *allocInfo
30838 )
30839 #else
30840 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo)
30841 RgSchCellCb           *cell;
30842 RgSchCmnDlRbAllocInfo *allocInfo;
30843 #endif
30844 {
30845    RgSchDlRbAlloc     *reqAllocInfo;
30846
30847    TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
30848
30849    /* 143473 */
30850    /* Allocate for PCCH */
30851    reqAllocInfo = &(allocInfo->pcchAlloc);
30852    if (reqAllocInfo->rbsReq)
30853    {
30854       rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
30855    }
30856    /* Allocate for BCCH on DLSCH */
30857    reqAllocInfo = &(allocInfo->bcchAlloc);
30858    if (reqAllocInfo->rbsReq)
30859    {
30860       rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
30861    }
30862    RETVOID;
30863 }
30864
30865
30866 #ifdef RGR_SI_SCH
30867 /**
30868  * @brief This function implements the handling to check and
30869  *        update the SI cfg at the start of the modificiation period.
30870  *
30871  * @details
30872  *
30873  *     Function: rgSCHChkNUpdSiCfg
30874  *     Purpose:  This function implements handling for update of SI Cfg
30875  *               at the start of modification period.
30876  *
30877  *     Invoked by: Scheduler
30878  *
30879  *  @param[in]  RgSchCellCb*     cell
30880  *  @return  S16
30881  *      -# ROK
30882  *      -# RFAILED
30883  **/
30884 #ifdef ANSI
30885 PRIVATE Void rgSCHChkNUpdSiCfg
30886 (
30887 RgSchCellCb             *cell
30888 )
30889 #else
30890 PRIVATE Void rgSCHChkNUpdSiCfg(cell)
30891 RgSchCellCb             *cell;
30892 #endif
30893 {
30894    CmLteTimingInfo   pdSchTmInfo;
30895
30896    TRC2(rgSCHChkNUpdSiCfg);
30897
30898
30899    pdSchTmInfo   = cell->crntTime;
30900 #ifdef LTEMAC_HDFDD
30901    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
30902       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
30903    RGSCH_INCR_SUB_FRAME(pdSchTmInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
30904 #else
30905    RGSCH_INCR_SUB_FRAME(pdSchTmInfo, RG_SCH_CMN_DL_DELTA);
30906 #endif
30907
30908
30909    /* Updating the SIB1 for Warning SI message immediately after it is received 
30910     * from application. No need to wait for next modification period.
30911     */
30912    if((pdSchTmInfo.sfn % RGSCH_SIB1_RPT_PERIODICITY == 0)
30913          && (RGSCH_SIB1_TX_SF_NUM == (pdSchTmInfo.slot % RGSCH_NUM_SUB_FRAMES)))
30914    {   
30915       /*Check whether SIB1 with PWS has been updated*/
30916       if(cell->siCb.siBitMask & RGSCH_SI_SIB1_PWS_UPD)
30917       {
30918          RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.sib1Info.sib1,
30919                cell->siCb.newSiInfo.sib1Info.sib1);
30920          cell->siCb.crntSiInfo.sib1Info.mcs = 
30921             cell->siCb.newSiInfo.sib1Info.mcs;
30922          cell->siCb.crntSiInfo.sib1Info.nPrb = 
30923              cell->siCb.newSiInfo.sib1Info.nPrb;
30924          cell->siCb.crntSiInfo.sib1Info.msgLen = 
30925             cell->siCb.newSiInfo.sib1Info.msgLen;
30926          cell->siCb.siBitMask &= ~RGSCH_SI_SIB1_PWS_UPD;
30927       }
30928    }
30929
30930    /*Check if this SFN and SF No marks the start of next modification
30931      period. If current SFN,SF No doesn't marks the start of next
30932      modification period, then return. */
30933    if(!((pdSchTmInfo.sfn % cell->siCfg.modPrd == 0)
30934             && (0 == pdSchTmInfo.slot)))
30935    /*if(!((((pdSchTmInfo.hSfn * 1024) + pdSchTmInfo.sfn) % cell->siCfg.modPrd == 0)
30936             && (0 == pdSchTmInfo.slot)))*/
30937    {
30938       RETVOID;
30939    }
30940
30941    /*Check whether MIB has been updated*/
30942    if(cell->siCb.siBitMask & RGSCH_SI_MIB_UPD)
30943    {
30944       RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.mib,
30945             cell->siCb.newSiInfo.mib);
30946       cell->siCb.siBitMask &= ~RGSCH_SI_MIB_UPD;
30947    }
30948
30949    /*Check whether SIB1 has been updated*/
30950    if(cell->siCb.siBitMask & RGSCH_SI_SIB1_UPD)
30951    {
30952       RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.sib1Info.sib1,
30953             cell->siCb.newSiInfo.sib1Info.sib1);
30954       cell->siCb.crntSiInfo.sib1Info.mcs = cell->siCb.newSiInfo.sib1Info.mcs;
30955       cell->siCb.crntSiInfo.sib1Info.nPrb = cell->siCb.newSiInfo.sib1Info.nPrb;
30956       cell->siCb.crntSiInfo.sib1Info.msgLen = 
30957          cell->siCb.newSiInfo.sib1Info.msgLen;
30958       cell->siCb.siBitMask &= ~RGSCH_SI_SIB1_UPD;
30959    }
30960
30961    /*Check whether SIs have been updated*/
30962    if(cell->siCb.siBitMask & RGSCH_SI_SI_UPD)
30963    {
30964       U8  idx;
30965
30966       /*Check if SI cfg have been modified And Check if numSi have
30967         been changed, if yes then we would need to update the
30968         pointers for all the SIs */
30969       if((cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) &&
30970             (cell->siCfg.numSi != cell->siCb.newSiCfg.numSi))
30971       {
30972          for(idx = 0;idx < cell->siCb.newSiCfg.numSi;idx++)
30973          {
30974             RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[idx].si,
30975                   cell->siCb.newSiInfo.siInfo[idx].si);
30976             cell->siCb.siArray[idx].si = cell->siCb.crntSiInfo.siInfo[idx].si;
30977             cell->siCb.siArray[idx].isWarningSi = FALSE;
30978
30979             cell->siCb.crntSiInfo.siInfo[idx].mcs = cell->siCb.newSiInfo.siInfo[idx].mcs;
30980             cell->siCb.crntSiInfo.siInfo[idx].nPrb = cell->siCb.newSiInfo.siInfo[idx].nPrb;
30981             cell->siCb.crntSiInfo.siInfo[idx].msgLen = cell->siCb.newSiInfo.siInfo[idx].msgLen;
30982          }
30983
30984          /*If numSi have been reduced then we need to free the
30985            pointers at the indexes in crntSiInfo which haven't
30986            been exercised. If numSi has increased then nothing
30987            additional is requires as above handling has taken
30988            care.*/
30989          if(cell->siCfg.numSi > cell->siCb.newSiCfg.numSi)
30990          {
30991             for(idx = cell->siCb.newSiCfg.numSi;
30992                   idx < cell->siCfg.numSi;idx++)
30993             {
30994                RGSCH_FREE_MSG(cell->siCb.crntSiInfo.siInfo[idx].si);
30995                cell->siCb.siArray[idx].si = NULLP;
30996             }
30997          }
30998       }
30999       else
31000       {
31001          /*numSi has not been updated, we just need to update the
31002            pointers for the SIs which are set to NON NULLP */
31003          /*ccpu00118260 - Correct Update of SIB2 */
31004          for(idx = 0;idx < cell->siCfg.numSi;idx++)
31005          {
31006             if(NULLP != cell->siCb.newSiInfo.siInfo[idx].si)
31007             {
31008                RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[idx].si,
31009                      cell->siCb.newSiInfo.siInfo[idx].si);
31010
31011                cell->siCb.siArray[idx].si = cell->siCb.crntSiInfo.siInfo[idx].si;
31012                cell->siCb.siArray[idx].isWarningSi = FALSE;
31013                cell->siCb.crntSiInfo.siInfo[idx].mcs = cell->siCb.newSiInfo.siInfo[idx].mcs;
31014                cell->siCb.crntSiInfo.siInfo[idx].nPrb = cell->siCb.newSiInfo.siInfo[idx].nPrb;
31015                cell->siCb.crntSiInfo.siInfo[idx].msgLen = cell->siCb.newSiInfo.siInfo[idx].msgLen;
31016             }
31017          }
31018       }
31019       cell->siCb.siBitMask &= ~RGSCH_SI_SI_UPD;
31020    }
31021
31022    /*Check whether SI cfg have been updated*/
31023    if(cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
31024    {
31025       cell->siCfg = cell->siCb.newSiCfg;
31026       cell->siCb.siBitMask &= ~RGSCH_SI_SICFG_UPD;
31027    }
31028
31029    RETVOID;
31030 }
31031
31032
31033 /**
31034  * @brief This function implements the selection of the SI
31035  *        that is to be scheduled.
31036  *
31037  * @details
31038  *
31039  *     Function: rgSCHSelectSi
31040  *     Purpose:  This function implements the selection of SI
31041  *               that is to be scheduled.
31042  *
31043  *     Invoked by: Scheduler
31044  *
31045  *  @param[in]  RgSchCellCb*     cell
31046  *  @return  S16
31047  *      -# ROK
31048  *      -# RFAILED
31049  **/
31050 #ifdef ANSI
31051 PRIVATE Void rgSCHSelectSi
31052 (
31053 RgSchCellCb             *cell
31054 )
31055 #else
31056 PRIVATE Void rgSCHSelectSi(cell)
31057 RgSchCellCb             *cell;
31058 #endif
31059 {
31060    CmLteTimingInfo        crntTmInfo;
31061    U8                     siWinSize;
31062    U16                    x; 
31063    U16                    windowId; 
31064
31065    TRC2(rgSCHSelectSi);
31066
31067
31068    crntTmInfo  = cell->crntTime;
31069 #ifdef LTEMAC_HDFDD
31070    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
31071       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
31072    RGSCH_INCR_SUB_FRAME(crntTmInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
31073 #else
31074    RGSCH_INCR_SUB_FRAME(crntTmInfo, RG_SCH_CMN_DL_DELTA);
31075 #endif
31076
31077    siWinSize    = cell->siCfg.siWinSize;
31078
31079    /* Select SI only once at the starting of the new window */
31080    if(cell->siCb.inWindow)
31081    {
31082       if ((crntTmInfo.sfn % cell->siCfg.minPeriodicity) == 0 && 
31083           crntTmInfo.slot == 0)
31084       {
31085          /* Reinit inWindow at the beginning of every SI window */
31086          cell->siCb.inWindow = siWinSize - 1;
31087       }
31088       else
31089       {
31090          cell->siCb.inWindow--;
31091          RETVOID;
31092       }
31093    }
31094    else /* New window. Re-init the winSize counter with the window length */
31095    {
31096       if((cell->siCb.siArray[cell->siCb.siCtx.siId - 1].isWarningSi == TRUE)&&
31097             (cell->siCb.siCtx.retxCntRem != 0))   
31098       {
31099          rgSCHUtlFreeWarningSiPdu(cell);
31100          cell->siCb.siCtx.warningSiFlag  = FALSE;
31101       }
31102
31103       cell->siCb.inWindow = siWinSize - 1;
31104    }
31105
31106    x = rgSCHCmnGetSiSetId(crntTmInfo.sfn, crntTmInfo.slot, 
31107                                   cell->siCfg.minPeriodicity); 
31108
31109    /* Window Id within a SI set. This window Id directly maps to a
31110     * unique SI Id */
31111    windowId = (((crntTmInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + 
31112             crntTmInfo.slot) - (x * (cell->siCfg.minPeriodicity * 10))) 
31113                                                                / siWinSize;
31114
31115    if(windowId >= RGR_MAX_NUM_SI)
31116       RETVOID;
31117
31118    /* Update the siCtx if there is a valid SI and its periodicity
31119     * has occurred */
31120    if (NULLP != cell->siCb.siArray[windowId].si)
31121    {
31122       /* Warning SI Periodicity is same as SIB2 Periodicity */
31123       if(((cell->siCb.siArray[windowId].isWarningSi == FALSE) && 
31124                (x % (cell->siCfg.siPeriodicity[windowId]
31125                      /cell->siCfg.minPeriodicity) == 0)) || 
31126             ((cell->siCb.siArray[windowId].isWarningSi == TRUE) &&
31127              (x % (cell->siCfg.siPeriodicity[0]
31128                    /cell->siCfg.minPeriodicity) == 0)))
31129       {
31130          cell->siCb.siCtx.siId = windowId+1;
31131          cell->siCb.siCtx.retxCntRem = cell->siCfg.retxCnt;
31132          cell->siCb.siCtx.warningSiFlag = cell->siCb.siArray[windowId].
31133                                                            isWarningSi;
31134          cell->siCb.siCtx.timeToTx.sfn = crntTmInfo.sfn;
31135          cell->siCb.siCtx.timeToTx.slot = crntTmInfo.slot;
31136
31137          RG_SCH_ADD_TO_CRNT_TIME(cell->siCb.siCtx.timeToTx,
31138                cell->siCb.siCtx.maxTimeToTx, (siWinSize - 1))
31139       }
31140    }
31141    else
31142    {/* Update the siCtx with invalid si Id */
31143       cell->siCb.siCtx.siId = 0;
31144    }
31145
31146    RETVOID;
31147 }
31148
31149
31150 /**
31151  * @brief This function implements scheduler DL allocation for
31152  *        SI.
31153  *
31154  * @details
31155  *
31156  *     Function: rgSCHDlSiSched
31157  *     Purpose:  This function implements scheduler for DL allocation
31158  *               for SI.
31159  *
31160  *     Invoked by: Scheduler
31161  *
31162  *  @param[in]  RgSchCellCb*     cell
31163  *  @return  S16
31164  *      -# ROK
31165  *      -# RFAILED
31166  **/
31167 #ifdef ANSI
31168 PRIVATE Void rgSCHDlSiSched
31169 (
31170 RgSchCellCb             *cell,
31171 RgSchCmnDlRbAllocInfo   *allocInfo,
31172 RgInfSfAlloc            *subfrmAlloc
31173 )
31174 #else
31175 PRIVATE Void rgSCHDlSiSched(cell, allocInfo, subfrmAlloc)
31176 RgSchCellCb             *cell;
31177 RgSchCmnDlRbAllocInfo   *allocInfo;
31178 RgInfSfAlloc            *subfrmAlloc;
31179 #endif
31180 {
31181    CmLteTimingInfo   crntTimInfo;
31182    RgSchDlSf         *sf;
31183    U8                nPrb = 0;
31184    U8                mcs  = 0;
31185    MsgLen            msgLen = 0;
31186    U32               rb=0;
31187    RgSchCmnDlCell    *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
31188    /* DwPTS Scheduling Changes Start */
31189 #ifdef LTE_TDD   
31190    U16                lostRe;  
31191    U8                 cfi = cellDl->currCfi;      
31192 #endif
31193    /* DwPTS Scheduling Changes End */
31194
31195    TRC2(rgSCHDlSiSched);
31196
31197
31198    crntTimInfo   = cell->crntTime;
31199 #ifdef LTEMAC_HDFDD
31200    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
31201       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
31202    RGSCH_INCR_SUB_FRAME(crntTimInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
31203 #else
31204    RGSCH_INCR_SUB_FRAME(crntTimInfo, RG_SCH_CMN_DL_DELTA);
31205 #endif
31206
31207    /* Compute the subframe for which allocation is being made.
31208       Essentially, we need pointer to the dl frame for this subframe */
31209    sf = rgSCHUtlSubFrmGet(cell, crntTimInfo);
31210
31211    /*Check if scheduling of MIB is required */
31212 #ifdef EMTC_ENABLE
31213    /* since we are adding the MIB repetition logic for EMTC UEs, checking if
31214     * emtcEnabled or not,  If enabled MIB would be repeted at as part of EMTC
31215     * feature, otherwise scheduling at (n,0) */
31216    if(0 == cell->emtcEnable)
31217    {
31218 #endif
31219    if((crntTimInfo.sfn % RGSCH_MIB_PERIODICITY == 0)
31220          && (RGSCH_MIB_TX_SF_NUM == crntTimInfo.slot))
31221    {
31222       MsgLen  mibLen = 0;
31223       U8      sfnOctet, mibOct2 = 0;
31224       U8      mibOct1 = 0;
31225       /*If MIB has not been yet setup by Application, return*/
31226       if(NULLP == cell->siCb.crntSiInfo.mib)
31227          RETVOID;
31228
31229       SFndLenMsg(cell->siCb.crntSiInfo.mib, &mibLen);
31230       sf->bch.tbSize = mibLen;
31231       /*Fill the interface information */
31232       rgSCHUtlFillRgInfCmnLcInfo(sf, subfrmAlloc, NULLD, NULLD);
31233
31234       /*Set the bits of MIB to reflect SFN */
31235       /*First get the Most signficant 8 bits of SFN */
31236       sfnOctet = (U8)(crntTimInfo.sfn >> 2);
31237       /*Get the first two octets of MIB, and then update them
31238         using the SFN octet value obtained above.*/
31239       if(ROK != SExamMsg((Data *)(&mibOct1),
31240                cell->siCb.crntSiInfo.mib, 0))
31241          RETVOID;
31242
31243       if(ROK != SExamMsg((Data *)(&mibOct2),
31244                cell->siCb.crntSiInfo.mib, 1))
31245          RETVOID;
31246
31247       /* ccpu00114572- Fix for improper way of MIB Octet setting for SFN */
31248       mibOct1 = (mibOct1 & 0xFC) | (sfnOctet >> 6);
31249       mibOct2 = (mibOct2 & 0x03) | (sfnOctet << 2);
31250       /* ccpu00114572- Fix ends*/
31251
31252       /*Now, replace the two octets in MIB */
31253       if(ROK != SRepMsg((Data)(mibOct1),
31254                cell->siCb.crntSiInfo.mib, 0))
31255          RETVOID;
31256
31257       if(ROK != SRepMsg((Data)(mibOct2),
31258                cell->siCb.crntSiInfo.mib, 1))
31259          RETVOID;
31260
31261       /*Copy the MIB msg buff into interface buffer */
31262       SCpyMsgMsg(cell->siCb.crntSiInfo.mib,
31263             rgSchCb[cell->instIdx].rgSchInit.region,
31264             rgSchCb[cell->instIdx].rgSchInit.pool,
31265             &subfrmAlloc->cmnLcInfo.bchInfo.pdu);
31266       /* Added Dl TB count for MIB message transmission
31267        * This counter is incremented 4 times to consider 
31268        * the retransmission at the PHY level on PBCH channel*/
31269 #ifdef LTE_L2_MEAS
31270       cell->dlUlTbCnt.tbTransDlTotalCnt += RG_SCH_MIB_CNT;
31271 #endif      
31272    }
31273 #ifdef EMTC_ENABLE
31274    }
31275 #endif
31276
31277    allocInfo->bcchAlloc.schdFirst = FALSE;
31278    /*Check if scheduling of SIB1 is required.
31279      Check of (crntTimInfo.sfn % RGSCH_SIB1_PERIODICITY == 0)
31280      is not required here since the below check takes care
31281      of SFNs applicable for this one too.*/
31282    if((crntTimInfo.sfn % RGSCH_SIB1_RPT_PERIODICITY == 0)
31283          && (RGSCH_SIB1_TX_SF_NUM == crntTimInfo.slot))
31284    {
31285       /*If SIB1 has not been yet setup by Application, return*/
31286       if(NULLP == (cell->siCb.crntSiInfo.sib1Info.sib1))
31287       {
31288          RETVOID;
31289       }
31290
31291       allocInfo->bcchAlloc.schdFirst = TRUE;
31292       mcs =  cell->siCb.crntSiInfo.sib1Info.mcs;
31293       nPrb =  cell->siCb.crntSiInfo.sib1Info.nPrb;
31294       msgLen =  cell->siCb.crntSiInfo.sib1Info.msgLen;
31295    }
31296    else
31297    {
31298       /*Check if scheduling of SI can be performed.*/
31299       Bool    invalid = FALSE;
31300
31301       if(cell->siCb.siCtx.siId == 0)
31302          RETVOID;
31303
31304       /*Check if the Si-Window for the current Si-Context is completed*/
31305       invalid = rgSCHCmnChkPastWin(crntTimInfo, cell->siCb.siCtx.maxTimeToTx);
31306       if(invalid)
31307       {
31308          /* LTE_ADV_FLAG_REMOVED_START */
31309          if(cell->siCb.siCtx.retxCntRem)
31310          { 
31311             RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,(ErrVal)cell->siCb.siCtx.siId,
31312                                 "rgSCHDlSiSched(): SI not scheduled and window expired");
31313          }
31314          /* LTE_ADV_FLAG_REMOVED_END */
31315          if(cell->siCb.siCtx.warningSiFlag == TRUE)
31316          {
31317             rgSCHUtlFreeWarningSiPdu(cell);
31318             cell->siCb.siCtx.warningSiFlag  = FALSE;
31319          }
31320          RETVOID;
31321       }
31322
31323       /*Check the timinginfo of the current SI-Context to see if its
31324         transmission can be scheduled. */
31325       if(FALSE == (rgSCHCmnChkInWin(crntTimInfo,
31326                   cell->siCb.siCtx.timeToTx,
31327                   cell->siCb.siCtx.maxTimeToTx)))
31328       {
31329          RETVOID;
31330
31331       }
31332       /*Check if retransmission count has become 0*/
31333       if(0 == cell->siCb.siCtx.retxCntRem)
31334       {
31335          RETVOID;
31336       }
31337
31338       /* LTE_ADV_FLAG_REMOVED_START */
31339       /* Check if ABS is enabled/configured  */
31340       if(RGR_ENABLE == cell->lteAdvCb.absCfg.status)
31341       {
31342          /* The pattern type is RGR_ABS_MUTE, then eNB need to blank the subframe */
31343          if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
31344          {
31345             /* Determine next scheduling subframe is ABS or not */
31346             if(RG_SCH_ABS_ENABLED_ABS_SF == (RgSchAbsSfEnum)(cell->lteAdvCb.absCfg.absPattern
31347                   [((crntTimInfo.sfn*RGSCH_NUM_SUB_FRAMES) + crntTimInfo.slot) % RGR_ABS_PATTERN_LEN]))
31348             {
31349                /* Skip the SI scheduling to next tti */
31350                RETVOID;
31351             }
31352          }
31353       }
31354       /* LTE_ADV_FLAG_REMOVED_END */
31355
31356       /*Schedule the transmission of the current SI-Context */
31357       /*Find out the messg length for the SI message */
31358       /* warningSiFlag is to differentiate between Warning SI
31359        * and Other SI */
31360         if((rgSCHUtlGetMcsAndNPrb(cell, &nPrb, &mcs, &msgLen)) != ROK)
31361         {
31362            RETVOID; 
31363         }
31364
31365       cell->siCb.siCtx.i = RGSCH_CALC_SF_DIFF(crntTimInfo,
31366             cell->siCb.siCtx.timeToTx);
31367    } 
31368
31369
31370    /*Get the number of rb required */
31371    /*rgSCHCmnClcRbAllocForFxdTb(cell, msgLen, cellDl->ccchCqi, &rb);*/
31372    if(cellDl->bitsPerRb==0)
31373    {
31374       while ((rgTbSzTbl[0][0][rb]) < (U32) (msgLen*8))
31375       {
31376          rb++;
31377       }
31378       rb = rb+1;
31379    }
31380    else
31381    {
31382       rb = RGSCH_CEIL((msgLen*8), cellDl->bitsPerRb);
31383    }
31384    /* DwPTS Scheduling Changes Start */   
31385 #ifdef LTE_TDD
31386    if (sf->sfType == RG_SCH_SPL_SF_DATA) 
31387    {
31388       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
31389
31390       /* Calculate the less RE's because of DwPTS */
31391        lostRe = rb * (cellDl->noResPerRb[cfi] - cellDl->numReDwPts[cfi]);
31392
31393        /* Increase number of RBs in Spl SF to compensate for lost REs */
31394        rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]); 
31395    }
31396 #endif
31397    /* DwPTS Scheduling Changes End */   
31398    /*ccpu00115595- end*/
31399    /* Additional check to see if required RBs
31400     * exceeds the available */
31401    if (rb > sf->bw - sf->bwAssigned)
31402    {
31403       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "rgSCHDlSiSched(): "
31404          "BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
31405       RETVOID;
31406    }
31407
31408    /* Update the subframe Allocated BW field */
31409    sf->bwAssigned = sf->bwAssigned + rb;
31410
31411    /*Fill the parameters in allocInfo */
31412    allocInfo->bcchAlloc.rnti = RGSCH_SI_RNTI;
31413    allocInfo->bcchAlloc.dlSf = sf;
31414    allocInfo->bcchAlloc.rbsReq = rb;
31415    /*ccpu00116710- MCS is not getting assigned */
31416    allocInfo->bcchAlloc.tbInfo[0].imcs = mcs;
31417
31418    /* ccpu00117510 - ADD - Assignment of nPrb and other information */
31419    allocInfo->bcchAlloc.nPrb = nPrb;
31420    allocInfo->bcchAlloc.tbInfo[0].bytesReq = msgLen;
31421    allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
31422    RETVOID;
31423 }
31424 #endif /*RGR_SI_SCH*/
31425
31426 \f
31427 /* ccpu00117452 - MOD - Changed macro name from
31428    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
31429 #ifdef RGR_CQI_REPT
31430 /**
31431  * @brief This function Updates the DL CQI for the UE.
31432  *
31433  * @details
31434  *
31435  *     Function: rgSCHCmnUeDlPwrCtColltCqiRept
31436  *     Purpose:  Manages PUSH N CQI reporting
31437  *         Step 1: Store the CQI in collation array
31438  *         Step 2: Increament the tracking count
31439  *         Step 3: Check is it time to to send the report
31440  *         Step 4: if yes, Send StaInd to RRM
31441  *         Step 4.1: Fill StaInd for sending collated N CQI rpeorts
31442  *         Step 4.2: Call utility function (rgSCHUtlRgrStaInd) to send rpts to RRM
31443  *         Step 4.2.1: If sending was not sucessful, return RFAILED
31444  *         Step 4.2.2: If sending was sucessful, return ROK
31445  *         Step 5: If no, return
31446  *     Invoked by: rgSCHCmnDlCqiInd
31447  *
31448  *  @param[in]  RgSchCellCb        *cell
31449  *  @param[in]  RgSchUeCb          *ue
31450  *  @param[in]  RgrUeCqiRept        *ueCqiRpt
31451  *  @return  Void
31452  *
31453  **/
31454 #ifdef ANSI
31455 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept
31456 (
31457 RgSchCellCb        *cell,
31458 RgSchUeCb          *ue,
31459 RgrUeCqiRept        *ueCqiRpt
31460 )
31461 #else
31462 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, ueCqiRpt)
31463 RgSchCellCb        *cell;
31464 RgSchUeCb          *ue;
31465 RgrUeCqiRept        *ueCqiRpt;
31466 #endif
31467 {
31468    U8    *cqiCount = NULLP;
31469    S16   retVal;
31470    RgrStaIndInfo *staInfo = NULLP;
31471
31472    TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
31473
31474    /* Step 1: Store the CQI in collation array */
31475    /* Step 2: Increament the tracking count */
31476    cqiCount = &(ue->schCqiInfo.cqiCount);
31477    ue->schCqiInfo.cqiRept[(*cqiCount)++] =
31478                   *ueCqiRpt;
31479
31480
31481    /* Step 3: Check is it time to to send the report */
31482    if(RG_SCH_CQIR_IS_TIMTOSEND_CQIREPT(ue))
31483    {
31484    /* Step 4: if yes, Send StaInd to RRM */
31485       retVal = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&staInfo,
31486                sizeof(RgrStaIndInfo));
31487       if (retVal != ROK)
31488       {
31489          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
31490             "allocate memory for sending StaInd CRNTI:%d",ue->ueId);
31491          RETVALUE(retVal);
31492       }
31493
31494    /* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
31495 #ifdef CA_DBG
31496       {
31497          extern U32 gCqiReptToAppCount;
31498          gCqiReptToAppCount++;
31499       
31500       }
31501
31502 #endif
31503       retVal = rgSCHUtlFillSndStaInd(cell, ue, staInfo,
31504             ue->cqiReptCfgInfo.numColltdCqiRept);
31505       RETVALUE(retVal);
31506
31507    }
31508
31509    RETVALUE(ROK);
31510 } /* End of rgSCHCmnUeDlPwrCtColltCqiRept */
31511
31512 #endif /* End of RGR_CQI_REPT */
31513
31514 /**
31515  * @brief This function checks for the retransmisson
31516  *        for a DTX scenario.
31517  * @details
31518  *
31519  *     Function:
31520  *     Purpose:
31521  *     Invoked by:
31522  *
31523  *  @param[in]  RgSchCellCb        *cell
31524  *  @param[in]  RgSchUeCb          *ue
31525  *  @param[in]
31526  *  @return  Void
31527  *
31528  **/
31529 #ifdef ANSI
31530 PUBLIC Void rgSCHCmnChkRetxAllowDtx
31531 (
31532 RgSchCellCb        *cell,
31533 RgSchUeCb          *ueCb,
31534 RgSchDlHqProcCb    *proc,
31535 Bool               *reTxAllwd
31536 )
31537 #else
31538 PUBLIC Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
31539 RgSchCellCb        *cell;
31540 RgSchUeCb          *ueCb;
31541 RgSchDlHqProcCb    *proc;
31542 Bool               *reTxAllwd;
31543 #endif
31544 {
31545    TRC3(rgSCHCmnChkRetxAllowDtx)
31546
31547
31548    *reTxAllwd = TRUE;
31549    /* Fix */
31550    if ((proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX))
31551    {
31552        *reTxAllwd = FALSE;
31553    }
31554
31555    RETVOID;
31556 }
31557
31558 /**
31559  * @brief API for calculating the SI Set Id 
31560  *
31561  * @details
31562  *
31563  *     Function: rgSCHCmnGetSiSetId
31564  *
31565  *     This API is used for calculating the SI Set Id, as shown below
31566  *     
31567  *          siSetId = 0        siSetId = 1
31568  *     |******************|******************|---------------->
31569  *   (0,0)              (8,0)              (16,0)          (SFN, SF)
31570  *    
31571  *
31572  *  @param[in]  U16     sfn                   
31573  *  @param[in]  U8      sf
31574  *  @return     U16     siSetId
31575  **/
31576 #ifdef ANSI
31577 PUBLIC U16 rgSCHCmnGetSiSetId
31578 (
31579 U16    sfn,
31580 U8     sf,
31581 U16    minPeriodicity
31582 )
31583 #else
31584 PUBLIC U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
31585 U16    sfn;
31586 U8     sf
31587 U16    minPeriodicity;
31588 #endif
31589 {
31590    /* 80 is the minimum SI periodicity in sf. Also
31591     * all other SI periodicities are multiples of 80 */
31592     RETVALUE (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
31593 }
31594 #ifdef LTE_TDD
31595 /**
31596  * @brief API for calculating the DwPts Rb, Itbs and  tbSz 
31597  *
31598  * @details
31599  *
31600  *     Function: rgSCHCmnCalcDwPtsTbSz
31601  *
31602  *  @param[in]     RgSchCellCb    *cell                   
31603  *  @param[in]     U32             bo
31604  *  @param[in/out] U8             *rb
31605  *  @param[in/out] U8             *iTbs
31606  *  @param[in]     U8              lyr
31607  *  @param[in]     U8              cfi
31608  *  @return        U32             tbSz
31609  **/
31610 #ifdef ANSI
31611 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz
31612 (
31613 RgSchCellCb    *cell,
31614 U32             bo,
31615 U8             *rb,
31616 U8             *iTbs,
31617 U8              lyr,
31618 U8              cfi
31619 )
31620 #else
31621 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
31622 RgSchCellCb    *cell;
31623 U32             bo;
31624 U8             *rb;
31625 U8             *iTbs;
31626 U8              lyr;
31627 U8              cfi;
31628 #endif
31629 {
31630     U32             tbSz;
31631     RgSchCmnDlCell *cellDl     = RG_SCH_CMN_GET_DL_CELL(cell);
31632     U32             numRE      = *rb * cellDl->noResPerRb[cfi];
31633     U32             numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);   
31634
31635     TRC2(rgSCHCmnCalcDwPtsTbSz);
31636
31637     /* DwPts Rb cannot exceed the cell Bw */
31638     numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
31639     
31640     /* Adjust the iTbs for optimum usage of the DwPts region. 
31641      * Using the same iTbs adjustment will not work for all 
31642      * special subframe configurations and iTbs levels. Hence use the 
31643      * static iTbs Delta table for adjusting the iTbs  */
31644     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs);
31645     
31646     if (bo)
31647     {
31648        while(rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1] < bo*8 &&
31649              numDwPtsRb < cellDl->maxDlBwPerUe) 
31650        {
31651           (numDwPtsRb)++;
31652        }
31653
31654        tbSz = rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1];
31655     }
31656     else
31657     {
31658        tbSz = rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1];
31659     }
31660     *rb = numDwPtsRb;
31661
31662     RETVALUE(tbSz/8);
31663 }
31664
31665 /**
31666  * @brief API for calculating the DwPts Rb, Itbs and  tbSz 
31667  *
31668  * @details
31669  *
31670  *     Function: rgSCHCmnCalcDwPtsTbSz2Cw
31671  *
31672  *  @param[in]      RgSchCellCb    *cell                   
31673  *  @param[in]      U32             bo
31674  *  @param[in/out]  U8             *rb
31675  *  @param[in]      U8              maxRb
31676  *  @param[in/out]  U8             *iTbs1
31677  *  @param[in/out]  U8             *iTbs2
31678  *  @param[in]      U8              lyr1
31679  *  @param[in]      U8              lyr2
31680  *  @return[in/out] U32            *tb1Sz
31681  *  @return[in/out] U32            *tb2Sz
31682  *  @param[in]      U8              cfi 
31683  **/
31684 #ifdef ANSI
31685 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw
31686 (
31687 RgSchCellCb    *cell,
31688 U32             bo,
31689 U8             *rb,
31690 U8              maxRb,
31691 U8             *iTbs1,
31692 U8             *iTbs2,
31693 U8              lyr1,
31694 U8              lyr2,
31695 U32            *tb1Sz, 
31696 U32            *tb2Sz,
31697 U8              cfi
31698 )
31699 #else
31700 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2, 
31701       lyr1, lyr2, tb1Sz, tb2Sz, cfi)
31702 RgSchCellCb    *cell;
31703 U32             bo;
31704 U8             *rb;
31705 U8              maxRb;
31706 U8             *iTbs1;
31707 U8             *iTbs2;
31708 U8              lyr1;
31709 U8              lyr2;
31710 U32            *tb1Sz; 
31711 U32            *tb2Sz;
31712 U8              cfi;
31713 #endif
31714 {
31715     RgSchCmnDlCell *cellDl     = RG_SCH_CMN_GET_DL_CELL(cell);
31716     U32             numRE      = *rb * cellDl->noResPerRb[cfi];
31717     U32             numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);   
31718
31719     TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
31720
31721     /* DwPts Rb cannot exceed the cell Bw */
31722     numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
31723     
31724     /* Adjust the iTbs for optimum usage of the DwPts region. 
31725      * Using the same iTbs adjustment will not work for all 
31726      * special subframe configurations and iTbs levels. Hence use the 
31727      * static iTbs Delta table for adjusting the iTbs  */
31728     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs1);
31729     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs2);
31730     
31731     while((rgTbSzTbl[lyr1-1][*iTbs1][RGSCH_MAX(numDwPtsRb*3/4,1)-1] +
31732            rgTbSzTbl[lyr2-1][*iTbs2][RGSCH_MAX(numDwPtsRb*3/4,1)-1])< bo*8 &&
31733           numDwPtsRb < maxRb) 
31734     {
31735        (numDwPtsRb)++;
31736     }
31737
31738     *tb1Sz = rgTbSzTbl[lyr1-1][*iTbs1][RGSCH_MAX(numDwPtsRb*3/4,1)-1]/8;
31739     *tb2Sz = rgTbSzTbl[lyr2-1][*iTbs2][RGSCH_MAX(numDwPtsRb*3/4,1)-1]/8;
31740
31741     *rb = numDwPtsRb;
31742
31743     RETVOID;    
31744 }
31745
31746 #endif
31747
31748 /**
31749  * @brief Updates the GBR LCGs when datInd is received from MAC
31750  * 
31751  * @details
31752  *
31753  *     Function: rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
31754  *     Purpose:  This function updates the GBR LCGs 
31755  *               when datInd is received from MAC.
31756  *
31757  *     Invoked by: TOM
31758  *
31759  *  @param[in]  RgSchCellCb      *cell
31760  *  @param[in]  RgSchUeCb        *ue
31761  *  @param[in]  RgInfUeDatInd    *datInd
31762  *  @return Void
31763  **/
31764 #ifdef ANSI
31765 PUBLIC Void rgSCHCmnUpdUeDataIndLcg 
31766 (
31767 RgSchCellCb    *cell,
31768 RgSchUeCb      *ue,
31769 RgInfUeDatInd  *datInd
31770 )
31771 #else
31772 PUBLIC Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
31773 RgSchCellCb    *cell;
31774 RgSchUeCb      *ue;
31775 RgInfUeDatInd  *datInd;
31776 #endif
31777 {
31778    U32 idx = 0;
31779    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
31780 #ifdef DEBUGP
31781    Inst                inst = cell->instIdx;
31782 #endif
31783
31784    TRC2(rgSCHCmnUpdUeDataIndLcg);
31785
31786    for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
31787    {
31788       if (datInd->lcgInfo[idx].bytesRcvd != 0)
31789       {
31790          U8  lcgId     = datInd->lcgInfo[idx].lcgId;
31791          U32 bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
31792
31793          if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
31794          {
31795             RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
31796             if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
31797             {
31798                if(bytesRcvd > cmnLcg->effGbr)
31799                {
31800                   bytesRcvd -= cmnLcg->effGbr;
31801                   cmnLcg->effDeltaMbr = (cmnLcg->effDeltaMbr > bytesRcvd) ? \
31802                                         (cmnLcg->effDeltaMbr - bytesRcvd) : (0);
31803                   cmnLcg->effGbr = 0;
31804                }
31805                else
31806                {
31807                   cmnLcg->effGbr -= bytesRcvd;
31808                }
31809                /* To keep BS updated with the amount of data received for the GBR */
31810                cmnLcg->reportedBs = (cmnLcg->reportedBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31811                                     (cmnLcg->reportedBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31812                cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr+cmnLcg->effDeltaMbr);
31813             }
31814             else if(lcgId != 0)
31815             {
31816                ue->ul.effAmbr = (ue->ul.effAmbr > datInd->lcgInfo[idx].bytesRcvd) ? \
31817                                (ue->ul.effAmbr - datInd->lcgInfo[idx].bytesRcvd) : (0);
31818                cmnLcg->reportedBs = (cmnLcg->reportedBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31819                                     (cmnLcg->reportedBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31820                cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
31821                ue->ul.nonGbrLcgBs = (ue->ul.nonGbrLcgBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31822                                    (ue->ul.nonGbrLcgBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31823             }
31824             ue->ul.nonLcg0Bs = (ue->ul.nonLcg0Bs > datInd->lcgInfo[idx].bytesRcvd) ? \
31825                               (ue->ul.nonLcg0Bs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31826          }
31827       }
31828       else
31829       {
31830          break;
31831       }
31832    }
31833 #ifdef EMTC_ENABLE
31834    if(TRUE == ue->isEmtcUe)
31835    {
31836       if (cellSch->apisEmtcUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
31837       {
31838          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
31839       }
31840
31841    }
31842    else
31843 #endif
31844    {
31845       if (cellSch->apisUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
31846       {
31847          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
31848       }
31849    }
31850 }
31851
31852
31853 /** @brief This function initializes DL allocation lists and prepares
31854  *         for scheduling  
31855  *
31856  * @details
31857  *
31858  *     Function: rgSCHCmnInitRbAlloc
31859  *
31860  * @param  [in] RgSchCellCb    *cell
31861  *
31862  * Returns: Void
31863  *
31864  */
31865 #ifdef ANSI
31866 PRIVATE Void  rgSCHCmnInitRbAlloc 
31867 (
31868 RgSchCellCb        *cell
31869 )
31870 #else
31871 PRIVATE Void  rgSCHCmnInitRbAlloc (cell)
31872 RgSchCellCb        *cell;
31873 #endif
31874 {
31875    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
31876    CmLteTimingInfo        frm;
31877    RgSchDlSf              *dlSf;
31878         U8                     idx;
31879    
31880    TRC2(rgSCHCmnInitRbAlloc);
31881
31882 /* Initializing RgSchCmnUlRbAllocInfo structure.*/
31883    rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
31884
31885    frm = cellSch->dl.time;
31886
31887    dlSf = rgSCHUtlSubFrmGet(cell, frm);
31888 #ifdef RG_5GTF
31889    dlSf->numGrpPerTti = cell->cell5gtfCb.ueGrpPerTti;
31890    dlSf->numUePerGrp = cell->cell5gtfCb.uePerGrpPerTti;
31891         for(idx = 0; idx < MAX_5GTF_BEAMS; idx++)
31892    {
31893       dlSf->sfBeamInfo[idx].totVrbgAllocated = 0;
31894       dlSf->sfBeamInfo[idx].totVrbgRequired = 0;
31895       dlSf->sfBeamInfo[idx].vrbgStart = 0;
31896    }
31897 #endif
31898    dlSf->remUeCnt = cellSch->dl.maxUePerDlSf;
31899    /* Updating the Subframe information in RBAllocInfo */
31900    cellSch->allocInfo.dedAlloc.dedDlSf   = dlSf;
31901    cellSch->allocInfo.msg4Alloc.msg4DlSf = dlSf;
31902
31903    /* LTE_ADV_FLAG_REMOVED_START */
31904    /* Determine next scheduling subframe is ABS or not */
31905    if(RGR_ENABLE == cell->lteAdvCb.absCfg.status)
31906    {
31907       cell->lteAdvCb.absPatternDlIdx = 
31908          ((frm.sfn*RGSCH_NUM_SUB_FRAMES_5G) + frm.slot) % RGR_ABS_PATTERN_LEN;
31909       cell->lteAdvCb.absDlSfInfo = (RgSchAbsSfEnum)(cell->lteAdvCb.absCfg.absPattern[
31910             cell->lteAdvCb.absPatternDlIdx]);
31911
31912    }
31913    else
31914    {
31915       cell->lteAdvCb.absDlSfInfo = RG_SCH_ABS_DISABLED;
31916    }
31917    /* LTE_ADV_FLAG_REMOVED_END */
31918
31919 #ifdef RGR_V1
31920    cellSch->allocInfo.ccchSduAlloc.ccchSduDlSf = dlSf;
31921 #endif
31922 #ifdef LTEMAC_SPS
31923    /* Update subframe-wide allocation information with SPS allocation */
31924    rgSCHCmnSpsDlUpdDlSfAllocWithSps(cell, frm, dlSf);
31925 #endif
31926    RETVOID;
31927 }
31928
31929
31930
31931 #ifdef DL_LA
31932 /**
31933  * @brief Check & Updates the TM Mode chnage threashold based on cqiiTbs and
31934  * actual iTbs
31935  * 
31936  * @details
31937  *
31938  *     Function: rgSCHCmnSendTxModeInd(cell, ueUl, newTxMode)
31939  *     Purpose:  This function sends the TX mode Change 
31940  *               indication to RRM
31941  *     change
31942  *
31943  *     Invoked by: CMN
31944  *
31945  *  @param[in]  RgSchCellCb      *cell
31946  *  @param[in]  RgSchUeCb        *ue
31947  *  @param[in]  U8               newTxMode
31948  *  @return Void
31949  **/
31950 #ifdef ANSI
31951 PRIVATE Void rgSCHCmnSendTxModeInd 
31952 (
31953 RgSchCellCb    *cell,
31954 RgSchUeCb      *ue,
31955 U8             newTxMode
31956 )
31957 #else
31958 PRIVATE Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
31959 RgSchCellCb    *cell;
31960 RgSchUeCb      *ue;
31961 U8             newTxMode;
31962 #endif
31963 { 
31964    RgmTransModeInd   *txModeChgInd;
31965    RgSchCmnDlUe      *ueDl =  RG_SCH_CMN_GET_DL_UE(ue,cell);
31966
31967    TRC2(rgSCHCmnSendTxModeInd);
31968
31969    if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
31970    {
31971       /* Mem Alloc */
31972       if(SGetSBuf(cell->rgmSap->sapCfg.sapPst.region,
31973                cell->rgmSap->sapCfg.sapPst.pool, (Data**)&txModeChgInd,
31974                sizeof(RgmTransModeInd)) != ROK)
31975       {
31976          RETVOID;
31977       }
31978       RG_SCH_FILL_RGM_TRANSMODE_IND(ue->ueId, cell->cellId, newTxMode, txModeChgInd);
31979       RgUiRgmChangeTransModeInd(&(cell->rgmSap->sapCfg.sapPst),
31980             cell->rgmSap->sapCfg.suId, txModeChgInd);
31981    }
31982
31983    ue->mimoInfo.txModUpChgFactor = 0;
31984    ue->mimoInfo.txModDownChgFactor = 0;
31985    ueDl->laCb[0].deltaiTbs = 0;
31986
31987    RETVOID;
31988 }
31989
31990 /**
31991  * @brief Check & Updates the TM Mode chnage threashold based on cqiiTbs and
31992  * actual iTbs
31993  * 
31994  * @details
31995  *
31996  *     Function: rgSchCheckAndTriggerModeChange(cell, ueUl, iTbsNew)
31997  *     Purpose:  This function update and check for threashold for TM mode
31998  *     change
31999  *
32000  *     Invoked by: CMN
32001  *
32002  *  @param[in]  RgSchCellCb      *cell
32003  *  @param[in]  RgSchUeCb        *ue
32004  *  @param[in]  U8               iTbs
32005  *  @return Void
32006  **/
32007 #ifdef ANSI
32008 PUBLIC Void rgSchCheckAndTriggerModeChange
32009 (
32010 RgSchCellCb    *cell,
32011 RgSchUeCb      *ue,
32012 U8             reportediTbs,
32013 U8             previTbs,
32014 U8             maxiTbs
32015 )
32016 #else
32017 PUBLIC Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
32018 RgSchCellCb    *cell;
32019 RgSchUeCb      *ue;
32020 U8             reportediTbs;
32021 U8             previTbs;
32022 U8             maxiTbs;
32023 #endif
32024 {
32025    RgrTxMode          txMode;       /*!< UE's Transmission Mode */
32026    RgrTxMode          modTxMode;       /*!< UE's Transmission Mode */
32027
32028    TRC2(rgSchCheckAndTriggerModeChange);
32029
32030    txMode = ue->mimoInfo.txMode;
32031
32032    /* Check for Step down */
32033    /* Step down only when TM4 is configured. */
32034    if(RGR_UE_TM_4 == txMode)
32035    {
32036       if((previTbs <= reportediTbs) && ((reportediTbs - previTbs) >= RG_SCH_MODE_CHNG_STEPDOWN_CHECK_FACTOR))
32037       {
32038          ue->mimoInfo.txModDownChgFactor += RG_SCH_MODE_CHNG_STEPUP_FACTOR;
32039       }
32040       else
32041       {
32042          ue->mimoInfo.txModDownChgFactor -= RG_SCH_MODE_CHNG_STEPDOWN_FACTOR;
32043       }
32044
32045       ue->mimoInfo.txModDownChgFactor =  
32046          RGSCH_MAX(ue->mimoInfo.txModDownChgFactor, -(RG_SCH_MODE_CHNG_STEPDOWN_THRSHD));
32047
32048       if(ue->mimoInfo.txModDownChgFactor >= RG_SCH_MODE_CHNG_STEPDOWN_THRSHD)
32049       {
32050          /* Trigger Mode step down */
32051          modTxMode = RGR_UE_TM_3;
32052          rgSCHCmnSendTxModeInd(cell, ue, modTxMode);
32053       }
32054    }
32055
32056    /* Check for Setup up */
32057    /* Step Up only when TM3 is configured, Max possible Mode is TM4*/
32058    if(RGR_UE_TM_3 == txMode)
32059    {
32060       if((previTbs > reportediTbs) || (maxiTbs == previTbs))
32061       {
32062          ue->mimoInfo.txModUpChgFactor += RG_SCH_MODE_CHNG_STEPUP_FACTOR;
32063       }
32064       else
32065       {
32066          ue->mimoInfo.txModUpChgFactor -= RG_SCH_MODE_CHNG_STEPDOWN_FACTOR;
32067       }
32068
32069       ue->mimoInfo.txModUpChgFactor = 
32070          RGSCH_MAX(ue->mimoInfo.txModUpChgFactor, -(RG_SCH_MODE_CHNG_STEPUP_THRSHD));
32071
32072       /* Check if TM step up need to be triggered */
32073       if(ue->mimoInfo.txModUpChgFactor >= RG_SCH_MODE_CHNG_STEPUP_THRSHD)
32074       {
32075          /* Trigger mode chnage */
32076          modTxMode =  RGR_UE_TM_4;
32077          rgSCHCmnSendTxModeInd(cell, ue, modTxMode);
32078       }
32079    }
32080
32081    RETVOID;
32082 }
32083 #endif
32084
32085 /**
32086 * @brief Updates the GBR LCGs when datInd is received from MAC
32087  * 
32088  * @details
32089  *
32090  *     Function: rgSCHCmnIsDlCsgPrio (cell)
32091  *     Purpose:  This function returns if csg UEs are
32092  *               having priority at current time
32093  *
32094  *     Invoked by: Scheduler
32095  *
32096  *  @param[in]  RgSchCellCb      *cell
32097  *  @param[in]  RgSchUeCb        *ue
32098  *  @param[in]  RgInfUeDatInd    *datInd
32099  *  @return Void
32100  **/
32101 #ifdef ANSI
32102 PUBLIC Bool rgSCHCmnIsDlCsgPrio
32103 (
32104 RgSchCellCb    *cell
32105 )
32106 #else
32107 PUBLIC Bool rgSCHCmnIsDlCsgPrio(cell)
32108 RgSchCellCb    *cell;
32109 #endif
32110 {
32111   
32112    RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
32113  
32114    TRC2(rgSCHCmnIsDlCsgPrio)
32115    /* Calculating the percentage resource allocated */
32116    if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
32117    {
32118       RETVALUE(FALSE);
32119    }
32120    else
32121    {
32122       if(((cmnDlCell->ncsgPrbCnt * 100) / cmnDlCell->totPrbCnt) < cell->minDlResNonCsg)
32123       {
32124          RETVALUE(FALSE);
32125       }
32126       else
32127       {
32128          RETVALUE(TRUE);
32129       }
32130    }
32131 }
32132
32133 /**
32134 * @brief Updates the GBR LCGs when datInd is received from MAC
32135  * 
32136  * @details
32137  *
32138  *     Function: rgSCHCmnIsUlCsgPrio (cell)
32139  *     Purpose:  This function returns if csg UEs are
32140  *               having priority at current time
32141  *
32142  *     Invoked by: Scheduler
32143  *
32144  *  @param[in]  RgSchCellCb      *cell
32145  *  @param[in]  RgSchUeCb        *ue
32146  *  @param[in]  RgInfUeDatInd    *datInd
32147  *  @return Void
32148  **/
32149 #ifdef ANSI
32150 PUBLIC Bool rgSCHCmnIsUlCsgPrio
32151 (
32152 RgSchCellCb    *cell
32153 )
32154 #else
32155 PUBLIC Bool rgSCHCmnIsUlCsgPrio(cell)
32156 RgSchCellCb    *cell;
32157 #endif
32158 {
32159    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
32160  
32161    TRC2(rgSCHCmnIsUlCsgPrio)
32162
32163    /* Calculating the percentage resource allocated */
32164    if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
32165    {
32166       RETVALUE(FALSE);
32167    }
32168    else
32169    {
32170       if (((cmnUlCell->ncsgPrbCnt * 100) /cmnUlCell->totPrbCnt) < cell->minUlResNonCsg)
32171       {
32172          RETVALUE(FALSE);
32173       }
32174       else
32175       {
32176          RETVALUE(TRUE);
32177       }
32178    }
32179 }
32180
32181 /** @brief DL scheduler for SPS, and all other downlink data
32182  *
32183  * @details
32184  *
32185  *      Function: rgSchCmnPreDlSch
32186  *
32187  *  @param  [in] Inst               schInst;
32188  *   Returns: Void
32189  *
32190  */
32191 #ifdef ANSI
32192    PUBLIC Void rgSchCmnPreDlSch
32193 (
32194  RgSchCellCb        **cell,
32195  U8                 nCell,
32196  RgSchCellCb        **cellLst
32197  )
32198 #else
32199 PUBLIC Void rgSchCmnPreDlSch(cell, nCell, cellLst)
32200    RgSchCellCb        **cell;
32201    U8                 nCell;
32202    RgSchCellCb        **cellLst;
32203 #endif
32204 {
32205    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell[0]);
32206    RgSchDlSf     *sf;
32207    U8            idx;
32208
32209    TRC2(rgSchCmnPreDlSch);
32210
32211    if(nCell > CM_LTE_MAX_CELLS)
32212    {
32213       RETVOID;
32214    }
32215
32216    if (cell[0]->isDlDataAllwd && (cell[0]->stopDlSch == FALSE))
32217    {
32218       /* Specific DL scheduler to perform UE scheduling */
32219       cellSch->apisDl->rgSCHDlPreSched(cell[0]);
32220
32221       /* Rearranging the cell entries based on their remueCnt in SF.
32222        * cells will be processed in the order of number of ue scheduled
32223        * in that cell */
32224       for (idx = 0; idx < nCell; idx++)
32225       {
32226          U8    j;
32227          cellSch = RG_SCH_CMN_GET_CELL(cell[idx]);
32228          sf = cellSch->allocInfo.dedAlloc.dedDlSf;
32229
32230          if(idx == 0)
32231          {
32232             cellLst[idx] = cell[idx];
32233             continue;
32234          }
32235
32236          for(j = 0; j < idx; j++)
32237          {
32238             RgSchCmnCell *cmnCell = RG_SCH_CMN_GET_CELL(cellLst[j]);
32239             RgSchDlSf    *subfrm = cmnCell->allocInfo.dedAlloc.dedDlSf;
32240
32241             if(sf->remUeCnt < subfrm->remUeCnt)
32242             {
32243                U8  k;
32244                for(k = idx; k > j; k--)
32245                {
32246                   cellLst[k] = cellLst[k-1];
32247                }
32248                break;
32249             }
32250          }
32251          cellLst[j] = cell[idx];
32252       }
32253    }
32254    else
32255    {
32256       for (idx = 0; idx < nCell; idx++)
32257       {
32258          cellLst[idx] = cell[idx];
32259       }
32260    }
32261    RETVOID;
32262 }
32263
32264 /** @brief DL scheduler for SPS, and all other downlink data
32265  *  @details
32266  *
32267  *       Function: rgSchCmnPstDlSch
32268  *
32269  *        @param  [in] Inst               schInst;
32270  *        Returns: Void
32271  *
32272  */
32273 #ifdef ANSI
32274 PUBLIC Void rgSchCmnPstDlSch
32275 (
32276  RgSchCellCb       *cell
32277 )
32278 #else
32279 PUBLIC Void rgSchCmnPstDlSch(cell)
32280    RgSchCellCb        *cell
32281 #endif
32282 {
32283    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
32284
32285    TRC2(rgSchCmnPstDlSch);
32286
32287    if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
32288    {
32289       cellSch->apisDl->rgSCHDlPstSched(cell->instIdx);
32290    }
32291 }
32292
32293 #ifdef ANSI
32294 PUBLIC U8 rgSCHCmnCalcPcqiBitSz
32295 (
32296  RgSchUeCb    *ueCb, 
32297  U8           numTxAnt
32298 )
32299 #else
32300 PUBLIC U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
32301    RgSchUeCb     *ueCb;
32302    U8            numTxAnt;
32303 #endif
32304 {
32305    U8 confRepMode;
32306    U8 pcqiSz;
32307    U8 ri;
32308    RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
32309
32310    TRC3(rgSCHCmnCalcPcqiBitSz);
32311
32312    confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
32313    if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) && 
32314          (ueCb->mimoInfo.txMode != RGR_UE_TM_4))
32315    {
32316       ri =1;
32317    }
32318    else
32319    {
32320       ri = cqiCb->perRiVal;
32321    }
32322    switch(confRepMode)
32323    {
32324       case RGR_PRD_CQI_MOD10:
32325          {
32326             pcqiSz = 4;
32327          }
32328          break;
32329
32330       case RGR_PRD_CQI_MOD11:
32331          {
32332             if(numTxAnt == 2)
32333             {
32334                if (ri ==1)
32335                {
32336                   pcqiSz = 6;
32337                }
32338                else
32339                {
32340                   pcqiSz = 8;
32341                }
32342             }
32343             else if(numTxAnt == 4)
32344             {
32345                if (ri ==1)
32346                {
32347                   pcqiSz = 8;
32348                }
32349                else
32350                {
32351                   pcqiSz = 11;
32352                }
32353             }
32354             else
32355             {
32356                /* This is number of antenna case 1.
32357                 * This is not applicable for Mode 1-1. 
32358                 * So setting it to invalid value */
32359                pcqiSz = 0;
32360             }
32361          }
32362          break;
32363
32364       case RGR_PRD_CQI_MOD20:
32365          {
32366             if(cqiCb->isWb)
32367             {
32368                pcqiSz = 4;
32369             }
32370             else
32371             {
32372                pcqiSz = 4 + cqiCb->label;
32373             }
32374          }
32375          break;
32376
32377       case RGR_PRD_CQI_MOD21:
32378          {
32379             if(cqiCb->isWb)
32380             {
32381                if(numTxAnt == 2)
32382                {
32383                   if (ri ==1)
32384                   {
32385                      pcqiSz = 6;
32386                   }
32387                   else
32388                   {
32389                      pcqiSz = 8;
32390                   }
32391                }
32392                else if(numTxAnt == 4)
32393                {
32394                   if (ri ==1)
32395                   {
32396                      pcqiSz = 8;
32397                   }
32398                   else
32399                   {
32400                      pcqiSz = 11;
32401                   }
32402                }
32403                else
32404                {
32405                   /* This might be number of antenna case 1.
32406                    * For mode 2-1 wideband case only antenna port 2 or 4 is supported.
32407                    * So setting invalid value.*/
32408                   pcqiSz = 0;
32409                }
32410             }
32411             else
32412             {
32413                if (ri ==1)
32414                {
32415                   pcqiSz = 4 + cqiCb->label;
32416                }
32417                else
32418                {
32419                   pcqiSz = 7 + cqiCb->label;
32420                }
32421             }
32422          }
32423          break;
32424       default:
32425           pcqiSz = 0;
32426           break;
32427    }
32428    
32429    RETVALUE(pcqiSz);
32430 }
32431
32432 /** @brief DL scheduler for SPS, and all other downlink data
32433  *
32434  * @details
32435  *
32436  *     Function: rgSCHCmnDlSch
32437  *
32438  * @param  [in] RgSchCellCb    *cell
32439  *
32440  * Returns: Void
32441  *
32442  */
32443 #ifdef ANSI
32444 PUBLIC Void rgSCHCmnDlSch
32445 (
32446  RgSchCellCb        *cell
32447  )
32448 #else
32449 PUBLIC Void rgSCHCmnDlSch (cell)
32450    RgSchCellCb        *cell;
32451 #endif
32452 {
32453    RgSchDlSf *dlSf;
32454    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
32455 #ifdef RG_5GTF
32456    RgSchDynTddCb  *rgSchDynTddInfo = &(rgSchCb[cell->instIdx].rgSchDynTdd);
32457    U16 dlCntrlSfIdx;
32458 #endif
32459
32460    TRC2(rgSCHCmnDlSch);
32461
32462    dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
32463 #ifdef RG_5GTF
32464         if (rgSchDynTddInfo->isDynTddEnbld)
32465    {
32466       RG_SCH_DYN_TDD_GET_SFIDX(dlCntrlSfIdx, rgSchDynTddInfo->crntDTddSfIdx, 
32467                                             RG_SCH_CMN_DL_DELTA);
32468                 if(RG_SCH_DYNTDD_DLC_ULD == rgSchDynTddInfo->sfInfo[dlCntrlSfIdx].sfType)
32469                 {
32470                    if(1 == cell->cellId)
32471          {
32472                       ul5gtfsidDlAlreadyMarkUl++;
32473             /*
32474                       printf("ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n", 
32475                     ul5gtfsidDlAlreadyMarkUl, cellSch->dl.time.sfn, 
32476                     cellSch->dl.time.slot);
32477             */
32478          }
32479                    RETVOID;
32480                 }
32481    }
32482 #endif
32483
32484    /* Specific DL scheduler to perform UE scheduling */
32485    cellSch->apisDl->rgSCHDlNewSched(cell, &cellSch->allocInfo);      
32486    /* LTE_ADV_FLAG_REMOVED_END */
32487
32488    /* call common allocator for RB Allocation */
32489    rgSCHCmnDlRbAlloc(cell, &cellSch->allocInfo);
32490
32491    /* Finalize the Allocations for reqested Against alloced */
32492    rgSCHCmnDlAllocFnlz(cell);
32493
32494    /* Perform Pdcch allocations for PDCCH Order Q.
32495     * As of now, giving this the least preference.
32496     * This func call could be moved above other allocations
32497     * as per need */
32498    rgSCHCmnGenPdcchOrder(cell, dlSf);
32499
32500    /* Do group power control for PUCCH */
32501    rgSCHCmnGrpPwrCntrlPucch(cell, dlSf);
32502
32503    RETVOID;
32504 }
32505
32506 /**********************************************************************
32507
32508   End of file
32509 **********************************************************************/
O-RAN DU Layer 2