Code Review / o-du / l2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Initial commit for Bronze release
[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 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
162 (
163 RgSchCellCb        *cell,
164 RgSchUeCb          *ue,
165 RgSchDlSf          *dlSf,
166 U8                 rbStrt,
167 U8                 numRb
168 );
169 PRIVATE S16 rgSCHCmnBuildRntpInfo (
170 RgSchCellCb        *cell,
171 U8                 *rntpPtr,
172 U8                  startRb,
173 U8                  nmbRb,
174 U16                 bw
175 );
176 #endif
177
178 PUBLIC Void rgSCHCmnDlSpsSch
179 (
180  RgSchCellCb        *cell
181 );
182 /* LTE_ADV_FLAG_REMOVED_END */
183
184 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc ARGS((
185 RgSchCellCb           *cell,
186 RgSchCmnDlRbAllocInfo *allocInfo
187 ));
188 PRIVATE Void rgSCHBcchPcchDlRbAlloc ARGS((
189 RgSchCellCb           *cell,
190 RgSchCmnDlRbAllocInfo *allocInfo
191 ));
192 PRIVATE Void rgSCHCmnDlBcchPcchAlloc ARGS((
193 RgSchCellCb  *cell
194 ));
195 #ifdef RGR_CQI_REPT
196 PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
197  RgSchCellCb        *cell,
198  RgSchUeCb          *ue,
199  TfuDlCqiPucch      *pucchCqi,
200  RgrUeCqiRept       *ueCqiRept,
201  Bool               *isCqiAvail,
202  Bool               *is2ndCwCqiAvail
203  ));
204 PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
205  RgSchCellCb        *cell,
206  RgSchUeCb          *ue,
207  TfuDlCqiPusch      *puschCqi,
208  RgrUeCqiRept       *ueCqiRept,
209  Bool               *isCqiAvail,
210  Bool               *is2ndCwCqiAvail
211  ));
212 #else
213 PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
214  RgSchCellCb        *cell,
215  RgSchUeCb          *ue,
216  TfuDlCqiPucch      *pucchCqi
217  ));
218 PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
219  RgSchCellCb        *cell,
220  RgSchUeCb          *ue,
221  TfuDlCqiPusch      *puschCqi
222  ));
223 #endif
224 /* ccpu00117452 - MOD - Changed macro name from
225    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
226 #ifdef RGR_CQI_REPT
227 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept ARGS((
228    RgSchCellCb        *cell,
229    RgSchUeCb          *ue,
230    RgrUeCqiRept        *ueCqiRept));
231 #endif /* End of RGR_CQI_REPT */
232 /* Fix: syed align multiple UEs to refresh at same time */
233 PRIVATE Void rgSCHCmnGetRefreshPer ARGS((
234    RgSchCellCb  *cell,
235    RgSchUeCb    *ue,
236    U32          *waitPer));
237 PRIVATE S16 rgSCHCmnApplyUeRefresh ARGS((
238 RgSchCellCb     *cell,
239 RgSchUeCb       *ue));
240 #ifdef DL_LA
241 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa ARGS
242 ((
243 RgSchCellCb   *cell,
244 RgSchUeCb     *ue
245 ));
246 PRIVATE Void rgSCHCheckAndSetTxScheme ARGS
247 ((
248 RgSchCellCb   *cell,
249 RgSchUeCb     *ue
250 ));
251 #endif
252
253 #ifdef LTE_TDD
254 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz ARGS
255 ((
256 RgSchCellCb    *cell,
257 U32             bo,
258 U8             *rb,
259 U8             *iTbs,
260 U8              lyr,
261 U8              cfi
262 ));
263
264 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw ARGS
265 ((
266 RgSchCellCb    *cell,
267 U32             bo,
268 U8             *rb,
269 U8              maxRb,
270 U8             *iTbs1,
271 U8             *iTbs2,
272 U8              lyr1,
273 U8              lyr2,
274 U32            *tb1Sz, 
275 U32            *tb2Sz, 
276 U8              cfi
277 ));
278
279 #endif
280 PRIVATE Void rgSCHCmnNonDlfsType0Alloc
281 (
282 RgSchCellCb        *cell,
283 RgSchDlSf          *dlSf,
284 RgSchDlRbAlloc     *allocInfo,
285 RgSchUeCb          *ue
286 );
287 PRIVATE Void  rgSCHCmnInitRbAlloc ARGS 
288 ((
289 RgSchCellCb        *cell
290 ));
291 #ifdef __cplusplus
292 }
293 #endif /* __cplusplus */
294
295
296 /* local defines */
297 PUBLIC  RgSchdApis          rgSchCmnApis;
298 PRIVATE RgUlSchdApis        rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
299 PRIVATE RgDlSchdApis        rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
300 #ifdef EMTC_ENABLE
301 PRIVATE RgUlSchdApis        rgSchEmtcUlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
302 PRIVATE RgDlEmtcSchdApis        rgSchEmtcDlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
303 #endif
304 #ifdef RG_PHASE2_SCHED
305 PRIVATE RgDlfsSchdApis      rgSchDlfsSchdTbl[RGSCH_NUM_DLFS_SCHEDULERS];
306 #endif
307 PRIVATE RgUlSchdInits       rgSchUlSchdInits = RGSCH_ULSCHED_INITS;
308 PRIVATE RgDlSchdInits       rgSchDlSchdInits = RGSCH_DLSCHED_INITS;
309 #ifdef EMTC_ENABLE
310 PRIVATE RgEmtcUlSchdInits       rgSchEmtcUlSchdInits = RGSCH_EMTC_ULSCHED_INITS;
311 PRIVATE RgEmtcDlSchdInits       rgSchEmtcDlSchdInits = RGSCH_EMTC_DLSCHED_INITS;
312 #endif
313 #if (defined (RG_PHASE2_SCHED) && defined (TFU_UPGRADE))
314 PRIVATE RgDlfsSchdInits     rgSchDlfsSchdInits = RGSCH_DLFSSCHED_INITS;
315 #endif
316
317 typedef Void (*RgSchCmnDlAllocRbFunc) ARGS((RgSchCellCb *cell, RgSchDlSf *subFrm,
318 RgSchUeCb *ue, U32 bo, U32 *effBo, RgSchDlHqProcCb *proc,
319 RgSchCmnDlRbAllocInfo *cellWdAllocInfo));
320 typedef U8 (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, 
321       U8 numLyrs, Bool bothCwEnbld));
322
323 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
324 RgSchCellCb                *cell,
325 RgSchDlRbAlloc             *rbAllocInfo,
326 RgSchDlHqProcCb            *hqP,
327 RgSchPdcch                 *pdcch,
328 U8                         tpc
329 ));
330 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
331 RgSchCellCb                *cell,
332 RgSchDlRbAlloc             *rbAllocInfo,
333 RgSchDlHqProcCb            *hqP,
334 RgSchPdcch                 *pdcch,
335 U8                         tpc
336 ));
337 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
338 RgSchCellCb                *cell,
339 RgSchDlRbAlloc             *rbAllocInfo,
340 RgSchDlHqProcCb            *hqP,
341 RgSchPdcch                 *pdcch,
342 U8                         tpc
343 ));
344 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
345 RgSchCellCb                *cell,
346 RgSchDlRbAlloc             *rbAllocInfo,
347 RgSchDlHqProcCb            *hqP,
348 RgSchPdcch                 *pdcch,
349 U8                         tpc
350 ));
351 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
352 RgSchCellCb                *cell,
353 RgSchDlRbAlloc             *rbAllocInfo,
354 RgSchDlHqProcCb            *hqP,
355 RgSchPdcch                 *pdcch,
356 U8                         tpc
357 ));
358 PRIVATE Void rgSCHCmnDlAllocTxRbTM1 ARGS((
359 RgSchCellCb                *cell,
360 RgSchDlSf                  *subFrm,
361 RgSchUeCb                  *ue,
362 U32                        bo,
363 U32                        *effBo,
364 RgSchDlHqProcCb            *proc,
365 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
366 ));
367 PRIVATE Void rgSCHCmnDlAllocTxRbTM2 ARGS((
368 RgSchCellCb                *cell,
369 RgSchDlSf                  *subFrm,
370 RgSchUeCb                  *ue,
371 U32                        bo,
372 U32                        *effBo,
373 RgSchDlHqProcCb            *proc,
374 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
375 ));
376 PRIVATE Void rgSCHCmnDlAllocTxRbTM3 ARGS((
377 RgSchCellCb                *cell,
378 RgSchDlSf                  *subFrm,
379 RgSchUeCb                  *ue,
380 U32                        bo,
381 U32                        *effBo,
382 RgSchDlHqProcCb            *proc,
383 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
384 ));
385 PRIVATE Void rgSCHCmnDlAllocTxRbTM4 ARGS((
386 RgSchCellCb                *cell,
387 RgSchDlSf                  *subFrm,
388 RgSchUeCb                  *ue,
389 U32                        bo,
390 U32                        *effBo,
391 RgSchDlHqProcCb            *proc,
392 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
393 ));
394 #ifdef RG_UNUSED
395 PRIVATE Void rgSCHCmnDlAllocTxRbTM5 ARGS((
396 RgSchCellCb                *cell,
397 RgSchDlSf                  *subFrm,
398 RgSchUeCb                  *ue,
399 U32                        bo,
400 U32                        *effBo,
401 RgSchDlHqProcCb            *proc,
402 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
403 ));
404 #endif
405 PRIVATE Void rgSCHCmnDlAllocTxRbTM6 ARGS((
406 RgSchCellCb                *cell,
407 RgSchDlSf                  *subFrm,
408 RgSchUeCb                  *ue,
409 U32                        bo,
410 U32                        *effBo,
411 RgSchDlHqProcCb            *proc,
412 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
413 ));
414 PRIVATE Void rgSCHCmnDlAllocTxRbTM7 ARGS((
415 RgSchCellCb                *cell,
416 RgSchDlSf                  *subFrm,
417 RgSchUeCb                  *ue,
418 U32                        bo,
419 U32                        *effBo,
420 RgSchDlHqProcCb            *proc,
421 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
422 ));
423 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1 ARGS((
424 RgSchCellCb                *cell,
425 RgSchDlSf                  *subFrm,
426 RgSchUeCb                  *ue,
427 U32                        bo,
428 U32                        *effBo,
429 RgSchDlHqProcCb            *proc,
430 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
431 ));
432 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2 ARGS((
433 RgSchCellCb                *cell,
434 RgSchDlSf                  *subFrm,
435 RgSchUeCb                  *ue,
436 U32                        bo,
437 U32                        *effBo,
438 RgSchDlHqProcCb            *proc,
439 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
440 ));
441 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3 ARGS((
442 RgSchCellCb                *cell,
443 RgSchDlSf                  *subFrm,
444 RgSchUeCb                  *ue,
445 U32                        bo,
446 U32                        *effBo,
447 RgSchDlHqProcCb            *proc,
448 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
449 ));
450 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4 ARGS((
451 RgSchCellCb                *cell,
452 RgSchDlSf                  *subFrm,
453 RgSchUeCb                  *ue,
454 U32                        bo,
455 U32                        *effBo,
456 RgSchDlHqProcCb            *proc,
457 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
458 ));
459 #ifdef RG_UNUSED
460 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5 ARGS((
461 RgSchCellCb                *cell,
462 RgSchDlSf                  *subFrm,
463 RgSchUeCb                  *ue,
464 U32                        bo,
465 U32                        *effBo,
466 RgSchDlHqProcCb            *proc,
467 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
468 ));
469 #endif
470 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6 ARGS((
471 RgSchCellCb                *cell,
472 RgSchDlSf                  *subFrm,
473 RgSchUeCb                  *ue,
474 U32                        bo,
475 U32                        *effBo,
476 RgSchDlHqProcCb            *proc,
477 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
478 ));
479 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7 ARGS((
480 RgSchCellCb                *cell,
481 RgSchDlSf                  *subFrm,
482 RgSchUeCb                  *ue,
483 U32                        bo,
484 U32                        *effBo,
485 RgSchDlHqProcCb            *proc,
486 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
487 ));
488
489 #ifdef LTE_ADV 
490 PRIVATE U8 rgSchGetN1ResCount ARGS ((
491  RgSchUeCb *ue,
492  U16       servCellId 
493 ));
494 PUBLIC Bool rgSchCmnChkDataOnlyOnPcell 
495 (
496  RgSchUeCb         *ue,
497  RgSchDlSf         *dlSf
498 );
499 #endif /*LTE_ADV */
500 PUBLIC U8 rgSCHCmnCalcPcqiBitSz
501 (
502  RgSchUeCb    *ueCb, 
503  U8           numTxAnt
504 );
505
506 #ifndef LTE_ADV
507 /* Functions specific to each transmission mode for DL Tx RB Allocation*/
508 RgSchCmnDlAllocRbFunc  dlAllocTxRbFunc[7] = {rgSCHCmnDlAllocTxRbTM1,
509 rgSCHCmnDlAllocTxRbTM2, rgSCHCmnDlAllocTxRbTM3, rgSCHCmnDlAllocTxRbTM4,
510 NULLP, rgSCHCmnDlAllocTxRbTM6, rgSCHCmnDlAllocTxRbTM7};
511
512 /* Functions specific to each transmission mode for DL Retx RB Allocation*/
513 RgSchCmnDlAllocRbFunc  dlAllocRetxRbFunc[7] = {rgSCHCmnDlAllocRetxRbTM1,
514 rgSCHCmnDlAllocRetxRbTM2, rgSCHCmnDlAllocRetxRbTM3, rgSCHCmnDlAllocRetxRbTM4,
515 NULLP, rgSCHCmnDlAllocRetxRbTM6, rgSCHCmnDlAllocRetxRbTM7};
516 #else
517 /* Functions specific to each transmission mode for DL Tx RB Allocation*/
518 RgSchCmnDlAllocRbFunc  dlAllocTxRbFunc[9] = {rgSCHCmnDlAllocTxRbTM1,
519 rgSCHCmnDlAllocTxRbTM2, rgSCHCmnDlAllocTxRbTM3, rgSCHCmnDlAllocTxRbTM4,
520 NULLP, rgSCHCmnDlAllocTxRbTM6, rgSCHCmnDlAllocTxRbTM7, NULLP, NULLP};
521
522 /* Functions specific to each transmission mode for DL Retx RB Allocation*/
523 RgSchCmnDlAllocRbFunc  dlAllocRetxRbFunc[9] = {rgSCHCmnDlAllocRetxRbTM1,
524 rgSCHCmnDlAllocRetxRbTM2, rgSCHCmnDlAllocRetxRbTM3, rgSCHCmnDlAllocRetxRbTM4,
525 NULLP, rgSCHCmnDlAllocRetxRbTM6, rgSCHCmnDlAllocRetxRbTM7, NULLP, NULLP};
526
527 #endif
528
529
530 PRIVATE U8 rgSCHCmnDlTM3PrecInf2 ARGS((
531 RgSchCellCb                *cell,
532 RgSchUeCb                  *ue,
533 U8                         numTxLyrs,
534 Bool                       bothCwEnbld
535 ));
536 PRIVATE U8 rgSCHCmnDlTM3PrecInf4 ARGS((
537 RgSchCellCb                *cell,
538 RgSchUeCb                  *ue,
539 U8                         numTxLyrs,
540 Bool                       bothCwEnbld
541 ));
542 PRIVATE U8 rgSCHCmnDlTM4PrecInf2 ARGS((
543 RgSchCellCb                *cell,
544 RgSchUeCb                  *ue,
545 U8                         numTxLyrs,
546 Bool                       bothCwEnbld
547 ));
548 PRIVATE U8 rgSCHCmnDlTM4PrecInf4 ARGS((
549 RgSchCellCb                *cell,
550 RgSchUeCb                  *ue,
551 U8                         numTxLyrs,
552 Bool                       bothCwEnbld
553 ));
554 /* Functions specific to each transmission mode for DL RB Allocation*/
555 RgSchCmnDlGetPrecInfFunc getPrecInfoFunc[2][2] = {
556 {rgSCHCmnDlTM3PrecInf2, rgSCHCmnDlTM3PrecInf4},
557 {rgSCHCmnDlTM4PrecInf2, rgSCHCmnDlTM4PrecInf4}
558 };
559
560 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb ARGS((
561 RgSchCellCb                *cell,
562 RgSchDlSf                  *subFrm,
563 RgSchUeCb                  *ue,
564 RgSchDlHqTbCb              *tbInfo,
565 U8                         noLyr,
566 U8                         *numRb,
567 U32                        *effBo
568 ));
569 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb ARGS((
570 RgSchCellCb                *cell,
571 RgSchDlSf                  *subFrm,
572 RgSchUeCb                  *ue,
573 RgSchDlHqProcCb            *proc,
574 U8                         *numRb,
575 Bool                       *swpFlg,
576 U32                        *effBo
577 ));
578 PRIVATE Void rgSCHCmnDlTM3TxTx ARGS((
579 RgSchCellCb                *cell,
580 RgSchDlSf                  *subFrm,
581 RgSchUeCb                  *ue,
582 U32                        bo,
583 U32                        *effBo,
584 RgSchDlHqProcCb            *proc,
585 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
586 ));
587 PRIVATE Void rgSCHCmnDlTM3TxRetx ARGS((
588 RgSchCellCb                *cell,
589 RgSchDlSf                  *subFrm,
590 RgSchUeCb                  *ue,
591 U32                        bo,
592 U32                        *effBo,
593 RgSchDlHqProcCb            *proc,
594 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
595 ));
596 PRIVATE Void rgSCHCmnDlTM3RetxRetx ARGS((
597 RgSchCellCb                *cell,
598 RgSchDlSf                  *subFrm,
599 RgSchUeCb                  *ue,
600 U32                        bo,
601 U32                        *effBo,
602 RgSchDlHqProcCb            *proc,
603 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
604 ));
605
606 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc ARGS((
607 RgSchCellCb        *cell,
608 RgSchDlSf          *dlSf,
609 U8                 rbStrt,
610 U8                 numRb
611 ));
612 /* LTE_ADV_FLAG_REMOVED_START */
613 #ifndef LTE_TDD
614 PRIVATE Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc ARGS((
615 RgSchCellCb        *cell,
616 RgSchDlSf          *dlSf,
617 U8                 rbStrt,
618 U8                 numRb
619 ));
620 #endif
621 /* LTE_ADV_FLAG_REMOVED_END */
622 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx ARGS((
623 RgSchCellCb        *cell,
624 RgSchCmnDlRbAllocInfo *allocInfo,
625 RgSchUeCb             *ue,
626 RgSchDlHqProcCb       *proc
627 ));
628 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx ARGS((
629 RgSchCellCb        *cell,
630 RgSchCmnDlRbAllocInfo *allocInfo,
631 RgSchUeCb             *ue,
632 RgSchDlHqProcCb       *hqP
633 ));
634 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst ARGS((
635 RgSchCmnDlRbAllocInfo *allocInfo,
636 RgSchUeCb             *ue,
637 RgSchDlHqProcCb       *proc
638 ));
639 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb ARGS((
640 RgSchCellCb                *cell,
641 RgSchDlSf                  *subFrm,
642 RgSchUeCb                  *ue,
643 RgSchDlHqTbCb              *reTxTb,
644 RgSchDlHqTbCb              *txTb,
645 U8                         *numRb,
646 U32                        *effBo
647 ));
648 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb ARGS((
649 RgSchCellCb                *cell,
650 RgSchDlSf                  *subFrm,
651 RgSchUeCb                  *ue,
652 RgSchDlHqProcCb            *proc,
653 U32                        bo,
654 U8                         *numRb,
655 U32                        *effBo
656 ));
657 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb ARGS((
658 RgSchCellCb                *cell,
659 RgSchDlSf                  *subFrm,
660 RgSchUeCb                  *ue,
661 RgSchDlHqTbCb              *tbInfo,
662 U32                        bo,
663 U8                         *numRb,
664 U32                        *effBo
665 ));
666 #ifndef LTEMAC_SPS
667 PRIVATE Void rgSCHCmnFillHqPTb ARGS((
668 RgSchCellCb                *cell,
669 RgSchDlRbAlloc             *rbAllocInfo,
670 U8                         tbAllocIdx,
671 RgSchPdcch                 *pdcch
672 ));
673 #endif
674 #ifdef LTEMAC_SPS
675 PRIVATE Void rgSCHCmnDlGetBestFitHole ARGS((
676 U32         *allocMask,
677 U8          numMaskRbs,
678 U32         *crntAllocMask,
679 U8          rbsReq,
680 U8          *allocStart,
681 U8          *allocNumRbs,
682 Bool        isPartialAlloc
683 ));
684 #ifdef RGSCH_SPS_UNUSED
685 PRIVATE U32 rgSCHCmnGetRaType1Mask ARGS((
686 U8                rbIdx,
687 U8                rbgSize,
688 U8                *type1Subset
689 ));
690 #endif
691 PRIVATE U32 rgSCHCmnGetRaType0Mask ARGS((
692 U8                rbIdx,
693 U8                rbgSize
694 ));
695 PRIVATE U32 rgSCHCmnGetRaType2Mask ARGS((
696 U8                rbIdx,
697 U8                *maskIdx
698 ));
699 #endif
700
701 PUBLIC Bool rgSCHCmnRetxAllocAvoid ARGS(( 
702 RgSchDlSf                  *subFrm,
703 RgSchCellCb                *cell,
704 RgSchDlHqProcCb            *proc
705 ));
706
707 PUBLIC U16 rgSCHCmnGetSiSetId ARGS((
708 U16    sfn,
709 U8     sf,
710 U16    minPeriodicity
711 ));
712
713 #ifdef TFU_UPGRADE
714 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
715 RgSchCellCb  *cell,
716 RgSchUeCb    *ue,
717 U32          maxRb,
718 U32          *numSb,
719 U8           *iTbs,
720 U32          hqSz,
721 U32          stepDownItbs,
722 U32          effTgt
723 ));
724 #endif
725
726 #ifdef RG_5GTF
727 //TODO_SID: Currenly table is only for 100 Prbs. Need to modify wrt VRBG table 8.1.5.2.1-1 V5G_213
728 U32 rgSch5gtfTbSzTbl[MAX_5GTF_MCS] = 
729     {1864, 5256, 8776, 13176, 17576, 21976, 26376, 31656, 35176, 39576, 43976, 47496, 52776, 59376, 66392};
730 U32 g5gtfTtiCnt = 0;
731 U32 gUl5gtfSrRecv = 0;
732 U32 gUl5gtfBsrRecv = 0;
733 U32 gUl5gtfUeSchPick = 0;
734 U32 gUl5gtfPdcchSchd = 0;
735 U32 gUl5gtfAllocAllocated = 0;
736 U32 gUl5gtfUeRbAllocDone = 0;
737 U32 gUl5gtfUeRmvFnlzZeroBo = 0;
738 U32 gUl5gtfUeFnlzReAdd = 0;
739 U32 gUl5gtfPdcchSend = 0;
740 U32 gUl5gtfRbAllocFail = 0;
741 U32 ul5gtfsidUlMarkUl = 0;
742 U32 ul5gtfsidDlSchdPass = 0;
743 U32 ul5gtfsidDlAlreadyMarkUl = 0;
744 U32 ul5gtfTotSchdCnt = 0;
745 #endif
746
747 /* CQI Offset Index to Beta CQI Offset value mapping,
748  * stored as parts per 1000. Reserved is set to 0.
749  * Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
750 PUBLIC U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
751    1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
752    3125, 3500, 4000, 5000, 6250};
753 PUBLIC U32 rgSchCmnBetaHqOffstTbl[16] =  {2000, 2500, 3125, 
754    4000, 5000, 6250, 8000,10000, 12625, 15875, 20000, 
755    31000, 50000,80000,126000,0};
756 PUBLIC U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000, 
757    2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
758    15875,20000,0,0,0};
759 PUBLIC S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
760
761 /* Include CRS REs while calculating Efficiency */
762 CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
763 CONSTANT PRIVATE U8 rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
764 U32 cfiSwitchCnt ;
765 U32 cfiIncr ;
766 U32 cfiDecr ;
767
768
769 #ifdef TFU_UPGRADE
770 PUBLIC S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
771 PUBLIC S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
772 #endif
773
774 typedef struct rgSchCmnDlUeDciFrmtOptns
775 {
776   TfuDciFormat spfcDciFrmt;   /* TM(Transmission Mode) specific DCI format.
777                                * Search space : UE Specific by C-RNTI only. */
778   U8           spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
779   TfuDciFormat prfrdDciFrmt;  /* Preferred DCI format among the available
780                                * options for TD (Transmit Diversity) */
781   U8           prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
782 }RgSchCmnDlUeDciFrmtOptns;
783 #ifndef LTE_ADV
784
785 /* DCI Format options for each Transmission Mode */
786 RgSchCmnDlUeDciFrmtOptns rgSchCmnDciFrmtOptns[7] = {
787    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
788    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
789    {TFU_DCI_FORMAT_2A,RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
790    {TFU_DCI_FORMAT_2, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
791    {TFU_DCI_FORMAT_1D,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
792    {TFU_DCI_FORMAT_1B,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
793    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2}
794 };
795
796 #else
797 /* DCI Format options for each Transmission Mode */
798 RgSchCmnDlUeDciFrmtOptns rgSchCmnDciFrmtOptns[9] = {
799    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, 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    {TFU_DCI_FORMAT_2A,RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
802    {TFU_DCI_FORMAT_2, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
803    {TFU_DCI_FORMAT_1D,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
804    {TFU_DCI_FORMAT_1B,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
805    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2}
806 };
807 #endif
808
809
810 typedef struct rgSchCmnDlImcsTbl
811 {
812   U8   modOdr; /* Modulation Order */
813   U8   iTbs;   /* ITBS */
814 }RgSchCmnDlImcsTbl[29];
815
816 CONSTANT struct rgSchCmnMult235Info
817 {
818    U8   match;    /* Closest number satisfying 2^a.3^b.5^c, with a bias
819                   * towards the smaller number */
820    U8   prvMatch; /* Closest number not greater than array index
821                   * satisfying 2^a.3^b.5^c */
822 } rgSchCmnMult235Tbl[110+1] = {
823    {0, 0},  /* dummy */
824    {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {6, 6}, {8, 8},
825    {9, 9}, {10, 10}, {10, 10}, {12, 12}, {12, 12}, {15, 12}, {15, 15},
826    {16, 16}, {16, 16}, {18, 18}, {18, 18}, {20, 20}, {20, 20}, {20, 20},
827    {24, 20}, {24, 24}, {25, 25}, {25, 25}, {27, 27}, {27, 27}, {30, 27},
828    {30, 30}, {30, 30}, {32, 32}, {32, 32}, {32, 32}, {36, 32}, {36, 36},
829    {36, 36}, {36, 36}, {40, 36}, {40, 40}, {40, 40}, {40, 40}, {45, 40},
830    {45, 40}, {45, 45}, {45, 45}, {48, 45}, {48, 48}, {48, 48}, {50, 50},
831    {50, 50}, {50, 50}, {54, 50}, {54, 54}, {54, 54}, {54, 54}, {54, 54},
832    {60, 54}, {60, 54}, {60, 60}, {60, 60}, {60, 60}, {64, 60}, {64, 64},
833    {64, 64}, {64, 64}, {64, 64}, {64, 64}, {72, 64}, {72, 64}, {72, 64},
834    {72, 72}, {72, 72}, {75, 72}, {75, 75}, {75, 75}, {75, 75}, {80, 75},
835    {80, 75}, {80, 80}, {81, 81}, {81, 81}, {81, 81}, {81, 81}, {81, 81},
836    {90, 81}, {90, 81}, {90, 81}, {90, 81}, {90, 90}, {90, 90}, {90, 90},
837    {90, 90}, {96, 90}, {96, 90}, {96, 96}, {96, 96}, {96, 96}, {100, 96},
838    {100, 100}, {100, 100}, {100, 100}, {100, 100}, {100, 100}, {108, 100},
839    {108, 100}, {108, 100}, {108, 108}, {108, 108}, {108, 108}
840 };
841
842 /* R8 Upgrade */
843 /* BI table from 36.321 Table 7.2.1 */
844 CONSTANT PRIVATE S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
845       0, 10, 20, 30,40,60,80,120,160,240,320,480,960};
846 PUBLIC RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
847  {     0,                0              },
848  {RGSCH_CMN_QM_CQI_1,RGSCH_CMN_UL_EFF_CQI_1 },
849  {RGSCH_CMN_QM_CQI_2,RGSCH_CMN_UL_EFF_CQI_2 },
850  {RGSCH_CMN_QM_CQI_3,RGSCH_CMN_UL_EFF_CQI_3 },
851  {RGSCH_CMN_QM_CQI_4,RGSCH_CMN_UL_EFF_CQI_4 },
852  {RGSCH_CMN_QM_CQI_5,RGSCH_CMN_UL_EFF_CQI_5 },
853  {RGSCH_CMN_QM_CQI_6,RGSCH_CMN_UL_EFF_CQI_6 },
854  {RGSCH_CMN_QM_CQI_7,RGSCH_CMN_UL_EFF_CQI_7 },
855  {RGSCH_CMN_QM_CQI_8,RGSCH_CMN_UL_EFF_CQI_8 },
856  {RGSCH_CMN_QM_CQI_9,RGSCH_CMN_UL_EFF_CQI_9 },
857  {RGSCH_CMN_QM_CQI_10,RGSCH_CMN_UL_EFF_CQI_10 },
858  {RGSCH_CMN_QM_CQI_11,RGSCH_CMN_UL_EFF_CQI_11 },
859  {RGSCH_CMN_QM_CQI_12,RGSCH_CMN_UL_EFF_CQI_12 },
860  {RGSCH_CMN_QM_CQI_13,RGSCH_CMN_UL_EFF_CQI_13 },
861  {RGSCH_CMN_QM_CQI_14,RGSCH_CMN_UL_EFF_CQI_14 },
862  {RGSCH_CMN_QM_CQI_15,RGSCH_CMN_UL_EFF_CQI_15 },
863 };
864
865 #ifdef RG_UNUSED
866 /* This table maps a (delta_offset * 2 + 2) to a (beta * 8)
867  * where beta is 10^-(delta_offset/10) rounded off to nearest 1/8
868  */
869 PRIVATE U16 rgSchCmnUlBeta8Tbl[29] = {
870    6, RG_SCH_CMN_UL_INVALID_BETA8, 8, 9, 10, 11, 13, 14, 16, 18, 20, 23,
871    25, 28, 32, RG_SCH_CMN_UL_INVALID_BETA8, 40, RG_SCH_CMN_UL_INVALID_BETA8,
872    50, RG_SCH_CMN_UL_INVALID_BETA8, 64, RG_SCH_CMN_UL_INVALID_BETA8, 80,
873    RG_SCH_CMN_UL_INVALID_BETA8, 101, RG_SCH_CMN_UL_INVALID_BETA8, 127,
874    RG_SCH_CMN_UL_INVALID_BETA8, 160
875 };
876 #endif
877
878 /* QCI to SVC priority mapping. Index specifies the Qci*/
879 PRIVATE U8 rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
880
881 /* The configuration is efficiency measured per 1024 REs.  */
882 /* The first element stands for when CQI is not known      */
883 /* This table is used to translate CQI to its corrospoding */
884 /* allocation parameters. These are currently from 36.213  */
885 /* Just this talbe needs to be edited for modifying the    */
886 /* the resource allocation behaviour                       */
887
888 /* ADD CQI to MCS mapping correction
889  * single dimensional array is replaced by 2 dimensions for different CFI*/
890 PRIVATE U16 rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
891     RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI2,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI3};
892
893 PRIVATE U16 rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
894     RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI2, RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI3};
895
896 /* This configuration determines the transalation of a UEs CQI to its    */
897 /* PDCCH coding efficiency. This may be edited based on the installation */
898 PRIVATE U8 rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
899
900 /* Indexed by [DciFrmt].
901  * Considering the following definition in determining the dciFrmt index.
902  * typedef enum
903 {
904    TFU_DCI_FORMAT_0,
905    TFU_DCI_FORMAT_1,
906    TFU_DCI_FORMAT_1A,
907    TFU_DCI_FORMAT_1B,
908    TFU_DCI_FORMAT_1C,
909    TFU_DCI_FORMAT_1D,
910    TFU_DCI_FORMAT_2,
911    TFU_DCI_FORMAT_2A,
912    TFU_DCI_FORMAT_3,
913    TFU_DCI_FORMAT_3A
914 } TfuDciFormat;
915 */
916 PRIVATE U16 rgSchCmnDciFrmtSizes[10];
917
918
919 PRIVATE U16 rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
920
921 #ifdef LTE_TDD
922
923 PUBLIC RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
924    {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},
925    {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},
926    {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},
927    {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},
928    {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},
929    {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},
930    {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}
931 };
932
933 /* SPS_INTG_FIX */
934 #ifdef LTEMAC_SPS
935 PUBLIC U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
936    /* 0 */ 6,
937    /* 1 */ 7,
938    /* 2 */ 8,
939    /* 3 */ 11,
940    /* 4 */ 12,
941    /* 5 */ 13,
942    /* 6 */ 7};
943
944 #endif
945
946
947 /* Special Subframes in OFDM symbols */
948 /* ccpu00134197-MOD-Correct the number of symbols */
949 PUBLIC RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
950         {3,  1, 1, 3,   1, 1},
951         {9,  1, 1, 8,   1, 1},
952         {10, 1, 1, 9,   1, 1},
953         {11, 1, 1, 10,  1, 1},
954         {12, 1, 1, 3,   2, 2},
955         {3,  2, 2, 8,   2, 2},
956         {9,  2, 2, 9,   2, 2},
957         {10, 2, 2, 0,   0, 0},
958         {11, 2, 2, 0,   0, 0}
959 };
960
961 /* PHICH 'm' value Table */
962 PUBLIC RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
963         {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
964         {0, 1, 0, 0, 1, 0, 1, 0, 0, 1},
965         {0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
966         {1, 0, 0, 0, 0, 0, 0, 0, 1, 1},
967         {0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
968         {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
969         {1, 1, 0, 0, 0, 1, 1, 0, 0, 1}
970 };
971
972 /* PHICH 'K' value Table */
973 PUBLIC RgSchTddKPhichTbl rgSchTddKPhichTbl = {
974         {0, 0, 4, 7, 6, 0, 0, 4, 7, 6},
975         {0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
976         {0, 0, 6, 0, 0, 0, 0, 6, 0, 0},
977         {0, 0, 6, 6, 6, 0, 0, 0, 0, 0},
978         {0, 0, 6, 6, 0, 0, 0, 0, 0, 0},
979         {0, 0, 6, 0, 0, 0, 0, 0, 0, 0},
980         {0, 0, 4, 6, 6, 0, 0, 4, 7, 0}
981 };
982
983 /* Uplink association index 'K' value Table */
984 PUBLIC RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
985         {0, 0, 6, 4, 0, 0, 0, 6, 4, 0},
986         {0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
987         {0, 0, 4, 4, 4, 0, 0, 0, 0, 0},
988         {0, 0, 4, 4, 0, 0, 0, 0, 0, 0},
989         {0, 0, 4, 0, 0, 0, 0, 0, 0, 0},
990         {0, 0, 7, 7, 5, 0, 0, 7, 7, 0}
991 };
992
993
994 /* PUSCH 'K' value Table */
995 PUBLIC RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
996         {4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
997         {0, 6, 0, 0, 4, 0, 6, 0, 0, 4},
998         {0, 0, 0, 4, 0, 0, 0, 0, 4, 0},
999         {4, 0, 0, 0, 0, 0, 0, 0, 4, 4},
1000         {0, 0, 0, 0, 0, 0, 0, 0, 4, 4},
1001         {0, 0, 0, 0, 0, 0, 0, 0, 4, 0},
1002         {7, 7, 0, 0, 0, 7, 7, 0, 0, 5}
1003 };
1004
1005 /* PDSCH to PUCCH Table for DL Harq Feed back. Based on the 
1006    Downlink association set index 'K' table */
1007 PUBLIC U8 rgSchTddPucchTxTbl[7][10] = {
1008         {4,  6,  0, 0, 0, 4, 6, 0, 0,  0},
1009         {7,  6,  0, 0, 4, 7, 6, 0, 0,  4},
1010         {7,  6,  0, 4, 8, 7, 6, 0, 4,  8},
1011         {4,  11, 0, 0, 0, 7, 6, 6, 5,  5},
1012         {12, 11, 0, 0, 8, 7, 7, 6, 5,  4},
1013         {12, 11, 0, 9, 8, 7, 6, 5, 4, 13},
1014         {7,  7,  0, 0, 0, 7, 7, 0, 0,  5}
1015 };
1016
1017 /* Table to fetch the next DL sf idx for applying the 
1018    new CFI. The next Dl sf Idx at which the new CFI 
1019    is applied is always the starting Sf of the next ACK/NACK
1020    Fdbk bundle. 
1021    
1022    Ex: In Cfg-2, sf4 and sf9 are the only subframes at which 
1023        a new ACK/NACK bundle of DL subframes can start
1024        
1025    D  S  U  D  D  D  S  U  D  D  D  S  U  D  D  D  S  U  D  D    
1026                4              9
1027    
1028    dlSf Array for Cfg-2:
1029    sfNum:  0  1  3  4  5  6  8  9  0  1   3  4  5  6  8  9 
1030    sfIdx:  0  1  2  3  4  5  6  7  8  9  10 11 12 12 14 15 
1031     
1032    If CFI changes at sf0,  nearest DL SF bundle >= 4 TTI is sf4
1033    So at sf4 the new CFI can be applied. To arrive at sf4 from
1034    sf0, the sfIdx has to be increased by 3 */  
1035                  
1036 PUBLIC U8 rgSchTddPdcchSfIncTbl[7][10] = {
1037  /* A/N Bundl: 0,1,5,6*/   {2,  1,  0, 0, 0, 2, 1,  0,  0,  0},
1038  /* A/N Bundl: 0,4,5,9*/   {2,  2,  0, 0, 3, 2, 2,  0,  0,  3},
1039  /* A/N Bundl: 4,9*/       {3,  6,  0, 5, 4, 3, 6,  0,  5,  4},
1040  /* A/N Bundl: 1,7,9*/     {4,  3,  0, 0, 0, 4, 5,  4,  6,  5},
1041  /* A/N Bundl: 0,6*/       {4,  3,  0, 0, 6, 5, 4,  7,  6,  5},
1042  /* A/N Bundl: 9*/         {8,  7,  0, 6, 5, 4, 12, 11, 10, 9},
1043  /* A/N Bundl: 0,1,5,6,9*/ {2,  1,  0, 0, 0, 2, 2,  0,  0,  3}
1044 };
1045    
1046
1047 /* combine compilation fixes */
1048 #ifdef LTEMAC_SPS
1049 /* subframe offset values to be used when twoIntervalsConfig is enabled in UL
1050  * SPS for a UE */
1051 PUBLIC RgSchTddSfOffTbl rgSchTddSfOffTbl = {
1052         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0},
1053         {0, 0, 1, -1,  0, 0, 0,  1, -1, 0},
1054         {0, 0, 5,  0,  0, 0, 0, -5,  0, 0},
1055         {0, 0, 1,  1, -2, 0, 0,  0,  0, 0},
1056         {0, 0, 1, -1,  0, 0, 0,  0,  0, 0},
1057         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0},
1058         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0}
1059 };
1060
1061
1062 /* Table to determine when uplink SPS configured grants should
1063  * explicitly be reserved in a subframe. When enries are same
1064  * as that of Msg3SubfrmTbl, indicates competition with msg3.
1065  * As of now, this is same as Msg3SubfrmTbl (leaving out uldlcfg 2),
1066  * except that all 255s are now zeros. */
1067 PUBLIC RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
1068         {0,    0,  0,  6,  8,  0, 0,  0,  6,  8},
1069         {0,    0,  6,  9,  0,  0, 0,  6,  9,  0},
1070         {0,    0,  10,  0,  0,  0, 0,  10,  0,  0},
1071         {0,   0,  0,  0,  8,  0, 7,  7,  14,  0},
1072         {0,   0,  0,  9,  0,  0, 7,  15,  0, 0},
1073         {0,   0,  10,  0,  0,  0, 16,  0, 0, 0},
1074         {0,    0,  0,  0,  8,  0, 0,  0,  9,  0}
1075 };
1076
1077 /* Inverse DL Assoc Set index Table */
1078 PUBLIC RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
1079        {4,  6,  0, 0, 0, 4, 6, 0, 0,  0},
1080        {7,  6,  0, 0, 4, 7, 6, 0, 0,  4},
1081        {7,  6,  0, 4, 8, 7, 6, 0, 4,  8},
1082        {4,  11, 0, 0, 0, 7, 6, 6, 5,  5},
1083        {12, 11, 0, 0, 8, 7, 7, 6, 5,  4},
1084        {12, 11, 0, 9, 8, 7, 6, 5, 4, 13},
1085        {7,  7,  0, 0, 0, 7, 7, 0, 0,  5}
1086 };
1087
1088 #endif /* (LTEMAC_SPS ) */
1089
1090 /* Number of Uplink subframes Table */
1091 PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
1092
1093 /* Downlink HARQ processes Table */
1094 PUBLIC RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
1095
1096 /* Uplink HARQ processes Table */
1097 PUBLIC RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
1098
1099 /* Downlink association index set 'K' value Table */
1100 PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
1101         { {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
1102
1103         { {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
1104
1105         { {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}} },
1106
1107         { {0, {0}}, {0, {0}}, {3, {7, 6, 11}}, {2, {6, 5}}, {2, {5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1108
1109         { {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}} },
1110
1111         { {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}} },
1112
1113         { {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {1, {5}}, {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {0, {0}} }
1114 };
1115
1116  /* ccpu132282-ADD-the table rgSchTddDlAscSetIdxKTbl is rearranged in 
1117   * decreasing order of Km, this is used to calculate the NCE used for 
1118   * calculating N1Pucch Resource for Harq*/
1119 PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
1120         { {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
1121
1122         { {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
1123
1124         { {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}} },
1125
1126         { {0, {0}}, {0, {0}}, {3, {11, 7, 6}}, {2, {6, 5}}, {2, {5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1127
1128         { {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}} },
1129
1130         { {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}} },
1131
1132         { {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {1, {5}}, {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {0, {0}} }
1133 };
1134
1135 /* Minimum number of Ack/Nack feeback information to be
1136    stored for each UL-DL configuration */
1137 PUBLIC RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
1138
1139 /* Uplink switch points and number of UL subframes Table */
1140 PUBLIC RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
1141      {2,3,3}, {2,2,2}, {2,1,1}, {1,3,0}, {1,2,0}, {1,1,0}, {2,3,2}
1142 };
1143
1144 /* Uplink switch points and number of DL subframes Table */
1145 PUBLIC RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
1146      {2,2,2}, {2,3,3}, {2,4,4}, {1,7,0}, {1,8,0}, {1,9,0}, {2,2,3}
1147 };
1148
1149 /* Number of UL subframes present before a particular subframe */
1150 PUBLIC RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
1151         {0, 0, 1, 2, 3, 3, 3, 4, 5, 6},
1152         {0, 0, 1, 2, 2, 2, 2, 3, 4, 4},
1153         {0, 0, 1, 1, 1, 1, 1, 2, 2, 2},
1154         {0, 0, 1, 2, 3, 3, 3, 3, 3, 3},
1155         {0, 0, 1, 2, 2, 2, 2, 2, 2, 2},
1156         {0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
1157         {0, 0, 1, 2, 3, 3, 3, 4, 5, 5}
1158 };
1159
1160 /* Number of DL subframes present till a particular subframe */
1161 PUBLIC RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
1162         {1, 2, 2, 2, 2, 3, 4, 4, 4, 4},
1163         {1, 2, 2, 2, 3, 4, 5, 5, 5, 6},
1164         {1, 2, 2, 3, 4, 5, 6, 6, 7, 8},
1165         {1, 2, 2, 2, 2, 3, 4, 5, 6, 7},
1166         {1, 2, 2, 2, 3, 4, 5, 6, 7, 8},
1167         {1, 2, 2, 3, 4, 5, 6, 7, 8, 9},
1168         {1, 2, 2, 2, 2, 3, 4, 4, 4, 5}
1169 };
1170
1171
1172 /* Nearest possible UL subframe Index from UL subframe
1173  * DL Index < UL Index */
1174 PUBLIC RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
1175         {0, 1, 1, 1, 1, 5, 6, 6, 6, 6},
1176         {0, 1, 1, 1, 4, 5, 6, 6, 6, 9},
1177         {0, 1, 1, 3, 4, 5, 6, 6, 8, 9},
1178         {0, 1, 1, 1, 1, 5, 6, 7, 8, 9},
1179         {0, 1, 1, 1, 4, 5, 6, 7, 8, 9},
1180         {0, 1, 1, 3, 4, 5, 6, 7, 8, 9},
1181         {0, 1, 1, 1, 1, 5, 6, 6, 6, 9}
1182 };
1183
1184 /* Nearest possible DL subframe Index from UL subframe
1185  * DL Index > UL Index
1186  * 10 represents Next SFN low DL Idx */
1187 PUBLIC RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
1188         {0, 1, 5, 5, 5, 5, 6, 10, 10, 10},
1189         {0, 1, 4, 4, 4, 5, 6,  9,  9,  9},
1190         {0, 1, 3, 3, 4, 5, 6,  8,  8,  9},
1191         {0, 1, 5, 5, 5, 5, 6,  7,  8,  9},
1192         {0, 1, 4, 4, 4, 5, 6,  7,  8,  9},
1193         {0, 1, 3, 3, 4, 5, 6,  7,  8,  9},
1194         {0, 1, 5, 5, 5, 5, 6,  9,  9,  9}
1195 };
1196
1197 /* RACH Message3 related information */
1198 PUBLIC RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
1199         {7,      6,  255,  255,  255,  7,   6,  255,  255,  255},
1200         {7,      6,  255,  255,    8,  7,   6,  255,  255,    8},
1201         {7,      6,  255,  9,      8,  7,   6,  255,    9,    8},
1202         {12,    11,  255,  255,  255,  7,   6,    6,    6,   13},
1203         {12,    11,  255,  255,    8,  7,   6,    6,   14,   13},
1204         {12,    11,  255,    9,    8,  7,   6,   15,   14,   13},
1205         {7,      6,  255,  255,  255,  7,   6,  255,  255,    8}
1206 };
1207
1208 /* ccpu00132341-DEL Removed rgSchTddRlsDlSubfrmTbl and used Kset table for 
1209  * releasing DL HARQs */
1210
1211 /* DwPTS Scheduling Changes Start */
1212 /* Provides the number of Cell Reference Signals in DwPTS
1213  * region per RB */
1214 PRIVATE U8  rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
1215            {4, 8,  16}, /* Spl Sf cfg 1,2,3,6,7,8 */
1216            {6, 12, 20}, /* Spl Sf cfg 4 */
1217 };
1218
1219 PRIVATE S8  rgSchCmnSplSfDeltaItbs[9] = RG_SCH_DWPTS_ITBS_ADJ;
1220 /* DwPTS Scheduling Changes End */
1221 #endif
1222
1223
1224 PRIVATE U32 rgSchCmnBsrTbl[64] = {
1225    0, 10, 12, 14, 17, 19, 22, 26,
1226    31, 36, 42, 49, 57, 67, 78, 91,
1227    107, 125, 146, 171, 200, 234, 274, 321,
1228    376, 440, 515, 603, 706, 826, 967, 1132,
1229    1326, 1552, 1817, 2127, 2490, 2915, 3413, 3995,
1230    4677, 5476, 6411, 7505, 8787, 10287, 12043, 14099,
1231    16507, 19325, 22624, 26487, 31009, 36304, 42502, 49759,
1232    58255, 68201, 79846, 93479, 109439, 128125, 150000, 220000
1233 };
1234
1235 PRIVATE U32 rgSchCmnExtBsrTbl[64] = {
1236    0, 10, 13, 16, 19, 23, 29, 35,
1237    43, 53, 65, 80, 98, 120, 147, 181,
1238    223, 274, 337, 414, 509, 625, 769, 945,
1239    1162, 1429, 1757, 2161, 2657, 3267, 4017, 4940,
1240    6074, 7469, 9185, 11294, 13888, 17077, 20999, 25822,
1241    31752, 39045, 48012, 59039, 72598, 89272, 109774, 134986,
1242    165989, 204111, 250990, 308634, 379519, 466683, 573866, 705666,
1243    867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
1244 };
1245
1246
1247 PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
1248
1249 PUBLIC U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
1250
1251 PUBLIC RgSchTbSzTbl rgTbSzTbl = {
1252  {
1253    {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},
1254    {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},
1255    {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},
1256    {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},
1257    {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},
1258    {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},
1259    {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},
1260    {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},
1261    {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},
1262    {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},
1263    {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},
1264    {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},
1265    {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},
1266    {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},
1267    {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},
1268    {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},
1269    {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},
1270    {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},
1271    {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},
1272    {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},
1273    {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},
1274    {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},
1275    {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},
1276    {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},
1277    {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},
1278    {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},
1279    {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}
1280  },
1281  {
1282    {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},
1283    {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},
1284    {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},
1285    {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},
1286    {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},
1287    {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},
1288    {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},
1289    {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},
1290    {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},
1291    {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},
1292    {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},
1293    {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},
1294    {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},
1295    {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},
1296    {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},
1297    {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},
1298    {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},
1299    {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},
1300    {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},
1301    {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},
1302    {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},
1303    {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},
1304    {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},
1305    {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},
1306    {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},
1307    {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},
1308    {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}
1309  }
1310 };
1311 RgSchUlIMcsTbl rgUlIMcsTbl = {
1312    {2, 0}, {2, 1}, {2, 2}, {2, 3}, {2, 4}, {2, 5},
1313    {2, 6}, {2, 7}, {2, 8}, {2, 9}, {2, 10},
1314    {4, 10}, {4, 11}, {4, 12}, {4, 13}, {4, 14},
1315    {4, 15}, {4, 16}, {4, 17}, {4, 18}, {4, 19},
1316    {6, 19}, {6, 20}, {6, 21}, {6, 22}, {6, 23},
1317    {6, 24}, {6, 25}, {6, 26}
1318 };
1319 RgSchUeCatTbl rgUeCatTbl = {
1320    /*Column1:Maximum number of bits of an UL-SCH 
1321              transport block transmitted within a TTI
1322              - maxUlBits
1323      Column2:Maximum number of bits of a DLSCH
1324              transport block received within a TTI 
1325              - maxDlBits
1326      Column3:Total number of soft channel bits 
1327              - maxSftChBits
1328      Column4:Support for 64QAM in UL 
1329              - ul64qamSup
1330      Column5:Maximum number of DL-SCH transport
1331              block bits received within a TTI
1332              - maxDlTbBits
1333      Column6:Maximum number of supported layers for 
1334              spatial multiplexing in DL 
1335              - maxTxLyrs*/
1336    {5160,  {10296,0},      250368,  FALSE, 10296,  1},
1337    {25456, {51024,0},      1237248, FALSE, 51024,  2},
1338    {51024, {75376,0},      1237248, FALSE, 102048, 2},
1339    {51024, {75376,0},      1827072, FALSE, 150752, 2},
1340    {75376, {149776,0},     3667200, TRUE,  299552, 4},
1341    {51024, {75376,149776}, 3654144, FALSE, 301504,  4},
1342    {51024, {75376,149776}, 3654144, FALSE, 301504,  4},
1343    {149776,{299856,0},     35982720,TRUE,  2998560, 8}
1344 };
1345
1346 /* [ccpu00138532]-ADD-The below table stores the min HARQ RTT time
1347    in Downlink for TDD and FDD. Indices 0 to 6 map to tdd UL DL config 0-6. 
1348    Index 7 map to FDD */    
1349 U8 rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
1350 /* Number of CFI Switchover Index is equals to 7 TDD Indexes + 1 FDD index */
1351 U8 rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
1352
1353 /* EffTbl is calculated for single layer and two layers.
1354   * CqiToTbs is calculated for single layer and two layers */
1355 RgSchCmnTbSzEff rgSchCmnNorCfi1Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi2Eff[RGSCH_MAX_NUM_LYR_PERCW];
1356 RgSchCmnTbSzEff rgSchCmnNorCfi3Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi4Eff[RGSCH_MAX_NUM_LYR_PERCW];
1357 /* New variable to store UL effiency values for normal and extended CP*/
1358 RgSchCmnTbSzEff rgSchCmnNorUlEff[1],rgSchCmnExtUlEff[1];
1359 RgSchCmnCqiToTbs rgSchCmnNorCfi1CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi2CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1360 RgSchCmnCqiToTbs rgSchCmnNorCfi3CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi4CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1361 RgSchCmnCqiToTbs *rgSchCmnCqiToTbs[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_CFI];
1362 RgSchCmnTbSzEff rgSchCmnExtCfi1Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi2Eff[RGSCH_MAX_NUM_LYR_PERCW];
1363 RgSchCmnTbSzEff rgSchCmnExtCfi3Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi4Eff[RGSCH_MAX_NUM_LYR_PERCW];
1364 RgSchCmnCqiToTbs rgSchCmnExtCfi1CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi2CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1365 RgSchCmnCqiToTbs rgSchCmnExtCfi3CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi4CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1366 /* Include CRS REs while calculating Efficiency */
1367 RgSchCmnTbSzEff *rgSchCmnEffTbl[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_ANT_CONF][RG_SCH_CMN_MAX_CFI];
1368 RgSchCmnTbSzEff *rgSchCmnUlEffTbl[RG_SCH_CMN_MAX_CP];
1369 #ifdef LTE_TDD
1370 RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3, 1};
1371 #else
1372 /* Added matrix 'rgRaPrmblToRaFrmTbl'for computation of RA sub-frames from RA preamble */
1373 RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3};
1374 #endif
1375
1376 EXTERN  RgUlSchdInits        rgSchUlSchdInits;
1377 EXTERN  RgDlSchdInits        rgSchDlSchdInits;
1378 EXTERN  RgDlfsSchdInits      rgSchDlfsSchdInits;
1379 #ifdef EMTC_ENABLE
1380 EXTERN  RgEmtcUlSchdInits        rgSchEmtcUlSchdInits;
1381 EXTERN  RgEmtcDlSchdInits        rgSchEmtcDlSchdInits;
1382 #endif
1383
1384 /* RACHO : start */
1385 PRIVATE S16 rgSCHCmnUeIdleExdThrsld ARGS((
1386 RgSchCellCb     *cell,
1387 RgSchUeCb       *ue
1388 ));
1389 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe ARGS((
1390 RgSchCellCb           *cell,
1391 U16                   rapId
1392 ));
1393 PRIVATE Void rgSCHCmnDelDedPreamble ARGS((
1394 RgSchCellCb           *cell,
1395 U8                    preambleId
1396 ));
1397 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe ARGS((
1398 RgSchCellCb           *cell,
1399 U16                   rapId,
1400 CmLteTimingInfo       timingInfo
1401 ));
1402 PRIVATE Void rgSCHCmnDelRachInfo ARGS((
1403 RgSchCellCb  *cell,
1404 RgSchUeCb    *ue
1405 ));
1406 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe ARGS((
1407 RgSchCellCb           *cell,
1408 RgSchUlSf             *sf,
1409 RgSchUeCb             *ue,
1410 U8                    maxRb
1411 ));
1412 PRIVATE Void rgSCHCmnHdlHoPo ARGS((
1413 RgSchCellCb           *cell,
1414 CmLListCp             *raRspLst,
1415 RgSchRaReqInfo        *raReq
1416 ));
1417 PRIVATE Void rgSCHCmnAllocPoHoGrnt ARGS((
1418 RgSchCellCb           *cell,
1419 CmLListCp             *raRspLst,
1420 RgSchUeCb             *ue,
1421 RgSchRaReqInfo        *raReq
1422 ));
1423 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf ARGS((
1424 RgSchCellCb *cell,
1425 RgSchUeCb   *ue,
1426 RgSchPdcch  *pdcc,
1427 U8          rapId,
1428 U8          prachMskIdx
1429 ));
1430 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ ARGS((
1431 RgSchCellCb                *cell,
1432 RgSchUeCb                  *ue
1433 ));
1434 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ ARGS((
1435 RgSchCellCb                *cell,
1436 RgSchUeCb                  *ue
1437 ));
1438 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx ARGS((
1439 RgSchCellCb  *cell
1440 ));
1441 PRIVATE Void rgSCHCmnUpdRachParam ARGS((
1442 RgSchCellCb  *cell
1443 ));
1444 PRIVATE S16 rgSCHCmnAllocPOParam ARGS((
1445 RgSchCellCb  *cell,
1446 RgSchDlSf    *dlSf,
1447 RgSchUeCb    *ue,
1448 RgSchPdcch   **pdcch,
1449 U8           *rapId,
1450 U8           *prachMskIdx
1451 ));
1452 PRIVATE Void rgSCHCmnGenPdcchOrder ARGS((
1453 RgSchCellCb  *cell,
1454 RgSchDlSf    *dlSf
1455 ));
1456 PRIVATE Void rgSCHCmnCfgRachDedPrm ARGS((
1457 RgSchCellCb   *cell
1458 ));
1459 /* RACHO : end */
1460
1461 PRIVATE Void rgSCHCmnHdlUlInactUes ARGS((
1462 RgSchCellCb  *cell
1463 ));
1464 PRIVATE Void rgSCHCmnHdlDlInactUes ARGS((
1465 RgSchCellCb  *cell
1466 ));
1467 PRIVATE Void rgSCHCmnUlInit ARGS((Void
1468 ));
1469 PRIVATE Void rgSCHCmnDlInit ARGS((Void
1470 ));
1471 PRIVATE Void rgSCHCmnInitDlRbAllocInfo ARGS((
1472 RgSchCmnDlRbAllocInfo  *allocInfo
1473 ));
1474 PRIVATE Void rgSCHCmnUpdUlCompEffBsr ARGS((
1475 RgSchUeCb *ue
1476 ));
1477 #if RG_UNUSED
1478 PRIVATE Void rgSCHCmnUlSetAllUnSched  ARGS((
1479 RgSchCmnUlRbAllocInfo *allocInfo
1480 ));
1481 PRIVATE Void rgSCHCmnUlUpdSf ARGS((
1482          RgSchCellCb           *cell,
1483          RgSchCmnUlRbAllocInfo *allocInfo,
1484          RgSchUlSf     *sf
1485          ));
1486 PRIVATE Void rgSCHCmnUlHndlAllocRetx ARGS((
1487          RgSchCellCb           *cell,
1488          RgSchCmnUlRbAllocInfo *allocInfo,
1489          RgSchUlSf     *sf,
1490          RgSchUlAlloc  *alloc
1491          ));
1492 #endif
1493 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch ARGS((
1494 RgSchCellCb  *cell,
1495 RgSchDlSf    *dlSf
1496 ));
1497 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch ARGS((
1498 RgSchCellCb  *cell,
1499 RgSchUlSf    *ulSf
1500 ));
1501 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ ARGS((
1502 RgSchCellCb     *cell,
1503 RgSchUeCb       *ue
1504 ));
1505 PRIVATE S16 rgSCHCmnTmrExpiry ARGS((
1506 PTR cb,               /* Pointer to timer control block */
1507 S16 tmrEvnt           /* Timer Event */
1508 ));
1509 PRIVATE S16 rgSCHCmnTmrProc ARGS((
1510 RgSchCellCb *cell
1511 ));
1512 PRIVATE Void rgSCHCmnAddUeToRefreshQ ARGS((
1513 RgSchCellCb     *cell,
1514 RgSchUeCb       *ue,
1515 U32             wait
1516 ));
1517 PRIVATE Void rgSCHCmnDlCcchRetx ARGS((
1518 RgSchCellCb             *cell,
1519 RgSchCmnDlRbAllocInfo   *allocInfo
1520 ));
1521 PRIVATE Void rgSCHCmnUpdUeMimoInfo ARGS((
1522 RgrUeCfg     *ueCfg,
1523 RgSchCmnDlUe *ueDl,
1524 RgSchCellCb  *cell,
1525 RgSchCmnCell *cellSchd
1526 ));
1527 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo ARGS((
1528 RgSchCellCb   *cell,
1529 RgSchUeCb     *ue,
1530 RgSchCmnUlUe  *ueUl,
1531 RgSchCmnUe    *ueSchCmn,
1532 RgSchCmnCell  *cellSchd,
1533 Bool          isEcp 
1534 ));
1535 #ifdef RGR_V1
1536 PRIVATE Void rgSCHCmnDlCcchSduRetx ARGS((
1537 RgSchCellCb             *cell,
1538 RgSchCmnDlRbAllocInfo   *allocInfo
1539 ));
1540 PRIVATE Void rgSCHCmnDlCcchSduTx ARGS((
1541 RgSchCellCb             *cell,
1542 RgSchCmnDlRbAllocInfo   *allocInfo
1543 ));
1544 PRIVATE S16 rgSCHCmnCcchSduAlloc ARGS((
1545 RgSchCellCb                *cell,
1546 RgSchUeCb                  *ueCb,
1547 RgSchCmnDlRbAllocInfo      *allocInfo
1548 ));
1549 PRIVATE S16 rgSCHCmnCcchSduDedAlloc ARGS((
1550 RgSchCellCb                *cell,
1551 RgSchUeCb                  *ueCb
1552 ));
1553 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc ARGS((
1554 RgSchCellCb           *cell,
1555 RgSchUeCb             *ueCb,
1556 RgSchDlSf             *dlSf
1557 ));
1558 #endif
1559 PRIVATE Void rgSCHCmnInitVars ARGS((
1560          RgSchCellCb *cell
1561          ));
1562
1563 /*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now PUBLIC */
1564 PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
1565          RgSchCellCb           *cell,
1566          RgSchUlSf             *sf,
1567          U32                   count,
1568          CmLListCp             *reqLst,
1569          CmLListCp             *schdLst,
1570          CmLListCp             *nonSchdLst,
1571          Bool                  isNewTx
1572          ));
1573 PRIVATE S16 rgSCHCmnUlRbAllocForUe ARGS((
1574          RgSchCellCb           *cell,
1575          RgSchUlSf             *sf,
1576          RgSchUeCb             *ue,
1577          U8                    maxRb,
1578          RgSchUlHole           *hole
1579          ));
1580 PRIVATE Void rgSCHCmnMsg3GrntReq ARGS((
1581          RgSchCellCb     *cell,
1582          CmLteRnti       rnti,
1583          Bool            preamGrpA,
1584          RgSchUlHqProcCb *hqProc,
1585          RgSchUlAlloc    **ulAllocRef,
1586          U8              *hqProcIdRef
1587          ));
1588 PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
1589          RgSchCmnUlCell  *cellUl,
1590          RgSchUlAlloc    *alloc,
1591          U8               idx
1592          ));
1593
1594 PRIVATE Void rgSCHCmnDlCcchRarAlloc ARGS((
1595 RgSchCellCb             *cell
1596 ));
1597 PRIVATE Void rgSCHCmnDlCcchTx ARGS((
1598 RgSchCellCb             *cell,
1599 RgSchCmnDlRbAllocInfo   *allocInfo
1600 ));
1601 PRIVATE Void rgSCHCmnDlBcchPcch ARGS((
1602 RgSchCellCb             *cell,
1603 RgSchCmnDlRbAllocInfo   *allocInfo,
1604 RgInfSfAlloc            *subfrmAlloc
1605 ));
1606 PUBLIC Bool rgSCHCmnChkInWin ARGS((
1607 CmLteTimingInfo   frm,
1608 CmLteTimingInfo   start,
1609 CmLteTimingInfo   end
1610 ));
1611 PUBLIC Bool rgSCHCmnChkPastWin ARGS((
1612 CmLteTimingInfo   frm,
1613 CmLteTimingInfo   end
1614 ));
1615 PRIVATE Void rgSCHCmnClcAlloc ARGS((
1616 RgSchCellCb             *cell,
1617 RgSchDlSf               *sf,
1618 RgSchClcDlLcCb          *lch,
1619 U16                     rnti,
1620 RgSchCmnDlRbAllocInfo   *allocInfo
1621 ));
1622 #ifndef LTEMAC_SPS
1623 PRIVATE Void rgSCHCmnClcRbAlloc ARGS((
1624 RgSchCellCb             *cell,
1625 U32                     bo,
1626 U8                      cqi,
1627 U8                      *rb,
1628 U32                     *tbs,
1629 U8                      *mcs,
1630 RgSchDlSf               *sf 
1631 ));
1632 #endif
1633
1634 PRIVATE S16 rgSCHCmnMsg4Alloc ARGS((
1635 RgSchCellCb                *cell,
1636 RgSchRaCb                  *raCb,
1637 RgSchCmnDlRbAllocInfo      *allocInfo
1638 ));
1639 PRIVATE S16 rgSCHCmnMsg4DedAlloc ARGS((
1640 RgSchCellCb                *cell,
1641 RgSchRaCb                  *raCb
1642 ));
1643 PRIVATE Void rgSCHCmnDlRaRsp ARGS((
1644 RgSchCellCb                *cell,
1645 RgSchCmnDlRbAllocInfo      *allocInfo
1646 ));
1647 PRIVATE S16 rgSCHCmnRaRspAlloc ARGS((
1648 RgSchCellCb             *cell,
1649 RgSchDlSf               *subFrm,
1650 U16                     rntiIdx,
1651 U16                     rarnti,
1652 U8                      noRaRnti,
1653 RgSchCmnDlRbAllocInfo   *allocInfo
1654 ));
1655 PRIVATE Void rgSCHCmnUlUeDelAllocs ARGS((
1656 RgSchCellCb  *cell,
1657 RgSchUeCb   *ue
1658 ));
1659 PRIVATE Void rgSCHCmnDlSetUeAllocLmt ARGS((
1660 RgSchCellCb   *cell,
1661 RgSchCmnDlUe  *ueDl,
1662 Bool          isEmtcUe
1663 ));
1664 PRIVATE S16 rgSCHCmnDlRgrCellCfg ARGS((
1665 RgSchCellCb    *cell,
1666 RgrCellCfg     *cfg,
1667 RgSchErrInfo   *err
1668 ));
1669 PRIVATE Void rgSCHCmnUlAdapRetx ARGS((
1670 RgSchUlAlloc    *alloc,
1671 RgSchUlHqProcCb *proc
1672 ));
1673 PRIVATE Void rgSCHCmnUlUpdAllocRetx ARGS((
1674 RgSchCellCb    *cell,
1675 RgSchUlAlloc   *alloc
1676 ));
1677 PRIVATE Void rgSCHCmnUlSfReTxAllocs ARGS((
1678 RgSchCellCb *cell,
1679 RgSchUlSf   *sf
1680 ));
1681 /* Fix: syed Adaptive Msg3 Retx crash. */
1682 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
1683 RgSchCellCb *cell,
1684 RgSchUlSf   *sf
1685 ));
1686
1687 #ifdef TFU_UPGRADE
1688 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
1689 ((
1690 RgSchCellCb *cell,
1691 RgSchUeCb    *ue,
1692 RgrUeRecfg   *ueRecfg,
1693 U8 numTxPorts
1694 ));
1695 #else
1696 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
1697 ((
1698 RgSchCellCb *cell,
1699 RgSchUeCb    *ue,
1700 RgrUeRecfg   *ueRecfg
1701 ));
1702 #endif
1703
1704
1705 /*
1706  * DL RB allocation specific functions
1707  */
1708
1709 PRIVATE Void rgSCHCmnDlRbAlloc ARGS((
1710 RgSchCellCb           *cell,
1711 RgSchCmnDlRbAllocInfo *allocInfo
1712 ));
1713 PRIVATE Void rgSCHCmnNonDlfsRbAlloc ARGS((
1714 RgSchCellCb           *cell,
1715 RgSchCmnDlRbAllocInfo *allocInfo
1716 ));
1717 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc ARGS((
1718 RgSchCellCb           *cell,
1719 RgSchDlRbAlloc        *cmnAllocInfo));
1720
1721 #ifndef LTE_TDD
1722 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj ARGS((
1723 RgSchCellCb           *cell,
1724 RgSchDlRbAlloc        *cmnAllocInfo,
1725 U8                    pbchSsRsSym,
1726 Bool                  isBcchPcch
1727 ));
1728 /* Added function to adjust TBSize*/
1729 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj ARGS((
1730 RgSchDlRbAlloc        *allocInfo,
1731 U8                    numOvrlapgPbchRb,
1732 U8                    pbchSsRsSym,
1733 U8                    idx,
1734 U32                   bytesReq
1735 ));
1736
1737 /* Added function to find num of overlapping PBCH rb*/
1738 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs ARGS((
1739 RgSchCellCb           *cell,
1740 RgSchDlSf             *dlSf,
1741 RgSchDlRbAlloc        *allocInfo,
1742 U8                    *numOvrlapgPbchRb
1743 ));
1744
1745 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl ARGS((
1746 RgSchCellCb           *cell,
1747 RgSchDlSf             *dlSf,
1748 RgSchDlRbAlloc        *allocInfo
1749 ));
1750 #ifdef DEBUGP
1751 PRIVATE Void rgSCHCmnFindCodeRate ARGS((
1752 RgSchCellCb           *cell,
1753 RgSchDlSf             *dlSf,
1754 RgSchDlRbAlloc        *allocInfo,
1755 U8                    idx
1756 ));
1757 #endif
1758 #endif
1759 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
1760 RgSchCellCb           *cell,
1761 RgSchCmnMsg4RbAlloc   *msg4AllocInfo,
1762 U8                    isRetx
1763 ));
1764 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc ARGS((
1765 RgSchCellCb           *cell,
1766 RgSchRaCb             *raCb,
1767 RgSchDlSf             *dlSf
1768 ));
1769
1770 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc ARGS((
1771 RgSchCellCb           *cell,
1772 RgSchUeCb             *ue,
1773 RgSchDlSf             *dlSf,
1774 U8                    *isDlBwAvail
1775 ));
1776 #ifndef LTEMAC_SPS
1777 PRIVATE U32 rgSCHCmnCalcRiv ARGS(( U8 bw,
1778          U8           rbStart,
1779          U8           numRb));
1780 #endif
1781
1782 #ifdef LTE_TDD
1783 PRIVATE Void rgSCHCmnUpdHqAndDai ARGS((
1784 RgSchDlHqProcCb   *hqP,
1785 RgSchDlSf         *subFrm,
1786 RgSchDlHqTbCb     *tbCb,
1787 U8                tbAllocIdx
1788 ));
1789 PRIVATE S16 rgSCHCmnUlCalcAvailBw ARGS((
1790 RgSchCellCb *cell,
1791 RgrCellCfg  *cellCfg,
1792 U8          cfi,
1793 U8          *rbStartRef,
1794 U8          *bwAvailRef
1795 ));
1796 PRIVATE S16 rgSCHCmnDlKdashUlAscInit ARGS((
1797 RgSchCellCb *cell
1798 ));
1799 PRIVATE S16 rgSCHCmnDlANFdbkInit ARGS((
1800 RgSchCellCb *cell
1801 ));
1802 PRIVATE S16 rgSCHCmnDlNpValInit ARGS((
1803 RgSchCellCb *cell
1804 ));
1805 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst ARGS((
1806 RgSchCellCb *cell
1807 ));
1808 PRIVATE S16 rgSCHCmnDlCpyRachInfo ARGS((
1809 RgSchCellCb        *cell,
1810 RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
1811 U8                 raArrSz
1812 ));
1813 PRIVATE S16 rgSCHCmnDlRachInfoInit ARGS((
1814 RgSchCellCb *cell
1815 ));
1816 PRIVATE S16 rgSCHCmnDlPhichOffsetInit ARGS((
1817 RgSchCellCb *cell
1818 ));
1819 #endif
1820 #ifdef TFU_UPGRADE
1821 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt ARGS
1822 ((
1823  RgSchCellCb          *cell,
1824  RgSchUeCb            *ue,
1825  U8                          wideCqi
1826  ));
1827  PRIVATE RgSchCmnRank rgSCHCmnComputeRank ARGS
1828 ((
1829  RgrTxMode    txMode,
1830  U32          *pmiBitMap,
1831  U8           numTxPorts
1832  ));
1833
1834  PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3 ARGS
1835 ((
1836  U32 *pmiBitMap
1837  ));
1838
1839   PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3 ARGS
1840 ((
1841  U32 *pmiBitMap
1842  ));
1843
1844   PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4 ARGS
1845 ((
1846  U32 *pmiBitMap
1847  ));
1848
1849   PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4 ARGS
1850 ((
1851  U32 *pmiBitMap
1852  ));
1853
1854  PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr ARGS
1855 ((
1856  RgSchCellCb        *cell,
1857  TfuSrsRpt        *srsRpt
1858  ));
1859 #endif
1860
1861 /* comcodsepa : start */
1862 \f
1863 /**
1864  * @brief This function computes efficiency and stores in a table.
1865  *
1866  * @details
1867  *
1868  *     Function: rgSCHCmnCompEff
1869  *     Purpose:  this function computes the efficiency as number of
1870  *               bytes per 1024 symbols. The CFI table is also filled
1871  *               with the same information such that comparison is valid
1872  *
1873  *     Invoked by: Scheduler
1874  *
1875  *  @param[in]  U8            noPdcchSym
1876  *  @param[in]  U8            cpType
1877  *  @param[in]  U8            txAntIdx
1878  *  @param[in]  RgSchCmnTbSzEff* effTbl
1879  *  @return  Void
1880  *
1881  **/
1882 #ifdef ANSI
1883 PRIVATE Void rgSCHCmnCompEff
1884 (
1885 U8                    noPdcchSym,
1886 U8                    cpType,
1887 U8                    txAntIdx,
1888 RgSchCmnTbSzEff       *effTbl
1889 )
1890 #else
1891 PRIVATE Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
1892 U8                    noPdcchSym;
1893 U8                    cpType;
1894 U8                    txAntIdx;
1895 RgSchCmnTbSzEff       *effTbl;
1896 #endif
1897 {
1898    U8               noResPerRb;
1899    U8               noSymPerRb;
1900    U8               resOfCrs; /* Effective REs occupied by CRS */
1901    U8               i, j;
1902
1903    TRC2(rgSCHCmnCompEff);
1904
1905    switch (cpType)
1906    {
1907       case RG_SCH_CMN_NOR_CP:
1908          noSymPerRb = 14;
1909          break;
1910       case RG_SCH_CMN_EXT_CP:
1911          noSymPerRb = 12;
1912          break;
1913       default:
1914          /* Generate a log error. This case should never be executed */
1915          RETVOID;
1916    }
1917
1918    /* Depending on the Tx Antenna Index, deduct the
1919     * Resource elements for the CRS */
1920    switch (txAntIdx)
1921    {
1922       case 0:
1923          resOfCrs = RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT;
1924          break;
1925       case 1:
1926          resOfCrs = RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT;
1927          break;
1928       case 2:
1929          resOfCrs = RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT;
1930          break;
1931       default:
1932          /* Generate a log error. This case should never be executed */
1933          RETVOID;
1934    }
1935    noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
1936    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
1937    {
1938       (*effTbl)[i] = 0;
1939       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
1940       {
1941          /* This line computes the coding efficiency per 1024 REs */
1942          (*effTbl)[i] += (rgTbSzTbl[0][i][j] * 1024) / (noResPerRb * (j+1));
1943       }
1944       (*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
1945    }
1946    RETVOID;
1947 }
1948 /**
1949  * @brief This function computes efficiency and stores in a table.
1950  *
1951  * @details
1952  *
1953  *     Function: rgSCHCmnCompUlEff
1954  *     Purpose:  this function computes the efficiency as number of
1955  *               bytes per 1024 symbols. The CFI table is also filled
1956  *               with the same information such that comparison is valid
1957  *
1958  *     Invoked by: Scheduler
1959  *
1960  *  @param[in]  U8            noUlRsSym
1961  *  @param[in]  U8            cpType
1962  *  @param[in]  U8            txAntIdx
1963  *  @param[in]  RgSchCmnTbSzEff* effTbl
1964  *  @return  Void
1965  *
1966  **/
1967 #ifdef ANSI
1968 PRIVATE Void rgSCHCmnCompUlEff
1969 (
1970 U8                    noUlRsSym,
1971 U8                    cpType,
1972 RgSchCmnTbSzEff       *effTbl
1973 )
1974 #else
1975 PRIVATE Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
1976 U8                    noUlRsSym;
1977 U8                    cpType;
1978 RgSchCmnTbSzEff       *effTbl;
1979 #endif
1980 {
1981    U8               noResPerRb;
1982    U8               noSymPerRb;
1983    U8               i, j;
1984
1985    TRC2(rgSCHCmnCompUlEff);
1986
1987    switch (cpType)
1988    {
1989       case RG_SCH_CMN_NOR_CP:
1990          noSymPerRb = 14;
1991          break;
1992       case RG_SCH_CMN_EXT_CP:
1993          noSymPerRb = 12;
1994          break;
1995       default:
1996          /* Generate a log error. This case should never be executed */
1997          RETVOID;
1998    }
1999
2000    noResPerRb = ((noSymPerRb - noUlRsSym) * RB_SCH_CMN_NUM_SCS_PER_RB);
2001    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
2002    {
2003       (*effTbl)[i] = 0;
2004       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
2005       {
2006          /* This line computes the coding efficiency per 1024 REs */
2007          (*effTbl)[i] += (rgTbSzTbl[0][i][j] * 1024) / (noResPerRb * (j+1));
2008       }
2009       (*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
2010    }
2011    RETVOID;
2012 }
2013
2014 /**
2015  * @brief This function computes efficiency for 2 layers and stores in a table.
2016  *
2017  * @details
2018  *
2019  *     Function: rgSCHCmn2LyrCompEff
2020  *     Purpose:  this function computes the efficiency as number of
2021  *               bytes per 1024 symbols. The CFI table is also filled
2022  *               with the same information such that comparison is valid
2023  *
2024  *     Invoked by: Scheduler
2025  *
2026  *  @param[in]  U8            noPdcchSym
2027  *  @param[in]  U8            cpType
2028  *  @param[in]  U8            txAntIdx
2029  *  @param[in]  RgSchCmnTbSzEff* effTbl2Lyr
2030  *  @return  Void
2031  *
2032  **/
2033 #ifdef ANSI
2034 PRIVATE Void rgSCHCmn2LyrCompEff
2035 (
2036 U8                    noPdcchSym,
2037 U8                    cpType,
2038 U8                    txAntIdx,
2039 RgSchCmnTbSzEff       *effTbl2Lyr
2040 )
2041 #else
2042 PRIVATE Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
2043 U8                    noPdcchSym;
2044 U8                    cpType;
2045 U8                    txAntIdx;
2046 RgSchCmnTbSzEff       *effTbl2Lyr;
2047 #endif
2048 {
2049    U8               noResPerRb;
2050    U8               noSymPerRb;
2051    U8               resOfCrs; /* Effective REs occupied by CRS */
2052    U8               i, j;
2053
2054    TRC2(rgSCHCmn2LyrCompEff);
2055
2056    switch (cpType)
2057    {
2058       case RG_SCH_CMN_NOR_CP:
2059          noSymPerRb = 14;
2060          break;
2061       case RG_SCH_CMN_EXT_CP:
2062          noSymPerRb = 12;
2063          break;
2064       default:
2065          /* Generate a log error. This case should never be executed */
2066          RETVOID;
2067    }
2068
2069    /* Depending on the Tx Antenna Index, deduct the
2070     * Resource elements for the CRS */
2071    switch (txAntIdx)
2072    {
2073       case 0:
2074          resOfCrs = RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT;
2075          break;
2076       case 1:
2077          resOfCrs = RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT;
2078          break;
2079       case 2:
2080          resOfCrs = RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT;
2081          break;
2082       default:
2083          /* Generate a log error. This case should never be executed */
2084          RETVOID;
2085    }
2086
2087    noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
2088    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
2089    {
2090       (*effTbl2Lyr)[i] = 0;
2091       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
2092       {
2093          /* This line computes the coding efficiency per 1024 REs */
2094          (*effTbl2Lyr)[i] += (rgTbSzTbl[1][i][j] * 1024) / (noResPerRb * (j+1));
2095       }
2096       (*effTbl2Lyr)[i] /= RG_SCH_CMN_NUM_RBS;
2097    }
2098    RETVOID;
2099 }
2100
2101 \f
2102 /**
2103  * @brief This function initializes the rgSchCmnDciFrmtSizes table.
2104  *
2105  * @details
2106  *
2107  *     Function: rgSCHCmnGetDciFrmtSizes
2108  *     Purpose:  This function determines the sizes of all
2109  *               the available DCI Formats. The order of
2110  *               bits addition for each format is inaccordance
2111  *               with the specs.
2112  *     Invoked by: rgSCHCmnRgrCellCfg
2113  *
2114  *  @return  Void
2115  *
2116  **/
2117 #ifdef ANSI
2118 PRIVATE Void rgSCHCmnGetDciFrmtSizes
2119 (
2120 RgSchCellCb *cell
2121 )
2122 #else
2123 PRIVATE Void rgSCHCmnGetDciFrmtSizes(cell)
2124 RgSchCellCb *cell;
2125 #endif
2126 {
2127
2128    TRC2(rgSCHCmnGetDciFrmtSizes);
2129
2130    /* DCI Format 0 size determination */
2131    rgSchCmnDciFrmtSizes[0] = 1 +
2132                              1 +
2133                              rgSCHUtlLog32bitNbase2((cell->bwCfg.ulTotalBw * \
2134                              (cell->bwCfg.ulTotalBw + 1))/2) +
2135                              5 +
2136                              1 +
2137                              2 +
2138                              3 +
2139 #ifdef LTE_TDD
2140                              2 +
2141                              2 +
2142 #endif
2143                              1;
2144    /* DCI Format 1 size determination */
2145    rgSchCmnDciFrmtSizes[1] = 1 +
2146    RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2147                              5 +
2148 #ifndef LTE_TDD
2149                              3 +
2150 #else
2151                              4 + 2 + /* HqProc Id and DAI */
2152 #endif
2153                              1 +
2154                              2 +
2155                              2;
2156
2157    /* DCI Format 1A size determination */
2158    rgSchCmnDciFrmtSizes[2] = 1 + /* Flag for format0/format1a differentiation */
2159                1 + /* Localized/distributed VRB assignment flag */
2160                5 + /* For mcs */
2161 #ifndef LTE_TDD
2162                3 + /* Harq process Id */
2163 #else
2164                4 + /* Harq process Id */
2165                2 + /* UL Index or DAI */
2166 #endif
2167                1 + /* New Data Indicator */
2168                2 + /* For RV */
2169                2 + /* For tpc */
2170                1 + rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2171                    (cell->bwCfg.dlTotalBw + 1))/2);
2172                /* Resource block assignment ceil[log2(bw(bw+1)/2)] : \
2173                   Since VRB is local */
2174
2175    /* DCI Format 1B size determination */
2176    rgSchCmnDciFrmtSizes[3] = 1 +
2177                              rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2178                              (cell->bwCfg.dlTotalBw + 1))/2) +
2179                              5 +
2180                              3 +
2181 #ifdef LTE_TDD
2182                              1 + /* HqP */
2183                              2 + /* Dai */
2184 #endif
2185                              1 +
2186                              2 +
2187                              2 +
2188                              ((cell->numTxAntPorts == 4)? 4:2) +
2189                              1;
2190
2191    /* DCI Format 1C size determination */
2192    /* Approximation: NDLVrbGap1 ~= Nprb for DL */
2193    rgSchCmnDciFrmtSizes[4] = (cell->bwCfg.dlTotalBw < 50)? 0:1 +
2194                              (cell->bwCfg.dlTotalBw < 50)?
2195                              (rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw/2 * \
2196                                 (cell->bwCfg.dlTotalBw/2 + 1))/2)) :
2197                              (rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw/4 * \
2198                                 (cell->bwCfg.dlTotalBw/4 + 1))/2)) +
2199                              5;
2200
2201    /* DCI Format 1D size determination */
2202    rgSchCmnDciFrmtSizes[5] = 1 +
2203                              rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2204                              (cell->bwCfg.dlTotalBw + 1))/2) +
2205                              5 +
2206                              3 +
2207 #ifdef LTE_TDD
2208                              1 + 2 +
2209 #endif
2210                              1 +
2211                              2 +
2212                              2 +
2213                              ((cell->numTxAntPorts == 4)? 4:2) +
2214                              1;
2215
2216    /* DCI Format 2 size determination */
2217    rgSchCmnDciFrmtSizes[6] = ((cell->bwCfg.dlTotalBw < 10)?0:1) +
2218                              RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2219                              2 +
2220 #ifdef LTE_TDD
2221                              2 + 1 +
2222 #endif
2223                              3 +
2224                              1 +
2225                              (5 + 1 + 2)*2 +
2226                              ((cell->numTxAntPorts == 4)? 6:3);
2227
2228    /* DCI Format 2A size determination */
2229    rgSchCmnDciFrmtSizes[7] = ((cell->bwCfg.dlTotalBw < 10)?0:1) +
2230                              RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2231                              2 +
2232 #ifdef LTE_TDD
2233                              2 + 1 +
2234 #endif
2235                              3 +
2236                              1 +
2237                              (5 + 1 + 2)*2 +
2238                              ((cell->numTxAntPorts == 4)? 2:0);
2239
2240    /* DCI Format 3 size determination */
2241    rgSchCmnDciFrmtSizes[8] = rgSchCmnDciFrmtSizes[0];
2242
2243    /* DCI Format 3A size determination */
2244    rgSchCmnDciFrmtSizes[9] = rgSchCmnDciFrmtSizes[0];
2245
2246    RETVOID;
2247 }
2248
2249
2250 /**
2251  * @brief This function initializes the cmnCell->dciAggrLvl table.
2252  *
2253  * @details
2254  *
2255  *     Function: rgSCHCmnGetCqiDciFrmt2AggrLvl
2256  *     Purpose:  This function determines the Aggregation level
2257  *               for each CQI level against each DCI format.
2258  *     Invoked by: rgSCHCmnRgrCellCfg
2259  *
2260  *  @return  Void
2261  *
2262  **/
2263 #ifdef ANSI
2264 PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl
2265 (
2266 RgSchCellCb *cell
2267 )
2268 #else
2269 PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl(cell)
2270 RgSchCellCb *cell;
2271 #endif
2272 {
2273    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
2274    U8            i;
2275    U8            j;
2276
2277    TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
2278
2279    for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
2280    {
2281       for (j = 0; j < 10; j++)
2282       {
2283          U32 pdcchBits; /* Actual number of phy bits needed for a given DCI Format
2284                * for a given CQI Level */
2285          pdcchBits = (rgSchCmnDciFrmtSizes[j] * 1024)/rgSchCmnCqiPdcchEff[i];
2286                         /* V5G_211 : 6.6 */
2287          if (pdcchBits < 192)
2288          {
2289              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL2;
2290              continue;
2291          }
2292          if (pdcchBits < 384)
2293          {
2294              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL4;
2295              continue;
2296          }
2297          if (pdcchBits < 768)
2298          {
2299              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL8;
2300              continue;
2301          }
2302          cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL16;
2303       }
2304    }
2305    RETVOID;
2306 }
2307 \f
2308 /**
2309  * @brief This function initializes all the data for the scheduler.
2310  *
2311  * @details
2312  *
2313  *     Function: rgSCHCmnDlInit
2314  *     Purpose:  This function initializes the following information:
2315  *               1. Efficiency table
2316  *               2. CQI to table index - It is one row for upto 3 RBs
2317  *                  and another row for greater than 3 RBs
2318  *                  currently extended prefix is compiled out.
2319  *     Invoked by: MAC intialization code..may be ActvInit
2320  *
2321  *  @return  Void
2322  *
2323  **/
2324 #ifdef ANSI
2325 PRIVATE Void rgSCHCmnDlInit
2326 (
2327 )
2328 #else
2329 PRIVATE Void rgSCHCmnDlInit()
2330 #endif
2331 {
2332    U8                   i;
2333    S16                  j;
2334    S16                  k;
2335    U8                   idx;
2336    RgSchCmnTbSzEff      *effTbl;
2337    RgSchCmnCqiToTbs     *tbsTbl;
2338
2339    TRC2(rgSCHCmnDlInit);
2340
2341    /* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
2342    /* Init Efficiency table for normal cyclic prefix */
2343    /*Initialize Efficiency table for Layer Index 0 */
2344    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2345    /*Initialize Efficiency table for each of the CFI indices. The
2346     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2347    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][0] = &rgSchCmnNorCfi1Eff[0];
2348    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][1] = &rgSchCmnNorCfi2Eff[0];
2349    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][2] = &rgSchCmnNorCfi3Eff[0];
2350    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][3] = &rgSchCmnNorCfi4Eff[0];
2351    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2352    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][0] = &rgSchCmnNorCfi1Eff[0];
2353    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][1] = &rgSchCmnNorCfi2Eff[0];
2354    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][2] = &rgSchCmnNorCfi3Eff[0];
2355    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][3] = &rgSchCmnNorCfi4Eff[0];
2356    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2357    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][0] = &rgSchCmnNorCfi1Eff[0];
2358    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][1] = &rgSchCmnNorCfi2Eff[0];
2359    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][2] = &rgSchCmnNorCfi3Eff[0];
2360    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][3] = &rgSchCmnNorCfi4Eff[0];
2361
2362    /*Initialize CQI to TBS table for Layer Index 0 for Normal CP */
2363    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][0] = &rgSchCmnNorCfi1CqiToTbs[0];
2364    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][1] = &rgSchCmnNorCfi2CqiToTbs[0];
2365    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][2] = &rgSchCmnNorCfi3CqiToTbs[0];
2366    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][3] = &rgSchCmnNorCfi4CqiToTbs[0];
2367
2368    /*Intialize Efficency table for Layer Index 1 */
2369    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2370    /*Initialize Efficiency table for each of the CFI indices. The
2371     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2372    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][0] = &rgSchCmnNorCfi1Eff[1];
2373    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][1] = &rgSchCmnNorCfi2Eff[1];
2374    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][2] = &rgSchCmnNorCfi3Eff[1];
2375    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][3] = &rgSchCmnNorCfi4Eff[1];
2376    /*Initialize Efficiency table for Tx Antenna Port Index 1 */
2377    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][0] = &rgSchCmnNorCfi1Eff[1];
2378    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][1] = &rgSchCmnNorCfi2Eff[1];
2379    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][2] = &rgSchCmnNorCfi3Eff[1];
2380    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][3] = &rgSchCmnNorCfi4Eff[1];
2381    /*Initialize Efficiency table for Tx Antenna Port Index 2 */
2382    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][0] = &rgSchCmnNorCfi1Eff[1];
2383    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][1] = &rgSchCmnNorCfi2Eff[1];
2384    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][2] = &rgSchCmnNorCfi3Eff[1];
2385    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][3] = &rgSchCmnNorCfi4Eff[1];
2386
2387    /*Initialize CQI to TBS table for Layer Index 1 for Normal CP */
2388    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][0] = &rgSchCmnNorCfi1CqiToTbs[1];
2389    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][1] = &rgSchCmnNorCfi2CqiToTbs[1];
2390    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][2] = &rgSchCmnNorCfi3CqiToTbs[1];
2391    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][3] = &rgSchCmnNorCfi4CqiToTbs[1];
2392
2393    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2394    {
2395       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2396       {
2397          /* EfficiencyTbl calculation incase of 2 layers for normal CP  */
2398          rgSCHCmnCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
2399                rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i]);
2400          rgSCHCmn2LyrCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
2401                rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i]);
2402       }
2403    }
2404
2405    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2406    {
2407       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2408       {
2409          effTbl = rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i];
2410          tbsTbl = rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][i];
2411          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2412                (j >= 0) && (k > 0); --j)
2413          {
2414             /* ADD CQI to MCS mapping correction
2415             * single dimensional array is replaced by 2 dimensions for different CFI*/
2416             if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
2417             {
2418                (*tbsTbl)[k--] = (U8)j;
2419             }
2420          }
2421          for (; k > 0; --k)
2422          {
2423             (*tbsTbl)[k] = 0;
2424          }
2425          /* effTbl,tbsTbl calculation incase of 2 layers for normal CP */
2426          effTbl = rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i];
2427          tbsTbl = rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][i];
2428          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2429                (j >= 0) && (k > 0); --j)
2430          {
2431             /* ADD CQI to MCS mapping correction
2432             * single dimensional array is replaced by 2 dimensions for different CFI*/
2433             if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
2434             {
2435                (*tbsTbl)[k--] = (U8)j;
2436             }
2437          }
2438          for (; k > 0; --k)
2439          {
2440             (*tbsTbl)[k] = 0;
2441          }
2442       }
2443    }
2444
2445    /* Efficiency Table for Extended CP */
2446    /*Initialize Efficiency table for Layer Index 0 */
2447    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2448    /*Initialize Efficiency table for each of the CFI indices. The
2449     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2450    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][0] = &rgSchCmnExtCfi1Eff[0];
2451    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][1] = &rgSchCmnExtCfi2Eff[0];
2452    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][2] = &rgSchCmnExtCfi3Eff[0];
2453    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][3] = &rgSchCmnExtCfi4Eff[0];
2454    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2455    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][0] = &rgSchCmnExtCfi1Eff[0];
2456    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][1] = &rgSchCmnExtCfi2Eff[0];
2457    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][2] = &rgSchCmnExtCfi3Eff[0];
2458    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][3] = &rgSchCmnExtCfi4Eff[0];
2459    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2460    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][0] = &rgSchCmnExtCfi1Eff[0];
2461    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][1] = &rgSchCmnExtCfi2Eff[0];
2462    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][2] = &rgSchCmnExtCfi3Eff[0];
2463    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][3] = &rgSchCmnExtCfi4Eff[0];
2464
2465    /*Initialize CQI to TBS table for Layer Index 0 for Extended CP */
2466    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][0] = &rgSchCmnExtCfi1CqiToTbs[0];
2467    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][1] = &rgSchCmnExtCfi2CqiToTbs[0];
2468    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][2] = &rgSchCmnExtCfi3CqiToTbs[0];
2469    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][3] = &rgSchCmnExtCfi4CqiToTbs[0];
2470
2471    /*Initialize Efficiency table for Layer Index 1 */
2472    /*Initialize Efficiency table for each of the CFI indices. The
2473     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2474    /*Initialize Efficency table for Tx Antenna Port Index 0 */
2475    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][0] = &rgSchCmnExtCfi1Eff[1];
2476    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][1] = &rgSchCmnExtCfi2Eff[1];
2477    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][2] = &rgSchCmnExtCfi3Eff[1];
2478    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][3] = &rgSchCmnExtCfi4Eff[1];
2479    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2480    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][0] = &rgSchCmnExtCfi1Eff[1];
2481    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][1] = &rgSchCmnExtCfi2Eff[1];
2482    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][2] = &rgSchCmnExtCfi3Eff[1];
2483    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][3] = &rgSchCmnExtCfi4Eff[1];
2484    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2485    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][0] = &rgSchCmnExtCfi1Eff[1];
2486    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][1] = &rgSchCmnExtCfi2Eff[1];
2487    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][2] = &rgSchCmnExtCfi3Eff[1];
2488    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][3] = &rgSchCmnExtCfi4Eff[1];
2489
2490    /*Initialize CQI to TBS table for Layer Index 1 for Extended CP */
2491    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][0] = &rgSchCmnExtCfi1CqiToTbs[1];
2492    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][1] = &rgSchCmnExtCfi2CqiToTbs[1];
2493    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][2] = &rgSchCmnExtCfi3CqiToTbs[1];
2494    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][3] = &rgSchCmnExtCfi4CqiToTbs[1];
2495    /* Activate this code when extended cp is supported */
2496    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2497    {
2498       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2499       {
2500          /* EfficiencyTbl calculation incase of 2 layers for extendedl CP  */
2501          rgSCHCmnCompEff( (U8)(i + 1 ), (U8)RG_SCH_CMN_EXT_CP, idx,\
2502                rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i]);
2503          rgSCHCmn2LyrCompEff((U8)(i + 1), (U8) RG_SCH_CMN_EXT_CP,idx, \
2504                rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i]);
2505       }
2506    }
2507
2508    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2509    {
2510       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2511       {
2512          effTbl = rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i];
2513          tbsTbl = rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][i];
2514          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2515                (j >= 0) && (k > 0); --j)
2516          {
2517             /* ADD CQI to MCS mapping correction
2518             * single dimensional array is replaced by 2 dimensions for different CFI*/
2519             if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
2520             {
2521                (*tbsTbl)[k--] = (U8)j;
2522             }
2523          }
2524          for (; k > 0; --k)
2525          {
2526             (*tbsTbl)[k] = 0;
2527          }
2528          /* effTbl,tbsTbl calculation incase of 2 layers for extended CP */
2529          effTbl = rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i];
2530          tbsTbl = rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][i];
2531          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2532                (j >= 0) && (k > 0); --j)
2533          {
2534            /* ADD CQI to MCS mapping correction
2535             * single dimensional array is replaced by 2 dimensions for different CFI*/
2536             if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
2537             {
2538                (*tbsTbl)[k--] = (U8)j;
2539             }
2540          }
2541          for (; k > 0; --k)
2542          {
2543             (*tbsTbl)[k] = 0;
2544          }
2545       }
2546    }
2547    RETVOID;
2548 }
2549 \f
2550 /**
2551  * @brief This function initializes all the data for the scheduler.
2552  *
2553  * @details
2554  *
2555  *     Function: rgSCHCmnUlInit
2556  *     Purpose:  This function initializes the following information:
2557  *               1. Efficiency table
2558  *               2. CQI to table index - It is one row for upto 3 RBs
2559  *                  and another row for greater than 3 RBs
2560  *                  currently extended prefix is compiled out.
2561  *     Invoked by: MAC intialization code..may be ActvInit
2562  *
2563  *  @return  Void
2564  *
2565  **/
2566 #ifdef ANSI
2567 PRIVATE Void rgSCHCmnUlInit
2568 (
2569 )
2570 #else
2571 PRIVATE Void rgSCHCmnUlInit()
2572 #endif
2573 {
2574    U8              *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
2575    RgSchCmnTbSzEff    *effTbl    = &rgSchCmnNorUlEff[0];
2576    CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
2577    S16              i;
2578    S16              j;
2579    TRC2(rgSCHCmnUlInit);
2580
2581    /* Initaializing new variable added for UL eff */
2582    rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
2583    /* Reason behind using 3 as the number of symbols to rule out for
2584     * efficiency table computation would be that we are using 2 symbols for
2585     * DMRS(1 in each slot) and 1 symbol for SRS*/
2586    rgSCHCmnCompUlEff(RGSCH_UL_SYM_DMRS_SRS,RG_SCH_CMN_NOR_CP,rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP]);
2587
2588    for (i = RGSCH_NUM_ITBS - 1, j = RG_SCH_CMN_UL_NUM_CQI - 1;
2589          i >= 0 && j > 0; --i)
2590    {
2591       if ((*effTbl)[i] <= cqiTbl[j].eff)
2592       {
2593          mapTbl[j--] = (U8)i;
2594       }
2595    }
2596    for (; j > 0; --j)
2597    {
2598       mapTbl[j] = 0;
2599    }
2600    effTbl    = &rgSchCmnExtUlEff[0];
2601    mapTbl    = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_EXT_CP][0];
2602
2603    /* Initaializing new variable added for UL eff */
2604    rgSchCmnUlEffTbl[RG_SCH_CMN_EXT_CP] = &rgSchCmnExtUlEff[0];
2605    /* Reason behind using 3 as the number of symbols to rule out for
2606     * efficiency table computation would be that we are using 2 symbols for
2607     * DMRS(1 in each slot) and 1 symbol for SRS*/
2608    rgSCHCmnCompUlEff(3,RG_SCH_CMN_EXT_CP,rgSchCmnUlEffTbl[RG_SCH_CMN_EXT_CP]);
2609
2610    for (i = RGSCH_NUM_ITBS - 1, j = RG_SCH_CMN_UL_NUM_CQI - 1;
2611          i >= 0 && j > 0; --i)
2612    {
2613       if ((*effTbl)[i] <= cqiTbl[j].eff)
2614       {
2615          mapTbl[j--] = (U8)i;
2616       }
2617    }
2618    for (; j > 0; --j)
2619    {
2620       mapTbl[j] = 0;
2621    }
2622    rgSCHPwrInit();
2623    RETVOID;
2624 }
2625
2626 /**
2627  * @brief This function initializes all the data for the scheduler.
2628  *
2629  * @details
2630  *
2631  *     Function: rgSCHCmnInit
2632  *     Purpose:  This function initializes the following information:
2633  *               1. Efficiency table
2634  *               2. CQI to table index - It is one row for upto 3 RBs
2635  *                  and another row for greater than 3 RBs
2636  *                  currently extended prefix is compiled out.
2637  *     Invoked by: MAC intialization code..may be ActvInit
2638  *
2639  *  @return  Void
2640  *
2641  **/
2642 #ifdef ANSI
2643 PUBLIC Void rgSCHCmnInit
2644 (
2645 )
2646 #else
2647 PUBLIC Void rgSCHCmnInit()
2648 #endif
2649 {
2650    U8   idx;
2651    TRC2(rgSCHCmnInit);
2652
2653    rgSCHCmnDlInit();
2654    rgSCHCmnUlInit();
2655 #ifdef EMTC_ENABLE
2656    rgSCHEmtcCmnDlInit();
2657    rgSCHEmtcCmnUlInit();
2658 #endif      
2659 #ifdef LTEMAC_SPS
2660    rgSCHCmnSpsInit();
2661 #endif
2662
2663    /* Init the function pointers */
2664    rgSchCmnApis.rgSCHRgrUeCfg         = rgSCHCmnRgrUeCfg;
2665    rgSchCmnApis.rgSCHRgrUeRecfg       = rgSCHCmnRgrUeRecfg;
2666    rgSchCmnApis.rgSCHFreeUe           = rgSCHCmnUeDel;
2667    rgSchCmnApis.rgSCHRgrCellCfg       = rgSCHCmnRgrCellCfg;
2668    rgSchCmnApis.rgSCHRgrCellRecfg     = rgSCHCmnRgrCellRecfg;
2669    rgSchCmnApis.rgSCHFreeCell         = rgSCHCmnCellDel;
2670    rgSchCmnApis.rgSCHRgrLchCfg        = rgSCHCmnRgrLchCfg;
2671    rgSchCmnApis.rgSCHRgrLcgCfg        = rgSCHCmnRgrLcgCfg;
2672    rgSchCmnApis.rgSCHRgrLchRecfg      = rgSCHCmnRgrLchRecfg;
2673    rgSchCmnApis.rgSCHRgrLcgRecfg      = rgSCHCmnRgrLcgRecfg;
2674    rgSchCmnApis.rgSCHFreeDlLc         = rgSCHCmnFreeDlLc;
2675    rgSchCmnApis.rgSCHFreeLcg          = rgSCHCmnLcgDel;
2676    rgSchCmnApis.rgSCHRgrLchDel        = rgSCHCmnRgrLchDel;
2677    rgSchCmnApis.rgSCHActvtUlUe        = rgSCHCmnActvtUlUe;
2678    rgSchCmnApis.rgSCHActvtDlUe        = rgSCHCmnActvtDlUe;
2679    rgSchCmnApis.rgSCHHdlUlTransInd    = rgSCHCmnHdlUlTransInd;
2680    rgSchCmnApis.rgSCHDlDedBoUpd       = rgSCHCmnDlDedBoUpd;
2681    rgSchCmnApis.rgSCHUlRecMsg3Alloc   = rgSCHCmnUlRecMsg3Alloc;
2682    rgSchCmnApis.rgSCHUlCqiInd         = rgSCHCmnUlCqiInd;
2683    rgSchCmnApis.rgSCHPucchDeltaPwrInd = rgSCHPwrPucchDeltaInd;
2684    rgSchCmnApis.rgSCHUlHqProcForUe    = rgSCHCmnUlHqProcForUe;
2685 #ifdef RG_UNUSED
2686    rgSchCmnApis.rgSCHUpdUlHqProc      = rgSCHCmnUpdUlHqProc;
2687 #endif
2688    rgSchCmnApis.rgSCHUpdBsrShort      = rgSCHCmnUpdBsrShort;
2689    rgSchCmnApis.rgSCHUpdBsrTrunc      = rgSCHCmnUpdBsrTrunc;
2690    rgSchCmnApis.rgSCHUpdBsrLong       = rgSCHCmnUpdBsrLong;
2691    rgSchCmnApis.rgSCHUpdPhr           = rgSCHCmnUpdPhr;
2692    rgSchCmnApis.rgSCHUpdExtPhr        = rgSCHCmnUpdExtPhr;
2693    rgSchCmnApis.rgSCHContResUlGrant   = rgSCHCmnContResUlGrant;
2694    rgSchCmnApis.rgSCHSrRcvd           = rgSCHCmnSrRcvd;
2695    rgSchCmnApis.rgSCHFirstRcptnReq    = rgSCHCmnFirstRcptnReq;
2696    rgSchCmnApis.rgSCHNextRcptnReq     = rgSCHCmnNextRcptnReq;
2697    rgSchCmnApis.rgSCHFirstHqFdbkAlloc = rgSCHCmnFirstHqFdbkAlloc;
2698    rgSchCmnApis.rgSCHNextHqFdbkAlloc  = rgSCHCmnNextHqFdbkAlloc;
2699    rgSchCmnApis.rgSCHDlProcAddToRetx  = rgSCHCmnDlProcAddToRetx;
2700    rgSchCmnApis.rgSCHDlCqiInd         = rgSCHCmnDlCqiInd;
2701 #ifdef EMTC_ENABLE
2702    rgSchCmnApis.rgSCHUlProcAddToRetx  = rgSCHCmnEmtcUlProcAddToRetx;
2703 #endif
2704 #ifdef TFU_UPGRADE
2705    rgSchCmnApis.rgSCHSrsInd           = rgSCHCmnSrsInd;
2706 #endif
2707    rgSchCmnApis.rgSCHDlTARpt          = rgSCHCmnDlTARpt;
2708    rgSchCmnApis.rgSCHDlRlsSubFrm      = rgSCHCmnDlRlsSubFrm;
2709    rgSchCmnApis.rgSCHUeReset          = rgSCHCmnUeReset;
2710 #ifdef LTEMAC_SPS
2711    rgSchCmnApis.rgSCHHdlCrntiCE         = rgSCHCmnHdlCrntiCE;
2712    rgSchCmnApis.rgSCHDlProcAck        = rgSCHCmnDlProcAck;
2713    rgSchCmnApis.rgSCHDlRelPdcchFbk    = rgSCHCmnDlRelPdcchFbk;
2714    rgSchCmnApis.rgSCHUlSpsRelInd      = rgSCHCmnUlSpsRelInd;
2715    rgSchCmnApis.rgSCHUlSpsActInd      = rgSCHCmnUlSpsActInd;
2716    rgSchCmnApis.rgSCHUlCrcFailInd     = rgSCHCmnUlCrcFailInd;
2717    rgSchCmnApis.rgSCHUlCrcInd     = rgSCHCmnUlCrcInd;
2718 #endif
2719    rgSchCmnApis.rgSCHDrxStrtInActvTmrInUl = rgSCHCmnDrxStrtInActvTmrInUl;
2720    rgSchCmnApis.rgSCHUpdUeDataIndLcg      = rgSCHCmnUpdUeDataIndLcg;
2721
2722    for (idx = 0; idx < RGSCH_NUM_SCHEDULERS; ++idx)
2723    {
2724       rgSchUlSchdInits[idx](&rgSchUlSchdTbl[idx]);
2725       rgSchDlSchdInits[idx](&rgSchDlSchdTbl[idx]);
2726    }
2727 #ifdef EMTC_ENABLE 
2728    for (idx = 0; idx < RGSCH_NUM_EMTC_SCHEDULERS; ++idx)
2729    {
2730       rgSchEmtcUlSchdInits[idx](&rgSchEmtcUlSchdTbl[idx]);
2731       rgSchEmtcDlSchdInits[idx](&rgSchEmtcDlSchdTbl[idx]);
2732    }
2733 #endif
2734 #if (defined (RG_PHASE2_SCHED) && defined(TFU_UPGRADE))
2735    for (idx = 0; idx < RGSCH_NUM_DLFS_SCHEDULERS; ++idx)
2736    {
2737       rgSchDlfsSchdInits[idx](&rgSchDlfsSchdTbl[idx]);
2738    }
2739 #endif
2740 #ifdef LTE_ADV
2741    rgSchCmnApis.rgSCHRgrSCellUeCfg         = rgSCHCmnRgrSCellUeCfg;
2742    rgSchCmnApis.rgSCHRgrSCellUeDel         = rgSCHCmnRgrSCellUeDel;
2743 #endif
2744    RETVOID;
2745 }
2746
2747 \f
2748 /**
2749  * @brief This function is a wrapper to call scheduler specific API.
2750  *
2751  * @details
2752  *
2753  *     Function: rgSCHCmnDlRlsSubFrm
2754  *     Purpose:  Releases scheduler Information from DL SubFrm.
2755  *
2756  *     Invoked by: DHM
2757  *
2758  *  @param[in]   RgSchCellCb     *cell
2759  *  @param[out]  CmLteTimingInfo frm
2760  *  @return  Void
2761  *
2762  **/
2763 #ifdef ANSI
2764 PUBLIC Void rgSCHCmnDlRlsSubFrm
2765 (
2766 RgSchCellCb        *cell,
2767 CmLteTimingInfo   frm
2768 )
2769 #else
2770 PUBLIC Void rgSCHCmnDlRlsSubFrm(cell, frm)
2771 RgSchCellCb        *cell;
2772 CmLteTimingInfo    frm;
2773 #endif
2774 {
2775    RgSchCmnCell        *cellSch = RG_SCH_CMN_GET_CELL(cell);
2776    RgSchDlSf           *sf;
2777
2778    TRC2(rgSCHCmnDlRlsSubFrm);
2779
2780    /* Get the pointer to the subframe */
2781    sf = rgSCHUtlSubFrmGet(cell, frm);
2782
2783    rgSCHUtlSubFrmPut(cell, sf);
2784    if (sf->dlfsSf)
2785    {
2786       /* Re-initialize DLFS specific information for the sub-frame */
2787       cellSch->apisDlfs->rgSCHDlfsReinitSf(cell, sf);
2788    }
2789    RETVOID;
2790 }
2791
2792
2793 \f
2794 /**
2795  * @brief This function is the starting function for DL allocation.
2796  *
2797  * @details
2798  *
2799  *     Function: rgSCHCmnDlCmnChAlloc
2800  *     Purpose:  Scheduling for downlink. It performs allocation in the order
2801  *               of priority wich BCCH/PCH first, CCCH, Random Access and TA.
2802  *
2803  *     Invoked by: Scheduler
2804  *
2805  *  @param[in]  RgSchCellCb*           cell
2806  *  @param[out] RgSchCmnDlRbAllocInfo* allocInfo
2807  *  @return  Void
2808  *
2809  **/
2810 #ifdef ANSI
2811 PRIVATE Void rgSCHCmnDlCcchRarAlloc
2812 (
2813 RgSchCellCb             *cell
2814 )
2815 #else
2816 PRIVATE Void rgSCHCmnDlCcchRarAlloc(cell)
2817 RgSchCellCb             *cell;
2818 #endif
2819 {
2820    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
2821
2822    TRC2(rgSCHCmnDlCcchRarAlloc);
2823
2824    rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
2825    /* LTE_ADV_FLAG_REMOVED_START */
2826    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2827    {
2828       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2829       {
2830          /*eNodeB need to blank the subframe */
2831       }
2832       else
2833       {
2834          rgSCHCmnDlCcchTx(cell, &cellSch->allocInfo);
2835       }
2836    }
2837    else
2838    {
2839       rgSCHCmnDlCcchTx(cell, &cellSch->allocInfo);
2840    }
2841    /* LTE_ADV_FLAG_REMOVED_END */
2842
2843 #ifdef RGR_V1
2844
2845    /*Added these function calls for processing CCCH SDU arriving
2846     * after guard timer expiry.Functions differ from above two functions
2847     * in using ueCb instead of raCb.*/
2848    rgSCHCmnDlCcchSduRetx(cell, &cellSch->allocInfo);
2849    /* LTE_ADV_FLAG_REMOVED_START */
2850    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2851    {
2852       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2853       {
2854          /*eNodeB need to blank the subframe */
2855       }
2856       else
2857       {
2858          rgSCHCmnDlCcchSduTx(cell, &cellSch->allocInfo);
2859       }
2860    }
2861    else
2862    {
2863       rgSCHCmnDlCcchSduTx(cell, &cellSch->allocInfo);
2864    }
2865    /* LTE_ADV_FLAG_REMOVED_END */
2866 #endif
2867
2868 #ifdef LTE_TDD
2869    if(cellSch->ul.msg3SchdIdx != RGSCH_INVALID_INFO)
2870    {
2871       /* Do not schedule msg3 if there is a CFI change ongoing */
2872       if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2873       {
2874          rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2875       }
2876    }
2877 #else
2878    /* LTE_ADV_FLAG_REMOVED_START */
2879    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2880    {
2881       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2882       {
2883          /*eNodeB need to blank the subframe */
2884       }
2885       else
2886       {
2887          /* Do not schedule msg3 if there is a CFI change ongoing */
2888          if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2889          {
2890             rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2891          }
2892       }
2893    }
2894    else
2895    {
2896       /* Do not schedule msg3 if there is a CFI change ongoing */
2897       if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2898       {
2899          rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2900       }
2901    }
2902    /* LTE_ADV_FLAG_REMOVED_END */
2903 #endif
2904
2905    RETVOID;
2906 }
2907
2908 #ifdef RGR_V1
2909 /**
2910  * @brief Scheduling for CCCH SDU.
2911  *
2912  * @details
2913  *
2914  *     Function: rgSCHCmnCcchSduAlloc
2915  *     Purpose:  Scheduling for CCCH SDU
2916  *
2917  *     Invoked by: Scheduler
2918  *
2919  *  @param[in]  RgSchCellCb*          cell
2920  *  @param[in]  RgSchUeCb*            ueCb
2921  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
2922  *  @return  S16
2923  *
2924  **/
2925 #ifdef ANSI
2926 PRIVATE S16 rgSCHCmnCcchSduAlloc
2927 (
2928 RgSchCellCb                *cell,
2929 RgSchUeCb                  *ueCb,
2930 RgSchCmnDlRbAllocInfo      *allocInfo
2931 )
2932 #else
2933 PRIVATE S16 rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)
2934 RgSchCellCb                *cell;
2935 RgSchUeCb                  *ueCb;
2936 RgSchCmnDlRbAllocInfo      *allocInfo;
2937 #endif
2938 {
2939    RgSchDlRbAlloc  *rbAllocInfo;
2940    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
2941    RgSchCmnDlUe       *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
2942
2943    TRC2(rgSCHCmnCcchSduAlloc);
2944
2945    /* Return if subframe BW exhausted */
2946    if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
2947        allocInfo->ccchSduAlloc.ccchSduDlSf->bwAssigned)
2948    {
2949       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2950          "bw<=bwAssigned for UEID:%d",ueCb->ueId);
2951       RETVALUE(RFAILED);
2952    }
2953
2954    if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
2955    {
2956       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2957          "rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
2958       RETVALUE(RFAILED);
2959    }
2960
2961    rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
2962    rbAllocInfo->dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
2963
2964    if (rgSCHCmnCcchSduDedAlloc(cell, ueCb) != ROK)
2965    {
2966       /* Fix : syed Minor failure handling, release hqP if Unsuccessful */    
2967       rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
2968       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2969          "rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
2970       RETVALUE(RFAILED);
2971    }
2972    cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
2973    ueDl->proc->reqLnk.node = (PTR)ueDl->proc;
2974    allocInfo->ccchSduAlloc.ccchSduDlSf->schdCcchUe++;
2975
2976    RETVALUE(ROK);
2977 }
2978 /**
2979  * @brief This function scheduler for downlink CCCH messages.
2980  *
2981  * @details
2982  *
2983  *     Function: rgSCHCmnDlCcchSduTx
2984  *     Purpose:  Scheduling for downlink CCCH
2985  *
2986  *     Invoked by: Scheduler
2987  *
2988  *  @param[in]  RgSchCellCb           *cell
2989  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
2990  *  @return  Void
2991  *
2992  **/
2993 #ifdef ANSI
2994 PRIVATE Void rgSCHCmnDlCcchSduTx
2995 (
2996 RgSchCellCb             *cell,
2997 RgSchCmnDlRbAllocInfo   *allocInfo
2998 )
2999 #else
3000 PRIVATE Void rgSCHCmnDlCcchSduTx(cell, allocInfo)
3001 RgSchCellCb             *cell;
3002 RgSchCmnDlRbAllocInfo   *allocInfo;
3003 #endif
3004 {
3005    CmLList           *node;
3006    RgSchUeCb         *ueCb;
3007    RgSchCmnDlUe      *ueCmnDl;
3008    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3009
3010    RgSchDlSf         *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
3011    
3012    TRC2(rgSCHCmnDlCcchSduTx);
3013
3014    node = cell->ccchSduUeLst.first;
3015    while(node)
3016    {
3017       if(cellSch->dl.maxCcchPerDlSf &&
3018             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3019       {
3020          break;
3021       }
3022       else
3023       {
3024          ueCb = (RgSchUeCb *)(node->node);
3025          ueCmnDl  = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
3026          node = node->next;
3027          /* Fix : syed postpone scheduling for this
3028           * until msg4 is done */
3029          /* Fix : syed RLC can erroneously send CCCH SDU BO 
3030           * twice. Hence an extra guard to avoid if already 
3031           * scheduled for RETX */
3032          if ((!(ueCb->dl.dlInactvMask & RG_HQENT_INACTIVE)) &&
3033                (!ueCmnDl->proc))
3034          {
3035             if ((rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)) != ROK)
3036             {
3037                break;
3038             }
3039          }
3040          else
3041          {
3042             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"ERROR!! THIS SHOULD "
3043                      "NEVER HAPPEN for UEID:%d", ueCb->ueId);
3044             continue;
3045          }
3046       }
3047    }
3048    RETVOID;
3049 }
3050 #endif
3051 \f
3052 /**
3053  * @brief This function scheduler for downlink CCCH messages.
3054  *
3055  * @details
3056  *
3057  *     Function: rgSCHCmnDlCcchTx
3058  *     Purpose:  Scheduling for downlink CCCH
3059  *
3060  *     Invoked by: Scheduler
3061  *
3062  *  @param[in]  RgSchCellCb           *cell
3063  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3064  *  @return  Void
3065  *
3066  **/
3067 #ifdef ANSI
3068 PRIVATE Void rgSCHCmnDlCcchTx
3069 (
3070 RgSchCellCb             *cell,
3071 RgSchCmnDlRbAllocInfo   *allocInfo
3072 )
3073 #else
3074 PRIVATE Void rgSCHCmnDlCcchTx(cell, allocInfo)
3075 RgSchCellCb             *cell;
3076 RgSchCmnDlRbAllocInfo   *allocInfo;
3077 #endif
3078 {
3079    CmLList           *node;
3080    RgSchRaCb         *raCb;
3081    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3082    RgSchDlSf         *dlSf = allocInfo->msg4Alloc.msg4DlSf;
3083    
3084    TRC2(rgSCHCmnDlCcchTx);
3085
3086    node = cell->raInfo.toBeSchdLst.first;
3087    while(node)
3088    {
3089       if(cellSch->dl.maxCcchPerDlSf &&
3090             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3091       {
3092          break;
3093       }
3094       else
3095       {
3096
3097          raCb = (RgSchRaCb *)(node->node);
3098          node = node->next;
3099          /* Address allocation for this UE for MSG 4 */
3100          /* Allocation for Msg4 */
3101          if ((rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)) != ROK)
3102          {
3103             break;
3104          }
3105       }
3106    }
3107    RETVOID;
3108 }
3109
3110 #ifdef RGR_V1
3111 /**
3112  * @brief This function scheduler for downlink CCCH messages.
3113  *
3114  * @details
3115  *
3116  *     Function: rgSCHCmnDlCcchSduRetx
3117  *     Purpose:  Scheduling for downlink CCCH
3118  *
3119  *     Invoked by: Scheduler
3120  *
3121  *  @param[in]  RgSchCellCb           *cell
3122  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3123  *  @return  Void
3124  *
3125  **/
3126 #ifdef ANSI
3127 PRIVATE Void rgSCHCmnDlCcchSduRetx
3128 (
3129 RgSchCellCb             *cell,
3130 RgSchCmnDlRbAllocInfo   *allocInfo
3131 )
3132 #else
3133 PRIVATE Void rgSCHCmnDlCcchSduRetx(cell, allocInfo)
3134 RgSchCellCb             *cell;
3135 RgSchCmnDlRbAllocInfo   *allocInfo;
3136 #endif
3137 {
3138    RgSchDlRbAlloc  *rbAllocInfo;
3139    CmLList           *node;
3140    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3141    RgSchUeCb         *ueCb;
3142    RgSchDlHqProcCb   *hqP;
3143    U8                retxBw = 0;
3144    RgSchCmnDlUe      *ueDl;
3145    RgSchDlSf         *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
3146    
3147    TRC2(rgSCHCmnDlCcchSduRetx);
3148
3149    node = cellSch->dl.ccchSduRetxLst.first;
3150    while(node)
3151    {
3152       if(cellSch->dl.maxCcchPerDlSf &&
3153             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3154       {
3155          break;
3156       }
3157       else
3158       {
3159
3160          hqP = (RgSchDlHqProcCb *)(node->node);
3161          node = node->next;
3162
3163          /* DwPts Scheduling Changes Start */      
3164 #ifdef LTE_TDD
3165          if (rgSCHCmnRetxAvoidTdd(allocInfo->ccchSduAlloc.ccchSduDlSf, 
3166                   cell, hqP) == TRUE)
3167          {
3168             continue;  
3169          }
3170 #endif
3171          /* DwPts Scheduling Changes End */     
3172
3173          if (hqP->tbInfo[0].dlGrnt.numRb > (dlSf->bw - dlSf->bwAssigned))
3174          {
3175             break;
3176          }
3177          ueCb = (RgSchUeCb*)(hqP->hqE->ue);
3178          ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
3179
3180          rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
3181          /* Fill RB Alloc Info */
3182          rbAllocInfo->dlSf = dlSf;
3183          rbAllocInfo->tbInfo[0].bytesReq =  hqP->tbInfo[0].ccchSchdInfo.totBytes;
3184          rbAllocInfo->rbsReq = hqP->tbInfo[0].dlGrnt.numRb;
3185          /* Fix : syed iMcs setting did not correspond to RETX */
3186          RG_SCH_CMN_GET_MCS_FOR_RETX((&hqP->tbInfo[0]), 
3187                rbAllocInfo->tbInfo[0].imcs);
3188          rbAllocInfo->rnti = ueCb->ueId;
3189          rbAllocInfo->tbInfo[0].noLyr = hqP->tbInfo[0].numLyrs;
3190          /* Fix : syed Copying info in entirety without depending on stale TX information */
3191          rbAllocInfo->tbInfo[0].tbCb = &hqP->tbInfo[0];
3192          rbAllocInfo->tbInfo[0].schdlngForTb = TRUE;
3193          /* Fix : syed Assigning proc to scratchpad */ 
3194          ueDl->proc = hqP;
3195
3196          retxBw += rbAllocInfo->rbsReq;
3197
3198          cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduRetxLst, \
3199                &hqP->reqLnk);
3200          hqP->reqLnk.node = (PTR)hqP;
3201          dlSf->schdCcchUe++;
3202       }
3203    }
3204    dlSf->bwAssigned += retxBw;
3205    RETVOID;
3206 }
3207 #endif
3208 \f
3209 /**
3210  * @brief This function scheduler for downlink CCCH messages.
3211  *
3212  * @details
3213  *
3214  *     Function: rgSCHCmnDlCcchRetx
3215  *     Purpose:  Scheduling for downlink CCCH
3216  *
3217  *     Invoked by: Scheduler
3218  *
3219  *  @param[in]  RgSchCellCb           *cell
3220  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3221  *  @return  Void
3222  *
3223  **/
3224 #ifdef ANSI
3225 PRIVATE Void rgSCHCmnDlCcchRetx
3226 (
3227 RgSchCellCb             *cell,
3228 RgSchCmnDlRbAllocInfo   *allocInfo
3229 )
3230 #else
3231 PRIVATE Void rgSCHCmnDlCcchRetx(cell, allocInfo)
3232 RgSchCellCb             *cell;
3233 RgSchCmnDlRbAllocInfo   *allocInfo;
3234 #endif
3235 {
3236    CmLList           *node;
3237    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3238    RgSchRaCb         *raCb;
3239    RgSchDlHqProcCb   *hqP;
3240    U8                retxBw = 0;
3241    RgSchDlSf         *dlSf = allocInfo->msg4Alloc.msg4DlSf;
3242         
3243    TRC2(rgSCHCmnDlCcchRetx);
3244
3245    node = cellSch->dl.msg4RetxLst.first;
3246    while(node)
3247    {
3248       if(cellSch->dl.maxCcchPerDlSf &&
3249             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3250       {
3251          break;
3252       }
3253       else
3254       {
3255          hqP = (RgSchDlHqProcCb *)(node->node);
3256
3257          node = node->next;
3258
3259          /* DwPts Scheduling Changes Start */     
3260 #ifdef LTE_TDD      
3261          if (rgSCHCmnRetxAvoidTdd(allocInfo->msg4Alloc.msg4DlSf, 
3262                   cell, hqP) == TRUE)
3263          {
3264             continue;  
3265          }
3266 #endif      
3267          /* DwPts Scheduling Changes End */      
3268
3269          if (hqP->tbInfo[0].dlGrnt.numRb > (dlSf->bw - dlSf->bwAssigned))
3270          {
3271             break;
3272          }
3273          raCb = (RgSchRaCb*)(hqP->hqE->raCb);
3274          /* Fill RB Alloc Info */
3275          raCb->rbAllocInfo.dlSf = dlSf;
3276          raCb->rbAllocInfo.tbInfo[0].bytesReq =  hqP->tbInfo[0].ccchSchdInfo.totBytes;
3277          raCb->rbAllocInfo.rbsReq = hqP->tbInfo[0].dlGrnt.numRb;
3278          /* Fix : syed iMcs setting did not correspond to RETX */
3279          RG_SCH_CMN_GET_MCS_FOR_RETX((&hqP->tbInfo[0]), 
3280                raCb->rbAllocInfo.tbInfo[0].imcs);
3281          raCb->rbAllocInfo.rnti = raCb->tmpCrnti;
3282          raCb->rbAllocInfo.tbInfo[0].noLyr = hqP->tbInfo[0].numLyrs;
3283          /* Fix; syed Copying info in entirety without depending on stale TX information */
3284          raCb->rbAllocInfo.tbInfo[0].tbCb = &hqP->tbInfo[0];
3285          raCb->rbAllocInfo.tbInfo[0].schdlngForTb = TRUE;
3286
3287          retxBw += raCb->rbAllocInfo.rbsReq;
3288
3289          cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4RetxLst, \
3290                &hqP->reqLnk);
3291          hqP->reqLnk.node = (PTR)hqP;
3292          dlSf->schdCcchUe++;
3293       }
3294    }
3295    dlSf->bwAssigned += retxBw;
3296    RETVOID;
3297 }
3298
3299 \f
3300 /**
3301  * @brief This function implements scheduler DL allocation for
3302  *        for broadcast (on PDSCH) and paging.
3303  *
3304  * @details
3305  *
3306  *     Function: rgSCHCmnDlBcchPcch
3307  *     Purpose:  This function implements scheduler for DL allocation
3308  *               for broadcast (on PDSCH) and paging.
3309  *
3310  *     Invoked by: Scheduler
3311  *
3312  *  @param[in]  RgSchCellCb*     cell
3313  *  @return  S16
3314  *      -# ROK
3315  *      -# RFAILED
3316  **/
3317 #ifdef ANSI
3318 PRIVATE Void rgSCHCmnDlBcchPcch
3319 (
3320 RgSchCellCb             *cell,
3321 RgSchCmnDlRbAllocInfo   *allocInfo,
3322 RgInfSfAlloc            *subfrmAlloc
3323 )
3324 #else
3325 PRIVATE Void rgSCHCmnDlBcchPcch(cell, allocInfo, subfrmAlloc)
3326 RgSchCellCb             *cell;
3327 RgSchCmnDlRbAllocInfo   *allocInfo;
3328 RgInfSfAlloc            *subfrmAlloc;
3329 #endif
3330 {
3331    CmLteTimingInfo   frm;
3332    RgSchDlSf         *sf;
3333    RgSchClcDlLcCb    *pcch;
3334    RgSchClcBoRpt     *bo;
3335 #ifndef RGR_SI_SCH
3336    Bool              valid;
3337    RgSchClcDlLcCb    *bcch, *bch;
3338 #endif/*RGR_SI_SCH*/
3339
3340
3341    TRC2(rgSCHCmnDlBcchPcch);
3342
3343    frm   = cell->crntTime;
3344 #ifdef LTEMAC_HDFDD
3345    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
3346       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
3347    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
3348 #else
3349    RGSCH_SUBFRAME_INDEX(frm);
3350    //RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
3351 #endif
3352
3353    /* Compute the subframe for which allocation is being made        */
3354    /* essentially, we need pointer to the dl frame for this subframe */
3355    sf = rgSCHUtlSubFrmGet(cell, frm);
3356
3357
3358 #ifndef RGR_SI_SCH
3359    bch = rgSCHDbmGetBcchOnBch(cell);
3360 #if (ERRCLASS & ERRCLS_DEBUG)
3361    if (bch == NULLP)
3362    {
3363       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
3364       RETVOID;
3365    }
3366 #endif
3367    if (bch->boLst.first != NULLP)
3368    {
3369       bo = (RgSchClcBoRpt *)(bch->boLst.first->node);
3370       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3371       {
3372          sf->bch.tbSize = bo->bo;
3373          cmLListDelFrm(&bch->boLst, bch->boLst.first);
3374          /* ccpu00117052 - MOD - Passing double pointer
3375             for proper NULLP assignment*/
3376          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(*bo));
3377          rgSCHUtlFillRgInfCmnLcInfo(sf, subfrmAlloc, bch->lcId,TRUE);
3378       }
3379    }
3380    else
3381    {
3382       if ((frm.sfn % 4 == 0) && (frm.subframe == 0))
3383       {
3384       }
3385    }
3386
3387    allocInfo->bcchAlloc.schdFirst = FALSE;
3388    bcch = rgSCHDbmGetFirstBcchOnDlsch(cell);
3389 #if (ERRCLASS & ERRCLS_DEBUG)
3390    if (bcch == NULLP)
3391    {
3392       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
3393       RETVOID;
3394    }
3395 #endif
3396    if (bcch->boLst.first != NULLP)
3397    {
3398       bo = (RgSchClcBoRpt *)(bcch->boLst.first->node);
3399
3400       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3401       {
3402          allocInfo->bcchAlloc.schdFirst = TRUE;
3403          /* Time to perform allocation for this BCCH transmission */
3404          rgSCHCmnClcAlloc(cell, sf, bcch, RGSCH_SI_RNTI, allocInfo);
3405       }
3406    }
3407
3408    if(!allocInfo->bcchAlloc.schdFirst)
3409    {
3410       CmLList   *lnk;
3411       bcch = rgSCHDbmGetSecondBcchOnDlsch(cell);
3412 #if (ERRCLASS & ERRCLS_DEBUG)
3413       if (bcch == NULLP)
3414       {
3415          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
3416          RETVOID;
3417       }
3418 #endif
3419       lnk = bcch->boLst.first;
3420       while (lnk != NULLP)
3421       {
3422          bo = (RgSchClcBoRpt *)(lnk->node);
3423          lnk = lnk->next;
3424          valid = rgSCHCmnChkInWin(frm, bo->timeToTx, bo->maxTimeToTx);
3425
3426          if(valid)
3427          {
3428             bo->i = RGSCH_CALC_SF_DIFF(frm, bo->timeToTx);
3429             /* Time to perform allocation for this BCCH transmission */
3430             rgSCHCmnClcAlloc(cell, sf, bcch, RGSCH_SI_RNTI, allocInfo);
3431             break;
3432          }
3433          else
3434          {
3435             valid = rgSCHCmnChkPastWin(frm, bo->maxTimeToTx);
3436             if(valid)
3437             {
3438                cmLListDelFrm(&bcch->boLst, &bo->boLstEnt);
3439                /* ccpu00117052 - MOD - Passing double pointer
3440                   for proper NULLP assignment*/
3441                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo,
3442                      sizeof(RgSchClcBoRpt));
3443             }
3444          }
3445       }
3446    }
3447 #else
3448    rgSCHDlSiSched(cell, allocInfo, subfrmAlloc);
3449 #endif/*RGR_SI_SCH*/
3450
3451    pcch = rgSCHDbmGetPcch(cell);
3452 #ifdef ERRCLS_KW
3453    if (pcch == NULLP)
3454    {
3455       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
3456       RETVOID;
3457    }
3458 #endif
3459    if (pcch->boLst.first != NULLP)
3460    {
3461       bo = (RgSchClcBoRpt *)(pcch->boLst.first->node);
3462
3463       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3464       {
3465          /* Time to perform allocation for this PCCH transmission */
3466          rgSCHCmnClcAlloc(cell, sf, pcch, RGSCH_P_RNTI, allocInfo);
3467       }
3468    }
3469    RETVOID;
3470 }
3471
3472 /*
3473 *
3474 *       Fun:   rgSCHCmnChkInWin
3475 *
3476 *       Desc:  This function checks if frm occurs in window
3477 *
3478 *       Ret:   TRUE      - if in window
3479 *              FALSE     - otherwise
3480 *
3481 *       Notes: None
3482 *
3483 *       File:  rg_sch_cmn.c
3484 *
3485 */
3486 #ifdef ANSI
3487 PUBLIC Bool rgSCHCmnChkInWin
3488 (
3489 CmLteTimingInfo   frm,
3490 CmLteTimingInfo   start,
3491 CmLteTimingInfo   end
3492 )
3493 #else
3494 PUBLIC Bool rgSCHCmnChkInWin(frm, start, end)
3495 CmLteTimingInfo   frm;
3496 CmLteTimingInfo   start;
3497 CmLteTimingInfo   end;
3498 #endif
3499 {
3500    Bool    inWin = FALSE;
3501
3502    TRC2(rgSCHCmnChkInWin);
3503
3504    if (end.sfn > start.sfn)
3505    {
3506       if (frm.sfn > start.sfn
3507             || (frm.sfn == start.sfn && frm.subframe >= start.subframe))
3508       {
3509          if (frm.sfn < end.sfn
3510 #ifdef EMTC_ENABLE
3511                || (frm.sfn == end.sfn && frm.subframe <= end.subframe))
3512 #else
3513                || (frm.sfn == end.sfn && frm.subframe <= start.subframe))
3514 #endif
3515          {
3516             inWin = TRUE;
3517          }
3518       }
3519    }
3520    /* Testing for wrap around, sfn wraparound check should be enough */
3521    else if (end.sfn < start.sfn)
3522    {
3523       if (frm.sfn > start.sfn
3524             || (frm.sfn == start.sfn && frm.subframe >= start.subframe))
3525       {
3526          inWin = TRUE;
3527       }
3528       else
3529       {
3530          if (frm.sfn < end.sfn
3531                || (frm.sfn == end.sfn && frm.subframe <= end.subframe))
3532          {
3533             inWin = TRUE;
3534          }
3535       }
3536    }
3537    else  /* start.sfn == end.sfn */
3538    {
3539       if (frm.sfn == start.sfn
3540             && (frm.subframe >= start.subframe
3541                && frm.subframe <= end.subframe))
3542       {
3543          inWin = TRUE;
3544       }
3545    }
3546
3547    RETVALUE(inWin);
3548 } /* end of rgSCHCmnChkInWin*/
3549
3550 /*
3551 *
3552 *       Fun:   rgSCHCmnChkPastWin
3553 *
3554 *       Desc:  This function checks if frm has gone past window edge
3555 *
3556 *       Ret:   TRUE      - if past window edge
3557 *              FALSE     - otherwise
3558 *
3559 *       Notes: None
3560 *
3561 *       File:  rg_sch_cmn.c
3562 *
3563 */
3564 #ifdef ANSI
3565 PUBLIC Bool rgSCHCmnChkPastWin
3566 (
3567 CmLteTimingInfo   frm,
3568 CmLteTimingInfo   end
3569 )
3570 #else
3571 PUBLIC Bool rgSCHCmnChkPastWin(frm, end)
3572 CmLteTimingInfo   frm;
3573 CmLteTimingInfo   end;
3574 #endif
3575 {
3576    CmLteTimingInfo  refFrm = end;
3577    Bool             pastWin;
3578
3579    TRC2(rgSCHCmnChkPastWin);
3580
3581    RGSCH_INCR_FRAME(refFrm.sfn);
3582    RGSCH_INCR_SUB_FRAME(end, 1);
3583    pastWin = rgSCHCmnChkInWin(frm, end, refFrm);
3584
3585    RETVALUE(pastWin);
3586 } /* end of rgSCHCmnChkPastWin*/
3587 \f
3588 /**
3589  * @brief This function implements allocation of the resources for common
3590  * channels BCCH, PCCH.
3591  *
3592  * @details
3593  *
3594  *     Function: rgSCHCmnClcAlloc
3595  *     Purpose:  This function implements selection of number of RBs based
3596  *               the allowed grant for the service. It is also responsible
3597  *               for selection of MCS for the transmission.
3598  *
3599  *     Invoked by: Scheduler
3600  *
3601  *  @param[in]  RgSchCellCb                *cell,
3602  *  @param[in]  RgSchDlSf                  *sf,
3603  *  @param[in]  RgSchClcDlLcCb             *lch,
3604  *  @param[in]  U16                        rnti,
3605  *  @param[out] RgSchCmnDlRbAllocInfo      *allocInfo
3606  *  @return     Void
3607  *
3608  **/
3609 #ifdef ANSI
3610 PRIVATE Void rgSCHCmnClcAlloc
3611 (
3612 RgSchCellCb             *cell,
3613 RgSchDlSf               *sf,
3614 RgSchClcDlLcCb          *lch,
3615 U16                     rnti,
3616 RgSchCmnDlRbAllocInfo   *allocInfo
3617 )
3618 #else
3619 PRIVATE Void rgSCHCmnClcAlloc(cell, sf, lch, rnti, allocInfo)
3620 RgSchCellCb             *cell;
3621 RgSchDlSf               *sf;
3622 RgSchClcDlLcCb          *lch;
3623 U16                     rnti;
3624 RgSchCmnDlRbAllocInfo   *allocInfo;
3625 #endif
3626 {
3627    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
3628    RgSchClcBoRpt        *bo;
3629    U32                  rb=0;
3630    U8                   mcs;
3631    U32                  tbs;
3632 #ifdef LTE_TDD   
3633    U8                   lostRe;
3634    U8                   cfi = cellDl->currCfi;  
3635 #endif
3636
3637    TRC2(rgSCHCmnClcAlloc);
3638
3639    bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
3640
3641    mcs = bo->mcs;
3642    tbs = bo->bo;
3643    /* rgSCHCmnClcRbAllocForFxdTb(cell, bo->bo, cellDl->ccchCqi, &rb);*/
3644    if(cellDl->bitsPerRb==0)
3645    {
3646       while ((rgTbSzTbl[0][0][rb]) < (tbs*8))
3647       {
3648          rb++;
3649       }
3650       rb = rb+1;
3651    }
3652    else
3653    {
3654       rb = RGSCH_CEIL((tbs*8), cellDl->bitsPerRb);
3655    }
3656    /* DwPTS Scheduling Changes Start */   
3657 #ifdef LTE_TDD
3658    if(sf->sfType == RG_SCH_SPL_SF_DATA) 
3659    {
3660       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
3661
3662       /* Calculate the less RE's because of DwPTS */
3663       lostRe = rb * (cellDl->noResPerRb[cfi] - cellDl->numReDwPts[cfi]);
3664
3665       /* Increase number of RBs in Spl SF to compensate for lost REs */
3666       rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]); 
3667    }
3668 #endif
3669    /* DwPTS Scheduling Changes End */   
3670    /*ccpu00115595- end*/
3671    /* additional check to see if required RBs
3672     * exceeds the available */
3673    if (rb > sf->bw - sf->bwAssigned)
3674    {
3675       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
3676                 "failed for CRNTI:%d",rnti);
3677       RETVOID;
3678    }
3679
3680    /* Update the subframe Allocated BW field */
3681    sf->bwAssigned = sf->bwAssigned + rb;
3682    /* Fill in the BCCH/PCCH transmission info to the RBAllocInfo struct */
3683    if (rnti == RGSCH_SI_RNTI)
3684    {
3685       allocInfo->bcchAlloc.rnti = rnti;
3686       allocInfo->bcchAlloc.dlSf = sf;
3687       allocInfo->bcchAlloc.tbInfo[0].bytesReq = tbs;
3688       allocInfo->bcchAlloc.rbsReq = rb;
3689       allocInfo->bcchAlloc.tbInfo[0].imcs = mcs;
3690       allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
3691       /* Nprb indication at PHY for common Ch */
3692       allocInfo->bcchAlloc.nPrb = bo->nPrb;
3693    }
3694    else
3695    {
3696       allocInfo->pcchAlloc.rnti = rnti;
3697       allocInfo->pcchAlloc.dlSf = sf;
3698       allocInfo->pcchAlloc.tbInfo[0].bytesReq = tbs;
3699       allocInfo->pcchAlloc.rbsReq = rb;
3700       allocInfo->pcchAlloc.tbInfo[0].imcs = mcs;
3701       allocInfo->pcchAlloc.tbInfo[0].noLyr = 1;
3702       allocInfo->pcchAlloc.nPrb = bo->nPrb;
3703    }
3704    RETVOID;
3705 }
3706
3707 \f
3708 /**
3709  * @brief This function implements PDCCH allocation for common channels.
3710  *
3711  * @details
3712  *
3713  *     Function: rgSCHCmnCmnPdcchAlloc
3714  *     Purpose:  This function implements allocation of PDCCH for a UE.
3715  *               1. This uses index 0 of PDCCH table for efficiency.
3716  *               2. Uses he candidate PDCCH count for the aggr level.
3717  *               3. Look for availability for each candidate and choose
3718  *                  the first one available.
3719  *
3720  *     Invoked by: Scheduler
3721  *
3722  *  @param[in]  RgSchCellCb           *cell
3723  *  @param[in]  RgSchDlSf             *sf
3724  *  @return     RgSchPdcch *
3725  *               -# NULLP when unsuccessful
3726  *
3727  **/
3728 #ifdef ANSI
3729 PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc
3730 (
3731 RgSchCellCb                *cell,
3732 RgSchDlSf                  *subFrm
3733 )
3734 #else
3735 PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
3736 RgSchCellCb                *cell;
3737 RgSchDlSf                  *subFrm;
3738 #endif
3739 {
3740    CmLteAggrLvl         aggrLvl;
3741    RgSchPdcchInfo       *pdcchInfo;
3742    RgSchPdcch           *pdcch;
3743    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
3744    U8                   numCce;  /*store num CCEs based on 
3745                                   aggregation level */
3746    TRC2(rgSCHCmnCmnPdcchAlloc);
3747
3748    aggrLvl   = cellSch->dl.cmnChAggrLvl;
3749
3750    pdcchInfo = &(subFrm->pdcchInfo);
3751
3752     /* Updating the no. of nCce in pdcchInfo, in case if CFI
3753     * was changed  */
3754 #ifdef LTE_TDD
3755    if(subFrm->nCce != pdcchInfo->nCce)
3756    {   
3757       rgSCHUtlPdcchInit(cell, subFrm, subFrm->nCce);
3758    }
3759 #else   
3760    if(cell->nCce != pdcchInfo->nCce)
3761    {
3762       rgSCHUtlPdcchInit(cell, subFrm, cell->nCce);
3763    }
3764 #endif  
3765
3766    switch (aggrLvl)
3767    {
3768       case CM_LTE_AGGR_LVL4:
3769         numCce = 4;
3770         break;
3771       case CM_LTE_AGGR_LVL8:
3772         numCce = 8;
3773         break;
3774                 case CM_LTE_AGGR_LVL16:
3775         numCce = 16;
3776         break;
3777       default:
3778         RETVALUE(NULLP);
3779    }
3780
3781    if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
3782    {
3783 #ifdef LTEMAC_SPS
3784       pdcch->isSpsRnti = FALSE;
3785 #endif
3786       /* Increment the CCE used counter in the current subframe */
3787       subFrm->cceCnt += numCce;
3788       pdcch->pdcchSearchSpace = RG_SCH_CMN_SEARCH_SPACE;
3789
3790       RETVALUE(pdcch);
3791    }
3792
3793    /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
3794    subFrm->isCceFailure = TRUE;
3795
3796    RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
3797             "PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u", 
3798             aggrLvl);
3799    RETVALUE(NULLP);
3800 }
3801
3802 \f
3803 /**
3804  * @brief This function implements bandwidth allocation for common channels.
3805  *
3806  * @details
3807  *
3808  *     Function: rgSCHCmnClcRbAlloc
3809  *     Purpose:  This function implements bandwith allocation logic
3810  *               for common control channels.
3811  *
3812  *     Invoked by: Scheduler
3813  *
3814  *  @param[in]  RgSchCellCb*  cell
3815  *  @param[in]  U32           bo
3816  *  @param[in]  U8            cqi
3817  *  @param[in]  U8            *rb
3818  *  @param[in]  U32           *tbs
3819  *  @param[in]  U8            *mcs
3820  *  @param[in]  RgSchDlSf     *sf
3821  *  @return  Void
3822  *
3823  **/
3824 #ifdef LTEMAC_SPS
3825 #ifdef ANSI
3826 PUBLIC Void rgSCHCmnClcRbAlloc
3827 (
3828 RgSchCellCb             *cell,
3829 U32                     bo,
3830 U8                      cqi,
3831 U8                      *rb,
3832 U32                     *tbs,
3833 U8                      *mcs,
3834 U8                      *iTbs,
3835 Bool                    isSpsBo,
3836 RgSchDlSf               *sf 
3837 )
3838 #else
3839 PUBLIC Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
3840 RgSchCellCb             *cell;
3841 U32                     bo;
3842 U8                      cqi;
3843 U8                      *rb;
3844 U32                     *tbs;
3845 U8                      *mcs;
3846 U8                      *iTbs;
3847 Bool                    isSpsBo;
3848 RgSchDlSf               *sf; 
3849 #endif
3850 #else
3851 #ifdef ANSI
3852 PRIVATE Void rgSCHCmnClcRbAlloc
3853 (
3854 RgSchCellCb             *cell,
3855 U32                     bo,
3856 U8                      cqi,
3857 U8                      *rb,
3858 U32                     *tbs,
3859 U8                      *mcs,
3860 RgSchDlSf               *sf 
3861 )
3862 #else
3863 PRIVATE Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
3864 RgSchCellCb             *cell;
3865 U32                     bo;
3866 U8                      cqi;
3867 U8                      *rb;
3868 U32                     *tbs;
3869 U8                      *mcs;
3870 RgSchDlSf               *sf; 
3871 #endif
3872 #endif /* LTEMAC_SPS */
3873 {
3874    U8                   iTbsVal;
3875    RgSchCmnTbSzEff      *effTbl;
3876    U32                  eff;
3877    U32                  noRes;
3878    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
3879    U8                   cfi = cellSch->dl.currCfi;
3880    U32                  tmpRb=0;
3881    TRC2(rgSCHCmnClcRbAlloc);
3882
3883    /* first get the CQI to MCS table and determine the number of RBs */
3884    effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
3885    iTbsVal = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[cqi];
3886    RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
3887
3888    /* Efficiency is number of bits per 1024 REs */
3889    eff  = (*effTbl)[iTbsVal];
3890
3891    /* Get the number of REs needed for this bo  */
3892    noRes = ((bo * 8 * 1024) / eff );
3893
3894    /* Get the number of RBs needed for this transmission */
3895    /* Number of RBs = No of REs / No of REs per RB       */
3896    tmpRb = RGSCH_CEIL(noRes, cellSch->dl.noResPerRb[cfi]);
3897    /* KWORK_FIX: added check to see if rb has crossed maxRb*/
3898    RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
3899    if (tmpRb > cellSch->dl.maxDlBwPerUe)
3900    {
3901       tmpRb = cellSch->dl.maxDlBwPerUe;
3902    }
3903    while ((rgTbSzTbl[0][iTbsVal][tmpRb-1]/8) < bo && 
3904            (tmpRb < cellSch->dl.maxDlBwPerUe))
3905    {
3906       tmpRb++;
3907       RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
3908    }
3909    *tbs =  rgTbSzTbl[0][iTbsVal][tmpRb-1]/8;
3910    *rb = (U8)tmpRb;
3911    RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
3912
3913    RETVOID;
3914 }
3915
3916 \f
3917
3918 /**
3919  * @brief Scheduling for MSG4.
3920  *
3921  * @details
3922  *
3923  *     Function: rgSCHCmnMsg4Alloc
3924  *     Purpose:  Scheduling for MSG4
3925  *
3926  *     Invoked by: Scheduler
3927  *
3928  *  @param[in]  RgSchCellCb*          cell
3929  *  @param[in]  RgSchRaCb*            raCb
3930  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3931  *  @return  S16
3932  *
3933  **/
3934 #ifdef ANSI
3935 PRIVATE S16 rgSCHCmnMsg4Alloc
3936 (
3937 RgSchCellCb                *cell,
3938 RgSchRaCb                  *raCb,
3939 RgSchCmnDlRbAllocInfo      *allocInfo
3940 )
3941 #else
3942 PRIVATE S16 rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)
3943 RgSchCellCb                *cell;
3944 RgSchRaCb                  *raCb;
3945 RgSchCmnDlRbAllocInfo      *allocInfo;
3946 #endif
3947 {
3948    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
3949
3950    TRC2(rgSCHCmnMsg4Alloc);
3951
3952  /* SR_RACH_STATS : MSG4 TO BE TXED */
3953    rgNumMsg4ToBeTx++;
3954    /* Return if subframe BW exhausted */
3955    if (allocInfo->msg4Alloc.msg4DlSf->bw <=
3956        allocInfo->msg4Alloc.msg4DlSf->bwAssigned)
3957    {
3958       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
3959          "bw<=bwAssigned");
3960       RETVALUE(RFAILED);
3961    }
3962
3963    if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
3964    {
3965       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
3966          "rgSCHDhmGetMsg4HqProc failed");
3967       RETVALUE(RFAILED);
3968    }
3969
3970    raCb->rbAllocInfo.dlSf = allocInfo->msg4Alloc.msg4DlSf;
3971
3972    if (rgSCHCmnMsg4DedAlloc(cell, raCb) != ROK)
3973    {
3974       /* Fix : syed Minor failure handling, release hqP if Unsuccessful */    
3975       rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
3976       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
3977          "rgSCHCmnMsg4DedAlloc failed.");
3978       RETVALUE(RFAILED);
3979    }
3980    cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
3981    raCb->dlHqE->msg4Proc->reqLnk.node = (PTR)raCb->dlHqE->msg4Proc;
3982    allocInfo->msg4Alloc.msg4DlSf->schdCcchUe++;
3983
3984    RETVALUE(ROK);
3985 }
3986
3987 \f
3988 /**
3989  * @brief This function implements PDCCH allocation for an UE.
3990  *
3991  * @details
3992  *
3993  *     Function: PdcchAlloc
3994  *     Purpose:  This function implements allocation of PDCCH for an UE.
3995  *               1. Get the aggregation level for the CQI of the UE.
3996  *               2. Get the candidate PDCCH count for the aggr level.
3997  *               3. Look for availability for each candidate and choose
3998  *                  the first one available.
3999  *
4000  *     Invoked by: Scheduler
4001  *
4002  *  @param[in]  cell
4003  *  @param[in]  subFrm
4004  *  @param[in]  cqi
4005  *  @param[in]  dciFrmt
4006  *  @return  RgSchPdcch *
4007  *         -# NULLP when unsuccessful
4008  *
4009  **/
4010 #ifdef ANSI
4011 PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc
4012 (
4013 RgSchCellCb             *cell,
4014 RgSchUeCb               *ue,
4015 RgSchDlSf               *subFrm,
4016 U8                      cqi,
4017 TfuDciFormat            dciFrmt,
4018 Bool                    isDtx
4019 )
4020 #else
4021 PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
4022 RgSchCellCb             *cell;
4023 RgSchUeCb               *ue;
4024 RgSchDlSf               *subFrm;
4025 U8                      cqi;
4026 TfuDciFormat            dciFrmt;
4027 Bool                    isDtx;
4028 #endif
4029 {
4030    CmLteAggrLvl     aggrLvl;
4031    RgSchPdcchInfo   *pdcchInfo;
4032    RgSchPdcch       *pdcch;
4033
4034    TRC2(rgSCHCmnPdcchAlloc);
4035
4036    /* 3.1 consider the selected DCI format size in determining the
4037     * aggregation level */
4038    //TODO_SID Need to update. Currently using 4 aggregation level
4039    aggrLvl   = CM_LTE_AGGR_LVL2;//cellSch->dciAggrLvl[cqi][dciFrmt];
4040
4041 #ifdef LTE_ADV
4042    if((dciFrmt == TFU_DCI_FORMAT_1A) &&
4043       ((ue) && (ue->allocCmnUlPdcch)) )
4044    {
4045       pdcch = rgSCHCmnCmnPdcchAlloc(cell, subFrm);
4046       /* Since CRNTI Scrambled */
4047       if(NULLP != pdcch)
4048       {
4049          pdcch->dciNumOfBits = ue->dciSize.cmnSize[dciFrmt];
4050         // prc_trace_format_string(PRC_TRACE_GROUP_PS, PRC_TRACE_INFO_LOW,"Forcing alloc in CMN search spc size %d fmt %d \n",
4051         // pdcch->dciNumOfBits, dciFrmt);
4052       }
4053       RETVALUE(pdcch);
4054    }
4055 #endif
4056
4057    /* Incrementing aggrLvl by 1 if it not AGGR_LVL8(MAX SIZE)
4058     * inorder to increse the redudancy bits for better decoding of UE */
4059    if (isDtx)
4060    {
4061       if (aggrLvl != CM_LTE_AGGR_LVL16)
4062       {
4063          switch(aggrLvl)
4064          {
4065             case CM_LTE_AGGR_LVL2:
4066                aggrLvl = CM_LTE_AGGR_LVL4;
4067                 break;
4068             case CM_LTE_AGGR_LVL4:
4069                aggrLvl = CM_LTE_AGGR_LVL8;
4070                break;
4071             case CM_LTE_AGGR_LVL8:
4072                aggrLvl = CM_LTE_AGGR_LVL16;
4073                break;
4074             default:
4075                break;
4076          }
4077          /* aggrLvl   += 1; */
4078       }
4079    }
4080
4081    pdcchInfo = &subFrm->pdcchInfo;
4082
4083    /* Updating the no. of nCce in pdcchInfo, in case if CFI
4084     * was changed  */
4085 #ifdef LTE_TDD
4086    if(subFrm->nCce != pdcchInfo->nCce)
4087    {   
4088       rgSCHUtlPdcchInit(cell, subFrm, subFrm->nCce);
4089    }
4090 #else   
4091    if(cell->nCce != pdcchInfo->nCce)
4092    {
4093       rgSCHUtlPdcchInit(cell, subFrm, cell->nCce);
4094    }
4095 #endif       
4096
4097    if (pdcchInfo->nCce < (1 << (aggrLvl - 1)))
4098    {
4099       /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
4100       subFrm->isCceFailure = TRUE;
4101       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
4102             "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)", 
4103             aggrLvl);
4104
4105       RETVALUE(NULLP);
4106    }
4107
4108    if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
4109    {
4110       /* SR_RACH_STATS : Reset isTBMsg4 */
4111       pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4= FALSE;         
4112       pdcch->dci.u.format0Info.isSrGrant = FALSE;
4113 #ifdef LTEMAC_SPS
4114       pdcch->isSpsRnti = FALSE;
4115 #endif
4116       /* Increment the CCE used counter in the current subframe */
4117       subFrm->cceCnt += aggrLvl;
4118       pdcch->pdcchSearchSpace = RG_SCH_UE_SPECIFIC_SEARCH_SPACE;
4119       if (ue != NULLP)
4120                 {
4121 #ifdef LTE_ADV
4122                  if (ue->cell != cell)
4123                  {
4124                     /* Secondary Cell */
4125                     //pdcch->dciNumOfBits = ue->dciSize.noUlCcSize[dciFrmt];
4126                     pdcch->dciNumOfBits = MAX_5GTF_DCIA1B1_SIZE;
4127                  }
4128                  else
4129 #endif
4130                  {
4131                     //pdcch->dciNumOfBits = ue->dciSize.dedSize[dciFrmt];
4132                     //TODO_SID Need to update dci size.
4133                     pdcch->dciNumOfBits = MAX_5GTF_DCIA1B1_SIZE;
4134                  }
4135                 }
4136       else
4137       {
4138          /* MSG4 */
4139          pdcch->dciNumOfBits = cell->dciSize.size[dciFrmt];
4140       }
4141       RETVALUE(pdcch);
4142    }
4143
4144    /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
4145    subFrm->isCceFailure = TRUE;
4146
4147    RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
4148          "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
4149          aggrLvl);
4150    RETVALUE(NULLP);
4151 }
4152
4153 #ifdef RGR_V1
4154 /**
4155  * @brief This function implements BW allocation for CCCH SDU
4156  *
4157  * @details
4158  *
4159  *     Function: rgSCHCmnCcchSduDedAlloc
4160  *     Purpose:  Downlink bandwidth Allocation for CCCH SDU.
4161  *
4162  *     Invoked by: Scheduler
4163  *
4164  *  @param[in]  RgSchCellCb*     cell
4165  *  @param[out] RgSchUeCb        *ueCb
4166  *  @return S16
4167  *
4168  **/
4169 #ifdef ANSI
4170 PRIVATE S16 rgSCHCmnCcchSduDedAlloc
4171 (
4172 RgSchCellCb      *cell,
4173 RgSchUeCb        *ueCb
4174 )
4175 #else
4176 PRIVATE S16 rgSCHCmnCcchSduDedAlloc(cell, ueCb)
4177 RgSchCellCb      *cell;
4178 RgSchUeCb        *ueCb;
4179 #endif
4180 {
4181    RgSchDlHqEnt      *hqE = NULLP;
4182    U32                  effBo;
4183    RgSchDlRbAlloc       *rbAllocinfo = NULLP;
4184    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4185    U8                   iTbs;
4186    U8                   numRb;
4187 #ifdef LTE_TDD
4188    U8                   cfi     = cellDl->currCfi;
4189 #endif
4190
4191    TRC2(rgSCHCmnCcchSduDedAlloc);
4192
4193    rbAllocinfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
4194
4195    effBo  =   ueCb->dlCcchInfo.bo + RGSCH_CCCH_SDU_HDRSIZE;
4196
4197 #ifndef LTEMAC_SPS
4198    rgSCHCmnClcRbAlloc(cell, effBo, cellDl->ccchCqi, &rbAllocinfo->rbsReq, \
4199                       &rbAllocinfo->tbInfo[0].bytesReq,
4200                       &rbAllocinfo->tbInfo[0].imcs, rbAllocinfo->dlSf);
4201 #else /* LTEMAC_SPS */
4202    rgSCHCmnClcRbAlloc(cell, effBo, cellDl->ccchCqi, &rbAllocinfo->rbsReq, \
4203                       &rbAllocinfo->tbInfo[0].bytesReq,\
4204                       &rbAllocinfo->tbInfo[0].imcs, &iTbs, FALSE, 
4205                       rbAllocinfo->dlSf);
4206 #endif /* LTEMAC_SPS */
4207
4208    iTbs = 0;
4209    /* Cannot exceed the total number of RBs in the cell */
4210    if ((S16)rbAllocinfo->rbsReq > ((S16)(rbAllocinfo->dlSf->bw - \
4211                                    rbAllocinfo->dlSf->bwAssigned)))
4212    {
4213       /* Check if atleast one allocation was possible.
4214          This may be the case where the Bw is very less and
4215          with the configured CCCH CQI, CCCH SDU exceeds the min Bw */
4216       if (rbAllocinfo->dlSf->bwAssigned == 0)
4217       {
4218          numRb   = rbAllocinfo->dlSf->bw;
4219          RG_SCH_CMN_DL_MCS_TO_TBS(rbAllocinfo->tbInfo[0].imcs, iTbs);
4220          while (rgTbSzTbl[0][++iTbs][numRb-1]/8 < effBo)
4221          {
4222             iTbs++;
4223          }
4224          rbAllocinfo->rbsReq = numRb;
4225          rbAllocinfo->tbInfo[0].bytesReq = rgTbSzTbl[0][iTbs][numRb-1]/8;
4226          /* DwPTS Scheduling Changes Start */
4227 #ifdef LTE_TDD
4228          if(rbAllocinfo->dlSf->sfType == RG_SCH_SPL_SF_DATA)
4229          {
4230             rbAllocinfo->tbInfo[0].bytesReq =
4231                rgSCHCmnCalcDwPtsTbSz(cell, effBo, &numRb, &iTbs, 1,cfi);
4232          }
4233 #endif
4234          /* DwPTS Scheduling Changes End */
4235          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, rbAllocinfo->tbInfo[0].imcs);
4236       }
4237       else
4238       {
4239          RETVALUE(RFAILED);
4240       }
4241    }
4242
4243    /* Update the subframe Allocated BW field */
4244    rbAllocinfo->dlSf->bwAssigned = rbAllocinfo->dlSf->bwAssigned + \
4245                                    rbAllocinfo->rbsReq;
4246    hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
4247    rbAllocinfo->tbInfo[0].tbCb = &hqE->ccchSduProc->tbInfo[0];
4248    rbAllocinfo->rnti = ueCb->ueId;
4249    rbAllocinfo->tbInfo[0].noLyr = 1;
4250
4251    RETVALUE(ROK);
4252 }
4253 #endif
4254 \f
4255 /**
4256  * @brief This function implements BW allocation for MSG4
4257  *
4258  * @details
4259  *
4260  *     Function: rgSCHCmnMsg4DedAlloc
4261  *     Purpose:  Downlink bandwidth Allocation for MSG4.
4262  *
4263  *     Invoked by: Scheduler
4264  *
4265  *  @param[in]  RgSchCellCb*     cell
4266  *  @param[out] RgSchRaCb        *raCb
4267  *  @return S16
4268  *
4269  **/
4270 #ifdef ANSI
4271 PRIVATE S16 rgSCHCmnMsg4DedAlloc
4272 (
4273 RgSchCellCb      *cell,
4274 RgSchRaCb        *raCb
4275 )
4276 #else
4277 PRIVATE S16 rgSCHCmnMsg4DedAlloc(cell, raCb)
4278 RgSchCellCb      *cell;
4279 RgSchRaCb        *raCb;
4280 #endif
4281 {
4282    U32                  effBo;
4283    RgSchDlRbAlloc       *rbAllocinfo = &raCb->rbAllocInfo;
4284    U8                   iTbs;
4285    U8                   numRb;
4286 #ifdef LTE_TDD
4287    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4288    U8                   cfi     = cellDl->currCfi;
4289 #endif
4290
4291    TRC2(rgSCHCmnMsg4DedAlloc);
4292
4293    effBo  = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
4294
4295 #ifndef LTEMAC_SPS
4296    rgSCHCmnClcRbAlloc(cell, effBo, raCb->ccchCqi, &rbAllocinfo->rbsReq, \
4297          &rbAllocinfo->tbInfo[0].bytesReq,\
4298          &rbAllocinfo->tbInfo[0].imcs, rbAllocinfo->dlSf);
4299 #else /* LTEMAC_SPS */
4300    rgSCHCmnClcRbAlloc(cell, effBo, raCb->ccchCqi, &rbAllocinfo->rbsReq, \
4301                       &rbAllocinfo->tbInfo[0].bytesReq,\
4302                       &rbAllocinfo->tbInfo[0].imcs, &iTbs, FALSE,
4303                       rbAllocinfo->dlSf);
4304 #endif /* LTEMAC_SPS */
4305
4306    iTbs = 0;
4307    /* Cannot exceed the total number of RBs in the cell */
4308    if ((S16)rbAllocinfo->rbsReq > ((S16)(rbAllocinfo->dlSf->bw - \
4309                rbAllocinfo->dlSf->bwAssigned)))
4310    {
4311       /* Check if atleast one allocation was possible.
4312          This may be the case where the Bw is very less and
4313          with the configured CCCH CQI, CCCH SDU exceeds the min Bw */
4314       if (rbAllocinfo->dlSf->bwAssigned == 0)
4315       {
4316          numRb   = rbAllocinfo->dlSf->bw;
4317          RG_SCH_CMN_DL_MCS_TO_TBS(rbAllocinfo->tbInfo[0].imcs, iTbs);
4318          while (rgTbSzTbl[0][++iTbs][numRb-1]/8 < effBo)
4319          {
4320             iTbs++;
4321          }
4322          rbAllocinfo->rbsReq = numRb;
4323          rbAllocinfo->tbInfo[0].bytesReq = rgTbSzTbl[0][iTbs][numRb-1]/8;
4324          /* DwPTS Scheduling Changes Start */
4325 #ifdef LTE_TDD
4326          if(rbAllocinfo->dlSf->sfType == RG_SCH_SPL_SF_DATA)
4327          {
4328             rbAllocinfo->tbInfo[0].bytesReq =
4329                rgSCHCmnCalcDwPtsTbSz(cell, effBo, &numRb, &iTbs, 1, cfi);
4330          }
4331 #endif
4332          /* DwPTS Scheduling Changes End */
4333          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, rbAllocinfo->tbInfo[0].imcs);
4334       }
4335       else
4336       {
4337          RETVALUE(RFAILED);
4338       }
4339    }
4340
4341    /* Update the subframe Allocated BW field */
4342    rbAllocinfo->dlSf->bwAssigned = rbAllocinfo->dlSf->bwAssigned + \
4343                                    rbAllocinfo->rbsReq;
4344    rbAllocinfo->rnti = raCb->tmpCrnti;
4345    rbAllocinfo->tbInfo[0].tbCb = &raCb->dlHqE->msg4Proc->tbInfo[0];
4346    rbAllocinfo->tbInfo[0].schdlngForTb = TRUE;
4347    rbAllocinfo->tbInfo[0].noLyr = 1;
4348
4349    RETVALUE(ROK);
4350 }
4351
4352 #ifdef LTE_TDD
4353 /**
4354  * @brief This function implements scheduling for RA Response.
4355  *
4356  * @details
4357  *
4358  *     Function: rgSCHCmnDlRaRsp
4359  *     Purpose:  Downlink scheduling for RA responses.
4360  *
4361  *     Invoked by: Scheduler
4362  *
4363  *  @param[in]  RgSchCellCb*     cell
4364  *  @return  Void
4365  *
4366  **/
4367 #ifdef ANSI
4368 PRIVATE Void rgSCHCmnDlRaRsp
4369 (
4370 RgSchCellCb                *cell,
4371 RgSchCmnDlRbAllocInfo      *allocInfo
4372 )
4373 #else
4374 PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
4375 RgSchCellCb                *cell;
4376 RgSchCmnDlRbAllocInfo      *allocInfo;
4377 #endif
4378 {
4379    CmLteTimingInfo      frm;
4380    CmLteTimingInfo      schFrm;
4381    RgSchDlSf            *subFrm;
4382    U16                  rarnti;
4383    U8                   i;
4384    U8                   noRaRnti=0;
4385    U8                   raIdx;
4386    RgSchTddRachRspLst   *rachRsp;
4387    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
4388    U8                   sfnIdx;
4389    U8                   subfrmIdx;
4390    U16                  rntiIdx=0;
4391    TRC2(rgSCHCmnDlRaRsp);
4392
4393    frm   = cell->crntTime;
4394    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
4395
4396    /* Compute the subframe for which allocation is being made        */
4397    /* essentially, we need pointer to the dl frame for this subframe */
4398    subFrm  = rgSCHUtlSubFrmGet(cell, frm);
4399
4400    /* Get the RACH Response scheduling related information
4401     * for the subframe with RA index */
4402    raIdx = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][frm.subframe]-1;
4403
4404    rachRsp = &cell->rachRspLst[raIdx];
4405
4406    for(sfnIdx = 0; sfnIdx < rachRsp->numRadiofrms; sfnIdx++)
4407    {
4408       /* For all scheduled RACH Responses in SFNs */
4409       schFrm = frm;
4410       RG_SCH_CMN_DECR_FRAME(schFrm.sfn, rachRsp->rachRsp[sfnIdx].sfnOffset);
4411       /* For all scheduled RACH Responses in subframes */
4412       for(subfrmIdx = 0;
4413             subfrmIdx < rachRsp->rachRsp[sfnIdx].numSubfrms; subfrmIdx++)
4414       {
4415          schFrm.subframe = rachRsp->rachRsp[sfnIdx].subframe[subfrmIdx];
4416          /* compute the last RA RNTI used in the previous subframe */
4417          raIdx = (((schFrm.sfn % cell->raInfo.maxRaSize) * \
4418                   RGSCH_NUM_SUB_FRAMES * RGSCH_MAX_RA_RNTI_PER_SUBFRM) \
4419                                     + schFrm.subframe);
4420
4421          /* For all RA RNTIs within a subframe */
4422
4423          for(i=0; (i < RGSCH_MAX_RA_RNTI_PER_SUBFRM) && \
4424                (noRaRnti < RGSCH_MAX_TDD_RA_RSP_ALLOC); i++)
4425          {
4426             rarnti = (schFrm.subframe + RGSCH_NUM_SUB_FRAMES*i + 1);
4427             rntiIdx = (raIdx + RGSCH_NUM_SUB_FRAMES*i);
4428
4429             if (cell->raInfo.raReqLst[rntiIdx].first != NULLP)
4430             {
4431                /* compute the next RA RNTI */
4432                if (rgSCHCmnRaRspAlloc(cell, subFrm, rntiIdx,
4433                         rarnti, noRaRnti, allocInfo) != ROK)
4434                {
4435                   /* The resources are exhausted */
4436                   break;
4437                }
4438                noRaRnti++;
4439             }
4440          }
4441          noRaRnti=0;
4442       }
4443    }
4444
4445    RETVOID;
4446 }
4447 #else
4448 /**
4449  * @brief This function implements scheduling for RA Response.
4450  *
4451  * @details
4452  *
4453  *     Function: rgSCHCmnDlRaRsp
4454  *     Purpose:  Downlink scheduling for RA responses.
4455  *
4456  *     Invoked by: Scheduler
4457  *
4458  *  @param[in]  RgSchCellCb*          cell
4459  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
4460  *  @return  Void
4461  *
4462  **/
4463 #ifdef ANSI
4464 PRIVATE Void rgSCHCmnDlRaRsp  //FDD
4465 (
4466 RgSchCellCb                *cell,
4467 RgSchCmnDlRbAllocInfo      *allocInfo
4468 )
4469 #else
4470 PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
4471 RgSchCellCb                *cell;
4472 RgSchCmnDlRbAllocInfo      *allocInfo;
4473 #endif
4474 {
4475    CmLteTimingInfo      frm;
4476    CmLteTimingInfo      winStartFrm;
4477    RgSchDlSf            *subFrm;
4478    U8                   winStartIdx;
4479    U8                   winGap;
4480    U8                   rarnti;
4481    U8                   raIdx;
4482    RgSchCmnCell         *sched;
4483    U8                   i,noRaRnti=0;
4484    TRC2(rgSCHCmnDlRaRsp);
4485
4486    frm   = cell->crntTime;
4487    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
4488
4489    /* Compute the subframe for which allocation is being made        */
4490    /* essentially, we need pointer to the dl frame for this subframe */
4491    subFrm  = rgSCHUtlSubFrmGet(cell, frm);
4492    sched   = RG_SCH_CMN_GET_CELL(cell);
4493
4494    /* ccpu00132523 - Window Start calculated by considering RAR window size, 
4495     * RAR Wait period, Subframes occuppied for respective preamble format*/
4496    winGap = (sched->dl.numRaSubFrms-1) + (cell->rachCfg.raWinSize-1) 
4497              +RGSCH_RARSP_WAIT_PERIOD;
4498
4499    /* Window starting occassion is retrieved using the gap and tried to 
4500     * fit to the size of raReqLst array*/ 
4501    RGSCHDECRFRMCRNTTIME(frm, winStartFrm, winGap);
4502
4503         //5G_TODO TIMING update. Need to check
4504    winStartIdx = (winStartFrm.sfn & 1) * RGSCH_MAX_RA_RNTI+ winStartFrm.subframe;
4505
4506    for(i = 0; ((i < cell->rachCfg.raWinSize) && (noRaRnti < RG_SCH_CMN_MAX_CMN_PDCCH)); i++)
4507    {
4508       raIdx = (winStartIdx + i) % RGSCH_RAREQ_ARRAY_SIZE;
4509
4510       if (cell->raInfo.raReqLst[raIdx].first != NULLP)
4511       {
4512          allocInfo->raRspAlloc[noRaRnti].biEstmt = \
4513                          (!i * RGSCH_ONE_BIHDR_SIZE);
4514          rarnti = raIdx % RGSCH_MAX_RA_RNTI+ 1;
4515          if (rgSCHCmnRaRspAlloc(cell, subFrm, raIdx,
4516                                  rarnti, noRaRnti, allocInfo) != ROK)
4517          {
4518             /* The resources are exhausted */
4519             break;
4520          }
4521          /* ccpu00132523- If all the RAP ids are not scheduled then need not 
4522           * proceed for next RA RNTIs*/
4523          if(allocInfo->raRspAlloc[noRaRnti].numRapids < cell->raInfo.raReqLst[raIdx].count)
4524          {
4525             break;
4526          }
4527          noRaRnti++; /* Max of RG_SCH_CMN_MAX_CMN_PDCCH RARNTIs
4528                         for response allocation */
4529       }
4530    }
4531    RETVOID;
4532 }
4533 #endif
4534
4535 \f
4536 /**
4537  * @brief This function allocates the resources for an RARNTI.
4538  *
4539  * @details
4540  *
4541  *     Function: rgSCHCmnRaRspAlloc
4542  *     Purpose:  Allocate resources to a RARNTI.
4543  *               0. Allocate PDCCH for sending the response.
4544  *               1. Locate the number of RA requests pending for the RARNTI.
4545  *               2. Compute the size of data to be built.
4546  *               3. Using common channel CQI, compute the number of RBs.
4547  *
4548  *     Invoked by: Scheduler
4549  *
4550  *  @param[in]  RgSchCellCb             *cell,
4551  *  @param[in]  RgSchDlSf               *subFrm,
4552  *  @param[in]  U16                     rarnti,
4553  *  @param[in]  U8                      noRaRnti
4554  *  @param[out] RgSchCmnDlRbAllocInfo   *allocInfo
4555  *  @return  S16
4556  *
4557  **/
4558 #ifdef ANSI
4559 PRIVATE S16 rgSCHCmnRaRspAlloc
4560 (
4561 RgSchCellCb             *cell,
4562 RgSchDlSf               *subFrm,
4563 U16                     raIndex,
4564 U16                     rarnti,
4565 U8                      noRaRnti,
4566 RgSchCmnDlRbAllocInfo   *allocInfo
4567 )
4568 #else
4569 PRIVATE S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
4570 RgSchCellCb             *cell;
4571 RgSchDlSf               *subFrm;
4572 U16                     raIndex;
4573 U16                     rarnti;
4574 U8                      noRaRnti;
4575 RgSchCmnDlRbAllocInfo   *allocInfo;
4576 #endif
4577 {
4578    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4579    RgSchCmnUlCell       *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4580    U16                  noBytes;
4581    U32                  rb = 0;
4582    U32                  tbs;
4583    /*ccpu00116700,ccpu00116708- Corrected the wrong type for mcs*/
4584    U8                   mcs;
4585    CmLListCp            *reqLst;
4586    /* RACH handling related changes */
4587    Bool                 isAlloc = FALSE;
4588    static U8            schdNumRapid = 0;
4589    U8                   remNumRapid = 0;
4590    U8                   nPrb = 0;
4591    S32                  allwdTbSz = 0;
4592 #ifdef LTE_TDD   
4593    U16                  lostRe;  
4594    U8                   cfi = cellDl->currCfi;  
4595 #endif   
4596
4597    TRC2(rgSCHCmnRaRspAlloc);
4598 #ifndef RGR_V1
4599    UNUSED(cellUl);
4600 #endif
4601
4602    /* ccpu00132523: Resetting the schdRap Id count in every scheduling subframe*/
4603    if(noRaRnti == 0)
4604    {
4605       schdNumRapid = 0;
4606    }
4607
4608
4609    if (subFrm->bw == subFrm->bwAssigned)
4610    {
4611       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4612          "bw == bwAssigned RARNTI:%d",rarnti);
4613       RETVALUE(RFAILED);
4614    }
4615
4616    reqLst = &cell->raInfo.raReqLst[raIndex];
4617    if (reqLst->count == 0)
4618    {
4619       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4620          "reqLst Count=0 RARNTI:%d",rarnti);
4621       RETVALUE(RFAILED);
4622    }
4623    remNumRapid = reqLst->count;
4624
4625 #ifdef RGR_V1
4626    /* Limit number of rach rsps to maxMsg3PerUlsf */
4627    if ( schdNumRapid+remNumRapid > cellUl->maxMsg3PerUlSf )
4628    {
4629       remNumRapid = cellUl->maxMsg3PerUlSf-schdNumRapid;
4630    }
4631 #endif
4632  
4633    while (remNumRapid)
4634    {
4635       /* Try allocating for as many RAPIDs as possible */
4636       /* BI sub-header size to the tbSize requirement */
4637       noBytes  = RGSCH_GET_RAR_BYTES(remNumRapid) +\
4638                  allocInfo->raRspAlloc[noRaRnti].biEstmt;
4639       if ((allwdTbSz = rgSCHUtlGetAllwdCchTbSz(noBytes*8, &nPrb, &mcs)) == -1)
4640       {
4641          remNumRapid--;
4642          continue;
4643       }
4644
4645       /* rgSCHCmnClcRbAllocForFxdTb(cell, allwdTbSz/8, cellDl->ccchCqi, &rb);*/
4646       if(cellDl->bitsPerRb==0)
4647       {
4648          while ((rgTbSzTbl[0][0][rb]) <(U32) allwdTbSz)
4649          {
4650             rb++;
4651          }
4652          rb = rb+1;
4653       }
4654       else
4655       {
4656          rb = RGSCH_CEIL(allwdTbSz, cellDl->bitsPerRb);
4657       }
4658       /* DwPTS Scheduling Changes Start */      
4659 #ifdef LTE_TDD      
4660       if (subFrm->sfType == RG_SCH_SPL_SF_DATA)
4661       {
4662          RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
4663
4664          /* Calculate the less RE's because of DwPTS */
4665          lostRe = rb * (cellDl->noResPerRb[cfi] - 
4666                                   cellDl->numReDwPts[cfi]);
4667           
4668          /* Increase number of RBs in Spl SF to compensate for lost REs */
4669          rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]);
4670       }
4671 #endif      
4672       /* DwPTS Scheduling Changes End */
4673
4674       /*ccpu00115595- end*/
4675       if (rb > subFrm->bw - subFrm->bwAssigned)
4676       {
4677          remNumRapid--;
4678          continue;
4679       }
4680       /* Allocation succeeded for 'remNumRapid' */
4681       isAlloc = TRUE;
4682       tbs = allwdTbSz/8;
4683       printf("\n!!!RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
4684                                       noBytes,allwdTbSz,tbs,rb);
4685       break;
4686    }
4687    if (!isAlloc)
4688    {
4689       RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
4690       RETVALUE(RFAILED);
4691    }
4692
4693    subFrm->bwAssigned = subFrm->bwAssigned + rb;
4694
4695    /* Fill AllocInfo structure */
4696    allocInfo->raRspAlloc[noRaRnti].rnti = rarnti;
4697    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].bytesReq = tbs;
4698    allocInfo->raRspAlloc[noRaRnti].rbsReq = rb;
4699    allocInfo->raRspAlloc[noRaRnti].dlSf = subFrm;
4700    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].imcs = mcs;
4701    allocInfo->raRspAlloc[noRaRnti].raIndex = raIndex;
4702    /* RACH changes for multiple RAPID handling */
4703    allocInfo->raRspAlloc[noRaRnti].numRapids = remNumRapid;
4704    allocInfo->raRspAlloc[noRaRnti].nPrb = nPrb;
4705    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].noLyr = 1;
4706    allocInfo->raRspAlloc[noRaRnti].vrbgReq = RGSCH_CEIL(nPrb,MAX_5GTF_VRBG_SIZE); 
4707    schdNumRapid += remNumRapid; 
4708    RETVALUE(ROK);
4709 }
4710
4711 /***********************************************************
4712  *
4713  *     Func : rgSCHCmnUlAllocFillRbInfo
4714  *
4715  *     Desc : Fills the start RB and the number of RBs for
4716  *            uplink allocation.
4717  *
4718  *     Ret  : void
4719  *
4720  *     Notes:
4721  *
4722  *     File :
4723  *
4724  **********************************************************/
4725 #ifdef ANSI
4726 PUBLIC Void rgSCHCmnUlAllocFillRbInfo
4727 (
4728 RgSchCellCb   *cell,
4729 RgSchUlSf      *sf,
4730 RgSchUlAlloc  *alloc
4731 )
4732 #else
4733 PUBLIC Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
4734 RgSchCellCb    *cell;
4735 RgSchUlSf      *sf;
4736 RgSchUlAlloc   *alloc;
4737 #endif
4738 {
4739     RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4740     RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4741     U8             cfi = cellDl->currCfi;
4742
4743
4744    TRC2(rgSCHCmnUlAllocFillRbInfo);
4745    alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) + 
4746                                     cell->dynCfiCb.bwInfo[cfi].startRb;
4747
4748    /* Num RBs = numSbAllocated * sbSize - less RBs in the last SB */
4749    alloc->grnt.numRb = (alloc->numSb * cellUl->sbSize);
4750
4751    RETVOID;
4752 }
4753
4754 /**
4755  * @brief Grant request for Msg3.
4756  *
4757  * @details
4758  *
4759  *     Function : rgSCHCmnMsg3GrntReq
4760  *
4761  *     This is invoked by downlink scheduler to request allocation
4762  *     for msg3.
4763  *     Steps:
4764  *     - Attempt to allocate msg3 in the current msg3 subframe
4765  *       Allocation attempt based on whether preamble is from group A
4766  *       and the value of MESSAGE_SIZE_GROUP_A
4767  *     - Link allocation with passed RNTI and msg3 HARQ process
4768  *     - Set the HARQ process ID (*hqProcIdRef)
4769  *
4770  *  @param[in]  RgSchCellCb       *cell
4771  *  @param[in]  CmLteRnti         rnti
4772  *  @param[in]  Bool              preamGrpA
4773  *  @param[in]  RgSchUlHqProcCb   *hqProc
4774  *  @param[out] RgSchUlAlloc      **ulAllocRef
4775  *  @param[out] U8                *hqProcIdRef
4776  *  @return  Void
4777  **/
4778 #ifdef ANSI
4779 PRIVATE Void rgSCHCmnMsg3GrntReq
4780 (
4781 RgSchCellCb     *cell,
4782 CmLteRnti       rnti,
4783 Bool            preamGrpA,
4784 RgSchUlHqProcCb *hqProc,
4785 RgSchUlAlloc    **ulAllocRef,
4786 U8              *hqProcIdRef
4787 )
4788 #else
4789 PRIVATE Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
4790                                  ulAllocRef, hqProcIdRef)
4791 RgSchCellCb     *cell;
4792 CmLteRnti       rnti;
4793 Bool            preamGrpA;
4794 RgSchUlHqProcCb *hqProc;
4795 RgSchUlAlloc    **ulAllocRef;
4796 U8              *hqProcIdRef;
4797 #endif
4798 {
4799    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4800    RgSchUlSf       *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
4801    RgSchUlHole     *hole;
4802    RgSchUlAlloc    *alloc;
4803    U8              iMcs;
4804    U8              numSb;
4805
4806    TRC2(rgSCHCmnMsg3GrntReq);
4807
4808    *ulAllocRef = NULLP;
4809
4810    /* Fix: ccpu00120610 Use remAllocs from subframe during msg3 allocation */
4811    if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
4812    {
4813       RETVOID;
4814    }
4815    if (preamGrpA == FALSE)
4816    {
4817       numSb = cellUl->ra.prmblBNumSb;
4818       iMcs  = cellUl->ra.prmblBIMcs;
4819    }
4820    else
4821    {
4822       numSb = cellUl->ra.prmblANumSb;
4823       iMcs  = cellUl->ra.prmblAIMcs;
4824    }
4825
4826    if ((hole = rgSCHUtlUlHoleFirst(sf)) != NULLP)
4827    {
4828       if(*sf->allocCountRef == 0)
4829       {
4830          RgSchCmnDlCell  *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4831          /* Reinitialize the hole */
4832          if (sf->holeDb->count == 1 && (hole->start == 0)) /* Sanity check of holeDb */
4833          {
4834             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;
4835             /* Re-Initialize available subbands because of CFI change*/
4836             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;   
4837          }
4838          else
4839          {
4840             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4841                      "Error! holeDb sanity check failed RNTI:%d",rnti);
4842          } 
4843       }
4844       if (numSb <= hole->num)
4845       {
4846          U8 iTbs;
4847          alloc                = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
4848          rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
4849          alloc->grnt.iMcs     = iMcs;
4850          alloc->grnt.iMcsCrnt = iMcs;
4851          iTbs                 = rgSCHCmnUlGetITbsFrmIMcs(iMcs);
4852          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[0], iTbs); 
4853          /* To include the length and ModOrder in DataRecp Req.*/
4854          alloc->grnt.datSz = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
4855          RG_SCH_UL_MCS_TO_MODODR(iMcs, alloc->grnt.modOdr);
4856          /* RACHO : setting nDmrs to 0 and UlDelaybit to 0*/
4857          alloc->grnt.nDmrs    = 0;
4858          alloc->grnt.hop      = 0;
4859          alloc->grnt.delayBit = 0;
4860          alloc->grnt.isRtx    = FALSE;
4861          *ulAllocRef          = alloc;
4862          *hqProcIdRef         = (cellUl->msg3SchdHqProcIdx);
4863          hqProc->procId       = *hqProcIdRef;
4864          hqProc->ulSfIdx      = (cellUl->msg3SchdIdx);
4865          alloc->rnti          = rnti;
4866          alloc->ue            = NULLP;
4867          alloc->pdcch         = FALSE;
4868          alloc->forMsg3       = TRUE;
4869          alloc->hqProc        = hqProc;
4870          rgSCHUhmNewTx(hqProc, (U8)(cell->rachCfg.maxMsg3Tx - 1), alloc);
4871          //RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
4872          printf(
4873                "\nRNTI:%d MSG3 ALLOC proc(%p)procId(%d)schdIdx(%d)\n",
4874                alloc->rnti,
4875                ((PTR)alloc->hqProc),
4876                alloc->hqProc->procId,
4877                alloc->hqProc->ulSfIdx);
4878          RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
4879                "alloc(%p)maxMsg3Tx(%d)",
4880                ((PTR)alloc),
4881                cell->rachCfg.maxMsg3Tx);
4882       }
4883    }
4884
4885    RETVOID;
4886 }
4887
4888 \f
4889 /**
4890  * @brief This function determines the allocation limits and
4891  *        parameters that aid in DL scheduling.
4892  *
4893  * @details
4894  *
4895  *     Function: rgSCHCmnDlSetUeAllocLmt
4896  *     Purpose:  This function determines the Maximum RBs
4897  *               a UE is eligible to get based on softbuffer
4898  *               limitation and cell->>>maxDlBwPerUe. The Codeword
4899  *               specific parameters like iTbs, eff and noLyrs
4900  *               are also set in this function. This function
4901  *               is called while UE configuration and UeDlCqiInd.
4902  *
4903  *     Invoked by: Scheduler
4904  *
4905  *  @param[in]  RgSchCellCb   *cellCb
4906  *  @param[in]  RgSchCmnDlUe  *ueDl
4907  *  @return  Void
4908  *
4909  **/
4910 #ifdef ANSI
4911 PRIVATE Void rgSCHCmnDlSetUeAllocLmt
4912 (
4913 RgSchCellCb   *cell,
4914 RgSchCmnDlUe  *ueDl,
4915 Bool          isEmtcUe
4916 )
4917 #else
4918 PRIVATE Void rgSCHCmnDlSetUeAllocLmt(cell, ueDl, isEmtcUe)
4919 RgSchCellCb   *cell;
4920 RgSchCmnDlUe  *ueDl;
4921 Bool          isEmtcUe;
4922 #endif
4923 {
4924    U8            modOrder;
4925    U32           maxRb;
4926    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
4927    U8            cfi = cellSch->dl.currCfi;
4928
4929    TRC2(rgSCHCmnDlSetUeAllocLmt);
4930
4931 #ifdef EMTC_ENABLE
4932    if(TRUE == isEmtcUe)
4933    {
4934       /* ITbs for CW0 for 1 Layer Tx */
4935       ueDl->mimoInfo.cwInfo[0].iTbs[0] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[0][cfi]))\
4936                                              [ueDl->mimoInfo.cwInfo[0].cqi];
4937       /* ITbs for CW0 for 2 Layer Tx */
4938       ueDl->mimoInfo.cwInfo[0].iTbs[1] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[1][cfi]))\
4939                                              [ueDl->mimoInfo.cwInfo[0].cqi];
4940       /* Eff for CW0 for 1 Layer Tx */
4941       ueDl->mimoInfo.cwInfo[0].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4942                                             [ueDl->mimoInfo.cwInfo[0].iTbs[0]];
4943       /* Eff for CW0 for 2 Layer Tx */
4944       ueDl->mimoInfo.cwInfo[0].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4945                                             [ueDl->mimoInfo.cwInfo[0].iTbs[1]];
4946
4947       /* ITbs for CW1 for 1 Layer Tx */
4948       ueDl->mimoInfo.cwInfo[1].iTbs[0] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[0][cfi]))\
4949                                              [ueDl->mimoInfo.cwInfo[1].cqi];
4950       /* ITbs for CW1 for 2 Layer Tx */
4951       ueDl->mimoInfo.cwInfo[1].iTbs[1] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[1][cfi]))\
4952                                              [ueDl->mimoInfo.cwInfo[1].cqi];
4953       /* Eff for CW1 for 1 Layer Tx */
4954       ueDl->mimoInfo.cwInfo[1].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4955                                             [ueDl->mimoInfo.cwInfo[1].iTbs[0]];
4956       /* Eff for CW1 for 2 Layer Tx */
4957       ueDl->mimoInfo.cwInfo[1].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4958                                             [ueDl->mimoInfo.cwInfo[1].iTbs[1]];
4959    }
4960    else
4961 #endif 
4962    {
4963       /* ITbs for CW0 for 1 Layer Tx */
4964       ueDl->mimoInfo.cwInfo[0].iTbs[0] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
4965                                          [ueDl->mimoInfo.cwInfo[0].cqi];
4966       /* ITbs for CW0 for 2 Layer Tx */
4967       ueDl->mimoInfo.cwInfo[0].iTbs[1] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[1][cfi]))\
4968                                          [ueDl->mimoInfo.cwInfo[0].cqi];
4969       /* Eff for CW0 for 1 Layer Tx */
4970       ueDl->mimoInfo.cwInfo[0].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4971                                         [ueDl->mimoInfo.cwInfo[0].iTbs[0]];
4972       /* Eff for CW0 for 2 Layer Tx */
4973       ueDl->mimoInfo.cwInfo[0].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4974                                         [ueDl->mimoInfo.cwInfo[0].iTbs[1]];
4975       
4976       /* ITbs for CW1 for 1 Layer Tx */
4977       ueDl->mimoInfo.cwInfo[1].iTbs[0] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
4978                                          [ueDl->mimoInfo.cwInfo[1].cqi];
4979       /* ITbs for CW1 for 2 Layer Tx */
4980       ueDl->mimoInfo.cwInfo[1].iTbs[1] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[1][cfi]))\
4981                                          [ueDl->mimoInfo.cwInfo[1].cqi];
4982       /* Eff for CW1 for 1 Layer Tx */
4983       ueDl->mimoInfo.cwInfo[1].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4984                                         [ueDl->mimoInfo.cwInfo[1].iTbs[0]];
4985       /* Eff for CW1 for 2 Layer Tx */
4986       ueDl->mimoInfo.cwInfo[1].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4987                                         [ueDl->mimoInfo.cwInfo[1].iTbs[1]];
4988    }
4989
4990 //#ifdef DL_LA 
4991   // ueDl->laCb.cqiBasediTbs =  ueDl->mimoInfo.cwInfo[0].iTbs[0] * 100;
4992 //#endif
4993    /* Assigning noLyrs to each CW assuming optimal Spatial multiplexing
4994     * capability */
4995    (ueDl->mimoInfo.ri/2 == 0)? (ueDl->mimoInfo.cwInfo[0].noLyr = 1) : \
4996               (ueDl->mimoInfo.cwInfo[0].noLyr = ueDl->mimoInfo.ri/2);
4997    ueDl->mimoInfo.cwInfo[1].noLyr = ueDl->mimoInfo.ri - ueDl->mimoInfo.cwInfo[0].noLyr;
4998    /* rg002.101:ccpu00102106: correcting DL harq softbuffer limitation logic.
4999     * The maxTbSz is the maximum number of PHY bits a harq process can
5000     * hold. Hence we limit our allocation per harq process based on this.
5001     * Earlier implementation we misinterpreted the maxTbSz to be per UE
5002     * per TTI, but in fact it is per Harq per TTI. */
5003    /* rg002.101:ccpu00102106: cannot exceed the harq Tb Size
5004     * and harq Soft Bits limit.*/
5005
5006    /* Considering iTbs corresponding to 2 layer transmission for
5007     * codeword0(approximation) and the maxLayers supported by
5008     * this UE at this point of time. */
5009    RG_SCH_CMN_TBS_TO_MODODR(ueDl->mimoInfo.cwInfo[0].iTbs[1], modOrder);
5010
5011    /* Bits/modOrder gives #REs, #REs/noResPerRb gives #RBs */
5012    /* rg001.301 -MOD- [ccpu00119213] : avoiding wraparound */
5013    maxRb = ((ueDl->maxSbSz)/(cellSch->dl.noResPerRb[cfi] * modOrder *\
5014                    ueDl->mimoInfo.ri));
5015    if (cellSch->dl.isDlFreqSel)
5016    {
5017       /* Rounding off to left nearest multiple of RBG size */
5018       maxRb -= maxRb % cell->rbgSize;
5019    }
5020    ueDl->maxRb = RGSCH_MIN(maxRb, cellSch->dl.maxDlBwPerUe);
5021    if (cellSch->dl.isDlFreqSel)
5022    {
5023       /* Rounding off to right nearest multiple of RBG size */
5024       if (ueDl->maxRb % cell->rbgSize)
5025       {
5026          ueDl->maxRb += (cell->rbgSize - 
5027                          (ueDl->maxRb % cell->rbgSize));
5028       }
5029    }
5030
5031    /* Set the index of the cwInfo, which is better in terms of
5032     * efficiency. If RI<2, only 1 CW, hence btrCwIdx shall be 0 */
5033    if (ueDl->mimoInfo.ri < 2)
5034    {
5035       ueDl->mimoInfo.btrCwIdx = 0;
5036    }
5037    else
5038    {
5039       if (ueDl->mimoInfo.cwInfo[0].eff[ueDl->mimoInfo.cwInfo[0].noLyr-1] <\
5040           ueDl->mimoInfo.cwInfo[1].eff[ueDl->mimoInfo.cwInfo[1].noLyr-1])
5041       {
5042          ueDl->mimoInfo.btrCwIdx = 1;
5043       }
5044       else
5045       {
5046          ueDl->mimoInfo.btrCwIdx = 0;
5047       }
5048    }
5049
5050    RETVOID;
5051    }
5052
5053 #ifdef DL_LA
5054
5055 /**
5056  * @brief This function updates TX Scheme.
5057  *
5058  * @details
5059  *
5060  *     Function: rgSCHCheckAndSetTxScheme 
5061  *     Purpose:  This function determines the Maximum RBs
5062  *               a UE is eligible to get based on softbuffer
5063  *               limitation and cell->>>maxDlBwPerUe. The Codeword
5064  *               specific parameters like iTbs, eff and noLyrs
5065  *               are also set in this function. This function
5066  *               is called while UE configuration and UeDlCqiInd.
5067  *
5068  *     Invoked by: Scheduler
5069  *
5070  *  @param[in]  RgSchCellCb   *cell
5071  *  @param[in]  RgSchUeCb     *ue
5072  *  @return  Void
5073  *
5074  **/
5075 #ifdef ANSI
5076 PRIVATE Void rgSCHCheckAndSetTxScheme 
5077 (
5078 RgSchCellCb   *cell,
5079 RgSchUeCb     *ue
5080 )
5081 #else
5082 PRIVATE Void rgSCHCheckAndSetTxScheme(cell, ue)
5083 RgSchCellCb   *cell;
5084 RgSchUeCb     *ue;
5085 #endif
5086 {
5087    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
5088    RgSchCmnDlUe  *ueDl =  RG_SCH_CMN_GET_DL_UE(ue ,cell);
5089    U8            cfi = cellSch->dl.currCfi;
5090    U8            maxiTbs;
5091    U8            cqiBasediTbs;
5092    U8            actualiTbs;
5093
5094    TRC2(rgSCHCheckAndSetTxScheme);
5095
5096    maxiTbs      = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
5097                 [RG_SCH_CMN_MAX_CQI - 1];
5098    cqiBasediTbs = (ueDl->laCb[0].cqiBasediTbs)/100;
5099    actualiTbs   = ueDl->mimoInfo.cwInfo[0].iTbs[0];
5100
5101    if((actualiTbs < RG_SCH_TXSCHEME_CHNG_ITBS_FACTOR) && (cqiBasediTbs >
5102      actualiTbs) && ((cqiBasediTbs - actualiTbs) > RG_SCH_TXSCHEME_CHNG_THRSHD)) 
5103    {
5104       RG_SCH_CMN_SET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
5105    }
5106    
5107    if(actualiTbs >= maxiTbs)
5108    {
5109       RG_SCH_CMN_UNSET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
5110    }
5111
5112    RETVOID;
5113 }
5114
5115 /**
5116  * @brief This function determines the allocation limits and
5117  *        parameters that aid in DL scheduling.
5118  *
5119  * @details
5120  *
5121  *     Function: rgSCHCmnDlSetUeAllocLmtLa
5122  *     Purpose:  This function determines the Maximum RBs
5123  *               a UE is eligible to get based on softbuffer
5124  *               limitation and cell->>>maxDlBwPerUe. The Codeword
5125  *               specific parameters like iTbs, eff and noLyrs
5126  *               are also set in this function. This function
5127  *               is called while UE configuration and UeDlCqiInd.
5128  *
5129  *     Invoked by: Scheduler
5130  *
5131  *  @param[in]  RgSchCellCb   *cell
5132  *  @param[in]  RgSchUeCb     *ue
5133  *  @return  Void
5134  *
5135  **/
5136 #ifdef ANSI
5137 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa
5138 (
5139 RgSchCellCb   *cell,
5140 RgSchUeCb     *ue
5141 )
5142 #else
5143 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
5144 RgSchCellCb   *cell;
5145 RgSchUeCb     *ue;
5146 #endif
5147 {
5148    U8            modOrder;
5149    U32           maxRb;
5150    U8            reportediTbs;
5151    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
5152    RgSchCmnDlUe  *ueDl =  RG_SCH_CMN_GET_DL_UE(ue,cell);
5153    U8            cfi = cellSch->dl.currCfi;
5154    U8            maxiTbs;
5155    U8            cwIdx = 0; 
5156
5157    TRC2(rgSCHCmnDlSetUeAllocLmtLa);
5158
5159    maxiTbs      = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
5160    if(ueDl->cqiFlag == TRUE)
5161    {
5162       for(cwIdx=0; cwIdx < RG_SCH_CMN_MAX_CW_PER_UE; cwIdx++)
5163       {
5164          S32 iTbsNew;
5165
5166          /* Calcluating the reported iTbs for code word 0 */
5167          reportediTbs = ue->ue5gtfCb.mcs; 
5168
5169          iTbsNew = (S32) reportediTbs;
5170
5171          if(!ueDl->laCb[cwIdx].notFirstCqi)
5172          {
5173             /* This is the first CQI report from UE */
5174             ueDl->laCb[cwIdx].cqiBasediTbs = (iTbsNew * 100);
5175             ueDl->laCb[cwIdx].notFirstCqi  =  TRUE;
5176          }
5177          else if ((RG_ITBS_DIFF(reportediTbs, ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0])) > 5)
5178          {
5179             /* Ignore this iTBS report and mark that last iTBS report was */
5180             /* ignored so that subsequently we reset the LA algorithm     */
5181             ueDl->laCb[cwIdx].lastiTbsIgnored = TRUE;
5182             ueDl->laCb[cwIdx].numLastiTbsIgnored++;
5183             if( ueDl->laCb[cwIdx].numLastiTbsIgnored > 10)
5184             {
5185                /* CQI reported by UE is not catching up. Reset the LA algorithm */
5186                ueDl->laCb[cwIdx].cqiBasediTbs = (iTbsNew * 100);
5187                ueDl->laCb[cwIdx].deltaiTbs = 0;
5188                ueDl->laCb[cwIdx].lastiTbsIgnored = FALSE;
5189                ueDl->laCb[cwIdx].numLastiTbsIgnored = 0;
5190             }
5191          }
5192          else
5193          {
5194             if (ueDl->laCb[cwIdx].lastiTbsIgnored != TRUE)
5195             {
5196                ueDl->laCb[cwIdx].cqiBasediTbs = ((20 * iTbsNew * 100) +
5197                      (80 * ueDl->laCb[cwIdx].cqiBasediTbs))/100;
5198             }
5199             else
5200             {
5201                /* Reset the LA as iTbs in use caught up with the value   */
5202                /* reported by UE.                                        */
5203                ueDl->laCb[cwIdx].cqiBasediTbs = ((20 * iTbsNew * 100) +
5204                      (80 * ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0] * 100))/100;
5205                ueDl->laCb[cwIdx].deltaiTbs = 0;
5206                ueDl->laCb[cwIdx].lastiTbsIgnored = FALSE;
5207             }
5208          }
5209
5210          iTbsNew = (ueDl->laCb[cwIdx].cqiBasediTbs + ueDl->laCb[cwIdx].deltaiTbs)/100;
5211
5212          RG_SCH_CHK_ITBS_RANGE(iTbsNew, maxiTbs);       
5213
5214          ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0] = RGSCH_MIN(iTbsNew, cell->thresholds.maxDlItbs);
5215          //ueDl->mimoInfo.cwInfo[cwIdx].iTbs[1] = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
5216 #ifdef RG_5GTF
5217          ue->ue5gtfCb.mcs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
5218          /*
5219          printf("reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n", 
5220                  reportediTbs, ueDl->laCb[cwIdx].cqiBasediTbs, ueDl->laCb[cwIdx].deltaiTbs,
5221                  iTbsNew, ue->ue5gtfCb.mcs, cwIdx);
5222          */
5223 #endif
5224
5225          if((ue->mimoInfo.txMode != RGR_UE_TM_3) && (ue->mimoInfo.txMode != RGR_UE_TM_4))
5226          {
5227             break; 
5228          }
5229       }
5230       ueDl->cqiFlag = FALSE;
5231    } 
5232
5233
5234    RETVOID;
5235 }
5236 #endif
5237 /***********************************************************
5238  *
5239  *     Func : rgSCHCmnDlUeResetTemp
5240  *
5241  *     Desc : Reset whatever variables where temporarily used
5242  *            during UE scheduling.
5243  *
5244  *     Ret  : Void
5245  *
5246  *     Notes:
5247  *
5248  *     File :
5249  *
5250  **********************************************************/
5251 #ifdef ANSI
5252 PUBLIC Void rgSCHCmnDlHqPResetTemp 
5253 (
5254 RgSchDlHqProcCb         *hqP
5255 )
5256 #else
5257 PUBLIC Void rgSCHCmnDlHqPResetTemp(hqP)
5258 RgSchDlHqProcCb         *hqP;
5259 #endif
5260 {
5261
5262    TRC2(rgSCHCmnDlHqPResetTemp);
5263
5264    /* Fix: syed having a hqP added to Lists for RB assignment rather than
5265     * a UE, as adding UE was limiting handling some scenarios */ 
5266     hqP->reqLnk.node = (PTR)NULLP;
5267     hqP->schdLstLnk.node = (PTR)NULLP;
5268
5269    RETVOID;
5270 }  /* rgSCHCmnDlHqPResetTemp */
5271
5272 /***********************************************************
5273  *
5274  *     Func : rgSCHCmnDlUeResetTemp
5275  *
5276  *     Desc : Reset whatever variables where temporarily used
5277  *            during UE scheduling.
5278  *
5279  *     Ret  : Void
5280  *
5281  *     Notes:
5282  *
5283  *     File :
5284  *
5285  **********************************************************/
5286 #ifdef ANSI
5287 PUBLIC Void rgSCHCmnDlUeResetTemp
5288 (
5289 RgSchUeCb               *ue,
5290 RgSchDlHqProcCb         *hqP
5291 )
5292 #else
5293 PUBLIC Void rgSCHCmnDlUeResetTemp(ue, hqP)
5294 RgSchUeCb               *ue;
5295 RgSchDlHqProcCb         *hqP;
5296 #endif
5297 {
5298    RgSchDlRbAlloc  *allocInfo;
5299    RgSchCmnDlUe       *cmnUe = RG_SCH_CMN_GET_DL_UE(ue,hqP->hqE->cell);
5300 #ifdef LTE_ADV
5301    Void           *tmpCb;
5302 #endif
5303
5304    TRC2(rgSCHCmnDlUeResetTemp);
5305
5306    /* Fix : syed check for UE's existence was useless.
5307     * Instead we need to check that reset is done only for the 
5308     * information of a scheduled harq proc, which is cmnUe->proc.
5309     * Reset should not be done for non-scheduled hqP */
5310    if((cmnUe->proc == hqP) || (cmnUe->proc == NULLP))
5311    {
5312       cmnUe->proc = NULLP;
5313       allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, hqP->hqE->cell);
5314 #ifdef LTE_ADV
5315       tmpCb = allocInfo->laaCb;
5316 #endif
5317       cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
5318       allocInfo->rnti = ue->ueId;
5319 #ifdef LTE_ADV
5320       allocInfo->laaCb = tmpCb;
5321 #endif
5322       /* Fix: syed moving this to a common function for both scheduled
5323        * and non-scheduled UEs */
5324       cmnUe->outStndAlloc = 0;
5325    }
5326    rgSCHCmnDlHqPResetTemp(hqP);
5327
5328    RETVOID;
5329 }  /* rgSCHCmnDlUeResetTemp */
5330
5331 /***********************************************************
5332  *
5333  *     Func : rgSCHCmnUlUeResetTemp
5334  *
5335  *     Desc : Reset whatever variables where temporarily used
5336  *            during UE scheduling.
5337  *
5338  *     Ret  : Void
5339  *
5340  *     Notes:
5341  *
5342  *     File :
5343  *
5344  **********************************************************/
5345 #ifdef ANSI
5346 PUBLIC Void rgSCHCmnUlUeResetTemp
5347 (
5348 RgSchCellCb             *cell,
5349 RgSchUeCb               *ue
5350 )
5351 #else
5352 PUBLIC Void rgSCHCmnUlUeResetTemp(cell, ue)
5353 RgSchCellCb             *cell;
5354 RgSchUeCb               *ue;
5355 #endif
5356 {
5357    RgSchCmnUlUe       *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
5358
5359    TRC2(rgSCHCmnUlUeResetTemp);
5360
5361    cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
5362
5363    RETVOID;
5364 }  /* rgSCHCmnUlUeResetTemp */
5365
5366
5367 \f
5368 /**
5369  * @brief This function fills the PDCCH information from dlProc.
5370  *
5371  * @details
5372  *
5373  *     Function: rgSCHCmnFillPdcch
5374  *     Purpose:  This function fills in the PDCCH information
5375  *               obtained from the RgSchDlRbAlloc
5376  *               during common channel scheduling(P, SI, RA - RNTI's).
5377  *
5378  *     Invoked by: Downlink Scheduler
5379  *
5380  *  @param[out] RgSchPdcch*       pdcch
5381  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
5382  *  @return  Void
5383  *
5384  **/
5385 #ifdef ANSI
5386 PUBLIC Void rgSCHCmnFillPdcch
5387 (
5388 RgSchCellCb                *cell,
5389 RgSchPdcch                 *pdcch,
5390 RgSchDlRbAlloc             *rbAllocInfo
5391 )
5392 #else
5393 PUBLIC Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
5394 RgSchCellCb                *cell;
5395 RgSchPdcch                 *pdcch;
5396 RgSchDlRbAlloc             *rbAllocInfo;
5397 #endif
5398 {
5399
5400    TRC2(rgSCHCmnFillPdcch);
5401
5402    /* common channel pdcch filling,
5403     * only 1A and Local is supported */
5404    pdcch->rnti                       = rbAllocInfo->rnti;
5405    pdcch->dci.dciFormat              = rbAllocInfo->dciFormat;
5406    switch(rbAllocInfo->dciFormat)
5407    {
5408 #ifdef RG_5GTF  /* ANOOP: ToDo: DCI format B1/B2 filling */
5409       case TFU_DCI_FORMAT_B1:
5410          {
5411             /* ToDo: Anoop */
5412             pdcch->dci.u.formatB1Info.formatType = 0;
5413             pdcch->dci.u.formatB1Info.xPDSCHRange = rbAllocInfo->tbInfo[0].cmnGrnt.xPDSCHRange;
5414             pdcch->dci.u.formatB1Info.RBAssign = rbAllocInfo->tbInfo[0].cmnGrnt.rbAssign;
5415             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.hqProcId = 0;
5416             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
5417             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = 0;
5418             //pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].ndi;
5419             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].cmnGrnt.rv;
5420             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
5421             pdcch->dci.u.formatB1Info.CSI_BSI_BRI_Req = 0;
5422             pdcch->dci.u.formatB1Info.CSIRS_BRRS_TxTiming = 0;
5423             pdcch->dci.u.formatB1Info.CSIRS_BRRS_SymbIdx = 0;
5424             pdcch->dci.u.formatB1Info.CSIRS_BRRS_ProcInd = 0;
5425             pdcch->dci.u.formatB1Info.xPUCCH_TxTiming = 0;
5426             //TODO_SID: Need to update
5427             pdcch->dci.u.formatB1Info.freqResIdx_xPUCCH = 0;
5428             pdcch->dci.u.formatB1Info.beamSwitch  = 0;
5429             pdcch->dci.u.formatB1Info.SRS_Config = 0;
5430             pdcch->dci.u.formatB1Info.SRS_Symbol = 0;
5431             //TODO_SID: Need to check.Currently setting 0(1 layer, ports(8) w/o OCC).
5432             pdcch->dci.u.formatB1Info.AntPorts_numLayers = 0;
5433             pdcch->dci.u.formatB1Info.SCID = rbAllocInfo->tbInfo[0].cmnGrnt.SCID;
5434             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
5435             pdcch->dci.u.formatB1Info.tpcCmd = 1; //tpc;
5436             pdcch->dci.u.formatB1Info.DL_PCRS = 0;
5437
5438             break; /* case TFU_DCI_FORMAT_B1: */
5439          }
5440
5441       case TFU_DCI_FORMAT_B2:
5442          {
5443             //printf(" RG_5GTF:: Pdcch filling with DCI format B2\n");
5444             /* ToDo: Anoop */
5445             break; /* case TFU_DCI_FORMAT_B2: */
5446          }
5447 #endif
5448       case TFU_DCI_FORMAT_1A:
5449          pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
5450
5451          /*Nprb indication at PHY for common Ch
5452           *setting least significant bit of tpc field to 1 if
5453           nPrb=3 and 0 otherwise. */
5454          if (rbAllocInfo->nPrb == 3)
5455          {
5456             pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = 1;
5457          }
5458          else
5459          {
5460             pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = 0;
5461          }
5462          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.nGap2.pres = NOTPRSNT;
5463          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.isLocal = TRUE;
5464          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.mcs     = \
5465                                                                    rbAllocInfo->tbInfo[0].imcs;
5466          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.ndi     = 0;
5467          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv      = 0;
5468          /* Add RIV CALC */
5469          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.type =
5470             TFU_ALLOC_TYPE_RIV;
5471          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.u.riv =
5472             rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
5473                   rbAllocInfo->allocInfo.raType2.rbStart,
5474                   rbAllocInfo->allocInfo.raType2.numRb);
5475
5476 #ifdef LTE_TDD
5477          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres = \
5478                                                                            FALSE;
5479 #ifdef TFU_TDD
5480          pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
5481          pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 1;
5482 #endif
5483 #endif
5484          break; /* case TFU_DCI_FORMAT_1A: */
5485       case TFU_DCI_FORMAT_1:
5486          pdcch->dci.u.format1Info.tpcCmd = 0;
5487          /* Avoiding this check,as we dont support Type1 RA */
5488 #ifdef RG_UNUSED
5489          if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
5490          {
5491 #endif
5492             pdcch->dci.u.format1Info.allocInfo.isAllocType0 = TRUE;
5493             pdcch->dci.u.format1Info.allocInfo.resAllocMap[0] =
5494                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
5495                 & 0xff);
5496             pdcch->dci.u.format1Info.allocInfo.resAllocMap[1] =
5497                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
5498                 & 0x00ff);
5499             pdcch->dci.u.format1Info.allocInfo.resAllocMap[2] =
5500                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
5501                 & 0x0000ff);
5502             pdcch->dci.u.format1Info.allocInfo.resAllocMap[3] =
5503                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
5504 #ifdef RG_UNUSED
5505          }
5506 #endif
5507          pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
5508          pdcch->dci.u.format1Info.allocInfo.ndi = 0;
5509          pdcch->dci.u.format1Info.allocInfo.mcs = rbAllocInfo->tbInfo[0].imcs;
5510          pdcch->dci.u.format1Info.allocInfo.rv = 0;
5511 #ifdef TFU_TDD
5512          pdcch->dci.u.format1Info.dai = 1;
5513 #endif
5514          break;
5515       default:
5516          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Allocator's icorrect "
5517             "dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
5518          break;
5519    }
5520    RETVOID;
5521 }
5522
5523 #ifdef LTE_TDD
5524 /**
5525  * @brief This function finds whether the subframe is special subframe or not.
5526  *
5527  * @details
5528  *
5529  *     Function: rgSCHCmnIsSplSubfrm
5530  *     Purpose:  This function finds the subframe index of the special subframe
5531  *               and finds whether the current DL index matches it or not.
5532  *
5533  *     Invoked by: Scheduler
5534  *
5535  *  @param[in] U8                   splfrmCnt
5536  *  @param[in] U8                   curSubfrmIdx
5537  *  @param[in] U8                   periodicity
5538  *  @param[in] RgSchTddSubfrmInfo   *subfrmInfo
5539  *  @return  Bool
5540  *
5541  **/
5542 #ifdef ANSI
5543 PRIVATE Bool rgSCHCmnIsSplSubfrm
5544 (
5545 U8                   splfrmCnt,
5546 U8                   curSubfrmIdx,
5547 U8                   periodicity,
5548 RgSchTddSubfrmInfo   *subfrmInfo
5549 )
5550 #else
5551 PRIVATE Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
5552 U8                   splfrmCnt;
5553 U8                   curSubfrmIdx;
5554 U8                   periodicity;
5555 RgSchTddSubfrmInfo   *subfrmInfo;
5556 #endif
5557 {
5558    U8 dlSfCnt = 0;
5559    U8 splfrmIdx  = 0;
5560
5561    TRC2(rgSCHCmnIsSplSubfrm);
5562
5563    if(splfrmCnt > 0)
5564    {
5565       if(periodicity == RG_SCH_CMN_5_MS_PRD)
5566       {
5567          if(splfrmCnt%2)
5568          {
5569             dlSfCnt = ((splfrmCnt-1)/2) *\
5570                       (subfrmInfo->numFrmHf1 + subfrmInfo->numFrmHf2);
5571             dlSfCnt = dlSfCnt + subfrmInfo->numFrmHf1;
5572          }
5573          else
5574          {
5575             dlSfCnt = (splfrmCnt/2) * \
5576                       (subfrmInfo->numFrmHf1 + subfrmInfo->numFrmHf2);
5577          }
5578       }
5579       else
5580       {
5581          dlSfCnt = splfrmCnt * subfrmInfo->numFrmHf1;
5582       }
5583       splfrmIdx = RG_SCH_CMN_SPL_SUBFRM_1 +\
5584                   (periodicity*splfrmCnt - dlSfCnt);
5585    }
5586    else
5587    {
5588       splfrmIdx = RG_SCH_CMN_SPL_SUBFRM_1;
5589    }
5590
5591    if(splfrmIdx == curSubfrmIdx)
5592    {
5593       RETVALUE(TRUE);
5594    }
5595
5596    RETVALUE(FALSE);
5597 }
5598
5599 /**
5600  * @brief This function updates DAI or UL index.
5601  *
5602  * @details
5603  *
5604  *     Function: rgSCHCmnUpdHqAndDai
5605  *     Purpose:  Updates the DAI based on UL-DL Configuration
5606  *               index and UE. It also updates the HARQ feedback
5607  *               time and 'm' index.
5608  *
5609  *     Invoked by: TOM
5610  *
5611  *  @param[in]  RgDlHqProcCb  *hqP
5612  *  @param[in]  RgSchDlSf     *subFrm
5613  *  @param[in]  RgSchDlHqTbCb *tbCb
5614  *  @param[in]  U8            tbAllocIdx
5615  *  @return  Void
5616  *
5617  **/
5618 #ifdef ANSI
5619 PRIVATE Void rgSCHCmnUpdHqAndDai
5620 (
5621 RgSchDlHqProcCb   *hqP,
5622 RgSchDlSf         *subFrm,
5623 RgSchDlHqTbCb     *tbCb,
5624 U8                tbAllocIdx
5625 )
5626 #else
5627 PRIVATE Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
5628 RgSchDlHqProcCb   *hqP;
5629 RgSchDlSf         *subFrm;
5630 RgSchDlHqTbCb     *tbCb;
5631 U8                tbAllocIdx;
5632 #endif
5633 {
5634    RgSchUeCb      *ue = hqP->hqE->ue;
5635    
5636    TRC2(rgSCHCmnUpdHqAndDai);
5637
5638    if(subFrm != NULLP)
5639    {
5640       /* set the time at which UE shall send the feedback
5641        * for this process */
5642       tbCb->fdbkTime.sfn = (tbCb->timingInfo.sfn + \
5643             subFrm->dlFdbkInfo.sfnOffset) % RGSCH_MAX_SFN;
5644       tbCb->fdbkTime.subframe = subFrm->dlFdbkInfo.subframe;
5645       tbCb->m = subFrm->dlFdbkInfo.m;
5646    }
5647    else
5648    {
5649       /* set the time at which UE shall send the feedback
5650        * for this process */
5651       tbCb->fdbkTime.sfn = (tbCb->timingInfo.sfn + \
5652             hqP->subFrm->dlFdbkInfo.sfnOffset) % RGSCH_MAX_SFN;
5653       tbCb->fdbkTime.subframe = hqP->subFrm->dlFdbkInfo.subframe;
5654       tbCb->m = hqP->subFrm->dlFdbkInfo.m;
5655    }
5656
5657    /* ccpu00132340-MOD- DAI need to be updated for first TB only*/
5658    if(ue && !tbAllocIdx)
5659    {
5660       Bool   havePdcch = (tbCb->hqP->pdcch ? TRUE : FALSE);
5661       U8     dlDai;
5662       
5663       dlDai = rgSCHCmnUpdDai(ue, &tbCb->fdbkTime, tbCb->m, havePdcch,tbCb->hqP,
5664             &tbCb->dai);
5665       if(havePdcch)
5666       {/* Non SPS occasions */
5667          tbCb->hqP->pdcch->dlDai = dlDai;
5668          /* hqP->ulDai is used for N1 resource filling
5669           * when SPS occaions present in a bundle */
5670          tbCb->hqP->ulDai = tbCb->dai;
5671          tbCb->hqP->dlDai = dlDai;
5672       }
5673    }
5674
5675    /* Updatijng pucchFdbkIdx for both PUCCH or PUSCH
5676       fdbk reception */
5677    tbCb->pucchFdbkIdx = tbCb->hqP->ulDai;
5678
5679    RETVOID;
5680 }
5681
5682
5683 /**
5684  * @brief This function updates DAI or UL index.
5685  *
5686  * @details
5687  *
5688  *     Function: rgSCHCmnUpdDai
5689  *     Purpose:  Updates the DAI in the ack-nack info, a valid
5690  *               ue should be passed
5691  *
5692  *     Invoked by: TOM
5693  *
5694  *  @param[in]  RgDlHqProcCb  *hqP
5695  *  @param[in]  RgSchDlSf     *subFrm
5696  *  @param[in]  RgSchDlHqTbCb *tbCb
5697  *  @return  U8 dlDai 
5698  *
5699  **/
5700 #ifdef ANSI
5701 PUBLIC U8 rgSCHCmnUpdDai
5702 (
5703 RgSchUeCb         *ue,
5704 CmLteTimingInfo   *fdbkTime,
5705 U8                 m,
5706 Bool               havePdcch,
5707 RgSchDlHqProcCb   *hqP,
5708 U8                *ulDai
5709 )
5710 #else
5711 PUBLIC U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
5712 RgSchUeCb         *ue;
5713 CmLteTimingInfo   *fdbkTime;
5714 U8                 m;
5715 Bool               havePdcch;
5716 RgSchDlHqProcCb   *hqP;
5717 U8                *ulDai;
5718 #endif
5719 {
5720    RgSchTddANInfo *anInfo;
5721    U8             servCellIdx;
5722    U8             ackNackFdbkArrSize;
5723   
5724
5725    TRC2(rgSCHCmnUpdDai);
5726
5727    if(hqP != NULLP)
5728    {/* Non SPS */
5729 #ifdef LTE_ADV
5730       servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
5731             hqP->hqE->cell->cellId,
5732             ue);
5733 #else
5734      servCellIdx = RGSCH_PCELL_INDEX;
5735 #endif
5736       ackNackFdbkArrSize = hqP->hqE->cell->ackNackFdbkArrSize;
5737    }else
5738    {/* SPS on primary cell */
5739       servCellIdx = RGSCH_PCELL_INDEX;
5740       ackNackFdbkArrSize = ue->cell->ackNackFdbkArrSize;
5741    }
5742
5743
5744    anInfo = rgSCHUtlGetUeANFdbkInfo(ue, fdbkTime,servCellIdx);
5745
5746    /* If no ACK/NACK feedback already present, create a new one */
5747    if(NULLP == anInfo)
5748    {
5749       anInfo = &ue->cellInfo[servCellIdx]->anInfo[ue->cellInfo[servCellIdx]->nextFreeANIdx];
5750       anInfo->sfn = fdbkTime->sfn;
5751       anInfo->subframe = fdbkTime->subframe;
5752       anInfo->latestMIdx = m;
5753       /* Fixing DAI value - ccpu00109162 */
5754       /* Handle TDD case as in MIMO definition of the function */
5755       anInfo->ulDai = 1;
5756       if (havePdcch)
5757       {
5758          anInfo->dlDai = 1;
5759       }
5760       anInfo->isSpsOccasion = FALSE;
5761       /* set the free Index to store  Ack/Nack Information*/
5762       ue->cellInfo[servCellIdx]->nextFreeANIdx = (ue->cellInfo[servCellIdx]->nextFreeANIdx + 1) %
5763          ackNackFdbkArrSize;
5764
5765    }
5766    else
5767    {
5768       anInfo->latestMIdx = m;
5769       /* Fixing DAI value - ccpu00109162 */
5770       /* Handle TDD case as in MIMO definition of the function */
5771       anInfo->ulDai = anInfo->ulDai + 1;
5772       if (havePdcch)
5773       {
5774          anInfo->dlDai = anInfo->dlDai + 1;
5775       }
5776    }
5777 #ifdef LTE_ADV
5778    /* ignoring the Scell check,
5779     * for primary cell this field is unused*/
5780    if(hqP != NULLP)
5781    {/* SPS*/
5782       anInfo->n1ResTpcIdx = hqP->tpc;
5783    }
5784
5785    if(ulDai)
5786    {/* As this not required for release pdcch */
5787       *ulDai = anInfo->ulDai;
5788    }
5789 #endif
5790    RETVALUE(anInfo->dlDai);
5791
5792 }
5793 #endif /* ifdef LTE_TDD */
5794
5795 PUBLIC U32 rgHqRvRetxCnt[4][2];
5796 PUBLIC U32 rgUlrate_grant;
5797
5798 /**
5799  * @brief This function fills the HqP TB with rbAllocInfo.
5800  *
5801  * @details
5802  *
5803  *     Function: rgSCHCmnFillHqPTb
5804  *     Purpose:  This function fills in the HqP TB with rbAllocInfo.
5805  *
5806  *     Invoked by: rgSCHCmnFillHqPTb
5807  *
5808  *  @param[in]  RgSchCellCb*      cell
5809  *  @param[in]  RgSchDlRbAlloc    *rbAllocInfo,
5810  *  @param[in]  U8                tbAllocIdx
5811  *  @param[in]  RgSchPdcch        *pdcch
5812  *  @return  Void
5813  *
5814  **/
5815 #ifdef LTEMAC_SPS
5816 #ifdef ANSI
5817 PUBLIC Void rgSCHCmnFillHqPTb
5818 (
5819 RgSchCellCb                *cell,
5820 RgSchDlRbAlloc             *rbAllocInfo,
5821 U8                         tbAllocIdx,
5822 RgSchPdcch                 *pdcch
5823 )
5824 #else
5825 PUBLIC Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
5826 RgSchCellCb                *cell;
5827 RgSchDlRbAlloc             *rbAllocInfo;
5828 U8                         tbAllocIdx;
5829 RgSchPdcch                 *pdcch;
5830 #endif
5831 #else
5832 #ifdef ANSI
5833 PRIVATE Void rgSCHCmnFillHqPTb
5834 (
5835 RgSchCellCb                *cell,
5836 RgSchDlRbAlloc             *rbAllocInfo,
5837 U8                         tbAllocIdx,
5838 RgSchPdcch                 *pdcch
5839 )
5840 #else
5841 PRIVATE Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
5842 RgSchCellCb                *cell;
5843 RgSchDlRbAlloc             *rbAllocInfo;
5844 U8                         tbAllocIdx;
5845 RgSchPdcch                 *pdcch;
5846 #endif
5847 #endif /* LTEMAC_SPS */
5848 {
5849    RgSchCmnDlCell     *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
5850    RgSchDlTbAllocInfo *tbAllocInfo = &rbAllocInfo->tbInfo[tbAllocIdx];
5851    RgSchDlHqTbCb      *tbInfo = tbAllocInfo->tbCb;
5852    RgSchDlHqProcCb    *hqP = tbInfo->hqP;
5853
5854    TRC2(rgSCHCmnFillHqPTb);
5855
5856    /*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
5857     * Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
5858     */
5859    if ( tbAllocInfo->isDisabled)
5860    {
5861
5862       tbInfo->dlGrnt.iMcs = 0;
5863       tbInfo->dlGrnt.rv   = 1;
5864    }
5865    /* Fill for TB retransmission */
5866    else if (tbInfo->txCntr > 0)
5867    {
5868
5869       tbInfo->timingInfo = cmnCellDl->time;
5870       /* Fix */
5871       if ((tbInfo->isAckNackDtx == TFU_HQFDB_DTX)) 
5872       {
5873          tbInfo->dlGrnt.iMcs = tbAllocInfo->imcs;         
5874          rgHqRvRetxCnt[tbInfo->dlGrnt.rv][tbInfo->tbIdx]++;
5875       }
5876       else
5877       {
5878          tbInfo->dlGrnt.rv = rgSchCmnDlRvTbl[++(tbInfo->ccchSchdInfo.rvIdx) & 0x03];
5879       }
5880
5881       /* fill the scheduler information of hqProc */
5882       tbInfo->ccchSchdInfo.totBytes = tbAllocInfo->bytesAlloc;
5883       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx,hqP->tbInfo,tbInfo->tbIdx );
5884       rgSCHDhmHqTbRetx(hqP->hqE, tbInfo->timingInfo, hqP, tbInfo->tbIdx);
5885    }
5886    /* Fill for TB transmission */
5887    else
5888    {
5889       /* Fill the HqProc */
5890       tbInfo->dlGrnt.iMcs = tbAllocInfo->imcs;
5891       tbInfo->tbSz = tbAllocInfo->bytesAlloc;
5892       tbInfo->timingInfo = cmnCellDl->time;
5893
5894       tbInfo->dlGrnt.rv = rgSchCmnDlRvTbl[0];
5895       /* fill the scheduler information of hqProc */
5896       tbInfo->ccchSchdInfo.rvIdx = 0;
5897       tbInfo->ccchSchdInfo.totBytes = tbAllocInfo->bytesAlloc;
5898       /* DwPts Scheduling Changes Start */
5899       /* DwPts Scheduling Changes End */ 
5900       cell->measurements.dlBytesCnt += tbAllocInfo->bytesAlloc;
5901    }
5902
5903    /*ccpu00120365:-ADD-only add to subFrm list if tb is not disabled */
5904    if ( tbAllocInfo->isDisabled == FALSE )
5905    {
5906       /* Set the number of transmitting SM layers for this TB */
5907       tbInfo->numLyrs = tbAllocInfo->noLyr;
5908       /* Set the TB state as WAITING to indicate TB has been
5909        * considered for transmission */
5910       tbInfo->state  = HQ_TB_WAITING;
5911       hqP->subFrm = rbAllocInfo->dlSf;
5912       tbInfo->hqP->pdcch  = pdcch;
5913       //tbInfo->dlGrnt.numRb = rbAllocInfo->rbsAlloc;
5914       rgSCHUtlDlHqPTbAddToTx(hqP->subFrm, hqP, tbInfo->tbIdx);
5915    }
5916    RETVOID;
5917 }
5918
5919 /**
5920  * @brief This function fills the PDCCH DCI format 2 information from dlProc.
5921  *
5922  * @details
5923  *
5924  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2
5925  *     Purpose:  This function fills in the PDCCH information
5926  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
5927  *               for dedicated service scheduling. It also
5928  *               obtains TPC to be filled in from the power module.
5929  *               Assign the PDCCH to HQProc.
5930  *
5931  *     Invoked by: Downlink Scheduler
5932  *
5933  *  @param[in]  RgSchCellCb*      cell
5934  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
5935  *  @param[in]  RgDlHqProc*       hqP
5936  *  @param[out]  RgSchPdcch        *pdcch
5937  *  @param[in]   U8               tpc
5938  *  @return  Void
5939  *
5940  **/
5941 #ifdef ANSI
5942 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2
5943 (
5944 RgSchCellCb                *cell,
5945 RgSchDlRbAlloc             *rbAllocInfo,
5946 RgSchDlHqProcCb            *hqP,
5947 RgSchPdcch                 *pdcch,
5948 U8                         tpc
5949 )
5950 #else
5951 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
5952 RgSchCellCb                *cell;
5953 RgSchDlRbAlloc             *rbAllocInfo;
5954 RgSchDlHqProcCb            *hqP;
5955 RgSchPdcch                 *pdcch;
5956 U8                         tpc;
5957 #endif
5958 {
5959
5960    TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
5961
5962    rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);   
5963    //Currently hardcoding values here.
5964    //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
5965    switch(rbAllocInfo->dciFormat)
5966    {
5967       case TFU_DCI_FORMAT_B1:
5968          {
5969             pdcch->dci.u.formatB1Info.formatType = 0;
5970             pdcch->dci.u.formatB1Info.xPDSCHRange = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange;
5971             pdcch->dci.u.formatB1Info.RBAssign = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign;
5972             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.hqProcId = hqP->procId;
5973             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
5974             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
5975             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
5976             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
5977             pdcch->dci.u.formatB1Info.CSI_BSI_BRI_Req = 0;
5978             pdcch->dci.u.formatB1Info.CSIRS_BRRS_TxTiming = 0;
5979             pdcch->dci.u.formatB1Info.CSIRS_BRRS_SymbIdx = 0;
5980             pdcch->dci.u.formatB1Info.CSIRS_BRRS_ProcInd = 0;
5981             pdcch->dci.u.formatB1Info.xPUCCH_TxTiming = 0;
5982             //TODO_SID: Need to update
5983             pdcch->dci.u.formatB1Info.freqResIdx_xPUCCH = 0;
5984             pdcch->dci.u.formatB1Info.beamSwitch  = 0;
5985             pdcch->dci.u.formatB1Info.SRS_Config = 0;
5986             pdcch->dci.u.formatB1Info.SRS_Symbol = 0;
5987             //TODO_SID: Need to check.Currently setting 0(1 layer, ports(8) w/o OCC).
5988             pdcch->dci.u.formatB1Info.AntPorts_numLayers = 0;
5989             pdcch->dci.u.formatB1Info.SCID = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.SCID;
5990             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
5991             pdcch->dci.u.formatB1Info.tpcCmd = 1; //tpc;
5992             pdcch->dci.u.formatB1Info.DL_PCRS = 0;
5993             break;
5994          }
5995       case TFU_DCI_FORMAT_B2:
5996          {
5997             pdcch->dci.u.formatB2Info.formatType = 1;
5998             pdcch->dci.u.formatB2Info.xPDSCHRange = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange;
5999             pdcch->dci.u.formatB2Info.RBAssign = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign;
6000             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.hqProcId = hqP->procId;
6001             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
6002             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6003             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6004             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
6005             pdcch->dci.u.formatB2Info.CSI_BSI_BRI_Req = 0;
6006             pdcch->dci.u.formatB2Info.CSIRS_BRRS_TxTiming = 0;
6007             pdcch->dci.u.formatB2Info.CSIRS_BRRS_SymbIdx = 0;
6008             pdcch->dci.u.formatB2Info.CSIRS_BRRS_ProcInd = 0;
6009             pdcch->dci.u.formatB2Info.xPUCCH_TxTiming = 0;
6010             //TODO_SID: Need to update
6011             pdcch->dci.u.formatB2Info.freqResIdx_xPUCCH = 0;
6012             pdcch->dci.u.formatB2Info.beamSwitch  = 0;
6013             pdcch->dci.u.formatB2Info.SRS_Config = 0;
6014             pdcch->dci.u.formatB2Info.SRS_Symbol = 0;
6015             //TODO_SID: Need to check.Currently setting 4(2 layer, ports(8,9) w/o OCC).
6016             pdcch->dci.u.formatB2Info.AntPorts_numLayers = 4;
6017             pdcch->dci.u.formatB2Info.SCID = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.SCID;
6018             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
6019             pdcch->dci.u.formatB2Info.tpcCmd = 1; //tpc;
6020             pdcch->dci.u.formatB2Info.DL_PCRS = 0;
6021             break;
6022          }
6023          default:
6024             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId," 5GTF_ERROR Allocator's icorrect "
6025                "dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
6026             break;
6027    }
6028    
6029    RETVOID;
6030 }
6031
6032 extern U32 totPcellSCell;
6033 extern U32 addedForScell;
6034 extern U32 addedForScell1;
6035 extern U32 addedForScell2;
6036 /**
6037  * @brief This function fills the PDCCH information from dlProc.
6038  *
6039  * @details
6040  *
6041  *     Function: rgSCHCmnFillHqPPdcch
6042  *     Purpose:  This function fills in the PDCCH information
6043  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6044  *               for dedicated service scheduling. It also
6045  *               obtains TPC to be filled in from the power module.
6046  *               Assign the PDCCH to HQProc.
6047  *
6048  *     Invoked by: Downlink Scheduler
6049  *
6050  *  @param[in]  RgSchCellCb*      cell
6051  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6052  *  @param[in]  RgDlHqProc*       hqP
6053  *  @return  Void
6054  *
6055  **/
6056 #ifdef ANSI
6057 PUBLIC Void rgSCHCmnFillHqPPdcch
6058 (
6059 RgSchCellCb                *cell,
6060 RgSchDlRbAlloc             *rbAllocInfo,
6061 RgSchDlHqProcCb            *hqP
6062 )
6063 #else
6064 PUBLIC Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
6065 RgSchCellCb                *cell;
6066 RgSchDlRbAlloc             *rbAllocInfo;
6067 RgSchDlHqProcCb            *hqP;
6068 #endif
6069 {
6070    RgSchCmnDlCell     *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
6071    RgSchPdcch         *pdcch = rbAllocInfo->pdcch;
6072    U8                 tpc = 1;
6073
6074    TRC2(rgSCHCmnFillHqPPdcch);
6075
6076    if (hqP->hqE->ue)
6077    {
6078 #ifdef LTE_ADV
6079       if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6080       {
6081          tpc = hqP->tpc;
6082       }
6083       else
6084 #endif
6085       {
6086          tpc = rgSCHPwrPucchTpcForUe(cell, hqP->hqE->ue);
6087       }
6088       /* Fix: syed moving this to a common function for both scheduled
6089        * and non-scheduled UEs */
6090
6091       pdcch->ue = hqP->hqE->ue;
6092       if (hqP->hqE->ue->csgMmbrSta == FALSE)
6093       {
6094          cmnCell->ncsgPrbCnt += rbAllocInfo->rbsAlloc;
6095       }
6096       cmnCell->totPrbCnt += rbAllocInfo->rbsAlloc;
6097 #ifdef TENB_STATS
6098       {
6099          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlPrbUsg += 
6100             rbAllocInfo->rbsAlloc;
6101          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlSumCw0iTbs += 
6102             rbAllocInfo->tbInfo[0].iTbs;
6103          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlNumCw0iTbs ++; 
6104          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt +=
6105             (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6106
6107 #ifdef LTE_ADV
6108       totPcellSCell += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6109       if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6110       {
6111          addedForScell +=  (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6112          addedForScell1 += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6113 /*
6114          printf (" Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
6115          hqP->procId,
6116          hqP->hqE->cell->cellId,
6117          addedForScell,
6118          addedForScell1,
6119          cell->crntTime.sfn,
6120          cell->crntTime.subframe);
6121          */
6122       }
6123 #endif
6124          hqP->hqE->cell->tenbStats->sch.dlPrbUsage[0] += 
6125             rbAllocInfo->rbsAlloc;
6126          hqP->hqE->cell->tenbStats->sch.dlSumCw0iTbs += 
6127             rbAllocInfo->tbInfo[0].iTbs;
6128          hqP->hqE->cell->tenbStats->sch.dlNumCw0iTbs ++; 
6129          hqP->hqE->cell->tenbStats->sch.dlTtlTpt +=
6130             (rbAllocInfo->tbInfo[0].bytesAlloc << 3); 
6131          if (rbAllocInfo->tbInfo[1].schdlngForTb)
6132          {
6133             hqP->hqE->cell->tenbStats->sch.dlSumCw1iTbs += 
6134                rbAllocInfo->tbInfo[1].iTbs;
6135             hqP->hqE->cell->tenbStats->sch.dlNumCw1iTbs ++; 
6136             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlSumCw1iTbs += 
6137                rbAllocInfo->tbInfo[1].iTbs;
6138             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlNumCw1iTbs ++; 
6139             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt +=
6140                (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6141
6142
6143 #ifdef LTE_ADV
6144             if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6145             {
6146                addedForScell +=  (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6147                addedForScell2 += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6148 /*
6149          printf (" Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
6150          hqP->procId,
6151          hqP->hqE->cell->cellId,
6152          addedForScell,
6153          addedForScell2);
6154          */
6155             }
6156             totPcellSCell += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6157 #endif
6158
6159
6160             hqP->hqE->cell->tenbStats->sch.dlTtlTpt +=
6161                (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6162          }
6163          /*
6164          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 ,
6165          cell->crntTime.sfn,
6166          cell->crntTime.subframe);
6167          */
6168       }
6169 #endif
6170    }
6171
6172    pdcch->rnti                       = rbAllocInfo->rnti;
6173    pdcch->dci.dciFormat              = rbAllocInfo->dciFormat;
6174    /* Update subframe and pdcch info in HqTb control block */
6175    switch(rbAllocInfo->dciFormat)
6176    {
6177 #ifdef RG_5GTF  
6178       case TFU_DCI_FORMAT_B1:
6179       case TFU_DCI_FORMAT_B2:
6180            {
6181         // printf(" RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
6182               rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, \
6183                     pdcch, tpc);
6184               break;
6185            }
6186 #endif
6187       default:
6188          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6189             "Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
6190          break;
6191    }
6192    RETVOID;
6193 }
6194
6195 /**
6196  * @brief This function fills the PDCCH DCI format 1 information from dlProc.
6197  *
6198  * @details
6199  *
6200  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1
6201  *     Purpose:  This function fills in the PDCCH information
6202  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6203  *               for dedicated service scheduling. It also
6204  *               obtains TPC to be filled in from the power module.
6205  *               Assign the PDCCH to HQProc.
6206  *
6207  *     Invoked by: Downlink Scheduler
6208  *
6209  *  @param[in]  RgSchCellCb*      cell
6210  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6211  *  @param[in]  RgDlHqProc*       hqP
6212  *  @param[out]  RgSchPdcch        *pdcch
6213  *  @param[in]   U8               tpc
6214  *  @return  Void
6215  *
6216  **/
6217 #ifdef ANSI
6218 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1
6219 (
6220 RgSchCellCb                *cell,
6221 RgSchDlRbAlloc             *rbAllocInfo,
6222 RgSchDlHqProcCb            *hqP,
6223 RgSchPdcch                 *pdcch,
6224 U8                         tpc
6225 )
6226 #else
6227 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
6228 RgSchCellCb                *cell;
6229 RgSchDlRbAlloc             *rbAllocInfo;
6230 RgSchDlHqProcCb            *hqP;
6231 RgSchPdcch                 *pdcch;
6232 U8                         tpc;
6233 #endif
6234 {
6235
6236 #ifdef LTE_TDD
6237    RgSchTddANInfo     *anInfo;
6238 #endif
6239
6240 #ifdef LTEMAC_SPS
6241 /* For activation or reactivation,
6242  * Harq ProcId should be 0 */
6243    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6244 #endif
6245
6246     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
6247
6248     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6249     pdcch->dci.u.format1Info.tpcCmd = tpc;
6250      /* Avoiding this check,as we dont support Type1 RA */
6251 #ifdef RG_UNUSED
6252     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6253     {
6254 #endif
6255        pdcch->dci.u.format1Info.allocInfo.isAllocType0 = TRUE;
6256        pdcch->dci.u.format1Info.allocInfo.resAllocMap[0] =
6257          ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6258                & 0xff);
6259        pdcch->dci.u.format1Info.allocInfo.resAllocMap[1] =
6260          ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6261                & 0x00ff);
6262        pdcch->dci.u.format1Info.allocInfo.resAllocMap[2] =
6263            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6264                & 0x0000ff);
6265        pdcch->dci.u.format1Info.allocInfo.resAllocMap[3] =
6266            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6267 #ifdef RG_UNUSED
6268     }
6269 #endif
6270 #ifdef LTEMAC_SPS
6271     if ((!(hqP->tbInfo[0].txCntr)) &&
6272        (cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6273          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6274          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV)))
6275        )
6276     {
6277        pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
6278     }
6279     else
6280     {
6281       pdcch->dci.u.format1Info.allocInfo.harqProcId = hqP->procId;
6282     }
6283 #else
6284     pdcch->dci.u.format1Info.allocInfo.harqProcId = hqP->procId;
6285 #endif
6286
6287     pdcch->dci.u.format1Info.allocInfo.ndi = 
6288                         rbAllocInfo->tbInfo[0].tbCb->ndi;
6289     pdcch->dci.u.format1Info.allocInfo.mcs = 
6290                         rbAllocInfo->tbInfo[0].imcs;
6291     pdcch->dci.u.format1Info.allocInfo.rv = 
6292                         rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6293 #ifdef LTE_TDD
6294        if(hqP->hqE->ue != NULLP)
6295        {
6296 #ifdef LTE_ADV
6297            U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6298                                         hqP->hqE->cell->cellId,
6299                                         hqP->hqE->ue);
6300
6301            anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6302                             &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6303 #else
6304            anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6305                             &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6306 #endif
6307 #ifdef TFU_TDD
6308           if(anInfo)
6309           {
6310              pdcch->dci.u.format1Info.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6311           }
6312           else
6313           {
6314                /* Fixing DAI value - ccpu00109162 */
6315              pdcch->dci.u.format1Info.dai = RG_SCH_MAX_DAI_IDX;
6316           }
6317 #endif
6318        }
6319        else
6320        {
6321             /* always 0 for RACH */
6322            pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
6323 #ifdef TFU_TDD
6324             /* Fixing DAI value - ccpu00109162 */
6325            pdcch->dci.u.format1Info.dai = 1;
6326 #endif
6327        }
6328 #endif
6329  
6330
6331        RETVOID;
6332 }
6333 /**
6334  * @brief This function fills the PDCCH DCI format 1A information from dlProc.
6335  *
6336  * @details
6337  *
6338  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1A
6339  *     Purpose:  This function fills in the PDCCH information
6340  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6341  *               for dedicated service scheduling. It also
6342  *               obtains TPC to be filled in from the power module.
6343  *               Assign the PDCCH to HQProc.
6344  *
6345  *     Invoked by: Downlink Scheduler
6346  *
6347  *  @param[in]  RgSchCellCb*      cell
6348  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6349  *  @param[in]  RgDlHqProc*       hqP
6350  *  @param[out]  RgSchPdcch        *pdcch
6351  *  @param[in]   U8               tpc
6352  *  @return  Void
6353  *
6354  **/
6355 #ifdef ANSI
6356 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A
6357 (
6358 RgSchCellCb                *cell,
6359 RgSchDlRbAlloc             *rbAllocInfo,
6360 RgSchDlHqProcCb            *hqP,
6361 RgSchPdcch                 *pdcch,
6362 U8                         tpc
6363 )
6364 #else
6365 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
6366 RgSchCellCb                *cell;
6367 RgSchDlRbAlloc             *rbAllocInfo;
6368 RgSchDlHqProcCb            *hqP;
6369 RgSchPdcch                 *pdcch;
6370 U8                         tpc;
6371 #endif
6372 {
6373
6374 #ifdef LTE_TDD
6375    RgSchTddANInfo     *anInfo;
6376 #endif
6377
6378 #ifdef LTEMAC_SPS
6379    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6380 #endif
6381
6382     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
6383
6384     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6385     pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
6386     pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = tpc;
6387     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.mcs     = \
6388       rbAllocInfo->tbInfo[0].imcs;
6389     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres = TRUE;
6390 #ifdef LTEMAC_SPS
6391     if ((!(hqP->tbInfo[0].txCntr)) &&
6392        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6393          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6394          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6395        ))
6396     {
6397        pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val = 0;
6398     }
6399     else
6400     {
6401       pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val
6402                                                 = hqP->procId;
6403     }
6404 #else
6405     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val =
6406                                               hqP->procId;
6407 #endif
6408     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.ndi     = \
6409        rbAllocInfo->tbInfo[0].tbCb->ndi;
6410     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv      = \
6411        rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6412          /* As of now, we do not support Distributed allocations */
6413     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.isLocal = TRUE;
6414     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.nGap2.pres = NOTPRSNT;
6415     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.type =
6416             TFU_ALLOC_TYPE_RIV;
6417     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.u.riv =
6418     rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
6419                   rbAllocInfo->allocInfo.raType2.rbStart,
6420                   rbAllocInfo->allocInfo.raType2.numRb);
6421 #ifdef LTE_TDD
6422     if(hqP->hqE->ue != NULLP)
6423     {
6424 #ifdef LTE_ADV
6425        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6426                                         hqP->hqE->cell->cellId,
6427                                         hqP->hqE->ue);
6428        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6429                               &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6430 #else
6431        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6432                               &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6433 #endif
6434 #ifdef TFU_TDD
6435        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
6436        if(anInfo)
6437        {
6438           pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 
6439                               RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6440        }
6441        else
6442        {
6443           /* Fixing DAI value - ccpu00109162 */
6444           pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = RG_SCH_MAX_DAI_IDX;
6445           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6446                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6447                     rbAllocInfo->rnti);
6448        }
6449 #endif
6450     }
6451     else
6452     {
6453             /* always 0 for RACH */
6454        pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres
6455                                                                      = FALSE;
6456 #ifdef TFU_TDD
6457        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
6458             /* Fixing DAI value - ccpu00109162 */
6459        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 1;
6460 #endif
6461     }
6462 #endif
6463  
6464     RETVOID;
6465 }
6466 /**
6467  * @brief This function fills the PDCCH DCI format 1B information from dlProc.
6468  *
6469  * @details
6470  *
6471  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1B
6472  *     Purpose:  This function fills in the PDCCH information
6473  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6474  *               for dedicated service scheduling. It also
6475  *               obtains TPC to be filled in from the power module.
6476  *               Assign the PDCCH to HQProc.
6477  *
6478  *     Invoked by: Downlink Scheduler
6479  *
6480  *  @param[in]  RgSchCellCb*      cell
6481  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6482  *  @param[in]  RgDlHqProc*       hqP
6483  *  @param[out]  RgSchPdcch        *pdcch
6484  *  @param[in]   U8               tpc
6485  *  @return  Void
6486  *
6487  **/
6488 #ifdef ANSI
6489 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B
6490 (
6491 RgSchCellCb                *cell,
6492 RgSchDlRbAlloc             *rbAllocInfo,
6493 RgSchDlHqProcCb            *hqP,
6494 RgSchPdcch                 *pdcch,
6495 U8                         tpc
6496 )
6497 #else
6498 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
6499 RgSchCellCb                *cell;
6500 RgSchDlRbAlloc             *rbAllocInfo;
6501 RgSchDlHqProcCb            *hqP;
6502 RgSchPdcch                 *pdcch;
6503 U8                         tpc;
6504 #endif
6505 {
6506
6507 #ifdef LTE_TDD
6508    RgSchTddANInfo     *anInfo;
6509 #endif
6510
6511 #ifdef LTEMAC_SPS
6512    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6513 #endif
6514
6515     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
6516
6517     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6518     pdcch->dci.u.format1bInfo.tpcCmd  = tpc;
6519     pdcch->dci.u.format1bInfo.allocInfo.mcs     = \
6520            rbAllocInfo->tbInfo[0].imcs;
6521 #ifdef LTEMAC_SPS
6522     if ((!(hqP->tbInfo[0].txCntr)) &&
6523        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6524          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6525          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6526        ))
6527     {
6528        pdcch->dci.u.format1bInfo.allocInfo.harqProcId = 0;
6529     }
6530     else
6531     {
6532       pdcch->dci.u.format1bInfo.allocInfo.harqProcId = hqP->procId;
6533     }
6534 #else
6535     pdcch->dci.u.format1bInfo.allocInfo.harqProcId = hqP->procId;
6536 #endif
6537     pdcch->dci.u.format1bInfo.allocInfo.ndi     = \
6538           rbAllocInfo->tbInfo[0].tbCb->ndi;
6539     pdcch->dci.u.format1bInfo.allocInfo.rv      = \
6540            rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6541          /* As of now, we do not support Distributed allocations */
6542     pdcch->dci.u.format1bInfo.allocInfo.isLocal = TRUE;
6543     pdcch->dci.u.format1bInfo.allocInfo.nGap2.pres = NOTPRSNT;
6544     pdcch->dci.u.format1bInfo.allocInfo.alloc.type =
6545             TFU_ALLOC_TYPE_RIV;
6546     pdcch->dci.u.format1bInfo.allocInfo.alloc.u.riv =
6547     rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
6548                   rbAllocInfo->allocInfo.raType2.rbStart,
6549                   rbAllocInfo->allocInfo.raType2.numRb);
6550          /* Fill precoding Info */
6551     pdcch->dci.u.format1bInfo.allocInfo.pmiCfm = \
6552                rbAllocInfo->mimoAllocInfo.precIdxInfo >> 4;
6553     pdcch->dci.u.format1bInfo.allocInfo.tPmi   = \
6554                rbAllocInfo->mimoAllocInfo.precIdxInfo & 0x0F;
6555 #ifdef LTE_TDD
6556     if(hqP->hqE->ue != NULLP)
6557     {
6558 #ifdef LTE_ADV
6559        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6560                                         hqP->hqE->cell->cellId,
6561                                         hqP->hqE->ue);
6562        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6563              &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6564 #else
6565        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6566              &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6567 #endif
6568 #ifdef TFU_TDD
6569        if(anInfo)
6570        {
6571           pdcch->dci.u.format1bInfo.dai = 
6572                          RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6573        }
6574        else
6575        {
6576           pdcch->dci.u.format1bInfo.dai = RG_SCH_MAX_DAI_IDX;
6577           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6578                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6579                    rbAllocInfo->rnti);
6580        }
6581 #endif
6582     }
6583 #endif
6584        
6585     RETVOID;
6586
6587 }
6588 /**
6589  * @brief This function fills the PDCCH DCI format 2 information from dlProc.
6590  *
6591  * @details
6592  *
6593  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2
6594  *     Purpose:  This function fills in the PDCCH information
6595  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6596  *               for dedicated service scheduling. It also
6597  *               obtains TPC to be filled in from the power module.
6598  *               Assign the PDCCH to HQProc.
6599  *
6600  *     Invoked by: Downlink Scheduler
6601  *
6602  *  @param[in]  RgSchCellCb*      cell
6603  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6604  *  @param[in]  RgDlHqProc*       hqP
6605  *  @param[out]  RgSchPdcch        *pdcch
6606  *  @param[in]   U8               tpc
6607  *  @return  Void
6608  *
6609  **/
6610 #ifdef ANSI
6611 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2
6612 (
6613 RgSchCellCb                *cell,
6614 RgSchDlRbAlloc             *rbAllocInfo,
6615 RgSchDlHqProcCb            *hqP,
6616 RgSchPdcch                 *pdcch,
6617 U8                         tpc
6618 )
6619 #else
6620 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
6621 RgSchCellCb                *cell;
6622 RgSchDlRbAlloc             *rbAllocInfo;
6623 RgSchDlHqProcCb            *hqP;
6624 RgSchPdcch                 *pdcch;
6625 U8                         tpc;
6626 #endif
6627 {
6628
6629 #ifdef LTE_TDD
6630    RgSchTddANInfo     *anInfo;
6631 #endif
6632
6633 #ifdef LTEMAC_SPS
6634 /* ccpu00119023-ADD-For activation or reactivation,
6635  * Harq ProcId should be 0 */
6636    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6637 #endif
6638
6639     TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
6640
6641     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6642     /*ccpu00120365:-ADD-call also if tb is disabled */
6643     if (rbAllocInfo->tbInfo[1].schdlngForTb ||
6644         rbAllocInfo->tbInfo[1].isDisabled)
6645     {
6646         rgSCHCmnFillHqPTb(cell, rbAllocInfo, 1, pdcch);
6647     }
6648     pdcch->dci.u.format2Info.tpcCmd = tpc;
6649          /* Avoiding this check,as we dont support Type1 RA */
6650 #ifdef RG_UNUSED
6651     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6652     {
6653 #endif
6654         pdcch->dci.u.format2Info.allocInfo.isAllocType0 = TRUE;
6655         pdcch->dci.u.format2Info.allocInfo.resAllocMap[0] =
6656           ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6657                & 0xff);
6658         pdcch->dci.u.format2Info.allocInfo.resAllocMap[1] =
6659            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6660                & 0x00ff);
6661         pdcch->dci.u.format2Info.allocInfo.resAllocMap[2] =
6662                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6663                 & 0x0000ff);
6664         pdcch->dci.u.format2Info.allocInfo.resAllocMap[3] =
6665                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6666 #ifdef RG_UNUSED
6667     }
6668 #endif
6669 #ifdef LTEMAC_SPS
6670     if ((!(hqP->tbInfo[0].txCntr)) &&
6671        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6672          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6673          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6674        ))
6675     {
6676        pdcch->dci.u.format2Info.allocInfo.harqProcId = 0;
6677     }
6678     else
6679     {
6680       pdcch->dci.u.format2Info.allocInfo.harqProcId = hqP->procId;
6681     }
6682 #else
6683      pdcch->dci.u.format2Info.allocInfo.harqProcId = hqP->procId;
6684 #endif
6685          /* Initialize the TB info for both the TBs */
6686      pdcch->dci.u.format2Info.allocInfo.tbInfo[0].mcs = 0;
6687      pdcch->dci.u.format2Info.allocInfo.tbInfo[0].rv  = 1;
6688      pdcch->dci.u.format2Info.allocInfo.tbInfo[1].mcs = 0;
6689      pdcch->dci.u.format2Info.allocInfo.tbInfo[1].rv  = 1;
6690          /* Fill tbInfo for scheduled TBs */
6691      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6692         tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6693      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6694         tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[0].imcs;
6695      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6696             tbCb->tbIdx].rv = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6697           /* If we reach this function. It is safely assumed that
6698            *  rbAllocInfo->tbInfo[0] always has non default valid values.
6699            *  rbAllocInfo->tbInfo[1]'s scheduling is optional */
6700      if (rbAllocInfo->tbInfo[1].schdlngForTb == TRUE)
6701      {
6702             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6703                 tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[1].tbCb->ndi;
6704             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6705                 tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[1].imcs;
6706             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6707                 tbCb->tbIdx].rv = rbAllocInfo->tbInfo[1].tbCb->dlGrnt.rv;
6708      }
6709      pdcch->dci.u.format2Info.allocInfo.transSwap =
6710              rbAllocInfo->mimoAllocInfo.swpFlg;
6711      pdcch->dci.u.format2Info.allocInfo.precoding =
6712              rbAllocInfo->mimoAllocInfo.precIdxInfo;
6713 #ifdef LTE_TDD
6714      if(hqP->hqE->ue != NULLP)
6715      {
6716
6717 #ifdef LTE_ADV
6718         U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6719                                         hqP->hqE->cell->cellId,
6720                                         hqP->hqE->ue);
6721         anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6722                            &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6723 #else
6724         anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6725                            &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6726 #endif
6727 #ifdef TFU_TDD
6728         if(anInfo)
6729         {
6730            pdcch->dci.u.format2Info.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6731         }
6732         else
6733         {
6734            pdcch->dci.u.format2Info.dai = RG_SCH_MAX_DAI_IDX;
6735            RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6736                     "PDCCH is been scheduled without updating anInfo RNTI:%d",
6737                     rbAllocInfo->rnti);
6738         }
6739 #endif
6740      }
6741 #endif
6742
6743      RETVOID;
6744 }
6745 /**
6746  * @brief This function fills the PDCCH DCI format 2A information from dlProc.
6747  *
6748  * @details
6749  *
6750  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2A
6751  *     Purpose:  This function fills in the PDCCH information
6752  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6753  *               for dedicated service scheduling. It also
6754  *               obtains TPC to be filled in from the power module.
6755  *               Assign the PDCCH to HQProc.
6756  *
6757  *     Invoked by: Downlink Scheduler
6758  *
6759  *  @param[in]  RgSchCellCb*      cell
6760  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6761  *  @param[in]  RgDlHqProc*       hqP
6762  *  @param[out]  RgSchPdcch        *pdcch
6763  *  @param[in]   U8               tpc
6764  *  @return  Void
6765  *
6766  **/
6767 #ifdef ANSI
6768 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A
6769 (
6770 RgSchCellCb                *cell,
6771 RgSchDlRbAlloc             *rbAllocInfo,
6772 RgSchDlHqProcCb            *hqP,
6773 RgSchPdcch                 *pdcch,
6774 U8                         tpc
6775 )
6776 #else
6777 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
6778 RgSchCellCb                *cell;
6779 RgSchDlRbAlloc             *rbAllocInfo;
6780 RgSchDlHqProcCb            *hqP;
6781 RgSchPdcch                 *pdcch;
6782 U8                         tpc;
6783 #endif
6784 {
6785 #ifdef LTE_TDD
6786    RgSchTddANInfo     *anInfo;
6787 #endif
6788
6789 #ifdef LTEMAC_SPS
6790    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6791 #endif
6792
6793     TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
6794
6795     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6796     /*ccpu00120365:-ADD-call also if tb is disabled */
6797     if (rbAllocInfo->tbInfo[1].schdlngForTb ||
6798           rbAllocInfo->tbInfo[1].isDisabled)
6799     {
6800
6801         rgSCHCmnFillHqPTb(cell, rbAllocInfo, 1, pdcch);
6802     }
6803
6804     pdcch->dci.u.format2AInfo.tpcCmd = tpc;
6805          /* Avoiding this check,as we dont support Type1 RA */
6806 #ifdef RG_UNUSED
6807     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6808     {
6809 #endif
6810         pdcch->dci.u.format2AInfo.allocInfo.isAllocType0 = TRUE;
6811         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[0] =
6812               ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6813                & 0xff);
6814         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[1] =
6815               ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6816                & 0x00ff);
6817         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[2] =
6818                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6819                 & 0x0000ff);
6820         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[3] =
6821                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6822 #ifdef RG_UNUSED
6823     }
6824 #endif
6825 #ifdef LTEMAC_SPS
6826     if ((!(hqP->tbInfo[0].txCntr)) &&
6827        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6828          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6829          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6830        ))
6831     {
6832        pdcch->dci.u.format2AInfo.allocInfo.harqProcId = 0;
6833     }
6834     else
6835     {
6836       pdcch->dci.u.format2AInfo.allocInfo.harqProcId = hqP->procId;
6837     }
6838 #else
6839     pdcch->dci.u.format2AInfo.allocInfo.harqProcId = hqP->procId;
6840 #endif
6841          /* Initialize the TB info for both the TBs */
6842     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[0].mcs = 0;
6843     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[0].rv  = 1;
6844     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[1].mcs = 0;
6845     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[1].rv  = 1;
6846          /* Fill tbInfo for scheduled TBs */
6847     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6848             tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6849     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6850             tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[0].imcs;
6851     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6852             tbCb->tbIdx].rv = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6853          /* If we reach this function. It is safely assumed that
6854           *  rbAllocInfo->tbInfo[0] always has non default valid values.
6855           *  rbAllocInfo->tbInfo[1]'s scheduling is optional */
6856
6857     if (rbAllocInfo->tbInfo[1].schdlngForTb == TRUE)
6858     {
6859             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6860                tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[1].tbCb->ndi;
6861             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6862                tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[1].imcs;
6863             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6864                tbCb->tbIdx].rv = rbAllocInfo->tbInfo[1].tbCb->dlGrnt.rv;
6865
6866     }
6867     pdcch->dci.u.format2AInfo.allocInfo.transSwap =
6868             rbAllocInfo->mimoAllocInfo.swpFlg;
6869     pdcch->dci.u.format2AInfo.allocInfo.precoding =
6870             rbAllocInfo->mimoAllocInfo.precIdxInfo;
6871 #ifdef LTE_TDD
6872     if(hqP->hqE->ue != NULLP)
6873     {
6874 #ifdef LTE_ADV
6875        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6876                                         hqP->hqE->cell->cellId,
6877                                         hqP->hqE->ue);
6878        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6879                          &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6880 #else
6881        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6882                          &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6883 #endif
6884 #ifdef TFU_TDD
6885        if(anInfo)
6886        {
6887           pdcch->dci.u.format2AInfo.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6888        }
6889        else
6890        {
6891           pdcch->dci.u.format2AInfo.dai = RG_SCH_MAX_DAI_IDX;
6892           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6893                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6894                    rbAllocInfo->rnti);
6895        }
6896 #endif
6897      }
6898 #endif
6899
6900
6901     RETVOID;
6902 }
6903
6904 /**
6905  * @brief init of Sch vars.
6906  *
6907  * @details
6908  *
6909  *     Function: rgSCHCmnInitVars
6910        Purpose:  Initialization of various UL subframe indices
6911  *
6912  *  @param[in]  RgSchCellCb *cell
6913  *  @return  Void
6914  *
6915  **/
6916 #ifdef ANSI
6917 PRIVATE Void rgSCHCmnInitVars
6918 (
6919 RgSchCellCb *cell
6920 )
6921 #else
6922 PRIVATE Void rgSCHCmnInitVars(cell)
6923 RgSchCellCb *cell;
6924 #endif
6925 {
6926    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
6927
6928    TRC2(rgSCHCmnInitVars);
6929
6930    cellUl->idx         = RGSCH_INVALID_INFO;
6931    cellUl->schdIdx     = RGSCH_INVALID_INFO;
6932    cellUl->schdHqProcIdx = RGSCH_INVALID_INFO;
6933    cellUl->msg3SchdIdx = RGSCH_INVALID_INFO;
6934 #ifdef EMTC_ENBLE
6935    cellUl->emtcMsg3SchdIdx = RGSCH_INVALID_INFO;
6936 #endif
6937    cellUl->msg3SchdHqProcIdx = RGSCH_INVALID_INFO;
6938    cellUl->rcpReqIdx   = RGSCH_INVALID_INFO;
6939    cellUl->hqFdbkIdx[0] = RGSCH_INVALID_INFO;
6940    cellUl->hqFdbkIdx[1] = RGSCH_INVALID_INFO;
6941    cellUl->reTxIdx[0]   = RGSCH_INVALID_INFO;
6942    cellUl->reTxIdx[1]   = RGSCH_INVALID_INFO;
6943   /* Stack Crash problem for TRACE5 Changes. Added the return below */
6944   RETVOID;
6945
6946 }
6947
6948 #ifndef LTE_TDD
6949 /**
6950  * @brief Updation of Sch vars per TTI.
6951  *
6952  * @details
6953  *
6954  *     Function: rgSCHCmnUpdVars
6955  *     Purpose:  Updation of Sch vars per TTI.
6956  *
6957  *  @param[in]  RgSchCellCb *cell
6958  *  @return  Void
6959  *
6960  **/
6961 #ifdef ANSI
6962 PUBLIC Void rgSCHCmnUpdVars
6963 (
6964 RgSchCellCb *cell
6965 )
6966 #else
6967 PUBLIC Void rgSCHCmnUpdVars(cell)
6968 RgSchCellCb *cell;
6969 #endif
6970 {
6971    CmLteTimingInfo   timeInfo;
6972    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
6973    U16 idx;
6974
6975    TRC2(rgSCHCmnUpdVars);
6976
6977    idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.subframe);
6978    cellUl->idx     = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
6979 #ifdef UL_ADPT_DBG     
6980    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.subframe);
6981 #endif    
6982    /* Need to scheduler for after SCHED_DELTA */
6983    /* UL allocation has been advanced by 1 subframe
6984     * so that we do not wrap around and send feedback
6985     * before the data is even received by the PHY */
6986    /* Introduced timing delta for UL control */
6987    idx = (cellUl->idx + TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA);
6988    cellUl->schdIdx     = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
6989
6990    RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,
6991             TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA)
6992    cellUl->schdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
6993
6994    /* ccpu00127193 filling schdTime for logging and enhancement purpose*/
6995    cellUl->schdTime = timeInfo;
6996
6997    /* msg3 scheduling two subframes after general scheduling */
6998    idx = (cellUl->idx + RG_SCH_CMN_DL_DELTA + RGSCH_RARSP_MSG3_DELTA);
6999    cellUl->msg3SchdIdx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7000
7001    RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,
7002             RG_SCH_CMN_DL_DELTA+ RGSCH_RARSP_MSG3_DELTA)
7003    cellUl->msg3SchdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
7004
7005    idx = (cellUl->idx + TFU_RECPREQ_DLDELTA);
7006
7007    cellUl->rcpReqIdx   = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7008
7009    /* Downlink harq feedback is sometime after data reception / harq failure */
7010    /* Since feedback happens prior to scheduling being called, we add 1 to   */
7011    /* take care of getting the correct subframe for feedback                 */
7012    idx = (cellUl->idx - TFU_CRCIND_ULDELTA + RG_SCH_CMN_UL_NUM_SF);
7013 #ifdef UL_ADPT_DBG     
7014    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);
7015 #endif
7016    cellUl->hqFdbkIdx[0]   = (idx % (RG_SCH_CMN_UL_NUM_SF));
7017
7018    idx = ((cellUl->schdIdx) % (RG_SCH_CMN_UL_NUM_SF));
7019
7020    cellUl->reTxIdx[0] = (U8) idx;
7021 #ifdef UL_ADPT_DBG     
7022    printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
7023 #endif
7024    /* RACHO: update cmn sched specific RACH variables,
7025     * mainly the prachMaskIndex */
7026    rgSCHCmnUpdRachParam(cell);
7027
7028    RETVOID;
7029 }
7030 #endif
7031
7032 #ifdef LTE_TDD
7033
7034 /**
7035  * @brief To get uplink subframe index associated with current PHICH
7036  *        transmission.
7037  *
7038  * @details
7039  *
7040  *     Function: rgSCHCmnGetPhichUlSfIdx
7041  *     Purpose:  Gets uplink subframe index associated with current PHICH
7042  *               transmission based on SFN and subframe no
7043  *
7044  *  @param[in]  CmLteTimingInfo  *timeInfo
7045  *  @param[in]  RgSchCellCb              *cell
7046  *  @return U8
7047  *
7048  **/
7049 #ifdef ANSI
7050 PUBLIC U8  rgSCHCmnGetPhichUlSfIdx
7051 (
7052 CmLteTimingInfo *timeInfo,
7053 RgSchCellCb *cell
7054 )
7055 #else
7056 PUBLIC U8  rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
7057 CmLteTimingInfo *timeInfo;
7058 RgSchCellCb        *cell;
7059 #endif
7060 {
7061    RgSchCmnUlCell       *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
7062    RgSchDlSf            *dlsf;
7063    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
7064    U8                   idx;
7065    U16                  numUlSf;
7066    U16                  sfn;
7067    U8                   subframe;
7068
7069    TRC2(rgSCHCmnGetPhichUlSfIdx);
7070
7071    dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
7072
7073    if(dlsf->phichOffInfo.sfnOffset == RGSCH_INVALID_INFO)
7074    {
7075       RETVALUE(RGSCH_INVALID_INFO);
7076    }
7077    subframe = dlsf->phichOffInfo.subframe;
7078
7079    sfn = (RGSCH_MAX_SFN + timeInfo->sfn -
7080                    dlsf->phichOffInfo.sfnOffset) % RGSCH_MAX_SFN;
7081
7082    /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
7083     * wrap case such that idx will be proper*/
7084    numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7085    numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
7086    idx = numUlSf % (cellUl->numUlSubfrms);
7087
7088    RETVALUE(idx);
7089 }
7090
7091 /**
7092  * @brief To get uplink subframe index.
7093  *
7094  * @details
7095  *
7096  *
7097  *     Function: rgSCHCmnGetUlSfIdx
7098  *     Purpose:  Gets uplink subframe index based on SFN and subframe number.
7099  *
7100  *  @param[in]  CmLteTimingInfo  *timeInfo
7101  *  @param[in]  U8               ulDlCfgIdx
7102  *  @return U8
7103  *
7104  **/
7105 #ifdef ANSI
7106 PUBLIC U8  rgSCHCmnGetUlSfIdx
7107 (
7108 CmLteTimingInfo *timeInfo,
7109 RgSchCellCb *cell
7110 )
7111 #else
7112 PUBLIC U8  rgSCHCmnGetUlSfIdx(timeInfo, cell)
7113 CmLteTimingInfo *timeInfo;
7114 RgSchCellCb *cell;
7115 #endif
7116 {
7117    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
7118    U8                ulDlCfgIdx = cell->ulDlCfgIdx;
7119    U8                idx = 0;
7120    U16               numUlSf;
7121
7122    TRC2(rgSCHCmnGetUlSfIdx);
7123
7124    /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
7125     * wrap case such that idx will be proper*/
7126    numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7127    numUlSf = ((numUlSf * timeInfo->sfn) + \
7128          rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->subframe]) - 1;
7129    idx = numUlSf % (cellUl->numUlSubfrms);
7130
7131    RETVALUE(idx);
7132 }
7133
7134 #endif
7135
7136 /**
7137  * @brief To get uplink hq index.
7138  *
7139  * @details
7140  *
7141  *
7142  *     Function: rgSCHCmnGetUlHqProcIdx
7143  *     Purpose:  Gets uplink subframe index based on SFN and subframe number.
7144  *
7145  *  @param[in]  CmLteTimingInfo  *timeInfo
7146  *  @param[in]  U8               ulDlCfgIdx
7147  *  @return U8
7148  *
7149  **/
7150 #ifdef ANSI
7151 PUBLIC U8  rgSCHCmnGetUlHqProcIdx
7152 (
7153 CmLteTimingInfo *timeInfo,
7154 RgSchCellCb *cell
7155 )
7156 #else
7157 PUBLIC U8  rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
7158 CmLteTimingInfo *timeInfo;
7159 RgSchCellCb *cell;
7160 #endif
7161 {
7162    U8            procId;
7163    U32           numUlSf;
7164   
7165 #ifndef LTE_TDD
7166    numUlSf  = (timeInfo->sfn * RGSCH_NUM_SUB_FRAMES_5G + timeInfo->subframe);
7167    procId   = numUlSf % RGSCH_NUM_UL_HQ_PROC;
7168 #else
7169    U8            ulDlCfgIdx = cell->ulDlCfgIdx;
7170    /*ccpu00130639 - MOD - To get correct UL HARQ Proc IDs for all UL/DL Configs*/
7171    U8            numUlSfInSfn;
7172    S8            sfnCycle = cell->tddHqSfnCycle;
7173    U8            numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
7174
7175    /* TRACE 5 Changes */
7176    TRC2(rgSCHCmnGetUlHqProcIdx);
7177
7178    /* Calculate the number of UL SF in one SFN */
7179    numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
7180                rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7181
7182    /* Check for the SFN wrap around case */
7183    if(cell->crntTime.sfn == 1023 && timeInfo->sfn == 0)
7184    {
7185       sfnCycle++;
7186    }
7187    else if(cell->crntTime.sfn == 0 && timeInfo->sfn == 1023)
7188    {
7189       /* sfnCycle decremented by 1 */
7190       sfnCycle = (sfnCycle + numUlHarq-1) % numUlHarq;
7191    }
7192    /* Calculate the total number of UL sf */
7193    /*  -1 is done since uplink sf are counted from 0 */
7194    numUlSf = numUlSfInSfn *  (timeInfo->sfn + (sfnCycle*1024)) +
7195                   rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->subframe] - 1;
7196
7197    procId = numUlSf % numUlHarq;   
7198 #endif
7199    RETVALUE(procId);
7200 }
7201
7202
7203 /* UL_ALLOC_CHANGES */
7204 /***********************************************************
7205  *
7206  *     Func : rgSCHCmnUlFreeAlloc
7207  *
7208  *     Desc : Free an allocation - invokes UHM and releases
7209  *            alloc for the scheduler
7210  *            Doest need subframe as argument
7211  *
7212  *     Ret  :
7213  *
7214  *     Notes:
7215  *
7216  *     File :
7217  *
7218  **********************************************************/
7219 #ifdef ANSI
7220 PUBLIC Void rgSCHCmnUlFreeAlloc
7221 (
7222 RgSchCellCb     *cell,
7223 RgSchUlAlloc    *alloc
7224 )
7225 #else
7226 PUBLIC Void rgSCHCmnUlFreeAlloc(cell, alloc)
7227 RgSchCellCb     *cell;
7228 RgSchUlAlloc    *alloc;
7229 #endif
7230 {
7231    RgSchUlHqProcCb *hqProc;
7232    TRC2(rgSCHCmnUlFreeAllocation);
7233
7234    if (alloc->forMsg3)
7235    {
7236       /* Fix : Release RNTI upon MSG3 max TX failure for non-HO UEs */
7237       if ((alloc->hqProc->remTx == 0) &&
7238           (alloc->hqProc->rcvdCrcInd == FALSE) &&
7239           (alloc->raCb))
7240       {
7241          RgSchRaCb      *raCb = alloc->raCb;
7242          rgSCHUhmFreeProc(alloc->hqProc, cell);
7243          rgSCHUtlUlAllocRelease(alloc);
7244          rgSCHRamDelRaCb(cell, raCb, TRUE);
7245          RETVOID;
7246       }
7247    }
7248    
7249    hqProc = alloc->hqProc;
7250    rgSCHUtlUlAllocRelease(alloc);
7251    rgSCHUhmFreeProc(hqProc, cell);
7252    RETVOID;
7253 }
7254
7255
7256 /***********************************************************
7257  *
7258  *     Func : rgSCHCmnUlFreeAllocation
7259  *
7260  *     Desc : Free an allocation - invokes UHM and releases
7261  *            alloc for the scheduler
7262  *
7263  *     Ret  :
7264  *
7265  *     Notes:
7266  *
7267  *     File :
7268  *
7269  **********************************************************/
7270 #ifdef ANSI
7271 PUBLIC Void rgSCHCmnUlFreeAllocation
7272 (
7273 RgSchCellCb     *cell,
7274 RgSchUlSf       *sf,
7275 RgSchUlAlloc    *alloc
7276 )
7277 #else
7278 PUBLIC Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
7279 RgSchCellCb     *cell;
7280 RgSchUlSf       *sf;
7281 RgSchUlAlloc    *alloc;
7282 #endif
7283 {
7284    RgSchUlHqProcCb *hqProc;
7285
7286    TRC2(rgSCHCmnUlFreeAllocation);
7287
7288    if (alloc->forMsg3)
7289    {
7290       /* Fix : Release RNTI upon MSG3 max TX failure for non-HO UEs */
7291       if ((alloc->hqProc->remTx == 0) &&
7292           (alloc->hqProc->rcvdCrcInd == FALSE) &&
7293           (alloc->raCb))
7294       {
7295          RgSchRaCb      *raCb = alloc->raCb;
7296          rgSCHUhmFreeProc(alloc->hqProc, cell);
7297          rgSCHUtlUlAllocRls(sf, alloc);
7298          rgSCHRamDelRaCb(cell, raCb, TRUE);
7299          RETVOID;
7300       }
7301    }
7302    
7303    hqProc = alloc->hqProc;
7304    rgSCHUhmFreeProc(hqProc, cell);
7305 #ifdef LTE_L2_MEAS
7306    /* re-setting the PRB count while freeing the allocations */
7307    sf->totPrb = 0;
7308 #endif
7309    rgSCHUtlUlAllocRls(sf, alloc);
7310
7311    RETVOID;
7312 }
7313
7314 /**
7315  * @brief This function implements PDCCH allocation for an UE
7316  *        in the currently running subframe.
7317  *
7318  * @details
7319  *
7320  *     Function: rgSCHCmnPdcchAllocCrntSf
7321  *     Purpose:  This function determines current DL subframe
7322  *               and UE DL CQI to call the actual pdcch allocator
7323  *               function.
7324  *               Note that this function is called only
7325  *               when PDCCH request needs to be made during
7326  *               uplink scheduling.
7327  *
7328  *     Invoked by: Scheduler
7329  *
7330  *  @param[in]  RgSchCellCb  *cell
7331  *  @param[in]  RgSchUeCb    *ue
7332  *  @return  RgSchPdcch *
7333  *         -# NULLP when unsuccessful
7334  **/
7335 #ifdef ANSI
7336 PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
7337 (
7338 RgSchCellCb                *cell,
7339 RgSchUeCb                  *ue
7340 )
7341 #else
7342 PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
7343 RgSchCellCb                *cell;
7344 RgSchUeCb                  *ue;
7345 #endif
7346 {
7347    CmLteTimingInfo      frm = cell->crntTime;
7348    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7349    RgSchDlSf            *sf;
7350    RgSchPdcch           *pdcch = NULLP;
7351
7352    TRC2(rgSCHCmnPdcchAllocCrntSf);
7353    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
7354    sf = rgSCHUtlSubFrmGet(cell, frm);
7355
7356 #ifdef LTE_ADV
7357    if (ue->allocCmnUlPdcch)
7358    {
7359       pdcch = rgSCHCmnCmnPdcchAlloc(cell, sf);
7360       /* Since CRNTI Scrambled */
7361       if(NULLP != pdcch)
7362       {
7363          pdcch->dciNumOfBits = ue->dciSize.cmnSize[TFU_DCI_FORMAT_0];
7364       }
7365    }
7366    else
7367 #endif
7368    {
7369       //pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, y, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_0, FALSE);
7370                 pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_A1, FALSE);
7371    }
7372    RETVALUE(pdcch);
7373 }
7374
7375 /***********************************************************
7376  *
7377  *     Func : rgSCHCmnUlAllocFillNdmrs
7378  *
7379  *     Desc : Determines and fills N_dmrs for a UE uplink
7380  *            allocation.
7381  *
7382  *     Ret  :
7383  *
7384  *     Notes: N_dmrs determination is straightforward, so
7385  *            it is configured per subband
7386  *
7387  *     File :
7388  *
7389  **********************************************************/
7390 #ifdef ANSI
7391 PUBLIC Void rgSCHCmnUlAllocFillNdmrs
7392 (
7393 RgSchCmnUlCell *cellUl,
7394 RgSchUlAlloc   *alloc
7395 )
7396 #else
7397 PUBLIC Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
7398 RgSchCmnUlCell *cellUl;
7399 RgSchUlAlloc   *alloc;
7400 #endif
7401 {
7402    TRC2(rgSCHCmnUlAllocFillNdmrs);
7403    alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
7404    RETVOID;
7405 }
7406
7407 /***********************************************************
7408  *
7409  *     Func : rgSCHCmnUlAllocLnkHqProc
7410  *
7411  *     Desc : Links a new allocation for an UE with the
7412  *            appropriate HARQ process of the UE.
7413  *
7414  *     Ret  :
7415  *
7416  *     Notes:
7417  *
7418  *     File :
7419  *
7420  **********************************************************/
7421 #ifdef ANSI
7422 PUBLIC Void rgSCHCmnUlAllocLnkHqProc
7423 (
7424 RgSchUeCb       *ue,
7425 RgSchUlAlloc    *alloc,
7426 RgSchUlHqProcCb *proc,
7427 Bool            isRetx
7428 )
7429 #else
7430 PUBLIC Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
7431 RgSchUeCb       *ue;
7432 RgSchUlAlloc    *alloc;
7433 RgSchUlHqProcCb *proc;
7434 Bool            isRetx;
7435 #endif
7436 {
7437    TRC2(rgSCHCmnUlAllocLnkHqProc);
7438
7439    if(TRUE == isRetx)
7440    {
7441       rgSCHCmnUlAdapRetx(alloc, proc);
7442    }
7443    else
7444    {
7445 #ifdef LTE_L2_MEAS /* L2_COUNTERS */
7446       alloc->ue = ue;
7447 #endif
7448       rgSCHUhmNewTx(proc, (((RgUeUlHqCb*)proc->hqEnt)->maxHqRetx), alloc);
7449    }
7450    RETVOID;
7451 }
7452
7453 /**
7454  * @brief This function releases a PDCCH in the subframe that is
7455  *        currently being allocated for.
7456  *
7457  * @details
7458  *
7459  *     Function: rgSCHCmnPdcchRlsCrntSf
7460  *     Purpose:  This function determines current DL subframe
7461  *               which is considered for PDCCH allocation,
7462  *               and then calls the actual function that
7463  *               releases a PDCCH in a specific subframe.
7464  *               Note that this function is called only
7465  *               when PDCCH release needs to be made during
7466  *               uplink scheduling.
7467  *
7468  *     Invoked by: Scheduler
7469  *
7470  *  @param[in]  RgSchCellCb  *cell
7471  *  @param[in]  RgSchPdcch   *pdcch
7472  *  @return  Void
7473  **/
7474 #ifdef ANSI
7475 PUBLIC Void rgSCHCmnPdcchRlsCrntSf
7476 (
7477 RgSchCellCb                *cell,
7478 RgSchPdcch                 *pdcch
7479 )
7480 #else
7481 PUBLIC Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
7482 RgSchCellCb                *cell;
7483 RgSchPdcch                 *pdcch;
7484 #endif
7485 {
7486    CmLteTimingInfo      frm = cell->crntTime;
7487    RgSchDlSf               *sf;
7488
7489    TRC2(rgSCHCmnPdcchRlsCrntSf);
7490
7491    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
7492    sf = rgSCHUtlSubFrmGet(cell, frm);
7493    rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, pdcch);
7494    RETVOID;
7495 }
7496 /***********************************************************
7497  *
7498  *     Func : rgSCHCmnUlFillPdcchWithAlloc
7499  *
7500  *     Desc : Fills a PDCCH with format 0 information.
7501  *
7502  *     Ret  :
7503  *
7504  *     Notes:
7505  *
7506  *     File :
7507  *
7508  **********************************************************/
7509 #ifdef ANSI
7510 PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc
7511 (
7512 RgSchPdcch      *pdcch,
7513 RgSchUlAlloc    *alloc,
7514 RgSchUeCb       *ue
7515 )
7516 #else
7517 PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
7518 RgSchPdcch      *pdcch;
7519 RgSchUlAlloc    *alloc;
7520 RgSchUeCb       *ue;
7521 #endif
7522 {
7523
7524    TRC2(rgSCHCmnUlFillPdcchWithAlloc);
7525
7526    pdcch->ue = ue;
7527    pdcch->rnti = alloc->rnti;
7528    //pdcch->dci.dciFormat = TFU_DCI_FORMAT_A2;
7529    pdcch->dci.dciFormat = alloc->grnt.dciFrmt;
7530
7531    //Currently hardcoding values here.
7532    //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
7533    switch(pdcch->dci.dciFormat)
7534    {
7535       case TFU_DCI_FORMAT_A1:
7536                 {
7537                         pdcch->dci.u.formatA1Info.formatType = 0;
7538          pdcch->dci.u.formatA1Info.xPUSCHRange = alloc->grnt.xPUSCHRange;
7539          pdcch->dci.u.formatA1Info.xPUSCH_TxTiming = 0;
7540          pdcch->dci.u.formatA1Info.RBAssign = alloc->grnt.rbAssign;
7541          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.hqProcId = alloc->grnt.hqProcId;
7542          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.mcs = alloc->grnt.iMcsCrnt;
7543          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.ndi = alloc->hqProc->ndi;
7544          pdcch->dci.u.formatA1Info.CSI_BSI_BRI_Req = 0;
7545          pdcch->dci.u.formatA1Info.CSIRS_BRRS_TxTiming = 0;
7546          pdcch->dci.u.formatA1Info.CSIRS_BRRS_SymbIdx = 0;
7547          pdcch->dci.u.formatA1Info.CSIRS_BRRS_ProcInd = 0;
7548          pdcch->dci.u.formatA1Info.numBSI_Reports = 0;
7549          pdcch->dci.u.formatA1Info.uciOnxPUSCH = alloc->grnt.uciOnxPUSCH;
7550          pdcch->dci.u.formatA1Info.beamSwitch  = 0;
7551          pdcch->dci.u.formatA1Info.SRS_Config = 0;
7552          pdcch->dci.u.formatA1Info.SRS_Symbol = 0;
7553          pdcch->dci.u.formatA1Info.REMapIdx_DMRS_PCRS_numLayers = 0;
7554          pdcch->dci.u.formatA1Info.SCID = alloc->grnt.SCID;
7555          pdcch->dci.u.formatA1Info.PMI = alloc->grnt.PMI;
7556          pdcch->dci.u.formatA1Info.UL_PCRS = 0;
7557          pdcch->dci.u.formatA1Info.tpcCmd = alloc->grnt.tpc;
7558                         break;
7559       }
7560                 case TFU_DCI_FORMAT_A2:
7561                 {
7562                         pdcch->dci.u.formatA2Info.formatType = 1;
7563          pdcch->dci.u.formatA2Info.xPUSCHRange = alloc->grnt.xPUSCHRange;
7564          pdcch->dci.u.formatA2Info.xPUSCH_TxTiming = 0;
7565          pdcch->dci.u.formatA2Info.RBAssign = alloc->grnt.rbAssign;
7566          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.hqProcId = alloc->grnt.hqProcId;
7567          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.mcs = alloc->grnt.iMcsCrnt;
7568          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.ndi = alloc->hqProc->ndi;
7569          pdcch->dci.u.formatA2Info.CSI_BSI_BRI_Req = 0;
7570          pdcch->dci.u.formatA2Info.CSIRS_BRRS_TxTiming = 0;
7571          pdcch->dci.u.formatA2Info.CSIRS_BRRS_SymbIdx = 0;
7572          pdcch->dci.u.formatA2Info.CSIRS_BRRS_ProcInd = 0;
7573          pdcch->dci.u.formatA2Info.numBSI_Reports = 0;
7574          pdcch->dci.u.formatA2Info.uciOnxPUSCH = alloc->grnt.uciOnxPUSCH;
7575          pdcch->dci.u.formatA2Info.beamSwitch  = 0;
7576          pdcch->dci.u.formatA2Info.SRS_Config = 0;
7577          pdcch->dci.u.formatA2Info.SRS_Symbol = 0;
7578          pdcch->dci.u.formatA2Info.REMapIdx_DMRS_PCRS_numLayers = 0;
7579          pdcch->dci.u.formatA2Info.SCID = alloc->grnt.SCID;
7580          pdcch->dci.u.formatA2Info.PMI = alloc->grnt.PMI;
7581          pdcch->dci.u.formatA2Info.UL_PCRS = 0;
7582          pdcch->dci.u.formatA2Info.tpcCmd = alloc->grnt.tpc;
7583                         break;
7584                 }
7585       default:
7586          RLOG1(L_ERROR," 5GTF_ERROR UL Allocator's icorrect "
7587                "dciForamt Fill RNTI:%d",alloc->rnti);
7588          break;
7589    }    
7590    
7591
7592    RETVOID;
7593 }
7594
7595 /***********************************************************
7596  *
7597  *     Func : rgSCHCmnUlAllocFillTpc
7598  *
7599  *     Desc : Determines and fills TPC for an UE allocation.
7600  *
7601  *     Ret  :
7602  *
7603  *     Notes:
7604  *
7605  *     File :
7606  *
7607  **********************************************************/
7608 #ifdef ANSI
7609 PUBLIC Void rgSCHCmnUlAllocFillTpc
7610 (
7611 RgSchCellCb  *cell,
7612 RgSchUeCb    *ue,
7613 RgSchUlAlloc *alloc
7614 )
7615 #else
7616 PUBLIC Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
7617 RgSchCellCb  *cell;
7618 RgSchUeCb    *ue;
7619 RgSchUlAlloc *alloc;
7620 #endif
7621 {
7622    TRC2(rgSCHCmnUlAllocFillTpc);
7623    alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
7624    RETVOID;
7625 }
7626
7627
7628 /***********************************************************
7629  *
7630  *     Func : rgSCHCmnAddUeToRefreshQ
7631  *
7632  *     Desc : Adds a UE to refresh queue, so that the UE is
7633  *            periodically triggered to refresh it's GBR and
7634  *            AMBR values.
7635  *
7636  *     Ret  :
7637  *
7638  *     Notes:
7639  *
7640  *     File :
7641  *
7642  **********************************************************/
7643 #ifdef ANSI
7644 PRIVATE Void rgSCHCmnAddUeToRefreshQ
7645 (
7646 RgSchCellCb     *cell,
7647 RgSchUeCb       *ue,
7648 U32             wait
7649 )
7650 #else
7651 PRIVATE Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
7652 RgSchCellCb     *cell;
7653 RgSchUeCb       *ue;
7654 U32             wait;
7655 #endif
7656 {
7657    RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
7658    CmTmrArg       arg;
7659    RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
7660
7661    TRC2(rgSCHCmnAddUeToRefreshQ);
7662    UNUSED(cell);
7663
7664    cmMemset((U8 *)&arg, 0, sizeof(arg));
7665    arg.tqCp   = &sched->tmrTqCp;
7666    arg.tq     = sched->tmrTq;
7667    arg.timers = &ueSchd->tmr;
7668    arg.cb     = (PTR)ue;
7669    arg.tNum   = 0;
7670    arg.max    = 1;
7671    arg.evnt   = RG_SCH_CMN_EVNT_UE_REFRESH;
7672    arg.wait   = wait;
7673    cmPlcCbTq(&arg);
7674    RETVOID;
7675 }
7676
7677 /**
7678  * @brief Perform UE reset procedure.
7679  *
7680  * @details
7681  *
7682  *     Function : rgSCHCmnUlUeReset
7683  *
7684  *     This functions performs BSR resetting and
7685  *     triggers UL specific scheduler
7686  *     to Perform UE reset procedure.
7687  *
7688  *  @param[in]  RgSchCellCb  *cell
7689  *  @param[in]  RgSchUeCb    *ue
7690  *  @return  Void
7691  **/
7692 #ifdef ANSI
7693 PRIVATE Void rgSCHCmnUlUeReset
7694 (
7695 RgSchCellCb  *cell,
7696 RgSchUeCb    *ue
7697 )
7698 #else
7699 PRIVATE Void rgSCHCmnUlUeReset(cell, ue)
7700 RgSchCellCb  *cell;
7701 RgSchUeCb    *ue;
7702 #endif
7703 {
7704    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7705    RgSchCmnUlUe         *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
7706    U8                   lcgCnt=0;
7707    RgSchCmnLcg          *lcgCmn;
7708    CmLList              *node;
7709    RgSchCmnAllocRecord  *allRcd;
7710    TRC2(rgSCHCmnUlUeReset);
7711
7712    ue->ul.minReqBytes = 0;
7713    ue->ul.totalBsr = 0;
7714    ue->ul.effBsr = 0;
7715    ue->ul.nonGbrLcgBs = 0;
7716    ue->ul.effAmbr = ue->ul.cfgdAmbr;
7717
7718    node = ueUl->ulAllocLst.first;
7719    while (node)
7720    {
7721       allRcd = (RgSchCmnAllocRecord *)node->node;
7722       allRcd->alloc = 0;
7723       node = node->next;
7724    }
7725    for(lcgCnt = 0; lcgCnt < RGSCH_MAX_LCG_PER_UE; lcgCnt++)
7726    {
7727       lcgCmn = RG_SCH_CMN_GET_UL_LCG(&ue->ul.lcgArr[lcgCnt]);
7728       lcgCmn->bs = 0;
7729       lcgCmn->reportedBs = 0;
7730       lcgCmn->effGbr = lcgCmn->cfgdGbr;
7731       lcgCmn->effDeltaMbr = lcgCmn->deltaMbr;
7732    }
7733    rgSCHCmnUlUeDelAllocs(cell, ue);
7734
7735    ue->isSrGrant = FALSE;
7736
7737    cellSchd->apisUl->rgSCHUlUeReset(cell, ue);
7738
7739    /* Stack Crash problem for TRACE5 changes. Added the return below */
7740    RETVOID;
7741
7742 }
7743
7744 /**
7745  * @brief RESET UL CQI and DL CQI&RI to conservative values
7746     * for a reestablishing UE.
7747  *
7748  * @details
7749  *
7750  *     Function : rgSCHCmnResetRiCqi 
7751  *     
7752  *     RESET UL CQI and DL CQI&RI to conservative values
7753  *     for a reestablishing UE
7754  *
7755  *  @param[in]  RgSchCellCb  *cell
7756  *  @param[in]  RgSchUeCb    *ue
7757  *  @return  Void
7758  **/
7759 #ifdef ANSI
7760 PRIVATE Void rgSCHCmnResetRiCqi 
7761 (
7762 RgSchCellCb  *cell,
7763 RgSchUeCb    *ue
7764 )
7765 #else
7766 PRIVATE Void rgSCHCmnResetRiCqi(cell, ue)
7767 RgSchCellCb  *cell;
7768 RgSchUeCb    *ue;
7769 #endif
7770 {
7771    RgSchCmnCell  *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7772    RgSchCmnUe    *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
7773    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7774    RgSchCmnUlUe  *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
7775
7776    TRC2(rgSCHCmnResetRiCqi);
7777
7778    rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, 
7779          cell->isCpUlExtend);
7780
7781    ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
7782    ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
7783    ueDl->mimoInfo.ri = 1;
7784    if ((ue->mimoInfo.txMode == RGR_UE_TM_4) ||
7785           (ue->mimoInfo.txMode == RGR_UE_TM_6))
7786    {
7787       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
7788    }
7789    if (ue->mimoInfo.txMode == RGR_UE_TM_3)
7790    {
7791       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
7792    }
7793 #ifdef EMTC_ENABLE   
7794    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, ue->isEmtcUe);
7795 #else
7796    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, FALSE);
7797 #endif      
7798
7799 #ifdef TFU_UPGRADE
7800    /* Request for an early Aper CQI in case of reest */
7801    RgSchUeACqiCb  *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell); 
7802    if(acqiCb && acqiCb->aCqiCfg.pres)
7803    {
7804       acqiCb->aCqiTrigWt = 0;
7805    }
7806 #endif   
7807
7808    RETVOID;
7809 }
7810
7811 /**
7812  * @brief Perform UE reset procedure.
7813  *
7814  * @details
7815  *
7816  *     Function : rgSCHCmnDlUeReset
7817  *
7818  *     This functions performs BO resetting and
7819  *     triggers DL specific scheduler
7820  *     to Perform UE reset procedure.
7821  *
7822  *  @param[in]  RgSchCellCb  *cell
7823  *  @param[in]  RgSchUeCb    *ue
7824  *  @return  Void
7825  **/
7826 #ifdef ANSI
7827 PRIVATE Void rgSCHCmnDlUeReset
7828 (
7829 RgSchCellCb  *cell,
7830 RgSchUeCb    *ue
7831 )
7832 #else
7833 PRIVATE Void rgSCHCmnDlUeReset(cell, ue)
7834 RgSchCellCb  *cell;
7835 RgSchUeCb    *ue;
7836 #endif
7837 {
7838    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7839    RgSchCmnDlCell       *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
7840    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7841
7842    TRC2(rgSCHCmnDlUeReset);
7843
7844    if (ueDl->rachInfo.poLnk.node != NULLP)
7845    {
7846       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
7847    }
7848
7849    /* Fix: syed Remove from TA List if this UE is there.
7850     * If TA Timer is running. Stop it */
7851    if (ue->dlTaLnk.node)
7852    {
7853       cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
7854       ue->dlTaLnk.node = (PTR)NULLP;
7855    }
7856    else if (ue->taTmr.tmrEvnt != TMR_NONE)
7857    {
7858       rgSCHTmrStopTmr(cell, ue->taTmr.tmrEvnt, ue);
7859    }
7860
7861    cellSchd->apisDl->rgSCHDlUeReset(cell, ue);
7862 #ifdef LTE_ADV
7863    if (ue->numSCells)
7864    {
7865       rgSCHSCellDlUeReset(cell,ue);
7866    }
7867 #endif
7868 }
7869
7870 /**
7871  * @brief Perform UE reset procedure.
7872  *
7873  * @details
7874  *
7875  *     Function : rgSCHCmnUeReset
7876  *
7877  *     This functions triggers specific scheduler
7878  *     to Perform UE reset procedure.
7879  *
7880  *  @param[in]  RgSchCellCb  *cell
7881  *  @param[in]  RgSchUeCb    *ue
7882  *  @return  S16
7883  *      -# ROK
7884  *      -# RFAILED
7885  **/
7886 #ifdef ANSI
7887 PUBLIC Void rgSCHCmnUeReset
7888 (
7889 RgSchCellCb  *cell,
7890 RgSchUeCb    *ue
7891 )
7892 #else
7893 PUBLIC Void rgSCHCmnUeReset(cell, ue)
7894 RgSchCellCb  *cell;
7895 RgSchUeCb    *ue;
7896 #endif
7897 {
7898    U8 idx;
7899    Pst               pst;
7900    RgInfResetHqEnt   hqEntRstInfo;
7901
7902    TRC2(rgSCHCmnUeReset);
7903    /* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
7904    rgSCHCmnDelRachInfo(cell, ue);
7905
7906    rgSCHPwrUeReset(cell, ue);
7907
7908    rgSCHCmnUlUeReset(cell, ue);
7909    rgSCHCmnDlUeReset(cell, ue);
7910    
7911 #ifdef LTE_ADV
7912    /* Making allocCmnUlPdcch TRUE to allocate DCI0/1A from Common search space.
7913       As because multiple cells are added hence 2 bits CqiReq is there 
7914       This flag will be set to FALSE once we will get Scell READY */
7915    ue->allocCmnUlPdcch = TRUE;
7916 #endif
7917
7918    /* Fix : syed RESET UL CQI and DL CQI&RI to conservative values
7919     * for a reestablishing UE */
7920    /*Reset Cqi Config for all the configured cells*/
7921    for (idx = 0;idx < CM_LTE_MAX_CELLS; idx++)
7922    {
7923       if (ue->cellInfo[idx] != NULLP) 
7924       {   
7925          rgSCHCmnResetRiCqi(ue->cellInfo[idx]->cell, ue);
7926       }
7927    }
7928    /*After Reset Trigger APCQI for Pcell*/
7929    RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
7930    if(pCellInfo->acqiCb.aCqiCfg.pres)
7931    {
7932       ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
7933    }
7934
7935 /* sending HqEnt reset to MAC */
7936    hqEntRstInfo.cellId = cell->cellId;
7937    hqEntRstInfo.crnti  = ue->ueId;
7938
7939    rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
7940    RgSchMacRstHqEnt(&pst,&hqEntRstInfo);
7941
7942    RETVOID;
7943 }
7944
7945 /**
7946  * @brief UE out of MeasGap or AckNackReptn.
7947  *
7948  * @details
7949  *
7950  *     Function : rgSCHCmnActvtUlUe
7951  *
7952  *     This functions triggers specific scheduler
7953  *     to start considering it for scheduling.
7954  *
7955  *  @param[in]  RgSchCellCb  *cell
7956  *  @param[in]  RgSchUeCb    *ue
7957  *  @return  S16
7958  *      -# ROK
7959  *      -# RFAILED
7960  **/
7961 #ifdef ANSI
7962 PUBLIC Void rgSCHCmnActvtUlUe
7963 (
7964 RgSchCellCb  *cell,
7965 RgSchUeCb    *ue
7966 )
7967 #else
7968 PUBLIC Void rgSCHCmnActvtUlUe(cell, ue)
7969 RgSchCellCb  *cell;
7970 RgSchUeCb    *ue;
7971 #endif
7972 {
7973    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7974    TRC2(rgSCHCmnActvtUlUe);
7975
7976    /* : take care of this in UL retransmission */
7977    cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
7978    RETVOID;
7979 }
7980
7981 /**
7982  * @brief UE out of MeasGap or AckNackReptn.
7983  *
7984  * @details
7985  *
7986  *     Function : rgSCHCmnActvtDlUe
7987  *
7988  *     This functions triggers specific scheduler
7989  *     to start considering it for scheduling.
7990  *
7991  *  @param[in]  RgSchCellCb  *cell
7992  *  @param[in]  RgSchUeCb    *ue
7993  *  @return  S16
7994  *      -# ROK
7995  *      -# RFAILED
7996  **/
7997 #ifdef ANSI
7998 PUBLIC Void rgSCHCmnActvtDlUe
7999 (
8000 RgSchCellCb  *cell,
8001 RgSchUeCb    *ue
8002 )
8003 #else
8004 PUBLIC Void rgSCHCmnActvtDlUe(cell, ue)
8005 RgSchCellCb  *cell;
8006 RgSchUeCb    *ue;
8007 #endif
8008 {
8009    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8010    TRC2(rgSCHCmnActvtDlUe);
8011
8012    cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
8013    RETVOID;
8014 }
8015
8016 /**
8017  * @brief This API is invoked to indicate scheduler of a CRC indication.
8018  *
8019  * @details
8020  *
8021  *     Function : rgSCHCmnHdlUlTransInd
8022  *      This API is invoked to indicate scheduler of a CRC indication.
8023  *
8024  *  @param[in]  RgSchCellCb     *cell
8025  *  @param[in]  RgSchUeCb       *ue
8026  *  @param[in]  CmLteTimingInfo timingInfo
8027  *
8028  *  @return Void
8029  **/
8030 #ifdef ANSI
8031 PUBLIC Void rgSCHCmnHdlUlTransInd
8032 (
8033 RgSchCellCb     *cell,
8034 RgSchUeCb       *ue,
8035 CmLteTimingInfo timingInfo
8036 )
8037 #else
8038 PUBLIC Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
8039 RgSchCellCb     *cell;
8040 RgSchUeCb       *ue;
8041 CmLteTimingInfo timingInfo;
8042 #endif
8043 {
8044    TRC2(rgSCHCmnHdlUlTransInd);
8045
8046    /* Update the latest UL dat/sig transmission time */
8047    RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
8048    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
8049    {
8050       /* Some UL Transmission from this UE.
8051        * Activate this UE if it was inactive */
8052       RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
8053       RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
8054    }
8055    RETVOID;
8056 }
8057
8058 #ifdef TFU_UPGRADE
8059
8060 /**
8061  * @brief Compute the minimum Rank based on Codebook subset
8062  *        restriction configuration for 4 Tx Ports and Tx Mode 4.
8063  *
8064  * @details
8065  *
8066  *     Function : rgSCHCmnComp4TxMode4
8067  *
8068  *     Depending on BitMap set at CBSR during Configuration
8069  *      - return the least possible Rank
8070  *
8071  *
8072  *  @param[in]  U32 *pmiBitMap
8073  *  @return  RgSchCmnRank
8074  **/
8075 #ifdef ANSI
8076 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4
8077 (
8078  U32    *pmiBitMap
8079  )
8080 #else
8081 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
8082    U32  *pmiBitMap;
8083 #endif
8084 {
8085    U32 bitMap0, bitMap1;
8086    TRC2(rgSCHCmnComp4TxMode4);
8087    bitMap0 = pmiBitMap[0];
8088    bitMap1 = pmiBitMap[1];
8089    if((bitMap1) & 0xFFFF)
8090    {
8091       RETVALUE (RG_SCH_CMN_RANK_1);
8092    }
8093    else if((bitMap1>>16) & 0xFFFF)
8094    {
8095       RETVALUE (RG_SCH_CMN_RANK_2);
8096    }
8097    else if((bitMap0) & 0xFFFF)
8098    {
8099       RETVALUE (RG_SCH_CMN_RANK_3);
8100    }
8101    else if((bitMap0>>16) & 0xFFFF)
8102    {
8103       RETVALUE (RG_SCH_CMN_RANK_4);
8104    }
8105    else
8106    {
8107       RETVALUE (RG_SCH_CMN_RANK_1);
8108    }
8109 }
8110
8111
8112 /**
8113  * @brief Compute the minimum Rank based on Codebook subset
8114  *        restriction configuration for 2 Tx Ports and Tx Mode 4.
8115  *
8116  * @details
8117  *
8118  *     Function : rgSCHCmnComp2TxMode4
8119  *
8120  *     Depending on BitMap set at CBSR during Configuration
8121  *      - return the least possible Rank
8122  *
8123  *
8124  *  @param[in]  U32 *pmiBitMap
8125  *  @return  RgSchCmnRank
8126  **/
8127 #ifdef ANSI
8128 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4
8129 (
8130  U32    *pmiBitMap
8131  )
8132 #else
8133 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
8134    U32  *pmiBitMap;
8135 #endif
8136 {
8137    U32 bitMap0;
8138    TRC2(rgSCHCmnComp2TxMode4);
8139    bitMap0 = pmiBitMap[0];
8140    if((bitMap0>>26)& 0x0F)
8141    {
8142       RETVALUE (RG_SCH_CMN_RANK_1);
8143    }
8144    else if((bitMap0>>30) & 3)
8145    {
8146       RETVALUE (RG_SCH_CMN_RANK_2);
8147    }
8148    else
8149    {
8150       RETVALUE (RG_SCH_CMN_RANK_1);
8151    }
8152 }
8153
8154 /**
8155  * @brief Compute the minimum Rank based on Codebook subset
8156  *        restriction configuration for 4 Tx Ports and Tx Mode 3.
8157  *
8158  * @details
8159  *
8160  *     Function : rgSCHCmnComp4TxMode3
8161  *
8162  *     Depending on BitMap set at CBSR during Configuration
8163  *      - return the least possible Rank
8164  *
8165  *
8166  *  @param[in]  U32 *pmiBitMap
8167  *  @return  RgSchCmnRank
8168  **/
8169 #ifdef ANSI
8170 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3
8171 (
8172  U32    *pmiBitMap
8173  )
8174 #else
8175 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
8176    U32  *pmiBitMap;
8177 #endif
8178 {
8179    U32 bitMap0;
8180    TRC2(rgSCHCmnComp4TxMode3);
8181    bitMap0 = pmiBitMap[0];
8182    if((bitMap0>>28)& 1)
8183    {
8184       RETVALUE (RG_SCH_CMN_RANK_1);
8185    }
8186    else if((bitMap0>>29) &1)
8187    {
8188       RETVALUE (RG_SCH_CMN_RANK_2);
8189    }
8190    else if((bitMap0>>30) &1)
8191    {
8192       RETVALUE (RG_SCH_CMN_RANK_3);
8193    }
8194    else if((bitMap0>>31) &1)
8195    {
8196       RETVALUE (RG_SCH_CMN_RANK_4);
8197    }
8198    else
8199    {
8200       RETVALUE (RG_SCH_CMN_RANK_1);
8201    }
8202 }
8203
8204 /**
8205  * @brief Compute the minimum Rank based on Codebook subset
8206  *        restriction configuration for 2 Tx Ports and Tx Mode 3.
8207  *
8208  * @details
8209  *
8210  *     Function : rgSCHCmnComp2TxMode3
8211  *
8212  *     Depending on BitMap set at CBSR during Configuration
8213  *      - return the least possible Rank
8214  *
8215  *
8216  *  @param[in]  U32 *pmiBitMap
8217  *  @return  RgSchCmnRank
8218  **/
8219 #ifdef ANSI
8220 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3
8221 (
8222  U32 *pmiBitMap
8223  )
8224 #else
8225 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
8226    U32 *pmiBitMap;
8227 #endif
8228 {
8229    U32 bitMap0;
8230    TRC2(rgSCHCmnComp2TxMode3);
8231    bitMap0 = pmiBitMap[0];
8232    if((bitMap0>>30)& 1)
8233    {
8234       RETVALUE (RG_SCH_CMN_RANK_1);
8235    }
8236    else if((bitMap0>>31) &1)
8237    {
8238       RETVALUE (RG_SCH_CMN_RANK_2);
8239    }
8240    else
8241    {
8242       RETVALUE (RG_SCH_CMN_RANK_1);
8243    }
8244 }
8245
8246 /**
8247  * @brief Compute the minimum Rank based on Codebook subset
8248  *        restriction configuration.
8249  *
8250  * @details
8251  *
8252  *     Function : rgSCHCmnComputeRank
8253  *
8254  *     Depending on Num Tx Ports and Transmission mode
8255  *      - return the least possible Rank
8256  *
8257  *
8258  *  @param[in]  RgrTxMode txMode
8259  *  @param[in]  U32 *pmiBitMap
8260  *  @param[in]  U8 numTxPorts
8261  *  @return  RgSchCmnRank
8262  **/
8263 #ifdef ANSI
8264 PRIVATE RgSchCmnRank rgSCHCmnComputeRank
8265 (
8266  RgrTxMode    txMode,
8267  U32          *pmiBitMap,
8268  U8           numTxPorts
8269  )
8270 #else
8271 PRIVATE RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
8272    RgrTxMode    txMode;
8273    U32          *pmiBitMap;
8274    U8           numTxPorts;
8275 #endif
8276 {
8277    TRC2(rgSCHCmnComputeRank);
8278
8279    if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
8280    {
8281       RETVALUE (rgSCHCmnComp2TxMode3(pmiBitMap));
8282    }
8283    else if (numTxPorts ==4 && txMode == RGR_UE_TM_3)
8284    {
8285       RETVALUE (rgSCHCmnComp4TxMode3(pmiBitMap));
8286    }
8287    else if (numTxPorts ==2 && txMode == RGR_UE_TM_4)
8288    {
8289       RETVALUE (rgSCHCmnComp2TxMode4(pmiBitMap));
8290    }
8291    else if (numTxPorts ==4 && txMode == RGR_UE_TM_4)
8292    {
8293       RETVALUE (rgSCHCmnComp4TxMode4(pmiBitMap));
8294    }
8295    else
8296    {
8297       RETVALUE (RG_SCH_CMN_RANK_1);
8298    }
8299 }
8300
8301 #endif
8302
8303 /**
8304  * @brief Harq Entity Deinitialization for CMN SCH.
8305  *
8306  * @details
8307  *
8308  *     Function : rgSCHCmnDlDeInitHqEnt 
8309  *
8310  *     Harq Entity Deinitialization for CMN SCH 
8311  *
8312  *  @param[in]  RgSchCellCb  *cell
8313  *  @param[in]  RgSchDlHqEnt *hqE 
8314  *  @return  VOID
8315  **/
8316 /*KWORK_FIX:Changed function return type to void */
8317 #ifdef ANSI
8318 PUBLIC Void rgSCHCmnDlDeInitHqEnt 
8319 (
8320 RgSchCellCb  *cell,
8321 RgSchDlHqEnt *hqE
8322 )
8323 #else
8324 PUBLIC Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
8325 RgSchCellCb  *cell;
8326 RgSchDlHqEnt *hqE;
8327 #endif
8328 {
8329    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8330    RgSchDlHqProcCb      *hqP;
8331    U8                   cnt;
8332    S16                  ret;
8333
8334    TRC2(rgSCHCmnDlDeInitHqEnt);
8335
8336    ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
8337    /* Free only If the Harq proc are created*/
8338    if(RFAILED == ret)
8339    {
8340    }
8341
8342    for(cnt = 0; cnt < hqE->numHqPrcs; cnt++)
8343    {
8344       hqP = &hqE->procs[cnt];
8345       if ((RG_SCH_CMN_GET_DL_HQP(hqP)))
8346       {
8347          rgSCHUtlFreeSBuf(cell->instIdx,
8348               (Data**)(&(hqP->sch)), (sizeof(RgSchCmnDlHqProc)));
8349       }
8350    }
8351 #ifdef LTE_ADV
8352    rgSCHLaaDeInitDlHqProcCb (cell, hqE);
8353 #endif
8354
8355    RETVOID;
8356 }
8357
8358 /**
8359  * @brief Harq Entity initialization for CMN SCH.
8360  *
8361  * @details
8362  *
8363  *     Function : rgSCHCmnDlInitHqEnt 
8364  *
8365  *     Harq Entity initialization for CMN SCH 
8366  *
8367  *  @param[in]  RgSchCellCb  *cell
8368  *  @param[in]  RgSchUeCb    *ue
8369  *  @return  S16
8370  *      -# ROK
8371  *      -# RFAILED
8372  **/
8373 #ifdef ANSI
8374 PUBLIC S16 rgSCHCmnDlInitHqEnt 
8375 (
8376 RgSchCellCb  *cell,
8377 RgSchDlHqEnt  *hqEnt
8378 )
8379 #else
8380 PUBLIC S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
8381 RgSchCellCb  *cell;
8382 RgSchDlHqEnt  *hqEnt;
8383 #endif
8384
8385 {
8386    RgSchDlHqProcCb      *hqP;
8387    U8                   cnt;
8388
8389    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8390    TRC2(rgSCHCmnDlInitHqEnt);
8391
8392    for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
8393    {
8394       hqP = &hqEnt->procs[cnt];
8395       if (rgSCHUtlAllocSBuf(cell->instIdx,
8396                (Data**)&(hqP->sch), (sizeof(RgSchCmnDlHqProc))) != ROK)
8397       {
8398          RETVALUE(RFAILED);
8399       }
8400    }
8401 #ifdef EMTC_ENABLE
8402    if((cell->emtcEnable) &&(hqEnt->ue->isEmtcUe))
8403    {
8404       if(ROK != cellSchd->apisEmtcDl->rgSCHDlUeHqEntInit(cell, hqEnt))
8405       {
8406          RETVALUE(RFAILED);
8407       }
8408
8409    }
8410    else
8411 #endif
8412    {
8413       if(ROK != cellSchd->apisDl->rgSCHDlUeHqEntInit(cell, hqEnt))
8414       {
8415          RETVALUE(RFAILED);
8416       }
8417    }
8418
8419    RETVALUE(ROK);
8420 }  /* rgSCHCmnDlInitHqEnt */
8421
8422 /**
8423  * @brief This function computes distribution of refresh period
8424  *
8425  * @details
8426  *
8427  *     Function: rgSCHCmnGetRefreshDist 
8428  *     Purpose: This function computes distribution of refresh period
8429  *              This is required to align set of UEs refresh
8430  *              around the different consecutive subframe.
8431  *               
8432  *     Invoked by: rgSCHCmnGetRefreshPerDist
8433  *
8434  *  @param[in]  RgSchCellCb        *cell
8435  *  @param[in]  RgSchUeCb          *ue
8436  *  @return  Void
8437  *
8438  **/
8439 #ifdef ANSI
8440 PRIVATE U8 rgSCHCmnGetRefreshDist 
8441 (
8442 RgSchCellCb        *cell,
8443 RgSchUeCb          *ue
8444 )
8445 #else
8446 PRIVATE U8 rgSCHCmnGetRefreshDist(cell, ue)
8447 RgSchCellCb        *cell;
8448 RgSchUeCb          *ue;
8449 #endif
8450 {
8451    U8   refOffst;
8452 #ifdef DEBUGP
8453    Inst inst = cell->instIdx;
8454 #endif
8455    TRC2(rgSCHCmnGetRefreshDist);
8456
8457    for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
8458    {
8459       if(cell->refreshUeCnt[refOffst] < RGSCH_MAX_REFRESH_GRPSZ)
8460       {
8461          cell->refreshUeCnt[refOffst]++;
8462          ue->refreshOffset = refOffst;
8463          /* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst,  cell->refreshUeCnt[refOffst]); */
8464          RETVALUE(refOffst);
8465       }
8466    }
8467   
8468    RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Allocation of refresh distribution failed\n"));
8469    /* We should not enter here  normally, but incase of failure, allocating from  last offset*/
8470    cell->refreshUeCnt[refOffst-1]++;
8471    ue->refreshOffset = refOffst-1;
8472
8473    RETVALUE(refOffst-1);
8474 }
8475 /**
8476  * @brief This function computes initial Refresh Wait Period.
8477  *
8478  * @details
8479  *
8480  *     Function: rgSCHCmnGetRefreshPer 
8481  *     Purpose: This function computes initial Refresh Wait Period.
8482  *              This is required to align multiple UEs refresh
8483  *              around the same time.
8484  *               
8485  *     Invoked by: rgSCHCmnGetRefreshPer 
8486  *
8487  *  @param[in]  RgSchCellCb        *cell
8488  *  @param[in]  RgSchUeCb          *ue
8489  *  @param[in]  U32                *waitPer 
8490  *  @return  Void
8491  *
8492  **/
8493 #ifdef ANSI
8494 PRIVATE Void rgSCHCmnGetRefreshPer 
8495 (
8496 RgSchCellCb        *cell,
8497 RgSchUeCb          *ue,
8498 U32                *waitPer
8499 )
8500 #else
8501 PRIVATE Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
8502 RgSchCellCb        *cell;
8503 RgSchUeCb          *ue;
8504 U32                *waitPer;
8505 #endif
8506 {
8507    U32       refreshPer;           
8508    U32       crntSubFrm;
8509
8510    TRC2(rgSCHCmnGetRefreshPer);     
8511
8512    refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
8513    crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.subframe;
8514    /* Fix: syed align multiple UEs to refresh at same time */
8515    *waitPer = refreshPer - (crntSubFrm % refreshPer);
8516    *waitPer = RGSCH_CEIL(*waitPer, RG_SCH_CMN_REFRESH_TIMERES);
8517    *waitPer = *waitPer + rgSCHCmnGetRefreshDist(cell, ue);
8518
8519    RETVOID;
8520 }
8521
8522
8523 #ifdef LTE_ADV
8524 /**
8525  * @brief UE initialisation for scheduler.
8526  *
8527  * @details
8528  *
8529  *     Function : rgSCHCmnRgrSCellUeCfg
8530  *
8531  *     This functions intialises UE specific scheduler 
8532  *     information for SCELL
8533  *     0. Perform basic validations
8534  *     1. Allocate common sched UE cntrl blk
8535  *     2. Perform DL cfg (allocate Hq Procs Cmn sched cntrl blks)
8536  *     3. Perform UL cfg
8537  *     4. Perform DLFS cfg
8538  *
8539  *  @param[in]  RgSchCellCb  *cell
8540  *  @param[in]  RgSchUeCb    *ue
8541  *  @param[out] RgSchErrInfo *err
8542  *  @return  S16
8543  *      -# ROK
8544  *      -# RFAILED
8545  **/
8546 #ifdef ANSI
8547 PUBLIC S16 rgSCHCmnRgrSCellUeCfg
8548 (
8549 RgSchCellCb  *sCell,
8550 RgSchUeCb    *ue,
8551 RgrUeSecCellCfg  *sCellInfoCfg,
8552 RgSchErrInfo *err
8553 )
8554 #else
8555 PUBLIC S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
8556 RgSchCellCb  *sCell;
8557 RgSchUeCb    *ue;
8558 RgrUeSecCellCfg  *sCellInfoCfg;
8559 RgSchErrInfo *err;
8560 #endif
8561 {
8562    U8 i;
8563    S16                  ret;
8564    U8                   cnt;
8565    RgSchCmnAllocRecord  *allRcd;
8566    RgSchDlRbAlloc       *allocInfo;
8567    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
8568    RgSchCmnUlUe         *ueUl;
8569    RgSchCmnUlUe         *ueUlPcell;
8570    RgSchCmnUe           *pCellUeSchCmn;
8571    RgSchCmnUe           *ueSchCmn;
8572    RgSchCmnDlUe         *ueDl;
8573    RgSchCmnDlUe         *pCellUeDl;
8574 #ifdef DEBUGP
8575    Inst                 inst = ue->cell->instIdx;
8576 #endif
8577    U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
8578    TRC2(rgSCHCmnRgrSCellUeCfg);
8579
8580    pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
8581    pCellUeDl = &pCellUeSchCmn->dl;
8582
8583    /* 1. Allocate Common sched control block */
8584    if((rgSCHUtlAllocSBuf(sCell->instIdx,
8585                (Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
8586    {
8587       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
8588       err->errCause = RGSCHERR_SCH_CFG;
8589       RETVALUE(RFAILED);
8590    }
8591    ueSchCmn = RG_SCH_CMN_GET_UE(ue,sCell);
8592
8593    /*2.  Perform UEs downlink configuration */
8594    ueDl = &ueSchCmn->dl;
8595
8596    /*CA TODO*/
8597    ueDl->mimoInfo = pCellUeDl->mimoInfo;
8598
8599    if ((ue->mimoInfo.txMode == RGR_UE_TM_4) ||
8600          (ue->mimoInfo.txMode == RGR_UE_TM_6))
8601    {
8602       RG_SCH_CMN_SET_FORCE_TD(ue, sCell, RG_SCH_CMN_TD_NO_PMI);
8603    }
8604    if (ue->mimoInfo.txMode == RGR_UE_TM_3)
8605    {
8606       RG_SCH_CMN_SET_FORCE_TD(ue, sCell, RG_SCH_CMN_TD_RI_1);
8607    }
8608    RGSCH_ARRAY_BOUND_CHECK(sCell->instIdx, rgUeCatTbl, pCellUeSchCmn->cmn.ueCat);
8609    ueDl->maxTbBits = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlTbBits;
8610    /*CA dev-Start*/
8611    U8 ri = 0;
8612    ri = RGSCH_MIN(ri, sCell->numTxAntPorts);
8613    if(((CM_LTE_UE_CAT_6 == pCellUeSchCmn->cmn.ueCat )
8614             ||(CM_LTE_UE_CAT_7 == pCellUeSchCmn->cmn.ueCat)) 
8615          && (4 == ri))
8616    {
8617       ueDl->maxTbSz = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlBits[1];
8618    }
8619    else
8620    {
8621       ueDl->maxTbSz = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlBits[0];
8622    }
8623    /*CA dev-End*/
8624    /* Fix : syed Assign hqEnt to UE only if msg4 is done */
8625 #ifdef LTE_TDD
8626    ueDl->maxSbSz = (rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxSftChBits/
8627          rgSchTddDlNumHarqProcTbl[sCell->ulDlCfgIdx]);
8628 #else
8629    ueDl->maxSbSz = (rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxSftChBits/
8630          RGSCH_NUM_DL_HQ_PROC);
8631 #endif
8632 #ifdef EMTC_ENABLE   
8633    rgSCHCmnDlSetUeAllocLmt(sCell, ueDl, ue->isEmtcUe);
8634 #else
8635    rgSCHCmnDlSetUeAllocLmt(sCell, ueDl, FALSE);
8636 #endif      
8637
8638    /* DL ambr */
8639    /* ambrCfgd config moved to ueCb.dl, as it's not needed for per cell wise*/
8640
8641    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, sCell);
8642    allocInfo->rnti = ue->ueId;
8643
8644    /* Initializing the lastCfi value to current cfi value */
8645    ueDl->lastCfi = cellSchd->dl.currCfi;
8646
8647    if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
8648    {
8649       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
8650       RETVALUE(RFAILED);
8651    }
8652
8653    /* TODO: enhance for DLFS RB Allocation for SCELLs in future dev */
8654
8655    /* DLFS UE Config */
8656    if (cellSchd->dl.isDlFreqSel)
8657    {
8658       if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
8659       {
8660          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
8661          RETVALUE(RFAILED);
8662       }
8663    }
8664
8665    /* TODO: Do UL SCELL CFG during UL CA dev */
8666    {
8667       ueUl = RG_SCH_CMN_GET_UL_UE(ue, sCell);
8668
8669       /* TODO_ULCA: SRS for SCELL needs to be handled in the below function call */
8670       rgSCHCmnUpdUeUlCqiInfo(sCell, ue, ueUl, ueSchCmn, cellSchd,
8671             sCell->isCpUlExtend);
8672
8673       ret = rgSCHUhmHqEntInit(sCell, ue);
8674       if (ret != ROK)
8675       {
8676          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
8677                "Failed for CRNTI:%d", ue->ueId);
8678          RETVALUE(RFAILED);
8679       }
8680
8681       ueUlPcell = RG_SCH_CMN_GET_UL_UE(ue, ue->cell);
8682       /* Initialize uplink HARQ related information for UE */
8683       ueUl->hqEnt.maxHqRetx = ueUlPcell->hqEnt.maxHqRetx;
8684       cmLListInit(&ueUl->hqEnt.free);
8685       cmLListInit(&ueUl->hqEnt.inUse);
8686       for(i=0; i < ueUl->hqEnt.numHqPrcs; i++)
8687       {
8688          ueUl->hqEnt.hqProcCb[i].hqEnt = (void*)(&ueUl->hqEnt);
8689          ueUl->hqEnt.hqProcCb[i].procId = i;
8690          ueUl->hqEnt.hqProcCb[i].ulSfIdx = RGSCH_INVALID_INFO;
8691          ueUl->hqEnt.hqProcCb[i].alloc = NULLP;
8692 #ifdef LTEMAC_SPS
8693          /* ccpu00139513- Initializing SPS flags*/
8694          ueUl->hqEnt.hqProcCb[i].isSpsActvnHqP = FALSE;
8695          ueUl->hqEnt.hqProcCb[i].isSpsOccnHqP = FALSE;
8696 #endif
8697          cmLListAdd2Tail(&ueUl->hqEnt.free, &ueUl->hqEnt.hqProcCb[i].lnk);
8698          ueUl->hqEnt.hqProcCb[i].lnk.node = (PTR)&ueUl->hqEnt.hqProcCb[i];
8699       }
8700
8701       /* Allocate UL BSR allocation tracking List */
8702       cmLListInit(&ueUl->ulAllocLst);
8703
8704       for (cnt = 0; cnt < RG_SCH_CMN_MAX_ALLOC_TRACK; cnt++)
8705       {
8706          if((rgSCHUtlAllocSBuf(sCell->instIdx,
8707                      (Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
8708          {
8709             RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
8710                   "for CRNTI:%d",ue->ueId);
8711             err->errCause = RGSCHERR_SCH_CFG;
8712             RETVALUE(RFAILED);
8713          }
8714          allRcd->allocTime = sCell->crntTime;
8715          cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
8716          allRcd->lnk.node = (PTR)allRcd;
8717       }
8718
8719       /* After initialising UL part, do power related init */
8720       ret = rgSCHPwrUeSCellCfg(sCell, ue, sCellInfoCfg);
8721       if (ret != ROK)
8722       {
8723          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
8724                "power config for UE CRNTI:%d",ue->ueId);
8725          RETVALUE(RFAILED);
8726       }
8727
8728 #ifdef EMTC_ENABLE   
8729       if(TRUE == ue->isEmtcUe)
8730       {
8731          if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
8732          {
8733             RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
8734                   "for CRNTI:%d",ue->ueId);
8735             RETVALUE(RFAILED);
8736          }
8737       }
8738       else
8739 #endif
8740       {
8741       if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
8742       {
8743          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
8744                "for CRNTI:%d",ue->ueId);
8745          RETVALUE(RFAILED);
8746       }
8747       }
8748    
8749       ue->ul.isUlCaEnabled = TRUE;
8750    }
8751
8752    RETVALUE(ROK);
8753 }  /* rgSCHCmnRgrSCellUeCfg */
8754
8755
8756 /**
8757  * @brief UE initialisation for scheduler.
8758  *
8759  * @details
8760  *
8761  *     Function : rgSCHCmnRgrSCellUeDel 
8762  *
8763  *     This functions Delete UE specific scheduler 
8764  *     information for SCELL
8765  *
8766  *  @param[in]  RgSchCellCb  *cell
8767  *  @param[in]  RgSchUeCb    *ue
8768  *  @return  S16
8769  *      -# ROK
8770  *      -# RFAILED
8771  **/
8772 #ifdef ANSI
8773 PUBLIC S16 rgSCHCmnRgrSCellUeDel
8774 (
8775 RgSchUeCellInfo *sCellInfo,
8776 RgSchUeCb    *ue
8777 )
8778 #else
8779 PUBLIC S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
8780 RgSchUeCellInfo *sCellInfo;
8781 RgSchUeCb    *ue;
8782 #endif
8783 {
8784    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
8785    Inst                 inst = ue->cell->instIdx;
8786
8787    TRC2(rgSCHCmnRgrSCellUeDel);
8788
8789    cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
8790
8791    /* UL CA */
8792    rgSCHCmnUlUeDelAllocs(sCellInfo->cell, ue);
8793
8794 #ifdef EMTC_ENABLE   
8795    if(TRUE == ue->isEmtcUe)
8796    {
8797       cellSchd->apisEmtcUl->rgSCHFreeUlUe(sCellInfo->cell, ue);
8798    }
8799    else
8800 #endif
8801    {
8802    cellSchd->apisUl->rgSCHFreeUlUe(sCellInfo->cell, ue);
8803    }
8804
8805    /* DLFS UE Config */
8806    if (cellSchd->dl.isDlFreqSel)
8807    {
8808       if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
8809       {
8810          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
8811          RETVALUE(RFAILED);
8812       }
8813    }
8814
8815    rgSCHUtlFreeSBuf(sCellInfo->cell->instIdx,
8816          (Data**)(&(sCellInfo->sch)), (sizeof(RgSchCmnUe)));
8817
8818
8819    RETVALUE(ROK);
8820 }  /* rgSCHCmnRgrSCellUeDel */
8821  
8822 #endif
8823
8824 #ifdef RG_5GTF
8825 /**
8826  * @brief Handles 5gtf configuration for a UE
8827  *
8828  * @details
8829  *
8830  *     Function : rgSCHCmn5gtfUeCfg
8831  *
8832  *     Processing Steps:
8833  *
8834  *      - Return ROK
8835  *
8836  *  @param[in]  RgSchCellCb  *cell
8837  *  @param[in]  RgSchUeCb    *ue
8838  *  @param[in]  RgrUeCfg     *cfg
8839  *  @return  S16
8840  *      -# ROK
8841  *      -# RFAILED
8842  **/
8843 #ifdef ANSI
8844 PUBLIC S16 rgSCHCmn5gtfUeCfg
8845 (
8846 RgSchCellCb *cell,
8847 RgSchUeCb   *ue,
8848 RgrUeCfg    *cfg
8849 )
8850 #else
8851 PUBLIC S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
8852 RgSchCellCb *cell;
8853 RgSchUeCb   *ue;
8854 RgrUeCfg    *cfg;
8855 #endif
8856 {
8857    TRC2(rgSCHCmnRgrUeCfg);
8858
8859    RgSchUeGrp *ue5gtfGrp;
8860    ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
8861    ue->ue5gtfCb.BeamId = cfg->ue5gtfCfg.BeamId;
8862    ue->ue5gtfCb.numCC = cfg->ue5gtfCfg.numCC;   
8863    ue->ue5gtfCb.mcs = cfg->ue5gtfCfg.mcs;
8864    ue->ue5gtfCb.maxPrb = cfg->ue5gtfCfg.maxPrb;
8865
8866    ue->ue5gtfCb.cqiRiPer = 100;
8867    /* 5gtf TODO: CQIs to start from (10,0)*/
8868    ue->ue5gtfCb.nxtCqiRiOccn.sfn = 10;
8869    ue->ue5gtfCb.nxtCqiRiOccn.subframe = 0;
8870    ue->ue5gtfCb.rank = 1;
8871
8872    printf("\nschd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
8873          ue->ue5gtfCb.mcs,ue->ue5gtfCb.maxPrb); 
8874
8875    ue5gtfGrp = &(cell->cell5gtfCb.ueGrp5gConf[ue->ue5gtfCb.BeamId]);
8876
8877    /* TODO_5GTF: Currently handling 1 group only. Need to update when multi group 
8878       scheduling comes into picture */
8879    if(ue5gtfGrp->beamBitMask & (1 << ue->ue5gtfCb.BeamId))
8880    {
8881       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
8882             "5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
8883       RETVALUE(RFAILED);
8884    }
8885    ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
8886
8887    RETVALUE(ROK);
8888 }
8889 #endif
8890
8891 /**
8892  * @brief UE initialisation for scheduler.
8893  *
8894  * @details
8895  *
8896  *     Function : rgSCHCmnRgrUeCfg
8897  *
8898  *     This functions intialises UE specific scheduler
8899  *     information
8900  *     0. Perform basic validations
8901  *     1. Allocate common sched UE cntrl blk
8902  *     2. Perform DL cfg (allocate Hq Procs Cmn sched cntrl blks)
8903  *     3. Perform UL cfg
8904  *     4. Perform DLFS cfg
8905  *
8906  *  @param[in]  RgSchCellCb  *cell
8907  *  @param[in]  RgSchUeCb    *ue
8908  *  @param[int] RgrUeCfg     *ueCfg
8909  *  @param[out] RgSchErrInfo *err
8910  *  @return  S16
8911  *      -# ROK
8912  *      -# RFAILED
8913  **/
8914 #ifdef ANSI
8915 PUBLIC S16 rgSCHCmnRgrUeCfg
8916 (
8917 RgSchCellCb  *cell,
8918 RgSchUeCb    *ue,
8919 RgrUeCfg     *ueCfg,
8920 RgSchErrInfo *err
8921 )
8922 #else
8923 PUBLIC S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
8924 RgSchCellCb  *cell;
8925 RgSchUeCb    *ue;
8926 RgrUeCfg     *ueCfg;
8927 RgSchErrInfo *err;
8928 #endif
8929 {
8930    RgSchDlRbAlloc  *allocInfo;
8931    S16                  ret;
8932    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8933    RgSchCmnUe           *ueSchCmn;
8934    RgSchCmnUlUe         *ueUl;
8935    RgSchCmnDlUe         *ueDl;
8936    U8                   cnt;
8937    RgSchCmnAllocRecord  *allRcd;
8938    U32                  waitPer;
8939    U32                  idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
8940    RgSchUeCellInfo      *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
8941    TRC2(rgSCHCmnRgrUeCfg);
8942
8943
8944    /* 1. Allocate Common sched control block */
8945    if((rgSCHUtlAllocSBuf(cell->instIdx,
8946                (Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
8947    {
8948       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
8949             "Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
8950       err->errCause = RGSCHERR_SCH_CFG;
8951       RETVALUE(RFAILED);
8952    }
8953    ueSchCmn   = RG_SCH_CMN_GET_UE(ue,cell);
8954    ue->dl.ueDlCqiCfg = ueCfg->ueDlCqiCfg;
8955    pCellInfo->acqiCb.aCqiCfg = ueCfg->ueDlCqiCfg.aprdCqiCfg;
8956    if(ueCfg->ueCatEnum > 0 )
8957    {
8958      /*KWORK_FIX removed NULL chk for ueSchCmn*/
8959       ueSchCmn->cmn.ueCat = ueCfg->ueCatEnum - 1; 
8960    }
8961    else
8962    {
8963       ueSchCmn->cmn.ueCat = 0; /* Assuming enum values correctly set */
8964    }
8965    cmInitTimers(&ueSchCmn->cmn.tmr, 1);
8966
8967    /*2.  Perform UEs downlink configuration */
8968    ueDl = &ueSchCmn->dl;
8969    /* RACHO : store the rapId assigned for HandOver UE.
8970     * Append UE to handover list of cmnCell */
8971    if (ueCfg->dedPreambleId.pres == PRSNT_NODEF)
8972    {
8973       rgSCHCmnDelDedPreamble(cell, ueCfg->dedPreambleId.val);
8974       ueDl->rachInfo.hoRapId = ueCfg->dedPreambleId.val;
8975       cmLListAdd2Tail(&cellSchd->rachCfg.hoUeLst, &ueDl->rachInfo.hoLnk);
8976       ueDl->rachInfo.hoLnk.node = (PTR)ue;
8977    }
8978
8979    rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd);
8980
8981    if (ueCfg->txMode.pres == TRUE)
8982    {
8983       if ((ueCfg->txMode.txModeEnum == RGR_UE_TM_4) ||
8984             (ueCfg->txMode.txModeEnum == RGR_UE_TM_6))
8985       {
8986          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
8987       }
8988       if (ueCfg->txMode.txModeEnum == RGR_UE_TM_3)
8989       {
8990          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
8991       }
8992    }
8993    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
8994    ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
8995    /*CA dev-Start*/
8996    U8 ri = 0;
8997    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
8998    if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
8999             ||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat)) 
9000                   && (4 == ri))
9001    {
9002       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[1];
9003    }
9004    else
9005    {
9006       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[0];
9007    }
9008    /*CA dev-End*/
9009    /* Fix : syed Assign hqEnt to UE only if msg4 is done */
9010 #ifdef LTE_TDD
9011    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9012          rgSchTddDlNumHarqProcTbl[cell->ulDlCfgIdx]);
9013 #else
9014    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9015          RGSCH_NUM_DL_HQ_PROC);
9016 #endif
9017 #ifdef EMTC_ENABLE   
9018    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, ue->isEmtcUe);
9019 #else
9020    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, FALSE);
9021 #endif 
9022      /* if none of the DL and UL AMBR are configured then fail the configuration
9023     */     
9024    if((ueCfg->ueQosCfg.dlAmbr == 0) && (ueCfg->ueQosCfg.ueBr == 0))
9025    {
9026       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
9027          "configured as 0 for CRNTI:%d",ueCfg->crnti);
9028       err->errCause = RGSCHERR_SCH_CFG;
9029       RETVALUE(RFAILED);
9030    }
9031    /* DL ambr */
9032    ue->dl.ambrCfgd = (ueCfg->ueQosCfg.dlAmbr * RG_SCH_CMN_REFRESH_TIME)/100;
9033
9034    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
9035    allocInfo->rnti = ue->ueId;
9036
9037    /* Initializing the lastCfi value to current cfi value */
9038    ueDl->lastCfi = cellSchd->dl.currCfi;
9039 #ifdef EMTC_ENABLE
9040    if(cell->emtcEnable && ue->isEmtcUe)
9041    {
9042       if ((cellSchd->apisEmtcDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
9043       {
9044          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9045                "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
9046          RETVALUE(RFAILED);
9047       }
9048
9049    }
9050    else
9051 #endif
9052    {
9053       if ((cellSchd->apisDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
9054       {
9055          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9056                "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
9057          RETVALUE(RFAILED);
9058       }
9059    }
9060
9061
9062
9063    /* 3. Initialize ul part */
9064    ueUl     = &ueSchCmn->ul;
9065
9066    rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
9067             cell->isCpUlExtend);
9068
9069    ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
9070                                RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
9071
9072    ue->ul.cfgdAmbr = (ueCfg->ueQosCfg.ueBr * RG_SCH_CMN_REFRESH_TIME)/100;
9073    ue->ul.effAmbr = ue->ul.cfgdAmbr;
9074    RGSCHCPYTIMEINFO(cell->crntTime, ue->ul.ulTransTime);
9075
9076    /* Allocate UL BSR allocation tracking List */
9077    cmLListInit(&ueUl->ulAllocLst);
9078
9079    for (cnt = 0; cnt < RG_SCH_CMN_MAX_ALLOC_TRACK; cnt++)
9080    {
9081       if((rgSCHUtlAllocSBuf(cell->instIdx,
9082                   (Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
9083       {
9084          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
9085                    "for CRNTI:%d",ueCfg->crnti);
9086          err->errCause = RGSCHERR_SCH_CFG;
9087          RETVALUE(RFAILED);
9088       }
9089       allRcd->allocTime = cell->crntTime;
9090       cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
9091       allRcd->lnk.node = (PTR)allRcd;
9092    }
9093    /* Allocate common sch cntrl blocks for LCGs */
9094    for (cnt=0; cnt<RGSCH_MAX_LCG_PER_UE; cnt++)
9095    {
9096       ret = rgSCHUtlAllocSBuf(cell->instIdx,
9097             (Data**)&(ue->ul.lcgArr[cnt].sch), (sizeof(RgSchCmnLcg)));
9098       if (ret != ROK)
9099       {
9100          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9101             "SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
9102          err->errCause = RGSCHERR_SCH_CFG;
9103          RETVALUE(ret);
9104       }
9105    }
9106    /* After initialising UL part, do power related init */
9107    ret = rgSCHPwrUeCfg(cell, ue, ueCfg);
9108    if (ret != ROK)
9109    {
9110       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
9111          "power config for UE CRNTI:%d",ueCfg->crnti);
9112       RETVALUE(RFAILED);
9113    }
9114 #ifdef LTEMAC_SPS
9115    ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
9116    if (ret != ROK)
9117    {
9118       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
9119          "SPS config for CRNTI:%d",ueCfg->crnti);
9120       RETVALUE(RFAILED);
9121    }
9122 #endif /* LTEMAC_SPS */
9123
9124 #ifdef EMTC_ENABLE   
9125    if(TRUE == ue->isEmtcUe)
9126    {
9127       if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
9128       {
9129          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
9130                   "for CRNTI:%d",ueCfg->crnti);
9131          RETVALUE(RFAILED);
9132       }
9133    }
9134    else
9135 #endif
9136    {
9137    if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
9138    {
9139       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
9140                "for CRNTI:%d",ueCfg->crnti);
9141       RETVALUE(RFAILED);
9142    }
9143    }
9144
9145    /* DLFS UE Config */
9146    if (cellSchd->dl.isDlFreqSel)
9147    {
9148       if ((cellSchd->apisDlfs->rgSCHDlfsUeCfg(cell, ue, ueCfg, err)) != ROK)
9149       {
9150          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
9151                    "for CRNTI:%d",ueCfg->crnti);
9152          RETVALUE(RFAILED);
9153       }
9154    }
9155
9156    /* Fix: syed align multiple UEs to refresh at same time */
9157    rgSCHCmnGetRefreshPer(cell, ue, &waitPer);
9158    /* Start UE Qos Refresh Timer */
9159    rgSCHCmnAddUeToRefreshQ(cell, ue, waitPer);
9160 #ifdef RG_5GTF
9161    rgSCHCmn5gtfUeCfg(cell, ue, ueCfg);
9162 #endif
9163
9164    RETVALUE(ROK);
9165 }  /* rgSCHCmnRgrUeCfg */
9166
9167 /**
9168  * @brief UE TX mode reconfiguration handler.
9169  *
9170  * @details
9171  *
9172  *     Function : rgSCHCmnDlHdlTxModeRecfg
9173  *
9174  *     This functions updates UE specific scheduler
9175  *     information upon UE reconfiguration.
9176  *
9177  *  @param[in]  RgSchUeCb    *ue
9178  *  @param[in] RgrUeRecfg   *ueRecfg
9179  *  @return  Void
9180  **/
9181 #ifdef TFU_UPGRADE
9182 #ifdef ANSI
9183 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
9184 (
9185 RgSchCellCb *cell,
9186 RgSchUeCb    *ue,
9187 RgrUeRecfg   *ueRecfg,
9188 U8 numTxPorts
9189 )
9190 #else
9191 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
9192 RgSchCellCb *cell;
9193 RgSchUeCb    *ue;
9194 RgrUeRecfg   *ueRecfg;
9195 U8 numTxPorts;
9196 #endif
9197 #else
9198 #ifdef ANSI
9199 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
9200 (
9201 RgSchCellCb *cell,
9202 RgSchUeCb    *ue,
9203 RgrUeRecfg   *ueRecfg
9204 )
9205 #else
9206 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg)
9207 RgSchCellCb *cell;
9208 RgSchUeCb    *ue;
9209 RgrUeRecfg   *ueRecfg;
9210 #endif
9211 #endif
9212 {
9213    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
9214    TRC2(rgSCHCmnDlHdlTxModeRecfg);
9215
9216    if (ueRecfg->txMode.pres != PRSNT_NODEF)
9217    {
9218       RETVOID;
9219    }
9220    /* ccpu00140894- Starting Timer for TxMode Transition Completion*/
9221    ue->txModeTransCmplt =FALSE;
9222    rgSCHTmrStartTmr (ue->cell, ue, RG_SCH_TMR_TXMODE_TRNSTN, RG_SCH_TXMODE_TRANS_TIMER);
9223    if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_CMPLT)
9224    {
9225       RG_SCH_CMN_UNSET_FORCE_TD(ue, cell,
9226                                 RG_SCH_CMN_TD_TXMODE_RECFG);
9227      /* MS_WORKAROUND for ccpu00123186 MIMO Fix Start: need to set FORCE TD bitmap based on TX mode */
9228      ueDl->mimoInfo.ri = 1;
9229      if ((ueRecfg->txMode.txModeEnum == RGR_UE_TM_4) ||
9230           (ueRecfg->txMode.txModeEnum == RGR_UE_TM_6))
9231       {
9232          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
9233       }
9234       if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_3)
9235       {
9236          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9237       }
9238       /* MIMO Fix End: need to set FORCE TD bitmap based on TX mode */
9239       RETVOID;
9240    }
9241    if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_START)
9242    {
9243       /* start afresh forceTD masking */
9244       RG_SCH_CMN_INIT_FORCE_TD(ue, cell, 0);
9245       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_TXMODE_RECFG);
9246       /* Intialize MIMO related parameters of UE */
9247
9248 #ifdef TFU_UPGRADE
9249       if(ueRecfg->txMode.pres)
9250       {
9251          if((ueRecfg->txMode.txModeEnum ==RGR_UE_TM_3) ||
9252                (ueRecfg->txMode.txModeEnum ==RGR_UE_TM_4))
9253          {
9254             if(ueRecfg->ueCodeBookRstRecfg.pres)
9255             {
9256                ueDl->mimoInfo.ri =
9257                   rgSCHCmnComputeRank(ueRecfg->txMode.txModeEnum,
9258                     ueRecfg->ueCodeBookRstRecfg.pmiBitMap, numTxPorts);
9259             }
9260             else
9261             {
9262                ueDl->mimoInfo.ri = 1;
9263             }
9264          }
9265          else
9266          {
9267             ueDl->mimoInfo.ri = 1;
9268          }
9269       }
9270       else
9271       {
9272          ueDl->mimoInfo.ri = 1;
9273       }
9274 #else
9275       ueDl->mimoInfo.ri = 1;
9276 #endif /* TFU_UPGRADE */
9277       if ((ueRecfg->txMode.txModeEnum == RGR_UE_TM_4) ||
9278           (ueRecfg->txMode.txModeEnum == RGR_UE_TM_6))
9279       {
9280          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
9281       }
9282       if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_3)
9283       {
9284          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9285       }
9286       RETVOID;
9287    }
9288 }
9289 /***********************************************************
9290  *
9291  *     Func : rgSCHCmnUpdUeMimoInfo
9292  *
9293  *     Desc : Updates UL and DL Ue Information
9294  *
9295  *     Ret  :
9296  *
9297  *     Notes:
9298  *
9299  *     File :
9300  *
9301  **********************************************************/
9302 #ifdef ANSI
9303 PRIVATE Void rgSCHCmnUpdUeMimoInfo
9304 (
9305 RgrUeCfg     *ueCfg,
9306 RgSchCmnDlUe *ueDl,
9307 RgSchCellCb  *cell,
9308 RgSchCmnCell *cellSchd
9309 )
9310 #else
9311 PRIVATE Void rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd)
9312 RgrUeCfg     *ueCfg;
9313 RgSchCmnDlUe *ueDl;
9314 RgSchCellCb  *cell;
9315 RgSchCmnCell *cellSchd;
9316 #endif
9317 {
9318    TRC2(rgSCHCmnUpdUeMimoInfo)
9319 #ifdef TFU_UPGRADE
9320    if(ueCfg->txMode.pres)
9321    {
9322       if((ueCfg->txMode.txModeEnum ==RGR_UE_TM_3) ||
9323             (ueCfg->txMode.txModeEnum ==RGR_UE_TM_4))
9324       {
9325          if(ueCfg->ueCodeBookRstCfg.pres)
9326          {
9327             ueDl->mimoInfo.ri =
9328                rgSCHCmnComputeRank(ueCfg->txMode.txModeEnum,
9329                  ueCfg->ueCodeBookRstCfg.pmiBitMap, cell->numTxAntPorts);
9330          }
9331          else
9332          {
9333             ueDl->mimoInfo.ri = 1;
9334          }
9335       }
9336       else
9337       {
9338          ueDl->mimoInfo.ri = 1;
9339       }
9340    }
9341    else
9342    {
9343       ueDl->mimoInfo.ri = 1;
9344    }
9345
9346 #else
9347    ueDl->mimoInfo.ri = 1;
9348 #endif /*TFU_UPGRADE */
9349    ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
9350    ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
9351
9352    RETVOID;
9353 }
9354 /***********************************************************
9355  *
9356  *     Func : rgSCHCmnUpdUeUlCqiInfo
9357  *
9358  *     Desc : Updates UL and DL Ue Information
9359  *
9360  *     Ret  :
9361  *
9362  *     Notes:
9363  *
9364  *     File :
9365  *
9366  **********************************************************/
9367 #ifdef ANSI
9368 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo
9369 (
9370 RgSchCellCb   *cell,
9371 RgSchUeCb     *ue,
9372 RgSchCmnUlUe  *ueUl,
9373 RgSchCmnUe    *ueSchCmn,
9374 RgSchCmnCell  *cellSchd,
9375 Bool          isEcp
9376 )
9377 #else
9378 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, isEcp)
9379 RgSchCellCb  *cell;
9380 RgSchUeCb    *ue;
9381 RgSchCmnUlUe *ueUl;
9382 RgSchCmnUe   *ueSchCmn;
9383 RgSchCmnCell *cellSchd;
9384 Bool          isEcp;
9385 #endif
9386 {
9387
9388    TRC2(rgSCHCmnUpdUeUlCqiInfo)
9389
9390 #ifdef TFU_UPGRADE
9391    if(ue->srsCb.srsCfg.type  ==  RGR_SCH_SRS_SETUP)
9392    {
9393      if(ue->ul.ulTxAntSel.pres)
9394      {
9395        ueUl->crntUlCqi[ue->srsCb.selectedAnt] = cellSchd->ul.dfltUlCqi;
9396        ueUl->validUlCqi = ueUl->crntUlCqi[ue->srsCb.selectedAnt];
9397      }
9398      else
9399      {
9400        ueUl->crntUlCqi[0] = cellSchd->ul.dfltUlCqi;
9401        ueUl->validUlCqi =  ueUl->crntUlCqi[0];
9402      }
9403       ue->validTxAnt = ue->srsCb.selectedAnt;
9404    }
9405    else
9406    {
9407       ueUl->validUlCqi = cellSchd->ul.dfltUlCqi;
9408       ue->validTxAnt = 0;
9409    }
9410 #ifdef UL_LA
9411    ueUl->ulLaCb.cqiBasediTbs = rgSchCmnUlCqiToTbsTbl[isEcp]
9412                                                 [ueUl->validUlCqi] * 100;   
9413    ueUl->ulLaCb.deltaiTbs = 0;
9414 #endif
9415
9416 #else
9417    ueUl->crntUlCqi[0] = cellSchd->ul.dfltUlCqi;
9418 #endif /*TFU_UPGRADE */
9419    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
9420    if (rgUeCatTbl[ueSchCmn->cmn.ueCat].ul64qamSup == FALSE)
9421    {
9422       ueUl->maxUlCqi = cellSchd->ul.max16qamCqi;
9423    }
9424    else
9425    {
9426       ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
9427    }
9428
9429    RETVOID;
9430 }
9431 /***********************************************************
9432  *
9433  *     Func : rgSCHCmnUpdUeCatCfg
9434  *
9435  *     Desc : Updates UL and DL Ue Information
9436  *
9437  *     Ret  :
9438  *
9439  *     Notes:
9440  *
9441  *     File :
9442  *
9443  **********************************************************/
9444 #ifdef ANSI
9445 PRIVATE Void rgSCHCmnUpdUeCatCfg
9446 (
9447 RgSchUeCb    *ue,
9448 RgSchCellCb  *cell
9449 )
9450 #else
9451 PRIVATE Void rgSCHCmnUpdUeCatCfg(ue, cell)
9452 RgSchUeCb    *ue;
9453 RgSchCellCb  *cell;
9454 #endif
9455 {
9456    RgSchDlHqEnt *hqE = NULLP;
9457    RgSchCmnUlUe *ueUl     = RG_SCH_CMN_GET_UL_UE(ue,cell);
9458    RgSchCmnDlUe *ueDl     = RG_SCH_CMN_GET_DL_UE(ue,cell);
9459    RgSchCmnUe   *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
9460    RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
9461
9462    TRC2(rgSCHCmnUpdUeCatCfg)
9463
9464    ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
9465    
9466    hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
9467    /*CA dev-Start*/
9468    U8 ri = 0;
9469    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
9470    if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
9471             ||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat)) 
9472          && (RG_SCH_MAX_TX_LYRS_4 == ri))
9473    {
9474       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[1];
9475    }
9476    else
9477    {
9478       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[0];
9479    }
9480    /*CA dev-End*/
9481    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9482                            hqE->numHqPrcs);
9483    if (rgUeCatTbl[ueSchCmn->cmn.ueCat].ul64qamSup == FALSE)
9484    {
9485       ueUl->maxUlCqi = cellSchd->ul.max16qamCqi;
9486    }
9487    else
9488    {
9489       ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
9490    }
9491    ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
9492                    RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
9493    RETVOID;
9494 }
9495
9496 /**
9497  * @brief UE reconfiguration for scheduler.
9498  *
9499  * @details
9500  *
9501  *     Function : rgSChCmnRgrUeRecfg
9502  *
9503  *     This functions updates UE specific scheduler
9504  *     information upon UE reconfiguration.
9505  *
9506  *  @param[in]  RgSchCellCb  *cell
9507  *  @param[in]  RgSchUeCb    *ue
9508  *  @param[int] RgrUeRecfg   *ueRecfg
9509  *  @param[out] RgSchErrInfo *err
9510  *  @return  S16
9511  *      -# ROK
9512  *      -# RFAILED
9513  **/
9514 #ifdef ANSI
9515 PUBLIC S16 rgSCHCmnRgrUeRecfg
9516 (
9517 RgSchCellCb  *cell,
9518 RgSchUeCb    *ue,
9519 RgrUeRecfg   *ueRecfg,
9520 RgSchErrInfo *err
9521 )
9522 #else
9523 PUBLIC S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
9524 RgSchCellCb  *cell;
9525 RgSchUeCb    *ue;
9526 RgrUeRecfg   *ueRecfg;
9527 RgSchErrInfo *err;
9528 #endif
9529 {
9530    RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
9531    U32          waitPer;
9532
9533    TRC2(rgSCHCmnRgrUeRecfg);
9534    /* Basic validations */
9535    if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
9536    {
9537 #ifdef TFU_UPGRADE
9538       rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, cell->numTxAntPorts);
9539 #else
9540       rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg);
9541 #endif /* TFU_UPGRADE */
9542    }
9543    if(ueRecfg->ueRecfgTypes & RGR_UE_CSG_PARAM_RECFG)
9544    {
9545       ue->csgMmbrSta = ueRecfg->csgMmbrSta;
9546    }
9547    /* Changes for UE Category reconfiguration feature */
9548    if(ueRecfg->ueRecfgTypes & RGR_UE_UECAT_RECFG)
9549    {
9550        rgSCHCmnUpdUeCatCfg(ue, cell);
9551    }
9552    if (ueRecfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG)
9553    {
9554       RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
9555       pCellInfo->acqiCb.aCqiCfg = ueRecfg->aprdDlCqiRecfg;
9556    }
9557 #ifndef TFU_UPGRADE
9558    if (ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG)
9559    {
9560       if ((ueRecfg->prdDlCqiRecfg.pres == TRUE)
9561             && (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD10)
9562             && (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD20))
9563       {
9564          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unsupported periodic CQI "
9565             "reporting mode %d for old CRNIT:%d", 
9566             (int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
9567          err->errCause = RGSCHERR_SCH_CFG;
9568          RETVALUE(RFAILED);
9569       }
9570      ue->dl.ueDlCqiCfg.prdCqiCfg = ueRecfg->prdDlCqiRecfg;
9571    }
9572 #endif
9573
9574    if (ueRecfg->ueRecfgTypes & RGR_UE_ULPWR_RECFG)
9575    {
9576       if (rgSCHPwrUeRecfg(cell, ue, ueRecfg) != ROK)
9577       {
9578          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9579                "Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
9580          RETVALUE(RFAILED);
9581       }
9582    }
9583
9584    if (ueRecfg->ueRecfgTypes & RGR_UE_QOS_RECFG)
9585    {
9586       /* Uplink Sched related Initialization */
9587       if ((ueRecfg->ueQosRecfg.dlAmbr == 0) && (ueRecfg->ueQosRecfg.ueBr == 0))
9588       {
9589          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
9590             "configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
9591          err->errCause = RGSCHERR_SCH_CFG;
9592          RETVALUE(RFAILED);
9593       }
9594       ue->ul.cfgdAmbr = (ueRecfg->ueQosRecfg.ueBr * \
9595       RG_SCH_CMN_REFRESH_TIME)/100;
9596       /* Downlink Sched related Initialization */
9597       ue->dl.ambrCfgd = (ueRecfg->ueQosRecfg.dlAmbr * \
9598       RG_SCH_CMN_REFRESH_TIME)/100;
9599       /* Fix: syed Update the effAmbr and effUeBR fields w.r.t the
9600        * new QOS configuration */
9601       rgSCHCmnDelUeFrmRefreshQ(cell, ue);
9602       /* Fix: syed align multiple UEs to refresh at same time */
9603       rgSCHCmnGetRefreshPer(cell, ue, &waitPer);
9604       rgSCHCmnApplyUeRefresh(cell, ue);
9605       rgSCHCmnAddUeToRefreshQ(cell, ue, waitPer);
9606    }
9607 #ifdef EMTC_ENABLE   
9608    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
9609    {
9610       if ((cellSchCmn->apisEmtcUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9611       {
9612          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9613                "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9614          RETVALUE(RFAILED);
9615       }
9616       if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9617       {
9618          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9619                "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9620          RETVALUE(RFAILED);
9621       }
9622    }
9623    else
9624 #endif
9625    {
9626       if ((cellSchCmn->apisUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9627       {
9628          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9629             "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9630          RETVALUE(RFAILED);
9631       }
9632       if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9633       {
9634          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9635             "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9636          RETVALUE(RFAILED);
9637       }
9638    }
9639    /* DLFS UE Config */
9640    if (cellSchCmn->dl.isDlFreqSel)
9641    {
9642       if ((cellSchCmn->apisDlfs->rgSCHDlfsUeRecfg(cell, ue, \
9643          ueRecfg, err)) != ROK)
9644       {
9645          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9646                "DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
9647          RETVALUE(RFAILED);
9648       }
9649    }
9650
9651 #ifdef LTEMAC_SPS
9652    /* Invoke re-configuration on SPS module */
9653    if (rgSCHCmnSpsUeRecfg(cell, ue, ueRecfg, err) != ROK)
9654    {
9655       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9656               "DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
9657       RETVALUE(RFAILED);
9658    }
9659 #endif
9660
9661    RETVALUE(ROK);
9662 }  /* rgSCHCmnRgrUeRecfg*/
9663
9664 /***********************************************************
9665  *
9666  *     Func : rgSCHCmnUlUeDelAllocs
9667  *
9668  *     Desc : Deletion of all UE allocations.
9669  *
9670  *     Ret  :
9671  *
9672  *     Notes:
9673  *
9674  *     File :
9675  *
9676  **********************************************************/
9677 #ifdef ANSI
9678 PRIVATE Void rgSCHCmnUlUeDelAllocs
9679 (
9680 RgSchCellCb  *cell,
9681 RgSchUeCb   *ue
9682 )
9683 #else
9684 PRIVATE Void rgSCHCmnUlUeDelAllocs(cell, ue)
9685 RgSchCellCb  *cell;
9686 RgSchUeCb   *ue;
9687 #endif
9688 {
9689    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
9690    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
9691    U8 i;
9692 #ifdef LTEMAC_SPS
9693    RgSchCmnUlUeSpsInfo   *ulSpsUe   = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
9694 #endif
9695    TRC2(rgSCHCmnUlUeDelAllocs);
9696
9697    for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
9698    {
9699       RgSchUlHqProcCb *proc = rgSCHUhmGetUlHqProc(cell, ue, i);
9700
9701 #ifdef ERRCLS_KW
9702       /* proc can't be NULL here */
9703       if (proc)
9704 #endif
9705       {
9706          /* R8 Upgrade */
9707          proc->ndi = 0;
9708          if (proc->alloc)
9709          {
9710             /* Added Insure Fixes Of reading Dangling memory.NULLed crntAlloc */
9711 #ifdef LTEMAC_SPS
9712             if(proc->alloc == ulSpsUe->ulSpsSchdInfo.crntAlloc)
9713             {
9714                ulSpsUe->ulSpsSchdInfo.crntAlloc = NULLP;
9715                ulSpsUe->ulSpsSchdInfo.crntAllocSf = NULLP;
9716             }
9717 #endif
9718 #ifdef EMTC_ENABLE
9719             rgSCHCmnUlFreeAllocation(cell, &cellUl->ulSfArr[proc->ulSfIdx],
9720                   proc->alloc,ue->isEmtcUe);
9721 #else
9722             rgSCHCmnUlFreeAllocation(cell, &cellUl->ulSfArr[proc->ulSfIdx],
9723                   proc->alloc);
9724 #endif
9725             /* PHY probably needn't be intimated since
9726              * whatever intimation it needs happens at the last minute
9727              */
9728          }
9729          /* Fix: syed Adaptive Msg3 Retx crash. Remove the harqProc
9730           * from adaptive retx List. */
9731          if (proc->reTxLnk.node)
9732          {
9733             {
9734                //TODO_SID: Need to take care
9735                cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk); 
9736                proc->reTxLnk.node = (PTR)NULLP;
9737             }
9738          }
9739       }
9740    }
9741    RETVOID;
9742 }
9743
9744 /***********************************************************
9745  *
9746  *     Func : rgSCHCmnDelUeFrmRefreshQ
9747  *
9748  *     Desc : Adds a UE to refresh queue, so that the UE is
9749  *            periodically triggered to refresh it's GBR and
9750  *            AMBR values.
9751  *
9752  *     Ret  :
9753  *
9754  *     Notes:
9755  *
9756  *     File :
9757  *
9758  **********************************************************/
9759 #ifdef ANSI
9760 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ
9761 (
9762 RgSchCellCb     *cell,
9763 RgSchUeCb       *ue
9764 )
9765 #else
9766 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ(cell, ue)
9767 RgSchCellCb     *cell;
9768 RgSchUeCb       *ue;
9769 #endif
9770 {
9771    RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
9772    CmTmrArg       arg;
9773    RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
9774
9775    TRC2(rgSCHCmnDelUeFrmRefreshQ);
9776
9777 #ifdef RGL_SPECIFIC_CHANGES
9778    if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
9779    {
9780       if(cell->refreshUeCnt[ue->refreshOffset])
9781       {
9782          cell->refreshUeCnt[ue->refreshOffset]--;
9783       }
9784    }
9785 #endif
9786
9787
9788    cmMemset((U8 *)&arg, 0, sizeof(arg));
9789    arg.tqCp   = &sched->tmrTqCp;
9790    arg.tq     = sched->tmrTq;
9791    arg.timers = &ueSchd->tmr;
9792    arg.cb     = (PTR)ue;
9793    arg.tNum   = 0;
9794    arg.max    = 1;
9795    arg.evnt   = RG_SCH_CMN_EVNT_UE_REFRESH;
9796
9797    cmRmvCbTq(&arg);
9798    RETVOID;
9799 }
9800
9801 /***********************************************************
9802  *
9803  *     Func : rgSCHCmnUeCcchSduDel
9804  *
9805  *     Desc : Clear CCCH SDU scheduling context.
9806  *
9807  *     Ret  :
9808  *
9809  *     Notes:
9810  *
9811  *     File :
9812  *
9813  **********************************************************/
9814 #ifdef ANSI
9815 PRIVATE Void rgSCHCmnUeCcchSduDel
9816 (
9817 RgSchCellCb  *cell,
9818 RgSchUeCb    *ueCb
9819 )
9820 #else
9821 PRIVATE Void rgSCHCmnUeCcchSduDel(cell, ueCb)
9822 RgSchCellCb  *cell;
9823 RgSchUeCb    *ueCb;
9824 #endif
9825 {
9826    RgSchDlHqEnt      *hqE = NULLP;
9827    RgSchDlHqProcCb   *ccchSduHqP = NULLP;
9828    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
9829
9830    TRC2(rgSCHCmnUeCcchSduDel);
9831
9832    hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
9833    if (hqE == NULLP)
9834    {
9835       RETVOID;
9836    }
9837    ccchSduHqP = hqE->ccchSduProc;
9838    if(ueCb->ccchSduLnk.node != NULLP)
9839    {
9840       /* Remove the ccchSduProc if it is in the Tx list */
9841       cmLListDelFrm(&(cell->ccchSduUeLst), &(ueCb->ccchSduLnk));
9842       ueCb->ccchSduLnk.node = NULLP;   
9843    }
9844    else if(ccchSduHqP != NULLP)
9845    {
9846       /* Fix for crash due to stale pdcch. Release ccch pdcch*/
9847       if(ccchSduHqP->pdcch)
9848       {
9849          cmLListDelFrm(&ccchSduHqP->subFrm->pdcchInfo.pdcchs,
9850                &ccchSduHqP->pdcch->lnk);
9851          cmLListAdd2Tail(&cell->pdcchLst, &ccchSduHqP->pdcch->lnk);
9852          ccchSduHqP->pdcch = NULLP;
9853       }
9854       if(ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk.node != NULLP)
9855       {
9856          /* Remove the ccchSduProc if it is in the retx list */
9857          cmLListDelFrm(&cellSch->dl.ccchSduRetxLst,
9858           &ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk);
9859          /* ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk.node = NULLP; */
9860          rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
9861       }
9862       else if ((ccchSduHqP->subFrm != NULLP) &&
9863        (ccchSduHqP->hqPSfLnk.node != NULLP))
9864       {
9865          rgSCHUtlDlHqPTbRmvFrmTx(ccchSduHqP->subFrm, 
9866                ccchSduHqP, 0, FALSE);
9867          rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
9868       }
9869    }   
9870    RETVOID;
9871 }
9872
9873
9874
9875
9876 /**
9877  * @brief UE deletion for scheduler.
9878  *
9879  * @details
9880  *
9881  *     Function : rgSCHCmnUeDel
9882  *
9883  *     This functions deletes all scheduler information
9884  *     pertaining to an UE.
9885  *
9886  *  @param[in]  RgSchCellCb  *cell
9887  *  @param[in]  RgSchUeCb    *ue
9888  *  @return  Void
9889  **/
9890 #ifdef ANSI
9891 PUBLIC Void rgSCHCmnUeDel
9892 (
9893 RgSchCellCb  *cell,
9894 RgSchUeCb    *ue
9895 )
9896 #else
9897 PUBLIC Void rgSCHCmnUeDel(cell, ue)
9898 RgSchCellCb  *cell;
9899 RgSchUeCb    *ue;
9900 #endif
9901 {
9902    RgSchDlHqEnt         *hqE = NULLP;
9903    RgSchCmnUlUe         *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
9904    CmLList              *node;
9905    RgSchCmnAllocRecord  *allRcd;
9906    U8                    cnt;
9907    RgSchCmnCell         *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
9908    U32                   idx = 0;
9909    TRC2(rgSCHCmnUeDel);
9910
9911    if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
9912    {
9913       /* Common scheduler config has not happened yet */
9914       RETVOID;
9915    }
9916    hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
9917    if(hqE)
9918    {
9919       /* UE Free can be triggered before MSG4 done when dlHqE is not updated */
9920 #ifdef EMTC_ENABLE
9921       if(ue->isEmtcUe)
9922       {
9923          rgSCHEmtcCmnUeCcchSduDel(cell, ue);
9924       }
9925       else
9926 #endif
9927      {    
9928          rgSCHCmnUeCcchSduDel(cell, ue);
9929      }
9930    }
9931    rgSCHCmnDelUeFrmRefreshQ(cell, ue);
9932
9933    rgSCHCmnUlUeDelAllocs(cell, ue);
9934
9935    rgSCHCmnDelRachInfo(cell, ue);
9936
9937 #ifdef EMTC_ENABLE   
9938    if(TRUE == ue->isEmtcUe)
9939    {
9940       cellSchCmn->apisEmtcUl->rgSCHFreeUlUe(cell, ue);
9941    }
9942    else
9943 #endif
9944    {
9945    cellSchCmn->apisUl->rgSCHFreeUlUe(cell, ue);
9946    }
9947 #ifdef LTE_ADV
9948    if (ue->numSCells)
9949    {
9950       for(idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
9951       {
9952          if(ue->cellInfo[idx] != NULLP) 
9953          {
9954             rgSCHSCellDelUeSCell(cell,ue,idx);
9955          }
9956       }
9957
9958    }
9959 #endif
9960 #ifdef EMTC_ENABLE
9961    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
9962    {
9963       cellSchCmn->apisEmtcDl->rgSCHFreeDlUe(cell, ue);
9964    }
9965    else
9966 #endif
9967    {
9968       cellSchCmn->apisDl->rgSCHFreeDlUe(cell, ue);
9969    }
9970    rgSCHPwrUeDel(cell, ue);
9971
9972 #ifdef LTEMAC_SPS
9973    rgSCHCmnSpsUeDel(cell, ue);
9974 #endif /* LTEMAC_SPS*/
9975
9976    /* CA Dev Start*/
9977    rgSchCmnDlSfHqDel(ue, cell);
9978    /* CA Dev End*/
9979    /* DLFS UE delete */
9980    if (cellSchCmn->dl.isDlFreqSel)
9981    {
9982       cellSchCmn->apisDlfs->rgSCHDlfsUeDel(cell, ue);
9983    }
9984    node = ueUl->ulAllocLst.first;
9985
9986 /* ccpu00117052 - MOD - Passing double pointer in all the places of
9987    rgSCHUtlFreeSBuf function call for proper NULLP assignment*/
9988    while(node)
9989    {
9990       allRcd = (RgSchCmnAllocRecord *)node->node;
9991       node = node->next;
9992       cmLListDelFrm(&ueUl->ulAllocLst, &allRcd->lnk);
9993       rgSCHUtlFreeSBuf(cell->instIdx,
9994          (Data**)(&allRcd), (sizeof(RgSchCmnAllocRecord)));
9995    }
9996
9997    for(cnt = 0; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
9998    {
9999       if (ue->ul.lcgArr[cnt].sch != NULLP)
10000       {
10001          rgSCHUtlFreeSBuf(cell->instIdx,
10002             (Data**)(&(ue->ul.lcgArr[cnt].sch)), (sizeof(RgSchCmnLcg)));
10003       }
10004    }
10005
10006    /* Fix : syed Moved hqEnt deinit to rgSCHCmnDlDeInitHqEnt */
10007    idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
10008    rgSCHUtlFreeSBuf(cell->instIdx,
10009          (Data**)(&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch))), (sizeof(RgSchCmnUe)));
10010    RETVOID;
10011 }  /* rgSCHCmnUeDel */
10012
10013 \f
10014 /**
10015  * @brief This function handles the common code rate configurations
10016  *        done as part of RgrCellCfg/RgrCellRecfg.
10017  *
10018  * @details
10019  *
10020  *     Function: rgSCHCmnDlCnsdrCmnRt
10021  *     Purpose:  This function handles the common code rate configurations
10022  *        done as part of RgrCellCfg/RgrCellRecfg.
10023  *
10024  *     Invoked by: Scheduler
10025  *
10026  *  @param[in]  RgSchCellCb                *cell
10027  *  @param[in]  RgrDlCmnCodeRateCfg     *dlCmnCodeRate
10028  *  @return     S16
10029  *
10030  **/
10031 #ifdef ANSI
10032 PRIVATE S16 rgSCHCmnDlCnsdrCmnRt
10033 (
10034 RgSchCellCb             *cell,
10035 RgrDlCmnCodeRateCfg     *dlCmnCodeRate
10036 )
10037 #else
10038 PRIVATE S16 rgSCHCmnDlCnsdrCmnRt(cell, dlCmnCodeRate)
10039 RgSchCellCb             *cell;
10040 RgrDlCmnCodeRateCfg     *dlCmnCodeRate;
10041 #endif
10042 {
10043    RgSchCmnCell         *cellDl = RG_SCH_CMN_GET_CELL(cell);
10044    U32                  bitsPerRb;
10045    U32                  bitsPer2Rb;
10046    U32                  bitsPer3Rb;
10047    U8                   i, rbNum;
10048    U32                  pdcchBits;
10049
10050    TRC2(rgSCHCmnDlCnsdrCmnRt);
10051
10052    /* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
10053     * bits per 1024/2 REs */
10054    if (dlCmnCodeRate->bcchPchRaCodeRate != 0)
10055    {
10056       bitsPerRb = ((dlCmnCodeRate->bcchPchRaCodeRate * 2) *
10057             cellDl->dl.noResPerRb[3])/1024;
10058    }
10059    else
10060    {
10061       bitsPerRb = ((RG_SCH_CMN_DEF_BCCHPCCH_CODERATE * 2) *
10062             cellDl->dl.noResPerRb[3])/1024;
10063    }
10064    /* Store bitsPerRb in cellDl->dl to use later to determine
10065     * Number of RBs for UEs with SI-RNTI, P-RNTI and RA-RNTI */
10066    cellDl->dl.bitsPerRb = bitsPerRb;
10067    /* ccpu00115595 end*/
10068    /* calculate the ITbs for 2 RBs. Initialize ITbs to MAX value */
10069    i = 0;
10070    rbNum = 2;
10071    bitsPer2Rb = bitsPerRb * rbNum;
10072    while ((i < 9) && (rgTbSzTbl[0][i][rbNum - 1] <= bitsPer2Rb))
10073       i++;
10074
10075    (i <= 1)? (cellDl->dl.cmnChITbs.iTbs2Rbs = 0) :
10076       (cellDl->dl.cmnChITbs.iTbs2Rbs = i-1);
10077
10078    /* calculate the ITbs for 3 RBs. Initialize ITbs to MAX value */
10079    i = 0;
10080    rbNum = 3;
10081    bitsPer3Rb = bitsPerRb * rbNum;
10082    while ((i < 9) && (rgTbSzTbl[0][i][rbNum - 1] <= bitsPer3Rb))
10083          i++;
10084
10085    (i <= 1)? (cellDl->dl.cmnChITbs.iTbs3Rbs = 0) :
10086       (cellDl->dl.cmnChITbs.iTbs3Rbs = i-1);
10087
10088
10089    pdcchBits = 1 + /* Flag for format0/format1a differentiation */
10090       1 + /* Localized/distributed VRB assignment flag */
10091       5 + /* For mcs */
10092 #ifndef LTE_TDD
10093       3 + /* Harq process Id */
10094 #else
10095       4 + /* Harq process Id */
10096       2 + /* UL Index or DAI */
10097 #endif
10098       1 + /* New Data Indicator */
10099       2 + /* For RV */
10100       2 + /* For tpc */
10101       1 + rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
10102                (cell->bwCfg.dlTotalBw + 1))/2);
10103    /* Resource block assignment ceil[log2(bw(bw+1)/2)] : \
10104       Since VRB is local */
10105    /* For TDD consider DAI */
10106
10107    /* Convert the pdcchBits to actual pdcchBits required for transmission */
10108    if (dlCmnCodeRate->pdcchCodeRate != 0)
10109    {
10110       pdcchBits = (pdcchBits * 1024)/dlCmnCodeRate->pdcchCodeRate;
10111       if (pdcchBits <= 288) /* 288 : Num of pdcch bits for aggrLvl=4 */
10112       {
10113          cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL4;
10114       }
10115       else                  /* 576 : Num of pdcch bits for aggrLvl=8 */
10116       {
10117          cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL8;
10118       }
10119    }
10120    else
10121    {
10122       cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL4;
10123    }
10124    if (dlCmnCodeRate->ccchCqi == 0)
10125    {
10126       RETVALUE(RFAILED);
10127    }
10128    else
10129    {
10130       cellDl->dl.ccchCqi = dlCmnCodeRate->ccchCqi;
10131    }
10132    RETVALUE(ROK);
10133 }
10134
10135 #ifdef LTE_TDD
10136 /**
10137  * @brief This function handles the configuration of cell for the first
10138  *        time by the scheduler.
10139  *
10140  * @details
10141  *
10142  *     Function: rgSCHCmnDlRgrCellCfg
10143  *     Purpose:  Configuration received is stored into the data structures
10144  *               Also, update the scheduler with the number of frames of
10145  *               RACH preamble transmission.
10146  *
10147  *     Invoked by: BO and Scheduler
10148  *
10149  *  @param[in]  RgSchCellCb*     cell
10150  *  @param[in]  RgrCellCfg*      cfg
10151  *  @return     S16
10152  *
10153  **/
10154 #ifdef ANSI
10155 PRIVATE S16 rgSCHCmnDlRgrCellCfg
10156 (
10157 RgSchCellCb    *cell,
10158 RgrCellCfg     *cfg,
10159 RgSchErrInfo   *err
10160 )
10161 #else
10162 PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
10163 RgSchCellCb    *cell;
10164 RgrCellCfg     *cfg;
10165 RgSchErrInfo   *err;
10166 #endif
10167 {
10168    RgSchCmnCell         *cellSch;
10169    U8                   cp;
10170    U8                   sfCount;
10171    U8                   numPdcchSym;
10172    U8                   noSymPerSlot;
10173    U8                   maxDlSubfrms = cell->numDlSubfrms;
10174    U8                   splSubfrmIdx = cfg->spclSfCfgIdx;
10175    U8                   swPtCnt = 0;
10176    Bool                 isSplfrm;
10177    RgSchTddSubfrmInfo   subfrmInfo = rgSchTddMaxUlSubfrmTbl[cell->ulDlCfgIdx];
10178    S16                  ret;
10179    U8                   splSfIdx;
10180    U8                   antPortIdx;
10181    U8                   numCrs;
10182    U8                   cfi;  
10183    U8                   cfiIdx;
10184    RgSchDlSf            *sf;
10185    U8                   splSfCfi;
10186    U8                   mPhich;
10187
10188    TRC2(rgSCHCmnDlRgrCellCfg);
10189    
10190
10191    cellSch = RG_SCH_CMN_GET_CELL(cell);
10192    cellSch->dl.numRaSubFrms = rgRaPrmblToRaFrmTbl[cell->\
10193                                                   rachCfg.preambleFormat];
10194    /*[ccpu00138532]-ADD-fill the Msg4 Harq data */
10195    cell->dlHqCfg.maxMsg4HqTx = cfg->dlHqCfg.maxMsg4HqTx;                                                
10196    
10197    /* Msg4 Tx Delay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  + 
10198                        3 TTI (MAX L1+L2 processing delay at the UE) */
10199    cellSch->dl.msg4TxDelay = (cfg->dlHqCfg.maxMsg4HqTx-1) *
10200                                  rgSchCmnHarqRtt[cell->ulDlCfgIdx] + 3; 
10201    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10202    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10203    if (cfg->maxUePerDlSf == 0)
10204    {
10205       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10206    }
10207    if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
10208    {
10209       RETVALUE(RFAILED);
10210    }
10211
10212
10213    if (cell->bwCfg.dlTotalBw <= 10)
10214    {
10215       cfiIdx = 1;
10216       numPdcchSym = 2;
10217    }
10218    else
10219    {
10220       cfiIdx = 0;
10221       numPdcchSym = 1;
10222    }
10223    /* DwPTS Scheduling Changes Start */
10224    cellSch->dl.splSfCfg  = splSubfrmIdx;
10225  
10226    if (cfg->isCpDlExtend == TRUE)
10227    {
10228       if((0 == splSubfrmIdx) || (4 == splSubfrmIdx) ||
10229          (7 == splSubfrmIdx) || (8 == splSubfrmIdx)
10230         )
10231       {
10232          cell->splSubfrmCfg.isDlDataAllowed = FALSE; 
10233       }
10234       else
10235       {
10236          cell->splSubfrmCfg.isDlDataAllowed = TRUE; 
10237       }
10238    }
10239    else
10240    {
10241       /* Refer to 36.213 Section 7.1.7 */
10242       if((0 == splSubfrmIdx) || (5 == splSubfrmIdx))
10243       {
10244          cell->splSubfrmCfg.isDlDataAllowed = FALSE; 
10245       }
10246       else
10247       {
10248          cell->splSubfrmCfg.isDlDataAllowed = TRUE; 
10249       }
10250    }
10251    /* DwPTS Scheduling Changes End */  
10252
10253    splSfCfi = RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi);
10254    RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, splSfCfi);
10255    
10256    for (sfCount = 0; sfCount < maxDlSubfrms; sfCount++)
10257    {
10258       sf = cell->subFrms[sfCount];
10259       /* Sfcount matches the first special subframe occurs at Index 0
10260             * or subsequent special subframes */
10261       if(subfrmInfo.switchPoints == 1)
10262       {
10263          isSplfrm = rgSCHCmnIsSplSubfrm(swPtCnt, sfCount,
10264                                  RG_SCH_CMN_10_MS_PRD, &subfrmInfo);
10265       }
10266       else
10267       {
10268          isSplfrm = rgSCHCmnIsSplSubfrm(swPtCnt, sfCount,
10269                                  RG_SCH_CMN_5_MS_PRD, &subfrmInfo);
10270       }
10271       if(isSplfrm == TRUE)
10272       {
10273          swPtCnt++;
10274          /* DwPTS Scheduling Changes Start */        
10275          if (cell->splSubfrmCfg.isDlDataAllowed == TRUE)
10276          {
10277             sf->sfType = RG_SCH_SPL_SF_DATA;
10278          }
10279          else
10280          {
10281             sf->sfType = RG_SCH_SPL_SF_NO_DATA;
10282          }
10283          /* DwPTS Scheduling Changes End */
10284       }
10285       else
10286       {
10287          /* DwPTS Scheduling Changes Start */
10288          if (sf->sfNum != 0)
10289          {
10290             sf->sfType = RG_SCH_DL_SF;
10291          }
10292          else
10293          {
10294             sf->sfType = RG_SCH_DL_SF_0;
10295          }
10296          /* DwPTS Scheduling Changes End */
10297       }
10298       
10299       /* Calculate the number of CCEs per subframe in the cell */
10300       mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][sf->sfNum];
10301       if(cell->dynCfiCb.isDynCfiEnb == TRUE)
10302       {   
10303          /* In case if Dynamic CFI feature is enabled, default CFI 
10304           * value 1 is used  */
10305          sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][1];
10306       }
10307       else
10308       {
10309          if (sf->sfType == RG_SCH_SPL_SF_DATA)
10310          {
10311             sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][splSfCfi];
10312          }
10313          else
10314          {
10315             sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi)];
10316          }
10317       }   
10318    }
10319
10320    /* Intialize the RACH response scheduling related infromation */
10321    if(rgSCHCmnDlRachInfoInit(cell) != ROK)
10322    {
10323      RETVALUE(RFAILED);
10324    }
10325
10326    /* Allocate PRACH preamble list */
10327    rgSCHCmnDlCreateRachPrmLst(cell);
10328
10329    /* Initialize PHICH offset information */
10330    rgSCHCmnDlPhichOffsetInit(cell);
10331
10332    /* Update the size of HARQ ACK/NACK feedback table */
10333    /* The array size is increased by 2 to have enough free indices, where other
10334     * indices are busy waiting for HARQ feedback */
10335    cell->ackNackFdbkArrSize = rgSchTddANFdbkMapTbl[cell->ulDlCfgIdx] + 2; 
10336
10337    /* Initialize expected HARQ ACK/NACK feedback time */
10338    rgSCHCmnDlANFdbkInit(cell);
10339
10340    /* Initialize UL association set index */
10341    if(cell->ulDlCfgIdx != 0)
10342    {
10343       rgSCHCmnDlKdashUlAscInit(cell);
10344    }
10345
10346    if (cfg->isCpDlExtend == TRUE)
10347    {
10348       cp = RG_SCH_CMN_EXT_CP;
10349       noSymPerSlot = 6;
10350       cell->splSubfrmCfg.dwPts =
10351           rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlDwPts;
10352    
10353       if ( cell->splSubfrmCfg.dwPts == 0 )
10354       {
10355          cell->isDwPtsCnted = FALSE;
10356       }
10357       else
10358       {
10359          cell->isDwPtsCnted = TRUE;
10360       }
10361
10362       if(cfg->isCpUlExtend == TRUE)
10363       {
10364          cell->splSubfrmCfg.upPts =
10365             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlExtUpPts;
10366       }
10367       else
10368       {
10369          cell->splSubfrmCfg.upPts =
10370             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlNorUpPts;
10371       }
10372    }
10373    else
10374    {
10375       cp = RG_SCH_CMN_NOR_CP;
10376       noSymPerSlot = 7;
10377       cell->splSubfrmCfg.dwPts =
10378           rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlDwPts;
10379       cell->isDwPtsCnted = TRUE;
10380
10381       if(cfg->isCpUlExtend == TRUE)
10382       {
10383          cell->splSubfrmCfg.upPts =
10384             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlExtUpPts;
10385       }
10386       else
10387       {
10388          cell->splSubfrmCfg.upPts =
10389             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlNorUpPts;
10390       }
10391    }
10392
10393    /* Initializing the cqiToEffTbl and cqiToTbsTbl for every CFI value */
10394    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++,cfiIdx++)
10395    {   
10396       cellSch->dl.cqiToTbsTbl[0][cfi]   = rgSchCmnCqiToTbs[0][cp][cfiIdx];
10397       cellSch->dl.cqiToEffTbl[0][cfi]   = rgSchCmnEffTbl[0][cp][rgSchCmnAntIdx\
10398                                                  [cell->numTxAntPorts]][cfiIdx];
10399       cellSch->dl.cqiToTbsTbl[1][cfi]   = rgSchCmnCqiToTbs[1][cp][cfiIdx];
10400       cellSch->dl.cqiToEffTbl[1][cfi]   = rgSchCmnEffTbl[1][cp][rgSchCmnAntIdx\
10401                                                  [cell->numTxAntPorts]][cfiIdx];
10402    }
10403
10404    /* Initializing the values of CFI parameters */
10405    if(cell->dynCfiCb.isDynCfiEnb)
10406    {   
10407       /* If DCFI is enabled, current CFI value will start from 1 */
10408       cellSch->dl.currCfi = cellSch->dl.newCfi = 1;
10409    }
10410    else
10411    {
10412       /* If DCFI is disabled, current CFI value is set as default max allowed CFI value */
10413       cellSch->dl.currCfi = RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi);
10414       cellSch->dl.newCfi = cellSch->dl.currCfi;
10415    }   
10416
10417    /* Include CRS REs while calculating Efficiency
10418     * The number of Resource Elements occupied by CRS depends on Number of
10419     * Antenna Ports. Please refer to Section 6.10.1 of 3GPP TS 36.211 V8.8.0.
10420     * Also, please refer to Figures 6.10.1.2-1 and 6.10.1.2-2 for diagrammatic
10421     * details of the same. Please note that PDCCH overlap symbols would not
10422     * considered in CRS REs deduction */
10423    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, numPdcchSym++)
10424    {
10425       cellSch->dl.noResPerRb[cfi] = (((noSymPerSlot * RG_SCH_CMN_NUM_SLOTS_PER_SF)
10426             - numPdcchSym) *RB_SCH_CMN_NUM_SCS_PER_RB) - rgSchCmnNumResForCrs[cell->numTxAntPorts];
10427    }
10428
10429    /* DwPTS Scheduling Changes Start */
10430    antPortIdx = (cell->numTxAntPorts == 1)? 0: 
10431       ((cell->numTxAntPorts == 2)? 1: 2);     
10432
10433    if (cp == RG_SCH_CMN_NOR_CP)
10434    {
10435       splSfIdx = (splSubfrmIdx == 4)? 1: 0;   
10436    }
10437    else
10438    {
10439       splSfIdx = (splSubfrmIdx == 3)? 1: 0;
10440    }
10441
10442    numCrs = rgSchCmnDwptsCrs[splSfIdx][antPortIdx];
10443
10444    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI-1; cfi++)
10445    { 
10446       /* If CFI is 2 and Ant Port is 4, don't consider the sym 1 CRS REs */  
10447       if (antPortIdx == 2 && cfi == 2)
10448       {
10449          numCrs -= 4;      
10450       }
10451       cellSch->dl.numReDwPts[cfi]  =  ((cell->splSubfrmCfg.dwPts - cfi)*
10452                                   RB_SCH_CMN_NUM_SCS_PER_RB) - numCrs;
10453    }
10454    /* DwPTS Scheduling Changes End */
10455
10456    if (cfg->maxDlBwPerUe == 0)
10457    {
10458       cellSch->dl.maxDlBwPerUe = RG_SCH_CMN_MAX_DL_BW_PERUE;
10459    }
10460    else
10461    {
10462       cellSch->dl.maxDlBwPerUe = cfg->maxDlBwPerUe;
10463    }
10464    if (cfg->maxDlRetxBw == 0)
10465    {
10466       cellSch->dl.maxDlRetxBw = RG_SCH_CMN_MAX_DL_RETX_BW;
10467    }
10468    else
10469    {
10470       cellSch->dl.maxDlRetxBw = cfg->maxDlRetxBw;
10471    }
10472    /* Fix: MUE_PERTTI_DL*/
10473    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10474    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10475    if (cfg->maxUePerDlSf == 0)
10476    {
10477       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10478    }
10479    RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
10480    /*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
10481    if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
10482    {
10483       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
10484                       "Invalid configuration !: "
10485                       "maxCcchPerDlSf %u > maxUePerDlSf %u",
10486                    cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
10487
10488       RETVALUE(RFAILED);
10489    }
10490    else if (!cfg->maxCcchPerDlSf)
10491    {
10492       /* ccpu00143032: maxCcchPerDlSf 0 means not configured by application
10493        * hence setting to maxUePerDlSf. If maxCcchPerDlSf is 0 then scheduler
10494        * does't consider CCCH allocation in MaxUePerTti cap. Hence more than
10495        * 4UEs getting schduled & SCH expects >16 Hq PDUs in a TTI which causes
10496        * FLE crash in PHY as PHY has limit of 16 max*/
10497       cellSch->dl.maxCcchPerDlSf = cfg->maxUePerDlSf;
10498    }
10499    else
10500    {
10501       cellSch->dl.maxCcchPerDlSf = cfg->maxCcchPerDlSf;
10502    }
10503    if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
10504    {
10505       RETVALUE(RFAILED);
10506    }
10507
10508    /*ccpu00118273 - ADD - start */
10509    cmLListInit(&cellSch->dl.msg4RetxLst);
10510 #ifdef RGR_V1
10511    cmLListInit(&cellSch->dl.ccchSduRetxLst);
10512 #endif
10513
10514 #ifdef RG_PHASE2_SCHED
10515    if (cellSch->apisDlfs == NULLP) /* DFLS specific initialization */
10516    {
10517       cellSch->apisDlfs = &rgSchDlfsSchdTbl[cfg->dlfsSchdType];
10518    }
10519    if (cfg->dlfsCfg.isDlFreqSel)
10520    {
10521       ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
10522       if (ret != ROK)
10523       {
10524          RETVALUE(RFAILED);
10525       }
10526    }
10527    cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
10528 #endif
10529
10530    /* Power related configuration */
10531    ret = rgSCHPwrCellCfg(cell, cfg);
10532    if (ret != ROK)
10533    {
10534       RETVALUE(RFAILED);
10535    }
10536
10537    cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset; 
10538    cellSch->dl.pcchTxPwrOffset = cfg->pcchTxPwrOffset; 
10539    cellSch->dl.rarTxPwrOffset  = cfg->rarTxPwrOffset; 
10540    cellSch->dl.phichTxPwrOffset  = cfg->phichTxPwrOffset; 
10541    cellSch->dl.msg4pAVal        = cfg->msg4pAVal;
10542    RETVALUE(ROK);
10543 }
10544 #else /* LTE_TDD */
10545 /**
10546  * @brief This function handles the configuration of cell for the first
10547  *        time by the scheduler.
10548  *
10549  * @details
10550  *
10551  *     Function: rgSCHCmnDlRgrCellCfg
10552  *     Purpose:  Configuration received is stored into the data structures
10553  *               Also, update the scheduler with the number of frames of
10554  *               RACH preamble transmission.
10555  *
10556  *     Invoked by: BO and Scheduler
10557  *
10558  *  @param[in]  RgSchCellCb*   cell
10559  *  @param[in]  RgrCellCfg*    cfg
10560  *  @param[in]  RgSchErrInfo*  err
10561  *  @return     S16
10562  *
10563  **/
10564 #ifdef ANSI
10565 PRIVATE S16 rgSCHCmnDlRgrCellCfg
10566 (
10567 RgSchCellCb             *cell,
10568 RgrCellCfg              *cfg,
10569 RgSchErrInfo            *err
10570 )
10571 #else
10572 PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
10573 RgSchCellCb             *cell;
10574 RgrCellCfg              *cfg;
10575 RgSchErrInfo            *err;
10576 #endif
10577 {
10578    S16                 ret;
10579    RgSchCmnCell        *cellSch;
10580    U8                   cp;
10581    U8                   numPdcchSym;
10582    U8                   noSymPerSlot;
10583    U8                   cfi;  
10584    U8                   cfiIdx;
10585
10586    TRC2(rgSCHCmnDlRgrCellCfg);
10587
10588    cellSch = RG_SCH_CMN_GET_CELL(cell);
10589
10590    /* Initialize the parameters with the ones received in the */
10591    /* configuration.                                          */
10592
10593    /* Added matrix 'rgRaPrmblToRaFrmTbl' for computation of RA
10594     * sub-frames from preamble format */
10595    cellSch->dl.numRaSubFrms = rgRaPrmblToRaFrmTbl[cell->rachCfg.preambleFormat];
10596
10597    /*[ccpu00138532]-ADD-fill the Msg4 Harq data */
10598    cell->dlHqCfg.maxMsg4HqTx = cfg->dlHqCfg.maxMsg4HqTx;                                                
10599    
10600    /* Msg4 Tx Delay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  + 
10601                        3 TTI (MAX L1+L2 processing delay at the UE) */
10602    cellSch->dl.msg4TxDelay = (cfg->dlHqCfg.maxMsg4HqTx-1) *
10603                                  rgSchCmnHarqRtt[7] + 3; 
10604
10605    if (cell->bwCfg.dlTotalBw <= 10)
10606    {
10607       cfiIdx = 1;
10608       numPdcchSym = 2;
10609    }
10610    else
10611    {
10612       cfiIdx = 0;
10613       numPdcchSym = 1;
10614    }
10615
10616    if (cell->isCpDlExtend == TRUE)
10617    {
10618       cp = RG_SCH_CMN_EXT_CP;
10619       noSymPerSlot = 6;
10620    }
10621    else
10622    {
10623       cp = RG_SCH_CMN_NOR_CP;
10624       noSymPerSlot = 7;
10625    }
10626
10627    /* Initializing the cqiToEffTbl and cqiToTbsTbl for every CFI value */
10628    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, cfiIdx++)
10629    {   
10630       cellSch->dl.cqiToTbsTbl[0][cfi]   = rgSchCmnCqiToTbs[0][cp][cfiIdx];
10631 #ifdef EMTC_ENABLE      
10632       cellSch->dl.emtcCqiToTbsTbl[0][cfi]   = rgSchEmtcCmnCqiToTbs[0][cp][cfiIdx];
10633 #endif      
10634       cellSch->dl.cqiToEffTbl[0][cfi]   = rgSchCmnEffTbl[0][cp][rgSchCmnAntIdx\
10635                                                  [cell->numTxAntPorts]][cfiIdx];
10636       cellSch->dl.cqiToTbsTbl[1][cfi]   = rgSchCmnCqiToTbs[1][cp][cfiIdx];
10637 #ifdef EMTC_ENABLE      
10638       cellSch->dl.emtcCqiToTbsTbl[1][cfi]   = rgSchEmtcCmnCqiToTbs[1][cp][cfiIdx];
10639 #endif      
10640       cellSch->dl.cqiToEffTbl[1][cfi]   = rgSchCmnEffTbl[1][cp][rgSchCmnAntIdx\
10641                                                  [cell->numTxAntPorts]][cfiIdx];
10642    }
10643
10644    /* Initializing the values of CFI parameters */
10645    if(cell->dynCfiCb.isDynCfiEnb)
10646    {   
10647       /* If DCFI is enabled, current CFI value will start from 1 */
10648       cellSch->dl.currCfi = cellSch->dl.newCfi = 1;
10649    }
10650    else
10651    {
10652       /* If DCFI is disabled, current CFI value is set as default CFI value */
10653       cellSch->dl.currCfi = cellSch->cfiCfg.cfi;
10654       cellSch->dl.newCfi = cellSch->dl.currCfi;
10655    }   
10656
10657    /* Include CRS REs while calculating Efficiency
10658     * The number of Resource Elements occupied by CRS depends on Number of
10659     * Antenna Ports. Please refer to Section 6.10.1 of 3GPP TS 36.211 V8.8.0.
10660     * Also, please refer to Figures 6.10.1.2-1 and 6.10.1.2-2 for diagrammatic
10661     * details of the same. Please note that PDCCH overlap symbols would not
10662     * considered in CRS REs deduction */
10663    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, numPdcchSym++)
10664    {
10665        cellSch->dl.noResPerRb[cfi]    = (((noSymPerSlot * RG_SCH_CMN_NUM_SLOTS_PER_SF)
10666             - numPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - rgSchCmnNumResForCrs[cell->numTxAntPorts];
10667    }           
10668
10669    if (cfg->maxDlBwPerUe == 0)
10670    {
10671       cellSch->dl.maxDlBwPerUe = RG_SCH_CMN_MAX_DL_BW_PERUE;
10672    }
10673    else
10674    {
10675       cellSch->dl.maxDlBwPerUe = cfg->maxDlBwPerUe;
10676    }
10677    if (cfg->maxDlRetxBw == 0)
10678    {
10679       cellSch->dl.maxDlRetxBw = RG_SCH_CMN_MAX_DL_RETX_BW;
10680    }
10681    else
10682    {
10683       cellSch->dl.maxDlRetxBw = cfg->maxDlRetxBw;
10684    }
10685    
10686    /* Fix: MUE_PERTTI_DL*/
10687    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10688    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10689    if (cfg->maxUePerDlSf == 0)
10690    {
10691       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10692    }
10693    /* Fix: MUE_PERTTI_DL syed validating Cell Configuration */
10694    if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
10695    {
10696       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
10697             "FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
10698             cellSch->dl.maxUePerDlSf,
10699             cellSch->dl.maxUeNewTxPerTti);
10700       RETVALUE(RFAILED);
10701    }
10702    /*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
10703    if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
10704    {
10705       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid configuration !: "
10706             "maxCcchPerDlSf %u > maxUePerDlSf %u",
10707             cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
10708
10709       RETVALUE(RFAILED);
10710    }
10711    else if (!cfg->maxCcchPerDlSf)
10712    {
10713       /* ccpu00143032: maxCcchPerDlSf 0 means not configured by application
10714        * hence setting to maxUePerDlSf. If maxCcchPerDlSf is 0 then scheduler
10715        * does't consider CCCH allocation in MaxUePerTti cap. Hence more than
10716        * 4UEs getting schduled & SCH expects >16 Hq PDUs in a TTI which causes
10717        * FLE crash in PHY as PHY has limit of 16 max*/
10718       cellSch->dl.maxCcchPerDlSf = cfg->maxUePerDlSf;
10719    }
10720    else
10721    {
10722       cellSch->dl.maxCcchPerDlSf = cfg->maxCcchPerDlSf;
10723    }
10724
10725
10726    if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
10727    {
10728       RETVALUE(RFAILED);
10729    }
10730    cmLListInit(&cellSch->dl.msg4RetxLst);
10731 #ifdef RGR_V1
10732    cmLListInit(&cellSch->dl.ccchSduRetxLst);
10733 #endif
10734
10735 #ifdef RG_PHASE2_SCHED
10736    if (cellSch->apisDlfs == NULLP) /* DFLS specific initialization */
10737    {
10738       cellSch->apisDlfs = &rgSchDlfsSchdTbl[cfg->dlfsSchdType];
10739    }
10740    if (cfg->dlfsCfg.isDlFreqSel)
10741    {
10742       ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
10743       if (ret != ROK)
10744       {
10745          RETVALUE(RFAILED);
10746       }
10747    }
10748    cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
10749 #endif
10750
10751    /* Power related configuration */
10752    ret = rgSCHPwrCellCfg(cell, cfg);
10753    if (ret != ROK)
10754    {
10755       RETVALUE(RFAILED);
10756    }
10757
10758    cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset; 
10759    cellSch->dl.pcchTxPwrOffset = cfg->pcchTxPwrOffset; 
10760    cellSch->dl.rarTxPwrOffset  = cfg->rarTxPwrOffset; 
10761    cellSch->dl.phichTxPwrOffset  = cfg->phichTxPwrOffset; 
10762    RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
10763    RETVALUE(ROK);
10764 }
10765 #endif /* LTE_TDD */
10766
10767 /***********************************************************
10768  *
10769  *     Func : rgSCHCmnUlCalcReqRbCeil
10770  *
10771  *     Desc : Calculate RB required to satisfy 'bytes' for
10772  *            a given CQI.
10773  *            Returns number of RBs such that requirement
10774  *            is necessarily satisfied (does a 'ceiling'
10775  *            computation).
10776  *
10777  *     Ret  : Required RBs (U8)
10778  *
10779  *     Notes:
10780  *
10781  *     File :
10782  *
10783  **********************************************************/
10784 #ifdef ANSI
10785 PUBLIC U8 rgSCHCmnUlCalcReqRbCeil
10786 (
10787 U32            bytes,
10788 U8             cqi,
10789 RgSchCmnUlCell *cellUl
10790 )
10791 #else
10792 PUBLIC U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
10793 U32            bytes;
10794 U8             cqi;
10795 RgSchCmnUlCell *cellUl;
10796 #endif
10797 {
10798    U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
10799    TRC2(rgSCHCmnUlCalcReqRbCeil);
10800    RETVALUE((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
10801 }
10802
10803 /***********************************************************
10804  *
10805  *     Func : rgSCHCmnPrecompMsg3Vars
10806  *
10807  *     Desc : Precomputes the following for msg3 allocation:
10808  *            1. numSb and Imcs for msg size A
10809  *            2. numSb and Imcs otherwise
10810  *
10811  *     Ret  :
10812  *
10813  *     Notes: The corresponding vars in cellUl struct is filled
10814  *            up
10815  *
10816  *     File :
10817  *
10818  **********************************************************/
10819 #ifdef ANSI
10820 PRIVATE S16 rgSCHCmnPrecompMsg3Vars
10821 (
10822 RgSchCmnUlCell *cellUl,
10823 U8           ccchCqi,
10824 U16          msgSzA,
10825 U8           sbSize,
10826 Bool         isEcp
10827 )
10828 #else
10829 PRIVATE S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
10830 RgSchCmnUlCell *cellUl;
10831 U8           ccchCqi;
10832 U16          msgSzA;
10833 U8           sbSize;
10834 Bool         isEcp;
10835 #endif
10836 {
10837    U8 numSb;
10838    U8 ccchTbs;
10839    U8 ccchMcs;
10840    U8   numRb = 0;
10841    U8   iTbs = 0;
10842    U16  msg3GrntSz = 0;
10843
10844    TRC2(rgSCHCmnPrecompMsg3Vars);
10845
10846    if (ccchCqi > cellUl->max16qamCqi)
10847    {
10848       ccchCqi = cellUl->max16qamCqi;
10849    }
10850 /* #ifndef RG_SCH_CMN_EXP_CP_SUP For ECP Pick the index 1 */
10851    /* Fix */
10852    ccchTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
10853    ccchMcs = rgSCHCmnUlGetIMcsFrmITbs(ccchTbs, CM_LTE_UE_CAT_1);
10854    
10855    /* MCS should fit in 4 bits in RAR */
10856    if (ccchMcs >= 15)
10857    {
10858       ccchMcs = 15;
10859    }
10860    
10861    /* Limit the ccchMcs to 15 as it
10862     * can be inferred from 36.213, section 6.2 that msg3 imcs
10863     * field is 4 bits.
10864     * Since, UE doesn't exist right now, we use CAT_1 for ue
10865     * category*/
10866    while((ccchMcs = (rgSCHCmnUlGetIMcsFrmITbs(
10867                       rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
10868                     ) >
10869                  RG_SCH_CMN_MAX_MSG3_IMCS)
10870    {
10871       ccchCqi--;
10872    }
10873    
10874    iTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
10875    
10876    if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
10877    {
10878       RETVALUE(RFAILED);
10879    }
10880    numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(msgSzA, ccchCqi, cellUl), sbSize);
10881    
10882    numRb   = numSb * sbSize;
10883    msg3GrntSz = 8 * msgSzA;
10884
10885    while( (rgTbSzTbl[0][iTbs][numRb - 1]) < msg3GrntSz)
10886    {
10887       ++numSb;
10888       numRb   = numSb * sbSize;
10889    }
10890    while (rgSchCmnMult235Tbl[numSb].match != numSb)
10891    {
10892       ++numSb;
10893    }
10894    /* Reversed(Corrected) the assignment for preamble-GrpA
10895     * Refer- TG36.321- section- 5.1.2*/
10896    cellUl->ra.prmblBNumSb = numSb;
10897    cellUl->ra.prmblBIMcs  = ccchMcs;
10898    numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(RGSCH_MIN_MSG3_GRNT_SZ, \
10899                       ccchCqi, cellUl),
10900          sbSize);
10901
10902    numRb   = numSb * sbSize;
10903    msg3GrntSz = 8 * RGSCH_MIN_MSG3_GRNT_SZ;
10904    while( (rgTbSzTbl[0][iTbs][numRb - 1]) < msg3GrntSz)
10905    {
10906       ++numSb;
10907       numRb   = numSb * sbSize;
10908    }
10909    while (rgSchCmnMult235Tbl[numSb].match != numSb)
10910    {
10911       ++numSb;
10912    }
10913    /* Reversed(Corrected) the assignment for preamble-GrpA
10914     * Refer- TG36.321- section- 5.1.2*/
10915    cellUl->ra.prmblANumSb = numSb;
10916    cellUl->ra.prmblAIMcs  = ccchMcs;
10917    RETVALUE(ROK);
10918 }
10919
10920 PUBLIC U32 gPrntPucchDet=0;
10921
10922 #ifdef LTE_TDD
10923 /***********************************************************
10924  *
10925  *     Func : rgSCHCmnUlCalcAvailBw
10926  *
10927  *     Desc : Calculates bandwidth available for PUSCH scheduling.
10928  *
10929  *     Ret  : S16 (ROK/RFAILED)
10930  *
10931  *     Notes:
10932  *
10933  *     File :
10934  *
10935  **********************************************************/
10936 #ifdef ANSI
10937 PRIVATE S16 rgSCHCmnUlCalcAvailBw
10938 (
10939 RgSchCellCb    *cell,
10940 RgrCellCfg     *cellCfg,
10941 U8              cfi,
10942 U8             *rbStartRef,
10943 U8             *bwAvailRef
10944 )
10945 #else
10946 PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
10947 RgSchCellCb   *cell;
10948 RgrCellCfg    *cellCfg;
10949 U8             cfi;  
10950 U8            *rbStartRef;
10951 U8            *bwAvailRef;
10952 #endif
10953 {
10954    U8  c        = 3;
10955    U8  ulBw     = cell->bwCfg.ulTotalBw;
10956    U8  n2Rb     = cell->pucchCfg.resourceSize;
10957    U8  pucchDeltaShft = cell->pucchCfg.deltaShift;
10958    U16 n1Pucch  = cell->pucchCfg.n1PucchAn;
10959    U8  n1Cs     = cell->pucchCfg.cyclicShift;
10960
10961    U8  n1PerRb;
10962    U8  totalCce;
10963    U16 n1Max;
10964    U8  n1Rb;
10965    U32 mixedRb;
10966    U8  exclRb; /* RBs to exclude */
10967    U8  n1RbPart;
10968    U8  puschRbStart;
10969    /* To avoid PUCCH and PUSCH collision issue */
10970    U8  P;
10971    U8  n1PlusOne;
10972    U8  mi;
10973    /* Maximum value of M as per Table 10.1-1 */
10974    U8  M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
10975
10976    TRC2(rgSCHCmnUlCalcAvailBw);
10977
10978    if (cell->isCpUlExtend)
10979    {
10980       c = 2;
10981    }
10982
10983    n1PerRb  = c * 12 / pucchDeltaShft; /* 12/18/36 */
10984
10985    /* Considering the max no. of CCEs for PUSCH BW calculation 
10986     * based on min mi value */
10987    if (cell->ulDlCfgIdx == 0 || cell->ulDlCfgIdx == 6)
10988    {
10989       mi = 1;
10990    }
10991    else
10992    { 
10993       mi = 0;
10994    }
10995    
10996    totalCce = cell->dynCfiCb.cfi2NCceTbl[mi][cfi];
10997
10998    P        = rgSCHCmnGetPValFrmCCE(cell, totalCce-1);
10999    n1PlusOne = cell->rgSchTddNpValTbl[P + 1];
11000    n1Max    = (M[cell->ulDlCfgIdx] - 1)*n1PlusOne + (totalCce-1) + n1Pucch;
11001
11002    /* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in 
11003     * TS 36.211  */
11004    n1RbPart = (c*n1Cs)/pucchDeltaShft;
11005    n1Rb = (n1Max - n1RbPart)/ n1PerRb;
11006    mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
11007
11008    /* get the total Number of RB's to be excluded for PUSCH */
11009    /* ccpu00137339 */
11010    if(n1Pucch < n1RbPart)
11011    {
11012       exclRb = n2Rb;
11013    }
11014    else
11015    {
11016       exclRb = n2Rb + mixedRb + n1Rb; /* RBs to exclude */
11017    }
11018    puschRbStart = exclRb/2 + 1; 
11019
11020    /* Num of PUCCH RBs = puschRbStart*2 */
11021    if (puschRbStart * 2 >= ulBw)
11022    {
11023       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
11024       RETVALUE(RFAILED);
11025    }
11026
11027    *rbStartRef = puschRbStart;
11028    *bwAvailRef = ulBw -  puschRbStart * 2;
11029  
11030    if(cell->pucchCfg.maxPucchRb !=0 && 
11031          (puschRbStart * 2 > cell->pucchCfg.maxPucchRb))
11032    {
11033       cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
11034    }
11035     
11036    RETVALUE(ROK);
11037 }
11038 #else
11039
11040 /***********************************************************
11041  *
11042  *     Func : rgSCHCmnUlCalcAvailBw
11043  *
11044  *     Desc : Calculates bandwidth available for PUSCH scheduling.
11045  *
11046  *     Ret  : S16 (ROK/RFAILED)
11047  *
11048  *     Notes:
11049  *
11050  *     File :
11051  *
11052  **********************************************************/
11053 #ifdef ANSI
11054 PRIVATE S16 rgSCHCmnUlCalcAvailBw
11055 (
11056 RgSchCellCb    *cell,
11057 RgrCellCfg     *cellCfg,
11058 U8              cfi,
11059 U8             *rbStartRef,
11060 U8             *bwAvailRef
11061 )
11062 #else
11063 PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
11064 RgSchCellCb   *cell;
11065 RgrCellCfg    *cellCfg;
11066 U8             cfi;
11067 U8            *rbStartRef;
11068 U8            *bwAvailRef;
11069 #endif
11070 {
11071    U8  c        = 3;
11072    U8  ulBw     = cell->bwCfg.ulTotalBw;
11073    U8  n2Rb     = cell->pucchCfg.resourceSize;
11074    U8  pucchDeltaShft = cell->pucchCfg.deltaShift;
11075    U16 n1Pucch  = cell->pucchCfg.n1PucchAn;
11076    U8  n1Cs     = cell->pucchCfg.cyclicShift;
11077    U8  n1PerRb;
11078    U8  totalCce;
11079    U16 n1Max;
11080    U8  n1Rb;
11081    U32 mixedRb;
11082    U8  exclRb; /* RBs to exclude */
11083    U8  n1RbPart;
11084    U8  puschRbStart;
11085 #ifdef LTE_ADV
11086    U16 numOfN3PucchRb;
11087    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);  
11088 #endif
11089    
11090    TRC2(rgSCHCmnUlCalcAvailBw);
11091
11092    if (cell->isCpUlExtend)
11093    {
11094       c = 2;
11095    }
11096
11097    n1PerRb  = c * 12 / pucchDeltaShft; /* 12/18/36 */
11098
11099    totalCce = cell->dynCfiCb.cfi2NCceTbl[0][cfi];
11100
11101    n1Max    = n1Pucch + totalCce-1;
11102
11103    /* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in 
11104     * TS 36.211  */
11105    n1RbPart = (c*n1Cs)/pucchDeltaShft;
11106    n1Rb = (U8)((n1Max - n1RbPart) / n1PerRb);
11107    mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
11108
11109    /* get the total Number of RB's to be excluded for PUSCH */
11110    /* ccpu00137339 */
11111    if(n1Pucch < n1RbPart)
11112    {
11113       exclRb = n2Rb;
11114    }
11115    else
11116    {
11117       exclRb = n2Rb + mixedRb + n1Rb; /* RBs to exclude */
11118    }
11119    /*Support for PUCCH Format 3*/
11120 #ifdef LTE_ADV
11121    if (cell->isPucchFormat3Sptd)
11122    {
11123       numOfN3PucchRb = RGSCH_CEIL(cellSch->dl.maxUePerDlSf,5); 
11124       exclRb = exclRb + numOfN3PucchRb;
11125    }
11126 #endif
11127    puschRbStart = exclRb/2 + 1;
11128
11129    if(gPrntPucchDet)
11130    {
11131 #ifndef ALIGN_64BIT
11132            printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
11133         cell->crntTime.sfn, cell->crntTime.subframe, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
11134 #else
11135            printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
11136         cell->crntTime.sfn, cell->crntTime.subframe, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
11137 #endif
11138    }
11139
11140    if (puschRbStart*2 >= ulBw)
11141    {
11142       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
11143       RETVALUE(RFAILED);
11144    }
11145
11146    *rbStartRef = puschRbStart;
11147    *bwAvailRef = ulBw - puschRbStart * 2;
11148
11149    if(cell->pucchCfg.maxPucchRb !=0 && 
11150       (puschRbStart * 2 > cell->pucchCfg.maxPucchRb))
11151    {
11152       cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
11153    }
11154    
11155    RETVALUE(ROK);
11156 }
11157 #endif
11158
11159
11160
11161 /***********************************************************
11162  *
11163  *     Func : rgSCHCmnUlCellInit
11164  *
11165  *     Desc : Uplink scheduler initialisation for cell.
11166  *
11167  *     Ret  : S16
11168  *
11169  *     Notes:
11170  *
11171  *     File :
11172  *
11173  **********************************************************/
11174 #ifdef ANSI
11175 PRIVATE S16 rgSCHCmnUlCellInit
11176 (
11177  RgSchCellCb  *cell,
11178  RgrCellCfg   *cellCfg
11179  )
11180 #else
11181 PRIVATE S16 rgSCHCmnUlCellInit(cell, cellCfg)
11182    RgSchCellCb *cell;
11183    RgrCellCfg  *cellCfg;
11184 #endif
11185 {
11186    S16            ret;
11187    RgSchCmnUlCell *cellUl      = RG_SCH_CMN_GET_UL_CELL(cell);
11188    U8             maxUePerUlSf = cellCfg->maxUePerUlSf;
11189 #ifdef RGR_V1
11190    /* Added configuration for maximum number of MSG3s */
11191    U8             maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
11192 #endif
11193    U8             maxUlBwPerUe = cellCfg->maxUlBwPerUe;
11194    U8             sbSize       = cellCfg->puschSubBand.size;
11195    U8             i;
11196    U8             rbStart;
11197    U8             bwAvail;
11198    U8             cfi;  
11199    U8             maxSbPerUe;
11200    U8             numSb;
11201 #ifdef LTE_TDD
11202    U16            ulDlCfgIdx = cell->ulDlCfgIdx;
11203    /* [ccpu00127294]-MOD-Change the max Ul subfrms size in TDD */
11204    U8             maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx]; 
11205    U8             ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL  * 2 */
11206    U8             maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
11207                                            [RGSCH_NUM_SUB_FRAMES-1];
11208    U16             subfrm;
11209    S8             dlIdx;
11210 #else
11211    U8             maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
11212 #endif
11213 #ifdef LTE_L2_MEAS
11214    U8             idx;
11215 #endif
11216    U8  iTbs;
11217 #if (defined(LTE_L2_MEAS) )
11218    Inst           inst         = cell->instIdx;
11219 #endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
11220    RgSchCmnCell      *cellSch =  (RgSchCmnCell *)(cell->sc.sch);
11221    
11222    TRC2(rgSCHCmnUlCellInit);
11223
11224    cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
11225    if (maxUePerUlSf == 0)
11226    {
11227       maxUePerUlSf = RG_SCH_CMN_MAX_UE_PER_UL_SF;
11228    }
11229 #ifdef RGR_V1
11230    if (maxMsg3PerUlSf == 0)
11231    {
11232       maxMsg3PerUlSf = RG_SCH_CMN_MAX_MSG3_PER_UL_SF;
11233    }
11234    /*  fixed the problem while sending raRsp 
11235     * if maxMsg3PerUlSf is greater than 
11236     * RGSCH_MAX_RNTI_PER_RARNTI 
11237     * */
11238    if(maxMsg3PerUlSf > RGSCH_MAX_RNTI_PER_RARNTI)
11239    {
11240       maxMsg3PerUlSf = RGSCH_MAX_RNTI_PER_RARNTI; 
11241    } 
11242
11243    if(maxMsg3PerUlSf > maxUePerUlSf)
11244    {
11245       maxMsg3PerUlSf =  maxUePerUlSf;   
11246    }
11247    
11248    /*cellUl->maxAllocPerUlSf = maxUePerUlSf + maxMsg3PerUlSf;*/
11249    /*Max MSG3 should be a subset of Max UEs*/
11250    cellUl->maxAllocPerUlSf = maxUePerUlSf;
11251    cellUl->maxMsg3PerUlSf = maxMsg3PerUlSf;
11252 #else
11253    cellUl->maxAllocPerUlSf = maxUePerUlSf;
11254 #endif
11255    /* Fix: MUE_PERTTI_UL syed validating Cell Configuration */
11256    if (cellUl->maxAllocPerUlSf < cellUl->maxUeNewTxPerTti)
11257    {
11258       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
11259             "FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
11260             cellUl->maxAllocPerUlSf,
11261             cellUl->maxUeNewTxPerTti);
11262       RETVALUE(RFAILED);
11263    }
11264
11265 #ifdef LTE_L2_MEAS
11266 #ifdef LTE_TDD
11267    for(idx = 0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
11268 #else
11269    for(idx = 0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
11270 #endif
11271    {
11272
11273       ret = rgSCHUtlAllocSBuf(inst,  (Data **)&(cell->sfAllocArr[idx].
11274               ulUeInfo.ulAllocInfo), (cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc)));
11275       if (ret != ROK)
11276       {
11277             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
11278             RETVALUE(ret);
11279       }
11280    }
11281 #endif
11282    if (maxUlBwPerUe == 0)
11283    {
11284       /* ccpu00139362- Setting to configured UL BW instead of MAX BW(100)*/
11285       maxUlBwPerUe = cell->bwCfg.ulTotalBw;
11286    }
11287    cellUl->maxUlBwPerUe = maxUlBwPerUe;
11288
11289    /* FOR RG_SCH_CMN_EXT_CP_SUP */
11290    if (!cellCfg->isCpUlExtend)
11291    {
11292       cellUl->ulNumRePerRb = 12 * (14 - RGSCH_UL_SYM_DMRS_SRS);
11293    }
11294    else
11295    {
11296       cellUl->ulNumRePerRb = 12 * (12 - RGSCH_UL_SYM_DMRS_SRS);
11297    }
11298
11299    if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
11300    {
11301       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
11302       RETVALUE(RFAILED);
11303    }
11304         //Setting the subband size to 4 which is size of VRBG in 5GTF
11305 #ifdef RG_5GTF
11306         sbSize = MAX_5GTF_VRBG_SIZE;
11307 #endif
11308         
11309    maxSbPerUe = maxUlBwPerUe / sbSize;
11310    if (maxSbPerUe == 0)
11311    {
11312       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
11313          "maxUlBwPerUe/sbSize is zero");
11314       RETVALUE(RFAILED);
11315    }
11316    cellUl->maxSbPerUe = rgSchCmnMult235Tbl[maxSbPerUe].prvMatch;
11317
11318    /* CQI related updations */
11319    if ((!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->ulCmnCodeRate.ccchCqi))
11320          || (!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->trgUlCqi.trgCqi)))
11321    {
11322       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
11323          "Invalid cqi");
11324       RETVALUE(RFAILED);
11325    }
11326    cellUl->dfltUlCqi = cellCfg->ulCmnCodeRate.ccchCqi;
11327
11328    /* Changed the logic to determine maxUlCqi.
11329     * For a 16qam UE, maxUlCqi is the CQI Index at which
11330     * efficiency is as close as possible to RG_SCH_MAX_CODE_RATE_16QAM
11331     * Refer to 36.213-8.6.1 */
11332     for (i = RG_SCH_CMN_UL_NUM_CQI - 1;i > 0; --i)
11333    {
11334       RLOG_ARG2(L_INFO,DBG_CELLID,cell->cellId,
11335             "CQI %u:iTbs %u",
11336             i, 
11337             rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i]);
11338 #ifdef MAC_SCH_STATS
11339       /* ccpu00128489 ADD Update mcs in hqFailStats here instead of at CRC 
11340        * since CQI to MCS mapping does not change. The only exception is for 
11341        * ITBS = 19 where the MCS can be 20 or 21 based on the UE cat. We 
11342        * choose 20, instead of 21, ie UE_CAT_3 */
11343       iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
11344       RG_SCH_CMN_UL_TBS_TO_MCS(iTbs, hqFailStats.ulCqiStat[i - 1].mcs);
11345 #endif
11346    }
11347    for (i = RG_SCH_CMN_UL_NUM_CQI - 1; i != 0; --i)
11348    {
11349       /* Fix for ccpu00123912*/
11350       iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
11351       if (iTbs <= RGSCH_UL_16QAM_MAX_ITBS) /* corresponds to 16QAM */
11352       {
11353          RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,
11354                          "16 QAM CQI %u", i);
11355          cellUl->max16qamCqi = i;
11356          break;
11357       }
11358    }
11359
11360 #ifdef EMTC_ENABLE
11361    /* Precompute useful values for RA msg3 */
11362    ret = rgSCHCmnPrecompEmtcMsg3Vars(cellUl, cellCfg->ulCmnCodeRate.ccchCqi,
11363          cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
11364    if (ret != ROK)
11365    {
11366       RETVALUE(ret);
11367    }
11368 #endif   
11369
11370    /* Precompute useful values for RA msg3 */
11371    ret = rgSCHCmnPrecompMsg3Vars(cellUl, cellCfg->ulCmnCodeRate.ccchCqi,
11372          cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
11373    if (ret != ROK)
11374    {
11375       RETVALUE(ret);
11376    }
11377
11378    cellUl->sbSize  = sbSize;
11379    
11380 #ifdef LTE_TDD  
11381    cellUl->numUlSubfrms = maxSubfrms;
11382
11383    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cellUl->ulSfArr,
11384             cellUl->numUlSubfrms * sizeof(RgSchUlSf));
11385
11386    if (ret != ROK)
11387    {
11388       cellUl->numUlSubfrms = 0;
11389       RETVALUE(ret);
11390    }
11391
11392    /* store the DL subframe corresponding to the PUSCH offset
11393     * in their respective UL subframe */
11394    for(i=0; i < RGSCH_NUM_SUB_FRAMES; i++)
11395    {
11396       if(rgSchTddPuschTxKTbl[ulDlCfgIdx][i] != 0)
11397       {
11398          subfrm = (i + rgSchTddPuschTxKTbl[ulDlCfgIdx][i]) % \
11399                                  RGSCH_NUM_SUB_FRAMES;
11400          subfrm = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subfrm]-1;
11401          dlIdx = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][i]-1;
11402          RGSCH_ARRAY_BOUND_CHECK( cell->instIdx, ulToDlMap, subfrm);
11403          ulToDlMap[subfrm] = dlIdx;
11404       }
11405    }
11406    /* Copy the information in the remaining UL subframes based
11407     * on number of HARQ processes */
11408    for(i=maxUlsubfrms; i < maxSubfrms; i++)
11409    {
11410       subfrm = i-maxUlsubfrms;
11411       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, ulToDlMap, i);
11412       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, ulToDlMap, subfrm)
11413       ulToDlMap[i] = ulToDlMap[subfrm];
11414    }
11415 #endif
11416
11417    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++)
11418    {
11419 #ifdef LTE_TDD        
11420       ret = rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, &rbStart, &bwAvail); 
11421 #else
11422       ret = rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, &rbStart, &bwAvail); 
11423 #endif
11424       if (ret != ROK)
11425       {
11426          RETVALUE(ret);
11427       }
11428
11429       if (cfi == 1)
11430       {
11431          cell->ulAvailBw = bwAvail;
11432       }
11433
11434       numSb = bwAvail/sbSize; 
11435
11436       cell->dynCfiCb.bwInfo[cfi].startRb  = rbStart;
11437       cell->dynCfiCb.bwInfo[cfi].numSb    = numSb;
11438    }
11439
11440    if(0 == cell->dynCfiCb.maxCfi)
11441    {
11442       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId, 
11443                "Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
11444                cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi, 
11445                cell->pucchCfg.maxPucchRb);
11446             
11447       RETVALUE(RFAILED);
11448    }
11449
11450    /* DMRS values */
11451    cellUl->dmrsArrSize = cell->dynCfiCb.bwInfo[1].numSb;
11452    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cellUl->dmrsArr,
11453          cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11454    if (ret != ROK)
11455    {
11456       RETVALUE(ret);
11457    }
11458    for (i = 0; i < cellUl->dmrsArrSize; ++i)
11459    {
11460       cellUl->dmrsArr[i] = cellCfg->puschSubBand.dmrs[i];
11461    }
11462  
11463    /* Init subframes */
11464    for (i = 0; i < maxSubfrms; ++i)
11465    {
11466       ret = rgSCHUtlUlSfInit(cell, &cellUl->ulSfArr[i], i,
11467                              cellUl->maxAllocPerUlSf);
11468       if (ret != ROK)
11469       {
11470          for (; i != 0; --i)
11471          {
11472             rgSCHUtlUlSfDeinit(cell, &cellUl->ulSfArr[i-1]);
11473          }
11474          /* ccpu00117052 - MOD - Passing double pointer
11475             for proper NULLP assignment*/
11476          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(cellUl->dmrsArr)),
11477                cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11478 #ifdef LTE_TDD
11479          /* ccpu00117052 - MOD - Passing double pointer
11480             for proper NULLP assignment*/
11481          rgSCHUtlFreeSBuf(cell->instIdx,
11482             (Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
11483 #endif
11484          RETVALUE(ret);
11485       }
11486    }
11487    RG_SCH_RESET_HCSG_UL_PRB_CNTR(cellUl);
11488    RETVALUE(ROK);
11489 }
11490
11491 /**
11492  * @brief Scheduler processing on cell configuration.
11493  *
11494  * @details
11495  *
11496  *     Function : rgSCHCmnRgrCellCfg
11497  *
11498  *     This function does requisite initialisation
11499  *     and setup for scheduler1 when a cell is
11500  *     configured.
11501  *
11502  *  @param[in]  RgSchCellCb   *cell
11503  *  @param[in]  RgrCellCfg    *cellCfg
11504  *  @param[out] RgSchErrInfo  *err
11505  *  @return  S16
11506  *      -# ROK
11507  *      -# RFAILED
11508  **/
11509 #ifdef ANSI
11510 PUBLIC S16 rgSCHCmnRgrCellCfg
11511 (
11512 RgSchCellCb   *cell,
11513 RgrCellCfg    *cellCfg,
11514 RgSchErrInfo  *err
11515 )
11516 #else
11517 PUBLIC S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
11518 RgSchCellCb   *cell;
11519 RgrCellCfg    *cellCfg;
11520 RgSchErrInfo  *err;
11521 #endif
11522 {
11523    S16       ret;
11524    RgSchCmnCell *cellSch;
11525    TRC2(rgSCHCmnRgrCellCfg);
11526
11527    /* As part of RGR cell configuration, validate the CRGCellCfg
11528     * There is no trigger for crgCellCfg from SC1 */
11529    /* Removed failure check for Extended CP */
11530
11531    if (((ret = rgSCHUtlAllocSBuf(cell->instIdx,
11532       (Data**)&(cell->sc.sch), (sizeof(RgSchCmnCell)))) != ROK))
11533    {
11534       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  
11535          "Memory allocation FAILED");
11536       err->errCause = RGSCHERR_SCH_CFG;
11537       RETVALUE(ret);
11538    }
11539    cellSch = (RgSchCmnCell *)(cell->sc.sch);
11540    cellSch->cfiCfg = cellCfg->cfiCfg;
11541    cellSch->trgUlCqi.trgCqi = cellCfg->trgUlCqi.trgCqi;
11542    /* Initialize the scheduler refresh timer queues */
11543    cellSch->tmrTqCp.nxtEnt = 0;
11544    cellSch->tmrTqCp.tmrLen = RG_SCH_CMN_NUM_REFRESH_Q;
11545
11546    /* RACHO Intialize the RACH ded Preamble Information */
11547    rgSCHCmnCfgRachDedPrm(cell);
11548 #ifdef LTE_TDD
11549    /* Initialize 'Np' value for each 'p' used for
11550     * HARQ ACK/NACK reception */
11551    rgSCHCmnDlNpValInit(cell);
11552 #endif
11553
11554    /* Initialize 'Np' value for each 'p' used for
11555     * HARQ ACK/NACK reception */
11556 #ifdef LTE_TDD
11557    rgSCHCmnDlNpValInit(cell);
11558 #endif
11559
11560    /* Now perform uplink related initializations  */
11561    ret = rgSCHCmnUlCellInit(cell, cellCfg);
11562    if (ret != ROK)
11563    {
11564       /* There is no downlink deinit to be performed */
11565       err->errCause = RGSCHERR_SCH_CFG;
11566       RETVALUE(ret);
11567    }
11568    ret = rgSCHCmnDlRgrCellCfg(cell, cellCfg, err);
11569    if (ret != ROK)
11570    {
11571       err->errCause = RGSCHERR_SCH_CFG;
11572       RETVALUE(ret);
11573    }
11574    /* DL scheduler has no initializations to make */
11575    /* As of now DL scheduler always returns ROK   */
11576
11577    rgSCHCmnGetDciFrmtSizes(cell);
11578    rgSCHCmnGetCqiDciFrmt2AggrLvl(cell);
11579 #ifdef EMTC_ENABLE 
11580    rgSCHCmnGetEmtcDciFrmtSizes(cell);
11581    rgSCHCmnGetCqiEmtcDciFrmt2AggrLvl(cell);
11582 #endif /* EMTC_ENABLE  */
11583
11584 #ifdef EMTC_ENABLE   
11585    if(TRUE == cellCfg->emtcEnable)
11586    {
11587       cellSch->apisEmtcUl = &rgSchEmtcUlSchdTbl[0];
11588       ret = cellSch->apisEmtcUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
11589       if (ret != ROK)
11590       {
11591          RETVALUE(ret);
11592       }
11593    }
11594 #endif
11595    cellSch->apisUl = &rgSchUlSchdTbl[RG_SCH_CMN_GET_UL_SCHED_TYPE(cell)];
11596    ret = cellSch->apisUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
11597    if (ret != ROK)
11598    {
11599       RETVALUE(ret);
11600    }
11601 #ifdef EMTC_ENABLE   
11602    if(TRUE == cellCfg->emtcEnable)
11603    {
11604       cellSch->apisEmtcDl = &rgSchEmtcDlSchdTbl[0];
11605       ret = cellSch->apisEmtcDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
11606       if (ret != ROK)
11607       {
11608          RETVALUE(ret);
11609       }
11610    }
11611 #endif
11612    cellSch->apisDl = &rgSchDlSchdTbl[RG_SCH_CMN_GET_DL_SCHED_TYPE(cell)];
11613 #ifdef LTEMAC_SPS
11614    /* Perform SPS specific initialization for the cell */
11615    ret = rgSCHCmnSpsCellCfg(cell, cellCfg, err);
11616    if (ret != ROK)
11617    {
11618       RETVALUE(ret);
11619    }
11620 #endif
11621    ret = cellSch->apisDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
11622    if (ret != ROK)
11623    {
11624       RETVALUE(ret);
11625    }
11626    rgSCHCmnInitVars(cell);
11627
11628    RETVALUE(ROK);
11629 }  /* rgSCHCmnRgrCellCfg*/
11630
11631 \f
11632 /**
11633  * @brief This function handles the reconfiguration of cell.
11634  *
11635  * @details
11636  *
11637  *     Function: rgSCHCmnRgrCellRecfg
11638  *     Purpose:  Update the reconfiguration parameters.
11639  *
11640  *     Invoked by: Scheduler
11641  *
11642  *  @param[in]  RgSchCellCb*  cell
11643  *  @return  Void
11644  *
11645  **/
11646 #ifdef ANSI
11647 PUBLIC S16 rgSCHCmnRgrCellRecfg
11648 (
11649 RgSchCellCb             *cell,
11650 RgrCellRecfg            *recfg,
11651 RgSchErrInfo            *err
11652 )
11653 #else
11654 PUBLIC S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
11655 RgSchCellCb             *cell;
11656 RgrCellRecfg            *recfg;
11657 RgSchErrInfo            *err;
11658 #endif
11659 {
11660    S16                  ret;
11661    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
11662    RgSchCmnUlCell       *cellUl  = RG_SCH_CMN_GET_UL_CELL(cell);
11663
11664    TRC2(rgSCHCmnRgrCellRecfg);
11665
11666    if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
11667    {
11668       U8   oldCqi = cellUl->dfltUlCqi;
11669       if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
11670       {
11671          err->errCause = RGSCHERR_SCH_CFG;
11672          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
11673             "Invalid cqi");
11674          RETVALUE(RFAILED);
11675       }
11676       cellUl->dfltUlCqi = recfg->ulCmnCodeRate.ccchCqi;
11677       ret = rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
11678             cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
11679       if (ret != ROK)
11680       {
11681          cellUl->dfltUlCqi = oldCqi;
11682          rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
11683                cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
11684          RETVALUE(ret);
11685       }
11686    }
11687
11688    if (recfg->recfgTypes & RGR_CELL_DL_CMNRATE_RECFG)
11689    {
11690       if (rgSCHCmnDlCnsdrCmnRt(cell, &recfg->dlCmnCodeRate) != ROK)
11691       {
11692          err->errCause = RGSCHERR_SCH_CFG;
11693          RETVALUE(RFAILED);
11694       }
11695    }
11696  
11697 #ifdef EMTC_ENABLE  
11698    if(TRUE == cell->emtcEnable) 
11699    {
11700       /* Invoke UL sched for cell Recfg */
11701       ret = cellSch->apisEmtcUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
11702       if (ret != ROK)
11703       {
11704          RETVALUE(RFAILED);
11705       }
11706
11707       /* Invoke DL sched for cell Recfg */
11708       ret = cellSch->apisEmtcDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
11709       if (ret != ROK)
11710       {
11711          RETVALUE(RFAILED);
11712       }
11713    }
11714    else
11715 #endif
11716    {
11717    /* Invoke UL sched for cell Recfg */
11718    ret = cellSch->apisUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
11719    if (ret != ROK)
11720    {
11721       RETVALUE(RFAILED);
11722    }
11723
11724    /* Invoke DL sched for cell Recfg */
11725    ret = cellSch->apisDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
11726    if (ret != ROK)
11727    {
11728       RETVALUE(RFAILED);
11729    }
11730    }
11731
11732    if (recfg->recfgTypes & RGR_CELL_DLFS_RECFG)
11733    {
11734       ret = cellSch->apisDlfs->rgSCHDlfsCellRecfg(cell, recfg, err);
11735       if (ret != ROK)
11736       {
11737          RETVALUE(RFAILED);
11738       }
11739       cellSch->dl.isDlFreqSel = recfg->dlfsRecfg.isDlFreqSel;
11740    }
11741
11742    if (recfg->recfgTypes & RGR_CELL_PWR_RECFG)
11743    {
11744       ret = rgSCHPwrCellRecfg(cell, recfg);
11745       if (ret != ROK)
11746       {
11747          RETVALUE(RFAILED);
11748       }
11749    }
11750
11751    RETVALUE(ROK);
11752 }
11753
11754 /***********************************************************
11755  *
11756  *     Func : rgSCHCmnUlCellDeinit
11757  *
11758  *     Desc : Uplink scheduler de-initialisation for cell.
11759  *
11760  *     Ret  : S16
11761  *
11762  *     Notes:
11763  *
11764  *     File :
11765  *
11766  **********************************************************/
11767 #ifdef ANSI
11768 PRIVATE Void rgSCHCmnUlCellDeinit
11769 (
11770 RgSchCellCb *cell
11771 )
11772 #else
11773 PRIVATE Void rgSCHCmnUlCellDeinit(cell)
11774 RgSchCellCb *cell;
11775 #endif
11776 {
11777    RgSchCmnUlCell   *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
11778    U8               ulSfIdx;
11779 #ifdef LTE_TDD
11780    U8        maxSubfrms = cellUl->numUlSubfrms;
11781 #endif
11782 #ifdef LTE_L2_MEAS
11783    CmLList       *lnk = NULLP;
11784    RgSchL2MeasCb *measCb;
11785 #endif
11786    TRC2(rgSCHCmnUlCellDeinit);
11787 #ifdef LTE_L2_MEAS
11788 #ifdef LTE_TDD
11789    for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
11790 #else
11791    for(ulSfIdx = 0; ulSfIdx < RGSCH_NUM_SUB_FRAMES; ulSfIdx++)
11792 #endif
11793    {
11794       if(cell->sfAllocArr[ulSfIdx].ulUeInfo.ulAllocInfo != NULLP)
11795       {
11796          /* ccpu00117052 - MOD - Passing double pointer
11797             for proper NULLP assignment*/
11798          rgSCHUtlFreeSBuf(cell->instIdx,
11799          (Data **)(&(cell->sfAllocArr[ulSfIdx].ulUeInfo.ulAllocInfo)),
11800          cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc));
11801
11802          /* ccpu00117052 - DEL - removed explicit NULLP assignment
11803             as it is done in above utility function */
11804       }
11805    }
11806    /* Free the memory allocated to measCb */
11807    lnk = cell->l2mList.first;
11808    while(lnk != NULLP)
11809    {
11810       measCb = (RgSchL2MeasCb *)lnk->node;
11811       cmLListDelFrm(&cell->l2mList, lnk);
11812       lnk = lnk->next;
11813    /* ccpu00117052 - MOD - Passing double pointer
11814    for proper NULLP assignment*/
11815       rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,\
11816                           sizeof(RgSchL2MeasCb));
11817    }
11818 #endif
11819    if (cellUl->dmrsArr != NULLP)
11820    {
11821       /* ccpu00117052 - MOD - Passing double pointer
11822       for proper NULLP assignment*/
11823       rgSCHUtlFreeSBuf(cell->instIdx,(Data **)(&(cellUl->dmrsArr)),
11824                cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11825    }
11826    /* De-init subframes */
11827 #ifdef LTE_TDD
11828    for (ulSfIdx = 0; ulSfIdx < maxSubfrms; ++ulSfIdx)
11829 #else
11830    for (ulSfIdx = 0; ulSfIdx < RG_SCH_CMN_UL_NUM_SF; ++ulSfIdx)
11831 #endif
11832    {
11833       rgSCHUtlUlSfDeinit(cell, &cellUl->ulSfArr[ulSfIdx]);
11834    }
11835
11836 #ifdef LTE_TDD
11837    if (cellUl->ulSfArr != NULLP)
11838    {
11839       /* ccpu00117052 - MOD - Passing double pointer
11840       for proper NULLP assignment*/
11841       rgSCHUtlFreeSBuf(cell->instIdx,
11842          (Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
11843    }
11844 #endif
11845
11846    RETVOID;
11847 }
11848
11849 /**
11850  * @brief Scheduler processing for cell delete.
11851  *
11852  * @details
11853  *
11854  *     Function : rgSCHCmnCellDel
11855  *
11856  *     This functions de-initialises and frees memory
11857  *     taken up by scheduler1 for the entire cell.
11858  *
11859  *  @param[in]  RgSchCellCb  *cell
11860  *  @return  Void
11861  **/
11862 #ifdef ANSI
11863 PUBLIC Void rgSCHCmnCellDel
11864 (
11865 RgSchCellCb  *cell
11866 )
11867 #else
11868 PUBLIC Void rgSCHCmnCellDel(cell)
11869 RgSchCellCb  *cell;
11870 #endif
11871 {
11872    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
11873    TRC2(rgSCHCmnCellDel);
11874
11875 #ifdef LTE_L2_MEAS
11876    glblTtiCnt = 0;
11877 #endif
11878    if (cellSch == NULLP)
11879    {
11880       RETVOID;
11881    }
11882    /* Perform the deinit for the UL scheduler */
11883    rgSCHCmnUlCellDeinit(cell);
11884 #ifdef EMTC_ENABLE
11885    if(TRUE == cell->emtcEnable)
11886    {
11887       if (cellSch->apisEmtcUl)
11888       {
11889          cellSch->apisEmtcUl->rgSCHFreeUlCell(cell);
11890       }
11891    }
11892 #endif 
11893    if (cellSch->apisUl)
11894    {
11895       /* api pointer checks added (here and below in
11896        * this function). pl check. - antriksh */
11897       cellSch->apisUl->rgSCHFreeUlCell(cell);
11898    }
11899
11900    /* Perform the deinit for the DL scheduler */
11901    cmLListInit(&cellSch->dl.taLst);
11902    if (cellSch->apisDl)
11903    {
11904       cellSch->apisDl->rgSCHFreeDlCell(cell);
11905    }
11906 #ifdef EMTC_ENABLE
11907    if (cellSch->apisEmtcDl)
11908    {
11909       rgSCHEmtcInitTaLst(&cellSch->dl);
11910
11911       cellSch->apisEmtcDl->rgSCHFreeDlCell(cell);
11912    }
11913 #endif
11914
11915    /* DLFS de-initialization */
11916    if (cellSch->dl.isDlFreqSel && cellSch->apisDlfs)
11917    {
11918       cellSch->apisDlfs->rgSCHDlfsCellDel(cell);
11919    }
11920
11921    rgSCHPwrCellDel(cell);
11922 #ifdef LTEMAC_SPS
11923    rgSCHCmnSpsCellDel(cell);
11924 #endif
11925
11926    /* ccpu00117052 - MOD - Passing double pointer
11927    for proper NULLP assignment*/
11928    rgSCHUtlFreeSBuf(cell->instIdx,
11929       (Data**)(&(cell->sc.sch)), (sizeof(RgSchCmnCell)));
11930    RETVOID;
11931 }  /* rgSCHCmnCellDel */
11932
11933 \f
11934 /**
11935  * @brief This function validates QOS parameters for DL.
11936  *
11937  * @details
11938  *
11939  *     Function: rgSCHCmnValidateDlQos
11940  *     Purpose:  This function validates QOS parameters for DL.
11941  *
11942  *     Invoked by: Scheduler
11943  *
11944  *  @param[in] CrgLchQosCfg    *dlQos
11945  *  @return                    S16
11946  *
11947  **/
11948 #ifdef ANSI
11949 PRIVATE S16 rgSCHCmnValidateDlQos
11950 (
11951 RgrLchQosCfg            *dlQos
11952 )
11953 #else
11954 PRIVATE S16 rgSCHCmnValidateDlQos(dlQos)
11955 RgrLchQosCfg            *dlQos;
11956 #endif
11957 {
11958    U8 qci = dlQos->qci;
11959
11960    TRC2(rgSCHCmnValidateDlQos);
11961
11962    if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
11963    {
11964       RETVALUE(RFAILED);
11965    }
11966
11967    if ((qci >= RG_SCH_CMN_GBR_QCI_START) &&
11968        (qci <= RG_SCH_CMN_GBR_QCI_END))
11969    {
11970       if ((dlQos->mbr == 0) || (dlQos->mbr < dlQos->gbr))
11971       {
11972          RETVALUE(RFAILED);
11973       }
11974    }
11975    RETVALUE(ROK);
11976 }
11977
11978 /**
11979  * @brief Scheduler invocation on logical channel addition.
11980  *
11981  * @details
11982  *
11983  *     Function : rgSCHCmnRgrLchCfg
11984  *
11985  *     This functions does required processing when a new
11986  *     (dedicated) logical channel is added. Assumes lcg
11987  *     pointer in ulLc is set.
11988  *
11989  *  @param[in]  RgSchCellCb  *cell
11990  *  @param[in]  RgSchUeCb    *ue
11991  *  @param[in]  RgSchDlLcCb  *dlLc
11992  *  @param[int] RgrLchCfg    *lcCfg
11993  *  @param[out] RgSchErrInfo *err
11994  *  @return  S16
11995  *      -# ROK
11996  *      -# RFAILED
11997  **/
11998 #ifdef ANSI
11999 PUBLIC S16 rgSCHCmnRgrLchCfg
12000 (
12001 RgSchCellCb  *cell,
12002 RgSchUeCb    *ue,
12003 RgSchDlLcCb  *dlLc,
12004 RgrLchCfg *lcCfg,
12005 RgSchErrInfo *err
12006 )
12007 #else
12008 PUBLIC S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
12009 RgSchCellCb  *cell;
12010 RgSchUeCb    *ue;
12011 RgSchDlLcCb  *dlLc;
12012 RgrLchCfg *lcCfg;
12013 RgSchErrInfo *err;
12014 #endif
12015 {
12016    S16 ret;
12017
12018    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12019
12020    TRC2(rgSCHCmnRgrLchCfg);
12021
12022    ret = rgSCHUtlAllocSBuf(cell->instIdx,
12023       (Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
12024    if (ret != ROK)
12025    {
12026       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
12027          "SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12028       err->errCause = RGSCHERR_SCH_CFG;
12029       RETVALUE(ret);
12030    }
12031    if(lcCfg->lcType != CM_LTE_LCH_DCCH)
12032    {
12033       ret = rgSCHCmnValidateDlQos(&lcCfg->dlInfo.dlQos);
12034       if (ret != ROK)
12035       {
12036          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
12037             "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12038          err->errCause = RGSCHERR_SCH_CFG;
12039          RETVALUE(ret);
12040       }
12041       /* Perform DL service activation in the scheduler */
12042       ((RgSchCmnDlSvc *)(dlLc->sch))->qci = lcCfg->dlInfo.dlQos.qci;
12043       ((RgSchCmnDlSvc *)(dlLc->sch))->prio = rgSchCmnDlQciPrio[lcCfg->dlInfo.dlQos.qci - 1];
12044       ((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcCfg->dlInfo.dlQos.gbr * \
12045       RG_SCH_CMN_REFRESH_TIME)/100;
12046       ((RgSchCmnDlSvc *)(dlLc->sch))->mbr = (lcCfg->dlInfo.dlQos.mbr * \
12047       RG_SCH_CMN_REFRESH_TIME)/100;
12048    }
12049    else
12050    {
12051      /*assigning highest priority to DCCH */
12052     ((RgSchCmnDlSvc *)(dlLc->sch))->prio=RG_SCH_CMN_DCCH_PRIO; 
12053    }   
12054    dlLc->ue = ue;
12055    dlLc->lcType=lcCfg->lcType;
12056
12057 #ifdef EMTC_ENABLE
12058    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12059    {
12060       ret = cellSch->apisEmtcDl->rgSCHRgrDlLcCfg(cell, ue,dlLc ,lcCfg, err);
12061       if (ret != ROK)
12062       {
12063          RETVALUE(RFAILED);
12064       }
12065    }
12066    else
12067 #endif 
12068    {
12069       ret = cellSch->apisDl->rgSCHRgrDlLcCfg(cell, ue, dlLc, lcCfg, err);
12070       if (ret != ROK)
12071       {
12072          RETVALUE(RFAILED);
12073       }
12074    }
12075    
12076 #ifdef EMTC_ENABLE
12077    if(TRUE == ue->isEmtcUe)
12078    {
12079       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
12080       if (ret != ROK)
12081       {
12082          RETVALUE(RFAILED);
12083       }
12084    }
12085    else
12086 #endif 
12087    {
12088    ret = cellSch->apisUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
12089    if (ret != ROK)
12090    {
12091       RETVALUE(RFAILED);
12092    }
12093    }
12094    
12095 #ifdef LTE_ADV
12096    if (ue->numSCells)
12097    {
12098       rgSCHSCellDlLcCfg(cell, ue, dlLc);
12099    }
12100 #endif
12101
12102
12103 #ifdef LTEMAC_SPS
12104    if(lcCfg->dlInfo.dlSpsCfg.isSpsEnabled)
12105    {
12106       /* Invoke SPS module if SPS is enabled for the service */
12107       ret = rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err);
12108       if (ret != ROK)
12109       {
12110          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "rgSchCmnRgrLchCfg(): "
12111             "SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12112          err->errCause = RGSCHERR_SCH_CFG;
12113          RETVALUE(RFAILED);
12114       }
12115    }
12116 #endif
12117
12118    RETVALUE(ROK);
12119 }
12120
12121 /**
12122  * @brief Scheduler invocation on logical channel addition.
12123  *
12124  * @details
12125  *
12126  *     Function : rgSCHCmnRgrLchRecfg
12127  *
12128  *     This functions does required processing when an existing
12129  *     (dedicated) logical channel is reconfigured. Assumes lcg
12130  *     pointer in ulLc is set to the old value.
12131  *     Independent of whether new LCG is meant to be configured,
12132  *     the new LCG scheduler information is accessed and possibly modified.
12133  *
12134  *  @param[in]  RgSchCellCb  *cell
12135  *  @param[in]  RgSchUeCb    *ue
12136  *  @param[in]  RgSchDlLcCb  *dlLc
12137  *  @param[int] RgrLchRecfg  *lcRecfg
12138  *  @param[out] RgSchErrInfo *err
12139  *  @return  S16
12140  *      -# ROK
12141  *      -# RFAILED
12142  **/
12143 #ifdef ANSI
12144 PUBLIC S16 rgSCHCmnRgrLchRecfg
12145 (
12146 RgSchCellCb  *cell,
12147 RgSchUeCb    *ue,
12148 RgSchDlLcCb  *dlLc,
12149 RgrLchRecfg  *lcRecfg,
12150 RgSchErrInfo *err
12151 )
12152 #else
12153 PUBLIC S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
12154 RgSchCellCb  *cell;
12155 RgSchUeCb    *ue;
12156 RgSchDlLcCb  *dlLc;
12157 RgrLchRecfg  *lcRecfg;
12158 RgSchErrInfo *err;
12159 #endif
12160 {
12161    S16   ret;
12162    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12163
12164    TRC2(rgSCHCmnRgrLchRecfg)
12165
12166    if(dlLc->lcType != CM_LTE_LCH_DCCH)
12167    {
12168       ret = rgSCHCmnValidateDlQos(&lcRecfg->dlRecfg.dlQos);
12169    
12170       if (ret != ROK)
12171       {
12172          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
12173                "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12174          err->errCause = RGSCHERR_SCH_CFG;
12175          RETVALUE(ret);
12176       }
12177       if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
12178       {
12179          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
12180             "not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12181          err->errCause = RGSCHERR_SCH_CFG;
12182          RETVALUE(ret);
12183       }
12184       ((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcRecfg->dlRecfg.dlQos.gbr * \
12185       RG_SCH_CMN_REFRESH_TIME)/100;
12186       ((RgSchCmnDlSvc *)(dlLc->sch))->mbr = (lcRecfg->dlRecfg.dlQos.mbr * \
12187       RG_SCH_CMN_REFRESH_TIME)/100;
12188    }
12189    else
12190    {
12191       /*assigning highest priority to DCCH */
12192       ((RgSchCmnDlSvc *)(dlLc->sch))->prio = RG_SCH_CMN_DCCH_PRIO; 
12193    }
12194    
12195 #ifdef EMTC_ENABLE
12196    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12197    {
12198       ret = cellSch->apisEmtcDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12199       if (ret != ROK)
12200       {
12201          RETVALUE(RFAILED);
12202       }
12203       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
12204       if (ret != ROK)
12205       {
12206          RETVALUE(RFAILED);
12207       }
12208    }
12209    else
12210 #endif 
12211    {
12212    ret = cellSch->apisDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12213    if (ret != ROK)
12214    {
12215       RETVALUE(RFAILED);
12216    }
12217    ret = cellSch->apisUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
12218    if (ret != ROK)
12219    {
12220       RETVALUE(RFAILED);
12221    }
12222    }
12223     
12224 #ifdef LTEMAC_SPS
12225    if (lcRecfg->recfgTypes & RGR_DL_LC_SPS_RECFG)
12226    {
12227       /* Invoke SPS module if SPS is enabled for the service */
12228       if(lcRecfg->dlRecfg.dlSpsRecfg.isSpsEnabled)
12229       {
12230          ret = rgSCHCmnSpsDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12231          if (ret != ROK)
12232          {
12233             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"SPS re-configuration not "
12234                   "supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12235          }
12236       }
12237       RETVALUE(ROK);
12238    }
12239 #endif
12240
12241    RETVALUE(ROK);
12242 }
12243
12244 /**
12245  * @brief Scheduler invocation on logical channel addition.
12246  *
12247  * @details
12248  *
12249  *     Function : rgSCHCmnRgrLcgCfg
12250  *
12251  *     This functions does required processing when a new
12252  *     (dedicated) logical channel is added. Assumes lcg
12253  *     pointer in ulLc is set.
12254  *
12255  *  @param[in]  RgSchCellCb  *cell,
12256  *  @param[in]  RgSchUeCb    *ue,
12257  *  @param[in]  RgSchLcgCb   *lcg,
12258  *  @param[in]  RgrLcgCfg    *lcgCfg,
12259  *  @param[out] RgSchErrInfo *err
12260  *  @return  S16
12261  *      -# ROK
12262  *      -# RFAILED
12263  **/
12264 #ifdef ANSI
12265 PUBLIC S16 rgSCHCmnRgrLcgCfg
12266 (
12267 RgSchCellCb  *cell,
12268 RgSchUeCb    *ue,
12269 RgSchLcgCb   *lcg,
12270 RgrLcgCfg    *lcgCfg,
12271 RgSchErrInfo *err
12272 )
12273 #else
12274 PUBLIC S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
12275 RgSchCellCb  *cell;
12276 RgSchUeCb    *ue;
12277 RgSchLcgCb   *lcg;
12278 RgrLcgCfg    *lcgCfg;
12279 RgSchErrInfo *err;
12280 #endif
12281 {
12282    S16 ret;
12283    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12284    RgSchCmnLcg  *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
12285
12286    TRC2(rgSCHCmnRgrLcgCfg);
12287
12288    ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
12289    ulLcg->effGbr  = ulLcg->cfgdGbr;
12290    ulLcg->deltaMbr = ((lcgCfg->ulInfo.mbr - lcgCfg->ulInfo.gbr) * RG_SCH_CMN_REFRESH_TIME)/100;
12291    ulLcg->effDeltaMbr = ulLcg->deltaMbr;
12292
12293 #ifdef EMTC_ENABLE
12294    if(TRUE == ue->isEmtcUe)
12295    {
12296       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
12297       if (ret != ROK)
12298       {
12299          RETVALUE(RFAILED);
12300       }
12301    }
12302    else
12303 #endif
12304    {
12305    ret = cellSch->apisUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
12306    if (ret != ROK)
12307    {
12308       RETVALUE(RFAILED);
12309    }
12310    }
12311    if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
12312    {
12313       /* Indicate MAC that this LCG is GBR LCG */
12314       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcgCfg->ulInfo.lcgId, TRUE);
12315    }
12316    RETVALUE(ROK);
12317 }
12318
12319 /**
12320  * @brief Scheduler invocation on logical channel addition.
12321  *
12322  * @details
12323  *
12324  *     Function : rgSCHCmnRgrLcgRecfg
12325  *
12326  *     This functions does required processing when a new
12327  *     (dedicated) logical channel is added. Assumes lcg
12328  *     pointer in ulLc is set.
12329  *
12330  *  @param[in]  RgSchCellCb  *cell,
12331  *  @param[in]  RgSchUeCb    *ue,
12332  *  @param[in]  RgSchLcgCb   *lcg,
12333  *  @param[in]  RgrLcgRecfg  *reCfg,
12334  *  @param[out] RgSchErrInfo *err
12335  *  @return  S16
12336  *      -# ROK
12337  *      -# RFAILED
12338  **/
12339 #ifdef ANSI
12340 PUBLIC S16 rgSCHCmnRgrLcgRecfg
12341 (
12342 RgSchCellCb  *cell,
12343 RgSchUeCb    *ue,
12344 RgSchLcgCb   *lcg,
12345 RgrLcgRecfg  *reCfg,
12346 RgSchErrInfo *err
12347 )
12348 #else
12349 PUBLIC S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
12350 RgSchCellCb  *cell;
12351 RgSchUeCb    *ue;
12352 RgSchLcgCb   *lcg;
12353 RgrLcgRecfg  *reCfg;
12354 RgSchErrInfo *err;
12355 #endif
12356 {
12357    S16 ret;
12358    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12359    RgSchCmnLcg  *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
12360    
12361    TRC2(rgSCHCmnRgrLcgRecfg);
12362
12363    ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
12364    ulLcg->effGbr  = ulLcg->cfgdGbr;
12365    ulLcg->deltaMbr = ((reCfg->ulRecfg.mbr - reCfg->ulRecfg.gbr) * RG_SCH_CMN_REFRESH_TIME)/100;
12366    ulLcg->effDeltaMbr = ulLcg->deltaMbr;
12367  
12368 #ifdef EMTC_ENABLE
12369    if(TRUE == ue->isEmtcUe)
12370    {
12371       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
12372       if (ret != ROK)
12373       {
12374          RETVALUE(RFAILED);
12375       }
12376    }
12377    else
12378 #endif
12379    {
12380    ret = cellSch->apisUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
12381    if (ret != ROK)
12382    {
12383       RETVALUE(RFAILED);
12384    }
12385    }
12386    if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
12387    {
12388       /* Indicate MAC that this LCG is GBR LCG */
12389       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, TRUE);
12390    }
12391    else
12392    {
12393       /* In case of RAB modification */
12394       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, FALSE);
12395    }
12396    RETVALUE(ROK);
12397 }
12398
12399 /***********************************************************
12400  *
12401  *     Func : rgSCHCmnRgrLchDel
12402  *
12403  *     Desc : Scheduler handling for a (dedicated)
12404  *             uplink logical channel being deleted.
12405  *
12406  *     Ret  :
12407  *
12408  *     Notes:
12409  *
12410  *     File :
12411  **********************************************************/
12412 #ifdef ANSI
12413 PUBLIC S16 rgSCHCmnRgrLchDel 
12414 (
12415 RgSchCellCb   *cell,
12416 RgSchUeCb     *ue,
12417 CmLteLcId     lcId,
12418 U8            lcgId
12419 )
12420 #else
12421 PUBLIC S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
12422 RgSchCellCb   *cell;
12423 RgSchUeCb     *ue;
12424 CmLteLcId     lcId;
12425 U8            lcgId;
12426 #endif
12427 {
12428    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12429    TRC2(rgSCHCmnRgrLchDel);
12430 #ifdef EMTC_ENABLE
12431    if(TRUE == ue->isEmtcUe)
12432    {
12433       cellSch->apisEmtcUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
12434    }
12435    else
12436 #endif
12437    {
12438    cellSch->apisUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
12439    }
12440    RETVALUE(ROK);
12441 }
12442
12443 /***********************************************************
12444  *
12445  *     Func : rgSCHCmnLcgDel
12446  *
12447  *     Desc : Scheduler handling for a (dedicated)
12448  *             uplink logical channel being deleted.
12449  *
12450  *     Ret  :
12451  *
12452  *     Notes:
12453  *
12454  *     File :
12455  *
12456  **********************************************************/
12457 #ifdef ANSI
12458 PUBLIC Void rgSCHCmnLcgDel
12459 (
12460 RgSchCellCb   *cell,
12461 RgSchUeCb     *ue,
12462 RgSchLcgCb    *lcg
12463 )
12464 #else
12465 PUBLIC Void rgSCHCmnLcgDel(cell, ue, lcg)
12466 RgSchCellCb   *cell;
12467 RgSchUeCb     *ue;
12468 RgSchLcgCb    *lcg;
12469 #endif
12470 {
12471    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12472    RgSchCmnLcg  *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
12473    TRC2(rgSCHCmnLcgDel);
12474
12475    if (lcgCmn == NULLP)
12476    {
12477       RETVOID;
12478    }
12479
12480    if (RGSCH_IS_GBR_BEARER(lcgCmn->cfgdGbr))
12481    {
12482       /* Indicate MAC that this LCG is GBR LCG */
12483       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcg->lcgId, FALSE);
12484    }
12485
12486 #ifdef LTEMAC_SPS
12487    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
12488    {
12489       rgSCHCmnSpsUlLcgDel(cell, ue, lcg);
12490    }
12491 #endif /* LTEMAC_SPS */
12492
12493    lcgCmn->effGbr     = 0;
12494    lcgCmn->reportedBs = 0;
12495    lcgCmn->cfgdGbr    = 0;
12496    /* set lcg bs to 0. Deletion of control block happens
12497     * at the time of UE deletion. */
12498    lcgCmn->bs = 0;
12499 #ifdef EMTC_ENABLE
12500    if(TRUE == ue->isEmtcUe)
12501    {
12502       cellSch->apisEmtcUl->rgSCHFreeUlLcg(cell, ue, lcg);
12503    }
12504    else
12505 #endif
12506    {
12507    cellSch->apisUl->rgSCHFreeUlLcg(cell, ue, lcg);
12508    }
12509    RETVOID;
12510 }
12511
12512 \f
12513 /**
12514  * @brief This function deletes a service from scheduler.
12515  *
12516  * @details
12517  *
12518  *     Function: rgSCHCmnFreeDlLc
12519  *     Purpose:  This function is made available through a FP for
12520  *               making scheduler aware of a service being deleted from UE.
12521  *
12522  *     Invoked by: BO and Scheduler
12523  *
12524  *  @param[in]  RgSchCellCb*  cell
12525  *  @param[in]  RgSchUeCb*    ue
12526  *  @param[in]  RgSchDlLcCb*  svc
12527  *  @return  Void
12528  *
12529  **/
12530 #ifdef ANSI
12531 PUBLIC Void rgSCHCmnFreeDlLc
12532 (
12533 RgSchCellCb                *cell,
12534 RgSchUeCb                  *ue,
12535 RgSchDlLcCb                *svc
12536 )
12537 #else
12538 PUBLIC Void rgSCHCmnFreeDlLc(cell, ue, svc)
12539 RgSchCellCb                *cell;
12540 RgSchUeCb                  *ue;
12541 RgSchDlLcCb                *svc;
12542 #endif
12543 {
12544    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12545    TRC2(rgSCHCmnFreeDlLc);
12546    if (svc->sch == NULLP)
12547    {
12548       RETVOID;
12549    }
12550 #ifdef EMTC_ENABLE
12551     if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12552     {
12553       cellSch->apisEmtcDl->rgSCHFreeDlLc(cell, ue, svc);
12554     }
12555     else
12556 #endif
12557    {
12558       cellSch->apisDl->rgSCHFreeDlLc(cell, ue, svc);
12559    }
12560
12561 #ifdef LTE_ADV
12562    if (ue->numSCells)
12563    {
12564       rgSCHSCellDlLcDel(cell, ue, svc);
12565    }
12566 #endif
12567
12568 #ifdef LTEMAC_SPS
12569    /* If SPS service, invoke SPS module */
12570    if (svc->dlLcSpsCfg.isSpsEnabled)
12571    {
12572       rgSCHCmnSpsDlLcDel(cell, ue, svc);
12573    }
12574 #endif
12575
12576    /* ccpu00117052 - MOD - Passing double pointer
12577    for proper NULLP assignment*/
12578    rgSCHUtlFreeSBuf(cell->instIdx,
12579          (Data**)(&(svc->sch)), (sizeof(RgSchCmnDlSvc)));
12580
12581 #ifdef LTE_ADV
12582    rgSCHLaaDeInitDlLchCb(cell, svc);
12583 #endif
12584
12585    RETVOID;
12586 }
12587
12588 #ifdef RGR_V1
12589
12590 /**
12591  * @brief This function Processes the Final Allocations
12592  *        made by the RB Allocator against the requested
12593  *        CCCH SDURetx Allocations.
12594  *
12595  * @details
12596  *
12597  *     Function: rgSCHCmnDlCcchSduRetxFnlz
12598  *     Purpose:  This function Processes the Final Allocations
12599  *               made by the RB Allocator against the requested
12600  *               CCCH Retx Allocations.
12601  *               Scans through the scheduled list of ccchSdu retrans
12602  *               fills the corresponding pdcch, adds the hqProc to
12603  *               the corresponding SubFrm and removes the hqP from
12604  *               cells retx List.
12605  *
12606  *     Invoked by: Common Scheduler
12607  *
12608  *  @param[in]  RgSchCellCb           *cell
12609  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12610  *  @return  Void
12611  *
12612  **/
12613 #ifdef ANSI
12614 PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz
12615 (
12616 RgSchCellCb           *cell,
12617 RgSchCmnDlRbAllocInfo *allocInfo
12618 )
12619 #else
12620 PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo)
12621 RgSchCellCb           *cell;
12622 RgSchCmnDlRbAllocInfo *allocInfo;
12623 #endif
12624 {
12625    CmLList           *node;
12626    RgSchCmnDlCell    *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
12627    RgSchDlRbAlloc    *rbAllocInfo;
12628    RgSchDlHqProcCb   *hqP;
12629    RgSchUeCb         *ue;
12630    TRC2(rgSCHCmnDlCcchSduRetxFnlz);
12631
12632    /* Traverse through the Scheduled Retx List */
12633    node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
12634    while (node)
12635    {
12636       hqP = (RgSchDlHqProcCb *)(node->node);
12637       ue = hqP->hqE->ue;
12638       rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
12639       node = node->next;
12640       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12641
12642       /* Remove the HqP from cell's ccchSduRetxLst */
12643       cmLListDelFrm(&cmnCellDl->ccchSduRetxLst, &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
12644       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
12645
12646       /* Fix: syed dlAllocCb reset should be performed.
12647        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12648       rgSCHCmnDlUeResetTemp(ue, hqP);
12649    }
12650    /* Fix: syed dlAllocCb reset should be performed.
12651     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12652    node = allocInfo->ccchSduAlloc.nonSchdCcchSduRetxLst.first;
12653    while(node)
12654    {
12655       hqP = (RgSchDlHqProcCb *)(node->node);
12656       ue = hqP->hqE->ue;
12657       node = node->next;
12658       /* reset the UE allocation Information */
12659       rgSCHCmnDlUeResetTemp(ue, hqP);
12660    }
12661    RETVOID;
12662 }
12663 #endif
12664 /**
12665  * @brief This function Processes the Final Allocations
12666  *        made by the RB Allocator against the requested
12667  *        CCCH Retx Allocations.
12668  *
12669  * @details
12670  *
12671  *     Function: rgSCHCmnDlCcchRetxFnlz
12672  *     Purpose:  This function Processes the Final Allocations
12673  *               made by the RB Allocator against the requested
12674  *               CCCH Retx Allocations.
12675  *               Scans through the scheduled list of msg4 retrans
12676  *               fills the corresponding pdcch, adds the hqProc to
12677  *               the corresponding SubFrm and removes the hqP from
12678  *               cells retx List.
12679  *
12680  *     Invoked by: Common Scheduler
12681  *
12682  *  @param[in]  RgSchCellCb           *cell
12683  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12684  *  @return  Void
12685  *
12686  **/
12687 #ifdef ANSI
12688 PRIVATE Void rgSCHCmnDlCcchRetxFnlz
12689 (
12690 RgSchCellCb           *cell,
12691 RgSchCmnDlRbAllocInfo *allocInfo
12692 )
12693 #else
12694 PRIVATE Void rgSCHCmnDlCcchRetxFnlz(cell, allocInfo)
12695 RgSchCellCb           *cell;
12696 RgSchCmnDlRbAllocInfo *allocInfo;
12697 #endif
12698 {
12699    CmLList           *node;
12700    RgSchCmnDlCell    *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
12701    RgSchDlRbAlloc    *rbAllocInfo;
12702    RgSchDlHqProcCb   *hqP;
12703    RgSchRaCb         *raCb;
12704    TRC2(rgSCHCmnDlCcchRetxFnlz);
12705
12706    /* Traverse through the Scheduled Retx List */
12707    node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
12708    while (node)
12709    {
12710       hqP = (RgSchDlHqProcCb *)(node->node);
12711       raCb = hqP->hqE->raCb;
12712       rbAllocInfo = &raCb->rbAllocInfo;
12713       node = node->next;
12714       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12715
12716       /* Remove the HqP from cell's msg4RetxLst */
12717       cmLListDelFrm(&cmnCellDl->msg4RetxLst, &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
12718       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
12719       /* Fix: syed dlAllocCb reset should be performed.
12720        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12721       cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
12722       rgSCHCmnDlHqPResetTemp(hqP);
12723    }
12724    /* Fix: syed dlAllocCb reset should be performed.
12725     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12726    node = allocInfo->msg4Alloc.nonSchdMsg4RetxLst.first;
12727    while(node)
12728    {
12729       hqP = (RgSchDlHqProcCb *)(node->node);
12730       raCb = hqP->hqE->raCb;
12731       node = node->next;
12732       cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
12733       rgSCHCmnDlHqPResetTemp(hqP);
12734    }
12735    RETVOID;
12736 }
12737
12738 #ifdef RGR_V1
12739 /**
12740  * @brief This function Processes the Final Allocations
12741  *        made by the RB Allocator against the requested
12742  *        CCCH SDU tx Allocations.
12743  *
12744  * @details
12745  *
12746  *     Function: rgSCHCmnDlCcchSduTxFnlz
12747  *     Purpose:  This function Processes the Final Allocations
12748  *               made by the RB Allocator against the requested
12749  *               CCCH tx Allocations.
12750  *               Scans through the scheduled list of CCCH SDU trans
12751  *               fills the corresponding pdcch, adds the hqProc to
12752  *               the corresponding SubFrm and removes the hqP from
12753  *               cells tx List.
12754  *
12755  *     Invoked by: Common Scheduler
12756  *
12757  *  @param[in]  RgSchCellCb           *cell
12758  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12759  *  @return  Void
12760  *
12761  **/
12762 #ifdef ANSI
12763 PRIVATE Void rgSCHCmnDlCcchSduTxFnlz
12764 (
12765 RgSchCellCb           *cell,
12766 RgSchCmnDlRbAllocInfo *allocInfo
12767 )
12768 #else
12769 PRIVATE Void rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo)
12770 RgSchCellCb           *cell;
12771 RgSchCmnDlRbAllocInfo *allocInfo;
12772 #endif
12773 {
12774    CmLList           *node;
12775    RgSchUeCb         *ueCb;
12776    RgSchDlRbAlloc    *rbAllocInfo;
12777    RgSchDlHqProcCb   *hqP;
12778    RgSchLchAllocInfo  lchSchdData;
12779    TRC2(rgSCHCmnDlCcchSduTxFnlz);
12780
12781    /* Traverse through the Scheduled Retx List */
12782    node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
12783    while (node)
12784    {
12785       hqP = (RgSchDlHqProcCb *)(node->node);
12786       ueCb = hqP->hqE->ue;
12787       node = node->next;
12788       rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
12789
12790       /* fill the pdcch and HqProc */
12791       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12792
12793       /* Remove the raCb from cell's toBeSchdLst */
12794       cmLListDelFrm(&cell->ccchSduUeLst, &ueCb->ccchSduLnk);
12795       ueCb->ccchSduLnk.node = (PTR)NULLP;
12796
12797       /* Fix : Resetting this required to avoid complication
12798        * in reestablishment case */
12799       ueCb->dlCcchInfo.bo = 0;
12800
12801       /* Indicate DHM of the CCCH LC scheduling */
12802       hqP->tbInfo[0].contResCe = NOTPRSNT;
12803       lchSchdData.lcId     = 0;
12804       lchSchdData.schdData = hqP->tbInfo[0].ccchSchdInfo.totBytes -
12805                              (RGSCH_MSG4_HDRSIZE);
12806       rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, &hqP->tbInfo[0]);
12807
12808       /* Fix: syed dlAllocCb reset should be performed.
12809        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12810       rgSCHCmnDlUeResetTemp(ueCb, hqP);
12811    }
12812    /* Fix: syed dlAllocCb reset should be performed.
12813     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12814    node = allocInfo->ccchSduAlloc.nonSchdCcchSduTxLst.first;
12815    while(node)
12816    {
12817       hqP = (RgSchDlHqProcCb *)(node->node);
12818       ueCb = hqP->hqE->ue;
12819       node = node->next;
12820       /* Release HqProc */
12821       rgSCHDhmRlsHqpTb(hqP, 0, FALSE);
12822       /*Fix: Removing releasing of TB1 as it will not exist for CCCH SDU and hence caused a crash*/
12823       /*rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
12824       /* reset the UE allocation Information */
12825       rgSCHCmnDlUeResetTemp(ueCb, hqP);
12826    }
12827    RETVOID;
12828 }
12829
12830 #endif
12831 /**
12832  * @brief This function Processes the Final Allocations
12833  *        made by the RB Allocator against the requested
12834  *        CCCH tx Allocations.
12835  *
12836  * @details
12837  *
12838  *     Function: rgSCHCmnDlCcchTxFnlz
12839  *     Purpose:  This function Processes the Final Allocations
12840  *               made by the RB Allocator against the requested
12841  *               CCCH tx Allocations.
12842  *               Scans through the scheduled list of msg4 trans
12843  *               fills the corresponding pdcch, adds the hqProc to
12844  *               the corresponding SubFrm and removes the hqP from
12845  *               cells tx List.
12846  *
12847  *     Invoked by: Common Scheduler
12848  *
12849  *  @param[in]  RgSchCellCb           *cell
12850  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12851  *  @return  Void
12852  *
12853  **/
12854 #ifdef ANSI
12855 PRIVATE Void rgSCHCmnDlCcchTxFnlz
12856 (
12857 RgSchCellCb           *cell,
12858 RgSchCmnDlRbAllocInfo *allocInfo
12859 )
12860 #else
12861 PRIVATE Void rgSCHCmnDlCcchTxFnlz(cell, allocInfo)
12862 RgSchCellCb           *cell;
12863 RgSchCmnDlRbAllocInfo *allocInfo;
12864 #endif
12865 {
12866    CmLList           *node;
12867    RgSchRaCb         *raCb;
12868    RgSchDlRbAlloc    *rbAllocInfo;
12869    RgSchDlHqProcCb   *hqP;
12870    RgSchLchAllocInfo  lchSchdData;
12871    TRC2(rgSCHCmnDlCcchTxFnlz);
12872
12873    /* Traverse through the Scheduled Retx List */
12874    node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
12875    while (node)
12876    {
12877       hqP = (RgSchDlHqProcCb *)(node->node);
12878       raCb = hqP->hqE->raCb;
12879       node = node->next;
12880       rbAllocInfo = &raCb->rbAllocInfo;
12881
12882       /* fill the pdcch and HqProc */
12883       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12884       /* MSG4 Fix Start */
12885      
12886       rgSCHRamRmvFrmRaInfoSchdLst(cell, raCb);
12887       /* MSG4 Fix End */     
12888
12889       /* Indicate DHM of the CCCH LC scheduling */
12890       lchSchdData.lcId     = 0;
12891       lchSchdData.schdData = hqP->tbInfo[0].ccchSchdInfo.totBytes -
12892          (RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE);
12893       /* TRansmitting presence of cont Res CE across MAC-SCH interface to
12894        * identify CCCH SDU transmissions which need to be done
12895        * without the
12896        * contention resolution CE*/
12897       hqP->tbInfo[0].contResCe = PRSNT_NODEF;
12898       /*Dont add lc if only cont res CE is being transmitted*/
12899       if(raCb->dlCcchInfo.bo)
12900       {
12901          rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, &hqP->tbInfo[0]);
12902       }
12903       else
12904       {
12905       }
12906       /* Fix: syed dlAllocCb reset should be performed.
12907        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12908       cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
12909       rgSCHCmnDlHqPResetTemp(hqP);
12910    }
12911    node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
12912    while(node)
12913    {
12914       hqP = (RgSchDlHqProcCb *)(node->node);
12915       raCb = hqP->hqE->raCb;
12916       node = node->next;
12917       rbAllocInfo = &raCb->rbAllocInfo;
12918       /* Release HqProc */
12919       rgSCHDhmRlsHqpTb(hqP, 0, FALSE);
12920       /*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
12921       /*      rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
12922       /* reset the UE allocation Information */
12923       cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
12924       rgSCHCmnDlHqPResetTemp(hqP);
12925    }
12926
12927    RETVOID;
12928 }
12929 /* R8 Upgrade */
12930 /**
12931  * @brief This function calculates the BI Index to be sent in the Bi header
12932  * field.
12933  *
12934  * @details
12935  *     Function: rgSCHCmnGetBiIndex
12936  *     Purpose:  This function Processes utilizes the previous BI time value
12937  *     calculated and the difference last BI sent time and current time. To
12938  *     calculate the latest BI Index. It also considers the how many UE's
12939  *     Unserved in this subframe.
12940  *
12941  *     Invoked by: Common Scheduler
12942  *
12943  *  @param[in]  RgSchCellCb           *cell
12944  *  @param[in]  U32                   ueCount
12945  *  @return  U8
12946  *
12947  **/
12948 #ifdef ANSI
12949 PUBLIC U8 rgSCHCmnGetBiIndex
12950 (
12951 RgSchCellCb   *cell,
12952 U32           ueCount
12953 )
12954 #else
12955 PUBLIC U8 rgSCHCmnGetBiIndex(cell, ueCount)
12956 RgSchCellCb   *cell;
12957 U32           ueCount;
12958 #endif
12959 {
12960    S16  prevVal = 0;      /* To Store Intermediate Value */
12961    U16  newBiVal = 0;     /* To store Bi Value in millisecond */
12962    U8   idx = 0;
12963    U16  timeDiff = 0;
12964
12965    TRC2(rgSCHCmnGetBiIndex)
12966
12967    if (cell->biInfo.prevBiTime != 0)
12968    {
12969 #ifdef EMTC_ENABLE
12970       if(cell->emtcEnable == TRUE)
12971       {
12972          timeDiff =(RGSCH_CALC_SF_DIFF_EMTC(cell->crntTime, cell->biInfo.biTime));
12973       }
12974       else
12975 #endif
12976       {
12977          timeDiff =(RGSCH_CALC_SF_DIFF(cell->crntTime, cell->biInfo.biTime));
12978       }
12979
12980       prevVal = cell->biInfo.prevBiTime - timeDiff;
12981    }
12982    if (prevVal < 0)
12983    {
12984       prevVal = 0;
12985    }
12986    newBiVal = RG_SCH_CMN_GET_BI_VAL(prevVal,ueCount);
12987    /* To be used next time when BI is calculated */
12988 #ifdef EMTC_ENABLE
12989    if(cell->emtcEnable == TRUE)
12990    {
12991       RGSCHCPYTIMEINFO_EMTC(cell->crntTime, cell->biInfo.biTime)
12992    }
12993    else
12994 #endif
12995    {
12996       RGSCHCPYTIMEINFO(cell->crntTime, cell->biInfo.biTime)
12997    }
12998
12999   /* Search the actual BI Index from table Backoff Parameters Value  and
13000    * return that Index */
13001    do
13002    {
13003       if (rgSchCmnBiTbl[idx] > newBiVal)
13004       {
13005          break;
13006       }
13007       idx++;
13008    }while(idx < RG_SCH_CMN_NUM_BI_VAL-1);
13009    cell->biInfo.prevBiTime = rgSchCmnBiTbl[idx];
13010    /* For 16 Entries in Table 7.2.1 36.321.880 - 3 reserved so total 13 Entries */
13011    RETVALUE(idx); /* Returning reserved value from table UE treats it has 960 ms */
13012 } /* rgSCHCmnGetBiIndex */
13013
13014
13015 /**
13016  * @brief This function Processes the Final Allocations
13017  *        made by the RB Allocator against the requested
13018  *        RAR allocations. Assumption: The reuqested
13019  *        allocations are always satisfied completely.
13020  *        Hence no roll back.
13021  *
13022  * @details
13023  *
13024  *     Function: rgSCHCmnDlRaRspFnlz
13025  *     Purpose:  This function Processes the Final Allocations
13026  *               made by the RB Allocator against the requested.
13027  *               Takes care of PDCCH filling.
13028  *
13029  *     Invoked by: Common Scheduler
13030  *
13031  *  @param[in]  RgSchCellCb           *cell
13032  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
13033  *  @return  Void
13034  *
13035  **/
13036 #ifdef ANSI
13037 PRIVATE Void rgSCHCmnDlRaRspFnlz
13038 (
13039 RgSchCellCb           *cell,
13040 RgSchCmnDlRbAllocInfo *allocInfo
13041 )
13042 #else
13043 PRIVATE Void rgSCHCmnDlRaRspFnlz(cell, allocInfo)
13044 RgSchCellCb           *cell;
13045 RgSchCmnDlRbAllocInfo *allocInfo;
13046 #endif
13047 {
13048    U32            rarCnt = 0;
13049    RgSchDlRbAlloc *raRspAlloc;
13050    RgSchDlSf      *subFrm = NULLP;
13051    RgSchRaCb      *raCb;
13052    RgSchErrInfo   err;
13053    CmLListCp      *reqLst;
13054    RgSchRaReqInfo *raReq;
13055    Bool           preamGrpA;
13056    RgSchUlAlloc   *ulAllocRef=NULLP;
13057    RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
13058    U8              allocRapidCnt = 0;
13059 #ifdef LTE_TDD
13060    U32            msg3SchdIdx = 0;
13061    U8             ulDlCfgIdx = cell->ulDlCfgIdx;
13062    U8             msg3Subfrm;
13063 #endif
13064
13065    TRC2(rgSCHCmnDlRaRspFnlz);
13066
13067    for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
13068    {
13069       raRspAlloc = &allocInfo->raRspAlloc[rarCnt];
13070       /* Having likely condition first for optimization */
13071       if (!raRspAlloc->pdcch)
13072       {
13073          continue;
13074       }
13075       else
13076       {
13077          subFrm = raRspAlloc->dlSf;
13078          reqLst = &cell->raInfo.raReqLst[raRspAlloc->raIndex];
13079          /* Corrected RACH handling for multiple RAPIDs per RARNTI */
13080          allocRapidCnt = raRspAlloc->numRapids;
13081          while (allocRapidCnt)
13082          {
13083             raReq = (RgSchRaReqInfo *)(reqLst->first->node);
13084             /* RACHO: If dedicated preamble, then allocate UL Grant
13085              * (consequence of handover/pdcchOrder) and continue */
13086             if (RGSCH_IS_DEDPRM(cell, raReq->raReq.rapId))
13087             {
13088                rgSCHCmnHdlHoPo(cell, &subFrm->raRsp[rarCnt].contFreeUeLst,
13089                      raReq);
13090                cmLListDelFrm(reqLst, reqLst->first);
13091                allocRapidCnt--;
13092                /* ccpu00117052 - MOD - Passing double pointer
13093                for proper NULLP assignment*/
13094                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13095                      sizeof(RgSchRaReqInfo));
13096                continue;
13097             }
13098             /* ccpu00139815 */
13099             if(cell->overLoadBackOffEnab)
13100             {/* rach Overlaod conrol is triggerd, Skipping this rach */
13101                cmLListDelFrm(reqLst, reqLst->first);
13102                allocRapidCnt--;
13103                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13104                      sizeof(RgSchRaReqInfo));
13105                continue;
13106             }
13107             /* Attempt to include each RA request into the RSP */
13108             /* Any failure in the procedure is considered to   */
13109             /* affect futher allocations in the same TTI. When */
13110             /* a failure happens, we break out and complete    */
13111             /* the processing for random access                */
13112             if (rgSCHRamCreateRaCb(cell, &raCb, &err) != ROK)
13113             {
13114                break;
13115             }
13116             /* Msg3 allocation request to USM */
13117             if (raReq->raReq.rapId < cell->rachCfg.sizeRaPreambleGrpA)
13118                preamGrpA = TRUE;
13119             else
13120                preamGrpA = FALSE;
13121             /*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
13122             rgSCHCmnMsg3GrntReq(cell, raCb->tmpCrnti, preamGrpA, \
13123                   &(raCb->msg3HqProc), &ulAllocRef, &raCb->msg3HqProcId);
13124             if (ulAllocRef == NULLP)
13125             {
13126                rgSCHRamDelRaCb(cell, raCb, TRUE);
13127                break;
13128             }
13129             if (raReq->raReq.cqiPres)
13130             {
13131                raCb->ccchCqi = raReq->raReq.cqiIdx;
13132             }
13133             else
13134             {
13135                raCb->ccchCqi = cellDl->ccchCqi;
13136             }
13137             raCb->rapId = raReq->raReq.rapId;
13138             raCb->ta.pres    = TRUE;
13139             raCb->ta.val = raReq->raReq.ta;
13140             raCb->msg3Grnt = ulAllocRef->grnt;
13141             /* Populating the tpc value received */
13142             raCb->msg3Grnt.tpc = raReq->raReq.tpc;
13143             /* PHR handling for MSG3 */
13144             ulAllocRef->raCb = raCb;
13145 #ifndef LTE_TDD
13146             /* To the crntTime, add the MIN time at which UE will
13147              * actually send MSG3 i.e DL_DELTA+6 */
13148             raCb->msg3AllocTime = cell->crntTime;
13149             RGSCH_INCR_SUB_FRAME(raCb->msg3AllocTime, RG_SCH_CMN_MIN_MSG3_RECP_INTRVL);
13150 #else
13151             msg3SchdIdx = (cell->crntTime.subframe+RG_SCH_CMN_DL_DELTA) % 
13152                                  RGSCH_NUM_SUB_FRAMES;
13153             /*[ccpu00134666]-MOD-Modify the check to schedule the RAR in
13154               special subframe */                       
13155             if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][msg3SchdIdx] != 
13156                         RG_SCH_TDD_UL_SUBFRAME)
13157             {
13158                RGSCHCMNADDTOCRNTTIME(cell->crntTime,raCb->msg3AllocTime,
13159                                        RG_SCH_CMN_DL_DELTA)
13160                msg3Subfrm = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][
13161                                        raCb->msg3AllocTime.subframe];
13162                RGSCHCMNADDTOCRNTTIME(raCb->msg3AllocTime, raCb->msg3AllocTime, 
13163                                  msg3Subfrm);
13164             }
13165 #endif
13166             cmLListAdd2Tail(&subFrm->raRsp[rarCnt].raRspLst, &raCb->rspLnk);
13167             raCb->rspLnk.node = (PTR)raCb;
13168             cmLListDelFrm(reqLst, reqLst->first);
13169             allocRapidCnt--;
13170             /* ccpu00117052 - MOD - Passing double pointer
13171             for proper NULLP assignment*/
13172             rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13173                   sizeof(RgSchRaReqInfo));
13174
13175             /* SR_RACH_STATS : RAR scheduled */
13176             rgNumRarSched++;
13177
13178          }
13179          /* R8 Upgrade */
13180          /* Fill subframe data members */
13181          subFrm->raRsp[rarCnt].raRnti = raRspAlloc->rnti;
13182          subFrm->raRsp[rarCnt].pdcch  = raRspAlloc->pdcch;
13183          subFrm->raRsp[rarCnt].tbSz   = raRspAlloc->tbInfo[0].bytesAlloc;
13184          /* Fill PDCCH data members */
13185          rgSCHCmnFillPdcch(cell, subFrm->raRsp[rarCnt].pdcch, raRspAlloc);
13186
13187          /* ccpu00139815 */
13188          if(cell->overLoadBackOffEnab)
13189          {/* rach Overlaod conrol is triggerd, Skipping this rach */
13190             subFrm->raRsp[rarCnt].backOffInd.pres = PRSNT_NODEF;
13191             subFrm->raRsp[rarCnt].backOffInd.val  = cell->overLoadBackOffval;
13192             continue;
13193          }
13194          else
13195          {
13196             subFrm->raRsp[rarCnt].backOffInd.pres = NOTPRSNT;
13197          }
13198
13199          /*[ccpu00125212] Avoiding sending of empty RAR in case of RAR window
13200            is short and UE is sending unauthorised preamble.*/
13201          reqLst = &cell->raInfo.raReqLst[raRspAlloc->raIndex];
13202          if ((raRspAlloc->biEstmt) && (reqLst->count))
13203          {
13204             subFrm->raRsp[0].backOffInd.pres = PRSNT_NODEF;
13205             /* Added as part of Upgrade */
13206             subFrm->raRsp[0].backOffInd.val =
13207             rgSCHCmnGetBiIndex(cell, reqLst->count);
13208
13209             /* SR_RACH_STATS : Back Off Inds */
13210             rgNumBI++;
13211
13212          }
13213          else if ((subFrm->raRsp[rarCnt].raRspLst.first == NULLP) &&
13214                (subFrm->raRsp[rarCnt].contFreeUeLst.first == NULLP))
13215          {
13216             /* Return the grabbed PDCCH */
13217             rgSCHUtlPdcchPut(cell, &subFrm->pdcchInfo, raRspAlloc->pdcch);
13218             subFrm->raRsp[rarCnt].pdcch = NULLP;
13219             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
13220                   "Not even one RaReq.");
13221             RETVOID;
13222          }
13223       }
13224       RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, 
13225             "RNTI:%d Scheduled RAR @ (%u,%u) ",
13226             raRspAlloc->rnti, 
13227             cell->crntTime.sfn,
13228             cell->crntTime.subframe);
13229    }
13230    RETVOID;
13231 }
13232
13233 /**
13234  * @brief This function computes rv.
13235  *
13236  * @details
13237  *
13238  *     Function: rgSCHCmnDlCalcRvForBcch
13239  *     Purpose:  This function computes rv.
13240  *
13241  *     Invoked by: Common Scheduler
13242  *
13243  *  @param[in]   RgSchCellCb     *cell
13244  *  @param[in]   Bool            si
13245  *  @param[in]   U16             i
13246  *  @return  U8
13247  *
13248  **/
13249 #ifdef ANSI
13250 PRIVATE U8 rgSCHCmnDlCalcRvForBcch
13251 (
13252 RgSchCellCb          *cell,
13253 Bool                 si,
13254 U16                  i
13255 )
13256 #else
13257 PRIVATE U8 rgSCHCmnDlCalcRvForBcch(cell, si, i)
13258 RgSchCellCb          *cell;
13259 Bool                 si;
13260 U16                  i;
13261 #endif
13262 {
13263    U8 k, rv;
13264    CmLteTimingInfo   frm;
13265    TRC2(rgSCHCmnDlCalcRvForBcch);
13266
13267    frm   = cell->crntTime;
13268    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
13269
13270    if(si)
13271    {
13272       k = i % 4;
13273    }
13274    else
13275    {
13276       k = (frm.sfn/2) % 4;
13277    }
13278    rv = RGSCH_CEIL(3*k, 2) % 4;
13279    RETVALUE(rv);
13280 }
13281
13282 /**
13283  * @brief This function Processes the Final Allocations
13284  *        made by the RB Allocator against the requested
13285  *        BCCH/PCCH allocations. Assumption: The reuqested
13286  *        allocations are always satisfied completely.
13287  *        Hence no roll back.
13288  *
13289  * @details
13290  *
13291  *     Function: rgSCHCmnDlBcchPcchFnlz
13292  *     Purpose:  This function Processes the Final Allocations
13293  *               made by the RB Allocator against the requested.
13294  *               Takes care of PDCCH filling.
13295  *
13296  *     Invoked by: Common Scheduler
13297  *
13298  *  @param[in]  RgSchCellCb           *cell
13299  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
13300  *  @return  Void
13301  *
13302  **/
13303 #ifdef ANSI
13304 PRIVATE Void rgSCHCmnDlBcchPcchFnlz
13305 (
13306 RgSchCellCb           *cell,
13307 RgSchCmnDlRbAllocInfo *allocInfo
13308 )
13309 #else
13310 PRIVATE Void rgSCHCmnDlBcchPcchFnlz(cell, allocInfo)
13311 RgSchCellCb           *cell;
13312 RgSchCmnDlRbAllocInfo *allocInfo;
13313 #endif
13314 {
13315    RgSchDlRbAlloc *rbAllocInfo;
13316    RgSchDlSf      *subFrm;
13317
13318 #ifdef LTE_TDD
13319    U8             nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
13320 #else
13321 #ifdef LTEMAC_HDFDD
13322    U8             nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13323 #else
13324    U8             nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13325 #endif
13326 #endif
13327
13328    /*  Moving variables to available scope for optimization */
13329    RgSchClcDlLcCb *pcch;
13330    RgSchClcBoRpt  *bo;
13331 #ifndef RGR_SI_SCH
13332    RgSchClcDlLcCb  *bcch;
13333    Bool           sendInd=TRUE;
13334 #endif
13335    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
13336
13337    TRC2(rgSCHCmnDlBcchPcchFnlz);
13338
13339    /* handle PCCH */
13340    rbAllocInfo = &allocInfo->pcchAlloc;
13341    if (rbAllocInfo->pdcch)
13342    {
13343       RgInfSfAlloc   *subfrmAlloc = &(cell->sfAllocArr[nextSfIdx]);
13344
13345       /* Added sfIdx calculation for TDD as well */
13346 #ifndef LTE_TDD
13347 #ifdef LTEMAC_HDFDD
13348       nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13349 #else
13350       nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13351 #endif
13352 #endif
13353       subFrm = rbAllocInfo->dlSf;
13354       pcch = rgSCHDbmGetPcch(cell);
13355       if(pcch == NULLP)
13356       {
13357          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
13358                "No Pcch Present");
13359          RETVOID;
13360       }
13361
13362       /* Added Dl TB count for paging message transmission*/
13363 #ifdef LTE_L2_MEAS
13364       cell->dlUlTbCnt.tbTransDlTotalCnt++;
13365 #endif      
13366       bo = (RgSchClcBoRpt *)pcch->boLst.first->node;
13367       cmLListDelFrm(&pcch->boLst, &bo->boLstEnt);
13368       /* ccpu00117052 - MOD - Passing double pointer
13369          for proper NULLP assignment*/
13370       rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
13371       /* Fill subframe data members */
13372       subFrm->pcch.tbSize = rbAllocInfo->tbInfo[0].bytesAlloc;
13373       subFrm->pcch.pdcch  = rbAllocInfo->pdcch;
13374       /* Fill PDCCH data members */
13375       rgSCHCmnFillPdcch(cell, subFrm->pcch.pdcch, rbAllocInfo);
13376       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, pcch->lcId, TRUE);
13377       /* ccpu00132314-ADD-Update the tx power allocation info  
13378          TODO-Need to add a check for max tx power per symbol */ 
13379       subfrmAlloc->cmnLcInfo.pcchInfo.txPwrOffset = cellDl->pcchTxPwrOffset;   
13380    }
13381
13382    /* handle BCCH */
13383    rbAllocInfo = &allocInfo->bcchAlloc;
13384    if (rbAllocInfo->pdcch)
13385    {
13386       RgInfSfAlloc   *subfrmAlloc = &(cell->sfAllocArr[nextSfIdx]);
13387 #ifndef LTE_TDD
13388 #ifdef LTEMAC_HDFDD
13389       nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13390 #else
13391       nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13392 #endif
13393 #endif
13394       subFrm = rbAllocInfo->dlSf;
13395
13396       /* Fill subframe data members */
13397       subFrm->bcch.tbSize = rbAllocInfo->tbInfo[0].bytesAlloc;
13398       subFrm->bcch.pdcch  = rbAllocInfo->pdcch;
13399       /* Fill PDCCH data members */
13400       rgSCHCmnFillPdcch(cell, subFrm->bcch.pdcch, rbAllocInfo);
13401
13402       if(rbAllocInfo->schdFirst)
13403       {
13404 #ifndef RGR_SI_SCH
13405          bcch = rgSCHDbmGetFirstBcchOnDlsch(cell);
13406          bo = (RgSchClcBoRpt *)bcch->boLst.first->node;
13407 #else
13408          /*Copy the SIB1 msg buff into interface buffer */
13409          SCpyMsgMsg(cell->siCb.crntSiInfo.sib1Info.sib1,
13410                rgSchCb[cell->instIdx].rgSchInit.region,
13411                rgSchCb[cell->instIdx].rgSchInit.pool,
13412                &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13413 #endif/*RGR_SI_SCH*/
13414          subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv =
13415             rgSCHCmnDlCalcRvForBcch(cell, FALSE, 0);
13416       }
13417       else
13418       {
13419          U16   i;
13420 #ifdef RGR_SI_SCH
13421          Buffer    *pdu;
13422
13423          i = cell->siCb.siCtx.i;
13424          /*Decrement the retransmission count */
13425          cell->siCb.siCtx.retxCntRem--;
13426
13427          /*Copy the SI msg buff into interface buffer */
13428          if(cell->siCb.siCtx.warningSiFlag == FALSE)
13429          {
13430             SCpyMsgMsg(cell->siCb.siArray[cell->siCb.siCtx.siId-1].si,
13431                   rgSchCb[cell->instIdx].rgSchInit.region,
13432                   rgSchCb[cell->instIdx].rgSchInit.pool,
13433                   &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13434          }
13435          else
13436          {
13437             pdu = rgSCHUtlGetWarningSiPdu(cell);
13438             RGSCH_NULL_CHECK(cell->instIdx, pdu);
13439             SCpyMsgMsg(pdu,
13440                   rgSchCb[cell->instIdx].rgSchInit.region,
13441                   rgSchCb[cell->instIdx].rgSchInit.pool,
13442                   &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13443             if(cell->siCb.siCtx.retxCntRem == 0)
13444             {  
13445                rgSCHUtlFreeWarningSiPdu(cell);
13446                cell->siCb.siCtx.warningSiFlag  = FALSE;
13447
13448             }
13449          }
13450 #else
13451          bcch = rgSCHDbmGetSecondBcchOnDlsch(cell);
13452          bo = (RgSchClcBoRpt *)bcch->boLst.first->node;
13453          bo->retxCnt--;
13454          if(bo->retxCnt != cell->siCfg.retxCnt-1)
13455          {
13456             sendInd=FALSE;
13457          }
13458          i = bo->i;
13459 #endif/*RGR_SI_SCH*/
13460          subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv =
13461             rgSCHCmnDlCalcRvForBcch(cell, TRUE, i);
13462       }
13463
13464       /* Added Dl TB count for SIB1 and SI messages transmission.
13465        * This counter will be incremented only for the first transmission
13466        * (with RV 0) of these messages*/
13467 #ifdef LTE_L2_MEAS
13468       if(subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv == 0)
13469       {   
13470          cell->dlUlTbCnt.tbTransDlTotalCnt++;
13471       }
13472 #endif      
13473 #ifndef RGR_SI_SCH
13474       if(bo->retxCnt == 0)
13475       {
13476          cmLListDelFrm(&bcch->boLst, &bo->boLstEnt);
13477          /* ccpu00117052 - MOD - Passing double pointer
13478             for proper NULLP assignment*/
13479          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
13480       }
13481       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, bcch->lcId, sendInd);
13482 #else
13483       /*Fill the interface info */
13484       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, NULLD, NULLD);
13485
13486       /* ccpu00132314-ADD-Update the tx power allocation info  
13487          TODO-Need to add a check for max tx power per symbol */ 
13488       subfrmAlloc->cmnLcInfo.bcchInfo.txPwrOffset = cellDl->bcchTxPwrOffset;   
13489
13490       /*mBuf has been already copied above */
13491 #endif/*RGR_SI_SCH*/
13492    }
13493
13494    RETVOID;
13495 }
13496
13497
13498 #if RG_UNUSED
13499 /**
13500  * @brief
13501  *
13502  * @details
13503  *
13504  *     Function: rgSCHCmnUlSetAllUnSched
13505  *     Purpose:
13506  *
13507  *     Invoked by: Common Scheduler
13508  *
13509  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13510  *  @return  Void
13511  *
13512  **/
13513 #ifdef ANSI
13514 PRIVATE Void rgSCHCmnUlSetAllUnSched
13515 (
13516 RgSchCmnUlRbAllocInfo *allocInfo
13517 )
13518 #else
13519 PRIVATE Void rgSCHCmnUlSetAllUnSched(allocInfo)
13520 RgSchCmnUlRbAllocInfo *allocInfo;
13521 #endif
13522 {
13523    CmLList            *node;
13524
13525    TRC2(rgSCHCmnUlSetAllUnSched);
13526
13527    node = allocInfo->contResLst.first;
13528    while (node)
13529    {
13530       rgSCHCmnUlMov2NonSchdCntResLst(allocInfo, (RgSchUeCb *)node->node);
13531       node = allocInfo->contResLst.first;
13532    }
13533
13534    node = allocInfo->retxUeLst.first;
13535    while (node)
13536    {
13537       rgSCHCmnUlMov2NonSchdRetxUeLst(allocInfo, (RgSchUeCb *)node->node);
13538       node = allocInfo->retxUeLst.first;
13539    }
13540
13541    node = allocInfo->ueLst.first;
13542    while (node)
13543    {
13544       rgSCHCmnUlMov2NonSchdUeLst(allocInfo, (RgSchUeCb *)node->node);
13545       node = allocInfo->ueLst.first;
13546    }
13547
13548    RETVOID;
13549 }
13550 #endif
13551
13552 /**
13553  * @brief
13554  *
13555  * @details
13556  *
13557  *     Function: rgSCHCmnUlAdd2CntResLst
13558  *     Purpose:
13559  *
13560  *     Invoked by: Common Scheduler
13561  *
13562  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13563  *  @param[in]  RgSchUeCb             *ue
13564  *  @return  Void
13565  *
13566  **/
13567 #ifdef ANSI
13568 PUBLIC Void rgSCHCmnUlAdd2CntResLst
13569 (
13570 RgSchCmnUlRbAllocInfo *allocInfo,
13571 RgSchUeCb             *ue
13572 )
13573 #else
13574 PUBLIC Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
13575 RgSchCmnUlRbAllocInfo *allocInfo;
13576 RgSchUeCb             *ue;
13577 #endif
13578 {
13579    RgSchCmnUeUlAlloc  *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
13580    TRC2(rgSCHCmnUlAdd2CntResLst);
13581    cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
13582    ulAllocInfo->reqLnk.node = (PTR)ue;
13583    RETVOID;
13584 }
13585
13586 /**
13587  * @brief
13588  *
13589  * @details
13590  *
13591  *     Function: rgSCHCmnUlAdd2UeLst
13592  *     Purpose:
13593  *
13594  *     Invoked by: Common Scheduler
13595  *
13596  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13597  *  @param[in]  RgSchUeCb             *ue
13598  *  @return  Void
13599  *
13600  **/
13601 #ifdef ANSI
13602 PUBLIC Void rgSCHCmnUlAdd2UeLst
13603 (
13604 RgSchCellCb           *cell,
13605 RgSchCmnUlRbAllocInfo *allocInfo,
13606 RgSchUeCb             *ue
13607 )
13608 #else
13609 PUBLIC Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
13610 RgSchCellCb           *cell;
13611 RgSchCmnUlRbAllocInfo *allocInfo;
13612 RgSchUeCb             *ue;
13613 #endif
13614 {
13615    RgSchCmnUeUlAlloc  *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
13616    TRC2(rgSCHCmnUlAdd2UeLst);
13617    if (ulAllocInfo->reqLnk.node == NULLP)
13618    {
13619       cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
13620       ulAllocInfo->reqLnk.node = (PTR)ue;
13621    }
13622    RETVOID;
13623 }
13624
13625 /**
13626  * @brief
13627  *
13628  * @details
13629  *
13630  *     Function: rgSCHCmnAllocUlRb
13631  *     Purpose:  To do RB allocations for uplink
13632  *
13633  *     Invoked by: Common Scheduler
13634  *
13635  *  @param[in]  RgSchCellCb           *cell
13636  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
13637  *  @return  Void
13638  **/
13639 #ifdef ANSI
13640 PUBLIC Void rgSCHCmnAllocUlRb
13641 (
13642 RgSchCellCb           *cell,
13643 RgSchCmnUlRbAllocInfo *allocInfo
13644 )
13645 #else
13646 PUBLIC Void rgSCHCmnAllocUlRb(cell, allocInfo)
13647 RgSchCellCb           *cell;
13648 RgSchCmnUlRbAllocInfo *allocInfo;
13649 #endif
13650 {
13651    RgSchUlSf         *sf = allocInfo->sf;
13652    TRC2(rgSCHCmnAllocUlRb);
13653
13654    /* Schedule for new transmissions */
13655    rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
13656          &allocInfo->ueLst, &allocInfo->schdUeLst,
13657          &allocInfo->nonSchdUeLst, (Bool)TRUE);
13658    RETVOID;
13659 }
13660
13661 /***********************************************************
13662  *
13663  *     Func : rgSCHCmnUlRbAllocForLst
13664  *
13665  *     Desc : Allocate for a list in cmn rb alloc information passed
13666  *            in a subframe.
13667  *
13668  *     Ret  :
13669  *
13670  *     Notes:
13671  *
13672  *     File :
13673  *
13674  **********************************************************/
13675 #ifdef ANSI
13676 PRIVATE Void rgSCHCmnUlRbAllocForLst
13677 (
13678 RgSchCellCb           *cell,
13679 RgSchUlSf             *sf,
13680 U32                   count,
13681 CmLListCp             *reqLst,
13682 CmLListCp             *schdLst,
13683 CmLListCp             *nonSchdLst,
13684 Bool                  isNewTx
13685 )
13686 #else
13687 PRIVATE Void rgSCHCmnUlRbAllocForLst(cell, sf, count, reqLst, schdLst,
13688                                      nonSchdLst, isNewTx)
13689 RgSchCellCb           *cell;
13690 RgSchUlSf             *sf;
13691 U32                   count;
13692 CmLListCp             *reqLst;
13693 CmLListCp             *schdLst;
13694 CmLListCp             *nonSchdLst;
13695 Bool                  isNewTx;
13696 #endif
13697 {
13698    CmLList          *lnk;
13699    RgSchUlHole      *hole;
13700 #ifdef LTE_L2_MEAS
13701 #ifdef LTE_TDD
13702    U8               k;
13703    CmLteTimingInfo  timeInfo;
13704 #endif    
13705 #endif    
13706    TRC2(rgSCHCmnUlRbAllocForLst);
13707
13708    if(schdLst->count == 0)
13709    {
13710       cmLListInit(schdLst);
13711    }
13712
13713    cmLListInit(nonSchdLst);
13714 #ifdef LTE_L2_MEAS
13715    if(isNewTx == TRUE)
13716    {
13717       cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (U8) count;
13718 #ifdef LTE_TDD
13719       RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, timeInfo, TFU_ULCNTRL_DLDELTA);
13720       k = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][timeInfo.subframe];
13721       RG_SCH_ADD_TO_CRNT_TIME(timeInfo,
13722           cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.timingInfo, k);
13723 #else
13724       RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime,cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.timingInfo,
13725                             (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
13726 #endif
13727    }
13728 #endif
13729
13730    for (lnk = reqLst->first; count; lnk = lnk->next, --count)
13731    {
13732       RgSchUeCb             *ue = (RgSchUeCb *)lnk->node;
13733       RgSchCmnUlUe          *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
13734       S16                   ret;
13735       U8                    maxRb;
13736
13737
13738       if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
13739       {
13740          break;
13741       }
13742
13743       ueUl->subbandShare = ueUl->subbandRequired;
13744       if(isNewTx == TRUE)
13745       {
13746          maxRb = RGSCH_MIN((ueUl->subbandRequired * MAX_5GTF_VRBG_SIZE), ue->ue5gtfCb.maxPrb);
13747       } 
13748       ret = rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole);
13749       if (ret == ROK)
13750       {
13751          rgSCHCmnUlRbAllocAddUeToLst(cell, ue, schdLst);
13752          rgSCHCmnUlUeFillAllocInfo(cell, ue);
13753       }
13754       else
13755       {
13756          gUl5gtfRbAllocFail++;
13757 #if defined (TENB_STATS) && defined (RG_5GTF)
13758          cell->tenbStats->sch.ul5gtfRbAllocFail++;
13759 #endif
13760          rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
13761          ue->isMsg4PdcchWithCrnti = FALSE;
13762          ue->isSrGrant = FALSE;
13763       }
13764 #ifdef LTE_L2_MEAS
13765       if(isNewTx == TRUE)
13766       {
13767          cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.
13768          ulAllocInfo[count - 1].rnti   = ue->ueId;
13769          cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.
13770          ulAllocInfo[count - 1].numPrb = ue->ul.nPrb;
13771       }
13772 #endif
13773       ueUl->subbandShare = 0; /* This reset will take care of
13774                                   * all scheduler types */
13775    }
13776    for (; count; lnk = lnk->next, --count)
13777    {
13778       RgSchUeCb             *ue = (RgSchUeCb *)lnk->node;
13779       rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
13780       ue->isMsg4PdcchWithCrnti = FALSE;
13781    }
13782    RETVOID;
13783 }
13784
13785 #ifdef TFU_UPGRADE
13786 /***********************************************************
13787  *
13788  *     Func : rgSCHCmnUlMdfyGrntForCqi
13789  *
13790  *     Desc : Modify UL Grant to consider presence of 
13791  *            CQI along with PUSCH Data.
13792  *
13793  *     Ret  :
13794  *
13795  *     Notes: 
13796  *          -  Scale down iTbs based on betaOffset and
13797  *             size of Acqi Size.
13798  *          -  Optionally attempt to increase numSb by 1
13799  *             if input payload size does not fit in due 
13800  *             to reduced tbSz as a result of iTbsNew.
13801  *
13802  *     File :
13803  *
13804  **********************************************************/
13805 #ifdef ANSI
13806 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi
13807 (
13808 RgSchCellCb  *cell,
13809 RgSchUeCb    *ue,
13810 U32          maxRb,
13811 U32          *numSb,
13812 U8           *iTbs,
13813 U32          hqSz,
13814 U32          stepDownItbs,
13815 U32          effTgt
13816 )
13817 #else
13818 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
13819 RgSchCellCb  *cell;
13820 RgSchUeCb    *ue;
13821 U32          maxRb;
13822 U32          *numSb;
13823 U8           *iTbs;
13824 U32          hqSz;
13825 U32          stepDownItbs;
13826 U32          effTgt;
13827 #endif
13828 {
13829    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(ue->cell);
13830    U32  nPrb;
13831    U32  totREs;
13832    U32  cqiRiREs;
13833    U32  hqREs;
13834    U32  remREsForPusch;
13835    U32  bitsPerRe;
13836    U32  tbSz;
13837    U32  betaOffVal = ue->ul.betaOffstVal;
13838    U32  cqiRiRptSz = ue->ul.cqiRiSz;
13839    U32  betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
13840    U32  resNumSb = *numSb;
13841    U32  puschEff = 1000;
13842    U8   modOdr;
13843    U8   iMcs;
13844    Bool mdfyiTbsFlg = FALSE;
13845    U8   resiTbs = *iTbs;
13846
13847    TRC2(rgSCHCmnUlMdfyGrntForCqi)
13848
13849    
13850    do
13851    {
13852       iMcs  = rgSCHCmnUlGetIMcsFrmITbs(resiTbs, RG_SCH_CMN_GET_UE_CTGY(ue));
13853       RG_SCH_UL_MCS_TO_MODODR(iMcs, modOdr);
13854       if (RG_SCH_CMN_GET_UE_CTGY(ue) != CM_LTE_UE_CAT_5)
13855       {
13856          modOdr = RGSCH_MIN(RGSCH_QM_QPSK, modOdr);
13857       }
13858       else
13859       {
13860          modOdr = RGSCH_MIN(RGSCH_QM_64QAM, modOdr);
13861       }
13862       nPrb = resNumSb * cellUl->sbSize;
13863       /* Restricting the minumum iTbs requried to modify to 10 */
13864       if ((nPrb >= maxRb) && (resiTbs <= 10))
13865       {
13866          /* Could not accomodate ACQI */
13867          RETVALUE(RFAILED);
13868       }
13869       totREs = nPrb * RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
13870       tbSz = rgTbSzTbl[0][resiTbs][nPrb-1];
13871       /*  totalREs/tbSz = num of bits perRE.  */
13872       cqiRiREs = (totREs * betaOffVal * cqiRiRptSz)/(1000 * tbSz); /* betaOffVal is represented 
13873                                                                    as parts per 1000 */
13874       hqREs = (totREs * betaOffHqVal * hqSz)/(1000 * tbSz);
13875       if ((cqiRiREs + hqREs) < totREs)
13876       {
13877          remREsForPusch = totREs - cqiRiREs - hqREs;
13878          bitsPerRe = (tbSz * 1000)/remREsForPusch; /* Multiplying by 1000 for Interger Oper */
13879          puschEff = bitsPerRe/modOdr;
13880       }
13881       if (puschEff < effTgt)
13882       {
13883           /* ensure resultant efficiency for PUSCH Data is within 0.93*/
13884           break;
13885       }
13886       else
13887       {
13888          /* Alternate between increasing SB or decreasing iTbs until eff is met */
13889          if (mdfyiTbsFlg == FALSE)
13890          {
13891             if (nPrb < maxRb)
13892             {
13893               resNumSb = resNumSb + 1;
13894             }
13895             mdfyiTbsFlg = TRUE;
13896          }
13897          else
13898          {
13899             if (resiTbs > 10)
13900             {
13901                resiTbs-= stepDownItbs;
13902             }
13903             mdfyiTbsFlg = FALSE;
13904          }
13905       }
13906    }while (1); /* Loop breaks if efficency is met 
13907                   or returns RFAILED if not able to meet the efficiency */
13908               
13909    *numSb = resNumSb;
13910    *iTbs = resiTbs;
13911
13912    RETVALUE(ROK);
13913 }
13914 #endif
13915 /***********************************************************
13916  *
13917  *     Func : rgSCHCmnUlRbAllocForUe
13918  *
13919  *     Desc : Do uplink RB allocation for an UE.
13920  *
13921  *     Ret  :
13922  *
13923  *     Notes: Note that as of now, for retx, maxRb
13924  *            is not considered. Alternatives, such
13925  *            as dropping retx if it crosses maxRb
13926  *            could be considered.
13927  *
13928  *     File :
13929  *
13930  **********************************************************/
13931 #ifdef ANSI
13932 PRIVATE S16 rgSCHCmnUlRbAllocForUe
13933 (
13934 RgSchCellCb           *cell,
13935 RgSchUlSf             *sf,
13936 RgSchUeCb             *ue,
13937 U8                    maxRb,
13938 RgSchUlHole           *hole
13939 )
13940 #else
13941 PRIVATE S16 rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole)
13942 RgSchCellCb           *cell;
13943 RgSchUlSf             *sf;
13944 RgSchUeCb             *ue;
13945 U8                    maxRb;
13946 RgSchUlHole           *hole;
13947 #endif
13948 {
13949    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
13950    RgSchCmnUlUe    *ueUl    = RG_SCH_CMN_GET_UL_UE(ue, cell);
13951    RgSchUlAlloc     *alloc = NULLP;
13952    U32              nPrb = 0;
13953    U8               numVrbg;
13954    U8               iMcs;
13955    U8               iMcsCrnt;
13956 #ifndef RG_5GTF
13957    RgSchUlHqProcCb  *proc = &ueUl->hqEnt.hqProcCb[cellUl->schdHqProcIdx];
13958 #else
13959    RgSchUlHqProcCb  *proc = NULLP;
13960 #endif
13961    RgSchPdcch       *pdcch;
13962    U32              reqVrbg;
13963    U8               numVrbgTemp;
13964 #ifdef RG_5GTF
13965    TfuDciFormat     dciFrmt;
13966    U8               numLyr;
13967 #endif
13968
13969    TRC2(rgSCHCmnUlRbAllocForUe);
13970 #ifdef RG_5GTF
13971    rgSCHUhmGetAvlHqProc(cell, ue, &proc);
13972    if (proc == NULLP)
13973    {
13974       //printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
13975       RETVALUE(RFAILED);
13976    }
13977 #endif
13978
13979    if (ue->ue5gtfCb.rank == 2)
13980    {
13981       dciFrmt = TFU_DCI_FORMAT_A2;
13982       numLyr = 2;
13983    }
13984    else
13985    {
13986       dciFrmt = TFU_DCI_FORMAT_A1;
13987       numLyr = 1;
13988    }
13989    /* 5gtf TODO : To pass dci frmt to this function */
13990    pdcch = rgSCHCmnPdcchAllocCrntSf(cell, ue);
13991    if(pdcch == NULLP)
13992    {
13993       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId, 
13994          "rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
13995       RETVALUE(RFAILED);
13996    }
13997         gUl5gtfPdcchSchd++;
13998 #if defined (TENB_STATS) && defined (RG_5GTF)
13999    cell->tenbStats->sch.ul5gtfPdcchSchd++;
14000 #endif
14001
14002    //TODO_SID using configured prb as of now
14003    nPrb = ue->ue5gtfCb.maxPrb;
14004    reqVrbg = nPrb/MAX_5GTF_VRBG_SIZE;
14005    iMcs  = ue->ue5gtfCb.mcs; //gSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
14006    iMcsCrnt = iMcs;
14007    numVrbg = reqVrbg;
14008
14009    if((sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart > MAX_5GTF_VRBG)
14010          || (sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated > MAX_5GTF_VRBG))
14011    {
14012       printf("5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
14013             , sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated);
14014       int *p=NULLP;
14015       *p = 10;
14016    }
14017
14018    /*TODO_SID: Workaround for alloc. Currently alloc is ulsf based. To handle multiple beams, we need a different
14019      design. Now alloc are formed based on MAX_5GTF_UE_SCH macro. */
14020    numVrbgTemp = MAX_5GTF_VRBG/MAX_5GTF_UE_SCH;
14021    if(numVrbg)
14022    {
14023       alloc = rgSCHCmnUlSbAlloc(sf, numVrbgTemp,\
14024                                 hole);
14025    }
14026    if (alloc == NULLP)
14027    {
14028       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
14029          "rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
14030       rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
14031       RETVALUE(RFAILED);
14032    }
14033    gUl5gtfAllocAllocated++;
14034 #if defined (TENB_STATS) && defined (RG_5GTF)
14035    cell->tenbStats->sch.ul5gtfAllocAllocated++;
14036 #endif
14037    alloc->grnt.vrbgStart = sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart;
14038    alloc->grnt.numVrbg = numVrbg;
14039    alloc->grnt.numLyr = numLyr;
14040    alloc->grnt.dciFrmt = dciFrmt;
14041
14042    sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart += numVrbg;
14043    sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated += numVrbg;
14044
14045    //rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
14046 #ifdef LTE_L2_MEAS
14047    sf->totPrb  += alloc->grnt.numRb;
14048    ue->ul.nPrb = alloc->grnt.numRb;
14049 #endif
14050    if (ue->csgMmbrSta != TRUE)
14051    {
14052       cellUl->ncsgPrbCnt += alloc->grnt.numRb;
14053    }
14054    cellUl->totPrbCnt += (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
14055    alloc->pdcch = pdcch;
14056    alloc->grnt.iMcs = iMcs;
14057    alloc->grnt.iMcsCrnt = iMcsCrnt;
14058    alloc->grnt.hop = 0;
14059    /* Initial Num RBs support for UCI on PUSCH */
14060 #ifdef TFU_UPGRADE
14061    ue->initNumRbs = (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
14062 #endif
14063    alloc->forMsg3 = FALSE;
14064    //RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTb5gtfSzTbl[0], (iTbs)); 
14065
14066    //ueUl->alloc.allocdBytes = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
14067    /* TODO_SID Allocating based on configured MCS as of now.
14068          Currently for format A2. When doing multi grp per tti, need to update this. */
14069    ueUl->alloc.allocdBytes = (rgSch5gtfTbSzTbl[iMcs]/8) * ue->ue5gtfCb.rank;
14070
14071    alloc->grnt.datSz = ueUl->alloc.allocdBytes;
14072    //TODO_SID Need to check mod order.
14073    RG_SCH_CMN_TBS_TO_MODODR(iMcs, alloc->grnt.modOdr);
14074         //alloc->grnt.modOdr = 6;
14075    alloc->grnt.isRtx = FALSE;
14076
14077    alloc->grnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, alloc->grnt.vrbgStart, alloc->grnt.numVrbg);
14078    alloc->grnt.SCID = 0;
14079    alloc->grnt.xPUSCHRange = MAX_5GTF_XPUSCH_RANGE;
14080    alloc->grnt.PMI = 0;
14081    alloc->grnt.uciOnxPUSCH = 0;
14082    alloc->grnt.hqProcId = proc->procId;
14083
14084    alloc->hqProc = proc;
14085    alloc->hqProc->ulSfIdx = cellUl->schdIdx;
14086    alloc->ue = ue;
14087    /*commenting to retain the rnti used for transmission SPS/c-rnti */
14088    alloc->rnti = ue->ueId;
14089    ueUl->alloc.alloc = alloc;
14090    /*rntiwari-Adding the debug for generating the graph.*/
14091    /* No grant attr recorded now */
14092    RETVALUE(ROK);
14093 }
14094
14095 /***********************************************************
14096  *
14097  *     Func : rgSCHCmnUlRbAllocAddUeToLst
14098  *
14099  *     Desc : Add UE to list (scheduled/non-scheduled list)
14100  *            for UL RB allocation information.
14101  *
14102  *     Ret  :
14103  *
14104  *     Notes:
14105  *
14106  *     File :
14107  *
14108  **********************************************************/
14109 #ifdef ANSI
14110 PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst
14111 (
14112 RgSchCellCb           *cell,
14113 RgSchUeCb             *ue,
14114 CmLListCp             *lst
14115 )
14116 #else
14117 PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
14118 RgSchCellCb           *cell;
14119 RgSchUeCb             *ue;
14120 CmLListCp             *lst;
14121 #endif
14122 {
14123    RgSchCmnUlUe   *ueUl   = RG_SCH_CMN_GET_UL_UE(ue,cell);
14124    TRC2(rgSCHCmnUlRbAllocAddUeToLst);
14125    UNUSED(cell);
14126
14127    gUl5gtfUeRbAllocDone++;
14128 #if defined (TENB_STATS) && defined (RG_5GTF)
14129    cell->tenbStats->sch.ul5gtfUeRbAllocDone++;
14130 #endif
14131    cmLListAdd2Tail(lst, &ueUl->alloc.schdLstLnk);
14132    ueUl->alloc.schdLstLnk.node = (PTR)ue;
14133 }
14134
14135
14136 /**
14137  * @brief This function Processes the Final Allocations
14138  *        made by the RB Allocator against the requested.
14139  *
14140  * @details
14141  *
14142  *     Function: rgSCHCmnUlAllocFnlz
14143  *     Purpose:  This function Processes the Final Allocations
14144  *               made by the RB Allocator against the requested.
14145  *
14146  *     Invoked by: Common Scheduler
14147  *
14148  *  @param[in]  RgSchCellCb           *cell
14149  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
14150  *  @return  Void
14151  *
14152  **/
14153 #ifdef ANSI
14154 PRIVATE Void rgSCHCmnUlAllocFnlz
14155 (
14156 RgSchCellCb           *cell,
14157 RgSchCmnUlRbAllocInfo *allocInfo
14158 )
14159 #else
14160 PRIVATE Void rgSCHCmnUlAllocFnlz(cell, allocInfo)
14161 RgSchCellCb           *cell;
14162 RgSchCmnUlRbAllocInfo *allocInfo;
14163 #endif
14164 {
14165    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
14166    TRC2(rgSCHCmnUlAllocFnlz);
14167
14168    /* call scheduler specific Finalization */
14169    cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
14170
14171    RETVOID;
14172 }
14173
14174 /**
14175  * @brief This function Processes the Final Allocations
14176  *        made by the RB Allocator against the requested.
14177  *
14178  * @details
14179  *
14180  *     Function: rgSCHCmnDlAllocFnlz
14181  *     Purpose:  This function Processes the Final Allocations
14182  *               made by the RB Allocator against the requested.
14183  *
14184  *     Invoked by: Common Scheduler
14185  *
14186  *  @param[in]  RgSchCellCb           *cell
14187  *  @return  Void
14188  *
14189  **/
14190 #ifdef ANSI
14191 PUBLIC Void rgSCHCmnDlAllocFnlz
14192 (
14193 RgSchCellCb           *cell
14194 )
14195 #else
14196 PUBLIC Void rgSCHCmnDlAllocFnlz(cell)
14197 RgSchCellCb           *cell;
14198 #endif
14199 {
14200    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14201    RgSchCmnDlRbAllocInfo  *allocInfo = &cellSch->allocInfo; 
14202
14203    TRC2(rgSCHCmnDlAllocFnlz);
14204
14205    rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
14206    rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
14207 #ifdef RGR_V1
14208    /* Added below functions for handling CCCH SDU transmission received
14209     * after
14210     *     * guard timer expiry*/
14211    rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo);
14212    rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo);
14213 #endif
14214    rgSCHCmnDlRaRspFnlz(cell, allocInfo);
14215       /* call scheduler specific Finalization */
14216    cellSch->apisDl->rgSCHDlAllocFnlz(cell, allocInfo);
14217
14218    /* Stack Crash problem for TRACE5 Changes. Added the return below */
14219    RETVOID;
14220
14221 }
14222
14223 #ifdef RG_UNUSED
14224 /**
14225  * @brief Update an uplink subframe.
14226  *
14227  * @details
14228  *
14229  *     Function : rgSCHCmnUlUpdSf
14230  *
14231  *     For each allocation
14232  *      - if no more tx needed
14233  *         - Release allocation
14234  *      - else
14235  *         - Perform retransmission
14236  *
14237  *  @param[in]  RgSchUlSf *sf
14238  *  @return  Void
14239  **/
14240 #ifdef ANSI
14241 PRIVATE Void rgSCHCmnUlUpdSf
14242 (
14243 RgSchCellCb           *cell,
14244 RgSchCmnUlRbAllocInfo *allocInfo,
14245 RgSchUlSf *sf
14246 )
14247 #else
14248 PRIVATE Void rgSCHCmnUlUpdSf(cell, allocInfo, sf)
14249 RgSchCellCb           *cell;
14250 RgSchCmnUlRbAllocInfo *allocInfo;
14251 RgSchUlSf *sf;
14252 #endif
14253 {
14254    CmLList        *lnk;
14255    TRC2(rgSCHCmnUlUpdSf);
14256
14257    while ((lnk = sf->allocs.first))
14258    {
14259       RgSchUlAlloc  *alloc = (RgSchUlAlloc *)lnk->node;
14260       lnk = lnk->next;
14261
14262       if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
14263       {
14264       }
14265       else
14266       {
14267          /* If need to handle all retx together, run another loop separately */
14268          rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc);
14269       }
14270       rgSCHCmnUlRlsUlAlloc(cell, sf, alloc);
14271    }
14272
14273    /* By this time, all allocs would have been cleared and
14274     * SF is reset to be made ready for new allocations. */
14275    rgSCHCmnUlSfReset(cell, sf);
14276    /* In case there are timing problems due to msg3
14277     * allocations being done in advance, (which will
14278     * probably happen with the current FDD code that
14279     * handles 8 subframes) one solution
14280     * could be to hold the (recent) msg3 allocs in a separate
14281     * list, and then possibly add that to the actual
14282     * list later. So at this time while allocations are
14283     * traversed, the recent msg3 ones are not seen. Anytime after
14284     * this (a good time is when the usual allocations
14285     * are made), msg3 allocations could be transferred to the
14286     * normal list. Not doing this now as it is assumed
14287     * that incorporation of TDD shall take care of this.
14288     */
14289
14290
14291    RETVOID;
14292 }
14293
14294 /**
14295  * @brief Handle uplink allocation for retransmission.
14296  *
14297  * @details
14298  *
14299  *     Function : rgSCHCmnUlHndlAllocRetx
14300  *
14301  *     Processing Steps:
14302  *     - Add to queue for retx.
14303  *     - Do not release here, release happends as part
14304  *       of the loop that calls this function.
14305  *
14306  *  @param[in]  RgSchCellCb           *cell
14307  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
14308  *  @param[in]  RgSchUlSf *sf
14309  *  @param[in]  RgSchUlAlloc  *alloc
14310  *  @return  Void
14311  **/
14312 #ifdef ANSI
14313 PRIVATE Void rgSCHCmnUlHndlAllocRetx
14314 (
14315 RgSchCellCb           *cell,
14316 RgSchCmnUlRbAllocInfo *allocInfo,
14317 RgSchUlSf     *sf,
14318 RgSchUlAlloc  *alloc
14319 )
14320 #else
14321 PRIVATE Void rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc)
14322 RgSchCellCb           *cell;
14323 RgSchCmnUlRbAllocInfo *allocInfo;
14324 RgSchUlSf     *sf;
14325 RgSchUlAlloc  *alloc;
14326 #endif
14327 {
14328    U32            bytes;
14329    RgSchCmnUlUe   *ueUl;
14330    TRC2(rgSCHCmnUlHndlAllocRetx);
14331    bytes = \
14332       rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
14333                                      [alloc->grnt.numRb-1]/8;
14334    if (!alloc->forMsg3)
14335    {
14336       ueUl = RG_SCH_CMN_GET_UL_UE(alloc->ue);
14337       ueUl->alloc.reqBytes = bytes;
14338       rgSCHUhmRetx(alloc->hqProc);
14339       rgSCHCmnUlAdd2RetxUeLst(allocInfo, alloc->ue);
14340    }
14341    else
14342    {
14343       /* RACHO msg3 retx handling. Part of RACH procedure changes. */
14344       retxAlloc = rgSCHCmnUlGetUlAlloc(cell, sf, alloc->numSb);
14345       if (retxAlloc == NULLP)
14346       {
14347          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
14348                "rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
14349                alloc->rnti);
14350          RETVOID;
14351       }
14352       retxAlloc->grnt.iMcs = alloc->grnt.iMcs;
14353       retxAlloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl\
14354                                  [alloc->hqProc->rvIdx];
14355       retxAlloc->grnt.nDmrs    = 0;
14356       retxAlloc->grnt.hop      = 0;
14357       retxAlloc->grnt.delayBit = 0;
14358       retxAlloc->rnti          = alloc->rnti;
14359       retxAlloc->ue            = NULLP;
14360       retxAlloc->pdcch         = FALSE;
14361       retxAlloc->forMsg3       = TRUE;
14362       retxAlloc->raCb          = alloc->raCb;
14363       retxAlloc->hqProc        = alloc->hqProc;
14364       rgSCHUhmRetx(retxAlloc->hqProc);
14365    }
14366    RETVOID;
14367 }
14368 #endif
14369
14370 /**
14371  * @brief Uplink Scheduling Handler.
14372  *
14373  * @details
14374  *
14375  *     Function: rgSCHCmnUlAlloc
14376  *     Purpose:  This function Handles Uplink Scheduling.
14377  *
14378  *     Invoked by: Common Scheduler
14379  *
14380  *  @param[in]  RgSchCellCb *cell
14381  *  @return  Void
14382  **/
14383 /* ccpu00132653- The definition of this function made common for TDD and FDD*/
14384 #ifdef ANSI
14385 PRIVATE Void rgSCHCmnUlAlloc
14386 (
14387 RgSchCellCb  *cell
14388 )
14389 #else
14390 PRIVATE Void rgSCHCmnUlAlloc(cell)
14391 RgSchCellCb  *cell;
14392 #endif
14393 {
14394    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14395    RgSchCmnUlCell         *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
14396    RgSchCmnDlCell         *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
14397    RgSchCmnUlRbAllocInfo  allocInfo;
14398    RgSchCmnUlRbAllocInfo  *allocInfoRef = &allocInfo;
14399 #ifdef RG_5GTF
14400    U8 idx;
14401
14402 #endif
14403
14404    TRC2(rgSCHCmnUlAlloc);
14405
14406    /* Initializing RgSchCmnUlRbAllocInfo structure */
14407    rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
14408
14409    /* Get Uplink Subframe */
14410    allocInfoRef->sf = &cellUl->ulSfArr[cellUl->schdIdx];
14411 #ifdef LTE_L2_MEAS
14412    /* initializing the UL PRB count */
14413    allocInfoRef->sf->totPrb = 0;
14414 #endif
14415
14416 #ifdef LTEMAC_SPS
14417    rgSCHCmnSpsUlTti(cell, allocInfoRef);
14418 #endif
14419
14420    if(*allocInfoRef->sf->allocCountRef == 0)
14421    {            
14422       RgSchUlHole     *hole;
14423
14424       if ((hole = rgSCHUtlUlHoleFirst(allocInfoRef->sf)) != NULLP)
14425       {
14426          /* Sanity check of holeDb */
14427          if (allocInfoRef->sf->holeDb->count == 1 && hole->start == 0) 
14428          {
14429             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;   
14430             /* Re-Initialize available subbands because of CFI change*/
14431             allocInfoRef->sf->availSubbands = cell->dynCfiCb.\
14432                                               bwInfo[cellDl->currCfi].numSb;
14433             /*Currently initializing 5gtf ulsf specific initialization here.
14434               need to do at proper place */
14435 #ifdef RG_5GTF
14436        allocInfoRef->sf->numGrpPerTti = cell->cell5gtfCb.ueGrpPerTti;
14437        allocInfoRef->sf->numUePerGrp = cell->cell5gtfCb.uePerGrpPerTti;
14438             for(idx = 0; idx < MAX_5GTF_BEAMS; idx++)
14439             {
14440                allocInfoRef->sf->sfBeamInfo[idx].totVrbgAllocated = 0;
14441                allocInfoRef->sf->sfBeamInfo[idx].totVrbgRequired = 0;
14442                allocInfoRef->sf->sfBeamInfo[idx].vrbgStart = 0;
14443             }    
14444 #endif
14445          }
14446          else
14447          {
14448             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
14449                   "Error! holeDb sanity check failed");
14450          }
14451       }
14452    }
14453
14454    /* Fix: Adaptive re-transmissions prioritised over other transmissions */
14455    /* perform adaptive retransmissions */
14456    rgSCHCmnUlSfReTxAllocs(cell, allocInfoRef->sf);
14457
14458         g5gtfTtiCnt++;
14459
14460    /* Fix: syed Adaptive Msg3 Retx crash. Release all
14461     Harq processes for which adap Retx failed, to avoid 
14462     blocking. This step should be done before New TX 
14463     scheduling to make hqProc available. Right now we
14464     dont check if proc is in adap Retx list for considering
14465     it to be available. But now with this release that 
14466     functionality would be correct. */
14467 #ifndef RG_5GTF
14468    rgSCHCmnUlSfRlsRetxProcs(cell, allocInfoRef->sf);  
14469 #endif
14470
14471    /* Specific UL scheduler to perform UE scheduling */
14472    cellSch->apisUl->rgSCHUlSched(cell, allocInfoRef);
14473
14474    /* Call UL RB allocator module */
14475    rgSCHCmnAllocUlRb(cell, allocInfoRef);
14476
14477    /* Do group power control for PUSCH */
14478    rgSCHCmnGrpPwrCntrlPusch(cell, allocInfoRef->sf);
14479
14480    cell->sc.apis->rgSCHDrxStrtInActvTmrInUl(cell);
14481
14482    rgSCHCmnUlAllocFnlz(cell, allocInfoRef);
14483         if(5000 == g5gtfTtiCnt)
14484         {
14485       ul5gtfsidDlAlreadyMarkUl = 0;
14486                 ul5gtfsidDlSchdPass = 0;
14487                 ul5gtfsidUlMarkUl = 0;
14488       ul5gtfTotSchdCnt = 0;
14489                 g5gtfTtiCnt = 0;
14490         }
14491
14492    RETVOID;
14493 }
14494
14495 /**
14496  * @brief send Subframe Allocations.
14497  *
14498  * @details
14499  *
14500  *     Function: rgSCHCmnSndCnsldtInfo
14501  *     Purpose:  Send the scheduled
14502  *     allocations to MAC for StaInd generation to Higher layers and
14503  *     for MUXing. PST's RgInfSfAlloc to MAC instance.
14504  *
14505  *     Invoked by: Common Scheduler
14506  *
14507  *  @param[in]  RgSchCellCb *cell
14508  *  @return  Void
14509  **/
14510 #ifdef ANSI
14511 PUBLIC Void rgSCHCmnSndCnsldtInfo
14512 (
14513 RgSchCellCb  *cell
14514 )
14515 #else
14516 PUBLIC Void rgSCHCmnSndCnsldtInfo(cell)
14517 RgSchCellCb  *cell;
14518 #endif
14519 {
14520    RgInfSfAlloc           *subfrmAlloc;
14521    Pst                    pst;
14522    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14523
14524    TRC2(rgSCHCmnSndCnsldtInfo);
14525
14526    subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
14527
14528    /* Send the allocations to MAC for MUXing */
14529    rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
14530    subfrmAlloc->cellId = cell->cellId;
14531    /* Populate the List of UEs needing PDB-based Flow control */
14532    cellSch->apisDl->rgSCHDlFillFlwCtrlInfo(cell, subfrmAlloc);
14533 #ifdef LTE_L2_MEAS
14534    if((subfrmAlloc->rarInfo.numRaRntis) ||
14535 #ifdef EMTC_ENABLE
14536       (subfrmAlloc->emtcInfo.rarInfo.numRaRntis) ||
14537       (subfrmAlloc->emtcInfo.cmnLcInfo.bitMask)  ||
14538       (subfrmAlloc->emtcInfo.ueInfo.numUes) ||
14539 #endif
14540       (subfrmAlloc->ueInfo.numUes)      ||
14541       (subfrmAlloc->cmnLcInfo.bitMask)  ||
14542          (subfrmAlloc->ulUeInfo.numUes)    ||
14543          (subfrmAlloc->flowCntrlInfo.numUes))
14544 #else
14545    if((subfrmAlloc->rarInfo.numRaRntis) ||
14546 #ifdef EMTC_ENABLE
14547       (subfrmAlloc->emtcInfo.rarInfo.numRaRntis) ||
14548       (subfrmAlloc->emtcInfo.cmnLcInfo.bitMask)  ||
14549       (subfrmAlloc->emtcInfo.ueInfo.numUes) ||
14550 #endif
14551       (subfrmAlloc->ueInfo.numUes)      ||
14552             (subfrmAlloc->cmnLcInfo.bitMask)  ||
14553             (subfrmAlloc->flowCntrlInfo.numUes))
14554 #endif
14555    {
14556       RgSchMacSfAlloc(&pst, subfrmAlloc);
14557    }
14558 #ifndef LTE_TDD
14559    cell->crntSfIdx  = (cell->crntSfIdx + 1) % RGSCH_NUM_SUB_FRAMES;
14560 #else
14561    cell->crntSfIdx  = (cell->crntSfIdx + 1) % RGSCH_SF_ALLOC_SIZE;
14562 #endif
14563    
14564    RETVOID;
14565 }
14566 /**
14567  * @brief Consolidate Subframe Allocations.
14568  *
14569  * @details
14570  *
14571  *     Function: rgSCHCmnCnsldtSfAlloc
14572  *     Purpose:  Consolidate Subframe Allocations.
14573  *
14574  *     Invoked by: Common Scheduler
14575  *
14576  *  @param[in]  RgSchCellCb *cell
14577  *  @return  Void
14578  **/
14579 #ifdef ANSI
14580 PUBLIC Void rgSCHCmnCnsldtSfAlloc
14581 (
14582 RgSchCellCb  *cell
14583 )
14584 #else
14585 PUBLIC Void rgSCHCmnCnsldtSfAlloc(cell)
14586 RgSchCellCb  *cell;
14587 #endif
14588 {
14589    RgInfSfAlloc           *subfrmAlloc;
14590    CmLteTimingInfo        frm;
14591    RgSchDlSf              *dlSf;
14592    CmLListCp              dlDrxInactvTmrLst;
14593    CmLListCp              dlInActvLst;
14594    CmLListCp              ulInActvLst;
14595    RgSchCmnCell           *cellSch = NULLP;
14596
14597    TRC2(rgSCHCmnCnsldtSfAlloc);
14598
14599    cmLListInit(&dlDrxInactvTmrLst);
14600    cmLListInit(&dlInActvLst);
14601    cmLListInit(&ulInActvLst);
14602
14603    subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
14604
14605    /* Get Downlink Subframe */
14606    frm   = cell->crntTime;
14607    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
14608    dlSf = rgSCHUtlSubFrmGet(cell, frm);
14609
14610    /* Fill the allocation Info */
14611    rgSCHUtlFillRgInfRarInfo(dlSf, subfrmAlloc, cell);
14612
14613   /* CA dev Start */
14614    rgSCHUtlFillRgInfUeInfo(dlSf, cell, &dlDrxInactvTmrLst, 
14615                            &dlInActvLst, &ulInActvLst);
14616 #ifdef RG_PFS_STATS
14617    cell->totalPrb += dlSf->bwAssigned;
14618 #endif
14619    /* Mark the following Ues inactive for UL*/
14620    cellSch = RG_SCH_CMN_GET_CELL(cell);
14621
14622    /* Calling Scheduler specific function with DRX inactive UE list*/
14623    cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInActvLst);
14624    cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInActvLst);
14625     
14626   /* CA dev End */
14627    /*re/start DRX inactivity timer for the UEs*/
14628    (Void)rgSCHDrxStrtInActvTmr(cell,&dlDrxInactvTmrLst,RG_SCH_DRX_DL);
14629
14630    RETVOID;
14631 }
14632
14633 /**
14634  * @brief Initialize the DL Allocation Information Structure.
14635  *
14636  * @details
14637  *
14638  *     Function: rgSCHCmnInitDlRbAllocInfo
14639  *     Purpose:  Initialize the DL Allocation Information Structure.
14640  *
14641  *     Invoked by: Common Scheduler
14642  *
14643  *  @param[out]  RgSchCmnDlRbAllocInfo  *allocInfo
14644  *  @return  Void
14645  **/
14646 #ifdef ANSI
14647 PRIVATE Void rgSCHCmnInitDlRbAllocInfo
14648 (
14649 RgSchCmnDlRbAllocInfo  *allocInfo
14650 )
14651 #else
14652 PRIVATE Void rgSCHCmnInitDlRbAllocInfo(allocInfo)
14653 RgSchCmnDlRbAllocInfo  *allocInfo;
14654 #endif
14655 {
14656    TRC2(rgSCHCmnInitDlRbAllocInfo);
14657    cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
14658    cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
14659    cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
14660          RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
14661
14662    allocInfo->msg4Alloc.msg4DlSf = NULLP;
14663    cmLListInit(&allocInfo->msg4Alloc.msg4TxLst);
14664    cmLListInit(&allocInfo->msg4Alloc.msg4RetxLst);
14665    cmLListInit(&allocInfo->msg4Alloc.schdMsg4TxLst);
14666    cmLListInit(&allocInfo->msg4Alloc.schdMsg4RetxLst);
14667    cmLListInit(&allocInfo->msg4Alloc.nonSchdMsg4TxLst);
14668    cmLListInit(&allocInfo->msg4Alloc.nonSchdMsg4RetxLst);
14669 #ifdef RGR_V1
14670    allocInfo->ccchSduAlloc.ccchSduDlSf = NULLP;
14671    cmLListInit(&allocInfo->ccchSduAlloc.ccchSduTxLst);
14672    cmLListInit(&allocInfo->ccchSduAlloc.ccchSduRetxLst);
14673    cmLListInit(&allocInfo->ccchSduAlloc.schdCcchSduTxLst);
14674    cmLListInit(&allocInfo->ccchSduAlloc.schdCcchSduRetxLst);
14675    cmLListInit(&allocInfo->ccchSduAlloc.nonSchdCcchSduTxLst);
14676    cmLListInit(&allocInfo->ccchSduAlloc.nonSchdCcchSduRetxLst);
14677 #endif
14678
14679    allocInfo->dedAlloc.dedDlSf = NULLP;
14680    cmLListInit(&allocInfo->dedAlloc.txHqPLst);
14681    cmLListInit(&allocInfo->dedAlloc.retxHqPLst);
14682    cmLListInit(&allocInfo->dedAlloc.schdTxHqPLst);
14683    cmLListInit(&allocInfo->dedAlloc.schdRetxHqPLst);
14684    cmLListInit(&allocInfo->dedAlloc.nonSchdTxHqPLst);
14685    cmLListInit(&allocInfo->dedAlloc.nonSchdRetxHqPLst);
14686
14687    cmLListInit(&allocInfo->dedAlloc.txRetxHqPLst);
14688    cmLListInit(&allocInfo->dedAlloc.schdTxRetxHqPLst);
14689    cmLListInit(&allocInfo->dedAlloc.nonSchdTxRetxHqPLst);
14690 #ifdef LTEMAC_SPS
14691    cmLListInit(&allocInfo->dedAlloc.txSpsHqPLst);
14692    cmLListInit(&allocInfo->dedAlloc.retxSpsHqPLst);
14693    cmLListInit(&allocInfo->dedAlloc.schdTxSpsHqPLst);
14694    cmLListInit(&allocInfo->dedAlloc.schdRetxSpsHqPLst);
14695    cmLListInit(&allocInfo->dedAlloc.nonSchdTxSpsHqPLst);
14696    cmLListInit(&allocInfo->dedAlloc.nonSchdRetxSpsHqPLst);
14697 #endif
14698
14699 #ifdef LTE_ADV
14700    rgSCHLaaCmnInitDlRbAllocInfo (allocInfo);
14701 #endif
14702
14703    cmLListInit(&allocInfo->dedAlloc.errIndTxHqPLst);
14704    cmLListInit(&allocInfo->dedAlloc.schdErrIndTxHqPLst);
14705    cmLListInit(&allocInfo->dedAlloc.nonSchdErrIndTxHqPLst);
14706    RETVOID;
14707 }
14708
14709 /**
14710  * @brief Initialize the UL Allocation Information Structure.
14711  *
14712  * @details
14713  *
14714  *     Function: rgSCHCmnInitUlRbAllocInfo
14715  *     Purpose:  Initialize the UL Allocation Information Structure.
14716  *
14717  *     Invoked by: Common Scheduler
14718  *
14719  *  @param[out]  RgSchCmnUlRbAllocInfo  *allocInfo
14720  *  @return  Void
14721  **/
14722 #ifdef ANSI
14723 PUBLIC Void rgSCHCmnInitUlRbAllocInfo
14724 (
14725 RgSchCmnUlRbAllocInfo  *allocInfo
14726 )
14727 #else
14728 PUBLIC Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
14729 RgSchCmnUlRbAllocInfo  *allocInfo;
14730 #endif
14731 {
14732    TRC2(rgSCHCmnInitUlRbAllocInfo);
14733    allocInfo->sf = NULLP;
14734    cmLListInit(&allocInfo->contResLst);
14735    cmLListInit(&allocInfo->schdContResLst);
14736    cmLListInit(&allocInfo->nonSchdContResLst);
14737    cmLListInit(&allocInfo->ueLst);
14738    cmLListInit(&allocInfo->schdUeLst);
14739    cmLListInit(&allocInfo->nonSchdUeLst);
14740
14741    RETVOID;
14742 }
14743
14744 /**
14745  * @brief Scheduling for PUCCH group power control.
14746  *
14747  * @details
14748  *
14749  *     Function: rgSCHCmnGrpPwrCntrlPucch
14750  *     Purpose: This function does group power control for PUCCH
14751  *     corresponding to the subframe for which DL UE allocations
14752  *     have happended.
14753  *
14754  *     Invoked by: Common Scheduler
14755  *
14756  *  @param[in]  RgSchCellCb *cell
14757  *  @return  Void
14758  **/
14759 #ifdef ANSI
14760 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch
14761 (
14762 RgSchCellCb            *cell,
14763 RgSchDlSf              *dlSf
14764 )
14765 #else
14766 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch(cell, dlSf)
14767 RgSchCellCb            *cell;
14768 RgSchDlSf              *dlSf;
14769 #endif
14770 {
14771    TRC2(rgSCHCmnGrpPwrCntrlPucch);
14772
14773    rgSCHPwrGrpCntrlPucch(cell, dlSf);
14774
14775    RETVOID;
14776 }
14777
14778 /**
14779  * @brief Scheduling for PUSCH group power control.
14780  *
14781  * @details
14782  *
14783  *     Function: rgSCHCmnGrpPwrCntrlPusch
14784  *     Purpose: This function does group power control, for
14785  *     the subframe for which UL allocation has (just) happened.
14786  *
14787  *     Invoked by: Common Scheduler
14788  *
14789  *  @param[in]  RgSchCellCb *cell
14790  *  @param[in]  RgSchUlSf   *ulSf
14791  *  @return  Void
14792  **/
14793 #ifdef ANSI
14794 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch
14795 (
14796 RgSchCellCb            *cell,
14797 RgSchUlSf              *ulSf
14798 )
14799 #else
14800 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch(cell, ulSf)
14801 RgSchCellCb            *cell;
14802 RgSchUlSf              *ulSf;
14803 #endif
14804 {
14805    /*removed unused variable *cellSch*/
14806    CmLteTimingInfo        frm;
14807    RgSchDlSf              *dlSf;
14808
14809    TRC2(rgSCHCmnGrpPwrCntrlPusch);
14810
14811    /* Got to pass DL SF corresponding to UL SF, so get that first.
14812     * There is no easy way of getting dlSf by having the RgSchUlSf*,
14813     * so use the UL delta from current time to get the DL SF. */
14814    frm   = cell->crntTime;
14815
14816 #ifdef EMTC_ENABLE
14817    if(cell->emtcEnable == TRUE)
14818    {
14819       RGSCH_INCR_SUB_FRAME_EMTC(frm, TFU_DLCNTRL_DLDELTA);
14820    }
14821    else
14822 #endif
14823    {
14824       RGSCH_INCR_SUB_FRAME(frm, TFU_DLCNTRL_DLDELTA);
14825    }
14826    /* Del filling of dl.time */
14827    dlSf = rgSCHUtlSubFrmGet(cell, frm);
14828
14829    rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf);
14830
14831    RETVOID;
14832 }
14833
14834 /* Fix: syed align multiple UEs to refresh at same time */
14835 /***********************************************************
14836  *
14837  *     Func : rgSCHCmnApplyUeRefresh 
14838  *
14839  *     Desc : Apply UE refresh in CMN and Specific 
14840  *     schedulers. Data rates and corresponding 
14841  *     scratchpad variables are updated.
14842  *
14843  *     Ret  :
14844  *
14845  *     Notes:
14846  *
14847  *     File :
14848  *
14849  **********************************************************/
14850 #ifdef ANSI
14851 PRIVATE S16 rgSCHCmnApplyUeRefresh 
14852 (
14853 RgSchCellCb     *cell,
14854 RgSchUeCb       *ue
14855 )
14856 #else
14857 PRIVATE S16 rgSCHCmnApplyUeRefresh(cell, ue)
14858 RgSchCellCb     *cell;
14859 RgSchUeCb       *ue;
14860 #endif
14861 {
14862    RgSchCmnCell    *cellSch     = RG_SCH_CMN_GET_CELL(cell);
14863    U32             effGbrBsr    = 0;
14864    U32             effNonGbrBsr = 0;
14865    U32             lcgId;
14866
14867    TRC2(rgSCHCmnApplyUeRefresh);
14868
14869    /* Reset the refresh cycle variableCAP */
14870    ue->ul.effAmbr = ue->ul.cfgdAmbr;
14871
14872    for (lcgId = 1; lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
14873    {
14874       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
14875       {
14876          RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
14877
14878          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
14879          {
14880             cmnLcg->effGbr = cmnLcg->cfgdGbr;
14881             cmnLcg->effDeltaMbr = cmnLcg->deltaMbr;
14882             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
14883             /* Considering GBR LCG will be prioritised by UE */
14884             effGbrBsr += cmnLcg->bs;
14885          }/* Else no remaing BS so nonLcg0 will be updated when BSR will be received */
14886          else
14887          {
14888             effNonGbrBsr += cmnLcg->reportedBs;
14889             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
14890          }
14891       }
14892    }
14893    effNonGbrBsr = RGSCH_MIN(effNonGbrBsr,ue->ul.effAmbr);
14894    ue->ul.nonGbrLcgBs = effNonGbrBsr;
14895
14896    ue->ul.nonLcg0Bs = effGbrBsr + effNonGbrBsr;
14897    ue->ul.effBsr = ue->ul.nonLcg0Bs +\
14898                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
14899
14900
14901    /* call scheduler specific event handlers
14902     * for refresh timer expiry */
14903    cellSch->apisUl->rgSCHUlUeRefresh(cell, ue);
14904    cellSch->apisDl->rgSCHDlUeRefresh(cell, ue);
14905
14906    RETVALUE(ROK);
14907 }
14908
14909 /***********************************************************
14910  *
14911  *     Func : rgSCHCmnTmrExpiry
14912  *
14913  *     Desc : Adds an UE to refresh queue, so that the UE is
14914  *            periodically triggered to refresh it's GBR and
14915  *            AMBR values.
14916  *
14917  *     Ret  :
14918  *
14919  *     Notes:
14920  *
14921  *     File :
14922  *
14923  **********************************************************/
14924 #ifdef ANSI
14925 PRIVATE S16 rgSCHCmnTmrExpiry
14926 (
14927 PTR cb,               /* Pointer to timer control block */
14928 S16 tmrEvnt           /* Timer Event */
14929 )
14930 #else
14931 PRIVATE S16 rgSCHCmnTmrExpiry(cb, tmrEvnt)
14932 PTR cb;               /* Pointer to timer control block */
14933 S16 tmrEvnt;           /* Timer Event */
14934 #endif
14935 {
14936    RgSchUeCb       *ue = (RgSchUeCb *)cb;
14937    RgSchCellCb     *cell = ue->cell;
14938 #if (ERRCLASS & ERRCLS_DEBUG)
14939 #endif
14940
14941    TRC2(rgSCHCmnTmrExpiry);
14942
14943 #if (ERRCLASS & ERRCLS_DEBUG)
14944    if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
14945    {
14946       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
14947          "timer event CRNTI:%d",ue->ueId);
14948       RETVALUE(RFAILED);
14949    }
14950 #else
14951    UNUSED(tmrEvnt);
14952 #endif
14953
14954    rgSCHCmnApplyUeRefresh(cell, ue);
14955
14956    rgSCHCmnAddUeToRefreshQ(cell, ue, RG_SCH_CMN_REFRESH_TIME);
14957
14958    RETVALUE(ROK);
14959 }
14960
14961 /***********************************************************
14962  *
14963  *     Func : rgSCHCmnTmrProc
14964  *
14965  *     Desc : Timer entry point per cell. Timer
14966  *            processing is triggered at every frame boundary
14967  *            (every 10 ms).
14968  *
14969  *     Ret  :
14970  *
14971  *     Notes:
14972  *
14973  *     File :
14974  *
14975  **********************************************************/
14976 #ifdef ANSI
14977 PRIVATE S16 rgSCHCmnTmrProc
14978 (
14979 RgSchCellCb *cell
14980 )
14981 #else
14982 PRIVATE S16 rgSCHCmnTmrProc(cell)
14983 RgSchCellCb *cell;
14984 #endif
14985 {
14986    RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
14987    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
14988    /* Moving the assignment of scheduler pointer
14989      to available scope for optimization */
14990    TRC2(rgSCHCmnTmrProc);
14991
14992    if ((cell->crntTime.subframe % RGSCH_NUM_SUB_FRAMES_5G) == 0)
14993    {
14994       /* Reset the counters periodically */
14995       if ((cell->crntTime.sfn % RG_SCH_CMN_CSG_REFRESH_TIME) == 0)
14996       {
14997          RG_SCH_RESET_HCSG_DL_PRB_CNTR(cmnDlCell);
14998          RG_SCH_RESET_HCSG_UL_PRB_CNTR(cmnUlCell);
14999       }
15000       if ((cell->crntTime.sfn % RG_SCH_CMN_OVRLDCTRL_REFRESH_TIME) == 0)
15001       {
15002
15003          cell->measurements.ulTpt =  ((cell->measurements.ulTpt * 95) + ( cell->measurements.ulBytesCnt * 5))/100;
15004          cell->measurements.dlTpt =  ((cell->measurements.dlTpt * 95) + ( cell->measurements.dlBytesCnt * 5))/100;
15005
15006          rgSCHUtlCpuOvrLdAdjItbsCap(cell);
15007          /* reset cell level tpt measurements for next cycle */
15008          cell->measurements.ulBytesCnt = 0;
15009          cell->measurements.dlBytesCnt = 0;
15010       }
15011       /* Comparing with Zero instead of % is being done for efficiency.
15012        * If Timer resolution changes then accordingly update the
15013        * macro RG_SCH_CMN_REFRESH_TIMERES */    
15014       RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
15015       cmPrcTmr(&sched->tmrTqCp, sched->tmrTq, (PFV)rgSCHCmnTmrExpiry);
15016    }
15017
15018    RETVALUE(ROK);
15019 }
15020
15021
15022 /***********************************************************
15023  *
15024  *     Func : rgSchCmnUpdCfiVal 
15025  *
15026  *     Desc : Update the CFI value if CFI switch was done 
15027  *
15028  *     Ret  :
15029  *
15030  *     Notes:
15031  *
15032  *     File :
15033  *
15034  **********************************************************/
15035 #ifdef ANSI
15036 PRIVATE Void rgSchCmnUpdCfiVal
15037 (
15038 RgSchCellCb     *cell,
15039 U8              delta
15040 )
15041 #else
15042 PRIVATE Void rgSchCmnUpdCfiVal(cell, delta)
15043 RgSchCellCb     *cell;
15044 U8              delta;
15045 #endif  
15046 {
15047    RgSchDlSf        *dlSf;
15048    CmLteTimingInfo  pdsch;
15049    RgSchCmnDlCell  *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell); 
15050    U8               dlIdx;
15051 #ifdef LTE_TDD
15052    U8               mPhich;
15053    RgSchDlSf        *tddSf;
15054    U8               idx;
15055    U8               splSfCfi = 0;
15056 #endif    
15057
15058    TRC2(rgSchCmnUpdCfiVal);
15059
15060    pdsch  = cell->crntTime;
15061    RGSCH_INCR_SUB_FRAME(pdsch, delta);
15062    dlSf = rgSCHUtlSubFrmGet(cell, pdsch);
15063    /* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
15064     *change happens in that SF then UL PDCCH allocation happens with old CFI
15065     *but CFI in control Req goes updated one since it was stored in the CELL
15066     */
15067    dlSf->pdcchInfo.currCfi = cellCmnDl->currCfi;
15068    if(cell->dynCfiCb.pdcchSfIdx != 0xFF) 
15069    {
15070 #ifdef LTE_TDD
15071       dlIdx = rgSCHUtlGetDlSfIdx(cell, &pdsch);
15072 #else
15073       dlIdx = (((pdsch.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (pdsch.subframe % RGSCH_NUM_SUB_FRAMES));
15074       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
15075 #endif  
15076       /* If current downlink subframe index is same as pdcch SF index,
15077        * perform the switching of CFI in this subframe */
15078       if(cell->dynCfiCb.pdcchSfIdx == dlIdx)
15079       {
15080          cellCmnDl->currCfi  = cellCmnDl->newCfi;
15081          cell->dynCfiCb.pdcchSfIdx = 0xFF;
15082
15083          /* Updating the nCce value based on the new CFI */
15084 #ifdef LTE_TDD
15085          splSfCfi = cellCmnDl->newCfi;
15086          for(idx = 0; idx < cell->numDlSubfrms; idx++)
15087          {   
15088             tddSf = cell->subFrms[idx];
15089
15090             mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][tddSf->sfNum];
15091
15092             if(tddSf->sfType == RG_SCH_SPL_SF_DATA)
15093             {
15094                RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, splSfCfi);
15095
15096                tddSf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][splSfCfi];
15097             }
15098             else
15099             {   
15100                tddSf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][cellCmnDl->currCfi];
15101             }
15102          }
15103          /* Setting the switch over window length based on config index.
15104           * During switch over period all the UL trnsmissions are Acked 
15105           * to UEs */
15106          cell->dynCfiCb.switchOvrWinLen = 
15107                rgSchCfiSwitchOvrWinLen[cell->ulDlCfgIdx];
15108 #else
15109          cell->nCce = cell->dynCfiCb.cfi2NCceTbl[0][cellCmnDl->currCfi];
15110          /* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
15111           *change happens in that SF then UL PDCCH allocation happens with old CFI
15112           *but CFI in control Req goes updated one since it was stored in the CELL
15113           */
15114          dlSf->pdcchInfo.currCfi = cellCmnDl->currCfi;
15115          cell->dynCfiCb.switchOvrWinLen = rgSchCfiSwitchOvrWinLen[7];
15116 #endif
15117       }   
15118    }   
15119
15120    RETVOID;
15121 }
15122
15123 /***********************************************************
15124  *
15125  *     Func : rgSchCmnUpdtPdcchSfIdx 
15126  *
15127  *     Desc : Update the switch over window length
15128  *
15129  *     Ret  : void
15130  *
15131  *     Notes:
15132  *
15133  *     File :
15134  *
15135  **********************************************************/
15136 #ifdef LTE_TDD
15137 #ifdef ANSI
15138 PRIVATE Void rgSchCmnUpdtPdcchSfIdx 
15139 (
15140 RgSchCellCb     *cell,
15141 U8              dlIdx,
15142 U8              sfNum
15143 )
15144 #else
15145 PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
15146 RgSchCellCb     *cell;
15147 U8              dlIdx;
15148 U8              sfNum;
15149 #endif   
15150 #else
15151 #ifdef ANSI
15152 PRIVATE Void rgSchCmnUpdtPdcchSfIdx 
15153 (
15154 RgSchCellCb     *cell,
15155 U8              dlIdx
15156 )
15157 #else
15158 PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
15159 RgSchCellCb     *cell;
15160 U8              dlIdx;
15161 #endif    
15162 #endif
15163 {
15164    U8         idx;
15165
15166    TRC2(rgSchCmnUpdtPdcchSfIdx);
15167
15168    /* Resetting the parameters on CFI switching */
15169    cell->dynCfiCb.cceUsed = 0;
15170    cell->dynCfiCb.lowCceCnt = 0;
15171
15172    cell->dynCfiCb.cceFailSum = 0;
15173    cell->dynCfiCb.cceFailCnt = 0;
15174    cell->dynCfiCb.prevCceFailIdx = 0;
15175
15176    cell->dynCfiCb.switchOvrInProgress = TRUE;
15177
15178    for(idx = 0; idx < cell->dynCfiCb.numFailSamples; idx++)
15179    {
15180       cell->dynCfiCb.cceFailSamples[idx] = 0;
15181    }   
15182
15183    cell->dynCfiCb.ttiCnt = 0;
15184
15185    cell->dynCfiCb.cfiSwitches++;
15186    cfiSwitchCnt = cell->dynCfiCb.cfiSwitches;
15187
15188 #ifdef LTE_TDD 
15189    cell->dynCfiCb.pdcchSfIdx = (dlIdx + 
15190       rgSchTddPdcchSfIncTbl[cell->ulDlCfgIdx][sfNum]) % cell->numDlSubfrms;
15191 #else
15192    cell->dynCfiCb.pdcchSfIdx = (dlIdx + RG_SCH_CFI_APPLY_DELTA) % \
15193         RGSCH_NUM_DL_SUBFRAMES;
15194 #endif
15195 }
15196
15197 /***********************************************************
15198  *
15199  *     Func : rgSchCmnUpdCfiDb 
15200  *
15201  *     Desc : Update the counters related to dynamic
15202  *            CFI feature in cellCb. 
15203  *
15204  *     Ret  :
15205  *
15206  *     Notes:
15207  *
15208  *     File :
15209  *
15210  **********************************************************/
15211 #ifdef ANSI
15212 PUBLIC Void rgSchCmnUpdCfiDb 
15213 (
15214 RgSchCellCb     *cell,
15215 U8              delta 
15216 )
15217 #else
15218 PUBLIC Void rgSchCmnUpdCfiDb(cell, delta)
15219 RgSchCellCb     *cell;
15220 U8              delta;
15221 #endif 
15222 {
15223    CmLteTimingInfo        frm;
15224    RgSchDlSf              *dlSf;
15225 #ifdef LTE_TDD
15226    U8                     mPhich;
15227    Bool                   isHiDci0; 
15228 #endif      
15229    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell); 
15230    U8                     nCceLowerCfi = 0;
15231    U8                     currCfi;
15232    U8                     cceFailIdx;
15233    U32                    totalCce;
15234    U8                     dlIdx;
15235    U16                    ttiMod;
15236
15237    TRC2(rgSchCmnUpdCfiDb);
15238
15239    /* Get Downlink Subframe */   
15240    frm   = cell->crntTime;
15241    RGSCH_INCR_SUB_FRAME(frm, delta);
15242
15243 #ifdef LTE_TDD
15244    dlIdx = rgSCHUtlGetDlSfIdx(cell, &frm);
15245    dlSf = cell->subFrms[dlIdx];
15246    isHiDci0 = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][dlSf->sfNum];
15247 #else
15248    /* Changing the idexing
15249       so that proper subframe is selected */
15250    dlIdx = (((frm.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (frm.subframe % RGSCH_NUM_SUB_FRAMES));
15251    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
15252    dlSf = cell->subFrms[dlIdx];
15253 #endif 
15254
15255    currCfi = cellSch->dl.currCfi;
15256
15257    if(!cell->dynCfiCb.switchOvrInProgress)
15258    {   
15259       do{
15260          if(!cell->dynCfiCb.isDynCfiEnb)
15261          {
15262             if(currCfi != cellSch->cfiCfg.cfi)
15263             {
15264                if(currCfi < cellSch->cfiCfg.cfi)
15265                {
15266                   RG_SCH_CFI_STEP_UP(cell, cellSch, currCfi)
15267                   cfiIncr = cell->dynCfiCb.cfiIncr;   
15268                }
15269                else
15270                {
15271                   RG_SCH_CFI_STEP_DOWN(cell, cellSch, currCfi)
15272                   cfiDecr = cell->dynCfiCb.cfiDecr;
15273                }
15274             }
15275             break;
15276          }
15277
15278 #ifdef LTE_TDD         
15279          /* Setting ttiMod to 0 for ttiCnt > 1000 in case if this 
15280           * function was not called in UL subframe*/
15281          if(cell->dynCfiCb.ttiCnt > RGSCH_CFI_TTI_MON_INTRVL)
15282          {   
15283             ttiMod = 0;
15284          }
15285          else
15286 #endif
15287          {   
15288             ttiMod = cell->dynCfiCb.ttiCnt % RGSCH_CFI_TTI_MON_INTRVL;
15289          }
15290
15291          dlSf->dlUlBothCmplt++;
15292 #ifdef LTE_TDD      
15293          if((dlSf->dlUlBothCmplt == 2) || (!isHiDci0))
15294 #else
15295          if(dlSf->dlUlBothCmplt == 2)
15296 #endif         
15297          {
15298             /********************STEP UP CRITERIA********************/
15299             /* Updating the CCE failure count parameter */
15300             cell->dynCfiCb.cceFailCnt += dlSf->isCceFailure;
15301             cell->dynCfiCb.cceFailSum += dlSf->isCceFailure;
15302
15303             /* Check if cfi step up can be performed */
15304             if(currCfi < cell->dynCfiCb.maxCfi)
15305             {
15306                if(cell->dynCfiCb.cceFailSum >= cell->dynCfiCb.cfiStepUpTtiCnt) 
15307                {
15308                   RG_SCH_CFI_STEP_UP(cell, cellSch, currCfi)
15309                   cfiIncr = cell->dynCfiCb.cfiIncr;   
15310                   break;
15311                }
15312             } 
15313
15314             /********************STEP DOWN CRITERIA********************/
15315
15316             /* Updating the no. of CCE used in this dl subframe */
15317             cell->dynCfiCb.cceUsed += dlSf->cceCnt;
15318
15319             if(currCfi > RGSCH_MIN_CFI_VAL)
15320             {   
15321                /* calculating the number of CCE for next lower CFI */
15322 #ifdef LTE_TDD      
15323                mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][dlSf->sfNum];
15324                nCceLowerCfi = cell->dynCfiCb.cfi2NCceTbl[mPhich][currCfi-1];
15325 #else
15326                nCceLowerCfi = cell->dynCfiCb.cfi2NCceTbl[0][currCfi-1];
15327 #endif     
15328                if(dlSf->cceCnt < nCceLowerCfi)
15329                {
15330                   /* Updating the count of TTIs in which no. of CCEs
15331                    * used were less than the CCEs of next lower CFI */
15332                   cell->dynCfiCb.lowCceCnt++;
15333                }   
15334
15335                if(ttiMod == 0)
15336                {
15337                   totalCce = (nCceLowerCfi * cell->dynCfiCb.cfiStepDownTtiCnt * 
15338                         RGSCH_CFI_CCE_PERCNTG)/100;
15339
15340                   if((!cell->dynCfiCb.cceFailSum) && 
15341                         (cell->dynCfiCb.lowCceCnt >= 
15342                          cell->dynCfiCb.cfiStepDownTtiCnt) && 
15343                         (cell->dynCfiCb.cceUsed < totalCce))  
15344                   {
15345                      RG_SCH_CFI_STEP_DOWN(cell, cellSch, currCfi)
15346                      cfiDecr = cell->dynCfiCb.cfiDecr; 
15347                      break;
15348                   }
15349                }   
15350             }
15351
15352             cceFailIdx = ttiMod/cell->dynCfiCb.failSamplePrd;
15353
15354             if(cceFailIdx != cell->dynCfiCb.prevCceFailIdx)
15355             {   
15356                /* New sample period has started. Subtract the old count  
15357                 * from the new sample period */
15358                cell->dynCfiCb.cceFailSum -= cell->dynCfiCb.cceFailSamples[cceFailIdx];
15359
15360                /* Store the previous sample period data */
15361                cell->dynCfiCb.cceFailSamples[cell->dynCfiCb.prevCceFailIdx]
15362                   = cell->dynCfiCb.cceFailCnt;
15363
15364                cell->dynCfiCb.prevCceFailIdx = cceFailIdx;
15365
15366                /* Resetting the CCE failure count as zero for next sample period */
15367                cell->dynCfiCb.cceFailCnt = 0;  
15368             }
15369
15370             if(ttiMod == 0)
15371             {   
15372                /* Restting the parametrs after Monitoring Interval expired */
15373                cell->dynCfiCb.cceUsed = 0;
15374                cell->dynCfiCb.lowCceCnt = 0;
15375                cell->dynCfiCb.ttiCnt = 0;
15376             }
15377
15378             cell->dynCfiCb.ttiCnt++;
15379          }
15380       }while(0);
15381
15382       if(cellSch->dl.newCfi != cellSch->dl.currCfi)
15383       {
15384 #ifdef LTE_TDD      
15385          rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, dlSf->sfNum);
15386 #else
15387          rgSchCmnUpdtPdcchSfIdx(cell, dlIdx);
15388 #endif      
15389       }  
15390    }
15391 }   
15392
15393 /**
15394  * @brief Dl Scheduler for Broadcast and Common channel scheduling.
15395  *
15396  * @details
15397  *
15398  *     Function: rgSCHCmnDlCommonChSch
15399  *     Purpose:  This function schedules DL Common channels for LTE. 
15400  *               Invoked by TTI processing in TOM. Scheduling is done for 
15401  *               BCCH, PCCH, Msg4, CCCH SDU, RAR in that order 
15402  *
15403  *     Invoked by: TOM (TTI processing)
15404  *
15405  *  @param[in]  RgSchCellCb *cell
15406  *  @return  Void
15407  **/
15408 #ifdef ANSI
15409 PUBLIC Void rgSCHCmnDlCommonChSch
15410 (
15411 RgSchCellCb  *cell
15412 )
15413 #else
15414 PUBLIC Void rgSCHCmnDlCommonChSch(cell)
15415 RgSchCellCb  *cell;
15416 #endif
15417 {
15418    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
15419
15420    TRC2(rgSCHCmnDlCommonChSch);
15421
15422    cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
15423    rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
15424
15425    /* handle Inactive UEs for DL */
15426    rgSCHCmnHdlDlInactUes(cell);
15427
15428    /* Send a Tick to Refresh Timer */
15429    rgSCHCmnTmrProc(cell);
15430
15431    if (cell->isDlDataAllwd && (cell->stopSiSch == FALSE)) 
15432    {
15433       rgSCHCmnInitRbAlloc(cell); 
15434       /* Perform DL scheduling of BCCH, PCCH */
15435       rgSCHCmnDlBcchPcchAlloc(cell);
15436    }
15437    else
15438    {
15439       if(cell->siCb.inWindow != 0)
15440       {
15441          cell->siCb.inWindow--;
15442       }
15443    }
15444    if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
15445    {
15446       rgSCHCmnDlCcchRarAlloc(cell);
15447    }
15448    RETVOID;
15449 }
15450
15451 /**
15452  * @brief Scheduler invocation per TTI.
15453  *
15454  * @details
15455  *
15456  *     Function: rgSCHCmnUlSch
15457  *     Purpose:  This function implements UL scheduler alone. This is to
15458  *               be able to perform scheduling with more flexibility.
15459  *
15460  *     Invoked by: TOM (TTI processing)
15461  *
15462  *  @param[in]  RgSchCellCb *cell
15463  *  @return  Void
15464  **/
15465 #ifdef ANSI
15466 PUBLIC Void rgSCHCmnUlSch
15467 (
15468 RgSchCellCb  *cell
15469 )
15470 #else
15471 PUBLIC Void  rgSCHCmnUlSch(cell)
15472 RgSchCellCb  *cell;
15473 #endif
15474 {
15475    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
15476    
15477    TRC2(rgSCHCmnUlSch);
15478
15479 #ifdef LTE_ADV
15480    /* LAA_SCELL: */
15481    if(TRUE == rgSCHLaaSCellEnabled(cell))
15482    {
15483       RETVOID;   
15484    }
15485 #endif
15486    
15487    if(cellSch->ul.schdIdx != RGSCH_INVALID_INFO)
15488    {   
15489       rgSchCmnUpdCfiVal(cell, TFU_ULCNTRL_DLDELTA);
15490
15491       /* Handle Inactive UEs for UL */
15492       rgSCHCmnHdlUlInactUes(cell);
15493       /* Perform UL Scheduling EVERY TTI */
15494       rgSCHCmnUlAlloc(cell);
15495
15496       /* Calling function to update CFI parameters*/
15497       rgSchCmnUpdCfiDb(cell, TFU_ULCNTRL_DLDELTA);   
15498
15499       if(cell->dynCfiCb.switchOvrWinLen > 0)
15500       {
15501          /* Decrementing the switchover window length */
15502          cell->dynCfiCb.switchOvrWinLen--;
15503
15504          if(!cell->dynCfiCb.switchOvrWinLen)
15505          {   
15506             if(cell->dynCfiCb.dynCfiRecfgPend)
15507             {  
15508                /* Toggling the Dynamic CFI enabling */
15509                cell->dynCfiCb.isDynCfiEnb ^= 1;
15510                rgSCHDynCfiReCfg(cell, cell->dynCfiCb.isDynCfiEnb); 
15511                cell->dynCfiCb.dynCfiRecfgPend = FALSE;
15512             }   
15513             cell->dynCfiCb.switchOvrInProgress = FALSE;
15514          }
15515       }
15516    }
15517 #ifdef LTE_TDD
15518 #ifdef LTEMAC_SPS
15519    else
15520    {
15521       rgSCHCmnSpsUlTti(cell, NULLP); 
15522    }
15523 #endif
15524 #endif
15525
15526    RETVOID;
15527 }
15528
15529 \f
15530 /**
15531  * @brief This function updates the scheduler with service for an UE.
15532  *
15533  * @details
15534  *
15535  *     Function: rgSCHCmnDlDedBoUpd
15536  *     Purpose:  This function should be called whenever there is a
15537  *               change BO for a service.
15538  *
15539  *     Invoked by: BO and Scheduler
15540  *
15541  *  @param[in]  RgSchCellCb*  cell
15542  *  @param[in]  RgSchUeCb*    ue
15543  *  @param[in]  RgSchDlLcCb*  svc
15544  *  @return  Void
15545  *
15546  **/
15547 #ifdef ANSI
15548 PUBLIC Void rgSCHCmnDlDedBoUpd
15549 (
15550 RgSchCellCb                *cell,
15551 RgSchUeCb                  *ue,
15552 RgSchDlLcCb                *svc
15553 )
15554 #else
15555 PUBLIC Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
15556 RgSchCellCb                *cell;
15557 RgSchUeCb                  *ue;
15558 RgSchDlLcCb                *svc;
15559 #endif
15560 {
15561    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15562    TRC2(rgSCHCmnDlDedBoUpd);
15563
15564    /* RACHO : if UEs idle time exceeded and a BO update
15565     * is received, then add UE to the pdcch Order Q */
15566    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
15567    {
15568       RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue, cell);
15569       /* If PDCCH order is already triggered and we are waiting for
15570        * RACH from UE then do not add to PdcchOdrQ. */
15571       if (ueDl->rachInfo.rapIdLnk.node == NULLP)
15572       {
15573          rgSCHCmnDlAdd2PdcchOdrQ(cell, ue);
15574       }
15575    }
15576
15577 #ifdef LTEMAC_SPS
15578
15579    /* If SPS service, invoke SPS module */
15580    if (svc->dlLcSpsCfg.isSpsEnabled)
15581    {
15582       rgSCHCmnSpsDlDedBoUpd(cell, ue, svc);
15583       /* Note: Retrun from here, no update needed in other schedulers */
15584       RETVOID;
15585    }
15586 #endif
15587 #ifdef EMTC_ENABLE
15588    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
15589    {
15590       cellSch->apisEmtcDl->rgSCHDlDedBoUpd(cell, ue, svc);
15591       //printf("rgSCHEMTCDlDedBoUpd\n");
15592    }
15593    else
15594 #endif
15595    {
15596       cellSch->apisDl->rgSCHDlDedBoUpd(cell, ue, svc);
15597    }
15598 #ifdef LTE_ADV
15599    if (ue->numSCells)
15600    {
15601       rgSCHSCellDlDedBoUpd(cell, ue, svc);
15602    }
15603 #endif
15604    RETVOID;
15605 }
15606
15607 \f
15608 /**
15609  * @brief Removes an UE from Cell's TA List.
15610  *
15611  * @details
15612  *
15613  *     Function: rgSCHCmnRmvFrmTaLst
15614  *     Purpose:  Removes an UE from Cell's TA List.
15615  *
15616  *     Invoked by: Specific Scheduler
15617  *
15618  *  @param[in]  RgSchCellCb*     cell
15619  *  @param[in]  RgSchUeCb*       ue
15620  *  @return  Void
15621  *
15622  **/
15623 #ifdef ANSI
15624 PUBLIC Void rgSCHCmnRmvFrmTaLst
15625 (
15626 RgSchCellCb                *cell,
15627 RgSchUeCb                  *ue
15628 )
15629 #else
15630 PUBLIC Void rgSCHCmnRmvFrmTaLst(cell, ue)
15631 RgSchCellCb                *cell;
15632 RgSchUeCb                  *ue;
15633 #endif
15634 {
15635    RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
15636    TRC2(rgSCHCmnRmvFrmTaLst);
15637
15638 #ifdef EMTC_ENABLE
15639    if(cell->emtcEnable && ue->isEmtcUe)
15640    {
15641       rgSCHEmtcRmvFrmTaLst(cellCmnDl,ue);
15642    }
15643    else
15644 #endif
15645    {
15646       cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
15647       ue->dlTaLnk.node = (PTR)NULLP;
15648    }
15649    RETVOID;
15650 }
15651
15652 /* Fix: syed Remove the msg4Proc from cell
15653  * msg4Retx Queue. I have used CMN scheduler function
15654  * directly. Please define a new API and call this
15655  * function through that. */        
15656 \f
15657 /**
15658  * @brief This function removes MSG4 HARQ process from cell RETX Queues.
15659  *
15660  * @details
15661  *
15662  *     Function: rgSCHCmnDlMsg4ProcRmvFrmRetx
15663  *     Purpose:  This function removes MSG4 HARQ process from cell RETX Queues.
15664  *
15665  *     Invoked by: UE/RACB deletion. 
15666  *
15667  *  @param[in]  RgSchCellCb*     cell
15668  *  @param[in]  RgSchDlHqProc*   hqP
15669  *  @return  Void
15670  *
15671  **/
15672 #ifdef ANSI
15673 PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx 
15674 (
15675 RgSchCellCb                *cell,
15676 RgSchDlHqProcCb            *hqP
15677 )
15678 #else
15679 PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
15680 RgSchCellCb                *cell;
15681 RgSchDlHqProcCb            *hqP;
15682 #endif
15683 {
15684    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15685    TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
15686
15687    if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
15688    {
15689       if (hqP->hqE->msg4Proc == hqP)
15690       {
15691          cmLListDelFrm(&cellSch->dl.msg4RetxLst, \
15692                &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15693          hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
15694       }
15695 #ifdef RGR_V1
15696       else if(hqP->hqE->ccchSduProc == hqP)
15697       {
15698          cmLListDelFrm(&cellSch->dl.ccchSduRetxLst,
15699                &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15700          hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
15701       }
15702 #endif
15703    }
15704    RETVOID;
15705 }
15706
15707 \f
15708 /**
15709  * @brief This function adds a HARQ process for retx.
15710  *
15711  * @details
15712  *
15713  *     Function: rgSCHCmnDlProcAddToRetx
15714  *     Purpose:  This function adds a HARQ process to retransmission
15715  *               queue. This may be performed when a HARQ ack is
15716  *               unsuccessful.
15717  *
15718  *     Invoked by: HARQ feedback processing
15719  *
15720  *  @param[in]  RgSchCellCb*     cell
15721  *  @param[in]  RgSchDlHqProc*   hqP
15722  *  @return  Void
15723  *
15724  **/
15725 #ifdef ANSI
15726 PUBLIC Void rgSCHCmnDlProcAddToRetx
15727 (
15728 RgSchCellCb                *cell,
15729 RgSchDlHqProcCb            *hqP
15730 )
15731 #else
15732 PUBLIC Void rgSCHCmnDlProcAddToRetx(cell, hqP)
15733 RgSchCellCb                *cell;
15734 RgSchDlHqProcCb            *hqP;
15735 #endif
15736 {
15737    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15738    TRC2(rgSCHCmnDlProcAddToRetx);
15739
15740    if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
15741    {
15742       cmLListAdd2Tail(&cellSch->dl.msg4RetxLst, \
15743             &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15744       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)hqP;
15745    }
15746 #ifdef RGR_V1
15747    else if(hqP->hqE->ccchSduProc == hqP)
15748    {
15749       /*If CCCH SDU being transmitted without cont res CE*/
15750       cmLListAdd2Tail(&cellSch->dl.ccchSduRetxLst,
15751             &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15752       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)hqP;
15753    }
15754 #endif
15755    else
15756    {
15757 #ifdef LTEMAC_SPS
15758       if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
15759       {
15760          /* Invoke SPS module for SPS HARQ proc re-transmission handling */
15761          rgSCHCmnSpsDlProcAddToRetx(cell, hqP);
15762          RETVOID;
15763       }
15764 #endif /* LTEMAC_SPS */
15765 #ifdef EMTC_ENABLE      
15766       if((TRUE == cell->emtcEnable)
15767          && (TRUE == hqP->hqE->ue->isEmtcUe))
15768       {
15769          cellSch->apisEmtcDl->rgSCHDlProcAddToRetx(cell, hqP);
15770       }
15771       else
15772 #endif         
15773       {
15774          cellSch->apisDl->rgSCHDlProcAddToRetx(cell, hqP);
15775       }
15776    }
15777    RETVOID;
15778 }
15779
15780 \f
15781 /**
15782  * @brief This function performs RI validation and
15783  *        updates it to the ueCb.
15784  *
15785  * @details
15786  *
15787  *     Function: rgSCHCmnDlSetUeRi
15788  *     Purpose:  This function performs RI validation and
15789  *        updates it to the ueCb.
15790  *
15791  *     Invoked by: rgSCHCmnDlCqiInd
15792  *
15793  *  @param[in]  RgSchCellCb        *cell
15794  *  @param[in]  RgSchUeCb          *ue
15795  *  @param[in]  U8                 ri
15796  *  @param[in]  Bool               isPeriodic
15797  *  @return  Void
15798  *
15799  **/
15800 #ifdef ANSI
15801 PRIVATE Void rgSCHCmnDlSetUeRi
15802 (
15803 RgSchCellCb        *cell,
15804 RgSchUeCb          *ue,
15805 U8                 ri,
15806 Bool               isPer
15807 )
15808 #else
15809 PRIVATE Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
15810 RgSchCellCb        *cell;
15811 RgSchUeCb          *ue;
15812 U8                 ri;
15813 Bool               isPer;
15814 #endif
15815 {
15816    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
15817    RgSchCmnUeInfo    *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
15818    TRC2(rgSCHCmnDlSetUeRi);
15819    
15820 #ifdef TFU_UPGRADE
15821    RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
15822    UNUSED(isPer);
15823 #endif
15824
15825
15826    /* FIX for RRC Reconfiguration issue */
15827    /* ccpu00140894- During Tx Mode transition RI report will not entertained for 
15828     * specific during which SCH expecting UE can complete TX mode transition*/
15829    if (ue->txModeTransCmplt == FALSE)
15830    {
15831       RETVOID;
15832    }
15833
15834    /* Restrict the Number of TX layers to cell->numTxAntPorts.
15835     * Protection from invalid RI values. */
15836    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
15837    
15838    /* Special case of converting PMI to sane value when
15839     * there is a switch in RI from 1 to 2 and PMI reported 
15840     * for RI=1 is invalid for RI=2 */
15841    if ((cell->numTxAntPorts == 2) && (ue->mimoInfo.txMode == RGR_UE_TM_4))
15842    {
15843       if ((ri == 2) && ( ueDl->mimoInfo.ri == 1))
15844       {
15845          ueDl->mimoInfo.pmi = (ueDl->mimoInfo.pmi < 2)? 1:2;
15846       }
15847    }
15848
15849    /* Restrict the Number of TX layers according to the UE Category */
15850    ueDl->mimoInfo.ri = RGSCH_MIN(ri, rgUeCatTbl[ueSchCmn->ueCat].maxTxLyrs);
15851 #ifdef TENB_STATS
15852    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].riCnt[ueDl->mimoInfo.ri-1]++;
15853    cell->tenbStats->sch.riCnt[ueDl->mimoInfo.ri-1]++;
15854 #endif
15855
15856 #ifdef TENB_STATS
15857    ue->tenbStats->stats.nonPersistent.sch[0].riCnt[ueDl->mimoInfo.ri-1]++;
15858    cell->tenbStats->sch.riCnt[ueDl->mimoInfo.ri-1]++;
15859 #endif
15860
15861 #ifdef TFU_UPGRADE
15862    if (isPer)
15863    {
15864       /* If RI is from Periodic CQI report */
15865       cqiCb->perRiVal = ueDl->mimoInfo.ri;
15866       /* Reset at every Periodic RI Reception */ 
15867       cqiCb->invalidateCqi = FALSE;
15868    }
15869    else
15870    {
15871       /* If RI is from Aperiodic CQI report */
15872       if (cqiCb->perRiVal != ueDl->mimoInfo.ri)
15873       {
15874          /* if this aperRI is different from last reported
15875           * perRI then invalidate all CQI reports till next
15876           * perRI */
15877          cqiCb->invalidateCqi = TRUE;
15878       }
15879       else
15880       {
15881          cqiCb->invalidateCqi = FALSE;
15882       }
15883    }
15884 #endif   
15885
15886    if (ueDl->mimoInfo.ri > 1)
15887    {
15888       RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
15889    }
15890    else if (ue->mimoInfo.txMode == RGR_UE_TM_3) /* ri == 1 */
15891    {
15892       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
15893    }
15894
15895    RETVOID;
15896 }
15897
15898 \f
15899 /**
15900  * @brief This function performs PMI validation and
15901  *        updates it to the ueCb.
15902  *
15903  * @details
15904  *
15905  *     Function: rgSCHCmnDlSetUePmi
15906  *     Purpose:  This function performs PMI validation and
15907  *        updates it to the ueCb.
15908  *
15909  *     Invoked by: rgSCHCmnDlCqiInd
15910  *
15911  *  @param[in]  RgSchCellCb        *cell
15912  *  @param[in]  RgSchUeCb          *ue
15913  *  @param[in]  U8                 pmi
15914  *  @return  Void
15915  *
15916  **/
15917 #ifdef ANSI
15918 PRIVATE S16 rgSCHCmnDlSetUePmi
15919 (
15920 RgSchCellCb        *cell,
15921 RgSchUeCb          *ue,
15922 U8                 pmi
15923 )
15924 #else
15925 PRIVATE S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
15926 RgSchCellCb        *cell;
15927 RgSchUeCb          *ue;
15928 U8                 pmi;
15929 #endif
15930 {
15931    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
15932    TRC2(rgSCHCmnDlSetUePmi);
15933
15934    if (ue->txModeTransCmplt == FALSE)
15935    {
15936        RETVALUE(RFAILED);
15937    }
15938  
15939    if (cell->numTxAntPorts == 2)
15940    {
15941       if (pmi > 3)
15942       {
15943          RETVALUE(RFAILED);
15944       }
15945       if (ueDl->mimoInfo.ri == 2)
15946       {
15947          /*ccpu00118150 - MOD - changed pmi value validation from 0 to 2*/
15948          /* PMI 2 and 3 are invalid incase of 2 TxAnt and 2 Layered SM */
15949          if (pmi == 2 || pmi == 3)
15950          {
15951             RETVALUE(RFAILED);
15952          }
15953          ueDl->mimoInfo.pmi = pmi+1;
15954       }
15955       else
15956       {
15957          ueDl->mimoInfo.pmi = pmi;
15958       }
15959    }
15960    else if (cell->numTxAntPorts == 4)
15961    {
15962       if (pmi > 15)
15963       {
15964          RETVALUE(RFAILED);
15965       }
15966       ueDl->mimoInfo.pmi = pmi;
15967    }
15968    /* Reset the No PMI Flag in forceTD */
15969    RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
15970    RETVALUE(ROK);
15971 }
15972
15973 /**
15974  * @brief This function Updates the DL CQI on PUCCH for the UE.
15975  *
15976  * @details
15977  *
15978  *     Function: rgSCHCmnDlProcCqiMode10
15979  *
15980  *     This function updates the DL CQI on PUCCH for the UE.
15981  *
15982  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
15983  *
15984  *     Processing Steps:
15985  *
15986  *  @param[in] RgSchCellCb     *cell
15987  *  @param[in] RgSchUeCb       *ue
15988  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
15989  *  @return  S16
15990  *      -# ROK
15991  *      -# RFAILED
15992  **/
15993 #ifdef RGR_CQI_REPT
15994 #ifdef ANSI
15995 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
15996 (
15997  RgSchCellCb        *cell,
15998  RgSchUeCb          *ue,
15999  TfuDlCqiPucch      *pucchCqi,
16000  Bool               *isCqiAvail
16001  )
16002 #else
16003 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail)
16004  RgSchCellCb        *cell;
16005  RgSchUeCb          *ue;
16006  TfuDlCqiPucch      *pucchCqi;
16007  Bool               *isCqiAvail;
16008 #endif
16009 #else
16010 #ifdef ANSI
16011 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
16012 (
16013  RgSchCellCb        *cell,
16014  RgSchUeCb          *ue,
16015  TfuDlCqiPucch      *pucchCqi
16016  )
16017 #else
16018 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi)
16019  RgSchCellCb        *cell;
16020  RgSchUeCb          *ue;
16021  TfuDlCqiPucch      *pucchCqi;
16022 #endif
16023 #endif
16024 {
16025    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16026    TRC2(rgSCHCmnDlProcCqiMode10);
16027
16028    if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
16029    {
16030       /*ccpu00109787 - ADD - Check for non-zero CQI*/
16031       /* Checking whether the decoded CQI is a value between 1 and 15*/
16032       if((pucchCqi->u.mode10Info.u.cqi) && (pucchCqi->u.mode10Info.u.cqi
16033                < RG_SCH_CMN_MAX_CQI))
16034       {
16035          ueDl->cqiFlag = TRUE;
16036          ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode10Info.u.cqi;
16037          ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16038          /* ccpu00117452 - MOD - Changed macro name from
16039             RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16040 #ifdef RGR_CQI_REPT
16041          *isCqiAvail = TRUE;
16042 #endif
16043       }
16044       else
16045       {
16046          RETVOID;
16047       }
16048    }
16049    else if (pucchCqi->u.mode10Info.type == TFU_RPT_RI)
16050    {
16051       if ( RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode10Info.u.ri) )
16052       {
16053          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode10Info.u.ri,
16054                            TRUE);
16055       }
16056       else
16057       {
16058          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16059             pucchCqi->u.mode10Info.u.ri,ue->ueId);
16060          RETVOID;
16061       }
16062    }
16063 }
16064
16065 /**
16066  * @brief This function Updates the DL CQI on PUCCH for the UE.
16067  *
16068  * @details
16069  *
16070  *     Function: rgSCHCmnDlProcCqiMode11
16071  *
16072  *     This function updates the DL CQI on PUCCH for the UE.
16073  *
16074  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16075  *
16076  *     Processing Steps:
16077  *       Process CQI MODE 11
16078  *  @param[in] RgSchCellCb     *cell
16079  *  @param[in] RgSchUeCb       *ue
16080  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16081  *  @return  S16
16082  *      -# ROK
16083  *      -# RFAILED
16084  **/
16085 #ifdef RGR_CQI_REPT
16086 #ifdef ANSI
16087 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
16088 (
16089  RgSchCellCb        *cell,
16090  RgSchUeCb          *ue,
16091  TfuDlCqiPucch      *pucchCqi,
16092  Bool               *isCqiAvail,
16093  Bool               *is2ndCwCqiAvail
16094  )
16095 #else
16096 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
16097  RgSchCellCb        *cell;
16098  RgSchUeCb          *ue;
16099  TfuDlCqiPucch      *pucchCqi;
16100  Bool               *isCqiAvail;
16101  Bool               *is2ndCwCqiAvail;
16102 #endif
16103 #else
16104 #ifdef ANSI
16105 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
16106 (
16107  RgSchCellCb        *cell,
16108  RgSchUeCb          *ue,
16109  TfuDlCqiPucch      *pucchCqi
16110  )
16111 #else
16112 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi)
16113  RgSchCellCb        *cell;
16114  RgSchUeCb          *ue;
16115  TfuDlCqiPucch      *pucchCqi;
16116 #endif
16117 #endif
16118 {
16119    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16120    TRC2(rgSCHCmnDlProcCqiMode11);
16121
16122    if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
16123    {
16124       ue->mimoInfo.puschFdbkVld  = FALSE;
16125       /*ccpu00109787 - ADD - Check for non-zero CQI*/
16126       if((pucchCqi->u.mode11Info.u.cqi.cqi) &&
16127             (pucchCqi->u.mode11Info.u.cqi.cqi < RG_SCH_CMN_MAX_CQI))
16128       {
16129          ueDl->cqiFlag = TRUE;
16130          /* ccpu00117452 - MOD - Changed macro name from
16131             RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16132 #ifdef RGR_CQI_REPT
16133          *isCqiAvail = TRUE;
16134 #endif
16135          ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode11Info.u.cqi.cqi;
16136          if (pucchCqi->u.mode11Info.u.cqi.wideDiffCqi.pres)
16137          {
16138             RG_SCH_UPDT_CW2_CQI(ueDl->mimoInfo.cwInfo[0].cqi, \
16139                                      ueDl->mimoInfo.cwInfo[1].cqi, \
16140                                      pucchCqi->u.mode11Info.u.cqi.wideDiffCqi.val);
16141 #ifdef RGR_CQI_REPT
16142             /* ccpu00117259 - ADD - Considering second codeword CQI info
16143                incase of MIMO for CQI Reporting */
16144             *is2ndCwCqiAvail = TRUE;
16145 #endif
16146          }
16147       }
16148       else
16149       {
16150          RETVOID;
16151       }
16152       rgSCHCmnDlSetUePmi(cell, ue, \
16153             pucchCqi->u.mode11Info.u.cqi.pmi);
16154    }
16155    else if (pucchCqi->u.mode11Info.type == TFU_RPT_RI)
16156    {
16157       if( RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode11Info.u.ri))
16158       {
16159          rgSCHCmnDlSetUeRi(cell, ue,  pucchCqi->u.mode11Info.u.ri,
16160                            TRUE);
16161       }
16162       else
16163       {
16164          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid RI value(%x) CRNTI:%d",
16165             pucchCqi->u.mode11Info.u.ri,ue->ueId);
16166          RETVOID;
16167       }
16168    }
16169 }
16170
16171 /**
16172  * @brief This function Updates the DL CQI on PUCCH for the UE.
16173  *
16174  * @details
16175  *
16176  *     Function: rgSCHCmnDlProcCqiMode20
16177  *
16178  *     This function updates the DL CQI on PUCCH for the UE.
16179  *
16180  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16181  *
16182  *     Processing Steps:
16183  *       Process CQI MODE 20
16184  *  @param[in] RgSchCellCb     *cell
16185  *  @param[in] RgSchUeCb       *ue
16186  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16187  *  @return  S16
16188  *      -# ROK
16189  *      -# RFAILED
16190  **/
16191 #ifdef RGR_CQI_REPT
16192 #ifdef ANSI
16193 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
16194 (
16195  RgSchCellCb        *cell,
16196  RgSchUeCb          *ue,
16197  TfuDlCqiPucch      *pucchCqi,
16198  Bool               *isCqiAvail
16199  )
16200 #else
16201 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail )
16202  RgSchCellCb        *cell;
16203  RgSchUeCb          *ue;
16204  TfuDlCqiPucch      *pucchCqi;
16205  Bool               *isCqiAvail;
16206 #endif
16207 #else
16208 #ifdef ANSI
16209 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
16210 (
16211  RgSchCellCb        *cell,
16212  RgSchUeCb          *ue,
16213  TfuDlCqiPucch      *pucchCqi
16214  )
16215 #else
16216 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi)
16217  RgSchCellCb        *cell;
16218  RgSchUeCb          *ue;
16219  TfuDlCqiPucch      *pucchCqi;
16220 #endif
16221 #endif
16222 {
16223    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16224    TRC2(rgSCHCmnDlProcCqiMode20);
16225
16226    if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
16227    {
16228       if (pucchCqi->u.mode20Info.u.cqi.isWideband)
16229       {
16230          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16231          if((pucchCqi->u.mode20Info.u.cqi.u.wideCqi) &&
16232                (pucchCqi->u.mode20Info.u.cqi.u.wideCqi < RG_SCH_CMN_MAX_CQI))
16233          {
16234             ueDl->cqiFlag = TRUE;
16235             ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode20Info.u.cqi.\
16236                                            u.wideCqi;
16237             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16238             /* ccpu00117452 - MOD - Changed macro name from
16239                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16240 #ifdef RGR_CQI_REPT
16241             *isCqiAvail = TRUE;
16242 #endif
16243          }
16244          else
16245          {
16246             RETVOID;
16247          }
16248       }
16249    }
16250    else if (pucchCqi->u.mode20Info.type == TFU_RPT_RI)
16251    {
16252       if(RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode20Info.u.ri))
16253       {
16254          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode20Info.u.ri, 
16255                            TRUE);
16256       }
16257       else
16258       {
16259          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16260             pucchCqi->u.mode20Info.u.ri,ue->ueId);
16261          RETVOID;
16262       }
16263    }
16264 }
16265
16266
16267 /**
16268  * @brief This function Updates the DL CQI on PUCCH for the UE.
16269  *
16270  * @details
16271  *
16272  *     Function: rgSCHCmnDlProcCqiMode21
16273  *
16274  *     This function updates the DL CQI on PUCCH for the UE.
16275  *
16276  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16277  *
16278  *     Processing Steps:
16279  *       Process CQI MODE 21
16280  *  @param[in] RgSchCellCb     *cell
16281  *  @param[in] RgSchUeCb       *ue
16282  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16283  *  @return  S16
16284  *      -# ROK
16285  *      -# RFAILED
16286  **/
16287 #ifdef RGR_CQI_REPT
16288 #ifdef ANSI
16289 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
16290 (
16291  RgSchCellCb        *cell,
16292  RgSchUeCb          *ue,
16293  TfuDlCqiPucch      *pucchCqi,
16294  Bool               *isCqiAvail,
16295  Bool               *is2ndCwCqiAvail
16296  )
16297 #else
16298 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
16299    RgSchCellCb        *cell;
16300    RgSchUeCb          *ue;
16301  TfuDlCqiPucch        *pucchCqi;
16302    TfuDlCqiRpt        *dlCqiRpt;
16303    Bool               *isCqiAvail;
16304    Bool               *is2ndCwCqiAvail;
16305 #endif
16306 #else
16307 #ifdef ANSI
16308 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
16309 (
16310  RgSchCellCb        *cell,
16311  RgSchUeCb          *ue,
16312  TfuDlCqiPucch      *pucchCqi
16313  )
16314 #else
16315 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi)
16316  RgSchCellCb        *cell;
16317  RgSchUeCb          *ue;
16318  TfuDlCqiPucch      *pucchCqi;
16319 #endif
16320 #endif
16321 {
16322    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16323    TRC2(rgSCHCmnDlProcCqiMode21);
16324
16325    if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
16326    {
16327       ue->mimoInfo.puschFdbkVld  = FALSE;
16328       if (pucchCqi->u.mode21Info.u.cqi.isWideband)
16329       {
16330          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16331          if((pucchCqi->u.mode21Info.u.cqi.u.wideCqi.cqi) &&
16332                (pucchCqi->u.mode21Info.u.cqi.u.wideCqi.cqi < RG_SCH_CMN_MAX_CQI))
16333          {
16334             ueDl->cqiFlag = TRUE;
16335             ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode21Info.u.cqi.\
16336                                            u.wideCqi.cqi;
16337             if (pucchCqi->u.mode21Info.u.cqi.u.wideCqi.diffCqi.pres)
16338             {
16339                RG_SCH_UPDT_CW2_CQI(ueDl->mimoInfo.cwInfo[0].cqi, \
16340                                      ueDl->mimoInfo.cwInfo[1].cqi, \
16341                                      pucchCqi->u.mode21Info.u.cqi.u.wideCqi.diffCqi.val);
16342 #ifdef RGR_CQI_REPT
16343                /* ccpu00117259 - ADD - Considering second codeword CQI info
16344                   incase of MIMO for CQI Reporting */
16345                *is2ndCwCqiAvail = TRUE;
16346 #endif
16347             }
16348             /* ccpu00117452 - MOD - Changed macro name from
16349                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16350 #ifdef RGR_CQI_REPT
16351             *isCqiAvail = TRUE;
16352 #endif
16353          }
16354          else
16355          {
16356             RETVOID;
16357          }
16358          rgSCHCmnDlSetUePmi(cell, ue, \
16359                pucchCqi->u.mode21Info.u.cqi.u.wideCqi.pmi);
16360       }
16361    }
16362    else if (pucchCqi->u.mode21Info.type == TFU_RPT_RI)
16363    {
16364       if(RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode21Info.u.ri))
16365       {
16366          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode21Info.u.ri,
16367                            TRUE);
16368       }
16369       else
16370       {
16371          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid RI value(%x) CRNTI:%d",
16372             pucchCqi->u.mode21Info.u.ri,ue->ueId);
16373          RETVOID;
16374       }
16375    }
16376 }
16377
16378
16379 /**
16380  * @brief This function Updates the DL CQI on PUCCH for the UE.
16381  *
16382  * @details
16383  *
16384  *     Function: rgSCHCmnDlCqiOnPucchInd
16385  *
16386  *     This function updates the DL CQI on PUCCH for the UE.
16387  *
16388  *     Invoked by: rgSCHCmnDlCqiInd
16389  *
16390  *     Processing Steps:
16391  *     - Depending on the reporting mode of the PUCCH, the CQI/PMI/RI values
16392  *       are updated and stored for each UE
16393  *
16394  *  @param[in] RgSchCellCb     *cell
16395  *  @param[in] RgSchUeCb       *ue
16396  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16397  *  @return  S16
16398  *      -# ROK
16399  *      -# RFAILED
16400  **/
16401 #ifdef RGR_CQI_REPT
16402 #ifdef ANSI
16403 PRIVATE Void rgSCHCmnDlCqiOnPucchInd
16404 (
16405  RgSchCellCb        *cell,
16406  RgSchUeCb          *ue,
16407  TfuDlCqiPucch      *pucchCqi,
16408  RgrUeCqiRept       *ueCqiRept,
16409  Bool               *isCqiAvail,
16410  Bool               *is2ndCwCqiAvail
16411  )
16412 #else
16413 PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
16414  RgSchCellCb        *cell;
16415  RgSchUeCb          *ue;
16416  TfuDlCqiPucch      *pucchCqi;
16417  RgrUeCqiRept       *ueCqiRept;
16418  Bool               *isCqiAvail;
16419  Bool               *is2ndCwCqiAvail;
16420 #endif
16421 #else
16422 #ifdef ANSI
16423 PRIVATE Void rgSCHCmnDlCqiOnPucchInd
16424 (
16425  RgSchCellCb        *cell,
16426  RgSchUeCb          *ue,
16427  TfuDlCqiPucch      *pucchCqi
16428  )
16429 #else
16430 PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi)
16431  RgSchCellCb        *cell;
16432  RgSchUeCb          *ue;
16433  TfuDlCqiPucch      *pucchCqi;
16434 #endif
16435 #endif
16436 {
16437    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16438    TRC2(rgSCHCmnDlCqiOnPucchInd);
16439
16440    /* ccpu00117452 - MOD - Changed
16441       RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16442 #ifdef RGR_CQI_REPT
16443    /* Save CQI mode information in the report */
16444    ueCqiRept->cqiMode = pucchCqi->mode;
16445 #endif
16446
16447    switch(pucchCqi->mode)
16448    {
16449       case TFU_PUCCH_CQI_MODE10:
16450 #ifdef RGR_CQI_REPT
16451          rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail);
16452 #else
16453          rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi);
16454 #endif
16455          ueDl->cqiFlag = TRUE;
16456          break;
16457       case TFU_PUCCH_CQI_MODE11:
16458 #ifdef RGR_CQI_REPT
16459          rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail,
16460                 is2ndCwCqiAvail);
16461 #else
16462          rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi);
16463 #endif
16464          ueDl->cqiFlag = TRUE;
16465          break;
16466       case TFU_PUCCH_CQI_MODE20:
16467 #ifdef RGR_CQI_REPT
16468          rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail);
16469 #else
16470          rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi);
16471 #endif
16472          ueDl->cqiFlag = TRUE;
16473          break;
16474       case TFU_PUCCH_CQI_MODE21:
16475 #ifdef RGR_CQI_REPT
16476          rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail,
16477                 is2ndCwCqiAvail);
16478 #else
16479          rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi);
16480 #endif
16481          ueDl->cqiFlag = TRUE;
16482          break;
16483       default:
16484          {
16485             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unknown CQI Mode %d",
16486                pucchCqi->mode,ue->ueId);
16487             /* ccpu00117452 - MOD - Changed macro name from
16488                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16489 #ifdef RGR_CQI_REPT
16490             *isCqiAvail = FALSE;
16491 #endif
16492          }
16493          break;
16494    }
16495
16496   RETVOID;
16497 }  /* rgSCHCmnDlCqiOnPucchInd */
16498
16499
16500 /**
16501  * @brief This function Updates the DL CQI on PUSCH for the UE.
16502  *
16503  * @details
16504  *
16505  *     Function: rgSCHCmnDlCqiOnPuschInd
16506  *
16507  *     This function updates the DL CQI on PUSCH for the UE.
16508  *
16509  *     Invoked by: rgSCHCmnDlCqiInd
16510  *
16511  *     Processing Steps:
16512  *     - Depending on the reporting mode of the PUSCH, the CQI/PMI/RI values
16513  *       are updated and stored for each UE
16514  *
16515  *  @param[in] RgSchCellCb     *cell
16516  *  @param[in] RgSchUeCb       *ue
16517  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16518  *  @return  S16
16519  *      -# ROK
16520  *      -# RFAILED
16521  **/
16522 #ifdef RGR_CQI_REPT
16523 #ifdef ANSI
16524 PRIVATE Void rgSCHCmnDlCqiOnPuschInd
16525 (
16526  RgSchCellCb        *cell,
16527  RgSchUeCb          *ue,
16528  TfuDlCqiPusch      *puschCqi,
16529  RgrUeCqiRept       *ueCqiRept,
16530  Bool               *isCqiAvail,
16531  Bool               *is2ndCwCqiAvail
16532  )
16533 #else
16534 PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
16535  RgSchCellCb        *cell;
16536  RgSchUeCb          *ue;
16537  TfuDlCqiPusch      *puschCqi;
16538  RgrUeCqiRept       *ueCqiRept;
16539  Bool               *isCqiAvail;
16540  Bool               *is2ndCwCqiAvail;
16541 #endif
16542 #else
16543 #ifdef ANSI
16544 PRIVATE Void rgSCHCmnDlCqiOnPuschInd
16545 (
16546  RgSchCellCb        *cell,
16547  RgSchUeCb          *ue,
16548  TfuDlCqiPusch      *puschCqi
16549  )
16550 #else
16551 PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi)
16552    RgSchCellCb        *cell;
16553    RgSchUeCb          *ue;
16554    TfuDlCqiPusch      *puschCqi;
16555 #endif
16556 #endif
16557 {
16558    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16559    U32 prevRiVal = 0; 
16560    TRC2(rgSCHCmnDlCqiOnPuschInd);
16561    if (puschCqi->ri.pres == PRSNT_NODEF)
16562    {
16563       if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
16564       {
16565          /* Saving the previous ri value to revert back
16566             in  case PMI update failed */
16567          if (RGR_UE_TM_4 == ue->mimoInfo.txMode ) /* Cheking for TM4. TM8 check later */
16568          {
16569             prevRiVal = ueDl->mimoInfo.ri;
16570          }
16571          rgSCHCmnDlSetUeRi(cell, ue, puschCqi->ri.val, FALSE);
16572       }
16573       else
16574       {
16575          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16576             puschCqi->ri.val,ue->ueId);
16577          RETVOID;
16578       }
16579    }
16580    ue->mimoInfo.puschFdbkVld  = FALSE;
16581    /* ccpu00117452 - MOD - Changed macro name from
16582       RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16583 #ifdef RGR_CQI_REPT
16584    /* Save CQI mode information in the report */
16585    ueCqiRept->cqiMode = puschCqi->mode;
16586    /* ccpu00117259 - DEL - removed default setting of isCqiAvail to TRUE */
16587 #endif
16588
16589    switch(puschCqi->mode)
16590    {
16591       case TFU_PUSCH_CQI_MODE_20:
16592          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16593          /* Checking whether the decoded CQI is a value between 1 and 15*/
16594          if((puschCqi->u.mode20Info.wideBandCqi) &&
16595                (puschCqi->u.mode20Info.wideBandCqi < RG_SCH_CMN_MAX_CQI))
16596          {
16597             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode20Info.wideBandCqi;
16598             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16599             /* ccpu00117452 - MOD - Changed macro name from
16600                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16601 #ifdef RGR_CQI_REPT
16602            *isCqiAvail = TRUE;
16603 #endif
16604          }
16605          else
16606          {
16607             RETVOID;
16608          }
16609          break;
16610       case TFU_PUSCH_CQI_MODE_30:
16611          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16612          if((puschCqi->u.mode30Info.wideBandCqi) &&
16613                (puschCqi->u.mode30Info.wideBandCqi < RG_SCH_CMN_MAX_CQI))
16614          {
16615             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode30Info.wideBandCqi;
16616             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16617             /* ccpu00117452 - MOD - Changed macro name from
16618                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16619 #ifdef RGR_CQI_REPT
16620             *isCqiAvail = TRUE;
16621 #endif
16622 #ifdef CA_DBG
16623             {
16624                extern U32 gACqiRcvdCount;
16625                gACqiRcvdCount++;
16626             
16627             }
16628 #endif
16629          }
16630          else
16631          {
16632             RETVOID;
16633          }
16634          break;
16635       case TFU_PUSCH_CQI_MODE_12:
16636          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16637          if((puschCqi->u.mode12Info.cqiIdx[0]) &&
16638                (puschCqi->u.mode12Info.cqiIdx[0] < RG_SCH_CMN_MAX_CQI))
16639          {
16640             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode12Info.cqiIdx[0];
16641             /* ccpu00117452 - MOD - Changed macro name from
16642                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16643 #ifdef RGR_CQI_REPT
16644             *isCqiAvail = TRUE;
16645 #endif
16646          }
16647          else
16648          {
16649             RETVOID;
16650          }
16651          if((puschCqi->u.mode12Info.cqiIdx[1]) &&
16652                (puschCqi->u.mode12Info.cqiIdx[1] < RG_SCH_CMN_MAX_CQI))
16653          {
16654             ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode12Info.cqiIdx[1];
16655             /* ccpu00117452 - MOD - Changed macro name from
16656                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16657 #ifdef RGR_CQI_REPT
16658             /* ccpu00117259 - ADD - Considering second codeword CQI info
16659                incase of MIMO for CQI Reporting */
16660             *is2ndCwCqiAvail = TRUE;
16661 #endif
16662          }
16663          else
16664          {
16665             RETVOID;
16666          }
16667          ue->mimoInfo.puschFdbkVld  = TRUE;
16668          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_12;
16669          ue->mimoInfo.puschPmiInfo.u.mode12Info = puschCqi->u.mode12Info;
16670          /*  : resetting this is time based. Make use of CQI reporting
16671           * periodicity, DELTA's in determining the exact time at which this
16672           * need to be reset. */
16673          break;
16674       case TFU_PUSCH_CQI_MODE_22:
16675          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16676          if((puschCqi->u.mode22Info.wideBandCqi[0]) &&
16677                (puschCqi->u.mode22Info.wideBandCqi[0] < RG_SCH_CMN_MAX_CQI))
16678          {
16679             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode22Info.wideBandCqi[0];
16680             /* ccpu00117452 - MOD - Changed macro name from
16681                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16682 #ifdef RGR_CQI_REPT
16683             *isCqiAvail = TRUE;
16684 #endif
16685          }
16686          else
16687          {
16688             RETVOID;
16689          }
16690          if((puschCqi->u.mode22Info.wideBandCqi[1]) &&
16691                (puschCqi->u.mode22Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
16692          {
16693             ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode22Info.wideBandCqi[1];
16694             /* ccpu00117452 - MOD - Changed macro name from
16695                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16696 #ifdef RGR_CQI_REPT
16697             /* ccpu00117259 - ADD - Considering second codeword CQI info
16698                incase of MIMO for CQI Reporting */
16699             *is2ndCwCqiAvail = TRUE;
16700 #endif
16701          }
16702          else
16703          {
16704             RETVOID;
16705          }
16706          rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode22Info.wideBandPmi);
16707          ue->mimoInfo.puschFdbkVld  = TRUE;
16708          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_22;
16709          ue->mimoInfo.puschPmiInfo.u.mode22Info = puschCqi->u.mode22Info;
16710          break;
16711       case TFU_PUSCH_CQI_MODE_31:
16712          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16713          if((puschCqi->u.mode31Info.wideBandCqi[0]) &&
16714                (puschCqi->u.mode31Info.wideBandCqi[0] < RG_SCH_CMN_MAX_CQI))
16715          {
16716             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode31Info.wideBandCqi[0];
16717             /* ccpu00117452 - MOD - Changed macro name from
16718                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16719 #ifdef RGR_CQI_REPT
16720             *isCqiAvail = TRUE;
16721 #endif
16722          }
16723          if (ueDl->mimoInfo.ri > 1)
16724          {
16725            if((puschCqi->u.mode31Info.wideBandCqi[1]) &&
16726                (puschCqi->u.mode31Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
16727            {
16728              ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode31Info.wideBandCqi[1];
16729             /* ccpu00117452 - MOD - Changed macro name from
16730                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16731 #ifdef RGR_CQI_REPT
16732             /* ccpu00117259 - ADD - Considering second codeword CQI info
16733                incase of MIMO for CQI Reporting */
16734              *is2ndCwCqiAvail = TRUE;
16735 #endif
16736            }
16737          }
16738          if (rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode31Info.pmi) != ROK)
16739          {
16740             /* To avoid Rank and PMI inconsistency */
16741             if ((puschCqi->ri.pres == PRSNT_NODEF) &&
16742                 (RGR_UE_TM_4 == ue->mimoInfo.txMode)) /* checking for TM4. TM8 check later */
16743             {
16744                ueDl->mimoInfo.ri = prevRiVal;
16745             }
16746          }
16747          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_31;
16748          ue->mimoInfo.puschPmiInfo.u.mode31Info = puschCqi->u.mode31Info;
16749          break;
16750       default:
16751          {
16752             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Unknown CQI Mode %d CRNTI:%d",
16753                puschCqi->mode,ue->ueId);
16754             /*  CQI decoding failed revert the RI to previous value */
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             /* ccpu00117452 - MOD - Changed macro name from
16761                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16762 #ifdef RGR_CQI_REPT
16763            *isCqiAvail = FALSE;
16764             /* ccpu00117259 - ADD - Considering second codeword CQI info
16765                incase of MIMO for CQI Reporting */
16766             *is2ndCwCqiAvail = FALSE;
16767 #endif
16768          }
16769          break;
16770    }
16771
16772    RETVOID;
16773 }  /* rgSCHCmnDlCqiOnPuschInd */
16774
16775 \f
16776 /**
16777  * @brief This function Updates the DL CQI for the UE.
16778  *
16779  * @details
16780  *
16781  *     Function: rgSCHCmnDlCqiInd
16782  *     Purpose:  Updates the DL CQI for the UE
16783  *
16784  *     Invoked by: TOM
16785  *
16786  *  @param[in]  RgSchCellCb        *cell
16787  *  @param[in]  RgSchUeCb          *ue
16788  *  @param[in]  TfuDlCqiRpt        *dlCqi
16789  *  @return  Void
16790  *
16791  **/
16792 #ifdef ANSI
16793 PUBLIC Void rgSCHCmnDlCqiInd
16794 (
16795 RgSchCellCb        *cell,
16796 RgSchUeCb          *ue,
16797 Bool               isPucchInfo,
16798 Void               *dlCqi,
16799 CmLteTimingInfo    timingInfo
16800 )
16801 #else
16802 PUBLIC Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
16803 RgSchCellCb        *cell;
16804 RgSchUeCb          *ue;
16805 Bool               isPucchInfo;
16806 Void               *dlCqi;
16807 CmLteTimingInfo    timingInfo;
16808 #endif
16809 {
16810    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
16811 /* ccpu00117452 - MOD - Changed macro name from
16812    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16813 #ifdef RGR_CQI_REPT
16814    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16815    RgrUeCqiRept   ueCqiRept = {{0}};
16816    Bool           isCqiAvail = FALSE;
16817    /* ccpu00117259 - ADD - Considering second codeword CQI info
16818       incase of MIMO for CQI Reporting */
16819    Bool           is2ndCwCqiAvail = FALSE;
16820 #endif
16821
16822    TRC2(rgSCHCmnDlCqiInd);
16823
16824 #ifdef RGR_CQI_REPT
16825    if (isPucchInfo)
16826    {
16827       rgSCHCmnDlCqiOnPucchInd(cell, ue, (TfuDlCqiPucch *)dlCqi, &ueCqiRept, &isCqiAvail, &is2ndCwCqiAvail);
16828    }
16829    else
16830    {
16831       rgSCHCmnDlCqiOnPuschInd(cell, ue, (TfuDlCqiPusch *)dlCqi, &ueCqiRept,  &isCqiAvail, &is2ndCwCqiAvail);
16832    }
16833 #else
16834    if (isPucchInfo)
16835    {
16836       rgSCHCmnDlCqiOnPucchInd(cell, ue, (TfuDlCqiPucch *)dlCqi);
16837    }
16838    else
16839    {
16840       rgSCHCmnDlCqiOnPuschInd(cell, ue, (TfuDlCqiPusch *)dlCqi);
16841    }
16842 #endif
16843
16844 #ifdef CQI_CONFBITMASK_DROP
16845    if(!ue->cqiConfBitMask)
16846    {
16847       if (ueDl->mimoInfo.cwInfo[0].cqi >15)
16848       {
16849          ueDl->mimoInfo.cwInfo[0].cqi = ue->prevCqi;
16850          ueDl->mimoInfo.cwInfo[1].cqi = ue->prevCqi;
16851       }
16852       else if ( ueDl->mimoInfo.cwInfo[0].cqi >= ue->prevCqi)
16853       {
16854          ue->prevCqi = ueDl->mimoInfo.cwInfo[0].cqi;
16855       }
16856       else
16857       {
16858          U8 dlCqiDeltaPrev = 0;
16859          dlCqiDeltaPrev = ue->prevCqi - ueDl->mimoInfo.cwInfo[0].cqi;
16860          if (dlCqiDeltaPrev > 3)
16861             dlCqiDeltaPrev = 3;
16862          if ((ue->prevCqi - dlCqiDeltaPrev) < 6)
16863          {
16864             ue->prevCqi = 6;
16865          }
16866          else 
16867          {
16868             ue->prevCqi = ue->prevCqi - dlCqiDeltaPrev;
16869          }
16870          ueDl->mimoInfo.cwInfo[0].cqi = ue->prevCqi;
16871          ueDl->mimoInfo.cwInfo[1].cqi = ue->prevCqi;
16872
16873       }
16874    }
16875 #endif
16876
16877 /* ccpu00117452 - MOD - Changed macro name from
16878    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16879 #ifdef RGR_CQI_REPT
16880    /* ccpu00117259 - ADD - Considering second codeword CQI info
16881       incase of MIMO for CQI Reporting - added is2ndCwCqiAvail\
16882       in 'if' condition*/
16883    if (RG_SCH_CQIR_IS_PUSHNCQI_ENBLE(ue) && (isCqiAvail || is2ndCwCqiAvail))
16884    {
16885       ueCqiRept.cqi[0] = ueDl->mimoInfo.cwInfo[0].cqi;
16886
16887    /* ccpu00117259 - ADD - Considering second codeword CQI info
16888       incase of MIMO for CQI Reporting - added is2ndCwCqiAvail
16889       in 'if' condition*/
16890       ueCqiRept.cqi[1] = 0;
16891       if(is2ndCwCqiAvail)
16892       {
16893          ueCqiRept.cqi[1] = ueDl->mimoInfo.cwInfo[1].cqi;
16894       }
16895       rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, &ueCqiRept);
16896
16897    }
16898 #endif
16899 #ifdef DL_LA
16900    rgSCHCmnDlSetUeAllocLmtLa(cell, ue);
16901    rgSCHCheckAndSetTxScheme(cell, ue);
16902 #else
16903 #ifdef EMTC_ENABLE   
16904    rgSCHCmnDlSetUeAllocLmt(cell, RG_SCH_CMN_GET_DL_UE(ue,cell), ue->isEmtcUe);
16905 #else 
16906    rgSCHCmnDlSetUeAllocLmt(cell, RG_SCH_CMN_GET_DL_UE(ue,cell), FALSE);
16907 #endif   
16908 #endif
16909
16910    if (cellSch->dl.isDlFreqSel)
16911    {
16912       cellSch->apisDlfs->rgSCHDlfsDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo);
16913    }
16914 #ifdef LTEMAC_SPS
16915    /* Call SPS module to update CQI indication */
16916    rgSCHCmnSpsDlCqiIndHndlr(cell, ue, timingInfo);
16917 #endif
16918    /* Call Specific scheduler to process on dlCqiInd */
16919 #ifdef EMTC_ENABLE
16920    if((TRUE == cell->emtcEnable) && (TRUE == ue->isEmtcUe))
16921    {
16922       cellSch->apisEmtcDl->rgSCHDlCqiInd(cell, ue, isPucchInfo, dlCqi);
16923    }
16924    else
16925 #endif
16926    {
16927       cellSch->apisDl->rgSCHDlCqiInd(cell, ue, isPucchInfo, dlCqi);
16928    }
16929
16930 #ifdef RG_PFS_STATS
16931    ue->pfsStats.cqiStats[(RG_SCH_GET_SCELL_INDEX(ue, cell))].avgCqi += 
16932       ueDl->mimoInfo.cwInfo[0].cqi;
16933    ue->pfsStats.cqiStats[(RG_SCH_GET_SCELL_INDEX(ue, cell))].totalCqiOcc++; 
16934 #endif
16935
16936 #ifdef SCH_STATS
16937    ueDl->avgCqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16938    ueDl->numCqiOccns++;
16939    if (ueDl->mimoInfo.ri == 1)
16940    {
16941       ueDl->numRi1++;
16942    }
16943    else
16944    {
16945       ueDl->numRi2++;
16946    }
16947 #endif
16948
16949 #ifdef TENB_STATS
16950    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlSumCw0Cqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16951    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlSumCw1Cqi +=  ueDl->mimoInfo.cwInfo[1].cqi;
16952    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlNumCw0Cqi ++;
16953    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlNumCw1Cqi ++;
16954    cell->tenbStats->sch.dlSumCw0Cqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16955    cell->tenbStats->sch.dlSumCw1Cqi +=  ueDl->mimoInfo.cwInfo[1].cqi;
16956    cell->tenbStats->sch.dlNumCw0Cqi ++;
16957    cell->tenbStats->sch.dlNumCw1Cqi ++;
16958 #endif
16959    RETVOID;
16960 }
16961
16962 #ifdef TFU_UPGRADE
16963 /**
16964  * @brief This function calculates the wideband CQI from SNR
16965  *            reported for each RB.
16966  *
16967  * @details
16968  *
16969  *     Function: rgSCHCmnCalcWcqiFrmSnr
16970  *     Purpose:  Wideband CQI calculation from SNR
16971  *
16972  *     Invoked by: RG SCH
16973  *
16974  *  @param[in]  RgSchCellCb        *cell
16975  *  @param[in]  TfuSrsRpt        *srsRpt,
16976  *  @return  Wideband CQI
16977  *
16978  **/
16979 #ifdef ANSI
16980 PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr
16981 (
16982  RgSchCellCb        *cell,
16983  TfuSrsRpt        *srsRpt
16984  )
16985 #else
16986 PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
16987    RgSchCellCb        *cell;
16988    TfuSrsRpt            *srsRpt;
16989 #endif
16990 {
16991    U8 wideCqi=1; /*Calculated value from SNR*/
16992    TRC2(rgSCHCmnCalcWcqiFrmSnr);
16993    /*Need to map a certain SNR with a WideCQI value.
16994     * The CQI calculation is still primitive. Further, need to
16995     * use a improvized method for calculating WideCQI from SNR*/
16996        if (srsRpt->snr[0] <=50)
16997        {
16998            wideCqi=3;
16999        }
17000        else if (srsRpt->snr[0]>=51 && srsRpt->snr[0] <=100)
17001        {
17002            wideCqi=6;
17003        }
17004        else if (srsRpt->snr[0]>=101 && srsRpt->snr[0] <=150)
17005        {
17006            wideCqi=9;
17007        }
17008        else if (srsRpt->snr[0]>=151 && srsRpt->snr[0] <=200)
17009        {
17010            wideCqi=12;
17011        }
17012        else if (srsRpt->snr[0]>=201 && srsRpt->snr[0] <=250)
17013        {
17014            wideCqi=14;
17015        }
17016        else
17017        {
17018            wideCqi=15;
17019        }
17020    RETVALUE(wideCqi);
17021 }/*rgSCHCmnCalcWcqiFrmSnr*/
17022
17023
17024 /**
17025  * @brief This function Updates the SRS for the UE.
17026  *
17027  * @details
17028  *
17029  *     Function: rgSCHCmnSrsInd
17030  *     Purpose:  Updates the UL SRS for the UE
17031  *
17032  *     Invoked by: TOM
17033  *
17034  *  @param[in]  RgSchCellCb        *cell
17035  *  @param[in]  RgSchUeCb          *ue
17036  *  @param[in]  TfuSrsRpt        *srsRpt,
17037  *  @return  Void
17038  *
17039  **/
17040 #ifdef ANSI
17041 PUBLIC Void rgSCHCmnSrsInd
17042 (
17043  RgSchCellCb        *cell,
17044  RgSchUeCb          *ue,
17045  TfuSrsRpt        *srsRpt,
17046  CmLteTimingInfo    timingInfo
17047  )
17048 #else
17049 PUBLIC Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
17050     RgSchCellCb        *cell;
17051     RgSchUeCb          *ue;
17052     TfuSrsRpt            *srsRpt;
17053     CmLteTimingInfo    timingInfo;
17054 #endif
17055 {
17056     U8 wideCqi; /*Calculated value from SNR*/
17057     U32 recReqTime; /*Received Time in TTI*/
17058     TRC2(rgSCHCmnSrsInd);
17059
17060     recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.subframe;
17061     ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
17062     if(srsRpt->wideCqiPres)
17063     {
17064         wideCqi = srsRpt->wideCqi;
17065     }
17066     else
17067     {
17068         wideCqi = rgSCHCmnCalcWcqiFrmSnr(cell, srsRpt);
17069     }
17070     rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi);
17071     RETVOID;
17072 }/*rgSCHCmnSrsInd*/
17073 #endif
17074
17075 \f
17076 /**
17077  * @brief This function is a handler for TA report for an UE.
17078  *
17079  * @details
17080  *
17081  *     Function: rgSCHCmnDlTARpt
17082  *     Purpose:  Determine based on UE_IDLE_TIME threshold,
17083  *     whether UE needs to be Linked to the scheduler's TA list OR
17084  *     if it needs a PDCCH Order.
17085  *
17086  *
17087  *     Invoked by: TOM
17088  *
17089  *  @param[in]  RgSchCellCb        *cell
17090  *  @param[in]  RgSchUeCb          *ue
17091  *  @return  Void
17092  *
17093  **/
17094 #ifdef ANSI
17095 PUBLIC Void rgSCHCmnDlTARpt
17096 (
17097 RgSchCellCb        *cell,
17098 RgSchUeCb          *ue
17099 )
17100 #else
17101 PUBLIC Void rgSCHCmnDlTARpt(cell, ue)
17102 RgSchCellCb        *cell;
17103 RgSchUeCb          *ue;
17104 #endif
17105 {
17106    RgSchCmnCell    *cellSch = RG_SCH_CMN_GET_CELL(cell);
17107    RgSchCmnDlCell  *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
17108    RgSchCmnDlUe    *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
17109    CmLListCp       poInactvLst;
17110
17111    TRC2(rgSCHCmnDlTARpt);
17112
17113    /* RACHO: If UE idle time is more than threshold, then
17114     * set its poInactv pdcch order inactivity  */
17115    /* Fix : syed Ignore if TaTmr is not configured */
17116    if ((ue->dl.taCb.cfgTaTmr) && (rgSCHCmnUeIdleExdThrsld(cell, ue) == ROK))
17117    {
17118       U32 prevDlMsk = ue->dl.dlInactvMask;
17119       U32 prevUlMsk = ue->ul.ulInactvMask;
17120       ue->dl.dlInactvMask |= RG_PDCCHODR_INACTIVE;
17121       ue->ul.ulInactvMask |= RG_PDCCHODR_INACTIVE;
17122       /* Indicate Specific scheduler for this UEs inactivity */
17123       cmLListInit(&poInactvLst);
17124       cmLListAdd2Tail(&poInactvLst, &ueDl->rachInfo.inActUeLnk);
17125       ueDl->rachInfo.inActUeLnk.node = (PTR)ue;
17126       /* Send inactivate ind only if not already sent */
17127       if (prevDlMsk == 0)
17128       {
17129          cellSch->apisDl->rgSCHDlInactvtUes(cell, &poInactvLst);
17130       }
17131       if (prevUlMsk == 0)
17132       {
17133          cellSch->apisUl->rgSCHUlInactvtUes(cell, &poInactvLst);
17134       }
17135    }
17136    else
17137    {
17138       /* Fix: ccpu00124009 Fix for loop in the linked list "cellDl->taLst" */
17139       if (!ue->dlTaLnk.node)
17140       {
17141 #ifdef EMTC_ENABLE
17142          if(cell->emtcEnable)
17143          {
17144             if(ue->isEmtcUe)
17145             {
17146                rgSCHEmtcAddToTaLst(cellDl,ue);
17147             }
17148          }
17149          else
17150 #endif
17151          {
17152
17153             cmLListAdd2Tail(&cellDl->taLst, &ue->dlTaLnk);
17154             ue->dlTaLnk.node = (PTR)ue;
17155          }
17156       }
17157       else
17158       {
17159          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
17160                "<TA>TA duplicate entry attempt failed: UEID:%u", 
17161                ue->ueId);
17162       }
17163    }
17164    RETVOID;
17165 }
17166
17167 #ifdef TFU_UPGRADE
17168 /**
17169  * @brief Indication of UL CQI.
17170  *
17171  * @details
17172  *
17173  *     Function : rgSCHCmnFindUlCqiUlTxAnt
17174  *
17175  *     - Finds the Best Tx Antenna amongst the CQIs received
17176  *         from Two Tx Antennas.
17177  *
17178  *  @param[in]  RgSchCellCb         *cell
17179  *  @param[in]  RgSchUeCb           *ue
17180  *  @param[in]   U8                 wideCqi
17181  *  @return  Void
17182  **/
17183 #ifdef ANSI
17184 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt
17185 (
17186 RgSchCellCb     *cell,
17187 RgSchUeCb       *ue,
17188 U8              wideCqi
17189 )
17190 #else
17191 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
17192 RgSchCellCb     *cell;
17193 RgSchUeCb       *ue;
17194 U8              wideCqi;
17195 #endif
17196 {
17197    ue->validTxAnt = 1;
17198    RETVOID;
17199 }  /* rgSCHCmnFindUlCqiUlTxAnt */
17200 #endif
17201
17202 /**
17203  * @brief Indication of UL CQI.
17204  *
17205  * @details
17206  *
17207  *     Function : rgSCHCmnUlCqiInd
17208  *
17209  *     - Updates uplink CQI information for the UE. Computes and
17210  *       stores the lowest CQI of CQIs reported in all subbands.
17211  *
17212  *  @param[in]  RgSchCellCb         *cell
17213  *  @param[in]  RgSchUeCb           *ue
17214  *  @param[in]  TfuUlCqiRpt         *ulCqiInfo
17215  *  @return  Void
17216  **/
17217 #ifdef ANSI
17218 PUBLIC Void rgSCHCmnUlCqiInd
17219 (
17220 RgSchCellCb          *cell,
17221 RgSchUeCb            *ue,
17222 TfuUlCqiRpt          *ulCqiInfo
17223 )
17224 #else
17225 PUBLIC Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
17226 RgSchCellCb          *cell;
17227 RgSchUeCb            *ue;
17228 TfuUlCqiRpt          *ulCqiInfo;
17229 #endif
17230 {
17231    RgSchCmnUlUe  *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
17232    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
17233 #ifdef UL_LA
17234    U8            iTbsNew;
17235    S32           previTbs;
17236 #endif
17237 #if (defined(SCH_STATS) || defined(TENB_STATS))
17238      CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
17239 #endif   
17240                   
17241    TRC2(rgSCHCmnUlCqiInd);
17242    /*  consider inputs from SRS handlers about SRS occassions
17243     * in determining the UL TX Antenna selection */
17244    ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
17245 #ifdef TFU_UPGRADE
17246    ueUl->validUlCqi = ueUl->crntUlCqi[0];
17247    ue->validTxAnt = 0;
17248 #ifdef UL_LA
17249    iTbsNew  =  rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][ueUl->validUlCqi];
17250    previTbs =  (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
17251
17252    if (RG_ITBS_DIFF(iTbsNew, previTbs) > 5)
17253    {
17254       /* Ignore this iTBS report and mark that last iTBS report was */
17255       /* ignored so that subsequently we reset the LA algorithm     */
17256       ueUl->ulLaCb.lastiTbsIgnored = TRUE;
17257    }
17258    else
17259    {
17260       if (ueUl->ulLaCb.lastiTbsIgnored != TRUE)
17261       {
17262          ueUl->ulLaCb.cqiBasediTbs = ((20 * iTbsNew * 100) +
17263                                        (80 * ueUl->ulLaCb.cqiBasediTbs))/100;
17264       }
17265       else
17266       {
17267          /* Reset the LA as iTbs in use caught up with the value   */
17268          /* reported by UE.                                        */
17269          ueUl->ulLaCb.cqiBasediTbs = ((20 * iTbsNew * 100) +
17270                                         (80 * previTbs * 100))/100;
17271          ueUl->ulLaCb.deltaiTbs = 0;
17272          ueUl->ulLaCb.lastiTbsIgnored = FALSE;
17273       }
17274    }
17275 #endif 
17276 #endif
17277    rgSCHPwrUlCqiInd(cell, ue);
17278 #ifdef LTEMAC_SPS
17279    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
17280    {
17281       rgSCHCmnSpsUlCqiInd(cell, ue);
17282    }
17283 #endif
17284    /* Applicable to only some schedulers */
17285 #ifdef EMTC_ENABLE
17286    if((TRUE == cell->emtcEnable) && (TRUE == ue->isEmtcUe))
17287    {
17288       cellSch->apisEmtcUl->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
17289    }
17290    else
17291 #endif
17292    {
17293       cellSch->apisUl->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
17294    }
17295
17296 #ifdef SCH_STATS
17297    ueUl->numCqiOccns++;
17298    ueUl->avgCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17299 #endif
17300
17301 #ifdef TENB_STATS
17302    {
17303       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulSumCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17304       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulNumCqi ++;
17305       cell->tenbStats->sch.ulSumCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17306       cell->tenbStats->sch.ulNumCqi ++;
17307    }
17308 #endif
17309
17310    RETVOID;
17311 }  /* rgSCHCmnUlCqiInd */
17312
17313 /**
17314  * @brief Returns HARQ proc for which data expected now.
17315  *
17316  * @details
17317  *
17318  *     Function: rgSCHCmnUlHqProcForUe
17319  *     Purpose:  This function returns the harq process for
17320  *               which data is expected in the current subframe.
17321  *               It does not validate that the HARQ process
17322  *               has an allocation.
17323  *
17324  *     Invoked by: TOM
17325  *
17326  *  @param[in]  RgSchCellCb        *cell
17327  *  @param[in]  CmLteTimingInfo    frm
17328  *  @param[in]  RgSchUeCb          *ue
17329  *  @param[out] RgSchUlHqProcCb    **procRef
17330  *  @return  Void
17331  **/
17332 #ifdef ANSI
17333 PUBLIC Void rgSCHCmnUlHqProcForUe
17334 (
17335 RgSchCellCb         *cell,
17336 CmLteTimingInfo     frm,
17337 RgSchUeCb           *ue,
17338 RgSchUlHqProcCb     **procRef
17339 )
17340 #else
17341 PUBLIC Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
17342 RgSchCellCb         *cell;
17343 CmLteTimingInfo     frm;
17344 RgSchUeCb           *ue;
17345 RgSchUlHqProcCb     **procRef;
17346 #endif
17347 {
17348 #ifndef RG_5GTF
17349    U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
17350 #endif
17351    TRC2(rgSCHCmnUlHqProcForUe);
17352 #ifndef RG_5GTF
17353    *procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
17354 #else
17355    *procRef = rgSCHUhmGetUlProcByTime(cell, ue, frm);
17356 #endif
17357    RETVOID;
17358 }
17359
17360 #ifdef RG_UNUSED
17361 /**
17362  * @brief Update harq process for allocation.
17363  *
17364  * @details
17365  *
17366  *     Function : rgSCHCmnUpdUlHqProc
17367  *
17368  *     This function is invoked when harq process
17369  *     control block is now in a new memory location
17370  *     thus requiring a pointer/reference update.
17371  *
17372  *  @param[in] RgSchCellCb      *cell
17373  *  @param[in] RgSchUlHqProcCb  *curProc
17374  *  @param[in] RgSchUlHqProcCb  *oldProc
17375  *  @return  S16
17376  *      -# ROK
17377  *      -# RFAILED
17378  **/
17379 #ifdef ANSI
17380 PUBLIC S16 rgSCHCmnUpdUlHqProc
17381 (
17382 RgSchCellCb      *cell,
17383 RgSchUlHqProcCb  *curProc,
17384 RgSchUlHqProcCb  *oldProc
17385 )
17386 #else
17387 PUBLIC S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
17388 RgSchCellCb      *cell;
17389 RgSchUlHqProcCb  *curProc;
17390 RgSchUlHqProcCb  *oldProc;
17391 #endif
17392 {
17393    TRC2(rgSCHCmnUpdUlHqProc);
17394
17395    UNUSED(cell);
17396    UNUSED(oldProc);
17397 #if (ERRCLASS & ERRCLS_DEBUG)
17398    if (curProc->alloc == NULLP)
17399    {
17400       RETVALUE(RFAILED);
17401    }
17402 #endif
17403    curProc->alloc->hqProc = curProc;
17404    RETVALUE(ROK);
17405 }  /* rgSCHCmnUpdUlHqProc */
17406 #endif
17407
17408 /*MS_WORKAROUND for CR FIXME */
17409 /**
17410  * @brief Hsndles BSR timer expiry
17411  *
17412  * @details
17413  *
17414  *     Function : rgSCHCmnBsrTmrExpry
17415  *
17416  *     This function is invoked when periodic BSR timer expires for a UE.
17417  *
17418  *  @param[in] RgSchUeCb        *ue
17419  *  @return  S16
17420  *      -# ROK
17421  *      -# RFAILED
17422  **/
17423 #ifdef ANSI
17424 PUBLIC S16 rgSCHCmnBsrTmrExpry
17425 (
17426 RgSchUeCb  *ueCb
17427 )
17428 #else
17429 PUBLIC S16 rgSCHCmnBsrTmrExpry(ueCb)
17430 RgSchUeCb  *ueCb;
17431 #endif
17432 {
17433    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
17434
17435    TRC2(rgSCHCmnBsrTmrExpry)
17436
17437    ueCb->isSrGrant = TRUE;
17438
17439 #ifdef EMTC_ENABLE
17440    emtcStatsUlBsrTmrTxp++;
17441 #endif
17442
17443 #ifdef EMTC_ENABLE
17444    if(ueCb->cell->emtcEnable)
17445    {
17446       if(ueCb->isEmtcUe)
17447       {
17448          cellSch->apisEmtcUl->rgSCHSrRcvd(ueCb->cell, ueCb);
17449          RETVALUE(ROK);
17450       }
17451    }
17452    else
17453 #endif
17454    {
17455       cellSch->apisUl->rgSCHSrRcvd(ueCb->cell, ueCb);
17456    }
17457
17458    RETVALUE (ROK);
17459 }
17460
17461 /**
17462  * @brief Short BSR update.
17463  *
17464  * @details
17465  *
17466  *     Function : rgSCHCmnUpdBsrShort
17467  *
17468  *     This functions does requisite updates to handle short BSR reporting.
17469  *
17470  *  @param[in]  RgSchCellCb  *cell
17471  *  @param[in]  RgSchUeCb    *ue
17472  *  @param[in]  RgSchLcgCb *ulLcg
17473  *  @param[in]  U8           bsr
17474  *  @param[out] RgSchErrInfo *err
17475  *  @return  S16
17476  *      -# ROK
17477  *      -# RFAILED
17478  **/
17479 #ifdef ANSI
17480 PUBLIC S16 rgSCHCmnUpdBsrShort
17481 (
17482 RgSchCellCb  *cell,
17483 RgSchUeCb    *ue,
17484 RgSchLcgCb *ulLcg,
17485 U8           bsr,
17486 RgSchErrInfo *err
17487 )
17488 #else
17489 PUBLIC S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
17490 RgSchCellCb  *cell;
17491 RgSchUeCb    *ue;
17492 RgSchLcgCb *ulLcg;
17493 U8           bsr;
17494 RgSchErrInfo *err;
17495 #endif
17496 {
17497    U8  lcgCnt;
17498 #ifdef LTE_L2_MEAS
17499    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
17500 #endif
17501    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17502    RgSchCmnLcg  *cmnLcg  = NULLP;
17503
17504 #ifdef LTE_L2_MEAS
17505    U8             idx;
17506 #endif
17507    TRC2(rgSCHCmnUpdBsrShort);
17508
17509    if (!RGSCH_LCG_ISCFGD(ulLcg))
17510    {
17511       err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
17512       RETVALUE(RFAILED);
17513    }
17514    for (lcgCnt=0; lcgCnt<4; lcgCnt++)
17515    {
17516 #ifdef LTE_L2_MEAS
17517       /* Set BS of all other LCGs to Zero.
17518          If Zero BSR is reported in Short BSR include this LCG too */
17519       if ((lcgCnt != ulLcg->lcgId) ||
17520             (!bsr && !ueUl->hqEnt.numBusyHqProcs))
17521       {
17522          /* If old BO is zero do nothing */
17523          if(((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->bs != 0)
17524          {
17525             for(idx = 0; idx < ue->ul.lcgArr[lcgCnt].numLch; idx++)
17526             {
17527                if((ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->ulUeCount) &&
17528                  (ue->ulActiveLCs & (1 << 
17529                   (ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->qci -1))))
17530                {
17531           /* L2_COUNTER */
17532                  ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->ulUeCount--;
17533                  ue->ulActiveLCs &= ~(1 << 
17534                   (ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->qci -1));
17535                }
17536             }
17537          }
17538       }
17539 #endif
17540       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgCnt]))
17541       {
17542          ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->bs = 0;
17543          ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->reportedBs = 0;
17544       }
17545    }
17546
17547 #ifdef LTE_L2_MEAS
17548    if(ulLcg->lcgId && bsr && (((RgSchCmnLcg *)(ulLcg->sch))->bs == 0))
17549    {
17550       for(idx = 0; idx < ulLcg->numLch; idx++)
17551       {
17552           /* L2_COUNTER */
17553           if (!(ue->ulActiveLCs & (1 << (ulLcg->lcArray[idx]->qciCb->qci -1))))
17554           {
17555              ulLcg->lcArray[idx]->qciCb->ulUeCount++;
17556              ue->ulActiveLCs |= (1 << (ulLcg->lcArray[idx]->qciCb->qci -1));
17557           }
17558       }
17559    }
17560 #endif
17561    /* Resetting the nonGbrLcgBs info here */
17562    ue->ul.nonGbrLcgBs = 0;
17563    ue->ul.nonLcg0Bs = 0;
17564
17565    cmnLcg = ((RgSchCmnLcg *)(ulLcg->sch));
17566    
17567    if (TRUE == ue->ul.useExtBSRSizes)
17568    {
17569       cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsr];
17570    }
17571    else
17572    {
17573       cmnLcg->reportedBs = rgSchCmnBsrTbl[bsr];
17574    }
17575    if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17576    {
17577       /* TBD check for effGbr != 0 */    
17578       cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17579    }
17580    else if (0 == ulLcg->lcgId) 
17581    {
17582       /* This is added for handling LCG0 */
17583       cmnLcg->bs = cmnLcg->reportedBs;
17584    }
17585    else 
17586    {
17587       /* Update non GBR LCG's BS*/
17588       ue->ul.nonGbrLcgBs = RGSCH_MIN(cmnLcg->reportedBs,ue->ul.effAmbr);
17589       cmnLcg->bs     = ue->ul.nonGbrLcgBs;
17590    }
17591    ue->ul.totalBsr = cmnLcg->bs;
17592
17593 #ifdef RGR_V1
17594    if ((ue->bsrTmr.tmrEvnt != TMR_NONE) && (bsr == 0))
17595    {
17596       rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
17597    }
17598 #endif
17599 #ifdef LTEMAC_SPS
17600    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
17601    {
17602       rgSCHCmnSpsBsrRpt(cell, ue, ulLcg);
17603    }
17604 #endif
17605    rgSCHCmnUpdUlCompEffBsr(ue);
17606
17607 #ifdef EMTC_ENABLE
17608    if(cell->emtcEnable)
17609    {
17610       if(ue->isEmtcUe)
17611       {
17612          cellSch->apisEmtcUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
17613          RETVALUE(ROK);
17614       }
17615    }
17616    else
17617 #endif
17618    {
17619    cellSch->apisUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
17620    }
17621
17622 #ifdef LTE_ADV
17623    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17624    {
17625       for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
17626       {
17627 #ifndef PAL_ENABLE_UL_CA
17628          if((ue->cellInfo[sCellIdx] != NULLP) &&
17629                (ue->cellInfo[sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
17630 #else
17631          if(ue->cellInfo[sCellIdx] != NULLP)
17632 #endif
17633          {
17634             cellSch->apisUl->rgSCHUpdBsrShort(ue->cellInfo[sCellIdx]->cell, 
17635                   ue, ulLcg, bsr);
17636          }
17637       }
17638    }
17639 #endif 
17640
17641    RETVALUE(ROK);
17642 }
17643
17644 /**
17645  * @brief Truncated BSR update.
17646  *
17647  * @details
17648  *
17649  *     Function : rgSCHCmnUpdBsrTrunc
17650  *
17651  *     This functions does required updates to handle truncated BSR report.
17652  *
17653  *
17654  *  @param[in]  RgSchCellCb  *cell
17655  *  @param[in]  RgSchUeCb    *ue
17656  *  @param[in]  RgSchLcgCb *ulLcg
17657  *  @param[in]  U8           bsr
17658  *  @param[out] RgSchErrInfo *err
17659  *  @return  S16
17660  *      -# ROK
17661  *      -# RFAILED
17662  **/
17663 #ifdef ANSI
17664 PUBLIC S16 rgSCHCmnUpdBsrTrunc
17665 (
17666 RgSchCellCb  *cell,
17667 RgSchUeCb    *ue,
17668 RgSchLcgCb *ulLcg,
17669 U8           bsr,
17670 RgSchErrInfo *err
17671 )
17672 #else
17673 PUBLIC S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
17674 RgSchCellCb  *cell;
17675 RgSchUeCb    *ue;
17676 RgSchLcgCb *ulLcg;
17677 U8           bsr;
17678 RgSchErrInfo *err;
17679 #endif
17680 {
17681    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17682    RgSchCmnLcg  *cmnLcg = NULLP;
17683    S32          cnt;
17684 #ifdef LTE_L2_MEAS
17685    U8     idx;
17686 #endif
17687
17688    TRC2(rgSCHCmnUpdBsrTrunc);
17689
17690    if (!RGSCH_LCG_ISCFGD(ulLcg))
17691    {
17692       err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
17693       RETVALUE(RFAILED);
17694    }
17695    /* set all higher prio lcgs bs to 0 and update this lcgs bs and
17696       total bsr= sumofall lcgs bs */
17697    if (ulLcg->lcgId)
17698    {
17699       for (cnt = ulLcg->lcgId-1; cnt >= 0; cnt--)
17700       {
17701 #ifdef LTE_L2_MEAS
17702          /* If Existing BO is zero the don't do anything */
17703          if(((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs != 0)
17704          {
17705             for(idx = 0; idx < ue->ul.lcgArr[cnt].numLch; idx++)
17706             {
17707                /* L2_COUNTERS */
17708                if((ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount) &&
17709                      (ue->ulActiveLCs & (1 << 
17710                                          (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1))))
17711                {
17712                   ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount--;
17713                   ue->ulActiveLCs &= ~(1 << 
17714                         (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1));
17715                }
17716             }
17717          }
17718 #endif
17719          ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs = 0;
17720          ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->reportedBs = 0;
17721       }
17722    }
17723
17724 #ifdef LTE_L2_MEAS
17725    for (cnt = ulLcg->lcgId; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
17726    {
17727       if (ulLcg->lcgId == 0)
17728       {
17729          continue;
17730       }
17731       /* If Existing BO is zero the don't do anything */
17732       if(((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs == 0)
17733       {
17734          for(idx = 0; idx < ue->ul.lcgArr[cnt].numLch; idx++)
17735          {
17736             /* L2_COUNTERS */
17737             if (!(ue->ulActiveLCs & (1 << 
17738                (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1))))
17739             {
17740                ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount++;
17741                ue->ulActiveLCs |= (1 << 
17742                      (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1));
17743             }
17744          }
17745       }
17746    }
17747 #endif
17748    ue->ul.nonGbrLcgBs = 0;
17749    ue->ul.nonLcg0Bs = 0;
17750    cmnLcg = ((RgSchCmnLcg *)(ulLcg->sch));
17751    if (TRUE == ue->ul.useExtBSRSizes)
17752    {
17753       cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsr];
17754    }
17755    else
17756    {
17757       cmnLcg->reportedBs = rgSchCmnBsrTbl[bsr];
17758    }
17759    if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17760    {
17761       cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17762    }
17763    else if(ulLcg->lcgId == 0)
17764    {
17765       /* This is for handeling LCG0 */
17766       cmnLcg->bs = cmnLcg->reportedBs;
17767    }
17768    else
17769    {
17770       ue->ul.nonGbrLcgBs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
17771       cmnLcg->bs = ue->ul.nonGbrLcgBs;
17772    }
17773    ue->ul.totalBsr = cmnLcg->bs;
17774
17775    for (cnt = ulLcg->lcgId+1; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
17776    {
17777       /* TODO: The bs for the other LCGs may be stale because some or all of
17778        * the part of bs may have been already scheduled/data received. Please 
17779        * consider this when truncated BSR is tested/implemented */
17780       ue->ul.totalBsr += ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs;
17781    }
17782
17783    rgSCHCmnUpdUlCompEffBsr(ue);
17784
17785 #ifdef EMTC_ENABLE
17786    if(cell->emtcEnable)
17787    {
17788       if(ue->isEmtcUe)
17789       {
17790          cellSch->apisEmtcUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
17791          RETVALUE(ROK);
17792       }
17793    }
17794    else
17795 #endif
17796    {
17797       cellSch->apisUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
17798    }
17799
17800 #ifdef LTE_ADV
17801    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17802    {
17803       for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
17804       {
17805 #ifndef PAL_ENABLE_UL_CA
17806          if((ue->cellInfo[sCellIdx] != NULLP) &&
17807                (ue->cellInfo[sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
17808 #else
17809          if(ue->cellInfo[sCellIdx] != NULLP)
17810 #endif
17811          {
17812             cellSch->apisUl->rgSCHUpdBsrTrunc(ue->cellInfo[sCellIdx]->cell, ue, ulLcg, bsr);
17813          }
17814       }
17815    }
17816 #endif 
17817
17818    RETVALUE(ROK);
17819 }
17820
17821 /**
17822  * @brief Long BSR update.
17823  *
17824  * @details
17825  *
17826  *     Function : rgSCHCmnUpdBsrLong
17827  *
17828  *     - Update BSRs for all configured LCGs.
17829  *     - Update priority of LCGs if needed.
17830  *     - Update UE's position within/across uplink scheduling queues.
17831  *
17832  *
17833  *  @param[in]  RgSchCellCb  *cell
17834  *  @param[in]  RgSchUeCb    *ue
17835  *  @param[in]  U8 bsArr[]
17836  *  @param[out] RgSchErrInfo *err
17837  *  @return  S16
17838  *      -# ROK
17839  *      -# RFAILED
17840  **/
17841 #ifdef ANSI
17842 PUBLIC S16 rgSCHCmnUpdBsrLong
17843 (
17844 RgSchCellCb  *cell,
17845 RgSchUeCb    *ue,
17846 U8           *bsArr,
17847 RgSchErrInfo *err
17848 )
17849 #else
17850 PUBLIC S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
17851 RgSchCellCb  *cell;
17852 RgSchUeCb    *ue;
17853 U8           *bsArr;
17854 RgSchErrInfo *err;
17855 #endif
17856 {
17857    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17858    U32           tmpBsArr[4] = {0, 0, 0, 0};
17859    U32           nonGbrBs = 0;
17860 #ifdef LTE_L2_MEAS
17861    U8            idx1;
17862    U8            idx2;
17863 #endif
17864    U32           lcgId;
17865
17866    TRC2(rgSCHCmnUpdBsrLong);
17867
17868 #ifdef LTE_L2_MEAS
17869    for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
17870    {
17871      /* If Old BO is non zero then do nothing */
17872      if ((((RgSchCmnLcg *)(ue->ul.lcgArr[idx1].sch))->bs == 0)
17873         && bsArr[idx1] )
17874      {
17875        for(idx2 = 0; idx2 < ue->ul.lcgArr[idx1].numLch; idx2++)
17876        {
17877           /* L2_COUNTERS */
17878           if (!(ue->ulActiveLCs & (1 << 
17879              (ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->qci -1))))
17880           {
17881              ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->ulUeCount++;
17882              ue->ulActiveLCs |= (1 << 
17883                (ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->qci -1));
17884           }
17885        }
17886      }
17887    }
17888 #endif
17889    ue->ul.nonGbrLcgBs = 0;
17890    ue->ul.nonLcg0Bs = 0;
17891
17892    if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[0]))
17893    {
17894       if (TRUE == ue->ul.useExtBSRSizes)
17895       {
17896          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = rgSchCmnExtBsrTbl[bsArr[0]];
17897          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->reportedBs = rgSchCmnExtBsrTbl[bsArr[0]];
17898          tmpBsArr[0] = rgSchCmnExtBsrTbl[bsArr[0]];
17899       }
17900       else
17901       {
17902          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = rgSchCmnBsrTbl[bsArr[0]];
17903          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->reportedBs = rgSchCmnBsrTbl[bsArr[0]];
17904          tmpBsArr[0] = rgSchCmnBsrTbl[bsArr[0]];
17905       }
17906    }
17907    for (lcgId = 1; lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
17908    {
17909       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
17910       {
17911          RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
17912
17913          if (TRUE == ue->ul.useExtBSRSizes)
17914          {
17915             cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsArr[lcgId]];
17916          }
17917          else
17918          {
17919             cmnLcg->reportedBs = rgSchCmnBsrTbl[bsArr[lcgId]];
17920          }
17921          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17922          {
17923             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17924             tmpBsArr[lcgId] = cmnLcg->bs;
17925          }
17926          else
17927          {
17928             nonGbrBs += cmnLcg->reportedBs;
17929             tmpBsArr[lcgId] = cmnLcg->reportedBs;
17930             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs,ue->ul.effAmbr);
17931          }
17932       }
17933    }
17934    ue->ul.nonGbrLcgBs = RGSCH_MIN(nonGbrBs,ue->ul.effAmbr);
17935
17936    ue->ul.totalBsr = tmpBsArr[0] + tmpBsArr[1] + tmpBsArr[2] + tmpBsArr[3];
17937 #ifdef RGR_V1
17938    if ((ue->bsrTmr.tmrEvnt != TMR_NONE) && (ue->ul.totalBsr == 0))
17939    {
17940       rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
17941    }
17942 #endif
17943
17944 #ifdef LTEMAC_SPS
17945    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE) /* SPS_FIX */
17946    {
17947      if(ue->ul.totalBsr - tmpBsArr[1] == 0)
17948      {/* Updaing the BSR to SPS only if LCG1 BS is present in sps active state */
17949         rgSCHCmnSpsBsrRpt(cell, ue, &ue->ul.lcgArr[1]);
17950      }
17951    }
17952 #endif
17953    rgSCHCmnUpdUlCompEffBsr(ue);
17954
17955 #ifdef EMTC_ENABLE
17956    if(cell->emtcEnable)
17957    {
17958       if(ue->isEmtcUe)
17959       {
17960          cellSch->apisEmtcUl->rgSCHUpdBsrLong(cell, ue, bsArr);
17961          RETVALUE(ROK);
17962       }
17963    }
17964    else
17965 #endif
17966    {
17967    cellSch->apisUl->rgSCHUpdBsrLong(cell, ue, bsArr);
17968    }
17969
17970 #ifdef LTE_ADV
17971    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17972    {
17973       for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
17974       {
17975 #ifndef PAL_ENABLE_UL_CA
17976          if((ue->cellInfo[idx] != NULLP) &&
17977                (ue->cellInfo[idx]->sCellState == RG_SCH_SCELL_ACTIVE))
17978 #else
17979          if(ue->cellInfo[idx] != NULLP)
17980 #endif
17981          {
17982             cellSch->apisUl->rgSCHUpdBsrLong(ue->cellInfo[idx]->cell, ue, bsArr);
17983          }
17984       }
17985    }
17986 #endif 
17987
17988    RETVALUE(ROK);
17989 }
17990
17991 /**
17992  * @brief PHR update.
17993  *
17994  * @details
17995  *
17996  *     Function : rgSCHCmnUpdExtPhr
17997  *
17998  *     Updates extended power headroom information for an UE.
17999  *
18000  *  @param[in]  RgSchCellCb  *cell
18001  *  @param[in]  RgSchUeCb    *ue
18002  *  @param[in]  U8           phr
18003  *  @param[out] RgSchErrInfo *err
18004  *  @return  S16
18005  *      -# ROK
18006  *      -# RFAILED
18007  **/
18008 #ifdef ANSI
18009 PUBLIC S16 rgSCHCmnUpdExtPhr
18010 (
18011 RgSchCellCb    *cell,
18012 RgSchUeCb      *ue,
18013 RgInfExtPhrCEInfo *extPhr,
18014 RgSchErrInfo   *err
18015 )
18016 #else
18017 PUBLIC S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
18018 RgSchCellCb    *cell;
18019 RgSchUeCb      *ue;
18020 RgInfExtPhrCEInfo *extPhr;
18021 RgSchErrInfo   *err;
18022 #endif
18023 {
18024    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18025    RgSchCmnAllocRecord *allRcd;
18026    CmLList             *node = ueUl->ulAllocLst.last;
18027
18028 #ifdef LTEMAC_SPS
18029    RgSchCmnUlUeSpsInfo   *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
18030 #endif
18031    TRC2(rgSCHCmnUpdExtPhr);
18032
18033    UNUSED(err);
18034
18035    while (node)
18036    {
18037       allRcd = (RgSchCmnAllocRecord *)node->node;
18038       node = node->prev;
18039       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18040       {
18041          rgSCHPwrUpdExtPhr(cell, ue, extPhr, allRcd);
18042          break;
18043       }
18044    }
18045 #ifdef LTEMAC_SPS
18046    if(ulSpsUe->isUlSpsActv)
18047    {
18048       rgSCHCmnSpsPhrInd(cell,ue);
18049    }
18050 #endif
18051
18052    RETVALUE(ROK);
18053 }  /* rgSCHCmnUpdExtPhr */
18054
18055
18056
18057
18058 /**
18059  * @brief PHR update.
18060  *
18061  * @details
18062  *
18063  *     Function : rgSCHCmnUpdPhr
18064  *
18065  *     Updates power headroom information for an UE.
18066  *
18067  *  @param[in]  RgSchCellCb  *cell
18068  *  @param[in]  RgSchUeCb    *ue
18069  *  @param[in]  U8           phr
18070  *  @param[out] RgSchErrInfo *err
18071  *  @return  S16
18072  *      -# ROK
18073  *      -# RFAILED
18074  **/
18075 #ifdef ANSI
18076 PUBLIC S16 rgSCHCmnUpdPhr
18077 (
18078 RgSchCellCb    *cell,
18079 RgSchUeCb      *ue,
18080 U8             phr,
18081 RgSchErrInfo   *err
18082 )
18083 #else
18084 PUBLIC S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
18085 RgSchCellCb    *cell;
18086 RgSchUeCb      *ue;
18087 U8             phr;
18088 RgSchErrInfo   *err;
18089 #endif
18090 {
18091    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18092    RgSchCmnAllocRecord *allRcd;
18093    CmLList             *node = ueUl->ulAllocLst.last;
18094
18095 #ifdef LTEMAC_SPS
18096    RgSchCmnUlUeSpsInfo   *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
18097 #endif
18098    TRC2(rgSCHCmnUpdPhr);
18099
18100    UNUSED(err);
18101
18102    while (node)
18103    {
18104       allRcd = (RgSchCmnAllocRecord *)node->node;
18105       node = node->prev;
18106       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18107       {
18108          rgSCHPwrUpdPhr(cell, ue, phr, allRcd, RG_SCH_CMN_PWR_USE_CFG_MAX_PWR);
18109          break;
18110       }
18111    }
18112 #ifdef LTEMAC_SPS
18113    if(ulSpsUe->isUlSpsActv)
18114    {
18115       rgSCHCmnSpsPhrInd(cell,ue);
18116    }
18117 #endif
18118
18119    RETVALUE(ROK);
18120 }  /* rgSCHCmnUpdPhr */
18121
18122 /**
18123  * @brief UL grant for contention resolution.
18124  *
18125  * @details
18126  *
18127  *     Function : rgSCHCmnContResUlGrant
18128  *
18129  *     Add UE to another queue specifically for CRNTI based contention
18130  *     resolution.
18131  *
18132  *
18133  *  @param[in]  RgSchUeCb    *ue
18134  *  @param[out] RgSchErrInfo *err
18135  *  @return  S16
18136  *      -# ROK
18137  *      -# RFAILED
18138  **/
18139 #ifdef ANSI
18140 PUBLIC S16 rgSCHCmnContResUlGrant
18141 (
18142 RgSchCellCb  *cell,
18143 RgSchUeCb    *ue,
18144 RgSchErrInfo *err
18145 )
18146 #else
18147 PUBLIC S16 rgSCHCmnContResUlGrant(cell, ue, err)
18148 RgSchCellCb  *cell;
18149 RgSchUeCb    *ue;
18150 RgSchErrInfo *err;
18151 #endif
18152 {
18153    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
18154    TRC2(rgSCHCmnContResUlGrant);
18155
18156    #ifdef EMTC_ENABLE
18157    if(cell->emtcEnable)
18158    {
18159       if(ue->isEmtcUe)
18160       {
18161          cellSch->apisEmtcUl->rgSCHContResUlGrant(cell, ue);
18162          RETVALUE(ROK);
18163       }
18164    }
18165    else
18166 #endif
18167    {
18168       cellSch->apisUl->rgSCHContResUlGrant(cell, ue);
18169    }
18170    RETVALUE(ROK);
18171 }
18172
18173 /**
18174  * @brief SR reception handling.
18175  *
18176  * @details
18177  *
18178  *     Function : rgSCHCmnSrRcvd
18179  *
18180  *     - Update UE's position within/across uplink scheduling queues
18181  *     - Update priority of LCGs if needed.
18182  *
18183  *  @param[in]  RgSchCellCb  *cell
18184  *  @param[in]  RgSchUeCb    *ue
18185  *  @param[in]  CmLteTimingInfo frm
18186  *  @param[out] RgSchErrInfo *err
18187  *  @return  S16
18188  *      -# ROK
18189  *      -# RFAILED
18190  **/
18191 #ifdef ANSI
18192 PUBLIC S16 rgSCHCmnSrRcvd
18193 (
18194 RgSchCellCb  *cell,
18195 RgSchUeCb    *ue,
18196 CmLteTimingInfo frm,
18197 RgSchErrInfo *err
18198 )
18199 #else
18200 PUBLIC S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
18201 RgSchCellCb  *cell;
18202 RgSchUeCb    *ue;
18203 CmLteTimingInfo frm;
18204 RgSchErrInfo *err;
18205 #endif
18206 {
18207    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
18208    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
18209    CmLList      *node    = ueUl->ulAllocLst.last;
18210
18211    TRC2(rgSCHCmnSrRcvd);
18212
18213 #ifdef EMTC_ENABLE
18214    emtcStatsUlTomSrInd++;
18215 #endif
18216
18217    RGSCH_INCR_SUB_FRAME(frm, 1); /* 1 TTI after the time SR was sent */
18218    while (node)
18219    {
18220       RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)node->node;
18221       if (RGSCH_TIMEINFO_SAME(frm, allRcd->allocTime))
18222       {
18223          break;
18224       }
18225       node = node->prev;
18226    }
18227    //TODO_SID Need to check when it is getting triggered
18228    ue->isSrGrant = TRUE;
18229 #ifdef EMTC_ENABLE
18230    if(cell->emtcEnable)
18231    {
18232       if(ue->isEmtcUe)
18233       {
18234          cellSch->apisEmtcUl->rgSCHSrRcvd(cell, ue);
18235          RETVALUE(ROK);
18236       }
18237    }
18238    else
18239 #endif
18240    {
18241       cellSch->apisUl->rgSCHSrRcvd(cell, ue);
18242    }
18243    RETVALUE(ROK);
18244 }
18245
18246 /**
18247  * @brief Returns first uplink allocation to send reception
18248  *        request to PHY.
18249  *
18250  * @details
18251  *
18252  *     Function: rgSCHCmnFirstRcptnReq(cell)
18253  *     Purpose:  This function returns the first uplink allocation
18254  *               (or NULLP if there is none) in the subframe
18255  *               in which is expected to prepare and send reception
18256  *               request to PHY.
18257  *
18258  *     Invoked by: TOM
18259  *
18260  *  @param[in]  RgSchCellCb      *cell
18261  *  @return  RgSchUlAlloc*
18262  **/
18263 #ifdef ANSI
18264 PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq
18265 (
18266 RgSchCellCb      *cell
18267 )
18268 #else
18269 PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
18270 RgSchCellCb      *cell;
18271 #endif
18272 {
18273    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18274 /* ACC_TDD */
18275    RgSchUlAlloc* alloc = NULLP;
18276
18277    TRC2(rgSCHCmnFirstRcptnReq);
18278
18279    if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
18280    {
18281            RgSchUlSf* sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18282            alloc = rgSCHUtlUlAllocFirst(sf);
18283
18284            if (alloc && alloc->hqProc == NULLP)
18285            {
18286                    alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18287            }
18288    }
18289
18290    RETVALUE(alloc);
18291 }
18292
18293 /**
18294  * @brief Returns first uplink allocation to send reception
18295  *        request to PHY.
18296  *
18297  * @details
18298  *
18299  *     Function: rgSCHCmnNextRcptnReq(cell)
18300  *     Purpose:  This function returns the next uplink allocation
18301  *               (or NULLP if there is none) in the subframe
18302  *               in which is expected to prepare and send reception
18303  *               request to PHY.
18304  *
18305  *     Invoked by: TOM
18306  *
18307  *  @param[in]  RgSchCellCb      *cell
18308  *  @return  RgSchUlAlloc*
18309  **/
18310 #ifdef ANSI
18311 PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq
18312 (
18313 RgSchCellCb      *cell,
18314 RgSchUlAlloc     *alloc
18315 )
18316 #else
18317 PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
18318 RgSchCellCb      *cell;
18319 RgSchUlAlloc     *alloc;
18320 #endif
18321 {
18322    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18323 /* ACC-TDD */
18324    //RgSchUlSf      *sf   = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18325
18326    TRC2(rgSCHCmnNextRcptnReq);
18327 /* ACC-TDD */
18328    if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
18329    {
18330            RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18331
18332            alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18333            if (alloc && alloc->hqProc == NULLP)
18334            {
18335                    alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18336            }
18337    }
18338    else
18339    {
18340            alloc = NULLP;
18341    }
18342
18343    RETVALUE(alloc);
18344 }
18345 /**
18346  * @brief Collates DRX enabled UE's scheduled in this SF
18347  *
18348  * @details
18349  *
18350  *     Function: rgSCHCmnDrxStrtInActvTmrInUl(cell)
18351  *     Purpose:  This function collates the link
18352  *               of UE's scheduled in this SF who
18353  *               have drx enabled. It then calls
18354  *               DRX specific function to start/restart
18355  *               inactivity timer in Ul
18356  *
18357  *     Invoked by: TOM
18358  *
18359  *  @param[in]  RgSchCellCb      *cell
18360  *  @return Void
18361  **/
18362 #ifdef ANSI
18363 PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl
18364 (
18365 RgSchCellCb      *cell
18366 )
18367 #else
18368 PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
18369 RgSchCellCb      *cell;
18370 #endif
18371 {
18372    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18373    RgSchUlSf      *sf     = &(cellUl->ulSfArr[cellUl->schdIdx]);
18374    RgSchUlAlloc   *alloc  = rgSCHUtlUlAllocFirst(sf);
18375    CmLListCp       ulUeLst;
18376    RgSchUeCb       *ueCb;
18377
18378
18379    TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
18380
18381    cmLListInit(&ulUeLst);
18382
18383    while(alloc)
18384    {
18385       ueCb = alloc->ue;
18386
18387       if (ueCb)
18388       {
18389          if (!(alloc->grnt.isRtx) && ueCb->isDrxEnabled && !(ueCb->isSrGrant)
18390 #ifdef LTEMAC_SPS
18391              /* ccpu00139513- DRX inactivity timer should not be started for 
18392               * UL SPS occasions */
18393              && (alloc->hqProc->isSpsOccnHqP == FALSE) 
18394 #endif
18395              )
18396          {
18397             cmLListAdd2Tail(&ulUeLst,&(ueCb->ulDrxInactvTmrLnk));
18398             ueCb->ulDrxInactvTmrLnk.node = (PTR)ueCb;
18399          }
18400       }
18401
18402       alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18403    }/*while(alloc)*/
18404
18405    (Void)rgSCHDrxStrtInActvTmr(cell,&ulUeLst,RG_SCH_DRX_UL);
18406
18407    RETVOID;
18408 }
18409
18410
18411 /**
18412  * @brief Returns first uplink allocation to send HARQ feedback
18413  *        request to PHY.
18414  *
18415  * @details
18416  *
18417  *     Function: rgSCHCmnFirstHqFdbkAlloc
18418  *     Purpose:  This function returns the first uplink allocation
18419  *               (or NULLP if there is none) in the subframe
18420  *               for which it is expected to prepare and send HARQ
18421  *               feedback to PHY.
18422  *
18423  *     Invoked by: TOM
18424  *
18425  *  @param[in]  RgSchCellCb      *cell
18426  *  @param[in]  U8               idx
18427  *  @return  RgSchUlAlloc*
18428  **/
18429 #ifdef ANSI
18430 PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
18431 (
18432 RgSchCellCb      *cell,
18433 U8               idx 
18434 )
18435 #else
18436 PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
18437 RgSchCellCb      *cell;
18438 U8               idx;
18439 #endif
18440 {
18441    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18442 /* ACC-TDD */
18443    RgSchUlAlloc  *alloc = NULLP;
18444
18445    TRC2(rgSCHCmnFirstHqFdbkAlloc);
18446
18447    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
18448    {
18449           RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
18450           alloc    = rgSCHUtlUlAllocFirst(sf);
18451
18452           while (alloc && (alloc->hqProc == NULLP))
18453           {
18454                   alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18455           }
18456    }
18457
18458    RETVALUE(alloc);
18459 }
18460
18461 /**
18462  * @brief Returns next allocation to send HARQ feedback for.
18463  *
18464  * @details
18465  *
18466  *     Function: rgSCHCmnNextHqFdbkAlloc(cell)
18467  *     Purpose:  This function returns the next uplink allocation
18468  *               (or NULLP if there is none) in the subframe
18469  *               for which HARQ feedback needs to be sent.
18470  *
18471  *     Invoked by: TOM
18472  *
18473  *  @param[in]  RgSchCellCb      *cell
18474  *  @return  RgSchUlAlloc*
18475  **/
18476 #ifdef ANSI
18477 PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
18478 (
18479 RgSchCellCb      *cell,
18480 RgSchUlAlloc     *alloc,
18481 U8               idx 
18482 )
18483 #else
18484 PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
18485 RgSchCellCb      *cell;
18486 RgSchUlAlloc     *alloc;
18487 U8               idx; 
18488 #endif
18489 {
18490    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18491    TRC2(rgSCHCmnNextHqFdbkAlloc);
18492
18493    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
18494    {
18495       RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
18496
18497       alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18498       while (alloc && (alloc->hqProc == NULLP))
18499       {
18500          alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18501       }
18502    }
18503    else
18504    {
18505           alloc = NULLP;
18506    }
18507    RETVALUE(alloc);
18508 }
18509
18510 /***********************************************************
18511  *
18512  *     Func : rgSCHCmnUlGetITbsFrmIMcs
18513  *
18514  *     Desc : Returns the Itbs that is mapped to an Imcs
18515  *            for the case of uplink.
18516  *
18517  *     Ret  :
18518  *
18519  *     Notes:
18520  *
18521  *     File :
18522  *
18523  **********************************************************/
18524 #ifdef ANSI
18525 PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs
18526 (
18527 U8          iMcs
18528 )
18529 #else
18530 PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
18531 U8          iMcs;
18532 #endif
18533 {
18534    TRC2(rgSCHCmnUlGetITbsFrmIMcs);
18535
18536    RETVALUE(rgUlIMcsTbl[iMcs].iTbs);
18537 }
18538
18539 /***********************************************************
18540  *
18541  *     Func : rgSCHCmnUlGetIMcsFrmITbs
18542  *
18543  *     Desc : Returns the Imcs that is mapped to an Itbs
18544  *            for the case of uplink.
18545  *
18546  *     Ret  :
18547  *
18548  *     Notes: For iTbs 19, iMcs is dependant on modulation order.
18549  *            Refer to 36.213, Table 8.6.1-1 and 36.306 Table 4.1-2
18550  *            for UE capability information
18551  *
18552  *     File :
18553  *
18554  **********************************************************/
18555 #ifdef ANSI
18556 PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs
18557 (
18558 U8                iTbs,
18559 CmLteUeCategory   ueCtg
18560 )
18561 #else
18562 PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
18563 U8                iTbs;
18564 CmLteUeCategory   ueCtg;
18565 #endif
18566 {
18567    U8 iMcs;
18568    TRC2(rgSCHCmnUlGetIMcsFrmITbs);
18569
18570    if (iTbs <= 10)
18571    {
18572       iMcs = iTbs;
18573    }
18574    /*a higher layer can force a 64QAM UE to transmit at 16QAM.
18575     * We currently do not support this. Once the support for such
18576     * is added, ueCtg should be replaced by current transmit
18577     * modulation configuration.Refer to 36.213 -8.6.1
18578     */
18579    else if ( iTbs < 19 )
18580    {
18581       iMcs = iTbs + 1;
18582    }
18583    else if ((iTbs == 19) && (ueCtg != CM_LTE_UE_CAT_5))
18584    {
18585       iMcs = iTbs + 1;
18586    }
18587    else
18588    {
18589       iMcs = iTbs + 2;
18590    }
18591
18592 #ifdef LTE_TDD
18593    /* This is a Temp fix, done for TENBPLUS-3898, ULSCH SDU corruption
18594       was seen when IMCS exceeds 20  on T2k TDD*/
18595    if (iMcs > 20)
18596    {
18597       iMcs = 20;
18598    }
18599 #endif
18600
18601    RETVALUE(iMcs);
18602 }
18603
18604 /***********************************************************
18605  *
18606  *     Func : rgSCHCmnUlMinTbBitsForITbs
18607  *
18608  *     Desc : Returns the minimum number of bits that can
18609  *            be given as grant for a specific CQI.
18610  *
18611  *     Ret  :
18612  *
18613  *     Notes:
18614  *
18615  *     File :
18616  *
18617  **********************************************************/
18618 #ifdef ANSI
18619 PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs
18620 (
18621 RgSchCmnUlCell     *cellUl,
18622 U8                 iTbs
18623 )
18624 #else
18625 PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
18626 RgSchCmnUlCell   *cellUl;
18627 U8               iTbs;
18628 #endif
18629 {
18630    TRC2(rgSCHCmnUlMinTbBitsForITbs);
18631
18632    RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs); 
18633
18634    RETVALUE(rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
18635 }
18636
18637 /***********************************************************
18638  *
18639  *     Func : rgSCHCmnUlSbAlloc
18640  *
18641  *     Desc : Given a required 'number of subbands' and a hole,
18642  *            returns a suitable alloc such that the subband
18643  *            allocation size is valid
18644  *
18645  *     Ret  :
18646  *
18647  *     Notes: Does not assume either passed numSb or hole size
18648  *            to be valid for allocation, and hence arrives at
18649  *            an acceptable value.
18650  *     File :
18651  *
18652  **********************************************************/
18653 #ifdef ANSI
18654 PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc
18655 (
18656 RgSchUlSf       *sf,
18657 U8              numSb,
18658 RgSchUlHole     *hole
18659 )
18660 #else
18661 PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
18662 RgSchUlSf       *sf;
18663 U8              numSb;
18664 RgSchUlHole     *hole;
18665 #endif
18666 {
18667    U8           holeSz; /* valid hole size */
18668    RgSchUlAlloc *alloc;
18669    TRC2(rgSCHCmnUlSbAlloc);
18670
18671    if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
18672    {
18673       numSb = rgSchCmnMult235Tbl[numSb].match;
18674       if (numSb >= holeSz)
18675       {
18676          alloc = rgSCHUtlUlAllocGetCompHole(sf, hole);
18677       }
18678       else
18679       {
18680          alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
18681       }
18682    }
18683    else
18684    {
18685       if (numSb < holeSz)
18686       {
18687          numSb = rgSchCmnMult235Tbl[numSb].match;
18688       }
18689       else
18690       {
18691          numSb = rgSchCmnMult235Tbl[numSb].prvMatch;
18692       }
18693
18694       if ( numSb >= holeSz )
18695       {
18696          numSb = holeSz;
18697       }
18698       alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
18699    }
18700    RETVALUE(alloc);
18701 }
18702
18703 /**
18704  * @brief To fill the RgSchCmnUeUlAlloc structure of UeCb.
18705  *
18706  * @details
18707  *
18708  *     Function: rgSCHCmnUlUeFillAllocInfo
18709  *     Purpose:  Specific scheduler to call this API to fill the alloc
18710  *               information.
18711  *
18712  *     Invoked by: Scheduler
18713  *
18714  *  @param[in]  RgSchCellCb      *cell
18715  *  @param[out] RgSchUeCb        *ue
18716  *  @return   Void
18717  **/
18718 #ifdef ANSI
18719 PUBLIC Void rgSCHCmnUlUeFillAllocInfo
18720 (
18721 RgSchCellCb      *cell,
18722 RgSchUeCb        *ue
18723 )
18724 #else
18725 PUBLIC Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
18726 RgSchCellCb      *cell;
18727 RgSchUeCb        *ue;
18728 #endif
18729 {
18730    RgSchCmnUlCell     *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18731    RgSchCmnUeUlAlloc  *ulAllocInfo;
18732    RgSchCmnUlUe       *ueUl;
18733
18734    TRC2(rgSCHCmnUlUeFillAllocInfo);
18735
18736    ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18737    ulAllocInfo = &ueUl->alloc;
18738
18739    /* Fill alloc structure */
18740    rgSCHCmnUlAllocFillTpc(cell, ue, ulAllocInfo->alloc);
18741    rgSCHCmnUlAllocFillNdmrs(cellUl, ulAllocInfo->alloc);
18742    rgSCHCmnUlAllocLnkHqProc(ue, ulAllocInfo->alloc, ulAllocInfo->alloc->hqProc,
18743                      ulAllocInfo->alloc->hqProc->isRetx);
18744    /* Fill PDCCH */
18745    rgSCHCmnUlFillPdcchWithAlloc(ulAllocInfo->alloc->pdcch,
18746          ulAllocInfo->alloc, ue);
18747    /* Recording information about this allocation */
18748    rgSCHCmnUlRecordUeAlloc(cell, ue);
18749
18750    /* Update the UE's outstanding allocation */
18751    if (!ulAllocInfo->alloc->hqProc->isRetx)
18752    {
18753       rgSCHCmnUlUpdOutStndAlloc(cell, ue, ulAllocInfo->allocdBytes);
18754    }
18755
18756    RETVOID;
18757 }
18758
18759 /**
18760  * @brief Update the UEs outstanding alloc based on the BSR report's timing.
18761  *
18762  *
18763  * @details
18764  *
18765  *     Function: rgSCHCmnUpdUlCompEffBsr
18766  *     Purpose:  Clear off all the allocations from outstanding allocation that
18767  *     are later than or equal to BSR timing information (stored in UEs datIndTime).
18768  *
18769  *     Invoked by: Scheduler
18770  *
18771  *  @param[in]  RgSchUeCb *ue
18772  *  @return  Void
18773  **/
18774 #ifdef ANSI
18775 PRIVATE Void rgSCHCmnUpdUlCompEffBsr
18776 (
18777 RgSchUeCb *ue
18778 )
18779 #else
18780 PRIVATE Void rgSCHCmnUpdUlCompEffBsr(ue)
18781 RgSchUeCb *ue;
18782 #endif
18783 {
18784    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,ue->cell);
18785    CmLList   *node = ueUl->ulAllocLst.last;
18786    RgSchCmnAllocRecord *allRcd;
18787    U32 outStndAlloc=0;
18788    U32 nonLcg0OutStndAllocBs=0;
18789    U32 nonLcg0Bsr=0;
18790    U8  lcgId;
18791    RgSchCmnLcg *cmnLcg = NULLP;
18792    TRC2(rgSCHCmnUpdUlCompEffBsr);
18793
18794    while (node)
18795    {
18796       allRcd = (RgSchCmnAllocRecord *)node->node;
18797       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18798       {
18799          node = node->next;
18800          break;
18801       }
18802       node = node->prev;
18803    }
18804    while (node)
18805    {
18806       allRcd = (RgSchCmnAllocRecord *)node->node;
18807       node = node->next;
18808       outStndAlloc += allRcd->alloc;
18809    }
18810  
18811    cmnLcg = (RgSchCmnLcg *)(ue->ul.lcgArr[0].sch);
18812    /* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
18813    if (cmnLcg->bs > outStndAlloc)
18814    {
18815       cmnLcg->bs -= outStndAlloc;
18816       ue->ul.minReqBytes = cmnLcg->bs;
18817       outStndAlloc = 0;
18818    }
18819    else
18820    {
18821       nonLcg0OutStndAllocBs = outStndAlloc - cmnLcg->bs;
18822       cmnLcg->bs = 0;
18823    }
18824
18825    for(lcgId = 1;lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
18826    {
18827       if(RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
18828       {
18829          cmnLcg = ((RgSchCmnLcg *) (ue->ul.lcgArr[lcgId].sch));
18830          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
18831          {
18832             nonLcg0Bsr += cmnLcg->bs;
18833          }
18834       }
18835    }
18836    nonLcg0Bsr += ue->ul.nonGbrLcgBs;  
18837    if (nonLcg0OutStndAllocBs > nonLcg0Bsr)
18838    {
18839       nonLcg0Bsr = 0;
18840    }
18841    else
18842    {
18843       nonLcg0Bsr -= nonLcg0OutStndAllocBs;
18844    }
18845    ue->ul.nonLcg0Bs = nonLcg0Bsr;
18846    /* Cap effBsr with nonLcg0Bsr and append lcg0 bs.
18847     * nonLcg0Bsr limit applies only to lcg1,2,3 */
18848    /* better be handled in individual scheduler */
18849    ue->ul.effBsr = nonLcg0Bsr +\
18850                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
18851    RETVOID;
18852 }
18853
18854 /**
18855  * @brief  Records information about the current allocation.
18856  *
18857  * @details
18858  *
18859  *     Function: rgSCHCmnUlRecordUeAlloc
18860  *     Purpose:  Records information about the curent allocation.
18861  *               This includes the allocated bytes, as well
18862  *               as some power information.
18863  *
18864  *     Invoked by: Scheduler
18865  *
18866  *  @param[in]  RgSchCellCb *cell
18867  *  @param[in]  RgSchUeCb   *ue
18868  *  @return  Void
18869  **/
18870 #ifdef ANSI
18871 PUBLIC Void rgSCHCmnUlRecordUeAlloc
18872 (
18873 RgSchCellCb *cell,
18874 RgSchUeCb   *ue
18875 )
18876 #else
18877 PUBLIC Void rgSCHCmnUlRecordUeAlloc(cell, ue)
18878 RgSchCellCb *cell;
18879 RgSchUeCb   *ue;
18880 #endif
18881 {
18882 #ifdef LTE_TDD
18883    RgSchCmnUlCell     *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18884 #endif
18885    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18886    CmLListCp           *lst = &ueUl->ulAllocLst;
18887    CmLList             *node = ueUl->ulAllocLst.first;
18888    RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
18889    RgSchCmnUeUlAlloc  *ulAllocInfo = &ueUl->alloc;
18890    CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
18891    TRC2(rgSCHCmnUlRecordUeAlloc);
18892
18893    cmLListDelFrm(lst, &allRcd->lnk);
18894 #ifndef LTE_TDD
18895    /* To the crntTime, add the MIN time at which UE will
18896     * actually send the BSR i.e DELTA+4 */
18897    allRcd->allocTime = cell->crntTime;
18898    /*ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
18899 #ifdef EMTC_ENABLE
18900    if(ue->isEmtcUe == TRUE)
18901    {
18902       RGSCH_INCR_SUB_FRAME_EMTC(allRcd->allocTime,
18903                            (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
18904    }
18905    else
18906 #endif
18907    {
18908       RGSCH_INCR_SUB_FRAME(allRcd->allocTime,
18909                            (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
18910    }
18911 #else
18912    allRcd->allocTime = cellUl->schdTime;
18913 #endif
18914    cmLListAdd2Tail(lst, &allRcd->lnk);
18915
18916    /* Filling in the parameters to be recorded */
18917    allRcd->alloc = ulAllocInfo->allocdBytes;
18918    //allRcd->numRb = ulAllocInfo->alloc->grnt.numRb;
18919    allRcd->numRb = (ulAllocInfo->alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
18920    /*Recording the UL CQI derived from the maxUlCqi */
18921    allRcd->cqi   = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
18922    allRcd->tpc   = ulAllocInfo->alloc->grnt.tpc;
18923
18924    rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
18925
18926    cell->measurements.ulBytesCnt += ulAllocInfo->allocdBytes;
18927
18928    RETVOID;
18929 }
18930
18931 /** PHR handling for MSG3
18932  * @brief  Records allocation information of msg3 in the the UE.
18933  *
18934  * @details
18935  *
18936  *     Function: rgSCHCmnUlRecMsg3Alloc
18937  *     Purpose:  Records information about msg3 allocation.
18938  *               This includes the allocated bytes, as well
18939  *               as some power information.
18940  *
18941  *     Invoked by: Scheduler
18942  *
18943  *  @param[in]  RgSchCellCb *cell
18944  *  @param[in]  RgSchUeCb   *ue
18945  *  @param[in]  RgSchRaCb   *raCb
18946  *  @return  Void
18947  **/
18948 #ifdef ANSI
18949 PUBLIC Void rgSCHCmnUlRecMsg3Alloc
18950 (
18951 RgSchCellCb *cell,
18952 RgSchUeCb   *ue,
18953 RgSchRaCb   *raCb
18954 )
18955 #else
18956 PUBLIC Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
18957 RgSchCellCb *cell;
18958 RgSchUeCb   *ue;
18959 RgSchRaCb   *raCb;
18960 #endif
18961 {
18962    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18963    CmLListCp           *lst = &ueUl->ulAllocLst;
18964    CmLList             *node = ueUl->ulAllocLst.first;
18965    RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
18966
18967    /* Stack Crash problem for TRACE5 changes */
18968    TRC2(rgSCHCmnUlRecMsg3Alloc);
18969
18970    cmLListDelFrm(lst, node);
18971    allRcd->allocTime = raCb->msg3AllocTime;
18972    cmLListAdd2Tail(lst, node);
18973
18974    /* Filling in the parameters to be recorded */
18975    allRcd->alloc = raCb->msg3Grnt.datSz;
18976    allRcd->numRb = raCb->msg3Grnt.numRb;
18977    allRcd->cqi   = raCb->ccchCqi;
18978    allRcd->tpc   = raCb->msg3Grnt.tpc;
18979
18980    rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
18981
18982    RETVOID;
18983 }
18984 /**
18985  * @brief Keeps track of the most recent RG_SCH_CMN_MAX_ALLOC_TRACK
18986  * allocations to track. Adds this allocation to the ueUl's ulAllocLst.
18987  *
18988  *
18989  * @details
18990  *
18991  *     Function: rgSCHCmnUlUpdOutStndAlloc
18992  *     Purpose:  Recent Allocation shall be at First Pos'n.
18993  *               Remove the last node, update the fields
18994  *                with the new allocation and add at front.
18995  *
18996  *     Invoked by: Scheduler
18997  *
18998  *  @param[in]  RgSchCellCb *cell
18999  *  @param[in]  RgSchUeCb   *ue
19000  *  @param[in]  U32 alloc
19001  *  @return  Void
19002  **/
19003 #ifdef ANSI
19004 PUBLIC Void rgSCHCmnUlUpdOutStndAlloc
19005 (
19006 RgSchCellCb *cell,
19007 RgSchUeCb   *ue,
19008 U32 alloc
19009 )
19010 #else
19011 PUBLIC Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
19012 RgSchCellCb *cell;
19013 RgSchUeCb   *ue;
19014 U32 alloc;
19015 #endif
19016 {
19017    U32                 nonLcg0Alloc=0;
19018    TRC2(rgSCHCmnUlUpdOutStndAlloc);
19019
19020    /* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
19021    if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
19022    {
19023       ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs -= alloc;
19024    }
19025    else
19026    {
19027       nonLcg0Alloc = alloc - ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
19028       ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = 0;
19029    }
19030
19031    if (nonLcg0Alloc >= ue->ul.nonLcg0Bs)
19032    {
19033       ue->ul.nonLcg0Bs  = 0;
19034    }
19035    else
19036    {
19037       ue->ul.nonLcg0Bs  -= nonLcg0Alloc;
19038    }
19039    /* Cap effBsr with effAmbr and append lcg0 bs.
19040     * effAmbr limit applies only to lcg1,2,3 non GBR LCG's*/
19041    /* better be handled in individual scheduler */
19042    ue->ul.effBsr = ue->ul.nonLcg0Bs +\
19043                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
19044 #ifdef RGR_V1
19045    if (ue->ul.effBsr == 0)
19046    {
19047       if (ue->bsrTmr.tmrEvnt != TMR_NONE)
19048       {
19049          rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
19050       }
19051       /* ccpu00133008 */
19052       if (FALSE == ue->isSrGrant)
19053       {
19054          if (ue->ul.bsrTmrCfg.isPrdBsrTmrPres)
19055          {
19056             /*
19057             rgSCHTmrStartTmr(cell, ue, RG_SCH_TMR_BSR,
19058                   ue->ul.bsrTmrCfg.prdBsrTmr);
19059             */
19060          }
19061       }
19062    }
19063 #endif
19064    /* Resetting UEs lower Cap */
19065    ue->ul.minReqBytes = 0;
19066
19067    RETVOID;
19068 }
19069
19070
19071 /**
19072  * @brief Returns the "Itbs" for a given UE.
19073  *
19074  * @details
19075  *
19076  *     Function: rgSCHCmnUlGetITbs
19077  *     Purpose:  This function returns the "Itbs" for a given UE.
19078  *
19079  *     Invoked by: Scheduler
19080  *
19081  *  @param[in]  RgSchUeCb        *ue
19082  *  @return     U8
19083  **/
19084 #ifdef ANSI
19085 PUBLIC U8 rgSCHCmnUlGetITbs
19086 (
19087 RgSchCellCb      *cell,
19088 RgSchUeCb        *ue,
19089 Bool             isEcp
19090 )
19091 #else
19092 PUBLIC U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
19093 RgSchCellCb      *cell;
19094 RgSchUeCb        *ue;
19095 Bool             isEcp;
19096 #endif
19097 {
19098    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
19099    /* CQI will be capped to maxUlCqi for 16qam UEs */
19100    CmLteUeCategory  ueCtgy = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
19101    U8            cqi;
19102 #ifdef UL_LA
19103    S32            iTbs;
19104    U8            maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi]; 
19105 #endif
19106
19107    TRC2(rgSCHCmnUlGetITbs);
19108
19109    /* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
19110 #ifdef TFU_UPGRADE
19111    if ( (ueCtgy != CM_LTE_UE_CAT_5) &&
19112         (ueUl->validUlCqi > ueUl->maxUlCqi)
19113       )
19114    {
19115       cqi = ueUl->maxUlCqi;
19116    }
19117    else
19118    {
19119       cqi = ueUl->validUlCqi;
19120    }
19121
19122 #ifdef UL_LA
19123    iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
19124
19125    RG_SCH_CHK_ITBS_RANGE(iTbs, maxiTbs); 
19126
19127    iTbs = RGSCH_MIN(iTbs,  ue->cell->thresholds.maxUlItbs);
19128
19129 #ifdef LTE_TDD
19130    /* This is a Temp fix, done for TENBPLUS-3898, ULSCH SDU corruption
19131       was seen when IMCS exceeds 20 on T2k TDD */
19132    if (iTbs > 19)
19133    {
19134       iTbs = 19;
19135    }
19136 #endif
19137    RETVALUE(iTbs);
19138 #endif 
19139 #else
19140    if ( (ueCtgy != CM_LTE_UE_CAT_5) && (ueUl->crntUlCqi[0] > ueUl->maxUlCqi ))
19141    {
19142       cqi = ueUl->maxUlCqi;
19143    }
19144    else
19145    {
19146       cqi = ueUl->crntUlCqi[0];
19147    }
19148 #endif
19149    RETVALUE(rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
19150 }
19151
19152 /**
19153  * @brief This function adds the UE to DLRbAllocInfo TX lst.
19154  *
19155  * @details
19156  *
19157  *     Function: rgSCHCmnDlRbInfoAddUeTx
19158  *     Purpose:  This function adds the UE to DLRbAllocInfo TX lst.
19159  *
19160  *     Invoked by: Common Scheduler
19161  *
19162  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19163  *  @param[in]  RgSchUeCb             *ue
19164  *  @param[in]  RgSchDlHqProcCb       *hqP
19165  *  @return  Void
19166  *
19167  **/
19168 #ifdef ANSI
19169 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx
19170 (
19171 RgSchCellCb        *cell,
19172 RgSchCmnDlRbAllocInfo *allocInfo,
19173 RgSchUeCb             *ue,
19174 RgSchDlHqProcCb       *hqP
19175 )
19176 #else
19177 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx(cell, allocInfo, ue, hqP)
19178 RgSchCellCb        *cell;
19179 RgSchCmnDlRbAllocInfo *allocInfo;
19180 RgSchUeCb             *ue;
19181 RgSchDlHqProcCb       *hqP;
19182 #endif
19183 {
19184    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
19185
19186    TRC2(rgSCHCmnDlRbInfoAddUeTx);
19187
19188    if (hqP->reqLnk.node == NULLP)
19189    {
19190       if (cellSch->dl.isDlFreqSel)
19191       {
19192          cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19193            &allocInfo->dedAlloc.txHqPLst, hqP);
19194       }
19195       else
19196       {
19197          {
19198             cmLListAdd2Tail(&allocInfo->dedAlloc.txHqPLst, &hqP->reqLnk);
19199          }
19200          hqP->reqLnk.node = (PTR)hqP;
19201       }
19202    }
19203    RETVOID;
19204 }
19205
19206 /**
19207  * @brief This function adds the UE to DLRbAllocInfo RETX lst.
19208  *
19209  * @details
19210  *
19211  *     Function: rgSCHCmnDlRbInfoAddUeRetx
19212  *     Purpose:  This function adds the UE to DLRbAllocInfo RETX lst.
19213  *
19214  *     Invoked by: Common Scheduler
19215  *
19216  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19217  *  @param[in]  RgSchUeCb             *ue
19218  *  @param[in]  RgSchDlHqProcCb       *hqP
19219  *  @return  Void
19220  *
19221  **/
19222 #ifdef ANSI
19223 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx
19224 (
19225 RgSchCellCb        *cell,
19226 RgSchCmnDlRbAllocInfo *allocInfo,
19227 RgSchUeCb             *ue,
19228 RgSchDlHqProcCb       *hqP
19229 )
19230 #else
19231 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx(cell, allocInfo, ue, hqP)
19232 RgSchCellCb        *cell;
19233 RgSchCmnDlRbAllocInfo *allocInfo;
19234 RgSchUeCb             *ue;
19235 RgSchDlHqProcCb       *hqP;
19236 #endif
19237 {
19238    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
19239
19240    TRC2(rgSCHCmnDlRbInfoAddUeRetx);
19241
19242    if (cellSch->dl.isDlFreqSel)
19243    {
19244       cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19245         &allocInfo->dedAlloc.retxHqPLst, hqP);
19246    }
19247    else
19248    {
19249       /* checking UE's presence in this lst is unnecessary */
19250       cmLListAdd2Tail(&allocInfo->dedAlloc.retxHqPLst, &hqP->reqLnk);
19251       hqP->reqLnk.node = (PTR)hqP;
19252    }
19253    RETVOID;
19254 }
19255
19256 /**
19257  * @brief This function adds the UE to DLRbAllocInfo TX-RETX lst.
19258  *
19259  * @details
19260  *
19261  *     Function: rgSCHCmnDlRbInfoAddUeRetxTx
19262  *     Purpose:  This adds the UE to DLRbAllocInfo TX-RETX lst.
19263  *
19264  *     Invoked by: Common Scheduler
19265  *
19266  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19267  *  @param[in]  RgSchUeCb             *ue
19268  *  @param[in]  RgSchDlHqProcCb       *hqP
19269  *  @return  Void
19270  *
19271  **/
19272 #ifdef ANSI
19273 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx
19274 (
19275 RgSchCellCb        *cell,
19276 RgSchCmnDlRbAllocInfo *allocInfo,
19277 RgSchUeCb             *ue,
19278 RgSchDlHqProcCb       *hqP
19279 )
19280 #else
19281 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx(allocInfo, ue, hqP)
19282 RgSchCellCb        *cell;
19283 RgSchCmnDlRbAllocInfo *allocInfo;
19284 RgSchUeCb             *ue;
19285 RgSchDlHqProcCb       *hqP;
19286 #endif
19287 {
19288    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
19289
19290    TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
19291
19292    if (cellSch->dl.isDlFreqSel)
19293    {
19294       cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19295         &allocInfo->dedAlloc.txRetxHqPLst, hqP);
19296    }
19297    else
19298    {
19299       cmLListAdd2Tail(&allocInfo->dedAlloc.txRetxHqPLst, &hqP->reqLnk);
19300       hqP->reqLnk.node = (PTR)hqP;
19301    }
19302    RETVOID;
19303 }
19304
19305 /**
19306  * @brief This function adds the UE to DLRbAllocInfo NonSchdRetxLst.
19307  *
19308  * @details
19309  *
19310  *     Function: rgSCHCmnDlAdd2NonSchdRetxLst 
19311  *     Purpose:  During RB estimation for RETX, if allocation fails
19312  *               then appending it to NonSchdRetxLst, the further
19313  *               action is taken as part of Finalization in
19314  *               respective schedulers.
19315  *
19316  *     Invoked by: Common Scheduler
19317  *
19318  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19319  *  @param[in]  RgSchUeCb             *ue
19320  *  @param[in]  RgSchDlHqProcCb       *hqP
19321  *  @return  Void
19322  *
19323  **/
19324 #ifdef ANSI
19325 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst 
19326 (
19327 RgSchCmnDlRbAllocInfo *allocInfo,
19328 RgSchUeCb             *ue,
19329 RgSchDlHqProcCb       *hqP
19330 )
19331 #else
19332 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst(allocInfo, ue, hqP)
19333 RgSchCmnDlRbAllocInfo *allocInfo;
19334 RgSchUeCb             *ue;
19335 RgSchDlHqProcCb       *hqP;
19336 #endif
19337 {
19338    CmLList         *schdLnkNode;
19339
19340    TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
19341
19342 #ifdef LTEMAC_SPS
19343    if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) && 
19344          (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP)))
19345    {
19346       RETVOID;
19347    }
19348 #endif
19349
19350    schdLnkNode = &hqP->schdLstLnk;
19351    RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
19352    cmLListAdd2Tail(&allocInfo->dedAlloc.nonSchdRetxHqPLst, schdLnkNode);
19353
19354    RETVOID;
19355 }
19356
19357
19358
19359 /**
19360  * @brief This function adds the UE to DLRbAllocInfo NonSchdTxRetxLst.
19361  *
19362  * @details
19363  *
19364  *     Function: rgSCHCmnDlAdd2NonSchdTxRetxLst 
19365  *     Purpose:  During RB estimation for TXRETX, if allocation fails
19366  *               then appending it to NonSchdTxRetxLst, the further
19367  *               action is taken as part of Finalization in
19368  *               respective schedulers.
19369  *
19370  *     Invoked by: Common Scheduler
19371  *
19372  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19373  *  @param[in]  RgSchUeCb             *ue
19374  *  @param[in]  RgSchDlHqProcCb       *hqP
19375  *  @return  Void
19376  *
19377  **/
19378 #ifdef LTE_TDD
19379 /**
19380  * @brief This function handles the initialisation of DL HARQ/ACK feedback
19381  *        timing information for eaach DL subframe.
19382  *
19383  * @details
19384  *
19385  *     Function: rgSCHCmnDlANFdbkInit
19386  *     Purpose:  Each DL subframe stores the sfn and subframe
19387  *               information of UL subframe in which it expects
19388  *               HARQ ACK/NACK feedback for this subframe.It
19389  *               generates the information based on Downlink
19390  *               Association Set Index table.
19391  *
19392  *     Invoked by: Scheduler
19393  *
19394  *  @param[in]  RgSchCellCb*     cell
19395  *  @return     S16
19396  *
19397  **/
19398 #ifdef ANSI
19399 PRIVATE S16 rgSCHCmnDlANFdbkInit
19400 (
19401 RgSchCellCb                *cell
19402 )
19403 #else
19404 PRIVATE S16 rgSCHCmnDlANFdbkInit(cell)
19405 RgSchCellCb                *cell;
19406 #endif
19407 {
19408  U8                   sfCount;
19409  U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19410  U8                   maxDlSubfrms = cell->numDlSubfrms;
19411  U8                   sfNum;
19412  U8                   idx;
19413  U8                   dlIdx;
19414  U8                   calcSfnOffset;
19415  S8                   calcSfNum;
19416  U8                   ulSfCnt =0;
19417  RgSchTddSubfrmInfo   ulSubfrmInfo;
19418  U8                   maxUlSubfrms;
19419
19420    TRC2(rgSCHCmnDlANFdbkInit);
19421
19422    ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19423    maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19424
19425    /* Generate HARQ ACK/NACK feedback information for each DL sf in a radio frame
19426     * Calculate this information based on DL Association set Index table */
19427    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19428    {
19429       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19430             RG_SCH_TDD_UL_SUBFRAME)
19431       {
19432          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19433       }
19434       ulSfCnt++;
19435
19436       for(idx=0; idx < rgSchTddDlAscSetIdxKTbl[ulDlCfgIdx][sfNum].\
19437             numFdbkSubfrms; idx++)
19438       {
19439          calcSfNum = sfNum - rgSchTddDlAscSetIdxKTbl[ulDlCfgIdx][sfNum].\
19440                      subfrmNum[idx];
19441          if(calcSfNum < 0)
19442          {
19443             calcSfnOffset = RGSCH_CEIL(-calcSfNum, RGSCH_NUM_SUB_FRAMES);
19444          }
19445          else
19446          {
19447             calcSfnOffset = 0;
19448          }
19449
19450          calcSfNum = ((RGSCH_NUM_SUB_FRAMES * calcSfnOffset) + calcSfNum)\
19451                      % RGSCH_NUM_SUB_FRAMES;
19452
19453          if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19454          {
19455             dlIdx = calcSfNum;
19456          }
19457          else if((ulSubfrmInfo.switchPoints == 2) && (calcSfNum <= \
19458                   RG_SCH_CMN_SPL_SUBFRM_6))
19459          {
19460             dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19461          }
19462          else
19463          {
19464             dlIdx = calcSfNum - maxUlSubfrms;
19465          }
19466
19467          cell->subFrms[dlIdx]->dlFdbkInfo.subframe = sfNum;
19468          cell->subFrms[dlIdx]->dlFdbkInfo.sfnOffset = calcSfnOffset;
19469          cell->subFrms[dlIdx]->dlFdbkInfo.m = idx;
19470       }
19471       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19472    }
19473
19474    /* DL subframes in the subsequent radio frames are initialized
19475     * with the previous radio frames  */
19476    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms; dlIdx < maxDlSubfrms;\
19477          dlIdx++)
19478    {
19479       sfNum = dlIdx - rgSchTddNumDlSubfrmTbl[ulDlCfgIdx]\
19480               [RGSCH_NUM_SUB_FRAMES-1];
19481       cell->subFrms[dlIdx]->dlFdbkInfo.subframe = \
19482                                                   cell->subFrms[sfNum]->dlFdbkInfo.subframe;
19483       cell->subFrms[dlIdx]->dlFdbkInfo.sfnOffset = \
19484                                                    cell->subFrms[sfNum]->dlFdbkInfo.sfnOffset;
19485       cell->subFrms[dlIdx]->dlFdbkInfo.m = cell->subFrms[sfNum]->dlFdbkInfo.m;
19486    }
19487    RETVALUE(ROK);
19488 }
19489
19490 /**
19491  * @brief This function handles the initialization of uplink association
19492  *        set information for each DL subframe.
19493  *
19494  *
19495  * @details
19496  *
19497  *     Function: rgSCHCmnDlKdashUlAscInit
19498  *     Purpose:  Each DL sf stores the sfn and sf information of UL sf
19499  *               in which it expects HQ ACK/NACK trans. It generates the information
19500  *               based on k` in UL association set index table.
19501  *
19502  *     Invoked by: Scheduler
19503  *
19504  *  @param[in]  RgSchCellCb*     cell
19505  *  @return     S16
19506  *
19507  **/
19508 #ifdef ANSI
19509 PRIVATE S16 rgSCHCmnDlKdashUlAscInit
19510 (
19511 RgSchCellCb                *cell
19512 )
19513 #else
19514 PRIVATE S16 rgSCHCmnDlKdashUlAscInit(cell)
19515 RgSchCellCb                *cell;
19516 #endif
19517 {
19518  U8                   sfCount;
19519  U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19520  U8                   maxDlSubfrms = cell->numDlSubfrms;
19521  U8                   sfNum;
19522  U8                   dlIdx;
19523  S8                   calcSfnOffset;
19524  S8                   calcSfNum;
19525  U8                   ulSfCnt =0;
19526  RgSchTddSubfrmInfo   ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19527  U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19528                                      [RGSCH_NUM_SUB_FRAMES-1];
19529  U8                   dlPres = 0;
19530
19531    TRC2(rgSCHCmnDlKdashUlAscInit);
19532
19533    /* Generate ACK/NACK offset information for each DL subframe in a radio frame
19534     * Calculate this information based on K` in UL Association Set table */
19535    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19536    {
19537       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19538             RG_SCH_TDD_UL_SUBFRAME)
19539       {
19540          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19541       }
19542       ulSfCnt++;
19543
19544       calcSfNum = (sfNum - rgSchTddUlAscIdxKDashTbl[ulDlCfgIdx-1][sfNum] + \
19545             RGSCH_NUM_SUB_FRAMES) % RGSCH_NUM_SUB_FRAMES;
19546       calcSfnOffset = sfNum - rgSchTddUlAscIdxKDashTbl[ulDlCfgIdx-1][sfNum];
19547       if(calcSfnOffset < 0)
19548       {
19549          calcSfnOffset = RGSCH_CEIL(-calcSfnOffset, RGSCH_NUM_SUB_FRAMES);
19550       }
19551       else
19552       {
19553          calcSfnOffset = 0;
19554       }
19555
19556       if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19557       {
19558          dlIdx = calcSfNum;
19559       }
19560       else if((ulSubfrmInfo.switchPoints == 2) &&
19561             (calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_6))
19562       {
19563          dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19564       }
19565       else
19566       {
19567          dlIdx = calcSfNum - maxUlSubfrms;
19568       }
19569
19570       cell->subFrms[dlIdx]->ulAscInfo.subframe = sfNum;
19571       cell->subFrms[dlIdx]->ulAscInfo.sfnOffset = calcSfnOffset;
19572
19573       /* set dlIdx for which ulAscInfo is updated */
19574       dlPres = dlPres | (1 << dlIdx);
19575       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19576    }
19577
19578    /* Set Invalid information for which ulAscInfo is not present */
19579    for (sfCount = 0;
19580          sfCount < rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19581          sfCount++)
19582    {
19583       /* If dlPres is 0, ulAscInfo is not present in that DL index */
19584       if(! ((dlPres >> sfCount)&0x01))
19585       {
19586          cell->subFrms[sfCount]->ulAscInfo.sfnOffset =
19587             RGSCH_INVALID_INFO;
19588          cell->subFrms[sfCount]->ulAscInfo.subframe =
19589             RGSCH_INVALID_INFO;
19590       }
19591    }
19592
19593    /* DL subframes in the subsequent radio frames are initialized
19594     * with the previous radio frames  */
19595    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms; dlIdx < maxDlSubfrms;
19596          dlIdx++)
19597    {
19598       sfNum = dlIdx - \
19599               rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19600       cell->subFrms[dlIdx]->ulAscInfo.subframe =
19601          cell->subFrms[sfNum]->ulAscInfo.subframe;
19602       cell->subFrms[dlIdx]->ulAscInfo.sfnOffset =
19603          cell->subFrms[sfNum]->ulAscInfo.sfnOffset;
19604    }
19605    RETVALUE(ROK);
19606 }
19607
19608
19609 /**
19610  * @brief This function initialises the 'Np' value for 'p'
19611  *
19612  * @details
19613  *
19614  *     Function: rgSCHCmnDlNpValInit
19615  *     Purpose:  To initialise the 'Np' value for each 'p'. It is used
19616  *               to find the mapping between nCCE and 'p' and used in
19617  *               HARQ ACK/NACK reception.
19618  *
19619  *     Invoked by: Scheduler
19620  *
19621  *  @param[in]  RgSchCellCb*     cell
19622  *  @return     S16
19623  *
19624  **/
19625 #ifdef ANSI
19626 PRIVATE S16 rgSCHCmnDlNpValInit
19627 (
19628 RgSchCellCb                *cell
19629 )
19630 #else
19631 PRIVATE S16 rgSCHCmnDlNpValInit(cell)
19632 RgSchCellCb                *cell;
19633 #endif
19634 {
19635    U8    idx;
19636    U16   np;
19637    TRC2(rgSCHCmnDlNpValInit);
19638
19639    /* Always Np is 0 for p=0 */
19640    cell->rgSchTddNpValTbl[0] = 0;
19641
19642    for(idx=1; idx < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; idx++)
19643    {
19644       np = cell->bwCfg.dlTotalBw * (idx * RG_SCH_CMN_NUM_SUBCAR - 4);
19645       cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
19646    }
19647
19648    RETVALUE(ROK);
19649 }
19650
19651 /**
19652  * @brief This function handles the creation of RACH preamble
19653  *        list to queue the preambles and process at the scheduled
19654  *        time.
19655  *
19656  * @details
19657  *
19658  *     Function: rgSCHCmnDlCreateRachPrmLst
19659  *     Purpose:  To create RACH preamble list based on RA window size.
19660  *               It is used to queue the preambles and process it at the
19661  *               scheduled time.
19662  *
19663  *     Invoked by: Scheduler
19664  *
19665  *  @param[in]  RgSchCellCb*     cell
19666  *  @return     S16
19667  *
19668  **/
19669 #ifdef ANSI
19670 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst
19671 (
19672 RgSchCellCb                *cell
19673 )
19674 #else
19675 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst(cell)
19676 RgSchCellCb                *cell;
19677 #endif
19678 {
19679  U8       raArrSz;
19680  S16       ret;
19681  U8       lstSize;
19682
19683    TRC2(rgSCHCmnDlCreateRachPrmLst);
19684
19685    RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
19686
19687    lstSize = raArrSz * RGSCH_MAX_RA_RNTI_PER_SUBFRM * RGSCH_NUM_SUB_FRAMES;
19688
19689    cell->raInfo.maxRaSize = raArrSz;
19690    ret = rgSCHUtlAllocSBuf(cell->instIdx,
19691          (Data **)(&cell->raInfo.raReqLst), (Size)(lstSize * sizeof(CmLListCp)));
19692    if (ret != ROK)
19693    {
19694       RETVALUE(ret);
19695    }
19696
19697    cell->raInfo.lstSize = lstSize;
19698
19699    RETVALUE(ROK);
19700 }
19701
19702
19703 /**
19704  * @brief This function handles the initialization of RACH Response
19705  *        information at each DL subframe.
19706  *
19707  * @details
19708  *
19709  *     Function: rgSCHCmnDlRachInfoInit
19710  *     Purpose:  Each DL subframe stores the sfn and subframe information of
19711  *               possible RACH response allowed for UL subframes. It generates
19712  *               the information based on PRACH configuration.
19713  *
19714  *     Invoked by: Scheduler
19715  *
19716  *  @param[in]  RgSchCellCb*     cell
19717  *  @return     S16
19718  *
19719  **/
19720 #ifdef ANSI
19721 PRIVATE S16 rgSCHCmnDlRachInfoInit
19722 (
19723 RgSchCellCb                *cell
19724 )
19725 #else
19726 PRIVATE S16 rgSCHCmnDlRachInfoInit(cell)
19727 RgSchCellCb                *cell;
19728 #endif
19729 {
19730    U8                   sfCount;
19731    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19732    U8                   sfNum;
19733    U8                   ulSfCnt =0;
19734    U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19735                                        [RGSCH_NUM_SUB_FRAMES-1];
19736    U8                   raArrSz;
19737    RgSchTddRachRspLst   rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
19738    U8                   startWin;
19739    U8                   endWin;
19740    U8                   sfnIdx;
19741    U8                   subfrmIdx;
19742    U8                   endSubfrmIdx;
19743    U8                   startSubfrmIdx;
19744    S16                   ret;
19745    RgSchTddRachDelInfo  *delInfo;
19746    S8                   sfnOffset;
19747    U8                   numSubfrms;
19748
19749    TRC2(rgSCHCmnDlRachInfoInit);
19750
19751    cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
19752
19753    RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
19754
19755    /* Include Special subframes */
19756    maxUlSubfrms = maxUlSubfrms + \
19757                   rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx].switchPoints;
19758    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19759    {
19760       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] ==
19761             RG_SCH_TDD_DL_SUBFRAME)
19762       {
19763          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19764       }
19765       ulSfCnt++;
19766
19767       startWin = (sfNum + RG_SCH_CMN_RARSP_WAIT_PRD + \
19768             ((RgSchCmnCell *)cell->sc.sch)->dl.numRaSubFrms);
19769       endWin = (startWin + cell->rachCfg.raWinSize - 1);
19770       startSubfrmIdx =
19771          rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][startWin%RGSCH_NUM_SUB_FRAMES];
19772       /* Find the next DL subframe starting from Subframe 0 */
19773       if((startSubfrmIdx % RGSCH_NUM_SUB_FRAMES) == 0)
19774       {
19775          startWin = RGSCH_CEIL(startWin, RGSCH_NUM_SUB_FRAMES);
19776          startWin = startWin * RGSCH_NUM_SUB_FRAMES;
19777       }
19778
19779       endSubfrmIdx =
19780          rgSchTddLowDlSubfrmIdxTbl[ulDlCfgIdx][endWin%RGSCH_NUM_SUB_FRAMES];
19781       endWin = (endWin/RGSCH_NUM_SUB_FRAMES) * RGSCH_NUM_SUB_FRAMES \
19782                + endSubfrmIdx;
19783       if(startWin > endWin)
19784       {
19785          continue;
19786       }
19787       /* Find all the possible RACH Response transmission
19788        * time within the RA window size */
19789       startSubfrmIdx = startWin%RGSCH_NUM_SUB_FRAMES;
19790       for(sfnIdx = startWin/RGSCH_NUM_SUB_FRAMES;
19791             sfnIdx <= endWin/RGSCH_NUM_SUB_FRAMES; sfnIdx++)
19792       {
19793          if(sfnIdx == endWin/RGSCH_NUM_SUB_FRAMES)
19794          {
19795             endSubfrmIdx = endWin%RGSCH_NUM_SUB_FRAMES;
19796          }
19797          else
19798          {
19799             endSubfrmIdx = RGSCH_NUM_SUB_FRAMES-1;
19800          }
19801
19802          /* Find all the possible RACH Response transmission
19803           * time within radio frame */
19804          for(subfrmIdx = startSubfrmIdx;
19805                subfrmIdx <= endSubfrmIdx; subfrmIdx++)
19806          {
19807             if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][subfrmIdx] ==
19808                   RG_SCH_TDD_UL_SUBFRAME)
19809             {
19810                continue;
19811             }
19812             subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][subfrmIdx];
19813             /* Find the next DL subframe starting from Subframe 0 */
19814             if(subfrmIdx == RGSCH_NUM_SUB_FRAMES)
19815             {
19816                break;
19817             }
19818             RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rachRspLst[sfnIdx], subfrmIdx);
19819             numSubfrms =
19820                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
19821             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].sfnOffset = sfnIdx;
19822             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].subframe[numSubfrms]
19823                = sfNum;
19824             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms++;
19825          }
19826          startSubfrmIdx = RG_SCH_CMN_SUBFRM_0;
19827       }
19828       /* Update the subframes to be deleted at this subframe */
19829       /* Get the subframe after the end of RA window size */
19830       endWin++;
19831       endSubfrmIdx++;
19832       sfnOffset = endWin/RGSCH_NUM_SUB_FRAMES;
19833       if(sfnOffset < 0)
19834       {
19835          sfnOffset += raArrSz;
19836       }
19837       sfnIdx = (endWin/RGSCH_NUM_SUB_FRAMES) % raArrSz;
19838
19839       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx],endSubfrmIdx-1);
19840       if((endSubfrmIdx == RGSCH_NUM_SUB_FRAMES) ||
19841             (rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][endSubfrmIdx] ==
19842              RGSCH_NUM_SUB_FRAMES))
19843       {
19844          subfrmIdx =
19845             rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][RG_SCH_CMN_SUBFRM_0];
19846       }
19847       else
19848       {
19849          subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][endSubfrmIdx];
19850       }
19851
19852       delInfo = &rachRspLst[sfnIdx][subfrmIdx].delInfo;
19853       delInfo->sfnOffset = sfnOffset;
19854       delInfo->subframe[delInfo->numSubfrms] = sfNum;
19855       delInfo->numSubfrms++;
19856
19857       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19858    }
19859
19860    ret = rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz);
19861    if (ret != ROK)
19862    {
19863       RETVALUE(ret);
19864    }
19865
19866    RETVALUE(ROK);
19867 }
19868
19869 /**
19870  * @brief This function handles the initialization of PHICH information
19871  *        for each DL subframe based on PHICH table.
19872  *
19873  * @details
19874  *
19875  *     Function: rgSCHCmnDlPhichOffsetInit
19876  *     Purpose:  Each DL subf stores the sfn and subf information of UL subframe
19877  *               for which it trnsmts PHICH in this subframe. It generates the information
19878  *               based on PHICH table.
19879  *
19880  *     Invoked by: Scheduler
19881  *
19882  *  @param[in]  RgSchCellCb*     cell
19883  *  @return     S16
19884  *
19885  **/
19886 #ifdef ANSI
19887 PRIVATE S16 rgSCHCmnDlPhichOffsetInit
19888 (
19889 RgSchCellCb                *cell
19890 )
19891 #else
19892 PRIVATE S16 rgSCHCmnDlPhichOffsetInit(cell)
19893 RgSchCellCb                *cell;
19894 #endif
19895 {
19896    U8                   sfCount;
19897    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19898    U8                   maxDlSubfrms = cell->numDlSubfrms;
19899    U8                   sfNum;
19900    U8                   dlIdx;
19901    U8                   dlPres = 0;
19902    U8                   calcSfnOffset;
19903    U8                   calcSfNum;
19904    U8                   ulSfCnt =0;
19905    RgSchTddSubfrmInfo   ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19906    U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19907                                        [RGSCH_NUM_SUB_FRAMES-1];
19908
19909    TRC2(rgSCHCmnDlPhichOffsetInit);
19910
19911    /* Generate PHICH offset information for each DL subframe in a radio frame
19912     * Calculate this information based on K in PHICH table */
19913    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19914    {
19915       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19916             RG_SCH_TDD_UL_SUBFRAME)
19917       {
19918          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19919       }
19920       ulSfCnt++;
19921
19922       calcSfNum = (rgSchTddKPhichTbl[ulDlCfgIdx][sfNum] + sfNum) % \
19923                   RGSCH_NUM_SUB_FRAMES;
19924       calcSfnOffset = (rgSchTddKPhichTbl[ulDlCfgIdx][sfNum] + sfNum) / \
19925                       RGSCH_NUM_SUB_FRAMES;
19926
19927       if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19928       {
19929          dlIdx = calcSfNum;
19930       }
19931       else if((ulSubfrmInfo.switchPoints == 2) &&
19932             (calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_6))
19933       {
19934          dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19935       }
19936       else
19937       {
19938          dlIdx = calcSfNum - maxUlSubfrms;
19939       }
19940
19941       cell->subFrms[dlIdx]->phichOffInfo.subframe = sfNum;
19942       cell->subFrms[dlIdx]->phichOffInfo.numSubfrms = 1;
19943
19944       cell->subFrms[dlIdx]->phichOffInfo.sfnOffset = calcSfnOffset;
19945
19946       /* set dlIdx for which phich offset is updated */
19947       dlPres = dlPres | (1 << dlIdx);
19948       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19949    }
19950
19951    /* Set Invalid information for which phich offset is not present */
19952    for (sfCount = 0;
19953          sfCount < rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19954          sfCount++)
19955    {
19956       /* If dlPres is 0, phich offset is not present in that DL index */
19957       if(! ((dlPres >> sfCount)&0x01))
19958       {
19959          cell->subFrms[sfCount]->phichOffInfo.sfnOffset =
19960             RGSCH_INVALID_INFO;
19961          cell->subFrms[sfCount]->phichOffInfo.subframe =
19962             RGSCH_INVALID_INFO;
19963          cell->subFrms[sfCount]->phichOffInfo.numSubfrms = 0;
19964       }
19965    }
19966
19967    /* DL subframes in the subsequent radio frames are
19968     * initialized with the previous radio frames  */
19969    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms;
19970          dlIdx < maxDlSubfrms; dlIdx++)
19971    {
19972       sfNum = dlIdx - \
19973               rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19974
19975       cell->subFrms[dlIdx]->phichOffInfo.subframe =
19976          cell->subFrms[sfNum]->phichOffInfo.subframe;
19977
19978       cell->subFrms[dlIdx]->phichOffInfo.sfnOffset =
19979          cell->subFrms[sfNum]->phichOffInfo.sfnOffset;
19980    }
19981    RETVALUE(ROK);
19982 }
19983
19984
19985 /**
19986  * @brief Updation of Sch vars per TTI.
19987  *
19988  * @details
19989  *
19990  *     Function: rgSCHCmnUpdVars
19991  *     Purpose:  Updation of Sch vars per TTI.
19992  *
19993  *  @param[in]  RgSchCellCb *cell
19994  *  @return  Void
19995  *
19996  **/
19997 #ifdef ANSI
19998 PUBLIC Void rgSCHCmnUpdVars
19999 (
20000 RgSchCellCb *cell
20001 )
20002 #else
20003 PUBLIC Void rgSCHCmnUpdVars(cell)
20004 RgSchCellCb *cell;
20005 #endif
20006 {
20007    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
20008    CmLteTimingInfo   timeInfo;
20009    U8                idx;
20010    U8                ulSubframe;
20011    U8                ulDlCfgIdx = cell->ulDlCfgIdx;
20012    U8                msg3Subfrm;
20013    U8                Mval;
20014    TRC2(rgSCHCmnUpdVars);
20015  
20016    /* ccpu00132654-ADD- Initializing all the indices in every subframe*/ 
20017    rgSCHCmnInitVars(cell);
20018
20019    idx = (cell->crntTime.subframe + TFU_ULCNTRL_DLDELTA) % RGSCH_NUM_SUB_FRAMES;
20020    /* Calculate the UL scheduling subframe idx based on the 
20021       Pusch k table */
20022    if(rgSchTddPuschTxKTbl[ulDlCfgIdx][idx] != 0)
20023    {
20024       /* PUSCH transmission is based on offset from DL
20025        * PDCCH scheduling */
20026       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo, TFU_ULCNTRL_DLDELTA); 
20027       ulSubframe = rgSchTddPuschTxKTbl[ulDlCfgIdx][timeInfo.subframe];
20028       /* Add the DCI-0 to PUSCH time to get the time of UL subframe */
20029       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, ulSubframe);
20030 #ifdef LTEMAC_SPS
20031       cellUl->schdTti = timeInfo.sfn * 10 + timeInfo.subframe;
20032 #endif
20033       /* Fetch the corresponding  UL subframe Idx in UL sf array */ 
20034       cellUl->schdIdx = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20035       /* Fetch the corresponding  UL Harq Proc ID */ 
20036       cellUl->schdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
20037       cellUl->schdTime = timeInfo;
20038    }
20039    Mval = rgSchTddPhichMValTbl[ulDlCfgIdx][idx]; 
20040    if(Mval)
20041    {
20042       /* Fetch the tx time for DL HIDCI-0 */
20043       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo, TFU_ULCNTRL_DLDELTA);
20044       /* Fetch the corresponding n-k tx time of PUSCH */
20045       cellUl->hqFdbkIdx[0] = rgSCHCmnGetPhichUlSfIdx(&timeInfo, cell);
20046       /* Retx will happen according to the Pusch k table */
20047       cellUl->reTxIdx[0] = cellUl->schdIdx;
20048       
20049       if(ulDlCfgIdx == 0) 
20050       {
20051          /* Calculate the ReTxIdx corresponding to hqFdbkIdx[0] */
20052          cellUl->reTxIdx[0] = rgSchUtlCfg0ReTxIdx(cell,timeInfo,
20053                                                 cellUl->hqFdbkIdx[0]);
20054          if(Mval == 2)
20055          {
20056             /* At Idx 1 store the UL SF adjacent(left) to the UL SF
20057                given at idx 0 */  
20058             cellUl->hqFdbkIdx[1] = (cellUl->hqFdbkIdx[0]-1 + 
20059                                    cellUl->numUlSubfrms) % cellUl->numUlSubfrms;
20060             /* Calculate the ReTxIdx corresponding to hqFdbkIdx[1] */
20061             cellUl->reTxIdx[1] = rgSchUtlCfg0ReTxIdx(cell,timeInfo,
20062                                                 cellUl->hqFdbkIdx[1]);
20063          }                               
20064       }
20065    }
20066
20067    idx = (cell->crntTime.subframe + TFU_RECPREQ_DLDELTA) % RGSCH_NUM_SUB_FRAMES;
20068    if (rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][idx] == RG_SCH_TDD_UL_SUBFRAME)
20069    {
20070       RGSCHCMNADDTOCRNTTIME(cell->crntTime, timeInfo, TFU_RECPREQ_DLDELTA)
20071       cellUl->rcpReqIdx   = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20072    }
20073    idx = (cell->crntTime.subframe+RG_SCH_CMN_DL_DELTA) % RGSCH_NUM_SUB_FRAMES;
20074    
20075    /*[ccpu00134666]-MOD-Modify the check to schedule the RAR in
20076      special subframe */                       
20077    if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][idx] != RG_SCH_TDD_UL_SUBFRAME)
20078    {
20079       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
20080       msg3Subfrm = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
20081       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, msg3Subfrm);
20082       cellUl->msg3SchdIdx     = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20083       cellUl->msg3SchdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
20084    }
20085 #ifdef LTEMAC_SPS
20086    if(!rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][idx])
20087    {
20088       cellUl->spsUlRsrvIdx = RGSCH_INVALID_INFO;
20089    }
20090    else
20091    {
20092       /* introduce some reuse with above code? */
20093       U8    offst;
20094       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
20095       //offst = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
20096       offst = rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][timeInfo.subframe];
20097       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, offst);
20098       cellUl->spsUlRsrvIdx     = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20099       /* The harq proc continues to be accessed and used the same delta before
20100        * actual data occurance, and hence use the same idx */
20101       cellUl->spsUlRsrvHqProcIdx = cellUl->schdHqProcIdx;
20102    }
20103 #endif
20104
20105    /* RACHO: update cmn sched specific RACH variables,
20106     * mainly the prachMaskIndex */
20107    rgSCHCmnUpdRachParam(cell);
20108
20109    RETVOID;
20110 }
20111
20112 /**
20113  * @brief To get 'p' value from nCCE.
20114  *
20115  * @details
20116  *
20117  *     Function: rgSCHCmnGetPValFrmCCE
20118  *     Purpose:  Gets 'p' value for HARQ ACK/NACK reception from CCE.
20119  *
20120  *  @param[in]  RgSchCellCb   *cell
20121  *  @param[in]  U8            cce
20122  *  @return U8
20123  *
20124  **/
20125 #ifdef ANSI
20126 PUBLIC U8  rgSCHCmnGetPValFrmCCE
20127 (
20128 RgSchCellCb *cell,
20129 U8          cce
20130 )
20131 #else
20132 PUBLIC U8  rgSCHCmnGetPValFrmCCE(cell, cce)
20133 RgSchCellCb *cell;
20134 U8          cce;
20135 #endif
20136 {
20137    U8 i;
20138    TRC2(rgSCHCmnGetPValFrmCCE);
20139
20140    for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
20141    {
20142       if(cce < cell->rgSchTddNpValTbl[i])
20143       {
20144          RETVALUE(i-1);
20145       }
20146    }
20147    RETVALUE(0);
20148 }
20149 #endif
20150
20151 /***********************************************************
20152  *
20153  *     Func : rgSCHCmnUlAdapRetx
20154  *
20155  *     Desc : Adaptive retransmission for an allocation.
20156  *
20157  *     Ret  :
20158  *
20159  *     Notes:
20160  *
20161  *     File :
20162  *
20163  **********************************************************/
20164 #ifdef ANSI
20165 PRIVATE Void rgSCHCmnUlAdapRetx
20166 (
20167 RgSchUlAlloc    *alloc,
20168 RgSchUlHqProcCb *proc
20169 )
20170 #else
20171 PRIVATE Void rgSCHCmnUlAdapRetx(alloc, proc)
20172 RgSchUlAlloc    *alloc;
20173 RgSchUlHqProcCb *proc;
20174 #endif
20175 {
20176    TRC2(rgSCHCmnUlAdapRetx);
20177
20178    rgSCHUhmRetx(proc, alloc);
20179 #ifndef RG_5GTF
20180    if (proc->rvIdx != 0)
20181    {
20182       alloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl[proc->rvIdx];
20183    }
20184    else
20185 #endif
20186    {
20187       alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
20188    }
20189    RETVOID;
20190 }
20191
20192 /**
20193  * @brief Scheduler invocation per TTI.
20194  *
20195  * @details
20196  *
20197  *     Function: rgSCHCmnHdlUlInactUes
20198  *     Purpose:
20199  *
20200  *     Invoked by: Common Scheduler
20201  *
20202  *  @param[in]  RgSchCellCb *cell
20203  *  @return  Void
20204  **/
20205 #ifdef ANSI
20206 PRIVATE Void rgSCHCmnHdlUlInactUes
20207 (
20208 RgSchCellCb  *cell
20209 )
20210 #else
20211 PRIVATE Void rgSCHCmnHdlUlInactUes(cell)
20212 RgSchCellCb  *cell;
20213 #endif
20214 {
20215    RgSchCmnCell  *cellSch  = RG_SCH_CMN_GET_CELL(cell);
20216    CmLListCp     ulInactvLst;
20217    TRC2(rgSCHCmnHdlUlInactUes);
20218    /* Get a List of Inactv UEs for UL*/
20219    cmLListInit(&ulInactvLst);
20220
20221    /* Trigger Spfc Schedulers with Inactive UEs */
20222    rgSCHMeasGapANRepGetUlInactvUe (cell, &ulInactvLst);
20223    /* take care of this in UL retransmission */
20224    cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
20225
20226    RETVOID;
20227 }
20228
20229 /**
20230  * @brief Scheduler invocation per TTI.
20231  *
20232  * @details
20233  *
20234  *     Function: rgSCHCmnHdlDlInactUes
20235  *     Purpose:
20236  *
20237  *     Invoked by: Common Scheduler
20238  *
20239  *  @param[in]  RgSchCellCb *cell
20240  *  @return  Void
20241  **/
20242 #ifdef ANSI
20243 PRIVATE Void rgSCHCmnHdlDlInactUes
20244 (
20245 RgSchCellCb  *cell
20246 )
20247 #else
20248 PRIVATE Void rgSCHCmnHdlDlInactUes(cell)
20249 RgSchCellCb  *cell;
20250 #endif
20251 {
20252    RgSchCmnCell *cellSch  = RG_SCH_CMN_GET_CELL(cell);
20253    CmLListCp    dlInactvLst;
20254    TRC2(rgSCHCmnHdlDlInactUes);
20255    /* Get a List of Inactv UEs for DL */
20256    cmLListInit(&dlInactvLst);
20257
20258    /* Trigger Spfc Schedulers with Inactive UEs */
20259    rgSCHMeasGapANRepGetDlInactvUe (cell, &dlInactvLst);
20260
20261    cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
20262    RETVOID;
20263 }
20264
20265 /* RACHO: Rach handover functions start here */
20266 /***********************************************************
20267  *
20268  *     Func : rgSCHCmnUeIdleExdThrsld
20269  *
20270  *     Desc : RETURN ROK if UE has been idle more
20271  *            than threshold.
20272  *
20273  *     Ret  :
20274  *
20275  *     Notes:
20276  *
20277  *     File :
20278  *
20279  **********************************************************/
20280 #ifdef ANSI
20281 PRIVATE S16 rgSCHCmnUeIdleExdThrsld
20282 (
20283 RgSchCellCb     *cell,
20284 RgSchUeCb       *ue
20285 )
20286 #else
20287 PRIVATE S16 rgSCHCmnUeIdleExdThrsld(cell, ue)
20288 RgSchCellCb     *cell;
20289 RgSchUeCb       *ue;
20290 #endif
20291 {
20292    /* Time difference in subframes */
20293    U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
20294
20295    TRC2(rgSCHCmnUeIdleExdThrsld);
20296
20297    if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
20298    {
20299       RETVALUE(ROK);
20300    }
20301    else
20302    {
20303       RETVALUE(RFAILED);
20304    }
20305 }
20306
20307 \f
20308 /**
20309  * @brief Scheduler processing for Ded Preambles on cell configuration.
20310  *
20311  * @details
20312  *
20313  *     Function : rgSCHCmnCfgRachDedPrm
20314  *
20315  *     This function does requisite initialisation
20316  *     for RACH Ded Preambles.
20317  *
20318  *
20319  *  @param[in]  RgSchCellCb   *cell
20320  *  @return  Void
20321  **/
20322 #ifdef ANSI
20323 PRIVATE Void rgSCHCmnCfgRachDedPrm
20324 (
20325 RgSchCellCb   *cell
20326 )
20327 #else
20328 PRIVATE Void rgSCHCmnCfgRachDedPrm(cell)
20329 RgSchCellCb   *cell;
20330 #endif
20331 {
20332    RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20333    U32          gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
20334    U32          sfDiff;
20335    U8           cnt;
20336    TRC2(rgSCHCmnCfgRachDedPrm);
20337
20338    if (cell->macPreambleSet.pres == NOTPRSNT)
20339    {
20340       RETVOID;
20341    }
20342    cellSch->rachCfg.numDedPrm = cell->macPreambleSet.size;
20343    cellSch->rachCfg.dedPrmStart = cell->macPreambleSet.start;
20344    /* Initialize handover List */
20345    cmLListInit(&cellSch->rachCfg.hoUeLst);
20346    /* Initialize pdcch Order List */
20347    cmLListInit(&cellSch->rachCfg.pdcchOdrLst);
20348
20349    /* Intialize the rapId to UE mapping structure */
20350    for (cnt = 0; cnt<cellSch->rachCfg.numDedPrm; cnt++)
20351    {
20352       cellSch->rachCfg.rapIdMap[cnt].rapId = cellSch->rachCfg.dedPrmStart + \
20353                                              cnt;
20354       cmLListInit(&cellSch->rachCfg.rapIdMap[cnt].assgndUes);
20355    }
20356    /* Perform Prach Mask Idx, remDedPrm, applFrm initializations */
20357    /* Set remDedPrm as numDedPrm */
20358    cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
20359    /* Initialize applFrm */
20360    cellSch->rachCfg.prachMskIndx = 0;
20361    if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_EVEN)
20362    {
20363       cellSch->rachCfg.applFrm.sfn = (cell->crntTime.sfn + \
20364             (cell->crntTime.sfn % 2)) % RGSCH_MAX_SFN;
20365    }
20366 #ifdef LTE_TDD
20367    else if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ODD)
20368    {
20369       if((cell->crntTime.sfn%2) == 0)
20370       {
20371          cellSch->rachCfg.applFrm.sfn = (cell->crntTime.sfn + 1)\
20372                                         % RGSCH_MAX_SFN;
20373       }
20374    }
20375 #endif
20376    else /* ANY sfn */
20377    {
20378       cellSch->rachCfg.applFrm.sfn = cell->crntTime.sfn;
20379    }
20380    /* Initialize cellSch->rachCfg.applFrm as >= crntTime.
20381     * This is because of RGSCH_CALC_SF_DIFF logic */
20382    if (cellSch->rachCfg.applFrm.sfn == cell->crntTime.sfn)
20383    {
20384       while (cellSch->rachCfg.prachMskIndx < cell->rachCfg.raOccasion.size)
20385       {
20386          if (cell->crntTime.subframe <\
20387                cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx])
20388          {
20389             break;
20390          }
20391          cellSch->rachCfg.prachMskIndx++;
20392       }
20393       if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size)
20394       {
20395          if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ANY)
20396          {
20397             cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+1) %\
20398                                            RGSCH_MAX_SFN;
20399          }
20400          else
20401          {
20402             cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+2) %\
20403                                            RGSCH_MAX_SFN;
20404          }
20405          cellSch->rachCfg.prachMskIndx = 0;
20406       }
20407       cellSch->rachCfg.applFrm.subframe = \
20408                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20409    }
20410    else
20411    {
20412       cellSch->rachCfg.applFrm.subframe = \
20413                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20414    }
20415
20416    /* Note first param to this macro should always be the latest in time */
20417    sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
20418    while (sfDiff <= gap)
20419    {
20420       rgSCHCmnUpdNxtPrchMskIdx(cell);
20421       sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
20422    }
20423
20424    RETVOID;
20425 }
20426
20427 /**
20428  * @brief Updates the PRACH MASK INDEX.
20429  *
20430  * @details
20431  *
20432  *     Function: rgSCHCmnUpdNxtPrchMskIdx
20433  *     Purpose:  Ensures the "applFrm" field of Cmn Sched RACH
20434  *     CFG is always >= "n"+"DELTA", where "n" is the crntTime
20435  *     of the cell. If not, applFrm is updated to the next avl
20436  *     PRACH oppurtunity as per the PRACH Cfg Index configuration.
20437  *
20438  *
20439  *     Invoked by: Common Scheduler
20440  *
20441  *  @param[in]  RgSchCellCb *cell
20442  *  @return  Void
20443  **/
20444 #ifdef ANSI
20445 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx
20446 (
20447 RgSchCellCb  *cell
20448 )
20449 #else
20450 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx(cell)
20451 RgSchCellCb  *cell;
20452 #endif
20453 {
20454    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20455    TRC2(rgSCHCmnUpdNxtPrchMskIdx);
20456
20457    /* Determine the next prach mask Index */
20458    if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
20459    {
20460       /* PRACH within applFrm.sfn are done, go to next AVL sfn */
20461       cellSch->rachCfg.prachMskIndx = 0;
20462       if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ANY)
20463       {
20464          cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+1) % \
20465                                         RGSCH_MAX_SFN;
20466       }
20467       else/* RGR_SFN_EVEN or RGR_SFN_ODD */
20468       {
20469          cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+2) % \
20470                                         RGSCH_MAX_SFN;
20471       }
20472       cellSch->rachCfg.applFrm.subframe = cell->rachCfg.raOccasion.\
20473                                           subFrameNum[0];
20474    }
20475    else /* applFrm.sfn is still valid */
20476    {
20477       cellSch->rachCfg.prachMskIndx += 1;
20478       if ( cellSch->rachCfg.prachMskIndx < RGR_MAX_SUBFRAME_NUM )
20479       {
20480          cellSch->rachCfg.applFrm.subframe = \
20481                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20482       }
20483    }
20484    RETVOID;
20485 }
20486
20487 /**
20488  * @brief Updates the Ded preamble RACH parameters
20489  *        every TTI.
20490  *
20491  * @details
20492  *
20493  *     Function: rgSCHCmnUpdRachParam
20494  *     Purpose:  Ensures the "applFrm" field of Cmn Sched RACH
20495  *     CFG is always >= "n"+"6"+"DELTA", where "n" is the crntTime
20496  *     of the cell. If not, applFrm is updated to the next avl
20497  *     PRACH oppurtunity as per the PRACH Cfg Index configuration,
20498  *     accordingly the "remDedPrm" is reset to "numDedPrm" and
20499  *     "prachMskIdx" field is updated as per "applFrm".
20500  *
20501  *
20502  *     Invoked by: Common Scheduler
20503  *
20504  *  @param[in]  RgSchCellCb *cell
20505  *  @return  Void
20506  **/
20507 #ifdef ANSI
20508 PRIVATE Void rgSCHCmnUpdRachParam
20509 (
20510 RgSchCellCb  *cell
20511 )
20512 #else
20513 PRIVATE Void rgSCHCmnUpdRachParam(cell)
20514 RgSchCellCb  *cell;
20515 #endif
20516 {
20517
20518    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20519    U32             gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
20520    U32             sfDiff;
20521    TRC2(rgSCHCmnUpdRachParam);
20522
20523    if (cell->macPreambleSet.pres == NOTPRSNT)
20524    {
20525       RETVOID;
20526    }
20527    sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, \
20528          cell->crntTime);
20529    if (sfDiff > gap)
20530    {
20531       /* applFrm is still a valid next Prach Oppurtunity */
20532       RETVOID;
20533    }
20534    rgSCHCmnUpdNxtPrchMskIdx(cell);
20535    /* Reset remDedPrm as numDedPrm */
20536    cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
20537
20538    RETVOID;
20539 }
20540
20541 /**
20542  * @brief Dedicated Preamble allocation function.
20543  *
20544  * @details
20545  *
20546  *     Function: rgSCHCmnAllocPOParam
20547  *     Purpose:  Allocate pdcch, rapId and PrachMskIdx.
20548  *     Set mapping of UE with the allocated rapId.
20549  *
20550  *     Invoked by: Common Scheduler
20551  *
20552  *  @param[in]   RgSchCellCb *cell
20553  *  @param[in]   RgSchDlSf   *dlSf
20554  *  @param[in]   RgSchUeCb   *ue
20555  *  @param[out]  RgSchPdcch  **pdcch
20556  *  @param[out]  U8          *rapId
20557  *  @param[out]  U8          *prachMskIdx
20558  *  @return  Void
20559  **/
20560 #ifdef ANSI
20561 PRIVATE S16 rgSCHCmnAllocPOParam
20562 (
20563 RgSchCellCb  *cell,
20564 RgSchDlSf    *dlSf,
20565 RgSchUeCb    *ue,
20566 RgSchPdcch   **pdcch,
20567 U8           *rapId,
20568 U8           *prachMskIdx
20569 )
20570 #else
20571 PRIVATE S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
20572 RgSchCellCb  *cell;
20573 RgSchDlSf    *dlSf;
20574 RgSchUeCb    *ue;
20575 RgSchPdcch   **pdcch;
20576 U8           *rapId;
20577 U8           *prachMskIdx;
20578 #endif
20579 {
20580
20581    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20582    RgSchCmnDlUe    *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20583
20584    TRC2(rgSCHCmnAllocPOParam);
20585
20586    if (cell->macPreambleSet.pres == PRSNT_NODEF)
20587    {
20588       if (cellSch->rachCfg.remDedPrm == 0)
20589       {
20590          RETVALUE(RFAILED);
20591       }
20592       /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
20593       if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
20594       {
20595          RETVALUE(RFAILED);
20596       }
20597       /* The stored prachMskIdx is the index of PRACH Oppurtunities in
20598        * raOccasions.subframes[].
20599        * Converting the same to the actual PRACHMskIdx to be transmitted. */
20600       *prachMskIdx = cellSch->rachCfg.prachMskIndx + 1;
20601       /* Distribution starts from dedPrmStart till dedPrmStart + numDedPrm */
20602       *rapId =  cellSch->rachCfg.dedPrmStart +
20603          cellSch->rachCfg.numDedPrm - cellSch->rachCfg.remDedPrm;
20604       cellSch->rachCfg.remDedPrm--;
20605       /* Map UE with the allocated RapId */
20606       ueDl->rachInfo.asgnOppr = cellSch->rachCfg.applFrm;
20607       RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, cellSch->rachCfg.rapIdMap, (*rapId - cellSch->rachCfg.dedPrmStart));
20608       cmLListAdd2Tail(&cellSch->rachCfg.rapIdMap[*rapId - cellSch->rachCfg.dedPrmStart].assgndUes, 
20609              &ueDl->rachInfo.rapIdLnk);
20610       ueDl->rachInfo.rapIdLnk.node = (PTR)ue;
20611       ueDl->rachInfo.poRapId = *rapId;
20612    }
20613    else /* if dedicated preambles not configured */
20614    {
20615       /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
20616       if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
20617       {
20618          RETVALUE(RFAILED);
20619       }
20620       *prachMskIdx = 0;
20621       *rapId       = 0;
20622    }
20623
20624    RETVALUE(ROK);
20625 }
20626
20627 /**
20628  * @brief Dowlink Scheduling Handler.
20629  *
20630  * @details
20631  *
20632  *     Function: rgSCHCmnGenPdcchOrder
20633  *     Purpose:  For each UE in PO Q, grab a PDCCH,
20634  *     get an available ded RapId and fill PDCCH
20635  *     with PO information.
20636  *
20637  *     Invoked by: Common Scheduler
20638  *
20639  *  @param[in]  RgSchCellCb *cell
20640  *  @param[in]  RgSchDlSf   *dlSf
20641  *  @return  Void
20642  **/
20643 #ifdef ANSI
20644 PRIVATE Void rgSCHCmnGenPdcchOrder
20645 (
20646 RgSchCellCb  *cell,
20647 RgSchDlSf    *dlSf
20648 )
20649 #else
20650 PRIVATE Void rgSCHCmnGenPdcchOrder(cell, dlSf)
20651 RgSchCellCb  *cell;
20652 RgSchDlSf    *dlSf;
20653 #endif
20654 {
20655    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
20656    CmLList           *node = cellSch->rachCfg.pdcchOdrLst.first;
20657    RgSchUeCb         *ue;
20658    U8                rapId;
20659    U8                prachMskIdx;
20660    RgSchPdcch        *pdcch = NULLP;
20661
20662    TRC2(rgSCHCmnGenPdcchOrder);
20663
20664    while (node)
20665    {
20666       ue = (RgSchUeCb *)node->node;
20667       node = node->next;
20668       /* Skip sending for this subframe is Measuring or inActive in UL due
20669        * to MeasGap or inactie due to DRX
20670        */
20671       if  ((ue->measGapCb.isMeasuring == TRUE) ||
20672            (ue->ul.ulInactvMask & RG_MEASGAP_INACTIVE) ||
20673            (ue->isDrxEnabled &&
20674              ue->dl.dlInactvMask & RG_DRX_INACTIVE)
20675            )
20676       {
20677          continue;
20678       }
20679       if (rgSCHCmnAllocPOParam(cell, dlSf, ue, &pdcch, &rapId,\
20680                &prachMskIdx) != ROK)
20681       {
20682          /* No More rapIds left for the valid next avl Oppurtunity.
20683           * Unsatisfied UEs here would be given a chance, when the
20684           * prach Mask Index changes as per rachUpd every TTI */
20685
20686          /* PDDCH can also be ordered with rapId=0, prachMskIdx=0
20687           * so that UE triggers a RACH procedure with non-dedicated preamble.
20688           * But the implementation here does not do this. Instead, the "break"
20689           * here implies, that PDCCH Odr always given with valid rapId!=0,
20690           * prachMskIdx!=0 if dedicated preambles are configured.
20691           * If not configured, then trigger a PO with rapId=0,prchMskIdx=0*/
20692          break;
20693       }
20694       /* Fill pdcch with pdcch odr information */
20695       rgSCHCmnFillPdcchOdr2Sf(cell, ue, pdcch, rapId, prachMskIdx);
20696       /* Remove this UE from the PDCCH ORDER QUEUE */
20697       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
20698       /* Reset UE's power state */
20699       rgSCHPwrUeReset(cell, ue);
20700    }
20701    RETVOID;
20702 }
20703
20704 \f
20705 /**
20706  * @brief This function add UE to PdcchOdr Q if not already present.
20707  *
20708  * @details
20709  *
20710  *     Function: rgSCHCmnDlAdd2PdcchOdrQ
20711  *     Purpose:
20712  *
20713  *     Invoked by: CMN Scheduler
20714  *
20715  *  @param[in]  RgSchCellCb*  cell
20716  *  @param[in]  RgSchUeCb*    ue
20717  *  @return  Void
20718  *
20719  **/
20720 #ifdef ANSI
20721 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ
20722 (
20723 RgSchCellCb                *cell,
20724 RgSchUeCb                  *ue
20725 )
20726 #else
20727 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ(cell, ue)
20728 RgSchCellCb                *cell;
20729 RgSchUeCb                  *ue;
20730 #endif
20731 {
20732    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20733    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20734
20735    TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
20736
20737    if (ueDl->rachInfo.poLnk.node == NULLP)
20738    {
20739       cmLListAdd2Tail(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
20740       ueDl->rachInfo.poLnk.node = (PTR)ue;
20741    }
20742    RETVOID;
20743 }
20744
20745 \f
20746 /**
20747  * @brief This function rmvs UE to PdcchOdr Q if not already present.
20748  *
20749  * @details
20750  *
20751  *     Function: rgSCHCmnDlRmvFrmPdcchOdrQ
20752  *     Purpose:
20753  *
20754  *     Invoked by: CMN Scheduler
20755  *
20756  *  @param[in]  RgSchCellCb*  cell
20757  *  @param[in]  RgSchUeCb*    ue
20758  *  @return  Void
20759  *
20760  **/
20761 #ifdef ANSI
20762 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ
20763 (
20764 RgSchCellCb                *cell,
20765 RgSchUeCb                  *ue
20766 )
20767 #else
20768 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue)
20769 RgSchCellCb                *cell;
20770 RgSchUeCb                  *ue;
20771 #endif
20772 {
20773    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20774    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20775
20776    TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
20777
20778    cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
20779    ueDl->rachInfo.poLnk.node = NULLP;
20780    RETVOID;
20781 }
20782
20783 /**
20784  * @brief Fill pdcch with PDCCH order information.
20785  *
20786  * @details
20787  *
20788  *     Function: rgSCHCmnFillPdcchOdr2Sf
20789  *     Purpose:  Fill PDCCH with PDCCH order information,
20790  *
20791  *     Invoked by: Common Scheduler
20792  *
20793  *  @param[in]  RgSchUeCb   *ue
20794  *  @param[in]  RgSchPdcch  *pdcch
20795  *  @param[in]  U8          rapId
20796  *  @param[in]  U8          prachMskIdx
20797  *  @return  Void
20798  **/
20799 #ifdef ANSI
20800 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf
20801 (
20802 RgSchCellCb *cell,
20803 RgSchUeCb   *ue,
20804 RgSchPdcch  *pdcch,
20805 U8          rapId,
20806 U8          prachMskIdx
20807 )
20808 #else
20809 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
20810 RgSchCellCb *cell;
20811 RgSchUeCb   *ue;
20812 RgSchPdcch  *pdcch;
20813 U8          rapId;
20814 U8          prachMskIdx;
20815 #endif
20816 {
20817    RgSchUeACqiCb  *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell); 
20818
20819    TRC2(rgSCHCmnFillPdcchOdr2Sf);
20820
20821    pdcch->rnti                                         = ue->ueId;
20822    pdcch->dci.dciFormat                                = TFU_DCI_FORMAT_1A;
20823    pdcch->dci.u.format1aInfo.isPdcchOrder = TRUE;
20824    pdcch->dci.u.format1aInfo.t.pdcchOrder.preambleIdx  = rapId;
20825    pdcch->dci.u.format1aInfo.t.pdcchOrder.prachMaskIdx = prachMskIdx;
20826
20827    /* Request for APer CQI immediately after PDCCH Order */
20828    /* CR ccpu00144525 */
20829 #ifdef TFU_UPGRADE
20830    if(ue->dl.ueDlCqiCfg.aprdCqiCfg.pres)
20831    {
20832       ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
20833       acqiCb->aCqiTrigWt = 0;
20834    }
20835 #endif   
20836
20837    RETVOID;
20838 }
20839
20840 \f
20841 /**
20842  * @brief UE deletion for scheduler.
20843  *
20844  * @details
20845  *
20846  *     Function : rgSCHCmnDelRachInfo
20847  *
20848  *     This functions deletes all scheduler information
20849  *     pertaining to an UE.
20850  *
20851  *  @param[in]  RgSchCellCb  *cell
20852  *  @param[in]  RgSchUeCb    *ue
20853  *  @return  Void
20854  **/
20855 #ifdef ANSI
20856 PRIVATE Void rgSCHCmnDelRachInfo
20857 (
20858 RgSchCellCb  *cell,
20859 RgSchUeCb    *ue
20860 )
20861 #else
20862 PRIVATE Void rgSCHCmnDelRachInfo(cell, ue)
20863 RgSchCellCb  *cell;
20864 RgSchUeCb    *ue;
20865 #endif
20866 {
20867    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20868    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20869    U8            rapIdIdx;
20870
20871    TRC2(rgSCHCmnDelRachInfo);
20872
20873    if (ueDl->rachInfo.poLnk.node)
20874    {
20875       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
20876    }
20877    if (ueDl->rachInfo.hoLnk.node)
20878    {
20879       cmLListDelFrm(&cellSch->rachCfg.hoUeLst, &ueDl->rachInfo.hoLnk);
20880       ueDl->rachInfo.hoLnk.node = NULLP;
20881    }
20882    if (ueDl->rachInfo.rapIdLnk.node)
20883    {
20884       rapIdIdx = ueDl->rachInfo.poRapId - cellSch->rachCfg.dedPrmStart;
20885       cmLListDelFrm(&cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes, 
20886           &ueDl->rachInfo.rapIdLnk);
20887       ueDl->rachInfo.rapIdLnk.node = NULLP;
20888    }
20889    RETVOID;
20890 }
20891
20892 /**
20893  * @brief This function retrieves the ue which has sent this raReq
20894  * and it allocates grant for UEs undergoing (for which RAR
20895  * is being generated) HandOver/PdcchOrder.
20896  *
20897  *
20898  * @details
20899  *
20900  *     Function: rgSCHCmnHdlHoPo
20901  *     Purpose:  This function  retrieves the ue which has sent this raReq
20902  *               and it allocates grant for UEs undergoing (for which RAR
20903  *               is being generated) HandOver/PdcchOrder.
20904  *
20905  *     Invoked by: Common Scheduler
20906  *
20907  *  @param[in]  RgSchCellCb           *cell
20908  *  @param[out] CmLListCp             *raRspLst
20909  *  @param[in]  RgSchRaReqInfo        *raReq
20910  *  @return  Void
20911  *
20912  **/
20913 #ifdef ANSI
20914 PRIVATE Void rgSCHCmnHdlHoPo
20915 (
20916 RgSchCellCb           *cell,
20917 CmLListCp             *raRspLst,
20918 RgSchRaReqInfo        *raReq
20919 )
20920 #else
20921 PRIVATE Void rgSCHCmnHdlHoPo(cell, raRspLst, raReq)
20922 RgSchCellCb           *cell;
20923 CmLListCp             *raRspLst;
20924 RgSchRaReqInfo        *raReq;
20925 #endif
20926 {
20927    RgSchUeCb             *ue = raReq->ue;
20928    TRC2(rgSCHCmnHdlHoPo);
20929
20930    if ( ue->isDrxEnabled )
20931    {
20932       rgSCHDrxDedRa(cell,ue);
20933    }
20934    rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq);
20935    RETVOID;
20936 }
20937
20938 /**
20939  * @brief This function retrieves the UE which has sent this raReq
20940  * for handover case.
20941  *
20942  *
20943  * @details
20944  *
20945  *     Function: rgSCHCmnGetHoUe
20946  *     Purpose:  This function retrieves the UE which has sent this raReq
20947  *     for handover case.
20948  *
20949  *     Invoked by: Common Scheduler
20950  *
20951  *  @param[in]  RgSchCellCb           *cell
20952  *  @param[in]  RgSchRaReqInfo        *raReq
20953  *  @return  RgSchUeCb*
20954  *
20955  **/
20956 #ifdef ANSI
20957 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe
20958 (
20959 RgSchCellCb           *cell,
20960 U16                   rapId
20961 )
20962 #else
20963 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
20964 RgSchCellCb           *cell;
20965 U16                   rapId
20966 #endif
20967 {
20968    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20969    CmLList               *node;
20970    CmLListCp             *ueLst;
20971    RgSchUeCb             *ue;
20972    RgSchCmnDlUe          *ueDl;
20973    TRC2(rgSCHCmnGetHoUe);
20974
20975    ueLst = &cellSch->rachCfg.hoUeLst;
20976    node = ueLst->first;
20977    while (node)
20978    {
20979       ue = (RgSchUeCb *)node->node;
20980       node = node->next;
20981       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20982       if (ueDl->rachInfo.hoRapId == rapId)
20983       {
20984          RETVALUE(ue);
20985       }
20986    }
20987    RETVALUE(NULLP);
20988 }
20989
20990 #ifdef ANSI
20991 PRIVATE Void rgSCHCmnDelDedPreamble
20992 (
20993 RgSchCellCb           *cell,
20994 U8                    preambleId
20995 )
20996 #else
20997 PRIVATE rgSCHCmnDelDedPreamble(cell, preambleId)
20998 RgSchCellCb           *cell;
20999 U8                    preambleId;
21000 #endif
21001 {
21002    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
21003    CmLList               *node;
21004    CmLListCp             *ueLst;
21005    RgSchUeCb             *ue;
21006    RgSchCmnDlUe          *ueDl;
21007    TRC2(rgSCHCmnDelDedPreamble);
21008
21009    ueLst = &cellSch->rachCfg.hoUeLst;
21010    node = ueLst->first;
21011    while (node)
21012    {
21013       ue = (RgSchUeCb *)node->node;
21014       node = node->next;
21015       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
21016       if (ueDl->rachInfo.hoRapId == preambleId)
21017       {
21018          cmLListDelFrm(ueLst, &ueDl->rachInfo.hoLnk);
21019          ueDl->rachInfo.hoLnk.node = (PTR)NULLP;
21020       }
21021    }
21022 }
21023
21024 /**
21025  * @brief This function retrieves the UE which has sent this raReq
21026  * for PDCCh Order case.
21027  *
21028  *
21029  * @details
21030  *
21031  *     Function: rgSCHCmnGetPoUe
21032  *     Purpose:  This function retrieves the UE which has sent this raReq
21033  *     for PDCCH Order case.
21034  *
21035  *     Invoked by: Common Scheduler
21036  *
21037  *  @param[in]  RgSchCellCb           *cell
21038  *  @param[in]  RgSchRaReqInfo        *raReq
21039  *  @return  RgSchUeCb*
21040  *
21041  **/
21042 #ifdef ANSI
21043 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe
21044 (
21045 RgSchCellCb           *cell,
21046 U16                   rapId,
21047 CmLteTimingInfo       timingInfo
21048 )
21049 #else
21050 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
21051 RgSchCellCb           *cell;
21052 U16                   rapId;
21053 CmLteTimingInfo       timingInfo;
21054 #endif
21055 {
21056    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
21057    CmLList               *node;
21058    CmLListCp             *ueLst;
21059    RgSchUeCb             *ue;
21060    RgSchCmnDlUe          *ueDl;
21061    U8                    rapIdIdx;
21062    TRC2(rgSCHCmnGetPoUe);
21063
21064    rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
21065    ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
21066    node = ueLst->first;
21067    while (node)
21068    {
21069       ue = (RgSchUeCb *)node->node;
21070       node = node->next;
21071       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
21072       /* Remove UEs irrespective.
21073        * Old UE associations are removed.*/
21074       cmLListDelFrm(ueLst, &ueDl->rachInfo.rapIdLnk);
21075       ueDl->rachInfo.rapIdLnk.node = (PTR)NULLP;
21076       if (RGSCH_TIMEINFO_SAME(ueDl->rachInfo.asgnOppr, timingInfo))
21077       {
21078          RETVALUE(ue);
21079       }
21080    }
21081
21082    RETVALUE(NULLP);
21083 }
21084
21085
21086 /**
21087  * @brief This function returns the valid UL cqi for a given UE.
21088  *
21089  * @details
21090  *
21091  *     Function: rgSCHCmnUlGetCqi
21092  *     Purpose:  This function returns the "valid UL cqi" for a given UE
21093  *               based on UE category
21094  *
21095  *     Invoked by: Scheduler
21096  *     
21097  *  @param[in]  RgSchUeCb        *ue
21098  *  @param[in]  U8               ueCtgy
21099  *  @return     U8 
21100  **/
21101 #ifdef ANSI
21102 PUBLIC U8 rgSCHCmnUlGetCqi
21103 (
21104 RgSchCellCb      *cell,
21105 RgSchUeCb        *ue,
21106 CmLteUeCategory  ueCtgy
21107 )
21108 #else
21109 PUBLIC U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
21110 RgSchCellCb      *cell;
21111 RgSchUeCb        *ue;
21112 CmLteUeCategory  ueCtgy;
21113 #endif
21114 {
21115    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
21116    U8            cqi;
21117
21118    TRC2(rgSCHCmnUlGetCqi);
21119    
21120    cqi = ueUl->maxUlCqi;
21121 #ifdef TFU_UPGRADE
21122    if (!((ueCtgy != CM_LTE_UE_CAT_5) && 
21123         (ueUl->validUlCqi > ueUl->maxUlCqi)))
21124    {
21125       cqi = ueUl->validUlCqi;
21126    }
21127 #else   
21128    if (!((ueCtgy != CM_LTE_UE_CAT_5) && 
21129          (ueUl->crntUlCqi[0] > ueUl->maxUlCqi )))
21130    {
21131       cqi = ueUl->crntUlCqi[0];
21132    }
21133 #endif    
21134    RETVALUE(cqi);
21135 }/* End of rgSCHCmnUlGetCqi */
21136
21137 /***********************************************************
21138  *
21139  *     Func : rgSCHCmnUlRbAllocForPoHoUe
21140  *
21141  *     Desc : Do uplink RB allocation for a HO/PO UE.
21142  *
21143  *     Ret  :
21144  *
21145  *     Notes: Note that as of now, for retx, maxRb
21146  *            is not considered. Alternatives, such
21147  *            as dropping retx if it crosses maxRb
21148  *            could be considered.
21149  *
21150  *     File :
21151  *
21152  **********************************************************/
21153 #ifdef ANSI
21154 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe
21155 (
21156 RgSchCellCb           *cell,
21157 RgSchUlSf             *sf,
21158 RgSchUeCb             *ue,
21159 U8                    maxRb
21160 )
21161 #else
21162 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
21163 RgSchCellCb           *cell;
21164 RgSchUlSf             *sf;
21165 RgSchUeCb             *ue;
21166 U8                    maxRb;
21167 #endif
21168 {
21169    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21170    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
21171    U8           sbSize  = cellUl->sbSize;
21172    U32          maxBits = ue->ul.maxBytesPerUePerTti*8;
21173    U32          bits;
21174    RgSchUlAlloc *alloc;
21175    U32          nPrb;
21176    U8           iTbs;
21177    U32          eff;
21178    U32          numSb;
21179    U8           iMcs;
21180    U8           iMcsCrnt;
21181    U8           cqi;
21182    U8           modOdr;
21183    RgSchUlHole      *hole;
21184    RgSchUlHqProcCb  *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
21185    CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
21186
21187    TRC2(rgSCHCmnUlRbAllocForPoHoUe);
21188    if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
21189    {
21190       RETVALUE(RFAILED);
21191    }
21192    /*MS_WORKAROUND for HO ccpu00121116*/
21193    cqi   = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
21194    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend], cqi);
21195    iTbs  = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
21196    iMcs  = rgSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
21197    while(iMcs > RG_SCH_CMN_MAX_MSG3_IMCS)
21198    {
21199        cqi--;
21200        iTbs  = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
21201        iMcs  = rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg);
21202    }
21203    /* Filling the modorder in the grant structure*/
21204    RG_SCH_UL_MCS_TO_MODODR(iMcs,modOdr);
21205    if (!cell->isCpUlExtend)
21206    {
21207       eff   = rgSchCmnNorUlEff[0][iTbs];
21208    }
21209    else
21210    {
21211       eff   = rgSchCmnExtUlEff[0][iTbs];
21212    }
21213
21214    bits = ueUl->alloc.reqBytes * 8;
21215
21216 #if (ERRCLASS & ERRCLS_DEBUG)
21217    if (!bits)
21218    {
21219       RETVALUE(RFAILED);
21220    }
21221 #endif
21222
21223    if (bits < rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs))
21224    {
21225       numSb = 1;
21226       nPrb = numSb * sbSize;
21227    }
21228    else
21229    {
21230       if (bits > maxBits)
21231       {
21232          bits  = maxBits;
21233          nPrb  = bits * 1024 / eff / RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
21234          if (nPrb > maxRb)
21235          {
21236             nPrb = maxRb;
21237          }
21238          numSb = nPrb / sbSize;
21239       }
21240       else
21241       {
21242          /*ccpu00128775:MOD-Change to get upper threshold nPrb*/
21243          nPrb = RGSCH_CEIL((RGSCH_CEIL(bits * 1024, eff)),
21244                   RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl));
21245          if (nPrb > maxRb)
21246          {
21247             nPrb = maxRb;
21248          }
21249          numSb = RGSCH_DIV_ROUND(nPrb, sbSize);
21250       }
21251    }
21252    iMcsCrnt = iMcs;
21253
21254    alloc = rgSCHCmnUlSbAlloc(sf, (U8)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
21255                              hole);
21256    if (alloc == NULLP)
21257    {
21258       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
21259          "rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
21260       RETVALUE(RFAILED);
21261    }
21262    rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
21263    
21264    /* Filling the modorder in the grant structure start*/
21265    alloc->grnt.modOdr = (TfuModScheme) modOdr;
21266    alloc->grnt.iMcs = iMcs;
21267    alloc->grnt.iMcsCrnt = iMcsCrnt;
21268    alloc->grnt.hop = 0;
21269    /* Fix for ccpu00123915*/
21270    alloc->forMsg3 = TRUE;
21271    alloc->hqProc = proc;
21272    alloc->hqProc->ulSfIdx = cellUl->msg3SchdIdx;
21273    alloc->ue = ue;
21274    alloc->rnti = ue->ueId;
21275    /* updating initNumRbs in case of HO */
21276 #ifdef TFU_UPGRADE
21277    ue->initNumRbs = alloc->grnt.numRb;
21278 #endif
21279    ueUl->alloc.alloc = alloc;
21280    iTbs = rgSCHCmnUlGetITbsFrmIMcs(iMcs);
21281    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[0], iTbs);
21282    alloc->grnt.datSz    = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
21283    /* MS_WORKAROUND for HO ccpu00121124*/
21284    /*[Adi temp change] Need to fil modOdr */
21285    RG_SCH_UL_MCS_TO_MODODR(alloc->grnt.iMcsCrnt,alloc->grnt.modOdr);
21286    rgSCHUhmNewTx(proc, ueUl->hqEnt.maxHqRetx, alloc);
21287    /* No grant attr recorded now */
21288    RETVALUE(ROK);
21289 }
21290
21291 /**
21292  * @brief This function allocates grant for UEs undergoing (for which RAR
21293  * is being generated) HandOver/PdcchOrder.
21294  *
21295  *
21296  * @details
21297  *
21298  *     Function: rgSCHCmnAllocPoHoGrnt
21299  *     Purpose:  This function allocates grant for UEs undergoing (for which RAR
21300  *               is being generated) HandOver/PdcchOrder.
21301  *
21302  *     Invoked by: Common Scheduler
21303  *
21304  *  @param[in]  RgSchCellCb           *cell
21305  *  @param[out] CmLListCp             *raRspLst,
21306  *  @param[in]  RgSchUeCb             *ue
21307  *  @param[in]  RgSchRaReqInfo        *raReq
21308  *  @return  Void
21309  *
21310  **/
21311 #ifdef ANSI
21312 PRIVATE Void rgSCHCmnAllocPoHoGrnt
21313 (
21314 RgSchCellCb           *cell,
21315 CmLListCp             *raRspLst,
21316 RgSchUeCb             *ue,
21317 RgSchRaReqInfo        *raReq
21318 )
21319 #else
21320 PRIVATE Void rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq)
21321 RgSchCellCb           *cell;
21322 CmLListCp             *raRspLst;
21323 RgSchUeCb             *ue;
21324 RgSchRaReqInfo        *raReq;
21325 #endif
21326 {
21327    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21328    RgSchCmnUlUe    *ueUl   = RG_SCH_CMN_GET_UL_UE(ue,cell);
21329    RgSchUlGrnt     *grnt;
21330    RgSchUlSf       *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
21331
21332    TRC2(rgSCHCmnAllocPoHoGrnt);
21333
21334    /* Clearing previous allocs if any*/
21335    rgSCHCmnUlUeDelAllocs(cell, ue);
21336    /* Fix : syed allocs are limited */
21337    if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
21338    {
21339       RETVOID;
21340    }
21341    ueUl->alloc.reqBytes = RG_SCH_MIN_GRNT_HOPO;
21342    if (rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, RGSCH_MAX_UL_RB) != ROK)
21343    {
21344       RETVOID;
21345    }
21346
21347    /* Fill grant information */
21348    grnt = &ueUl->alloc.alloc->grnt;
21349
21350    /* KWork fix */
21351    if (grnt == NULLP)
21352    {
21353       RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx,  "Failed to get"
21354         "the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
21355       RETVOID;
21356    }
21357    ue->ul.rarGrnt.rapId = raReq->raReq.rapId;
21358    ue->ul.rarGrnt.hop = grnt->hop;
21359    ue->ul.rarGrnt.rbStart = grnt->rbStart;
21360    ue->ul.rarGrnt.numRb = grnt->numRb;
21361    ue->ul.rarGrnt.tpc = grnt->tpc;
21362    ue->ul.rarGrnt.iMcsCrnt = grnt->iMcsCrnt;
21363    ue->ul.rarGrnt.ta.pres = TRUE;
21364    ue->ul.rarGrnt.ta.val = raReq->raReq.ta;
21365    ue->ul.rarGrnt.datSz = grnt->datSz;
21366    if((sf->numACqiCount < RG_SCH_MAX_ACQI_PER_ULSF) && (RG_SCH_APCQI_NO != ue->dl.reqForCqi)) 
21367    {
21368 #ifdef LTE_ADV
21369       U8    idx = 0; 
21370       /* Send two bits cqireq field if more than one cells are configured else one*/
21371       for (idx = 1;idx < CM_LTE_MAX_CELLS;idx++)
21372       {
21373          if (ue->cellInfo[idx] != NULLP)
21374          {
21375             ue->ul.rarGrnt.cqiReqBit = ue->dl.reqForCqi;
21376             break;
21377          }
21378       }
21379       if (idx == CM_LTE_MAX_CELLS)
21380 #endif
21381       {
21382          ue->ul.rarGrnt.cqiReqBit = ue->dl.reqForCqi;
21383       }
21384       ue->dl.reqForCqi = RG_SCH_APCQI_NO;
21385       sf->numACqiCount++;
21386    }
21387    else
21388    {
21389       ue->ul.rarGrnt.cqiReqBit = 0;
21390    }
21391    /* Attach Ho/Po allocation to RAR Rsp cont free Lst */
21392    cmLListAdd2Tail(raRspLst, &ue->ul.rarGrnt.raRspLnk);
21393    ue->ul.rarGrnt.raRspLnk.node = (PTR)ue;
21394
21395    RETVOID;
21396 }
21397
21398 /**
21399  * @brief This is a utility function to set the fields in
21400  * an UL harq proc which is identified for non-adaptive retx
21401  *
21402  * @details
21403  *
21404  *     Function: rgSCHCmnUlNonadapRetx 
21405  *     Purpose:  Sets the fields in UL Harq  proc for non-adaptive retx 
21406  *
21407  * @param[in]  RgSchCmnUlCell  *cellUl 
21408  * @param[out] RgSchUlAlloc    *alloc
21409  * @param[in]  U8              idx 
21410  * @return  Void
21411  *
21412  **/
21413 #ifdef ANSI
21414 PRIVATE Void rgSCHCmnUlNonadapRetx
21415 (
21416 RgSchCmnUlCell  *cellUl,
21417 RgSchUlAlloc    *alloc,
21418 U8              idx
21419 )
21420 #else
21421 PRIVATE Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
21422 RgSchCmnUlCell  *cellUl;
21423 RgSchUlAlloc    *alloc;
21424 U8              idx;
21425 #endif
21426 {
21427    TRC2(rgSCHCmnUlNonadapRetx);
21428    rgSCHUhmRetx(alloc->hqProc, alloc);
21429
21430    /* Update alloc to retx */
21431    alloc->hqProc->isRetx = TRUE;
21432    alloc->hqProc->ulSfIdx = cellUl->reTxIdx[idx];
21433
21434    if (alloc->hqProc->rvIdx != 0)
21435    {
21436       alloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl[alloc->hqProc->rvIdx];
21437    }
21438    else
21439    {
21440       alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
21441    }
21442    alloc->grnt.isRtx = TRUE;
21443    alloc->pdcch = NULLP;
21444    RETVOID;
21445 }
21446
21447 /**
21448  * @brief Check if 2 allocs overlap
21449  *
21450  * @details
21451  *
21452  *     Function : rgSCHCmnUlAllocsOvrLap
21453  *
21454  *      - Return TRUE if alloc1 and alloc2 overlap.
21455  *
21456  *  @param[in]  RgSchUlAlloc  *alloc1
21457  *  @param[in]  RgSchUlAlloc  *alloc2
21458  *  @return  Bool
21459  **/
21460 #ifdef ANSI
21461 PRIVATE Bool rgSCHCmnUlAllocsOvrLap
21462 (
21463 RgSchUlAlloc    *alloc1,
21464 RgSchUlAlloc    *alloc2
21465 )
21466 #else
21467 PRIVATE Bool rgSCHCmnUlAllocsOvrLap(alloc1, alloc2)
21468 RgSchUlAlloc    *alloc1;
21469 RgSchUlAlloc    *alloc2;
21470 #endif
21471 {
21472
21473    TRC2(rgSCHCmnUlAllocsOvrLap);
21474
21475    if (((alloc1->sbStart >= alloc2->sbStart) &&
21476          (alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
21477         ((alloc2->sbStart >= alloc1->sbStart) &&
21478          (alloc2->sbStart <= alloc1->sbStart + alloc1->numSb-1)))
21479    {
21480       RETVALUE(TRUE);
21481    }
21482    RETVALUE(FALSE);
21483 }
21484
21485 /**
21486  * @brief Copy allocation Info from src to dst.
21487  *
21488  * @details
21489  *
21490  *     Function : rgSCHCmnUlCpyAllocInfo
21491  *
21492  *      - Copy allocation Info from src to dst.
21493  *
21494  *  @param[in]  RgSchUlAlloc  *srcAlloc
21495  *  @param[in]  RgSchUlAlloc  *dstAlloc
21496  *  @return  Void
21497  **/
21498 #ifdef ANSI
21499 PRIVATE Void rgSCHCmnUlCpyAllocInfo
21500 (
21501 RgSchCellCb     *cell,
21502 RgSchUlAlloc    *srcAlloc,
21503 RgSchUlAlloc    *dstAlloc
21504 )
21505 #else
21506 PRIVATE Void rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc)
21507 RgSchCellCb     *cell;
21508 RgSchUlAlloc    *srcAlloc;
21509 RgSchUlAlloc    *dstAlloc;
21510 #endif
21511 {
21512    RgSchCmnUlUe *ueUl;
21513    TRC2(rgSCHCmnUlCpyAllocInfo);
21514
21515    dstAlloc->grnt = srcAlloc->grnt;
21516    dstAlloc->hqProc = srcAlloc->hqProc;
21517    /* Fix : syed During UE context release, hqProc->alloc
21518     * was pointing to srcAlloc instead of dstAlloc and
21519     * freeing from incorrect sf->allocDb was
21520     * corrupting the list. */
21521     /* In case of SPS Occasion Allocation is done in advance and 
21522        at a later time Hq Proc is linked. Hence HqProc
21523        pointer in alloc shall be NULL */
21524 #ifdef LTEMAC_SPS
21525    if (dstAlloc->hqProc)
21526 #endif
21527    {
21528       dstAlloc->hqProc->alloc = dstAlloc;
21529    }
21530    dstAlloc->ue = srcAlloc->ue;
21531    dstAlloc->rnti = srcAlloc->rnti;
21532    dstAlloc->forMsg3 = srcAlloc->forMsg3;
21533    dstAlloc->raCb  = srcAlloc->raCb;
21534    dstAlloc->pdcch = srcAlloc->pdcch;
21535    /* Fix : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
21536    if (dstAlloc->ue)
21537    {
21538       ueUl = RG_SCH_CMN_GET_UL_UE(dstAlloc->ue,cell);
21539       ueUl->alloc.alloc = dstAlloc;
21540 #ifdef LTEMAC_SPS
21541       if (dstAlloc->ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
21542       {
21543          if((dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc != NULLP)
21544                && (dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc == srcAlloc))
21545          {
21546             dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc = dstAlloc;
21547          }
21548       }
21549 #endif
21550    }
21551
21552    RETVOID;
21553 }
21554
21555
21556 /**
21557  * @brief Update TX and RETX subframe's allocation
21558  *        markings.
21559  *
21560  * @details
21561  *
21562  *     Function : rgSCHCmnUlInsAllocFrmNewSf2OldSf
21563  *
21564  *      - Release all preassigned allocations of newSf and merge
21565  *        them to oldSf.
21566  *      - If alloc of newSf collide with one or more allocs of oldSf
21567  *        - mark all such allocs of oldSf for Adaptive Retx.
21568  *      - Swap the alloc and hole DB references of oldSf and newSf.
21569  *
21570  *  @param[in]  RgSchCellCb   *cell
21571  *  @param[in]  RgSchUlSf     *newSf
21572  *  @param[in]  RgSchUlSf     *oldSf
21573  *  @param[in]  RgSchUlAlloc  *srcAlloc
21574  *  @return  Void
21575  **/
21576 #ifdef ANSI
21577 PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf
21578 (
21579 RgSchCellCb     *cell,
21580 RgSchUlSf       *newSf,
21581 RgSchUlSf       *oldSf,
21582 RgSchUlAlloc    *srcAlloc
21583 )
21584 #else
21585 PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, srcAlloc)
21586 RgSchCellCb     *cell;
21587 RgSchUlSf       *newSf;
21588 RgSchUlSf       *oldSf;
21589 RgSchUlAlloc    *srcAlloc;
21590 #endif
21591 {
21592    RgSchUlAlloc   *alloc, *dstAlloc, *nxtAlloc;
21593
21594    /* MS_WORKAROUND ccpu00120827 */
21595    RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
21596    U8 remAllocs;
21597    TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
21598
21599    if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
21600    {
21601       do
21602       {
21603          nxtAlloc = rgSCHUtlUlAllocNxt(oldSf, alloc);
21604          /* If there is an overlap between alloc and srcAlloc
21605           * then alloc is marked for Adaptive retx and it is released
21606           * from txSf */
21607          if (rgSCHCmnUlAllocsOvrLap(alloc, srcAlloc) == TRUE)
21608          {
21609             rgSCHCmnUlUpdAllocRetx(cell, alloc);
21610             rgSCHUtlUlAllocRls(oldSf, alloc);
21611          }
21612          /* No further allocs spanning the srcAlloc subbands */
21613          if (srcAlloc->sbStart + srcAlloc->numSb - 1  <= alloc->sbStart)
21614          {
21615             break;
21616          }
21617       } while ((alloc = nxtAlloc) != NULLP);
21618    }
21619
21620    /* After freeing all the colliding allocs, request for an allocation
21621     * specifying the start and numSb with in txSf. This function should
21622     * always return positively with a nonNULL dstAlloc */
21623     /* MS_WORKAROUND ccpu00120827 */
21624    remAllocs = schCmnCell->ul.maxAllocPerUlSf - *oldSf->allocCountRef;
21625    if (!remAllocs)
21626    {
21627       /* Fix : If oldSf already has max Allocs then release the
21628        * old RETX alloc to make space for new alloc of newSf.
21629        * newSf allocs(i.e new Msg3s) are given higher priority
21630        * over retx allocs. */      
21631       if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
21632       {
21633          do
21634          {
21635             nxtAlloc = rgSCHUtlUlAllocNxt(oldSf, alloc);           
21636             if (!alloc->mrgdNewTxAlloc)
21637             {
21638                /* If alloc is for RETX */                   
21639                /* TODO: Incase of this ad also in case of choosing
21640                 * and alloc for ADAP RETX, we need to send ACK for
21641                 * the corresponding alloc in PHICH */               
21642 #ifndef EMTC_ENABLE
21643                rgSCHCmnUlFreeAllocation(cell, oldSf, alloc);
21644 #else
21645                rgSCHCmnUlFreeAllocation(cell, oldSf, alloc,FALSE);
21646 #endif
21647                break;
21648             }               
21649          }while((alloc = nxtAlloc) != NULLP);
21650       }
21651    }
21652    dstAlloc = rgSCHUtlUlGetSpfcAlloc(oldSf, srcAlloc->sbStart, srcAlloc->numSb);
21653 #ifdef ERRCLS_KW
21654    /* This should never happen */
21655    if (dstAlloc == NULLP)
21656    {
21657       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
21658          "rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
21659          srcAlloc->rnti);
21660       RETVOID;
21661    }
21662 #endif
21663    /* Copy the srcAlloc's state information in to dstAlloc */
21664    rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc);
21665    /* Set new Tx merged Alloc Flag to TRUE, indicating that this
21666     * alloc shall not be processed for non-adaptive retransmission */
21667    dstAlloc->mrgdNewTxAlloc = TRUE;
21668    RETVOID;
21669 }
21670
21671 /**
21672  * @brief Merge all allocations of newSf to oldSf.
21673  *
21674  * @details
21675  *
21676  *     Function : rgSCHCmnUlMergeSfAllocs
21677  *
21678  *      - Merge all allocations of newSf to oldSf.
21679  *      - If newSf's alloc collides with oldSf's alloc
21680  *        then oldSf's alloc is marked for adaptive Retx
21681  *        and is released from oldSf to create space for
21682  *        newSf's alloc.
21683  *
21684  *  @param[in]  RgSchCellCb  *cell
21685  *  @param[in]  RgSchUlSf    *oldSf
21686  *  @param[in]  RgSchUlSf    *newSf
21687  *  @return  Void
21688  **/
21689 #ifdef ANSI
21690 PRIVATE Void rgSCHCmnUlMergeSfAllocs
21691 (
21692 RgSchCellCb  *cell,
21693 RgSchUlSf    *oldSf,
21694 RgSchUlSf    *newSf
21695 )
21696 #else
21697 PRIVATE Void rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf)
21698 RgSchCellCb  *cell;
21699 RgSchUlSf    *oldSf;
21700 RgSchUlSf    *newSf;
21701 #endif
21702 {
21703    RgSchUlAlloc    *alloc, *nxtAlloc;
21704    TRC2(rgSCHCmnUlMergeSfAllocs);
21705    UNUSED(cell);
21706
21707    /* Merge each alloc of newSf in to oldSf
21708     * and release it from newSf */
21709    if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
21710    {
21711       do
21712       {
21713          nxtAlloc = rgSCHUtlUlAllocNxt(newSf, alloc);
21714          rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, alloc);
21715          rgSCHUtlUlAllocRls(newSf, alloc);
21716       } while((alloc = nxtAlloc) != NULLP);
21717    }
21718    RETVOID;
21719 }
21720
21721 /**
21722  * @brief Swap Hole/Alloc DB context of newSf and oldSf.
21723  *
21724  * @details
21725  *
21726  *     Function : rgSCHCmnUlSwapSfAllocs
21727  *
21728  *      - Swap Hole/Alloc DB context of newSf and oldSf.
21729  *
21730  *  @param[in]  RgSchCellCb  *cell
21731  *  @param[in]  RgSchUlSf    *oldSf
21732  *  @param[in]  RgSchUlSf    *newSf
21733  *  @return  Void
21734  **/
21735 #ifdef ANSI
21736 PRIVATE Void rgSCHCmnUlSwapSfAllocs
21737 (
21738 RgSchCellCb  *cell,
21739 RgSchUlSf    *oldSf,
21740 RgSchUlSf    *newSf
21741 )
21742 #else
21743 PRIVATE Void rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf)
21744 RgSchCellCb  *cell;
21745 RgSchUlSf    *oldSf;
21746 RgSchUlSf    *newSf;
21747 #endif
21748 {
21749    RgSchUlAllocDb *tempAllocDb  = newSf->allocDb;
21750    RgSchUlHoleDb  *tempHoleDb   = newSf->holeDb;
21751    U8              tempAvailSbs = newSf->availSubbands;
21752
21753    TRC2(rgSCHCmnUlSwapSfAllocs);
21754    UNUSED(cell);
21755
21756    newSf->allocDb       = oldSf->allocDb;
21757    newSf->holeDb        = oldSf->holeDb;
21758    newSf->availSubbands = oldSf->availSubbands;
21759
21760    oldSf->allocDb = tempAllocDb;
21761    oldSf->holeDb  = tempHoleDb;
21762    oldSf->availSubbands = tempAvailSbs;
21763       
21764    /* Fix ccpu00120610*/
21765    newSf->allocCountRef = &newSf->allocDb->count;
21766    oldSf->allocCountRef = &oldSf->allocDb->count;
21767    RETVOID;
21768 }
21769
21770 /**
21771  * @brief Perform non-adaptive RETX for non-colliding allocs.
21772  *
21773  * @details
21774  *
21775  *     Function : rgSCHCmnUlPrcNonAdptRetx
21776  *
21777  *      - Perform non-adaptive RETX for non-colliding allocs.
21778  *
21779  *  @param[in]  RgSchCellCb  *cell
21780  *  @param[in]  RgSchUlSf    *newSf
21781  *  @param[in]  U8           idx
21782  *  @return  Void
21783  **/
21784 #ifdef ANSI
21785 PRIVATE Void rgSCHCmnUlPrcNonAdptRetx
21786 (
21787 RgSchCellCb  *cell,
21788 RgSchUlSf    *newSf,
21789 U8           idx
21790 )
21791 #else
21792 PRIVATE Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
21793 RgSchCellCb  *cell;
21794 RgSchUlSf    *newSf;
21795 U8           idx;
21796 #endif
21797 {
21798    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21799    RgSchUlAlloc    *alloc, *nxtAlloc;
21800    TRC2(rgSCHCmnUlPrcNonAdptRetx);
21801
21802    /* perform non-adaptive retx allocation(adjustment) */
21803    if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
21804    {
21805       do
21806       {
21807          nxtAlloc = rgSCHUtlUlAllocNxt(newSf, alloc);
21808          /* A merged new TX alloc, reset the state and skip */
21809          if (alloc->mrgdNewTxAlloc)
21810          {
21811             alloc->mrgdNewTxAlloc = FALSE;
21812             continue;
21813          }
21814          
21815
21816          rgSCHCmnUlNonadapRetx(cellUl, alloc, idx);
21817
21818       } while((alloc = nxtAlloc) != NULLP);
21819    }
21820    RETVOID;
21821 }
21822
21823 /**
21824  * @brief Update TX and RETX subframe's allocation
21825  *        markings.
21826  *
21827  * @details
21828  *
21829  *     Function : rgSCHCmnUlPrfmSfMerge
21830  *
21831  *      - Release all preassigned allocations of newSf and merge
21832  *        them to oldSf.
21833  *      - If alloc of newSf collide with one or more allocs of oldSf
21834  *        - mark all such allocs of oldSf for Adaptive Retx.
21835  *      - Swap the alloc and hole DB references of oldSf and newSf.
21836  *      - The allocs which did not collide with pre-assigned msg3
21837  *        allocs are marked for non-adaptive RETX.
21838  *
21839  *  @param[in]  RgSchCellCb  *cell
21840  *  @param[in]  RgSchUlSf    *oldSf
21841  *  @param[in]  RgSchUlSf    *newSf
21842  *  @param[in]  U8           idx 
21843  *  @return  Void
21844  **/
21845 #ifdef ANSI
21846 PRIVATE Void rgSCHCmnUlPrfmSfMerge
21847 (
21848 RgSchCellCb  *cell,
21849 RgSchUlSf    *oldSf,
21850 RgSchUlSf    *newSf,
21851 U8           idx
21852 )
21853 #else
21854 PRIVATE Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
21855 RgSchCellCb  *cell;
21856 RgSchUlSf    *oldSf;
21857 RgSchUlSf    *newSf;
21858 U8           idx;
21859 #endif
21860 {
21861    TRC2(rgSCHCmnUlPrfmSfMerge);
21862    /* Preassigned resources for msg3 in newSf.
21863     * Hence do adaptive retx for all NACKED TXs */
21864    rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
21865    /* swap alloc and hole DBs of oldSf and newSf. */
21866    rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf);
21867    /* Here newSf has the resultant merged allocs context */
21868    /* Perform non-adaptive RETX for non-colliding allocs */
21869    rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx);
21870    
21871    RETVOID;
21872 }
21873
21874 /**
21875  * @brief Update TX and RETX subframe's allocation
21876  *        markings.
21877  *
21878  * @details
21879  *
21880  *     Function : rgSCHCmnUlRmvCmpltdAllocs
21881  *
21882  *      - Free all Transmission which are ACKED
21883  *        OR for which MAX retransmission have
21884  *        occurred.
21885  *
21886  *
21887  *  @param[in]  RgSchCellCb    *cell,
21888  *  @param[in]  RgSchUlSf      *sf
21889  *  @return  Void
21890  **/
21891 #ifdef ANSI
21892 PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs
21893 (
21894 RgSchCellCb    *cell,
21895 RgSchUlSf      *sf
21896 )
21897 #else
21898 PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs(cell, sf)
21899 RgSchCellCb    *cell;
21900 RgSchUlSf      *sf;
21901 #endif
21902 {
21903    RgSchUlAlloc    *alloc, *nxtAlloc;
21904    TRC2(rgSCHCmnUlRmvCmpltdAllocs);
21905
21906    if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
21907    {
21908       RETVOID;
21909    }
21910    do
21911    {
21912       nxtAlloc = rgSCHUtlUlAllocNxt(sf, alloc);
21913 #ifdef UL_ADPT_DBG      
21914       printf("rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.subframe,alloc->hqProc->remTx, alloc->grnt.hqProcId);
21915 #endif
21916       alloc->hqProc->rcvdCrcInd = TRUE;
21917       if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
21918       {
21919
21920         /* SR_RACH_STATS : MSG 3 MAX RETX FAIL*/
21921          if ((alloc->forMsg3 == TRUE) && (alloc->hqProc->remTx == 0))
21922          {
21923             rgNumMsg3FailMaxRetx++;
21924 #ifdef TENB_STATS
21925             cell->tenbStats->sch.msg3Fail++;
21926 #endif
21927          }
21928
21929 #ifdef MAC_SCH_STATS
21930     if(alloc->ue != NULLP)
21931     {
21932        /* access from ulHarqProc*/
21933        RgSchUeCb       *ueCb  = alloc->ue;
21934        RgSchCmnUe      *cmnUe = (RgSchCmnUe*)ueCb->sch;
21935        RgSchCmnUlUe    *ulUe  = &(cmnUe->ul);
21936        U8              cqi    = ulUe->crntUlCqi[0];  
21937        U16             numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
21938
21939        hqRetxStats.ulCqiStat[(cqi - 1)].mcs = alloc->grnt.iMcs;
21940
21941        switch (numUlRetx)
21942        {
21943           case 1:
21944              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_1++;
21945              break;
21946           case 2:
21947              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_2++;
21948              break;
21949          case 3:
21950             hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_3++;
21951             break;
21952          case 4:
21953             hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_4++;
21954             break;
21955       }
21956       hqRetxStats.ulCqiStat[(cqi - 1)].totalTx = \
21957              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_1 + \
21958             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_2 * 2) + \
21959             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_3 * 3) + \
21960             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_4 * 4);
21961    }
21962
21963 #endif /*MAC_SCH_STATS*/
21964          rgSCHCmnUlFreeAllocation(cell, sf, alloc);
21965       }
21966       /*ccpu00106104 MOD added check for AckNackRep */
21967       /*added check for acknack so that adaptive retx considers ue
21968        inactivity due to ack nack repetition*/
21969       else if((alloc->ue != NULLP) && (TRUE != alloc->forMsg3))
21970       {
21971         rgSCHCmnUlUpdAllocRetx(cell, alloc);
21972         rgSCHUtlUlAllocRls(sf, alloc);
21973       }
21974    } while ((alloc = nxtAlloc) != NULLP);
21975
21976    RETVOID;
21977 }
21978
21979 /**
21980  * @brief Update an uplink subframe.
21981  *
21982  * @details
21983  *
21984  *     Function : rgSCHCmnRlsUlSf
21985  *
21986  *     For each allocation
21987  *      - if no more tx needed
21988  *         - Release allocation
21989  *      - else
21990  *         - Perform retransmission
21991  *
21992  *  @param[in]  RgSchUlSf *sf
21993  *  @param[in]  U8        idx 
21994  *  @return  Void
21995  **/
21996 #ifdef ANSI
21997 PUBLIC Void rgSCHCmnRlsUlSf
21998 (
21999 RgSchCellCb    *cell,
22000 U8              idx
22001 )
22002 #else
22003 PUBLIC Void rgSCHCmnRlsUlSf(cell, idx)
22004 RgSchCellCb    *cell;
22005 U8              idx;
22006 #endif
22007 {
22008    TRC2(rgSCHCmnRlsUlSf);
22009
22010    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22011    
22012    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO) 
22013    {
22014       RgSchUlSf   *oldSf  = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
22015
22016       /* Initialize the reTxLst of UL HqProcs for RETX subframe */
22017       if (rgSCHUtlUlAllocFirst(oldSf) == NULLP)
22018       {
22019          RETVOID;
22020       }
22021       /* Release all completed TX allocs from sf */
22022       rgSCHCmnUlRmvCmpltdAllocs(cell, oldSf);
22023
22024       oldSf->numACqiCount = 0;
22025    }
22026    RETVOID;
22027 }
22028
22029 /**
22030  * @brief Handle uplink allocation for retransmission.
22031  *
22032  * @details
22033  *
22034  *     Function : rgSCHCmnUlUpdAllocRetx
22035  *
22036  *     - Perform adaptive retransmission
22037  *
22038  *  @param[in]  RgSchUlSf *sf
22039  *  @param[in]  RgSchUlAlloc  *alloc
22040  *  @return  Void
22041  **/
22042 #ifdef ANSI
22043 PRIVATE Void rgSCHCmnUlUpdAllocRetx
22044 (
22045 RgSchCellCb    *cell,
22046 RgSchUlAlloc   *alloc
22047 )
22048 #else
22049 PRIVATE Void rgSCHCmnUlUpdAllocRetx(cell, alloc)
22050 RgSchCellCb    *cell;
22051 RgSchUlAlloc   *alloc;
22052 #endif
22053 {
22054    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
22055
22056    TRC2(rgSCHCmnUlUpdAllocRetx);
22057
22058    alloc->hqProc->reTxAlloc.rnti    =  alloc->rnti;
22059    alloc->hqProc->reTxAlloc.numSb   =  alloc->numSb;
22060    alloc->hqProc->reTxAlloc.iMcs   =  alloc->grnt.iMcs;
22061 #ifdef RG_5GTF
22062    alloc->hqProc->reTxAlloc.dciFrmt =  alloc->grnt.dciFrmt;
22063    alloc->hqProc->reTxAlloc.numLyr   =  alloc->grnt.numLyr;
22064    alloc->hqProc->reTxAlloc.vrbgStart =  alloc->grnt.vrbgStart;
22065    alloc->hqProc->reTxAlloc.numVrbg   =  alloc->grnt.numVrbg;
22066    alloc->hqProc->reTxAlloc.modOdr   =  alloc->grnt.modOdr;
22067 #endif
22068    //iTbs = rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs);
22069    //iTbs = alloc->grnt.iMcs;
22070    //RGSCH_ARRAY_BOUND_CHECK( 0, rgTbSzTbl[0], iTbs);
22071    alloc->hqProc->reTxAlloc.tbSz = alloc->grnt.datSz;
22072       //rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1]/8;
22073    alloc->hqProc->reTxAlloc.ue      = alloc->ue;
22074    alloc->hqProc->reTxAlloc.forMsg3 = alloc->forMsg3;
22075    alloc->hqProc->reTxAlloc.raCb = alloc->raCb;
22076
22077    /* Set as retransmission is pending */
22078    alloc->hqProc->isRetx = TRUE;
22079    alloc->hqProc->alloc = NULLP;
22080    alloc->hqProc->ulSfIdx = RGSCH_INVALID_INFO;
22081 #ifdef UL_ADPT_DBG  
22082    printf("Adding Harq Proc Id in the retx list  hqProcId %d \n",alloc->grnt.hqProcId); 
22083 #endif
22084    cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
22085    alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
22086    RETVOID;
22087 }
22088
22089 /**
22090  * @brief Attempts allocation for msg3s for which ADAP retransmissions
22091  *     are required.
22092  *
22093  * @details
22094  *
22095  *     Function : rgSCHCmnUlAdapRetxAlloc
22096  *
22097  *     Attempts allocation for msg3s for which ADAP retransmissions
22098  *     are required.
22099  *
22100  *  @param[in]  RgSchCellCb       *cell
22101  *  @param[in]  RgSchUlSf         *sf
22102  *  @param[in]  RgSchUlHqProcCb   *proc;
22103  *  @param[in]  RgSchUlHole       *hole;
22104  *  @return  U8
22105  **/
22106 #ifdef ANSI
22107 PRIVATE Bool rgSCHCmnUlAdapRetxAlloc
22108 (
22109 RgSchCellCb       *cell,
22110 RgSchUlSf         *sf,
22111 RgSchUlHqProcCb   *proc,
22112 RgSchUlHole       *hole
22113 )
22114 #else
22115 PRIVATE Bool rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole)
22116 RgSchCellCb       *cell;
22117 RgSchUlSf         *sf;
22118 RgSchUlHqProcCb   *proc;
22119 RgSchUlHole       *hole;
22120 #endif
22121 {
22122    U8              numSb = proc->reTxAlloc.numSb;
22123    U8              iMcs  = proc->reTxAlloc.iMcs;
22124    CmLteTimingInfo frm = cell->crntTime;
22125    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22126    RgSchDlSf       *dlSf;
22127    RgSchPdcch      *pdcch;
22128    RgSchUlAlloc    *alloc;
22129    TRC2(rgSCHCmnUlAdapRetxAlloc);
22130
22131    /* Fetch PDCCH for msg3 */
22132    /* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
22133    /* Introduced timing delta for UL control */
22134    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
22135    dlSf = rgSCHUtlSubFrmGet(cell, frm);
22136    pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
22137    if (pdcch == NULLP)
22138    {
22139       RETVALUE(FALSE);
22140    }
22141
22142    /* Fetch UL Alloc for msg3 */
22143    if (numSb <= hole->num)
22144    {
22145       alloc                = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
22146       
22147       /* KWork fix */
22148          if(alloc == NULLP)
22149          {
22150             rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
22151             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
22152                   "UL Alloc fail for msg3 retx for rnti: %d\n", 
22153                   proc->reTxAlloc.rnti);
22154             RETVALUE(FALSE);
22155          }
22156
22157       rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
22158       alloc->grnt.iMcs     = iMcs;
22159       alloc->grnt.datSz    = proc->reTxAlloc.tbSz;
22160 #ifdef RG_5GTF
22161 #else
22162       //RG_SCH_UL_MCS_TO_MODODR(iMcs, alloc->grnt.modOdr);
22163 #endif
22164       /* Fill UL Alloc for msg3 */
22165       /* RACHO : setting nDmrs to 0 and UlDelaybit to 0*/
22166       alloc->grnt.nDmrs    = 0;
22167       alloc->grnt.hop      = 0;
22168       alloc->grnt.delayBit = 0;
22169       alloc->grnt.isRtx    = TRUE;
22170       proc->ulSfIdx        = cellUl->schdIdx;
22171 #ifdef RG_5GTF
22172       proc->schdTime = cellUl->schdTime;
22173       alloc->grnt.hqProcId = proc->procId;
22174       alloc->grnt.dciFrmt = proc->reTxAlloc.dciFrmt;
22175       alloc->grnt.numLyr = proc->reTxAlloc.numLyr;
22176       alloc->grnt.vrbgStart = proc->reTxAlloc.vrbgStart;
22177       alloc->grnt.numVrbg = proc->reTxAlloc.numVrbg;
22178       alloc->grnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, alloc->grnt.vrbgStart, alloc->grnt.numVrbg);
22179       alloc->grnt.modOdr = proc->reTxAlloc.modOdr;
22180
22181       /* TODO : Hardcoding these as of now */
22182       alloc->grnt.hop = 0;
22183       alloc->grnt.SCID = 0;
22184       alloc->grnt.xPUSCHRange = MAX_5GTF_XPUSCH_RANGE;
22185       alloc->grnt.PMI = 0;
22186       alloc->grnt.uciOnxPUSCH = 0;
22187 #endif
22188       alloc->rnti          = proc->reTxAlloc.rnti;
22189       /* Fix : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
22190       alloc->ue            = proc->reTxAlloc.ue;
22191       alloc->pdcch         = pdcch;
22192       alloc->forMsg3       = proc->reTxAlloc.forMsg3;
22193       alloc->raCb          = proc->reTxAlloc.raCb;
22194       alloc->hqProc        = proc;
22195       alloc->isAdaptive    = TRUE;
22196 #ifdef LTE_L2_MEAS
22197       sf->totPrb  += alloc->grnt.numRb;
22198 #endif
22199       /* FIX : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
22200       if (alloc->raCb)
22201       {
22202          alloc->raCb->msg3Grnt= alloc->grnt;
22203 #ifndef LTE_TDD
22204          /* To the crntTime, add the time at which UE will
22205           * actually send MSG3 */
22206          alloc->raCb->msg3AllocTime = cell->crntTime;
22207          RGSCH_INCR_SUB_FRAME(alloc->raCb->msg3AllocTime, RG_SCH_CMN_MIN_RETXMSG3_RECP_INTRVL);
22208 #else
22209          alloc->raCb->msg3AllocTime =  cellUl->schdTime;
22210 #endif
22211          rgSCHCmnUlAdapRetx(alloc, proc);
22212          /* Fill PDCCH with alloc info */
22213          pdcch->rnti                           = alloc->rnti;
22214          pdcch->dci.dciFormat                  = TFU_DCI_FORMAT_0;
22215          pdcch->dci.u.format0Info.hoppingEnbld = alloc->grnt.hop;
22216          pdcch->dci.u.format0Info.rbStart      = alloc->grnt.rbStart;
22217          pdcch->dci.u.format0Info.numRb        = alloc->grnt.numRb;
22218          pdcch->dci.u.format0Info.mcs          = alloc->grnt.iMcsCrnt;
22219          pdcch->dci.u.format0Info.ndi          = alloc->hqProc->ndi;
22220          pdcch->dci.u.format0Info.nDmrs        = alloc->grnt.nDmrs;
22221          pdcch->dci.u.format0Info.tpcCmd       = alloc->grnt.tpc;
22222
22223 #ifdef LTE_TDD
22224 #ifdef TFU_TDD
22225          /* ulIdx setting for cfg 0 shall be appropriately fixed thru ccpu00109015 */
22226          pdcch->dci.u.format0Info.ulIdx = RG_SCH_ULIDX_MSB;
22227          pdcch->dci.u.format0Info.dai = RG_SCH_MAX_DAI_IDX;
22228 #endif
22229 #endif
22230          pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_0];
22231       }
22232       else
22233       {
22234          RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(alloc->ue,cell);
22235 #ifdef TFU_UPGRADE
22236          alloc->ue->initNumRbs = (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
22237 #endif
22238 #ifdef LTE_L2_MEAS
22239          ue->ul.nPrb = alloc->grnt.numRb;
22240 #endif
22241          ueUl->alloc.alloc = alloc;
22242          /* FIx: Removed the call to rgSCHCmnUlAdapRetx */
22243          rgSCHCmnUlUeFillAllocInfo(cell, alloc->ue);
22244          /* Setting csireq as false for Adaptive Retx*/
22245          ueUl->alloc.alloc->pdcch->dci.u.format0Info.cqiReq = RG_SCH_APCQI_NO;
22246          pdcch->dciNumOfBits = alloc->ue->dciSize.cmnSize[TFU_DCI_FORMAT_0];
22247       }
22248       /* Reset as retransmission is done */
22249       proc->isRetx = FALSE;
22250    }
22251    else /* Intg fix */
22252    {
22253       rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
22254       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
22255                "Num SB not suffiecient for adap retx for rnti: %d", 
22256                proc->reTxAlloc.rnti);
22257       RETVALUE(FALSE);
22258    }
22259    RETVALUE(TRUE);
22260 }
22261
22262 /* Fix: syed Adaptive Msg3 Retx crash. */
22263 /**
22264  * @brief Releases all Adaptive Retx HqProcs which failed for
22265  *        allocations in this scheduling occassion.
22266  *
22267  * @details
22268  *
22269  *     Function : rgSCHCmnUlSfRlsRetxProcs
22270  *
22271  *
22272  *  @param[in]  RgSchCellCb *cell
22273  *  @param[in]  RgSchUlSf   *sf
22274  *  @return  U8
22275  **/
22276 #ifdef ANSI
22277 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs
22278 (
22279 RgSchCellCb *cell,
22280 RgSchUlSf   *sf
22281 )
22282 #else
22283 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs(cell, sf)
22284 RgSchCellCb *cell;
22285 RgSchUlSf   *sf;
22286 #endif
22287 {
22288    CmLListCp         *cp;
22289    CmLList           *node;
22290    RgSchUlHqProcCb   *proc;
22291    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22292
22293    TRC2(rgSCHCmnUlSfRlsRetxProcs);
22294
22295    cp = &(cellUl->reTxLst);
22296    node = cp->first;
22297    while (node)
22298    {
22299       proc  = (RgSchUlHqProcCb *)node->node;
22300       node = node->next;
22301       /* ccpu00137834 : Deleting reTxLnk from the respective reTxLst */
22302       cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
22303       proc->reTxLnk.node = (PTR)NULLP;
22304    }
22305    RETVOID;
22306 }
22307    
22308
22309 /**
22310  * @brief Attempts allocation for UEs for which retransmissions
22311  *     are required.
22312  *
22313  * @details
22314  *
22315  *     Function : rgSCHCmnUlSfReTxAllocs
22316  *
22317  *     Attempts allocation for UEs for which retransmissions
22318  *     are required.
22319  *
22320  *  @param[in]  RgSchCellCb *cell
22321  *  @param[in]  RgSchUlSf   *sf
22322  *  @return  U8
22323  **/
22324 #ifdef ANSI
22325 PRIVATE Void rgSCHCmnUlSfReTxAllocs
22326 (
22327 RgSchCellCb *cell,
22328 RgSchUlSf   *sf
22329 )
22330 #else
22331 PRIVATE Void rgSCHCmnUlSfReTxAllocs(cell, sf)
22332 RgSchCellCb *cell;
22333 RgSchUlSf   *sf;
22334 #endif
22335 {
22336    CmLListCp         *cp;
22337    CmLList           *node;
22338    RgSchUlHqProcCb   *proc;
22339    RgSchUlHole       *hole;
22340    RgSchUeCb         *ue;
22341    RgSchCmnCell      *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
22342    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22343    TRC2(rgSCHCmnUlSfReTxAllocs);
22344
22345    cp = &(cellUl->reTxLst);
22346    node = cp->first;
22347    while ((node))
22348    {
22349       proc  = (RgSchUlHqProcCb *)node->node;
22350       ue = proc->reTxAlloc.ue;
22351       node = node->next;
22352       /*ccpu00106104 MOD added check for AckNackRep */
22353       /*added check for acknack so that adaptive retx considers ue
22354        inactivity due to ack nack repetition*/
22355       if((ue != NULLP) &&
22356             ((ue->measGapCb.isMeasuring == TRUE)||
22357                (ue->ackNakRepCb.isAckNakRep == TRUE)))
22358       {
22359          continue;
22360       }
22361       /* Fix for ccpu00123917: Check if maximum allocs per UL sf have been exhausted */
22362       if (((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
22363             || (sf->allocDb->count == schCmnCell->ul.maxAllocPerUlSf))
22364       {
22365          /* No more UL BW then return */
22366          break;
22367       }
22368       /* perform adaptive retx for UE's */
22369       if (rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole) == FALSE)
22370       {
22371          continue;
22372       }
22373       /* ccpu00137834 : Deleting reTxLnk from the respective reTxLst */
22374       cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
22375       /* Fix: syed Adaptive Msg3 Retx crash. */
22376       proc->reTxLnk.node = (PTR)NULLP;
22377    }
22378    RETVOID;
22379 }
22380
22381 /**
22382  * @brief Handles RB allocation for downlink.
22383  *
22384  * @details
22385  *
22386  *     Function : rgSCHCmnDlRbAlloc
22387  *
22388  *     Invoking Module Processing:
22389  *     - This function is invoked for DL RB allocation
22390  *
22391  *     Processing Steps:
22392  *     - If cell is frequency selecive,
22393  *       - Call rgSCHDlfsAllocRb().
22394  *     - else,
22395  *       - Call rgSCHCmnNonDlfsRbAlloc().
22396  *
22397  *  @param[in]  RgSchCellCb        *cell
22398  *  @param[in]  RgSchDlRbAllocInfo *allocInfo
22399  *  @return  Void
22400  **/
22401
22402 #ifdef ANSI
22403 PRIVATE Void rgSCHCmnDlRbAlloc
22404 (
22405 RgSchCellCb           *cell,
22406 RgSchCmnDlRbAllocInfo *allocInfo
22407 )
22408 #else
22409 PRIVATE Void rgSCHCmnDlRbAlloc(cell, allocInfo)
22410 RgSchCellCb           *cell;
22411 RgSchCmnDlRbAllocInfo *allocInfo;
22412 #endif
22413 {
22414    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
22415    TRC2(rgSCHCmnDlRbAlloc);
22416
22417    if (cellSch->dl.isDlFreqSel)
22418    {
22419       printf("5GTF_ERROR DLFS SCH Enabled\n");
22420       cellSch->apisDlfs->rgSCHDlfsAllocRb(cell, allocInfo);
22421    }
22422    else
22423    {
22424       rgSCHCmnNonDlfsRbAlloc(cell, allocInfo);
22425    }
22426    RETVOID;
22427 }
22428
22429 #ifdef LTEMAC_SPS
22430
22431 /**
22432  * @brief Determines number of RBGs and RBG subset sizes for the given DL
22433  * bandwidth and rbgSize
22434  *
22435  * @details
22436  *     Function : rgSCHCmnDlGetRbgInfo
22437  *
22438  *
22439  *     Processing Steps:
22440  *     - Fill-up rbgInfo data structure for given DL bandwidth and rbgSize
22441  *
22442  *   @param[in]  U8             dlTotalBw
22443  *   @param[in]  U8             dlSubsetBw
22444  *   @param[in]  U8             maxRaType1SubsetBw
22445  *   @param[in]  U8             rbgSize
22446  *   @param[out] RgSchBwRbgInfo *rbgInfo
22447  *  @return Void
22448  **/
22449 #ifdef ANSI
22450 PUBLIC Void rgSCHCmnDlGetRbgInfo
22451 (
22452 U8             dlTotalBw,
22453 U8             dlSubsetBw,
22454 U8             maxRaType1SubsetBw,
22455 U8             rbgSize,
22456 RgSchBwRbgInfo *rbgInfo
22457 )
22458 #else
22459 PUBLIC Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
22460       rbgSize, rbgInfo)
22461 U8             dlTotalBw;
22462 U8             dlSubsetBw;
22463 U8             maxRaType1SubsetBw;
22464 U8             rbgSize;
22465 RgSchBwRbgInfo *rbgInfo;
22466 #endif
22467 {
22468 #ifdef RGSCH_SPS_UNUSED
22469    U8    idx           = 0;
22470    U8    lastRbgIdx    = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
22471    U8    currRbgSize   = rbgSize;
22472    U8    subsetSizeIdx = 0;
22473    U8    subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
22474    U8    lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
22475    U8    numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
22476 #endif
22477
22478    /* Compute maximum number of SPS RBGs for the cell */
22479    rbgInfo->numRbgs =  ((dlSubsetBw + rbgSize - 1)/rbgSize);
22480
22481 #ifdef RGSCH_SPS_UNUSED
22482    /* Distribute RBGs across subsets except last RBG */
22483    for (;idx < numRaType1Rbgs - 1; ++idx)
22484    {
22485       subsetSize[subsetSizeIdx] += currRbgSize;
22486       subsetSizeIdx = (subsetSizeIdx + 1) % rbgSize;
22487    }
22488
22489    /* Computation for last RBG */
22490    if (idx == lastRbgIdx)
22491    {
22492       currRbgSize = lastRbgSize;
22493    }
22494    subsetSize[subsetSizeIdx] += currRbgSize;
22495    subsetSizeIdx = (subsetSizeIdx + 1) % rbgSize;
22496 #endif
22497
22498    /* Update the computed sizes */
22499 #ifdef RGSCH_SPS_UNUSED
22500    rbgInfo->lastRbgSize = currRbgSize;
22501 #endif
22502    rbgInfo->lastRbgSize = rbgSize - 
22503             (dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
22504 #ifdef RGSCH_SPS_UNUSED
22505    cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
22506 #endif
22507    rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
22508       dlTotalBw:(rbgInfo->numRbgs * rbgSize);
22509    rbgInfo->rbgSize = rbgSize;
22510 }
22511
22512 /**
22513  * @brief Handles RB allocation for Resource allocation type 0
22514  *
22515  * @details
22516  *
22517  *     Function : rgSCHCmnDlRaType0Alloc
22518  *
22519  *     Invoking Module Processing:
22520  *     - This function is invoked for DL RB allocation for resource allocation
22521  *     type 0
22522  *
22523  *     Processing Steps:
22524  *     - Determine the available positions in the rbgMask.
22525  *     - Allocate RBGs in the available positions.
22526  *     - Update RA Type 0, RA Type 1 and RA type 2 masks.
22527  *
22528  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22529  *  @param[in]   U8             rbsReq
22530  *  @param[in]   RgSchBwRbgInfo *rbgInfo
22531  *  @param[out]  U8             *numAllocRbs
22532  *  @param[out]  RgSchDlSfAllocInfo *resAllocInfo
22533  *  @param[in]   Bool           isPartialAlloc
22534  *
22535  *  @return  Void
22536  **/
22537
22538 #ifdef ANSI
22539 PUBLIC U8 rgSCHCmnDlRaType0Alloc
22540 (
22541 RgSchDlSfAllocInfo *allocedInfo,
22542 U8                 rbsReq,
22543 RgSchBwRbgInfo     *rbgInfo,
22544 U8                 *numAllocRbs,
22545 RgSchDlSfAllocInfo *resAllocInfo,
22546 Bool               isPartialAlloc
22547 )
22548 #else
22549 PUBLIC U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
22550       numAllocRbs, resAllocInfo, isPartialAlloc)
22551 RgSchDlSfAllocInfo *allocedInfo;
22552 U8                 rbsReq;
22553 RgSchBwRbgInfo     *rbgInfo;
22554 U8                 *numAllocRbs;
22555 RgSchDlSfAllocInfo *resAllocInfo;
22556 Bool               isPartialAlloc;
22557 #endif
22558 {
22559    /* Note: This function atttempts allocation only full allocation */
22560    U32      remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
22561    U8       type2MaskIdx, cnt, rbIdx;
22562    U8       maskSize, rbg;
22563    U8       bestNumAvailRbs = 0;
22564    U8       usedRbs = 0;
22565    U8       numAllocRbgs = 0;
22566    U8       rbgSize = rbgInfo->rbgSize;
22567    U32      *rbgMask = &(resAllocInfo->raType0Mask);
22568 #ifdef RGSCH_SPS_UNUSED
22569    U8       rbgSubset;
22570    U32      ueRaType1Mask;
22571    U32      *raType1Mask = resAllocInfo->raType1Mask;
22572    U32      *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22573 #endif
22574    U32      *raType2Mask = resAllocInfo->raType2Mask;
22575
22576    U32      allocedMask = allocedInfo->raType0Mask;
22577
22578    maskSize = rbgInfo->numRbgs;
22579
22580    *numAllocRbs = 0;
22581    RG_SCH_CMN_DL_COUNT_ONES(allocedMask, maskSize, &usedRbs);
22582    if (maskSize == usedRbs)
22583    {
22584       /* All RBGs are allocated, including the last one */
22585       remNumRbs = 0;
22586    }
22587    else
22588    {
22589       remNumRbs = (maskSize - usedRbs - 1) * rbgSize; /* vamsee: removed minus 1 */
22590
22591       /* If last RBG is available, add last RBG size */
22592       if (!(allocedMask & (1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(maskSize - 1))))
22593       {
22594          remNumRbs += rbgInfo->lastRbgSize;
22595       }
22596    }
22597
22598    /* If complete allocation is needed, check if total requested RBs are available else
22599     * check the best available RBs */
22600    if (!isPartialAlloc)
22601    {
22602       if (remNumRbs >= rbsReq)
22603       {
22604          bestNumAvailRbs = rbsReq;
22605       }
22606    }
22607    else
22608    {
22609       bestNumAvailRbs = remNumRbs > rbsReq ? rbsReq : remNumRbs;
22610    }
22611
22612    /* Allocate for bestNumAvailRbs */
22613    if (bestNumAvailRbs)
22614    {
22615       for (rbg = 0; rbg < maskSize - 1; ++rbg)
22616       {
22617          rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22618          if (!(allocedMask & rbgPosInRbgMask))
22619          {
22620             /* Update RBG mask */
22621             *rbgMask |= rbgPosInRbgMask;
22622
22623             /* Compute RB index of the first RB of the RBG allocated */
22624             rbIdx = rbg * rbgSize;
22625
22626             for (cnt = 0; cnt < rbgSize; ++cnt)
22627             {
22628 #ifdef RGSCH_SPS_UNUSED
22629                ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22630 #endif
22631                ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22632 #ifdef RGSCH_SPS_UNUSED
22633                /* Update RBG mask for RA type 1 */
22634                raType1Mask[rbgSubset] |= ueRaType1Mask;
22635                raType1UsedRbs[rbgSubset]++;
22636 #endif
22637                /* Update RA type 2 mask */
22638                raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22639                rbIdx++;
22640             }
22641             *numAllocRbs += rbgSize;
22642             remNumRbs -= rbgSize;
22643             ++numAllocRbgs;
22644             if (*numAllocRbs >= bestNumAvailRbs)
22645             {
22646                break;
22647             }
22648          }
22649       }
22650       /* If last RBG available and allocation is not completed, allocate
22651        * last RBG */
22652       if (*numAllocRbs < bestNumAvailRbs)
22653       {
22654          rbgPosInRbgMask =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22655          *rbgMask |= rbgPosInRbgMask;
22656          *numAllocRbs += rbgInfo->lastRbgSize;
22657
22658          /* Compute RB index of the first RB of the last RBG */
22659          rbIdx = ((rbgInfo->numRbgs - 1 ) * rbgSize ); /* removed minus 1  vamsee */
22660
22661          for (cnt = 0; cnt < rbgInfo->lastRbgSize; ++cnt)
22662          {
22663 #ifdef RGSCH_SPS_UNUSED
22664             ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22665 #endif
22666             ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22667 #ifdef RGSCH_SPS_UNUSED
22668             /* Update RBG mask for RA type 1 */
22669             raType1Mask[rbgSubset] |=  ueRaType1Mask;
22670             raType1UsedRbs[rbgSubset]++;
22671 #endif
22672             /* Update RA type 2 mask */
22673             raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22674             rbIdx++;
22675          }
22676          remNumRbs -= rbgInfo->lastRbgSize;
22677          ++numAllocRbgs;
22678       }
22679       /* Note: this should complete allocation, not checking for the
22680        * same */
22681    }
22682
22683    RETVALUE(numAllocRbgs);
22684 }
22685
22686 #ifdef RGSCH_SPS_UNUSED
22687 /**
22688  * @brief Handles RB allocation for Resource allocation type 1
22689  *
22690  * @details
22691  *
22692  *     Function : rgSCHCmnDlRaType1Alloc
22693  *
22694  *     Invoking Module Processing:
22695  *     - This function is invoked for DL RB allocation for resource allocation
22696  *     type 1
22697  *
22698  *     Processing Steps:
22699  *     - Determine the available positions in the subsets.
22700  *     - Allocate RB in the available subset.
22701  *     - Update RA Type1, RA type 0 and RA type 2 masks.
22702  *
22703  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22704  *  @param[in]   U8                 rbsReq
22705  *  @param[in]   RgSchBwRbgInfo     *rbgInfo
22706  *  @param[in]   U8                 startRbgSubset
22707  *  @param[in]   U8                 *allocRbgSubset
22708  *  @param[out]  rgSchDlSfAllocInfo *resAllocInfo
22709  *  @param[in]   Bool               isPartialAlloc
22710  *
22711  *  @return  U8
22712  *  Number of allocated RBs
22713  **/
22714
22715 #ifdef ANSI
22716 PUBLIC U8 rgSCHCmnDlRaType1Alloc
22717 (
22718 RgSchDlSfAllocInfo *allocedInfo,
22719 U8                 rbsReq,
22720 RgSchBwRbgInfo     *rbgInfo,
22721 U8                 startRbgSubset,
22722 U8                 *allocRbgSubset,
22723 RgSchDlSfAllocInfo *resAllocInfo,
22724 Bool               isPartialAlloc
22725 )
22726 #else
22727 PUBLIC U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
22728       allocRbgSubset, resAllocInfo, isPartialAlloc)
22729 RgSchDlSfAllocInfo *allocedInfo;
22730 U8                 rbsReq;
22731 RgSchBwRbgInfo     *rbgInfo;
22732 U8                 startRbgSubset;
22733 U8                 *allocRbgSubset;
22734 RgSchDlSfAllocInfo *resAllocInfo;
22735 Bool               isPartialAlloc;
22736 #endif
22737 {
22738    /* Note: This function atttempts only full allocation */
22739    U8          *rbgSubsetSzArr;
22740    U8          type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
22741    U8          offset, rbg, maskSize, bestSubsetIdx;
22742    U8          startPos = 0;
22743    U8          bestNumAvailRbs = 0;
22744    U8          numAllocRbs = 0;
22745    U32         ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
22746    U32         remNumRbs, allocedMask;
22747    U8          usedRbs = 0;
22748    U8          rbgSize = rbgInfo->rbgSize;
22749    U8          rbgSubset = startRbgSubset;
22750    U32         *rbgMask = &resAllocInfo->raType0Mask;
22751    U32         *raType1Mask = resAllocInfo->raType1Mask;
22752    U32         *raType2Mask = resAllocInfo->raType2Mask;
22753    U32         *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22754    U32         *allocMask = allocedInfo->raType1Mask;
22755
22756    /* Initialize the subset size Array */
22757    rbgSubsetSzArr = rbgInfo->rbgSubsetSize;
22758
22759    /* Perform allocation for RA type 1 */
22760    for (subsetIdx = 0;subsetIdx < rbgSize; ++subsetIdx)
22761    {
22762       allocedMask = allocMask[rbgSubset];
22763       maskSize = rbgSubsetSzArr[rbgSubset];
22764
22765       /* Determine number of available RBs in the subset */
22766       usedRbs = allocedInfo->raType1UsedRbs[subsetIdx];
22767       remNumRbs = maskSize - usedRbs;
22768
22769       if (remNumRbs >= rbsReq)
22770       {
22771          bestNumAvailRbs = rbsReq;
22772          bestSubsetIdx = rbgSubset;
22773          break;
22774       }
22775       else if (isPartialAlloc && (remNumRbs > bestNumAvailRbs))
22776       {
22777          bestNumAvailRbs = remNumRbs;
22778          bestSubsetIdx = rbgSubset;
22779       }
22780
22781       rbgSubset = (rbgSubset + 1) % rbgSize;
22782    } /* End of for (each rbgsubset) */
22783
22784    if (bestNumAvailRbs)
22785    {
22786       /* Initialize alloced mask and subsetSize depending on the RBG
22787        * subset of allocation */
22788       U8        startIdx = 0;
22789       maskSize = rbgSubsetSzArr[bestSubsetIdx];
22790       allocedMask = allocMask[bestSubsetIdx];
22791       RG_SCH_CMN_DL_GET_START_POS(allocedMask, maskSize,
22792             &startPos);
22793       for (; startIdx < rbgSize; ++startIdx, ++startPos)
22794       {
22795          for (rbInSubset = startPos; rbInSubset < maskSize;
22796                rbInSubset = rbInSubset + rbgSize)
22797          {
22798             rbPosInSubset =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
22799             if (!(allocedMask & rbPosInSubset))
22800             {
22801                raType1Mask[bestSubsetIdx] |= rbPosInSubset;
22802                raType1UsedRbs[bestSubsetIdx]++;
22803
22804                /* Compute RB index value for the RB being allocated */
22805                rbgInSubset = rbInSubset /rbgSize;
22806                offset = rbInSubset % rbgSize;
22807                rbg = (rbgInSubset * rbgSize) + bestSubsetIdx;
22808                rbIdx = (rbg * rbgSize) + offset;
22809
22810                /* Update RBG mask for RA type 0 allocation */
22811                ueRaType0Mask = rgSCHCmnGetRaType0Mask(rbIdx, rbgSize);
22812                *rbgMask |= ueRaType0Mask;
22813
22814                /* Update RA type 2 mask */
22815                ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22816                raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22817
22818                /* Update the counters */
22819                numAllocRbs++;
22820                remNumRbs--;
22821                if (numAllocRbs == bestNumAvailRbs)
22822                {
22823                   break;
22824                }
22825             }
22826          } /* End of for (each position in the subset mask) */
22827          if (numAllocRbs == bestNumAvailRbs)
22828          {
22829             break;
22830          }
22831       } /* End of for startIdx = 0 to rbgSize */
22832
22833       *allocRbgSubset = bestSubsetIdx;
22834    } /* End of if (bestNumAvailRbs) */
22835
22836    RETVALUE(numAllocRbs);
22837 }
22838 #endif
22839 /**
22840  * @brief Handles RB allocation for Resource allocation type 2
22841  *
22842  * @details
22843  *
22844  *     Function : rgSCHCmnDlRaType2Alloc
22845  *
22846  *     Invoking Module Processing:
22847  *     - This function is invoked for DL RB allocation for resource allocation
22848  *     type 2
22849  *
22850  *     Processing Steps:
22851  *     - Determine the available positions in the mask
22852  *     - Allocate best fit cosecutive RBs.
22853  *     - Update RA Type2, RA type 1 and RA type 0 masks.
22854  *
22855  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22856  *  @param[in]   U8             rbsReq
22857  *  @param[in]   RgSchBwRbgInfo *rbgInfo
22858  *  @param[out]  U8             *rbStart
22859  *  @param[out]  rgSchDlSfAllocInfo *resAllocInfo
22860  *  @param[in]   Bool           isPartialAlloc
22861  *
22862  *  @return  U8
22863  *  Number of allocated RBs
22864  **/
22865
22866 #ifdef ANSI
22867 PUBLIC U8 rgSCHCmnDlRaType2Alloc
22868 (
22869 RgSchDlSfAllocInfo *allocedInfo,
22870 U8                 rbsReq,
22871 RgSchBwRbgInfo     *rbgInfo,
22872 U8                 *rbStart,
22873 RgSchDlSfAllocInfo *resAllocInfo,
22874 Bool               isPartialAlloc
22875 )
22876 #else
22877 PUBLIC U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
22878       resAllocInfo, isPartialAlloc)
22879 RgSchDlSfAllocInfo *allocedInfo;
22880 U8                 rbsReq;
22881 RgSchBwRbgInfo     *rbgInfo;
22882 U8                 *rbStart;
22883 RgSchDlSfAllocInfo *resAllocInfo;
22884 Bool               isPartialAlloc;
22885 #endif
22886 {
22887    U8          numAllocRbs = 0;
22888    U8          rbIdx;
22889    U8          rbgSize = rbgInfo->rbgSize;
22890    U32         *rbgMask = &resAllocInfo->raType0Mask;
22891 #ifdef RGSCH_SPS_UNUSED
22892    U32         *raType1Mask = resAllocInfo->raType1Mask;
22893 #endif
22894    U32         *raType2Mask = resAllocInfo->raType2Mask;
22895 #ifdef RGSCH_SPS_UNUSED
22896    U32         *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22897 #endif
22898    U32         *allocedMask = allocedInfo->raType2Mask;
22899
22900    /* Note: This function atttempts only full allocation */
22901    rgSCHCmnDlGetBestFitHole(allocedMask, rbgInfo->numRbs,
22902          raType2Mask, rbsReq, rbStart, &numAllocRbs, isPartialAlloc);
22903    if (numAllocRbs)
22904    {
22905       /* Update the allocation in RA type 0 and RA type 1 masks */
22906       U8 rbCnt = numAllocRbs;
22907 #ifdef RGSCH_SPS_UNUSED
22908       U8 rbgSubset;
22909       U32 ueRaType1Mask;
22910 #endif
22911       U32 ueRaType0Mask;
22912       rbIdx = *rbStart;
22913
22914       while(rbCnt)
22915       {
22916          /* Update RBG mask for RA type 0 allocation */
22917          ueRaType0Mask = rgSCHCmnGetRaType0Mask(rbIdx, rbgSize);
22918          *rbgMask |= ueRaType0Mask;
22919
22920 #ifdef RGSCH_SPS_UNUSED
22921          /* Update RBG mask for RA type 1 */
22922          ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22923          raType1Mask[rbgSubset] |= ueRaType1Mask;
22924          raType1UsedRbs[rbgSubset]++;
22925 #endif
22926          /* Update the counters */
22927          --rbCnt;
22928          rbIdx++;
22929       }
22930    }
22931
22932    RETVALUE(numAllocRbs);
22933 }
22934
22935 /**
22936  * @brief Determines RA type 0 mask from given RB index.
22937  *
22938  * @details
22939  *
22940  *     Function : rgSCHCmnGetRaType0Mask
22941  *
22942  *
22943  *     Processing Steps:
22944  *     - Determine RA Type 0 mask for given rbIdex and rbg size.
22945  *
22946  *  @param[in]  U8          rbIdx
22947  *  @param[in]  U8          rbgSize
22948  *  @return  U32 RA type 0 mask
22949  **/
22950 #ifdef ANSI
22951 PRIVATE U32 rgSCHCmnGetRaType0Mask
22952 (
22953 U8                rbIdx,
22954 U8                rbgSize
22955 )
22956 #else
22957 PRIVATE U32 rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
22958 U8                rbIdx;
22959 U8                rbgSize;
22960 #endif
22961 {
22962    U8 rbg;
22963    U32 rbgPosInRbgMask = 0;
22964
22965    rbg = rbIdx/rbgSize;
22966    rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22967
22968    RETVALUE(rbgPosInRbgMask);
22969 }
22970
22971 #ifdef RGSCH_SPS_UNUSED
22972 /**
22973  * @brief Determines RA type 1 mask from given RB index.
22974  *
22975  * @details
22976  *
22977  *     Function : rgSCHCmnGetRaType1Mask
22978  *
22979  *
22980  *     Processing Steps:
22981  *     - Determine RA Type 1 mask for given rbIdex and rbg size.
22982  *
22983  *  @param[in]  U8          rbIdx
22984  *  @param[in]  U8          rbgSize
22985  *  @param[out] U8          *type1Subset
22986  *  @return  U32 RA type 1 mask
22987  **/
22988 #ifdef ANSI
22989 PRIVATE U32 rgSCHCmnGetRaType1Mask
22990 (
22991 U8                rbIdx,
22992 U8                rbgSize,
22993 U8                *type1Subset
22994 )
22995 #else
22996 PRIVATE U32 rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
22997 U8                rbIdx;
22998 U8                rbgSize;
22999 U8                *type1Subset;
23000 #endif
23001 {
23002    U8 rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
23003    U32 rbPosInSubset;
23004
23005    rbg = rbIdx/rbgSize;
23006    rbgSubset = rbg % rbgSize;
23007    rbgInSubset = rbg/rbgSize;
23008    offset = rbIdx % rbgSize;
23009    rbInSubset = rbgInSubset * rbgSize + offset;
23010    rbPosInSubset =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
23011
23012    *type1Subset = rbgSubset;
23013    RETVALUE(rbPosInSubset);
23014 } 
23015 #endif /* RGSCH_SPS_UNUSED */
23016 /**
23017  * @brief Determines RA type 2 mask from given RB index.
23018  *
23019  * @details
23020  *
23021  *     Function : rgSCHCmnGetRaType2Mask
23022  *
23023  *
23024  *     Processing Steps:
23025  *     - Determine RA Type 2 mask for given rbIdx and rbg size.
23026  *
23027  *  @param[in]  U8          rbIdx
23028  *  @param[out] U8          *maskIdx
23029  *  @return  U32 RA type 2 mask
23030  **/
23031 #ifdef ANSI
23032 PRIVATE U32 rgSCHCmnGetRaType2Mask
23033 (
23034 U8                rbIdx,
23035 U8                *maskIdx
23036 )
23037 #else
23038 PRIVATE U32 rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
23039 U8                rbIdx;
23040 U8                *maskIdx;
23041 #endif
23042 {
23043    U32 rbPosInType2;
23044
23045    *maskIdx = rbIdx / 32;
23046    rbPosInType2 =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
23047
23048    RETVALUE(rbPosInType2);
23049 }
23050
23051 /**
23052  * @brief Performs resource allocation for a non-SPS UE in SPS bandwidth
23053  *
23054  * @details
23055  *
23056  *     Function : rgSCHCmnAllocUeInSpsBw
23057  *
23058  *
23059  *     Processing Steps:
23060  *       - Determine allocation for the UE.
23061  *       - Use resource allocation type 0, 1 and 2 for allocation
23062  *         within maximum SPS bandwidth.
23063  *
23064  *  @param[in]  RgSchDlSf       *dlSf
23065  *  @param[in]  RgSchCellCb     *cell
23066  *  @param[in]  RgSchUeCb       *ue
23067  *  @param[in]  RgSchDlRbAlloc  *rbAllocInfo
23068  *  @param[in]  Bool            isPartialAlloc
23069  *  @return  Bool
23070  *             ROK      success
23071  *             RFAILED  failed
23072  **/
23073 #ifdef ANSI
23074 PUBLIC Bool rgSCHCmnAllocUeInSpsBw
23075 (
23076 RgSchDlSf           *dlSf,
23077 RgSchCellCb         *cell,
23078 RgSchUeCb           *ue,
23079 RgSchDlRbAlloc      *rbAllocInfo,
23080 Bool                isPartialAlloc
23081 )
23082 #else
23083 PUBLIC Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
23084 RgSchDlSf           *dlSf;
23085 RgSchCellCb         *cell;
23086 RgSchUeCb           *ue;
23087 RgSchDlRbAlloc      *rbAllocInfo;
23088 Bool                isPartialAlloc;
23089 #endif
23090 {
23091    U8                  rbgSize = cell->rbgSize;
23092    U8                  numAllocRbs = 0;
23093    U8                  numAllocRbgs = 0;
23094    U8                  rbStart = 0;
23095    U8                  idx, noLyr, iTbs;
23096    RgSchCmnDlUe        *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
23097    RgSchDlSfAllocInfo  *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
23098    RgSchBwRbgInfo      *spsRbgInfo = &cell->spsBwRbgInfo;
23099
23100    /* SPS_FIX : Check if this Hq proc is scheduled */
23101    if ((0 == rbAllocInfo->tbInfo[0].schdlngForTb) &&
23102          (0 == rbAllocInfo->tbInfo[1].schdlngForTb))
23103    {
23104       RETVALUE(TRUE);
23105    }
23106
23107    /* Check if the requirement can be accomodated in SPS BW */
23108    if (dlSf->spsAllocdBw == spsRbgInfo->numRbs)
23109    {
23110       /* SPS Bandwidth has been exhausted: no further allocations possible */
23111       RETVALUE(FALSE);
23112    }
23113    if (!isPartialAlloc)
23114    {
23115       if((dlSf->spsAllocdBw + rbAllocInfo->rbsReq) > spsRbgInfo->numRbs)
23116       {
23117          RETVALUE(TRUE);
23118       }
23119    }
23120
23121    /* Perform allocation for RA type 0 if rbsReq is multiple of RBG size (also
23122     * if RBG size = 1) */
23123    if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23124    {
23125       rbAllocInfo->rbsReq += (rbgSize - rbAllocInfo->rbsReq % rbgSize);
23126       numAllocRbgs = rgSCHCmnDlRaType0Alloc(dlSfAlloc,
23127             rbAllocInfo->rbsReq, spsRbgInfo, &numAllocRbs,
23128             &rbAllocInfo->resAllocInfo, isPartialAlloc);
23129    }
23130 #ifdef RGSCH_SPS_UNUSED
23131    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE1)
23132    {
23133       /* If no RBS could be allocated, attempt RA TYPE 1 */
23134
23135       numAllocRbs = rgSCHCmnDlRaType1Alloc(dlSfAlloc,
23136             rbAllocInfo->rbsReq, spsRbgInfo, (U8)dlSfAlloc->nxtRbgSubset,
23137             &rbAllocInfo->allocInfo.raType1.rbgSubset,
23138             &rbAllocInfo->resAllocInfo, isPartialAlloc);
23139
23140       if(numAllocRbs)
23141       {
23142          dlSfAlloc->nxtRbgSubset =
23143             (rbAllocInfo->allocInfo.raType1.rbgSubset + 1 ) % rbgSize;
23144       }
23145    }
23146 #endif
23147    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23148    {
23149       numAllocRbs = rgSCHCmnDlRaType2Alloc(dlSfAlloc,
23150             rbAllocInfo->rbsReq, spsRbgInfo,
23151             &rbStart, &rbAllocInfo->resAllocInfo, isPartialAlloc);
23152    }
23153    if (!numAllocRbs)
23154    {
23155       RETVALUE(TRUE);
23156    }
23157
23158    if (!(rbAllocInfo->pdcch =
23159             rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi,\
23160                rbAllocInfo->dciFormat, FALSE)))
23161    {
23162       /* Note: Returning TRUE since PDCCH might be available for another UE */
23163       RETVALUE(TRUE);
23164    }
23165
23166    /* Update Tb info for each scheduled TB */
23167    iTbs = rbAllocInfo->tbInfo[0].iTbs;
23168    noLyr = rbAllocInfo->tbInfo[0].noLyr;
23169    rbAllocInfo->tbInfo[0].bytesAlloc =
23170       rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;
23171
23172    if (rbAllocInfo->tbInfo[1].schdlngForTb)
23173    {
23174       iTbs = rbAllocInfo->tbInfo[1].iTbs;
23175       noLyr = rbAllocInfo->tbInfo[1].noLyr;
23176       rbAllocInfo->tbInfo[1].bytesAlloc =
23177          rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;;
23178    }
23179
23180    /* Update rbAllocInfo with the allocation information */
23181    if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23182    {
23183       rbAllocInfo->allocInfo.raType0.dlAllocBitMask =
23184          rbAllocInfo->resAllocInfo.raType0Mask;
23185       rbAllocInfo->allocInfo.raType0.numDlAlloc = numAllocRbgs;
23186    }
23187 #ifdef RGSCH_SPS_UNUSED
23188    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE1)
23189    {
23190       rbAllocInfo->allocInfo.raType1.dlAllocBitMask =
23191          rbAllocInfo->resAllocInfo.raType1Mask[rbAllocInfo->allocInfo.raType1.rbgSubset];
23192       rbAllocInfo->allocInfo.raType1.numDlAlloc = numAllocRbs;
23193       rbAllocInfo->allocInfo.raType1.shift = 0;
23194    }
23195 #endif
23196    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23197    {
23198       rbAllocInfo->allocInfo.raType2.isLocal = TRUE;
23199       rbAllocInfo->allocInfo.raType2.rbStart = rbStart;
23200       rbAllocInfo->allocInfo.raType2.numRb = numAllocRbs;
23201    }
23202
23203    rbAllocInfo->rbsAlloc = numAllocRbs;
23204    rbAllocInfo->tbInfo[0].schdlngForTb = TRUE;
23205
23206    /* Update allocation masks for RA types 0, 1 and 2 in DL SF */
23207
23208    /* Update type 0 allocation mask */
23209    dlSfAlloc->raType0Mask |= rbAllocInfo->resAllocInfo.raType0Mask;
23210 #ifdef RGSCH_SPS_UNUSED
23211    /* Update type 1 allocation masks */
23212    for (idx = 0; idx < RG_SCH_NUM_RATYPE1_32BIT_MASK; ++idx)
23213    {
23214       dlSfAlloc->raType1Mask[idx] |= rbAllocInfo->resAllocInfo.raType1Mask[idx];
23215       dlSfAlloc->raType1UsedRbs[idx] +=
23216          rbAllocInfo->resAllocInfo.raType1UsedRbs[idx];
23217    }
23218 #endif
23219    /* Update type 2 allocation masks */
23220    for (idx = 0; idx < RG_SCH_NUM_RATYPE2_32BIT_MASK; ++idx)
23221    {
23222       dlSfAlloc->raType2Mask[idx] |= rbAllocInfo->resAllocInfo.raType2Mask[idx];
23223    }
23224
23225    dlSf->spsAllocdBw += numAllocRbs;
23226    RETVALUE(TRUE);
23227 }
23228
23229 /***********************************************************
23230  *
23231  *     Func : rgSCHCmnDlGetBestFitHole
23232  *
23233  *
23234  *     Desc : Converts the best fit hole into allocation and returns the
23235  *     allocation information.
23236  *
23237  *
23238  *     Ret  : Void
23239  *
23240  *
23241  *     Notes:
23242  *
23243  *     File :
23244  *
23245  **********************************************************/
23246 #ifdef ANSI
23247 PRIVATE Void rgSCHCmnDlGetBestFitHole
23248 (
23249 U32         *allocMask,
23250 U8          numMaskRbs,
23251 U32         *crntAllocMask,
23252 U8          rbsReq,
23253 U8          *allocStart,
23254 U8          *allocNumRbs,
23255 Bool        isPartialAlloc
23256 )
23257 #else
23258 PRIVATE  Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
23259         crntAllocMask, rbsReq, allocStart, allocNumRbs, isPartialAlloc)
23260 U32         *allocMask;
23261 U8          numMaskRbs;
23262 U32         *crntAllocMask;
23263 U8          rbsReq;
23264 U8          *allocStart;
23265 U8          *allocNumRbs;
23266 Bool        isPartialAlloc;
23267 #endif
23268 {
23269    U8 maskSz = (numMaskRbs + 31)/32;
23270    U8 maxMaskPos = (numMaskRbs % 32);
23271    U8 maskIdx, maskPos;
23272    U8 numAvailRbs = 0;
23273    U8 bestAvailNumRbs = 0;
23274    S8 bestStartPos = -1;
23275    S8 startPos = -1;
23276    U32 tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
23277    U32 bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
23278
23279    *allocNumRbs = numAvailRbs;
23280    *allocStart = 0;
23281
23282    for (maskIdx = 0; maskIdx < maskSz; ++maskIdx)
23283    {
23284       maxMaskPos = 31;
23285       if (maskIdx == (maskSz - 1))
23286       {
23287          if (numMaskRbs % 32)
23288          {
23289             maxMaskPos = numMaskRbs % 32;
23290          }
23291       }
23292       for (maskPos = 0; maskPos < maxMaskPos; ++maskPos)
23293       {
23294          if (!(allocMask[maskIdx] & (1 << (31 - maskPos))))
23295          {
23296             tmpMask[maskIdx] |= (1 << (31 - maskPos));
23297             if (startPos == -1)
23298             {
23299                startPos = maskIdx * 32 + maskPos;
23300             }
23301             ++numAvailRbs;
23302             if (numAvailRbs == rbsReq)
23303             {
23304                *allocStart = (U8)startPos;
23305                *allocNumRbs = rbsReq;
23306                break;
23307             }
23308          }
23309          else
23310          {
23311             if (numAvailRbs > bestAvailNumRbs)
23312             {
23313                bestAvailNumRbs = numAvailRbs;
23314                bestStartPos = startPos;
23315                cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
23316             }
23317             numAvailRbs = 0;
23318             startPos = -1;
23319             cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
23320          }
23321       }
23322       if (*allocNumRbs == rbsReq)
23323       {
23324          break;
23325       }
23326    }
23327
23328    if (*allocNumRbs == rbsReq)
23329    {
23330       /* Convert the hole into allocation */
23331       cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
23332       RETVOID;
23333    }
23334    else
23335    {
23336       if (bestAvailNumRbs && isPartialAlloc)
23337       {
23338          /* Partial allocation could have been done */
23339          *allocStart = (U8)bestStartPos;
23340          *allocNumRbs = bestAvailNumRbs;
23341          /* Convert the hole into allocation */
23342          cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
23343       }
23344    }
23345
23346    RETVOID;
23347 }
23348 #endif /* LTEMAC_SPS */
23349
23350 /***************************************************************************
23351  *
23352  * NON-DLFS Allocation functions
23353  *
23354  * *************************************************************************/
23355 #ifndef LTE_TDD
23356 #ifdef DEBUGP
23357 /**
23358  * @brief Function to find out code rate
23359  *
23360  * @details
23361  *
23362  *     Function : rgSCHCmnFindCodeRate
23363  *
23364  *     Processing Steps:
23365  *
23366  *  @param[in]      RgSchCellCb     *cell
23367  *  @param[in]      RgSchDlSf       *dlSf
23368  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23369  *  @return  void
23370  **/
23371 #ifdef ANSI
23372 PRIVATE Void rgSCHCmnFindCodeRate
23373 (
23374 RgSchCellCb           *cell,
23375 RgSchDlSf             *dlSf,
23376 RgSchDlRbAlloc        *allocInfo,
23377 U8                    idx
23378 )
23379 #else
23380 PRIVATE Void rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,idx)
23381 RgSchCellCb           *cell;
23382 RgSchDlSf             *dlSf;
23383 RgSchDlRbAlloc        *allocInfo;
23384 U8                    idx;
23385 #endif
23386 {
23387     RETVOID;
23388
23389 }
23390 #endif
23391
23392 /* Adjust the Imcs and bytes allocated also with respect to the adjusted
23393    RBs - Here we will find out the Imcs by identifying first Highest
23394    number of bits compared to the original bytes allocated.  */
23395 /**
23396  * @brief Adjust IMCS according to tbSize and ITBS
23397  *
23398  * @details
23399  *
23400  *     Function : rgSCHCmnNonDlfsPbchTbImcsAdj
23401  *
23402  *     Processing Steps:
23403  *      - Adjust Imcs according to tbSize and ITBS.
23404  *
23405  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23406  *  @param[in]      U8              *idx
23407  *  @return  void
23408  **/
23409 #ifdef ANSI
23410 PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj
23411 (
23412 RgSchCellCb      *cell,
23413 RgSchDlRbAlloc   *allocInfo,
23414 U8               idx,
23415 U8               rbsReq
23416 )
23417 #else
23418 PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj(cell,allocInfo, idx, rbsReq)
23419 RgSchCellCb      *cell;
23420 RgSchDlRbAlloc   *allocInfo;
23421 U8               idx;
23422 U8               rbsReq;
23423 #endif
23424 {
23425    U8             noLyrs = 0;
23426    U8             tbs = 0;
23427    U32            origBytesReq;
23428    U8             noRbgs = 0;
23429    U8             noRbs = 0;
23430    RgSchDlSf     *dlSf = allocInfo->dlSf;
23431
23432    RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
23433    noLyrs = allocInfo->tbInfo[idx].noLyr;
23434
23435    if((allocInfo->raType == RG_SCH_CMN_RA_TYPE0))
23436    {
23437       noRbgs = RGSCH_CEIL((allocInfo->rbsReq + dlSf->lstRbgDfct), cell->rbgSize);
23438       noRbs = (noRbgs * cell->rbgSize) - dlSf->lstRbgDfct;
23439    }
23440    else
23441    {
23442        noRbs = allocInfo->rbsReq;
23443    }
23444
23445    /* This line will help in case if tbs is zero and reduction in MCS is not possible */
23446    if (allocInfo->rbsReq == 0 )
23447    {
23448       RETVOID;
23449    }
23450    origBytesReq = rgTbSzTbl[noLyrs - 1][tbs][rbsReq - 1]/8;
23451
23452    /* Find out the ITbs & Imcs by identifying first Highest
23453       number of bits compared to the original bytes allocated.*/
23454    if(tbs > 0)
23455    {
23456       if(((rgTbSzTbl[noLyrs - 1][0][noRbs - 1])/8) < origBytesReq)
23457       {
23458           RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[noLyrs - 1], tbs);
23459           while(((rgTbSzTbl[noLyrs - 1][tbs][noRbs - 1])/8) > origBytesReq)
23460           {
23461               tbs--;
23462           }
23463       }
23464       else
23465       {
23466           tbs = 0;
23467       }
23468       allocInfo->tbInfo[idx].bytesReq = rgTbSzTbl[noLyrs - 1][tbs][noRbs - 1]/8;
23469       allocInfo->tbInfo[idx].iTbs = tbs;
23470       RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
23471    }
23472
23473    RETVOID;
23474 }
23475 /* Added funcion to adjust TBSize*/
23476 /**
23477  * @brief Function to adjust the tbsize in case of subframe 0 & 5 when
23478  * we were not able to do RB alloc adjustment by adding extra required Rbs
23479  *
23480  * @details
23481  *
23482  *     Function : rgSCHCmnNonDlfsPbchTbSizeAdj
23483  *
23484  *     Processing Steps:
23485  *
23486  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23487  *  @param[in]      U8            numOvrlapgPbchRb
23488  *  @param[in]      U8            idx
23489  *  @param[in]      U8            pbchSsRsSym
23490  *  @return  void
23491  **/
23492 #ifdef ANSI
23493 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj
23494 (
23495 RgSchDlRbAlloc        *allocInfo,
23496 U8                    numOvrlapgPbchRb,
23497 U8                    pbchSsRsSym,
23498 U8                    idx,
23499 U32                   bytesReq
23500 )
23501 #else
23502 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,idx,bytesReq)
23503 RgSchDlRbAlloc        *allocInfo;
23504 U8                    numOvrlapgPbchRb;
23505 U8                    pbchSsRsSym;
23506 U8                    idx;
23507 U32                   bytesReq;
23508 #endif
23509 {
23510    U32             reducedTbs = 0;
23511    U8              noLyrs = 0;
23512    U8              tbs = 0;
23513
23514    noLyrs = allocInfo->tbInfo[idx].noLyr;
23515
23516    RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
23517
23518    reducedTbs = bytesReq - (((U32)numOvrlapgPbchRb * (U32)pbchSsRsSym * 6)/8);
23519
23520    /* find out the ITbs & Imcs by identifying first Highest
23521     number of bits compared with reduced bits considering the bits that are
23522     reserved for PBCH/PSS/SSS */
23523    if(((rgTbSzTbl[noLyrs - 1][0][allocInfo->rbsReq - 1])/8) < reducedTbs)
23524    {
23525        while(((rgTbSzTbl[noLyrs - 1][tbs][allocInfo->rbsReq - 1])/8) > reducedTbs)
23526        {
23527            tbs--;
23528        }
23529    }
23530    else
23531    {
23532        tbs = 0;
23533    }
23534    allocInfo->tbInfo[idx].bytesReq = rgTbSzTbl[noLyrs - 1][tbs][allocInfo->rbsReq - 1]/8;
23535    allocInfo->tbInfo[idx].iTbs = tbs;
23536    RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
23537
23538    RETVOID;
23539 }
23540
23541 /* Added this function to find num of ovrlapping PBCH rb*/
23542 /**
23543  * @brief Function to find out how many additional rbs are available
23544  *    in the entire bw which can be allocated to a UE
23545  * @details
23546  *
23547  *     Function : rgSCHCmnFindNumAddtlRbsAvl
23548  *
23549  *     Processing Steps:
23550  *      - Calculates number of additinal rbs available
23551  *
23552  *  @param[in]      RgSchCellCb     *cell
23553  *  @param[in]      RgSchDlSf       *dlSf
23554  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23555  *  @param[out]      U8            addtlRbsAvl
23556  *  @return  void
23557  **/
23558 #ifdef ANSI
23559 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl
23560 (
23561 RgSchCellCb           *cell,
23562 RgSchDlSf             *dlSf,
23563 RgSchDlRbAlloc        *allocInfo
23564 )
23565 #else
23566 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
23567 RgSchCellCb           *cell;
23568 RgSchDlSf             *dlSf;
23569 RgSchDlRbAlloc        *allocInfo;
23570 #endif
23571 {
23572     U8 addtlRbsAvl = 0;
23573
23574     TRC2(rgSCHCmnFindNumAddtlRbsAvl)
23575
23576     if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23577     {
23578          addtlRbsAvl = (((dlSf->type0End - dlSf->type2End + 1)*\
23579                         cell->rbgSize) - dlSf->lstRbgDfct) - allocInfo->rbsReq;
23580     }
23581     else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23582     {
23583        addtlRbsAvl = (dlSf->bw - dlSf->bwAlloced) - allocInfo->rbsReq;
23584     }
23585
23586     RETVALUE(addtlRbsAvl);
23587
23588 }
23589 /* Added this function to find num of ovrlapping PBCH rb*/
23590 /**
23591  * @brief Function to find out how many of the requested RBs are
23592  *        falling in the center 6 RBs of the downlink bandwidth.
23593  * @details
23594  *
23595  *     Function : rgSCHCmnFindNumPbchOvrlapRbs
23596  *
23597  *     Processing Steps:
23598  *      - Calculates number of overlapping rbs
23599  *
23600  *  @param[in]      RgSchCellCb     *cell
23601  *  @param[in]      RgSchDlSf       *dlSf
23602  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23603  *  @param[out]      U8*            numOvrlapgPbchRb
23604  *  @return  void
23605  **/
23606 #ifdef ANSI
23607 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs
23608 (
23609 RgSchCellCb           *cell,
23610 RgSchDlSf             *dlSf,
23611 RgSchDlRbAlloc        *allocInfo,
23612 U8                    *numOvrlapgPbchRb
23613 )
23614 #else
23615 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,numOvrlapgPbchRb)
23616 RgSchCellCb           *cell;
23617 RgSchDlSf             *dlSf;
23618 RgSchDlRbAlloc        *allocInfo;
23619 U8                    *numOvrlapgPbchRb;
23620 #endif
23621 {
23622     *numOvrlapgPbchRb = 0;
23623     TRC2(rgSCHCmnFindNumPbchOvrlapRbs)
23624    /*Find if we have already crossed the start boundary for PBCH 6 RBs,
23625     * if yes then lets find the number of RBs which are getting overlapped
23626     * with this allocation.*/
23627    if(dlSf->bwAlloced <= (cell->pbchRbStart))
23628    {
23629       /*We have not crossed the start boundary of PBCH RBs. Now we need
23630        * to know that if take this allocation then how much PBCH RBs
23631        * are overlapping with this allocation.*/
23632       /* Find out the overlapping RBs in the centre 6 RBs */
23633        if((dlSf->bwAlloced + allocInfo->rbsReq) > cell->pbchRbStart)
23634        {
23635            *numOvrlapgPbchRb = (dlSf->bwAlloced + allocInfo->rbsReq) - (cell->pbchRbStart);
23636            if(*numOvrlapgPbchRb > 6)
23637                 *numOvrlapgPbchRb = 6;
23638        }
23639    }
23640    else if ((dlSf->bwAlloced > (cell->pbchRbStart)) &&
23641          (dlSf->bwAlloced < (cell->pbchRbEnd)))
23642    {
23643       /*We have already crossed the start boundary of PBCH RBs.We need to
23644        * find that if we take this allocation then how much of the RBs for
23645        * this allocation will overlap with PBCH RBs.*/
23646       /* Find out the overlapping RBs in the centre 6 RBs */
23647       if(dlSf->bwAlloced + allocInfo->rbsReq < (cell->pbchRbEnd))
23648       {
23649          /*If we take this allocation then also we are not crossing the
23650           * end boundary of PBCH 6 RBs.*/
23651          *numOvrlapgPbchRb = allocInfo->rbsReq;
23652       }
23653       else
23654       {
23655          /*If we take this allocation then we are crossing the
23656           * end boundary of PBCH 6 RBs.*/
23657          *numOvrlapgPbchRb = (cell->pbchRbEnd) - dlSf->bwAlloced;
23658       }
23659    }
23660     RETVOID;
23661
23662 }
23663 /**
23664  * @brief Performs RB allocation adjustment if the requested RBs are
23665  *        falling in the center 6 RBs of the downlink bandwidth.
23666  * @details
23667  *
23668  *     Function : rgSCHCmnNonDlfsPbchRbAllocAdj
23669  *
23670  *     Processing Steps:
23671  *      - Allocate consecutively available RBs.
23672  *
23673  *  @param[in]      RgSchCellCb     *cell
23674  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23675  *  @param[in]      U8               pbchSsRsSym
23676  *  @return  void
23677  **/
23678 #ifdef ANSI
23679 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj
23680 (
23681 RgSchCellCb      *cell,
23682 RgSchDlRbAlloc   *allocInfo,
23683 U8               pbchSsRsSym,
23684 Bool             isBcchPcch
23685 )
23686 #else
23687 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo,pbchSsRsSym)
23688 RgSchCellCb      *cell;
23689 RgSchDlRbAlloc   *allocInfo;
23690 U8               pbchSsRsSym;
23691 Bool             isBcchPcch;
23692 #endif
23693 {
23694    RgSchDlSf     *dlSf = allocInfo->dlSf;
23695    U8             numOvrlapgPbchRb = 0;
23696    U8             numOvrlapgAdtlPbchRb = 0;
23697    U8             totSym;
23698    U8             addtlRbsReq = 0;
23699    U8             moreAddtlRbsReq = 0;
23700    U8             addtlRbsAdd = 0;
23701    U8             moreAddtlRbsAdd = 0;
23702    U8             tbs;
23703    U8             origRbsReq = 0;
23704    U32            bytesReq;
23705    U8             noLyr;
23706    U8             divResult;
23707
23708
23709    TRC2(rgSCHCmnNonDlfsPbchRbAllocAdj);
23710
23711
23712    origRbsReq = allocInfo->rbsReq;
23713    rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,&numOvrlapgPbchRb);
23714
23715   totSym =  (cell->isCpDlExtend) ? RGSCH_TOT_NUM_SYM_EXTCP : RGSCH_TOT_NUM_SYM_NORCP;
23716
23717    /* Additional RBs are allocated by considering the loss due to
23718       the reserved symbols for CFICH, PBCH, PSS, SSS and cell specific RS */
23719
23720    divResult = (numOvrlapgPbchRb * pbchSsRsSym)/totSym;
23721    if((numOvrlapgPbchRb * pbchSsRsSym) % totSym)
23722    {
23723       divResult++;
23724    }
23725    addtlRbsReq = divResult;
23726
23727    RG_SCH_CMN_UPD_RBS_TO_ADD(cell, dlSf, allocInfo, addtlRbsReq, addtlRbsAdd)
23728
23729    /*Now RBs requires is original requested RBs + these additional RBs to make
23730     * up for PSS/SSS/BCCH.*/
23731    allocInfo->rbsReq = allocInfo->rbsReq + addtlRbsAdd;
23732
23733    /*Check if with these additional RBs we have taken up, these are also falling
23734     * under PBCH RBs range, if yes then we would need to account for
23735     * PSS/BSS/BCCH for these additional RBs too.*/
23736    if(addtlRbsAdd && ((dlSf->bwAlloced + allocInfo->rbsReq - addtlRbsAdd) < (cell->pbchRbEnd)))
23737    {
23738       if((dlSf->bwAlloced + allocInfo->rbsReq) <= (cell->pbchRbEnd))
23739       {
23740       /*With additional RBs taken into account, we are not crossing the
23741        * PBCH RB end boundary.Thus here we need to account just for
23742        * overlapping PBCH RBs for these additonal RBs.*/
23743           divResult = (addtlRbsAdd * pbchSsRsSym)/totSym;
23744           if((addtlRbsAdd * pbchSsRsSym) % totSym)
23745           {
23746             divResult++;
23747           }
23748
23749           moreAddtlRbsReq = divResult;
23750
23751           RG_SCH_CMN_UPD_RBS_TO_ADD(cell, dlSf, allocInfo, moreAddtlRbsReq, moreAddtlRbsAdd)
23752
23753           allocInfo->rbsReq = allocInfo->rbsReq + moreAddtlRbsAdd;
23754       }
23755       else
23756       {
23757
23758          /*Here we have crossed the PBCH RB end boundary, thus we need to take
23759           * into account the overlapping RBs for additional RBs which will be
23760           * subset of addtlRbs.*/
23761           numOvrlapgAdtlPbchRb = (cell->pbchRbEnd) - ((dlSf->bwAlloced + allocInfo->rbsReq) -  addtlRbsAdd);
23762
23763           divResult = (numOvrlapgAdtlPbchRb * pbchSsRsSym)/totSym;
23764           if((numOvrlapgAdtlPbchRb * pbchSsRsSym) % totSym)
23765           {
23766              divResult++;
23767           }
23768
23769           moreAddtlRbsReq =  divResult;
23770
23771           RG_SCH_CMN_UPD_RBS_TO_ADD(cell, dlSf, allocInfo, moreAddtlRbsReq, moreAddtlRbsAdd)
23772
23773           allocInfo->rbsReq = allocInfo->rbsReq + moreAddtlRbsAdd;
23774       }
23775    }
23776    if (isBcchPcch == TRUE)
23777    {
23778       RETVOID;
23779    }
23780
23781    RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
23782    if(tbs == 6)
23783    {
23784       /* This case might be for Imcs value 6 and NPrb = 1 case  - Not
23785          Adjusting either RBs or Imcs or Bytes Allocated */
23786       allocInfo->rbsReq = allocInfo->rbsReq - addtlRbsAdd - moreAddtlRbsAdd;
23787    }
23788    else if(tbs && ((0 == addtlRbsAdd) && (moreAddtlRbsAdd == 0)))
23789    {
23790        /*In case of a situation where we the entire bandwidth is already occupied
23791         * and we dont have room to add additional Rbs then in order to decrease the
23792         * code rate we reduce the tbsize such that we reduce the present calculated
23793         * tbsize by number of bytes that would be occupied by PBCH/PSS/SSS in overlapping
23794         * rbs and find the nearest tbsize which would be less than this deduced value*/
23795
23796       rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,&numOvrlapgPbchRb);
23797
23798       noLyr = allocInfo->tbInfo[0].noLyr;
23799       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[noLyr - 1], tbs);
23800       bytesReq = rgTbSzTbl[noLyr - 1][tbs][allocInfo->rbsReq - 1]/8;
23801
23802       rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,0,bytesReq);
23803
23804       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23805       {
23806           noLyr = allocInfo->tbInfo[1].noLyr;
23807           bytesReq = rgTbSzTbl[noLyr - 1][tbs][allocInfo->rbsReq - 1]/8;
23808           rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,1,bytesReq);
23809       }
23810
23811    }
23812    else if(tbs && ((addtlRbsAdd != addtlRbsReq) ||
23813           (addtlRbsAdd && (moreAddtlRbsReq != moreAddtlRbsAdd))))
23814    {
23815        /*In case of a situation where we were not able to add required number of
23816         * additional RBs then we adjust the Imcs based on original RBs requested.
23817         * Doing this would comensate for the few extra Rbs we have added but inorder
23818         * to comensate for number of RBS we couldnt add we again do the TBSize adjustment*/
23819
23820       rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 0 , origRbsReq);
23821
23822       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23823       {
23824           rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 1 , origRbsReq);
23825       }
23826
23827       rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,&numOvrlapgPbchRb);
23828       numOvrlapgPbchRb = numOvrlapgPbchRb - (addtlRbsAdd + moreAddtlRbsAdd);
23829
23830       rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,0,allocInfo->tbInfo[0].bytesReq);
23831
23832       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23833       {
23834           rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,1,allocInfo->tbInfo[1].bytesReq);
23835       }
23836
23837    }
23838    else
23839    {
23840        /*We hit this code when we were able to add the required additional RBS
23841         * hence we should adjust the IMcs based on orignals RBs requested*/
23842
23843       rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 0 , origRbsReq);
23844
23845       if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
23846       {
23847           rgSCHCmnNonDlfsPbchTbImcsAdj(cell, allocInfo, 1 , origRbsReq);
23848       }
23849    }
23850
23851    RETVOID;
23852 } /* end of rgSCHCmnNonDlfsPbchRbAllocAdj */
23853 #endif
23854
23855 /**
23856  * @brief Performs RB allocation for frequency non-selective cell.
23857  *
23858  * @details
23859  *
23860  *     Function : rgSCHCmnNonDlfsCmnRbAlloc
23861  *
23862  *     Processing Steps:
23863  *      - Allocate consecutively available RBs for BCCH/PCCH/RAR.
23864  *
23865  *  @param[in]      RgSchCellCb     *cell
23866  *  @param[in, out] RgSchDlRbAlloc  *allocInfo
23867  *  @return  S16
23868  *      -# ROK
23869  *      -# RFAILED
23870  **/
23871 #ifdef ANSI
23872 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc
23873 (
23874 RgSchCellCb      *cell,
23875 RgSchDlRbAlloc   *allocInfo
23876 )
23877 #else
23878 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
23879 RgSchCellCb      *cell;
23880 RgSchDlRbAlloc   *allocInfo;
23881 #endif
23882 {
23883 #ifndef LTE_TDD
23884 #ifdef LTEMAC_SPS
23885 #endif
23886    U8 pbchSsRsSym = 0;
23887    U8 pbchFrame = 0;
23888    U8  tbs = 0;
23889    RgSchCmnDlCell   *cellDl    = RG_SCH_CMN_GET_DL_CELL(cell); 
23890 #endif
23891    RgSchDlSf     *dlSf   = allocInfo->dlSf;
23892 #ifdef LTEMAC_SPS
23893    U8                  rbStart = 0;
23894    U8                  spsRbsAlloc = 0;
23895    RgSchDlSfAllocInfo  *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
23896 #endif
23897    TRC2(rgSCHCmnNonDlfsCmnRbAlloc);
23898
23899    allocInfo->tbInfo[0].noLyr = 1;
23900
23901 #ifdef LTEMAC_SPS
23902    /* Note: Initialize the masks to 0, this might not be needed since alloInfo
23903     * is initialized to 0 at the beginning of allcoation */
23904    allocInfo->resAllocInfo.raType0Mask = 0;
23905    cmMemset((U8*)allocInfo->resAllocInfo.raType1Mask, 0,
23906          RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
23907    cmMemset((U8*)allocInfo->resAllocInfo.raType2Mask, 0,
23908          RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
23909
23910    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
23911          (dlSf->bwAlloced == dlSf->bw))
23912 #else
23913    if(dlSf->bwAlloced == dlSf->bw)
23914 #endif
23915    {
23916       RETVALUE(RFAILED);
23917    }
23918 #ifndef LTE_TDD
23919    if (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced))
23920    {
23921 #ifdef LTEMAC_SPS
23922       if ((allocInfo->tbInfo[0].imcs < 29) && (dlSf->bwAlloced < dlSf->bw))
23923 #else
23924       if(allocInfo->tbInfo[0].imcs < 29)
23925 #endif
23926       {
23927          /* set the remaining RBs for the requested UE */
23928          allocInfo->rbsReq = dlSf->bw - dlSf->bwAlloced;
23929          RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
23930          allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[0][tbs][allocInfo->rbsReq - 1]/8;
23931       }
23932       else
23933       {
23934 #ifdef LTEMAC_SPS
23935          /* Attempt RA Type 2 allocation in SPS Bandwidth */
23936          if (dlSf->spsAllocdBw < cell->spsBwRbgInfo.numRbs) 
23937          {
23938             spsRbsAlloc =
23939                rgSCHCmnDlRaType2Alloc(dlSfAlloc,
23940                      allocInfo->rbsReq, &cell->spsBwRbgInfo, &rbStart,
23941                      &allocInfo->resAllocInfo, FALSE);
23942             /* rbsAlloc assignment moved from line 16671 to here to avoid
23943              * compilation error. Recheck */
23944             dlSf->spsAllocdBw += spsRbsAlloc;
23945          }
23946          if (!spsRbsAlloc)
23947 #endif /* LTEMAC_SPS */
23948          {
23949             RETVALUE(RFAILED);
23950          }
23951       }
23952    }
23953 #endif
23954
23955    /* Update allocation information */
23956    allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
23957    if (allocInfo->pdcch == NULLP)
23958    {
23959       RETVALUE(RFAILED);
23960    }
23961    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
23962    allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
23963    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
23964    allocInfo->allocInfo.raType2.isLocal = TRUE;
23965 #ifdef LTEMAC_SPS
23966    if (spsRbsAlloc) 
23967    {
23968       allocInfo->allocInfo.raType2.rbStart = rbStart;
23969       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
23970       allocInfo->rbsAlloc = allocInfo->rbsReq;
23971    }
23972 #endif
23973
23974 #ifdef LTEMAC_SPS
23975    if (!spsRbsAlloc)
23976    {
23977 #endif
23978 #ifndef LTE_TDD
23979       if(dlSf->sfNum)
23980       {
23981          if(!(dlSf->sfNum == 5))
23982          {
23983             /* case for subframes 1 to 9 except 5 */
23984 #ifdef LTEMAC_SPS
23985             allocInfo->allocInfo.raType2.rbStart = rbStart;
23986 #else
23987             /*Fix for ccpu00123918*/
23988             allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
23989 #endif
23990          }
23991          else
23992          {
23993             pbchFrame = 1; /* case for subframe 5 */
23994             /* In subframe 5, symbols are reserved for PSS and SSS and CFICH
23995                and Cell Specific Reference Signals */
23996             pbchSsRsSym = (((cellDl->currCfi) + RGSCH_NUM_PSS_SSS_SYM) *
23997                   RGSCH_NUM_SC_IN_RB + cell->numCellRSPerSf);
23998          }
23999       }
24000       else
24001       {
24002          pbchFrame = 1;
24003          /* In subframe 0, symbols are reserved for PSS, SSS, PBCH, CFICH and
24004             and Cell Specific Reference signals */
24005          pbchSsRsSym = (((cellDl->currCfi) + RGSCH_NUM_PBCH_SYM +
24006                   RGSCH_NUM_PSS_SSS_SYM) * RGSCH_NUM_SC_IN_RB +
24007                cell->numCellRSPerSf);
24008       } /* end of outer else */
24009
24010       if((pbchFrame) &&
24011             (((dlSf->bwAlloced + allocInfo->rbsReq) - cell->pbchRbStart) > 0)&&
24012             (dlSf->bwAlloced < cell->pbchRbEnd))
24013       {
24014          if(allocInfo->tbInfo[0].imcs < 29)
24015          {
24016             rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo, pbchSsRsSym, TRUE);
24017          }
24018       }
24019 #endif
24020 #ifdef LTEMAC_SPS
24021    }
24022 #endif
24023
24024 #ifdef LTEMAC_SPS
24025    if (!spsRbsAlloc)
24026    {  
24027 #endif
24028       /*Fix for ccpu00123918*/
24029       allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
24030       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
24031       allocInfo->rbsAlloc = allocInfo->rbsReq;
24032
24033       /* LTE_ADV_FLAG_REMOVED_START */
24034 #ifndef LTE_TDD
24035       if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
24036       {
24037          rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, \
24038                allocInfo->allocInfo.raType2.rbStart, \
24039                allocInfo->allocInfo.raType2.numRb);
24040       }
24041       else
24042 #endif
24043       {
24044          rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, \
24045                allocInfo->allocInfo.raType2.rbStart, \
24046                allocInfo->allocInfo.raType2.numRb);
24047       }
24048
24049 #ifdef LTEMAC_SPS
24050    }
24051 #endif
24052    /* LTE_ADV_FLAG_REMOVED_END */
24053    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
24054
24055
24056 #ifdef LTEMAC_SPS
24057    if (spsRbsAlloc)
24058    {
24059       U8    idx;
24060       /* Update type 0, 1 and 2 masks */
24061       dlSfAlloc->raType0Mask    |= allocInfo->resAllocInfo.raType0Mask;
24062 #ifdef RGSCH_SPS_UNUSED
24063       for (idx = 0; idx < RG_SCH_NUM_RATYPE1_32BIT_MASK; ++idx)
24064       {
24065          dlSfAlloc->raType1Mask[idx] |=
24066             allocInfo->resAllocInfo.raType1Mask[idx];
24067          dlSfAlloc->raType1UsedRbs[idx] +=
24068             allocInfo->resAllocInfo.raType1UsedRbs[idx];
24069       }
24070 #endif
24071       for (idx = 0; idx < RG_SCH_NUM_RATYPE2_32BIT_MASK; ++idx)
24072       {
24073          dlSfAlloc->raType2Mask[idx] |=
24074             allocInfo->resAllocInfo.raType2Mask[idx];
24075       }
24076    }
24077 #endif
24078
24079    RETVALUE(ROK);
24080 }
24081
24082
24083 /**
24084  * @brief Performs RB allocation for frequency non-selective cell.
24085  *
24086  * @details
24087  *
24088  *     Function : rgSCHCmnNonDlfsCmnRbAllocRar
24089  *
24090  *     Processing Steps:
24091  *      - Allocate consecutively available RBs for BCCH/PCCH/RAR.
24092  *
24093  *  @param[in]      RgSchCellCb     *cell
24094  *  @param[in, out] RgSchDlRbAlloc  *allocInfo
24095  *  @return  S16
24096  *      -# ROK
24097  *      -# RFAILED
24098  **/
24099 #ifdef ANSI
24100 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAllocRar
24101 (
24102  RgSchCellCb      *cell,
24103  RgSchDlRbAlloc   *allocInfo
24104  )
24105 #else
24106 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
24107    RgSchCellCb      *cell;
24108    RgSchDlRbAlloc   *allocInfo;
24109 #endif
24110 {
24111    RgSchDlSf     *dlSf   = allocInfo->dlSf;
24112    TRC2(rgSCHCmnNonDlfsCmnRbAllocRar);
24113
24114
24115    if(dlSf->bwAlloced == dlSf->bw)
24116    {
24117       RETVALUE(RFAILED);
24118    }
24119
24120    allocInfo->tbInfo[0].noLyr = 1;
24121 #ifndef RG_5GTF
24122    /* Update allocation information */
24123    allocInfo->pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
24124    if (allocInfo->pdcch == NULLP)
24125    {
24126       RETVALUE(RFAILED);
24127    }
24128    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
24129    allocInfo->pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_1A];
24130    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
24131    allocInfo->allocInfo.raType2.isLocal = TRUE;
24132
24133    /*Fix for ccpu00123918*/
24134    allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
24135    allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
24136    allocInfo->rbsAlloc = allocInfo->rbsReq;
24137
24138    /* LTE_ADV_FLAG_REMOVED_END */
24139    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
24140
24141 #else
24142    allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, NULLP, dlSf, 13, TFU_DCI_FORMAT_B1, FALSE);
24143    if (allocInfo->pdcch == NULLP)
24144    {
24145       RETVALUE(RFAILED);
24146    }
24147    RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[0]);
24148    if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
24149    {
24150       printf("5GTF_ERROR vrbg allocated > 25\n");
24151       RETVALUE(RFAILED);
24152    }
24153
24154    allocInfo->tbInfo[0].cmnGrnt.vrbgStart = beamInfo->vrbgStart;
24155    allocInfo->tbInfo[0].cmnGrnt.numVrbg = allocInfo->vrbgReq;
24156
24157    /* Update allocation information */
24158    allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
24159
24160    allocInfo->tbInfo[0].cmnGrnt.xPDSCHRange = 1;  
24161    allocInfo->tbInfo[0].cmnGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
24162          allocInfo->tbInfo[0].cmnGrnt.vrbgStart, allocInfo->tbInfo[0].cmnGrnt.numVrbg);
24163
24164    allocInfo->tbInfo[0].cmnGrnt.rbStrt = (allocInfo->tbInfo[0].cmnGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
24165    allocInfo->tbInfo[0].cmnGrnt.numRb = (allocInfo->tbInfo[0].cmnGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
24166
24167    beamInfo->vrbgStart += allocInfo->tbInfo[0].cmnGrnt.numVrbg;
24168    beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].cmnGrnt.numVrbg;
24169    allocInfo->tbInfo[0].cmnGrnt.rv = 0;
24170    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
24171
24172 #endif
24173    printf("\n[%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
24174          __func__,allocInfo->tbInfo[0].bytesAlloc,allocInfo->vrbgReq);
24175
24176    RETVALUE(ROK);
24177 }
24178
24179
24180 /* LTE_ADV_FLAG_REMOVED_START */
24181 #ifndef LTE_TDD
24182 /**
24183  * @brief To check if DL BW available for non-DLFS allocation.
24184  *
24185  * @details
24186  *
24187  *     Function : rgSCHCmnNonDlfsBwAvlbl
24188  *
24189  *     Processing Steps:
24190  *      - Determine availability based on RA Type.
24191  *
24192  *  @param[in]  RgSchCellCb     *cell
24193  *  @param[in]  RgSchDlSf       *dlSf
24194  *  @param[in]  RgSchDlRbAlloc  *allocInfo
24195  *
24196  *  @return Bool
24197  *      -# TRUE
24198  *      -# FALSE
24199  **/
24200 #ifdef ANSI
24201 PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl
24202 (
24203 RgSchCellCb        *cell,
24204 RgSchSFRPoolInfo   **sfrpoolInfo,
24205 RgSchDlSf          *dlSf,
24206 RgSchDlRbAlloc     *allocInfo,
24207 Bool               isUeCellEdge
24208 )
24209 #else
24210 PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl(cell, sfrpoolInfo, dlSf, allocInfo, isUeCellEdge)
24211 RgSchCellCb        *cell;
24212 RgSchSFRPoolInfo   **sfrpoolInfo;
24213 RgSchDlSf          *dlSf;
24214 RgSchDlRbAlloc     *allocInfo;
24215 Bool               isUeCellEdge;
24216 #endif
24217 {
24218    CmLListCp   *l;
24219    CmLListCp   *l1;
24220    CmLList     *n;
24221    CmLList     *n1;
24222    RgSchSFRPoolInfo  *sfrPool;
24223    RgSchSFRPoolInfo  *sfrCEPool;
24224
24225    U8 tbs;
24226    U8 noLyrs;
24227    RgSchSFRPoolInfo *poolWithMaxAvlblBw = NULLP;
24228    U32 bwAvlbl = 0;
24229    U32 addtnlPRBs = 0;
24230
24231    if (dlSf->bw <= dlSf->bwAlloced)
24232    {
24233       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
24234             "BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
24235       return FALSE;
24236    }
24237
24238    if (dlSf->sfrTotalPoolInfo.ccBwFull == TRUE)
24239    {
24240       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
24241             "BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
24242       return FALSE;
24243    }
24244
24245    if ((dlSf->sfrTotalPoolInfo.ceBwFull == TRUE) && (isUeCellEdge))
24246    {
24247       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
24248             "BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
24249       return FALSE;
24250    }  
24251
24252    /* We first check if the ue scheduled is a cell edge or cell centre and accordingly check the avaialble
24253       memory in their pool. If the cell centre UE doesnt have Bw available in its pool, then it will check
24254       Bw availability in cell edge pool but the other way around is NOT possible.   */
24255    if(isUeCellEdge)
24256    {   
24257       l = &dlSf->sfrTotalPoolInfo.cePool;
24258    }
24259    else
24260    {
24261       l = &dlSf->sfrTotalPoolInfo.ccPool; 
24262    }     
24263
24264    n = cmLListFirst(l);
24265
24266    while(n)       
24267    {
24268       if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
24269       {
24270          sfrPool = (RgSchSFRPoolInfo*)(n->node);
24271
24272          /* MS_FIX for ccpu00123919 : Number of RBs in case of RETX should be same as that of initial transmission. */
24273          if(allocInfo->tbInfo[0].tbCb->txCntr)
24274          {
24275             /* If RB assignment is being done for RETX. Then if reqRbs are   a multiple of rbgSize then ignore lstRbgDfct. If reqRbs is 
24276              * not a multiple of rbgSize then check if lsgRbgDfct exists */
24277             if (allocInfo->rbsReq % cell->rbgSize == 0)
24278             {
24279                if ((sfrPool->type2End == dlSf->type2End) && dlSf->lstRbgDfct)
24280                {
24281                   /* In this scenario we are wasting the last RBG for this dlSf */
24282                   sfrPool->type0End--;
24283                   sfrPool->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24284
24285                   dlSf->lstRbgDfct = 0;
24286
24287                   /*ABHINAV To check if these variables need to be taken care of*/
24288                   dlSf->type0End--;
24289                   dlSf->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24290                }
24291             }
24292             else
24293             {
24294                if (dlSf->lstRbgDfct)
24295                {
24296                   /* Check if type0 allocation can cater to this RETX requirement */
24297                   if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
24298                   {
24299                      RETVALUE(FALSE);
24300                   }
24301                   else
24302                   {
24303                      if (sfrPool->type2End != dlSf->type2End)   /*Search again for some pool which has the END RBG of the BandWidth*/
24304                      {
24305                         continue;                                       
24306                      }  
24307                   }
24308                }
24309                else
24310                {
24311                   /* cannot allocate same number of required RBs */
24312                   RETVALUE(FALSE);                   
24313                }
24314             }
24315          }
24316
24317          /*rg002.301 ccpu00120391 MOD condition is modified approprialtely to find if rbsReq is less than available RBS*/
24318          if(allocInfo->rbsReq <= (((sfrPool->type0End - sfrPool->type2End + 1)*\
24319                      cell->rbgSize) - dlSf->lstRbgDfct))
24320          {
24321             *sfrpoolInfo = sfrPool;
24322             RETVALUE(TRUE);
24323          }
24324          else
24325          {
24326             if (sfrPool->bw <= sfrPool->bwAlloced + cell->rbgSize)
24327             {
24328                n = cmLListNext(l);
24329                /* If the ue is cell centre then it will simply check the memory available in next pool.
24330                   But if there are no more memory pools available, then cell centre Ue will try to look for memory in cell edge pool */
24331
24332                if((!isUeCellEdge) && (!n->node))
24333                {
24334                   l = &dlSf->sfrTotalPoolInfo.cePool;
24335                   n = cmLListFirst(l);
24336                }
24337
24338                continue; 
24339             }    
24340
24341             /* MS_FIX: Number of RBs in case of RETX should be same as that of initial transmission */
24342             if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24343             {
24344                /*rg002.301 ccpu00120391 MOD setting the remaining RBs  for the requested UE*/
24345                allocInfo->rbsReq = (((sfrPool->type0End - sfrPool->type2End + 1)*\
24346                         cell->rbgSize) - dlSf->lstRbgDfct);
24347                RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24348                noLyrs = allocInfo->tbInfo[0].noLyr;
24349                allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24350                *sfrpoolInfo = sfrPool;
24351                RETVALUE(TRUE);
24352             }
24353             else
24354             {
24355                n = cmLListNext(l);
24356
24357                /* If the ue is cell centre then it will simply check the memory available in next pool.
24358                   But if there are no more memory pools available, then cell centre Ue will try to look for memory in cell edge pool */
24359                if((!isUeCellEdge) && (!n->node))
24360                {
24361                   l = &dlSf->sfrTotalPoolInfo.cePool;
24362                   n = cmLListFirst(l);
24363                }
24364
24365                continue;
24366             }
24367
24368          //   RETVALUE(FALSE);
24369          }
24370       }
24371       else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
24372       {
24373          sfrPool = (RgSchSFRPoolInfo*)(n->node);
24374          /* This is a Case where a UE was CC and had more RBs allocated than present in CE pool.
24375             In case this UE whn become CE with retx going on, then BW is not sufficient for Retx */
24376          if ((isUeCellEdge) &&
24377             (allocInfo->tbInfo[0].tbCb->txCntr != 0))
24378          {
24379             if(allocInfo->rbsReq > (sfrPool->bw - sfrPool->bwAlloced))
24380             {
24381                /* Adjust CE BW such that Retx alloc is successful */
24382                /* Check if merging CE with adjacent CC pool will be sufficient to process Retx */
24383
24384                /* If no Type 0 allocations are made from this pool */
24385                if (sfrPool->type0End == (((sfrPool->poolendRB + 1) / cell->rbgSize) - 1))
24386                {
24387                   if (sfrPool->adjCCPool &&
24388                         (sfrPool->adjCCPool->type2Start == sfrPool->poolendRB + 1) &&
24389                         (allocInfo->rbsReq <= ((sfrPool->bw - sfrPool->bwAlloced) + 
24390                                                ((sfrPool->adjCCPool->bw - sfrPool->adjCCPool->bwAlloced)))))
24391                   {
24392                      addtnlPRBs = allocInfo->rbsReq - (sfrPool->bw - sfrPool->bwAlloced);
24393
24394                      /* Adjusting CE Pool Info */
24395                      sfrPool->bw += addtnlPRBs;
24396                      sfrPool->type0End = ((sfrPool->poolendRB + addtnlPRBs + 1) /
24397                            cell->rbgSize) - 1;
24398
24399                      /* Adjusting CC Pool Info */
24400                      sfrPool->adjCCPool->type2Start += addtnlPRBs;
24401                      sfrPool->adjCCPool->type2End = RGSCH_CEIL(sfrPool->adjCCPool->type2Start, 
24402                            cell->rbgSize);
24403                      sfrPool->adjCCPool->bw -= addtnlPRBs;
24404                      *sfrpoolInfo = sfrPool;
24405                      RETVALUE(TRUE);
24406                   }
24407                }
24408             }
24409          }
24410
24411          /* Check if CC pool is one of the following:
24412           * 1. |CE| + |CC "CCPool2Exists" = TRUE|
24413           * 2. |CC "CCPool2Exists" = FALSE| + |CE| + |CC "CCPool2Exists" = TRUE|
24414           */ 
24415          if(TRUE == sfrPool->CCPool2Exists)
24416          {
24417             l1 = &dlSf->sfrTotalPoolInfo.cePool;
24418             n1 = cmLListFirst(l1); 
24419             sfrCEPool = (RgSchSFRPoolInfo*)(n1->node);
24420             if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced))
24421             {
24422                *sfrpoolInfo = sfrCEPool;
24423                RETVALUE(TRUE);
24424             }
24425             else if(allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))  
24426             {
24427                *sfrpoolInfo = sfrPool;
24428                RETVALUE(TRUE);
24429             }
24430             /* Check if CE and CC boundary has unallocated prbs */
24431             else if ((sfrPool->poolstartRB == sfrPool->type2Start) &&
24432                   (sfrCEPool->type0End  == ((sfrCEPool->poolendRB + 1) / cell->rbgSize) - 1))
24433             {
24434                if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced) + 
24435                      (sfrPool->bw - sfrPool->bwAlloced))
24436                {
24437                   /* Checking if BW can be allocated partly from CE pool and partly
24438                    * from CC pool
24439                    */
24440                   addtnlPRBs = allocInfo->rbsReq - (sfrPool->bw - sfrPool->bwAlloced);
24441                   /* Updating CE and CC  type2 parametrs based on the RBs allocated
24442                    * from these pools*/
24443                   sfrPool->type2Start -= addtnlPRBs;
24444                   sfrPool->type2End = RGSCH_CEIL(sfrPool->type2Start, cell->rbgSize);
24445                   sfrPool->bw += addtnlPRBs;
24446                   if (addtnlPRBs == (sfrCEPool->bw - sfrCEPool->bwAlloced))
24447                   {
24448                      sfrCEPool->bwAlloced  = sfrCEPool->bw; 
24449                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE;
24450                   }
24451                   else
24452                   {
24453                      sfrCEPool->bw -= addtnlPRBs;
24454                      sfrCEPool->type0End = ((sfrCEPool->poolendRB + 1 - addtnlPRBs) / cell->rbgSize) - 1;
24455                   }
24456                   *sfrpoolInfo = sfrPool;
24457                   RETVALUE(TRUE);
24458                }
24459                else if ( bwAvlbl < 
24460                      ((sfrCEPool->bw - sfrCEPool->bwAlloced) +
24461                       (sfrPool->bw - sfrPool->bwAlloced)))
24462                {
24463                   /* All the Prbs from CE BW shall be allocated */
24464                   if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24465                   {
24466                      sfrPool->type2Start   = sfrCEPool->type2Start;
24467                      sfrPool->bw          += sfrCEPool->bw - sfrCEPool->bwAlloced;
24468                      sfrCEPool->type2Start = sfrCEPool->poolendRB + 1;
24469                      sfrCEPool->bwAlloced  = sfrCEPool->bw; 
24470                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE;
24471
24472                      /* set the remaining RBs for the requested UE */
24473                      allocInfo->rbsReq = (sfrPool->bw - sfrPool->bwAlloced);
24474                      RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24475                      noLyrs = allocInfo->tbInfo[0].noLyr;
24476                      allocInfo->tbInfo[0].bytesReq = 
24477                         rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24478                      *sfrpoolInfo = sfrPool;               
24479                      RETVALUE(TRUE);
24480                   }
24481                   else
24482                   {
24483                      RETVALUE(FALSE);
24484                   }
24485                }
24486             }
24487          } 
24488
24489          /* Checking if no. of RBs required can be allocated from
24490           * SFR pool. 
24491           * 1. If available return the SFR pool.
24492           * 2. Else update the RBs required parameter based on the 
24493           *    BW available in the pool 
24494           * 3. Return FALSE if no B/W is available. 
24495           */
24496          if (allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
24497          {
24498             *sfrpoolInfo = sfrPool;
24499             RETVALUE(TRUE);
24500          }
24501          else
24502          {
24503             if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24504             {
24505                if (bwAvlbl < sfrPool->bw - sfrPool->bwAlloced)
24506                {
24507                   if (isUeCellEdge)
24508                   {
24509                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE; 
24510                   }
24511                   bwAvlbl = sfrPool->bw - sfrPool->bwAlloced;
24512                   poolWithMaxAvlblBw = sfrPool;
24513                }
24514                n = cmLListNext(l);
24515
24516                if ((isUeCellEdge == FALSE) && (n == NULLP))
24517                {
24518                   if(l != &dlSf->sfrTotalPoolInfo.cePool)
24519                   {
24520                      l = &dlSf->sfrTotalPoolInfo.cePool;
24521                      n = cmLListFirst(l);                          
24522                   }
24523                }
24524
24525                if (n == NULLP)
24526                {
24527                   if (bwAvlbl == 0)
24528                   {                                                             
24529                      if (isUeCellEdge)
24530                      {
24531                         dlSf->sfrTotalPoolInfo.ceBwFull = TRUE; 
24532                      }
24533                      else
24534                      {
24535                         dlSf->sfrTotalPoolInfo.ccBwFull = TRUE;  
24536                      }
24537                      RETVALUE(FALSE);
24538                   }
24539                   else
24540                   {
24541                      /* set the remaining RBs for the requested UE */
24542                      allocInfo->rbsReq = poolWithMaxAvlblBw->bw - 
24543                         poolWithMaxAvlblBw->bwAlloced;
24544                      RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24545                      noLyrs = allocInfo->tbInfo[0].noLyr;
24546                      allocInfo->tbInfo[0].bytesReq = 
24547                         rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24548                      *sfrpoolInfo = poolWithMaxAvlblBw;            
24549                      RETVALUE(TRUE);
24550                   }
24551                }                          
24552             }
24553             else
24554             {                   
24555                n = cmLListNext(l);
24556
24557                if ((isUeCellEdge == FALSE) && (n == NULLP))
24558                {
24559                   if(l != &dlSf->sfrTotalPoolInfo.cePool)
24560                   {
24561                      l = &dlSf->sfrTotalPoolInfo.cePool;
24562                      n = cmLListFirst(l);                          
24563                   }
24564                }
24565
24566                if (n == NULLP)
24567                {
24568                   RETVALUE(FALSE);
24569                }
24570             }
24571
24572          }
24573       }   
24574    } 
24575    RETVALUE(FALSE);
24576 }
24577 #endif /* end of ifndef LTE_TDD*/
24578 /* LTE_ADV_FLAG_REMOVED_END */
24579
24580 /**
24581  * @brief To check if DL BW available for non-DLFS allocation.
24582  *
24583  * @details
24584  *
24585  *     Function : rgSCHCmnNonDlfsUeRbAlloc
24586  *
24587  *     Processing Steps:
24588  *      - Determine availability based on RA Type.
24589  *
24590  *  @param[in]  RgSchCellCb     *cell
24591  *  @param[in]  RgSchDlSf       *dlSf
24592  *  @param[in]  RgSchDlRbAlloc  *allocInfo
24593  *
24594  *  @return Bool
24595  *      -# TRUE
24596  *      -# FALSE
24597  **/
24598 #ifdef ANSI
24599 PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl
24600 (
24601 RgSchCellCb        *cell,
24602 RgSchDlSf          *dlSf,
24603 RgSchDlRbAlloc     *allocInfo
24604 )
24605 #else
24606 PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl(cell, dlSf, allocInfo)
24607 RgSchCellCb        *cell;
24608 RgSchDlSf          *dlSf;
24609 RgSchDlRbAlloc     *allocInfo;
24610 #endif
24611 {
24612    U8 tbs;
24613    U8 noLyrs;
24614    U8 ignoredDfctRbg = FALSE;
24615
24616    TRC2(rgSCHCmnNonDlfsBwAvlbl);
24617    if (dlSf->bw <= dlSf->bwAlloced)
24618    {
24619       RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
24620          dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
24621       RETVALUE(FALSE);
24622    }
24623    if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
24624    {
24625        /* Fix for ccpu00123919 : Number of RBs in case of RETX should be same as 
24626         * that of initial transmission. */
24627        if(allocInfo->tbInfo[0].tbCb->txCntr)
24628        {
24629           /* If RB assignment is being done for RETX. Then if reqRbs are 
24630            * a multiple of rbgSize then ignore lstRbgDfct. If reqRbs is 
24631            * not a multiple of rbgSize then check if lsgRbgDfct exists */
24632           if (allocInfo->rbsReq % cell->rbgSize == 0)
24633           {
24634              if (dlSf->lstRbgDfct)
24635              {
24636                 /* In this scenario we are wasting the last RBG for this dlSf */
24637                 
24638                 dlSf->type0End--;
24639                 dlSf->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24640                 /* Fix: MUE_PERTTI_DL */
24641                 dlSf->lstRbgDfct = 0;
24642                 ignoredDfctRbg = TRUE;
24643                 
24644              }
24645           }
24646           else
24647           {
24648              if (dlSf->lstRbgDfct)
24649              {
24650                 /* Check if type0 allocation can cater to this RETX requirement */
24651                 if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
24652                 {
24653                    RETVALUE(FALSE);
24654                 }
24655              }
24656              else
24657              {
24658                 /* cannot allocate same number of required RBs */
24659                 RETVALUE(FALSE);                     
24660              }
24661           }
24662        }
24663
24664        /* Condition is modified approprialtely to find
24665         * if rbsReq is less than available RBS*/
24666       if(allocInfo->rbsReq <= (((dlSf->type0End - dlSf->type2End + 1)*\
24667                cell->rbgSize) - dlSf->lstRbgDfct))
24668       {
24669          RETVALUE(TRUE);
24670       }
24671       /* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB 
24672        * allocation in TDD when requested RBs are more than available RBs*/
24673       else
24674       {
24675           /* MS_WORKAROUND for ccpu00122022 */
24676          if (dlSf->bw < dlSf->bwAlloced + cell->rbgSize)
24677          {
24678             /* ccpu00132358- Re-assigning the values which were updated above 
24679              * if it is RETX and Last  RBG available*/
24680             if(ignoredDfctRbg == TRUE)
24681             {
24682                dlSf->type0End++;
24683                dlSf->bwAlloced -= (cell->rbgSize - dlSf->lstRbgDfct);
24684                dlSf->lstRbgDfct = 1;
24685             }
24686
24687
24688             RETVALUE(FALSE);
24689          }
24690          /* Fix: Number of RBs in case of RETX should be same as 
24691           * that of initial transmission. */
24692          if(allocInfo->tbInfo[0].tbCb->txCntr == 0 
24693 #ifdef LTE_ADV
24694             && (FALSE == rgSCHLaaIsLaaTB(allocInfo))
24695 #endif
24696             )
24697          {
24698             /* Setting the remaining RBs for the requested UE*/
24699             allocInfo->rbsReq = (((dlSf->type0End - dlSf->type2End + 1)*\
24700                         cell->rbgSize) - dlSf->lstRbgDfct);
24701             RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24702             noLyrs = allocInfo->tbInfo[0].noLyr;
24703             allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24704             /* DwPts Scheduling Changes Start */
24705 #if LTE_TDD
24706             if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
24707             {   
24708                allocInfo->tbInfo[0].bytesReq = 
24709                         rgTbSzTbl[noLyrs-1][tbs][RGSCH_MAX(allocInfo->rbsReq*3/4,1) - 1]/8; 
24710             }
24711 #endif            
24712             /* DwPts Scheduling Changes End */
24713          }
24714          else
24715          {
24716                     /* ccpu00132358- Re-assigning the values which were updated above 
24717              * if it is RETX and Last  RBG available*/
24718             if(ignoredDfctRbg == TRUE)
24719             {
24720                dlSf->type0End++;
24721                dlSf->bwAlloced -= (cell->rbgSize - dlSf->lstRbgDfct);
24722                dlSf->lstRbgDfct = 1;
24723             }
24724
24725             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
24726                   allocInfo->rnti);
24727             printf ("RB Alloc failed for LAA TB type 0\n");
24728             RETVALUE(FALSE);
24729          }
24730          RETVALUE(TRUE);
24731       }
24732    }
24733    else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
24734    {
24735       if (allocInfo->rbsReq <= (dlSf->bw - dlSf->bwAlloced))
24736       {
24737          RETVALUE(TRUE);
24738       }
24739       /* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB 
24740        * allocation in TDD when requested RBs are more than available RBs*/
24741       else
24742       {
24743          /* Fix: Number of RBs in case of RETX should be same as 
24744           * that of initial transmission. */
24745          if((allocInfo->tbInfo[0].tbCb->txCntr == 0) 
24746 #ifdef LTE_ADV
24747             && (FALSE == rgSCHLaaIsLaaTB(allocInfo))
24748 #endif
24749             )
24750          {
24751             /* set the remaining RBs for the requested UE */
24752             allocInfo->rbsReq = dlSf->bw - dlSf->bwAlloced;
24753             RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24754             noLyrs = allocInfo->tbInfo[0].noLyr;
24755             allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24756             /* DwPts Scheduling Changes Start */
24757 #ifdef LTE_TDD
24758             if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
24759             {   
24760                allocInfo->tbInfo[0].bytesReq = 
24761                         rgTbSzTbl[noLyrs-1][tbs][RGSCH_MAX(allocInfo->rbsReq*3/4,1) - 1]/8; 
24762             }
24763 #endif            
24764             /* DwPts Scheduling Changes End */
24765          }
24766          else
24767          {
24768             printf ("RB Alloc failed for LAA TB type 2\n");
24769             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
24770             RETVALUE(FALSE);
24771          }
24772          /* Fix: Number of RBs in case of RETX should be same as 
24773           * that of initial transmission. */
24774          RETVALUE(TRUE);
24775       }
24776    }
24777    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
24778    RETVALUE(FALSE);
24779 }
24780 /* LTE_ADV_FLAG_REMOVED_START */
24781 #ifndef LTE_TDD
24782 /**
24783  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24784  *
24785  * @details
24786  *
24787  *     Function : rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
24788  *
24789  *     Processing Steps:
24790  *
24791  *  @param[in]  RgSchCellCb     *cell
24792  *  @param[in]  RgSchDlSf       *dlSf
24793  *  @param[in]  U8              rbStrt
24794  *  @param[in]  U8              numRb
24795  *
24796  *  @return Void
24797  **/
24798 #ifdef ANSI
24799 PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
24800 (
24801 RgSchCellCb        *cell,
24802 RgSchDlSf          *dlSf,
24803 U8                 rbStrt,
24804 U8                 numRb
24805 )
24806 #else
24807 PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
24808 RgSchCellCb        *cell;
24809 RgSchDlSf          *dlSf;
24810 U8                 rbStrt;
24811 U8                 numRb;
24812 #endif
24813 { 
24814    CmLListCp   *l;
24815    CmLList     *n;
24816    RgSchSFRPoolInfo  *sfrPool;
24817    TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
24818    
24819    l = &dlSf->sfrTotalPoolInfo.ccPool;
24820      
24821    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
24822    dlSf->bwAlloced += numRb;
24823    dlSf->type2Start += numRb;
24824    n = cmLListFirst(l);
24825         
24826    while(n->node)
24827    {
24828         sfrPool = (RgSchSFRPoolInfo*)(n->node);
24829         n = cmLListNext(l);
24830          
24831          /* 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   */
24832         if((sfrPool->poolendRB >= dlSf->type2Start) && (sfrPool->type2Start < dlSf->type2Start))
24833         {
24834                 sfrPool->type2End   =  dlSf->type2End;
24835                 sfrPool->bwAlloced  =  dlSf->type2Start - sfrPool->poolstartRB; 
24836                 sfrPool->type2Start =  dlSf->type2Start;
24837         }          
24838         else 
24839         { 
24840                 /* If the pool contains all RBs allocated in this allocation*/
24841                 if(dlSf->type2Start > sfrPool->poolendRB)
24842                 {                
24843                         sfrPool->type2End   =  sfrPool->type0End + 1;
24844                         sfrPool->bwAlloced  =  sfrPool->bw; 
24845                         sfrPool->type2Start =  sfrPool->poolendRB + 1;             
24846                 }  
24847         }
24848       if (!n)
24849       { 
24850          if (l != &dlSf->sfrTotalPoolInfo.cePool)
24851          {
24852             l = &dlSf->sfrTotalPoolInfo.cePool;   
24853             n = cmLListFirst(l);
24854          }
24855          else
24856             RETVOID;
24857       }
24858    }
24859    RETVOID;
24860 }
24861
24862 /**
24863  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24864  *
24865  * @details
24866  *
24867  *     Function : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
24868  *
24869  *     Processing Steps:
24870  *
24871  *  @param[in]  RgSchCellCb     *cell
24872  *  @param[in]  RgSchDlSf       *dlSf
24873  *  @param[in]  U8              rbStrt
24874  *  @param[in]  U8              numRb
24875  *
24876  *  @return Void
24877  **/
24878 #ifdef ANSI
24879 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
24880 (
24881 RgSchCellCb        *cell,
24882 RgSchUeCb          *ue,
24883 RgSchDlSf          *dlSf,
24884 U8                 rbStrt,
24885 U8                 numRb
24886 )
24887 #else
24888 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
24889 RgSchCellCb        *cell;
24890 RgSchUeCb          *ue;
24891 RgSchDlSf          *dlSf;
24892 U8                 rbStrt;
24893 U8                 numRb;
24894 #endif
24895 {
24896    CmLListCp   *l;
24897    CmLList     *n;
24898    RgSchSFRPoolInfo  *sfrCCPool1 = NULL;
24899    RgSchSFRPoolInfo  *sfrCCPool2 = NULL;
24900    S16 ret = RFAILED;
24901
24902    TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
24903    /* Move the type2End pivot forward */
24904    
24905    
24906    l = &dlSf->sfrTotalPoolInfo.ccPool;
24907    n = cmLListFirst(l);
24908    while(n)
24909    {
24910       sfrCCPool1 = (RgSchSFRPoolInfo*)(n->node);
24911       /* KWork fix */
24912       if (sfrCCPool1 ==  NULLP)
24913             {
24914                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
24915                         "sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
24916                RETVALUE(RFAILED);
24917             }
24918       n = cmLListNext(l);
24919       if(n)
24920       {
24921           sfrCCPool2 = (RgSchSFRPoolInfo*)(n->node);
24922           n = cmLListNext(l);
24923       }
24924       if((sfrCCPool1) && (sfrCCPool2))
24925       { 
24926           /* Based on RNTP info, the CC user is assigned high power per subframe basis */
24927           if(((dlSf->type2Start >= sfrCCPool1->pwrHiCCRange.startRb) &&
24928               (dlSf->type2Start + numRb < sfrCCPool1->pwrHiCCRange.endRb)) || 
24929              ((dlSf->type2Start >= sfrCCPool2->pwrHiCCRange.startRb) &&
24930               (dlSf->type2Start + numRb < sfrCCPool2->pwrHiCCRange.endRb)))
24931           {
24932                ue->lteAdvUeCb.isCCUePHigh = TRUE;
24933
24934                /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
24935                ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
24936                if (ret != ROK)
24937                {
24938                     RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
24939                       "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
24940                     RETVALUE(RFAILED);
24941                }
24942            }
24943       }
24944       else
24945       {
24946          if((dlSf->type2Start >= sfrCCPool1->pwrHiCCRange.startRb) &&
24947                (dlSf->type2Start + numRb < sfrCCPool1->pwrHiCCRange.endRb))
24948          {
24949             ue->lteAdvUeCb.isCCUePHigh = TRUE;
24950
24951             /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
24952             ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
24953             if (ret != ROK)
24954             {
24955                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,   "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():" 
24956                         "rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
24957                RETVALUE(RFAILED);
24958             }
24959          }
24960       }
24961    }
24962    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
24963 #ifndef LTEMAC_SPS
24964    dlSf->bwAlloced += numRb;
24965    /*MS_FIX for ccpu00123918*/
24966    dlSf->type2Start += numRb;
24967 #endif
24968    RETVALUE(ROK);
24969 }
24970 #endif /* end of ifndef LTE_TDD*/
24971 /* LTE_ADV_FLAG_REMOVED_END */
24972 /**
24973  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24974  *
24975  * @details
24976  *
24977  *     Function : rgSCHCmnNonDlfsUpdTyp2Alloc
24978  *
24979  *     Processing Steps:
24980  *
24981  *  @param[in]  RgSchCellCb     *cell
24982  *  @param[in]  RgSchDlSf       *dlSf
24983  *  @param[in]  U8              rbStrt
24984  *  @param[in]  U8              numRb
24985  *
24986  *  @return Void
24987  **/
24988 #ifdef ANSI
24989 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc
24990 (
24991 RgSchCellCb        *cell,
24992 RgSchDlSf          *dlSf,
24993 U8                 rbStrt,
24994 U8                 numRb
24995 )
24996 #else
24997 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
24998 RgSchCellCb        *cell;
24999 RgSchDlSf          *dlSf;
25000 U8                 rbStrt;
25001 U8                 numRb;
25002 #endif
25003 {
25004    TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
25005    /* Move the type2End pivot forward */
25006    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25007 //#ifndef LTEMAC_SPS
25008    dlSf->bwAlloced += numRb;
25009    /*Fix for ccpu00123918*/
25010    dlSf->type2Start += numRb;
25011 //#endif
25012    RETVOID;
25013 }
25014
25015 /**
25016  * @brief To do DL allocation using TYPE0 RA.
25017  *
25018  * @details
25019  *
25020  *     Function : rgSCHCmnNonDlfsType0Alloc
25021  *
25022  *     Processing Steps:
25023  *      - Perform TYPE0 allocation using the RBGs between
25024  *        type0End and type2End.
25025  *      - Build the allocation mask as per RBG positioning.
25026  *      - Update the allocation parameters.
25027  *
25028  *  @param[in]  RgSchCellCb     *cell
25029  *  @param[in]  RgSchDlSf       *dlSf
25030  *  @param[in]  RgSchDlRbAlloc  *allocInfo
25031  *
25032  *  @return Void
25033  **/
25034 #ifdef ANSI
25035 PRIVATE Void rgSCHCmnNonDlfsType0Alloc
25036 (
25037 RgSchCellCb        *cell,
25038 RgSchDlSf          *dlSf,
25039 RgSchDlRbAlloc     *allocInfo,
25040 RgSchUeCb          *ue
25041 )
25042 #else
25043 PRIVATE Void rgSCHCmnNonDlfsType0Alloc(cell, dlSf, allocInfo, dlUe)
25044 RgSchCellCb        *cell;
25045 RgSchDlSf          *dlSf;
25046 RgSchDlRbAlloc     *allocInfo;
25047 RgSchUeCb          *ue;
25048 #endif
25049 {
25050    U32 dlAllocMsk = 0;
25051    U8  rbgFiller = dlSf->lstRbgDfct;
25052    U8  noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
25053    //U8  noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
25054    U8  noRbs;
25055    U8  noLyr;
25056    U8  iTbs;
25057    U32          tb1BytesAlloc = 0;
25058    U32          tb2BytesAlloc = 0;
25059    RgSchCmnDlUe *dlUe         = RG_SCH_CMN_GET_DL_UE(ue,cell);
25060
25061    TRC2(rgSCHCmnNonDlfsType0Alloc);
25062    //if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
25063
25064    /* Fix for ccpu00123919*/
25065    noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25066    if (dlSf->bwAlloced + noRbs > dlSf->bw)
25067    {
25068       if (--noRbgs == 0)
25069       {
25070          RETVOID;
25071       }
25072       noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25073    }
25074
25075    /* Fix for ccpu00138701: Ceilling is using to derive num of RBGs, Therefore, 
25076    *  after this operation,checking Max TB size and Max RBs are not crossed
25077    * if it is crossed then decrement num of RBGs. */
25078    //if((noRbs + rbgFiller) % cell->rbgSize)
25079    if((noRbs > allocInfo->rbsReq) &&
25080          (allocInfo->rbsReq + rbgFiller) % cell->rbgSize)
25081    {/* considering ue category limitation
25082      * due to ceiling */
25083
25084 #ifdef LTE_ADV
25085       if (rgSCHLaaIsLaaTB(allocInfo)== FALSE)
25086 #endif
25087       {
25088          if ((allocInfo->tbInfo[0].schdlngForTb) && (!allocInfo->tbInfo[0].tbCb->txCntr))
25089          {
25090             iTbs = allocInfo->tbInfo[0].iTbs;
25091             noLyr = allocInfo->tbInfo[0].noLyr;
25092             tb1BytesAlloc = rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25093          }
25094
25095          if ((allocInfo->tbInfo[1].schdlngForTb) && (!allocInfo->tbInfo[1].tbCb->txCntr))
25096          {
25097             iTbs = allocInfo->tbInfo[1].iTbs;
25098             noLyr = allocInfo->tbInfo[1].noLyr;
25099             tb2BytesAlloc = rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25100          }
25101       }
25102       
25103       /* Only Check for New Tx No need for Retx */
25104       if (tb1BytesAlloc || tb2BytesAlloc)
25105       {
25106          if (( ue->dl.aggTbBits >= dlUe->maxTbBits) ||
25107                (tb1BytesAlloc >= dlUe->maxTbSz/8) ||
25108                (tb2BytesAlloc >= dlUe->maxTbSz/8) ||
25109                (noRbs >= dlUe->maxRb))
25110          {
25111             if (--noRbgs == 0)
25112             {
25113                RETVOID;
25114             }
25115             noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25116          }
25117       }
25118    }
25119    /* type0End would have been initially (during subfrm Init) at the bit position
25120     * (cell->noOfRbgs - 1), 0 being the most significant.
25121     * Getting DlAllocMsk for noRbgs and at the appropriate position */
25122    dlAllocMsk |= (((1 << noRbgs) - 1) << (31 - dlSf->type0End));
25123    /* Move backwards the type0End pivot */
25124    dlSf->type0End -= noRbgs;
25125    /*Fix for ccpu00123919*/
25126    /*noRbs = (noRbgs * cell->rbgSize) - rbgFiller;*/
25127    /* Update the bwAlloced field accordingly */
25128 //#ifndef LTEMAC_SPS    /* ccpu00129474*/
25129    dlSf->bwAlloced += noRbs;
25130 //#endif
25131    /* Update Type0 Alloc Info */
25132    allocInfo->allocInfo.raType0.numDlAlloc = noRbgs;
25133    allocInfo->allocInfo.raType0.dlAllocBitMask |= dlAllocMsk;
25134    allocInfo->rbsAlloc = noRbs;
25135
25136    /* Update Tb info for each scheduled TB */
25137    iTbs = allocInfo->tbInfo[0].iTbs;
25138    noLyr = allocInfo->tbInfo[0].noLyr;
25139    /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant.
25140     * RETX TB Size is same as Init TX TB Size */
25141    if (allocInfo->tbInfo[0].tbCb->txCntr)
25142    {
25143       allocInfo->tbInfo[0].bytesAlloc =
25144          allocInfo->tbInfo[0].bytesReq;
25145    }
25146    else
25147    {
25148       allocInfo->tbInfo[0].bytesAlloc =
25149          rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25150       /* DwPts Scheduling Changes Start */
25151 #ifdef LTE_TDD
25152       if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
25153       {
25154          allocInfo->tbInfo[0].bytesAlloc =
25155             rgTbSzTbl[noLyr - 1][iTbs][RGSCH_MAX(noRbs*3/4,1) - 1]/8;
25156       }
25157 #endif      
25158       /* DwPts Scheduling Changes End */
25159    }
25160
25161    if (allocInfo->tbInfo[1].schdlngForTb)
25162    {
25163       iTbs = allocInfo->tbInfo[1].iTbs;
25164       noLyr = allocInfo->tbInfo[1].noLyr;
25165       /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant
25166        * RETX TB Size is same as Init TX TB Size */
25167       if (allocInfo->tbInfo[1].tbCb->txCntr)
25168       {
25169          allocInfo->tbInfo[1].bytesAlloc =
25170             allocInfo->tbInfo[1].bytesReq;
25171       }
25172       else
25173       {
25174          allocInfo->tbInfo[1].bytesAlloc =
25175             rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
25176          /* DwPts Scheduling Changes Start */
25177 #ifdef LTE_TDD
25178          if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
25179          {
25180             allocInfo->tbInfo[1].bytesAlloc =
25181                rgTbSzTbl[noLyr - 1][iTbs][RGSCH_MAX(noRbs*3/4,1) - 1]/8;
25182          }
25183 #endif      
25184          /* DwPts Scheduling Changes End */
25185       }
25186    }
25187
25188    /* The last RBG which can be smaller than the RBG size is consedered
25189     * only for the first time allocation of TYPE0 UE */
25190    dlSf->lstRbgDfct = 0;
25191    RETVOID;
25192 }
25193 #ifndef LTE_TDD
25194
25195 /**
25196  * @brief To prepare RNTP value from the PRB allocation (P-High -> 1 and P-Low -> 0)
25197  *
25198  * @details
25199  *
25200  *     Function : rgSCHCmnBuildRntpInfo
25201  *
25202  *     Processing Steps:
25203  *
25204  *  @param[in]  U8                 *rntpPtr
25205  *  @param[in]  U8                 startRb
25206  *  @param[in]  U8                 numRb
25207  *
25208  *  @return Void
25209  **/
25210 #ifdef ANSI
25211 PRIVATE S16 rgSCHCmnBuildRntpInfo
25212 (
25213 RgSchCellCb        *cell,
25214 U8                 *rntpPtr,
25215 U8                            startRb,
25216 U8                  nmbRb,
25217 U16                 bw
25218 )
25219 #else
25220 PRIVATE S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
25221 RgSchCellCb        *cell;
25222 U8                 *rntpPtr;
25223 U8                            startRb;
25224 U8                  nmbRb;
25225 U16                 bw;
25226 #endif
25227 {
25228    U16 rbPtrStartIdx;              /* Start Index of Octete Buffer to be filled */
25229    U16 rbPtrEndIdx;                /* End Index of Octete Buffer to be filled */
25230    U16 rbBitLoc;                   /* Bit Location to be set as 1 in the current Byte */
25231    U16 nmbRbPerByte;               /* PRB's to be set in the current Byte (in case of multiple Bytes) */
25232
25233    TRC2(rgSCHCmnBuildRntpInfo);
25234
25235    rbPtrStartIdx = (startRb)/8;
25236    rbPtrEndIdx   = (startRb + nmbRb)/8;
25237
25238    if (rntpPtr == NULLP)
25239    {
25240       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
25241                "rgSCHCmnBuildRntpInfo():"
25242                "rntpPtr can't be NULLP (Memory Allocation Failed)");
25243       RETVALUE(RFAILED);
25244    }
25245
25246    while(rbPtrStartIdx <= rbPtrEndIdx)
25247    {
25248       rbBitLoc = (startRb)%8;
25249
25250       /* case 1: startRb and endRb lies in same Byte */
25251       if (rbPtrStartIdx == rbPtrEndIdx)
25252       {
25253          rntpPtr[rbPtrStartIdx] = rntpPtr[rbPtrStartIdx]
25254                                      | (((1<<nmbRb)-1)<<rbBitLoc);
25255       }
25256
25257       /* case 2: startRb and endRb lies in different Byte */
25258       if (rbPtrStartIdx != rbPtrEndIdx)
25259       {
25260          nmbRbPerByte = 8 - rbBitLoc;
25261          nmbRb        = nmbRb - nmbRbPerByte;
25262          rntpPtr[rbPtrStartIdx] = rntpPtr[rbPtrStartIdx]
25263                                      | (((1<<nmbRbPerByte)-1)<<rbBitLoc);
25264          startRb = startRb + nmbRbPerByte;
25265       }
25266
25267       rbPtrStartIdx++;
25268    }
25269
25270    /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Adding Debug logs */
25271
25272    /* dsfr_pal_fixes ** 25-March-2013 ** SKS ** Adding Debug logs to print RNTP */
25273
25274    RETVALUE(ROK);
25275 }
25276
25277
25278 /**
25279  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
25280  *
25281  * @details
25282  *
25283  *     Function : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
25284  *
25285  *     Processing Steps:
25286  *
25287  *  @param[in]  RgSchCellCb     *cell
25288  *  @param[in]  RgSchDlSf       *dlSf
25289  *  @param[in]  U8              rbStrt
25290  *  @param[in]  U8              numRb
25291  *
25292  *  @return Void
25293  **/
25294 #ifdef ANSI
25295 PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
25296 (
25297 RgSchCellCb        *cell,
25298 RgSchUeCb                  *ue,
25299 RgSchDlSf          *dlSf,
25300 RgSchSFRPoolInfo   *sfrPool,
25301 U8                 rbStrt,
25302 U8                 numRb
25303 )
25304 #else
25305 PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
25306 RgSchCellCb        *cell;
25307 RgSchUeCb          *ue;
25308 RgSchDlSf          *dlSf;
25309 RgSchSFRPoolInfo   *sfrPool;
25310 U8                 rbStrt;
25311 U8                 numRb;
25312 #endif
25313 {
25314 #ifndef LTEMAC_SPS
25315    S16 ret;
25316 #endif
25317
25318    TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
25319    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25320    sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25321    
25322 #ifndef LTEMAC_SPS
25323    dlSf->type2Start += numRb;
25324    dlSf->bwAlloced += numRb;
25325    
25326    if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
25327    {
25328       /* Based on RNTP info, the CC user is assigned high power per subframe basis */
25329       if(FALSE == ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge)
25330       {
25331          if((sfrPool->type2Start >= sfrPool->pwrHiCCRange.startRb) &&
25332                (sfrPool->type2Start + numRb < sfrPool->pwrHiCCRange.endRb))
25333          {
25334             ue->lteAdvUeCb.isCCUePHigh = TRUE;
25335
25336             /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
25337             ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
25338             if (ret != ROK)
25339             {
25340                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
25341                         "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
25342                RETVALUE(RFAILED);
25343             }
25344          }
25345       }
25346       else
25347       {
25348          /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
25349          ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
25350          if (ret != ROK)
25351          {
25352             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
25353                      "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
25354             RETVALUE(RFAILED);
25355          }
25356       }
25357    }
25358    sfrPool->type2Start += numRb;
25359    sfrPool->bwAlloced += numRb;
25360 #endif 
25361
25362    RETVALUE(ROK);
25363 }
25364
25365 /**
25366  * @brief To do DL allocation using TYPE0 RA.
25367  *
25368  * @details
25369  *
25370  *     Function : rgSCHCmnNonDlfsSFRPoolType0Alloc
25371  *
25372  *     Processing Steps:
25373  *      - Perform TYPE0 allocation using the RBGs between type0End and type2End.
25374  *      - Build the allocation mask as per RBG positioning.
25375  *      - Update the allocation parameters.
25376  *
25377  *  @param[in]  RgSchCellCb     *cell
25378  *  @param[in]  RgSchDlSf       *dlSf
25379  *  @param[in]  RgSchDlRbAlloc  *allocInfo
25380  *
25381  *  @return Void
25382  **/
25383 #ifdef ANSI
25384 PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc
25385 (
25386 RgSchCellCb        *cell,
25387 RgSchDlSf          *dlSf,
25388 RgSchSFRPoolInfo   *poolInfo,
25389 RgSchDlRbAlloc     *allocInfo
25390 )
25391 #else
25392 PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, poolInfo, allocInfo)
25393 RgSchCellCb        *cell;
25394 RgSchDlSf          *dlSf;
25395 RgSchSFRPoolInfo   *poolInfo;
25396 RgSchDlRbAlloc     *allocInfo;
25397 #endif
25398 {
25399    U32 dlAllocMsk = 0;
25400    U8  rbgFiller = 0;
25401    U8  noRbgs = 0;
25402    U8  noRbs;
25403    U8  noLyr;
25404    U8  iTbs;
25405
25406    TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
25407
25408    if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
25409    {
25410                 if (poolInfo->type0End == dlSf->bw/4)
25411                 {
25412                         rbgFiller = dlSf->lstRbgDfct;
25413                         /* The last RBG which can be smaller than the RBG size is consedered
25414                         * only for the first time allocation of TYPE0 UE */
25415                         dlSf->lstRbgDfct = 0;
25416                 }
25417    }
25418
25419    noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
25420
25421    /* Abhinav to-do start */
25422    /* MS_FIX for ccpu00123919*/
25423    noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25424    if (dlSf->bwAlloced + noRbs > dlSf->bw)
25425    {
25426       if (--noRbgs == 0)
25427       {
25428          RETVOID;
25429       }
25430       noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25431    }
25432    /* Abhinav to-do end */
25433
25434
25435    
25436    /* type0End would have been initially (during subfrm Init) at the bit position
25437     * (cell->noOfRbgs - 1), 0 being the most significant.
25438     * Getting DlAllocMsk for noRbgs and at the appropriate position */
25439    dlAllocMsk |= (((1 << noRbgs) - 1) << (31 - poolInfo->type0End));
25440    /* Move backwards the type0End pivot */
25441    poolInfo->type0End -= noRbgs;
25442    /*MS_FIX for ccpu00123919*/
25443    /*noRbs = (noRbgs * cell->rbgSize) - rbgFiller;*/
25444    /* Update the bwAlloced field accordingly */
25445    poolInfo->bwAlloced += noRbs + dlSf->lstRbgDfct;
25446    dlSf->bwAlloced += noRbs + dlSf->lstRbgDfct;
25447    
25448    /* Update Type0 Alloc Info */
25449    allocInfo->allocInfo.raType0.numDlAlloc = noRbgs;
25450    allocInfo->allocInfo.raType0.dlAllocBitMask |= dlAllocMsk;
25451    allocInfo->rbsAlloc = noRbs;
25452
25453    /* Update Tb info for each scheduled TB */
25454    iTbs = allocInfo->tbInfo[0].iTbs;
25455    noLyr = allocInfo->tbInfo[0].noLyr;
25456    /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant.
25457     * RETX TB Size is same as Init TX TB Size */
25458    if (allocInfo->tbInfo[0].tbCb->txCntr)
25459    {
25460       allocInfo->tbInfo[0].bytesAlloc =
25461          allocInfo->tbInfo[0].bytesReq;
25462    }
25463    else
25464    {
25465       allocInfo->tbInfo[0].bytesAlloc =
25466          rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25467    }
25468
25469    if (allocInfo->tbInfo[1].schdlngForTb)
25470    {
25471       iTbs = allocInfo->tbInfo[1].iTbs;
25472       noLyr = allocInfo->tbInfo[1].noLyr;
25473       /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant
25474        * RETX TB Size is same as Init TX TB Size */
25475       if (allocInfo->tbInfo[1].tbCb->txCntr)
25476       {
25477          allocInfo->tbInfo[1].bytesAlloc =
25478             allocInfo->tbInfo[1].bytesReq;
25479       }
25480       else
25481       {
25482          allocInfo->tbInfo[1].bytesAlloc =
25483             rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
25484       }
25485    }
25486
25487    /* The last RBG which can be smaller than the RBG size is consedered
25488     * only for the first time allocation of TYPE0 UE */
25489    dlSf->lstRbgDfct = 0;
25490    RETVOID;
25491 }
25492
25493 /**
25494  * @brief Computes RNTP Info for a subframe.
25495  *
25496  * @details
25497  *
25498  *     Function :  rgSCHCmnNonDlfsDsfrRntpComp 
25499  *
25500  *     Processing Steps:
25501  *      - Computes RNTP info from individual pools.
25502  *
25503  *  @param[in]  RgSchDlSf       *dlSf
25504  *
25505  *  @return  void
25506  
25507  **/
25508 #ifdef ANSI
25509 PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp
25510 (
25511 RgSchCellCb         *cell,
25512 RgSchDlSf          *dlSf
25513 )
25514 #else
25515 PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp(cell, dlSf)
25516 RgSchCellCb         *cell;
25517 RgSchDlSf          *dlSf;
25518 #endif
25519 {
25520    PRIVATE U16 samples = 0;
25521    U16 i;
25522    U16 bwBytes = (dlSf->bw-1)/8;
25523    RgrLoadInfIndInfo *rgrLoadInf;
25524    U16 len;
25525    U16 ret     = ROK;
25526
25527    TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
25528
25529    len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
25530
25531    /* RNTP info is ORed every TTI and the sample is stored in cell control block */ 
25532    for(i = 0; i <= bwBytes; i++)
25533    {
25534      cell->rntpAggrInfo.val[i] |= dlSf->rntpInfo.val[i];
25535    }
25536    samples = samples + 1;
25537    /* After every 1000 ms, the RNTP info will be sent to application to be further sent to all neighbouring eNB
25538          informing them about the load indication for cell edge users */
25539    if(RG_SCH_MAX_RNTP_SAMPLES == samples)
25540    {
25541       /* ccpu00134492 */
25542       ret = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&rgrLoadInf,
25543                sizeof(RgrLoadInfIndInfo));
25544       if (ret != ROK)
25545       {
25546          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
25547             "allocate memory for sending LoadInfo");
25548          RETVOID;  
25549       }
25550      
25551       rgrLoadInf->u.rntpInfo.pres = cell->rntpAggrInfo.pres;
25552       /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
25553       rgrLoadInf->u.rntpInfo.len  = len;
25554
25555       /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
25556       rgrLoadInf->u.rntpInfo.val = cell->rntpAggrInfo.val; 
25557       rgrLoadInf->cellId = cell->cellId;
25558
25559       /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
25560       rgrLoadInf->bw = dlSf->bw;
25561       rgrLoadInf->type = RGR_SFR;
25562
25563       ret = rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf);
25564       if(ret == RFAILED)
25565       {
25566          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsDsfrRntpComp():"
25567                   "rgSCHUtlRgrLoadInfInd() returned RFAILED");
25568       }
25569
25570       cmMemset(cell->rntpAggrInfo.val,0,len);
25571       samples = 0;
25572    }
25573  } 
25574 /* LTE_ADV_FLAG_REMOVED_END */
25575
25576 /* LTE_ADV_FLAG_REMOVED_START */
25577 /**
25578  * @brief Performs RB allocation per UE from a pool.
25579  *
25580  * @details
25581  *
25582  *     Function : rgSCHCmnSFRNonDlfsUeRbAlloc
25583  *
25584  *     Processing Steps:
25585  *      - Allocate consecutively available RBs.
25586  *
25587  *  @param[in]  RgSchCellCb     *cell
25588  *  @param[in]  RgSchUeCb       *ue
25589  *  @param[in]  RgSchDlSf       *dlSf
25590  *  @param[out] U8              *isDlBwAvail
25591  *
25592  *  @return  S16
25593  *      -# ROK
25594  *      -# RFAILED
25595  **/
25596 #ifdef ANSI
25597 PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc
25598 (
25599 RgSchCellCb        *cell,
25600 RgSchUeCb          *ue,
25601 RgSchDlSf          *dlSf,
25602 U8                 *isDlBwAvail
25603 )
25604 #else
25605 PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
25606 RgSchCellCb        *cell;
25607 RgSchUeCb          *ue;
25608 RgSchDlSf          *dlSf;
25609 U8                 *isDlBwAvail;
25610 #endif
25611 {
25612    RgSchDlRbAlloc  *allocInfo;
25613    RgSchCmnDlUe    *dlUe;
25614    Bool isUECellEdge;
25615    RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
25616
25617    TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
25618
25619    isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
25620
25621    dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
25622    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
25623    *isDlBwAvail = TRUE;
25624
25625    /*Find which pool is available for this UE*/
25626    if (rgSCHCmnNonDlfsSFRBwAvlbl(cell,  &sfrpoolInfo, dlSf, allocInfo, isUECellEdge) != TRUE)
25627    {
25628       /* SFR_FIX - If this is CE UE there may be BW available in CC Pool
25629          So CC UEs will be scheduled */
25630       if (isUECellEdge)
25631       {
25632          *isDlBwAvail = TRUE;
25633       }
25634       else
25635       {
25636          *isDlBwAvail = FALSE;
25637       }
25638       RETVALUE(RFAILED);
25639    }
25640
25641    if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX || dlUe->proc->tbInfo[1].isAckNackDtx)
25642    {
25643       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat, TRUE);
25644    }
25645    else
25646    {
25647       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat,FALSE);
25648    }
25649    
25650    if (!(allocInfo->pdcch))
25651    {
25652       /* Returning ROK since PDCCH might be available for another UE and further allocations could be done */
25653       RETVALUE(RFAILED);
25654    }
25655    
25656 #ifdef LTEMAC_SPS
25657    allocInfo->rnti = ue->ueId;
25658 #endif
25659
25660    if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
25661    {
25662       allocInfo->allocInfo.raType2.isLocal = TRUE;
25663       /* rg004.201 patch - ccpu00109921 fix end */
25664       /* MS_FIX for ccpu00123918*/
25665       allocInfo->allocInfo.raType2.rbStart = (U8)sfrpoolInfo->type2Start;
25666       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
25667       /* rg007.201 - Changes for MIMO feature addition */
25668       /* rg008.201 - Removed dependency on MIMO compile-time flag */
25669       rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrpoolInfo, \
25670             allocInfo->allocInfo.raType2.rbStart, \
25671             allocInfo->allocInfo.raType2.numRb);
25672       allocInfo->rbsAlloc = allocInfo->rbsReq;
25673       allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25674    }
25675    else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
25676    {
25677       rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, sfrpoolInfo, allocInfo);
25678    }
25679 #ifndef LTE_TDD
25680 #ifdef DEBUGP
25681    rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,0);
25682    if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
25683    {
25684       rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,1);
25685    }
25686 #endif
25687 #endif
25688
25689 #if defined(LTEMAC_SPS)
25690    /* Update the sub-frame with new allocation */
25691    dlSf->bwAlloced += allocInfo->rbsReq;
25692 #endif
25693
25694    RETVALUE(ROK);
25695 }
25696 /* LTE_ADV_FLAG_REMOVED_END */
25697 #endif /* LTE_TDD */
25698
25699 /**
25700  * @brief Performs RB allocation per UE for frequency non-selective cell.
25701  *
25702  * @details
25703  *
25704  *     Function : rgSCHCmnNonDlfsUeRbAlloc
25705  *
25706  *     Processing Steps:
25707  *      - Allocate consecutively available RBs.
25708  *
25709  *  @param[in]  RgSchCellCb     *cell
25710  *  @param[in]  RgSchUeCb       *ue
25711  *  @param[in]  RgSchDlSf       *dlSf
25712  *  @param[out] U8              *isDlBwAvail
25713  *
25714  *  @return  S16
25715  *      -# ROK
25716  *      -# RFAILED
25717  **/
25718 #ifdef ANSI
25719 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc
25720 (
25721 RgSchCellCb        *cell,
25722 RgSchUeCb          *ue,
25723 RgSchDlSf          *dlSf,
25724 U8                 *isDlBwAvail
25725 )
25726 #else
25727 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
25728 RgSchCellCb        *cell;
25729 RgSchUeCb          *ue;
25730 RgSchDlSf          *dlSf;
25731 U8                 *isDlBwAvail;
25732 #endif
25733 {
25734    RgSchDlRbAlloc  *allocInfo;
25735    RgSchCmnDlUe    *dlUe;
25736 #ifdef LAA_DBG
25737    U32            dbgRbsReq = 0;
25738 #endif
25739    TRC2(rgSCHCmnNonDlfsUeRbAlloc);
25740
25741 #ifdef RG_5GTF
25742    RgSch5gtfUeCb  *ue5gtfCb = &(ue->ue5gtfCb);
25743         RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[ue5gtfCb->BeamId]);
25744 #endif
25745    dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
25746    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
25747    *isDlBwAvail = TRUE;
25748
25749         if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
25750         {
25751            RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
25752          "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
25753          ue->ueId);
25754            printf("5GTF_ERROR vrbg allocated > 25\n");
25755                 RETVALUE(RFAILED);
25756         }
25757
25758    if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX 
25759        || dlUe->proc->tbInfo[1].isAckNackDtx)
25760    {
25761       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat, TRUE);
25762    }
25763    else
25764    {
25765       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat,FALSE);
25766    }
25767    if (!(allocInfo->pdcch))
25768    {
25769       /* Returning ROK since PDCCH might be available for another UE and
25770        * further allocations could be done */
25771       RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
25772          "5GTF_ERROR : PDCCH allocation failed :ue (%u)",
25773          ue->ueId);
25774            printf("5GTF_ERROR PDCCH allocation failed\n");
25775       RETVALUE(RFAILED);
25776    }
25777 #ifdef RG_5GTF
25778         //maxPrb = RGSCH_MIN((allocInfo->vrbgReq * MAX_5GTF_VRBG_SIZE), ue5gtfCb->maxPrb);
25779    //maxPrb = RGSCH_MIN(maxPrb, 
25780                 //((beamInfo->totVrbgAvail - beamInfo->vrbgStart)* MAX_5GTF_VRBG_SIZE)));
25781         //TODO_SID Need to check for vrbg available after scheduling for same beam.
25782         allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart = beamInfo->vrbgStart;
25783         allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg = allocInfo->vrbgReq;
25784         //TODO_SID: Setting for max TP
25785         allocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange = 1;      
25786         allocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
25787          allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart, allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg);
25788         allocInfo->tbInfo[0].tbCb->dlGrnt.SCID = 0;
25789         allocInfo->tbInfo[0].tbCb->dlGrnt.dciFormat = allocInfo->dciFormat;
25790    //Filling temporarily
25791    allocInfo->tbInfo[0].tbCb->dlGrnt.rbStrt = (allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
25792    allocInfo->tbInfo[0].tbCb->dlGrnt.numRb = (allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
25793
25794         beamInfo->vrbgStart += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg;
25795         beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg; 
25796         allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25797 #endif
25798
25799    RETVALUE(ROK);
25800 }
25801
25802 #ifdef RGR_V1
25803 /**
25804  * @brief Performs RB allocation for Msg4 for frequency non-selective cell.
25805  *
25806  * @details
25807  *
25808  *     Function : rgSCHCmnNonDlfsCcchSduAlloc
25809  *
25810  *     Processing Steps:
25811  *     - For each element in the list, Call rgSCHCmnNonDlfsCcchSduRbAlloc().
25812  *        - If allocation is successful, add the ueCb to scheduled list of CCCH
25813  *        SDU.
25814  *        - else, add UeCb to non-scheduled list.
25815  *
25816  *  @param[in]      RgSchCellCb         *cell
25817  *  @param[in, out] RgSchCmnCcchSduRbAlloc *allocInfo
25818  *  @param[in]      U8                  isRetx
25819  *
25820  *  @return  Void
25821  **/
25822 #ifdef ANSI
25823 PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc
25824 (
25825 RgSchCellCb         *cell,
25826 RgSchCmnCcchSduRbAlloc *allocInfo,
25827 U8                  isRetx
25828 )
25829 #else
25830 PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
25831 RgSchCellCb         *cell;
25832 RgSchCmnCcchSduRbAlloc *allocInfo;
25833 U8                  isRetx;
25834 #endif
25835 {
25836    S16             ret;
25837    CmLListCp       *ccchSduLst        = NULLP;
25838    CmLListCp       *schdCcchSduLst    = NULLP;
25839    CmLListCp       *nonSchdCcchSduLst = NULLP;
25840    CmLList         *schdLnkNode    = NULLP;
25841    CmLList         *toBeSchdLnk    = NULLP;
25842    RgSchDlSf       *dlSf           = allocInfo->ccchSduDlSf;
25843    RgSchUeCb       *ueCb           = NULLP;
25844    RgSchDlHqProcCb *hqP            = NULLP;
25845    TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
25846
25847    if (isRetx)
25848    {
25849       /* Initialize re-transmitting lists */
25850       ccchSduLst = &(allocInfo->ccchSduRetxLst);
25851       schdCcchSduLst = &(allocInfo->schdCcchSduRetxLst);
25852       nonSchdCcchSduLst = &(allocInfo->nonSchdCcchSduRetxLst);
25853    }
25854    else
25855    {
25856       /* Initialize transmitting lists */
25857       ccchSduLst = &(allocInfo->ccchSduTxLst);
25858       schdCcchSduLst = &(allocInfo->schdCcchSduTxLst);
25859       nonSchdCcchSduLst = &(allocInfo->nonSchdCcchSduTxLst);
25860    }
25861
25862    /* Perform allocaations  for the list */
25863    toBeSchdLnk = cmLListFirst(ccchSduLst);
25864    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
25865    {
25866       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
25867       ueCb = hqP->hqE->ue;
25868       schdLnkNode = &hqP->schdLstLnk;
25869       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
25870       ret = rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf);
25871       if (ret != ROK)
25872       {
25873          /* Allocation failed: Add remaining MSG4 nodes to non-scheduled
25874           * list and return */
25875          do
25876          {
25877             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
25878             ueCb = hqP->hqE->ue;
25879             schdLnkNode = &hqP->schdLstLnk;
25880             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
25881             cmLListAdd2Tail(nonSchdCcchSduLst, schdLnkNode);
25882             toBeSchdLnk = toBeSchdLnk->next;
25883          } while(toBeSchdLnk);
25884          RETVOID;
25885       }
25886
25887       /* Allocation successful: Add UE to the scheduled list */
25888       cmLListAdd2Tail(schdCcchSduLst, schdLnkNode);
25889    }
25890
25891
25892    RETVOID;
25893 }
25894
25895 /**
25896  * @brief Performs RB allocation for CcchSdu for frequency non-selective cell.
25897  *
25898  * @details
25899  *
25900  *     Function : rgSCHCmnNonDlfsCcchSduRbAlloc
25901  *
25902  *     Processing Steps:
25903  *     - Fetch PDCCH
25904  *     - Allocate consecutively available RBs
25905  *
25906  *  @param[in] RgSchCellCb     *cell
25907  *  @param[in] RgSchUeCb       *ueCb
25908  *  @param[in] RgSchDlSf       *dlSf
25909  *  @return  S16
25910  *      -# ROK
25911  *      -# RFAILED
25912  **/
25913 #ifdef ANSI
25914 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc
25915 (
25916 RgSchCellCb        *cell,
25917 RgSchUeCb          *ueCb,
25918 RgSchDlSf          *dlSf
25919 )
25920 #else
25921 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf)
25922 RgSchCellCb        *cell;
25923 RgSchUeCb          *ueCb;
25924 RgSchDlSf          *dlSf;
25925 #endif
25926 {
25927    RgSchDlRbAlloc  *allocInfo;
25928    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
25929
25930    TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
25931
25932
25933    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
25934
25935    /* [ccpu00138802]-MOD-If Bw is less than required, return fail
25936       It will be allocated in next TTI */
25937 #ifdef LTEMAC_SPS
25938    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
25939          (dlSf->bwAlloced == dlSf->bw))
25940 #else
25941    if((dlSf->bwAlloced == dlSf->bw) ||
25942       (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
25943 #endif
25944    {
25945       RETVALUE(RFAILED);
25946    }
25947    /* Retrieve PDCCH */
25948    /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
25949    if (ueDl->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX)
25950    {
25951       /*      allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, dlSf, y, ueDl->cqi,
25952        *      TFU_DCI_FORMAT_1A, TRUE);*/
25953       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ueCb, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, TRUE);
25954    }
25955    else
25956    {
25957       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ueCb, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE);
25958    }
25959    if (!(allocInfo->pdcch))
25960    {
25961       /* Returning RFAILED since PDCCH not available for any CCCH allocations */
25962       RETVALUE(RFAILED);
25963    }
25964
25965    /* Update allocation information */
25966    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
25967    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
25968    allocInfo->allocInfo.raType2.isLocal = TRUE;
25969
25970       /*Fix for ccpu00123918*/
25971       /* Push this harq process back to the free queue */
25972       allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
25973       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
25974       allocInfo->rbsAlloc = allocInfo->rbsReq;
25975       allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25976       /* Update the sub-frame with new allocation */
25977       /* ccpu00129469 */
25978       /* LTE_ADV_FLAG_REMOVED_START */
25979 #ifndef LTE_TDD
25980       if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
25981       {
25982          rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf,
25983                allocInfo->allocInfo.raType2.rbStart,
25984                allocInfo->allocInfo.raType2.numRb);
25985       }
25986       else
25987 #endif /* end of ifndef LTE_TDD*/
25988       {
25989          rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, 
25990                allocInfo->allocInfo.raType2.rbStart, 
25991                allocInfo->allocInfo.raType2.numRb);
25992       }
25993
25994    /* LTE_ADV_FLAG_REMOVED_END */
25995    /* ccpu00131941 - bwAlloced is updated from SPS bandwidth */  
25996
25997
25998    RETVALUE(ROK);
25999 }
26000 #endif
26001
26002 /**
26003  * @brief Performs RB allocation for Msg4 for frequency non-selective cell.
26004  *
26005  * @details
26006  *
26007  *     Function : rgSCHCmnNonDlfsMsg4RbAlloc
26008  *
26009  *     Processing Steps:
26010  *     - Fetch PDCCH
26011  *     - Allocate consecutively available RBs
26012  *
26013  *  @param[in] RgSchCellCb     *cell
26014  *  @param[in] RgSchRaCb       *raCb
26015  *  @param[in] RgSchDlSf       *dlSf
26016  *  @return  S16
26017  *      -# ROK
26018  *      -# RFAILED
26019  **/
26020 #ifdef ANSI
26021 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc
26022 (
26023 RgSchCellCb        *cell,
26024 RgSchRaCb          *raCb,
26025 RgSchDlSf          *dlSf
26026 )
26027 #else
26028 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf)
26029 RgSchCellCb        *cell;
26030 RgSchRaCb          *raCb;
26031 RgSchDlSf          *dlSf;
26032 #endif
26033 {
26034    RgSchDlRbAlloc  *allocInfo;
26035    TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
26036
26037
26038    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
26039
26040 #ifdef RG_5GTF
26041         RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[0]);
26042         if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
26043         {
26044            RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
26045          "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
26046          raCb->ue->ueId);
26047            printf("5GTF_ERROR vrbg allocated > 25\n");
26048                 RETVALUE(RFAILED);
26049         }
26050 #endif
26051 #ifdef LTEMAC_SPS
26052    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
26053          (dlSf->bwAlloced == dlSf->bw))
26054 #else
26055    if((dlSf->bwAlloced == dlSf->bw) ||
26056             (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
26057 #endif
26058    {
26059
26060       RETVALUE(RFAILED);
26061    }
26062
26063    /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
26064    if (raCb->dlHqE->msg4Proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX)
26065    {
26066       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, raCb->ue, dlSf, raCb->ccchCqi, TFU_DCI_FORMAT_B1, TRUE);
26067    }
26068    else
26069    {
26070       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, raCb->ue, dlSf, raCb->ccchCqi, TFU_DCI_FORMAT_B1, FALSE);
26071    }
26072    if (!(allocInfo->pdcch))
26073    {
26074       /* Returning RFAILED since PDCCH not available for any CCCH allocations */
26075       RETVALUE(RFAILED);
26076    }
26077    
26078 #ifndef RG_5GTF
26079  /* SR_RACH_STATS : MSG4 TX Failed */
26080    allocInfo->pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4 = TRUE;
26081
26082    /* Update allocation information */
26083    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
26084    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
26085    allocInfo->allocInfo.raType2.isLocal = TRUE;
26086
26087
26088         /*Fix for ccpu00123918*/
26089         allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
26090         allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
26091         /* LTE_ADV_FLAG_REMOVED_START */
26092 #ifndef LTE_TDD
26093         if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
26094         {
26095           rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, \
26096                 allocInfo->allocInfo.raType2.rbStart, \
26097                 allocInfo->allocInfo.raType2.numRb);
26098         }
26099         else
26100 #endif /* end of ifndef LTE_TDD */
26101         {
26102           rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, \
26103                 allocInfo->allocInfo.raType2.rbStart, \
26104                 allocInfo->allocInfo.raType2.numRb);
26105         }
26106         /* LTE_ADV_FLAG_REMOVED_END */
26107
26108    allocInfo->rbsAlloc = allocInfo->rbsReq;
26109    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26110
26111 #else
26112
26113   allocInfo->pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4 = TRUE;
26114
26115         allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart = beamInfo->vrbgStart;
26116         allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg = allocInfo->vrbgReq;
26117
26118    /* Update allocation information */
26119    allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
26120
26121         allocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange = 1;      
26122         allocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
26123          allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart, allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg);
26124
26125    allocInfo->tbInfo[0].tbCb->dlGrnt.rbStrt = (allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
26126    allocInfo->tbInfo[0].tbCb->dlGrnt.numRb = (allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
26127
26128
26129         beamInfo->vrbgStart += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg;
26130         beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg; 
26131         allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26132
26133 #endif
26134
26135    RETVALUE(ROK);
26136 }
26137
26138 /**
26139  * @brief Performs RB allocation for Msg4 lists of frequency non-selective cell.
26140  *
26141  * @details
26142  *
26143  *     Function : rgSCHCmnNonDlfsMsg4Alloc
26144  *
26145  *     Processing Steps:
26146  *     - For each element in the list, Call rgSCHCmnNonDlfsMsg4RbAlloc().
26147  *        - If allocation is successful, add the raCb to scheduled list of MSG4.
26148  *        - else, add RaCb to non-scheduled list.
26149  *
26150  *  @param[in]      RgSchCellCb         *cell
26151  *  @param[in, out] RgSchCmnMsg4RbAlloc *allocInfo
26152  *  @param[in]      U8                  isRetx
26153  *
26154  *  @return  Void
26155  **/
26156 #ifdef ANSI
26157 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc
26158 (
26159 RgSchCellCb         *cell,
26160 RgSchCmnMsg4RbAlloc *allocInfo,
26161 U8                  isRetx
26162 )
26163 #else
26164 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
26165 RgSchCellCb         *cell;
26166 RgSchCmnMsg4RbAlloc *allocInfo;
26167 U8                  isRetx;
26168 #endif
26169 {
26170    S16             ret;
26171    CmLListCp       *msg4Lst        = NULLP;
26172    CmLListCp       *schdMsg4Lst    = NULLP;
26173    CmLListCp       *nonSchdMsg4Lst = NULLP;
26174    CmLList         *schdLnkNode    = NULLP;
26175    CmLList         *toBeSchdLnk    = NULLP;
26176    RgSchDlSf       *dlSf           = allocInfo->msg4DlSf;
26177    RgSchRaCb       *raCb           = NULLP;
26178    RgSchDlHqProcCb *hqP            = NULLP;
26179    TRC2(rgSCHCmnNonDlfsMsg4Alloc);
26180
26181    if (isRetx)
26182    {
26183       /* Initialize re-transmitting lists */
26184       msg4Lst = &(allocInfo->msg4RetxLst);
26185       schdMsg4Lst = &(allocInfo->schdMsg4RetxLst);
26186       nonSchdMsg4Lst = &(allocInfo->nonSchdMsg4RetxLst);
26187    }
26188    else
26189    {
26190       /* Initialize transmitting lists */
26191       msg4Lst = &(allocInfo->msg4TxLst);
26192       schdMsg4Lst = &(allocInfo->schdMsg4TxLst);
26193       nonSchdMsg4Lst = &(allocInfo->nonSchdMsg4TxLst);
26194    }
26195
26196    /* Perform allocaations  for the list */
26197    toBeSchdLnk = cmLListFirst(msg4Lst);
26198    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
26199    {
26200       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26201       raCb = hqP->hqE->raCb;
26202       schdLnkNode = &hqP->schdLstLnk;
26203       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26204       ret = rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf);
26205       if (ret != ROK)
26206       {
26207          /* Allocation failed: Add remaining MSG4 nodes to non-scheduled
26208           * list and return */
26209          do
26210          {
26211             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26212             raCb = hqP->hqE->raCb;
26213             schdLnkNode = &hqP->schdLstLnk;
26214             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26215             cmLListAdd2Tail(nonSchdMsg4Lst, schdLnkNode);
26216             toBeSchdLnk = toBeSchdLnk->next;
26217          } while(toBeSchdLnk);
26218          RETVOID;
26219       }
26220
26221       /* Allocation successful: Add UE to the scheduled list */
26222       cmLListAdd2Tail(schdMsg4Lst, schdLnkNode);
26223       if (isRetx)
26224       {
26225       }
26226    }
26227
26228
26229    RETVOID;
26230 }
26231
26232 /**
26233  * @brief Performs RB allocation for the list of UEs of a frequency
26234  * non-selective cell.
26235  *
26236  * @details
26237  *
26238  *     Function : rgSCHCmnNonDlfsDedRbAlloc
26239  *
26240  *     Processing Steps:
26241  *     - For each element in the list, Call rgSCHCmnNonDlfsUeRbAlloc().
26242  *        - If allocation is successful, add the ueCb to scheduled list of UEs.
26243  *        - else, add ueCb to non-scheduled list of UEs.
26244  *
26245  *  @param[in]      RgSchCellCb        *cell
26246  *  @param[in, out] RgSchCmnUeRbAlloc  *allocInfo
26247  *  @param[in]      CmLListCp          *ueLst,
26248  *  @param[in, out] CmLListCp          *schdHqPLst,
26249  *  @param[in, out] CmLListCp          *nonSchdHqPLst
26250  *
26251  *  @return  Void
26252  **/
26253 #ifdef ANSI
26254 PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc
26255 (
26256 RgSchCellCb        *cell,
26257 RgSchCmnUeRbAlloc  *allocInfo,
26258 CmLListCp          *ueLst,
26259 CmLListCp          *schdHqPLst,
26260 CmLListCp          *nonSchdHqPLst
26261 )
26262 #else
26263 PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
26264         schdHqPLst, nonSchdHqPLst)
26265 RgSchCellCb        *cell;
26266 RgSchCmnUeRbAlloc  *allocInfo;
26267 CmLListCp          *ueLst;
26268 CmLListCp          *schdHqPLst;
26269 CmLListCp          *nonSchdHqPLst;
26270 #endif
26271 {
26272    S16             ret;
26273    CmLList         *schdLnkNode  = NULLP;
26274    CmLList         *toBeSchdLnk  = NULLP;
26275    RgSchDlSf       *dlSf         = allocInfo->dedDlSf;
26276    RgSchUeCb       *ue           = NULLP;
26277    RgSchDlHqProcCb *hqP          = NULLP;
26278    U8              isDlBwAvail;
26279    TRC2(rgSCHCmnNonDlfsDedRbAlloc);
26280
26281
26282    /* Perform allocaations  for the list */
26283    toBeSchdLnk = cmLListFirst(ueLst);
26284    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
26285    {
26286       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26287       ue = hqP->hqE->ue;
26288       schdLnkNode = &hqP->schdLstLnk;
26289       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26290
26291       ret = rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, &isDlBwAvail);
26292       if (!isDlBwAvail)
26293       {
26294          /* Allocation failed: Add remaining UEs to non-scheduled
26295           * list and return */
26296          do
26297          {
26298             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26299             ue = hqP->hqE->ue;
26300             schdLnkNode = &hqP->schdLstLnk;
26301             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26302             cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
26303             toBeSchdLnk = toBeSchdLnk->next;
26304          } while(toBeSchdLnk);
26305          break; 
26306       }
26307
26308       if (ret == ROK)
26309       {
26310 #if defined (TENB_STATS) && defined (RG_5GTF)
26311          cell->tenbStats->sch.dl5gtfRbAllocPass++;
26312 #endif
26313          /* Allocation successful: Add UE to the scheduled list */
26314          cmLListAdd2Tail(schdHqPLst, schdLnkNode);
26315       }
26316       else
26317       {
26318 #if defined (TENB_STATS) && defined (RG_5GTF)
26319          cell->tenbStats->sch.dl5gtfRbAllocFail++;
26320 #endif
26321          /* Allocation failed : Add UE to the non-scheduled list */
26322                         printf("5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
26323          cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
26324       }
26325    }
26326
26327    RETVOID;
26328 }
26329
26330 /**
26331  * @brief Handles RB allocation for frequency non-selective cell.
26332  *
26333  * @details
26334  *
26335  *     Function : rgSCHCmnNonDlfsRbAlloc
26336  *
26337  *     Invoking Module Processing:
26338  *      - SCH shall invoke this if downlink frequency selective is disabled for
26339  *        the cell for RB allocation.
26340  *      - MAX C/I/PFS/RR shall provide the requiredBytes, required RBs
26341  *        estimate and subframe for each allocation to be made to SCH.
26342  *
26343  *     Processing Steps:
26344  *     - Allocate sequentially for common channels.
26345  *     - For transmitting and re-transmitting UE list.
26346  *      - For each UE:
26347  *       - Perform wide-band allocations for UE in increasing order of
26348  *         frequency.
26349  *       - Determine Imcs for the allocation.
26350  *       - Determine RA type.
26351  *       - Determine DCI format.
26352  *
26353  *  @param[in]  RgSchCellCb        *cell
26354  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
26355  *  @return  Void
26356  **/
26357
26358 #ifdef ANSI
26359 PUBLIC Void rgSCHCmnNonDlfsRbAlloc
26360 (
26361 RgSchCellCb           *cell,
26362 RgSchCmnDlRbAllocInfo *allocInfo
26363 )
26364 #else
26365 PUBLIC Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
26366 RgSchCellCb           *cell;
26367 RgSchCmnDlRbAllocInfo *allocInfo;
26368 #endif
26369 {
26370    U8                 raRspCnt = 0;
26371    RgSchDlRbAlloc     *reqAllocInfo;
26372    TRC2(rgSCHCmnNonDlfsRbAlloc);
26373
26374    /* Allocate for MSG4 retransmissions */
26375    if (allocInfo->msg4Alloc.msg4RetxLst.count)
26376    {
26377       printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
26378       rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), TRUE);
26379    }
26380
26381    /* Allocate for MSG4 transmissions */
26382    /* Assuming all the nodes in the list need allocations: rbsReq is valid */
26383    if (allocInfo->msg4Alloc.msg4TxLst.count)
26384    {
26385       printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
26386       rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), FALSE);
26387    }
26388 #ifdef RGR_V1
26389    /* Allocate for CCCH SDU (received after guard timer expiry)
26390     * retransmissions */
26391    if (allocInfo->ccchSduAlloc.ccchSduRetxLst.count)
26392    {
26393       printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
26394       rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), TRUE);
26395    }
26396
26397    /* Allocate for CCCD SDU transmissions */
26398    /* Allocate for CCCH SDU (received after guard timer expiry) transmissions */
26399    if (allocInfo->ccchSduAlloc.ccchSduTxLst.count)
26400    {
26401       printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
26402       rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), FALSE);
26403    }
26404 #endif
26405
26406    /* Allocate for Random access response */
26407    for (raRspCnt = 0; raRspCnt < RG_SCH_CMN_MAX_CMN_PDCCH; ++raRspCnt)
26408    {
26409       /* Assuming that the requests will be filled in sequentially */
26410       reqAllocInfo = &(allocInfo->raRspAlloc[raRspCnt]);
26411       if (!reqAllocInfo->rbsReq)
26412       {
26413          break;
26414       }
26415       printf("5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
26416    //   if ((rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo)) != ROK)
26417       if ((rgSCHCmnNonDlfsCmnRbAllocRar(cell, reqAllocInfo)) != ROK)
26418       {
26419          break;
26420       }
26421    }
26422
26423    /* Allocate for RETX+TX UEs */
26424    if(allocInfo->dedAlloc.txRetxHqPLst.count)
26425    {
26426       printf("5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
26427       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26428             &(allocInfo->dedAlloc.txRetxHqPLst),
26429             &(allocInfo->dedAlloc.schdTxRetxHqPLst),
26430             &(allocInfo->dedAlloc.nonSchdTxRetxHqPLst));
26431    }
26432
26433    if((allocInfo->dedAlloc.retxHqPLst.count))
26434    {
26435       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26436             &(allocInfo->dedAlloc.retxHqPLst),
26437             &(allocInfo->dedAlloc.schdRetxHqPLst),
26438             &(allocInfo->dedAlloc.nonSchdRetxHqPLst));
26439    }
26440
26441    /* Allocate for transmitting UEs */
26442    if((allocInfo->dedAlloc.txHqPLst.count))
26443    {
26444       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26445             &(allocInfo->dedAlloc.txHqPLst),
26446             &(allocInfo->dedAlloc.schdTxHqPLst),
26447             &(allocInfo->dedAlloc.nonSchdTxHqPLst));
26448    }
26449    {
26450       RgSchCmnCell  *cmnCell = RG_SCH_CMN_GET_CELL(cell);
26451       if ((allocInfo->dedAlloc.txRetxHqPLst.count + 
26452                allocInfo->dedAlloc.retxHqPLst.count + 
26453                allocInfo->dedAlloc.txHqPLst.count) > 
26454             cmnCell->dl.maxUePerDlSf)
26455       {
26456 #ifndef ALIGN_64BIT
26457          RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
26458                   " scheduler exceed maximumUePerDlSf(%u)tx-retx %ld retx %ld tx %ld\n",
26459                   cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
26460                   allocInfo->dedAlloc.retxHqPLst.count,
26461                   allocInfo->dedAlloc.txHqPLst.count));
26462 #else
26463          RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
26464                   " scheduler exceed maximumUePerDlSf(%u)tx-retx %d retx %d tx %d\n",
26465                   cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
26466                   allocInfo->dedAlloc.retxHqPLst.count,
26467                   allocInfo->dedAlloc.txHqPLst.count));
26468 #endif
26469       }
26470    }
26471 #ifndef LTE_TDD
26472    /* LTE_ADV_FLAG_REMOVED_START */
26473    if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
26474    {    
26475       printf("5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
26476       rgSCHCmnNonDlfsDsfrRntpComp(cell, allocInfo->dedAlloc.dedDlSf); 
26477    }  
26478    /* LTE_ADV_FLAG_REMOVED_END */
26479 #endif /* LTE_TDD */
26480    RETVOID;
26481 }
26482
26483 /***********************************************************
26484  *
26485  *     Func : rgSCHCmnCalcRiv
26486  *
26487  *     Desc : This function calculates RIV.
26488  *
26489  *     Ret  : None.
26490  *
26491  *     Notes: None.
26492  *
26493  *     File : rg_sch_utl.c
26494  *
26495  **********************************************************/
26496 #ifdef LTEMAC_SPS
26497 #ifdef ANSI
26498 PUBLIC U32 rgSCHCmnCalcRiv
26499 (
26500 U8           bw,
26501 U8           rbStart,
26502 U8           numRb
26503 )
26504 #else
26505 PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
26506 U8           bw;
26507 U8           rbStart;
26508 U8           numRb;
26509 #endif
26510 #else
26511 #ifdef ANSI
26512 PUBLIC U32 rgSCHCmnCalcRiv
26513 (
26514 U8           bw,
26515 U8           rbStart,
26516 U8           numRb
26517 )
26518 #else
26519 PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
26520 U8           bw;
26521 U8           rbStart;
26522 U8           numRb;
26523 #endif
26524 #endif
26525 {
26526    U8           numRbMinus1 = numRb - 1;
26527    U32          riv;
26528
26529    TRC2(rgSCHCmnCalcRiv);
26530
26531    if (numRbMinus1 <= bw/2)
26532    {
26533       riv = bw * numRbMinus1 + rbStart;
26534    }
26535    else
26536    {
26537       riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
26538    }
26539    RETVALUE(riv);
26540 } /* rgSCHCmnCalcRiv */
26541
26542 #ifdef LTE_TDD
26543 /**
26544  * @brief This function allocates and copies the RACH response scheduling
26545  *        related information into cell control block.
26546  *
26547  * @details
26548  *
26549  *     Function: rgSCHCmnDlCpyRachInfo
26550  *     Purpose:  This function allocates and copies the RACH response
26551  *               scheduling related information into cell control block
26552  *               for each DL subframe.
26553  *
26554  *
26555  *     Invoked by: Scheduler
26556  *
26557  *  @param[in]  RgSchCellCb*           cell
26558  *  @param[in]  RgSchTddRachRspLst     rachRspLst[][RGSCH_NUM_SUB_FRAMES]
26559  *  @param[in]  U8                     raArrSz
26560  *  @return     S16
26561  *
26562  **/
26563 #ifdef ANSI
26564 PRIVATE S16 rgSCHCmnDlCpyRachInfo
26565 (
26566 RgSchCellCb                *cell,
26567 RgSchTddRachRspLst         rachRspLst[][RGSCH_NUM_SUB_FRAMES],
26568 U8                         raArrSz
26569 )
26570 #else
26571 PRIVATE S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
26572 RgSchCellCb                *cell;
26573 RgSchTddRachRspLst         rachRspLst[][RGSCH_NUM_SUB_FRAMES];
26574 U8                         raArrSz;
26575 #endif
26576 {
26577    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
26578    U8                   sfNum;
26579    S16                  sfnIdx;
26580    U16                  subfrmIdx;
26581    U8                   numRfs;
26582    U8                   numSubfrms;
26583    U8                   sfcount;
26584    S16                   ret;
26585
26586    TRC2(rgSCHCmnDlCpyRachInfo);
26587
26588    /* Allocate RACH response information for each DL
26589     * subframe in a radio frame */
26590    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cell->rachRspLst,
26591          rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1] *
26592          sizeof(RgSchTddRachRspLst));
26593    if (ret != ROK)
26594    {
26595       RETVALUE(ret);
26596    }
26597
26598    for(sfnIdx=raArrSz-1; sfnIdx>=0; sfnIdx--)
26599    {
26600       for(subfrmIdx=0; subfrmIdx < RGSCH_NUM_SUB_FRAMES; subfrmIdx++)
26601       {
26602          subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][subfrmIdx];
26603          if(subfrmIdx == RGSCH_NUM_SUB_FRAMES)
26604          {
26605             break;
26606          }
26607
26608          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rachRspLst[sfnIdx],subfrmIdx);
26609          numSubfrms =
26610             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
26611
26612          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchTddNumDlSubfrmTbl[ulDlCfgIdx],subfrmIdx);
26613          sfNum = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][subfrmIdx]-1;
26614          numRfs = cell->rachRspLst[sfNum].numRadiofrms;
26615          /* For each DL subframe in which RACH response can
26616           * be sent is updated */
26617          if(numSubfrms > 0)
26618          {
26619             cell->rachRspLst[sfNum].rachRsp[numRfs].sfnOffset =
26620                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].sfnOffset;
26621             for(sfcount=0; sfcount < numSubfrms; sfcount++)
26622             {
26623                cell->rachRspLst[sfNum].rachRsp[numRfs].\
26624                   subframe[sfcount] =
26625                   rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].\
26626                   subframe[sfcount];
26627             }
26628             cell->rachRspLst[sfNum].rachRsp[numRfs].numSubfrms =
26629                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
26630             cell->rachRspLst[sfNum].numRadiofrms++;
26631          }
26632
26633          /* Copy the subframes to be deleted at ths subframe */
26634          numSubfrms =
26635             rachRspLst[sfnIdx][subfrmIdx].delInfo.numSubfrms;
26636          if(numSubfrms > 0)
26637          {
26638             cell->rachRspLst[sfNum].delInfo.sfnOffset =
26639                rachRspLst[sfnIdx][subfrmIdx].delInfo.sfnOffset;
26640             for(sfcount=0; sfcount < numSubfrms; sfcount++)
26641             {
26642                cell->rachRspLst[sfNum].delInfo.subframe[sfcount] =
26643                   rachRspLst[sfnIdx][subfrmIdx].delInfo.subframe[sfcount];
26644             }
26645             cell->rachRspLst[sfNum].delInfo.numSubfrms =
26646                rachRspLst[sfnIdx][subfrmIdx].delInfo.numSubfrms;
26647          }
26648       }
26649    }
26650    RETVALUE(ROK);
26651 }
26652 #endif
26653 /**
26654  * @brief This function determines the iTbs based on the new CFI, 
26655  *        CQI and BLER based delta iTbs 
26656  *
26657  * @details
26658  *
26659  *     Function: rgSchCmnFetchItbs
26660  *     Purpose:  Fetch the new iTbs when CFI changes.
26661  *
26662  *  @param[in]  RgSchCellCb           *cell
26663  *  @param[in]  RgSchCmnDlUe          *ueDl
26664  *  @param[in]  U8                    cqi
26665  *
26666  *  @return S32 iTbs
26667  *
26668  **/
26669 #ifdef LTE_TDD
26670 #ifdef ANSI
26671 PRIVATE S32 rgSchCmnFetchItbs 
26672 (
26673 RgSchCellCb        *cell,
26674 RgSchCmnDlUe       *ueDl,
26675 RgSchDlSf          *subFrm,
26676 U8                 cqi,
26677 U8                 cfi,
26678 U8                 cwIdx,
26679 U8                 noLyr
26680 )
26681 #else
26682 PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
26683 RgSchCellCb        *cell;
26684 RgSchCmnDlUe       *ueDl; 
26685 RgSchDlSf          *subFrm;
26686 U8                 cqi;
26687 U8                 cfi;
26688 U8                 cwIdx;
26689 U8                 noLyr;
26690 #endif
26691 #else
26692 #ifdef ANSI
26693 PRIVATE S32 rgSchCmnFetchItbs 
26694 (
26695 RgSchCellCb        *cell,
26696 RgSchCmnDlUe       *ueDl,
26697 U8                 cqi,
26698 U8                 cfi,
26699 U8                 cwIdx,
26700 U8                 noLyr
26701 )
26702 #else
26703 PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
26704 RgSchCellCb        *cell;
26705 RgSchCmnDlUe       *ueDl; 
26706 U8                 cqi;
26707 U8                 cfi;
26708 U8                 cwIdx;
26709 U8                 noLyr;
26710 #endif 
26711 #endif
26712 {
26713
26714    RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
26715    S32 iTbs = 0;
26716
26717    TRC2(rgSchCmnFetchItbs);
26718
26719 #ifdef LTE_TDD      
26720    /* Special Handling for Spl Sf when CFI is 3 as 
26721     * CFI in Spl Sf will be max 2 */
26722    if(subFrm->sfType == RG_SCH_SPL_SF_DATA) 
26723    {
26724       if((cellDl->currCfi == 3) || 
26725             ((cell->bwCfg.dlTotalBw <= 10) && (cellDl->currCfi == 1)))
26726       {    
26727          /* Use CFI 2 in this case */
26728          iTbs = (ueDl->laCb[cwIdx].deltaiTbs + 
26729                ((*(RgSchCmnCqiToTbs *)(cellDl->cqiToTbsTbl[0][2]))[cqi])* 100)/100;
26730
26731          RG_SCH_CHK_ITBS_RANGE(iTbs, RGSCH_NUM_ITBS - 1);
26732       }
26733       else
26734       {
26735          iTbs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[noLyr - 1];
26736       }
26737       iTbs = RGSCH_MIN(iTbs, cell->thresholds.maxDlItbs);
26738    }   
26739    else /* CFI Changed. Update with new iTbs Reset the BLER*/
26740 #endif         
26741    {
26742       S32 tmpiTbs  = (*(RgSchCmnCqiToTbs *)(cellDl->cqiToTbsTbl[0][cfi]))[cqi];
26743       
26744       iTbs = (ueDl->laCb[cwIdx].deltaiTbs + tmpiTbs*100)/100;
26745
26746       RG_SCH_CHK_ITBS_RANGE(iTbs, tmpiTbs);     
26747
26748       iTbs = RGSCH_MIN(iTbs, cell->thresholds.maxDlItbs);
26749
26750       ueDl->mimoInfo.cwInfo[cwIdx].iTbs[noLyr - 1] = iTbs;
26751
26752       ueDl->lastCfi = cfi;
26753       ueDl->laCb[cwIdx].deltaiTbs = 0;
26754    }
26755
26756    RETVALUE(iTbs);
26757 } 
26758 \f
26759 /**
26760  * @brief This function determines the RBs and Bytes required for BO
26761  *        transmission for UEs configured with TM 1/2/6/7.
26762  *
26763  * @details
26764  *
26765  *     Function: rgSCHCmnDlAllocTxRb1Tb1Cw
26766  *     Purpose:  Allocate TB1 on CW1.
26767  *
26768  *               Reference Parameter effBo is filled with alloced bytes.
26769  *               Returns RFAILED if BO not satisfied at all.
26770  *
26771  *     Invoked by: rgSCHCmnDlAllocTxRbTM1/2/6/7
26772  *
26773  *  @param[in]  RgSchCellCb           *cell
26774  *  @param[in]  RgSchDlSf             *subFrm
26775  *  @param[in]  RgSchUeCb             *ue
26776  *  @param[in]  U32                   bo
26777  *  @param[out] U32                   *effBo
26778  *  @param[in]  RgSchDlHqProcCb       *proc
26779  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26780  *  @return  Void
26781  *
26782  **/
26783 #ifdef ANSI
26784 PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw
26785 (
26786 RgSchCellCb                *cell,
26787 RgSchDlSf                  *subFrm,
26788 RgSchUeCb                  *ue,
26789 U32                        bo,
26790 U32                        *effBo,
26791 RgSchDlHqProcCb            *proc,
26792 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26793 )
26794 #else
26795 PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26796 RgSchCellCb                *cell;
26797 RgSchDlSf                  *subFrm;
26798 RgSchUeCb                  *ue;
26799 U32                        bo;
26800 U32                        *effBo;
26801 RgSchDlHqProcCb            *proc;
26802 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26803 #endif
26804 {
26805    RgSchDlRbAlloc   *allocInfo;
26806    S16              ret;
26807    U8               numRb;
26808    TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
26809
26810    ret = ROK;
26811    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
26812 #ifdef RG_5GTF
26813    if (ue->ue5gtfCb.rank == 2)
26814    {
26815       allocInfo->dciFormat = TFU_DCI_FORMAT_B2;
26816    }
26817    else
26818    {
26819       allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
26820    }
26821 #else
26822    allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
26823          allocInfo->raType);
26824 #endif
26825    ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
26826          bo, &numRb, effBo);
26827    if (ret == RFAILED)
26828    {
26829       /* If allocation couldn't be made then return */
26830       RETVOID;
26831    }
26832    /* Adding UE to RbAllocInfo TX Lst */
26833    rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
26834    /* Fill UE alloc Info */
26835    allocInfo->rbsReq = numRb;
26836    allocInfo->dlSf   = subFrm;
26837 #ifdef RG_5GTF
26838    allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
26839 #endif
26840
26841    RETVOID;
26842 }
26843
26844 \f
26845 /**
26846  * @brief This function determines the RBs and Bytes required for BO
26847  *        retransmission for UEs configured with TM 1/2/6/7.
26848  *
26849  * @details
26850  *
26851  *     Function: rgSCHCmnDlAllocRetxRb1Tb1Cw
26852  *     Purpose:  Allocate TB1 on CW1.
26853  *
26854  *               Reference Parameter effBo is filled with alloced bytes.
26855  *               Returns RFAILED if BO not satisfied at all.
26856  *
26857  *     Invoked by: rgSCHCmnDlAllocRetxRbTM1/2/6/7
26858  *
26859  *  @param[in]  RgSchCellCb           *cell
26860  *  @param[in]  RgSchDlSf             *subFrm
26861  *  @param[in]  RgSchUeCb             *ue
26862  *  @param[in]  U32                   bo
26863  *  @param[out] U32                   *effBo
26864  *  @param[in]  RgSchDlHqProcCb       *proc
26865  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26866  *  @return  Void
26867  *
26868  **/
26869 #ifdef ANSI
26870 PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw
26871 (
26872 RgSchCellCb                *cell,
26873 RgSchDlSf                  *subFrm,
26874 RgSchUeCb                  *ue,
26875 U32                        bo,
26876 U32                        *effBo,
26877 RgSchDlHqProcCb            *proc,
26878 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26879 )
26880 #else
26881 PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26882 RgSchCellCb                *cell;
26883 RgSchDlSf                  *subFrm;
26884 RgSchUeCb                  *ue;
26885 U32                        bo;
26886 U32                        *effBo;
26887 RgSchDlHqProcCb            *proc;
26888 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26889 #endif
26890 {
26891    RgSchDlRbAlloc   *allocInfo;
26892    S16              ret;
26893    U8               numRb;
26894    TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
26895
26896    ret = ROK;
26897    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
26898
26899 #ifndef RG_5GTF
26900    /* 5GTF: RETX DCI format same as TX */
26901    allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
26902       &allocInfo->raType);
26903 #endif
26904
26905    /* Get the Allocation in terms of RBs that are required for
26906     * this retx of TB1 */
26907    ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, &proc->tbInfo[0],
26908          1, &numRb, effBo);
26909    if (ret == RFAILED)
26910    {
26911       /* Allocation couldn't be made for Retx */
26912       /* Fix : syed If TxRetx allocation failed then add the UE along with the proc
26913        * to the nonSchdTxRetxUeLst and let spfc scheduler take care of it during
26914        * finalization. */        
26915       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
26916       RETVOID;
26917    }
26918    rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
26919    /* Fill UE alloc Info */
26920    allocInfo->rbsReq = numRb;
26921    allocInfo->dlSf   = subFrm;
26922 #ifdef RG_5GTF
26923    allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
26924 #endif
26925
26926    RETVOID;
26927 }
26928
26929 \f
26930 /**
26931  * @brief This function determines the RBs and Bytes required for BO
26932  *        transmission for UEs configured with TM 2.
26933  *
26934  * @details
26935  *
26936  *     Function: rgSCHCmnDlAllocTxRbTM1
26937  *     Purpose:
26938  *
26939  *               Reference Parameter effBo is filled with alloced bytes.
26940  *               Returns RFAILED if BO not satisfied at all.
26941  *
26942  *     Invoked by: rgSCHCmnDlAllocTxRb
26943  *
26944  *  @param[in]  RgSchCellCb           *cell
26945  *  @param[in]  RgSchDlSf             *subFrm
26946  *  @param[in]  RgSchUeCb             *ue
26947  *  @param[in]  U32                   bo
26948  *  @param[out] U32                   *effBo
26949  *  @param[in]  RgSchDlHqProcCb       *proc
26950  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26951  *  @return Void
26952  *
26953  **/
26954 #ifdef ANSI
26955 PRIVATE Void rgSCHCmnDlAllocTxRbTM1
26956 (
26957 RgSchCellCb                *cell,
26958 RgSchDlSf                  *subFrm,
26959 RgSchUeCb                  *ue,
26960 U32                        bo,
26961 U32                        *effBo,
26962 RgSchDlHqProcCb            *proc,
26963 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26964 )
26965 #else
26966 PRIVATE Void rgSCHCmnDlAllocTxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26967 RgSchCellCb                *cell;
26968 RgSchDlSf                  *subFrm;
26969 RgSchUeCb                  *ue;
26970 U32                        bo;
26971 U32                        *effBo;
26972 RgSchDlHqProcCb            *proc;
26973 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26974 #endif
26975 {
26976    TRC2(rgSCHCmnDlAllocTxRbTM1);
26977    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
26978    RETVOID;
26979 }
26980
26981 \f
26982 /**
26983  * @brief This function determines the RBs and Bytes required for BO
26984  *        retransmission for UEs configured with TM 2.
26985  *
26986  * @details
26987  *
26988  *     Function: rgSCHCmnDlAllocRetxRbTM1
26989  *     Purpose:
26990  *
26991  *               Reference Parameter effBo is filled with alloced bytes.
26992  *               Returns RFAILED if BO not satisfied at all.
26993  *
26994  *     Invoked by: rgSCHCmnDlAllocRetxRb
26995  *
26996  *  @param[in]  RgSchCellCb           *cell
26997  *  @param[in]  RgSchDlSf             *subFrm
26998  *  @param[in]  RgSchUeCb             *ue
26999  *  @param[in]  U32                   bo
27000  *  @param[out] U32                   *effBo
27001  *  @param[in]  RgSchDlHqProcCb       *proc
27002  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27003  *  @return Void
27004  *
27005  **/
27006 #ifdef ANSI
27007 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1
27008 (
27009 RgSchCellCb                *cell,
27010 RgSchDlSf                  *subFrm,
27011 RgSchUeCb                  *ue,
27012 U32                        bo,
27013 U32                        *effBo,
27014 RgSchDlHqProcCb            *proc,
27015 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27016 )
27017 #else
27018 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27019 RgSchCellCb                *cell;
27020 RgSchDlSf                  *subFrm;
27021 RgSchUeCb                  *ue;
27022 U32                        bo;
27023 U32                        *effBo;
27024 RgSchDlHqProcCb            *proc;
27025 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27026 #endif
27027 {
27028    TRC2(rgSCHCmnDlAllocRetxRbTM1);
27029    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27030    RETVOID;
27031 }
27032
27033 \f
27034 /**
27035  * @brief This function determines the RBs and Bytes required for BO
27036  *        transmission for UEs configured with TM 2.
27037  *
27038  * @details
27039  *
27040  *     Function: rgSCHCmnDlAllocTxRbTM2
27041  *     Purpose:
27042  *
27043  *               Reference Parameter effBo is filled with alloced bytes.
27044  *               Returns RFAILED if BO not satisfied at all.
27045  *
27046  *     Invoked by: rgSCHCmnDlAllocTxRb
27047  *
27048  *  @param[in]  RgSchCellCb           *cell
27049  *  @param[in]  RgSchDlSf             *subFrm
27050  *  @param[in]  RgSchUeCb             *ue
27051  *  @param[in]  U32                   bo
27052  *  @param[out] U32                   *effBo
27053  *  @param[in]  RgSchDlHqProcCb       *proc
27054  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27055  *  @return Void
27056  *
27057  **/
27058 #ifdef ANSI
27059 PRIVATE Void rgSCHCmnDlAllocTxRbTM2
27060 (
27061 RgSchCellCb                *cell,
27062 RgSchDlSf                  *subFrm,
27063 RgSchUeCb                  *ue,
27064 U32                        bo,
27065 U32                        *effBo,
27066 RgSchDlHqProcCb            *proc,
27067 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27068 )
27069 #else
27070 PRIVATE Void rgSCHCmnDlAllocTxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27071 RgSchCellCb                *cell;
27072 RgSchDlSf                  *subFrm;
27073 RgSchUeCb                  *ue;
27074 U32                        bo;
27075 U32                        *effBo;
27076 RgSchDlHqProcCb            *proc;
27077 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27078 #endif
27079 {
27080    TRC2(rgSCHCmnDlAllocTxRbTM2);
27081    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27082    RETVOID;
27083 }
27084
27085 \f
27086 /**
27087  * @brief This function determines the RBs and Bytes required for BO
27088  *        retransmission for UEs configured with TM 2.
27089  *
27090  * @details
27091  *
27092  *     Function: rgSCHCmnDlAllocRetxRbTM2
27093  *     Purpose:
27094  *
27095  *               Reference Parameter effBo is filled with alloced bytes.
27096  *               Returns RFAILED if BO not satisfied at all.
27097  *
27098  *     Invoked by: rgSCHCmnDlAllocRetxRb
27099  *
27100  *  @param[in]  RgSchCellCb           *cell
27101  *  @param[in]  RgSchDlSf             *subFrm
27102  *  @param[in]  RgSchUeCb             *ue
27103  *  @param[in]  U32                   bo
27104  *  @param[out] U32                   *effBo
27105  *  @param[in]  RgSchDlHqProcCb       *proc
27106  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27107  *  @return Void
27108  *
27109  **/
27110 #ifdef ANSI
27111 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2
27112 (
27113 RgSchCellCb                *cell,
27114 RgSchDlSf                  *subFrm,
27115 RgSchUeCb                  *ue,
27116 U32                        bo,
27117 U32                        *effBo,
27118 RgSchDlHqProcCb            *proc,
27119 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27120 )
27121 #else
27122 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27123 RgSchCellCb                *cell;
27124 RgSchDlSf                  *subFrm;
27125 RgSchUeCb                  *ue;
27126 U32                        bo;
27127 U32                        *effBo;
27128 RgSchDlHqProcCb            *proc;
27129 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27130 #endif
27131 {
27132    TRC2(rgSCHCmnDlAllocRetxRbTM2);
27133    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27134    RETVOID;
27135 }
27136
27137 \f
27138 /**
27139  * @brief This function determines the RBs and Bytes required for BO
27140  *        transmission for UEs configured with TM 3.
27141  *
27142  * @details
27143  *
27144  *     Function: rgSCHCmnDlAllocTxRbTM3
27145  *     Purpose:
27146  *
27147  *               Reference Parameter effBo is filled with alloced bytes.
27148  *               Returns RFAILED if BO not satisfied at all.
27149  *
27150  *     Invoked by: rgSCHCmnDlAllocTxRb
27151  *
27152  *  @param[in]  RgSchCellCb           *cell
27153  *  @param[in]  RgSchDlSf             *subFrm
27154  *  @param[in]  RgSchUeCb             *ue
27155  *  @param[in]  U32                   bo
27156  *  @param[out] U32                   *effBo
27157  *  @param[in]  RgSchDlHqProcCb       *proc
27158  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27159  *  @return Void
27160  *
27161  **/
27162 #ifdef ANSI
27163 PRIVATE Void rgSCHCmnDlAllocTxRbTM3
27164 (
27165 RgSchCellCb                *cell,
27166 RgSchDlSf                  *subFrm,
27167 RgSchUeCb                  *ue,
27168 U32                        bo,
27169 U32                        *effBo,
27170 RgSchDlHqProcCb            *proc,
27171 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27172 )
27173 #else
27174 PRIVATE Void rgSCHCmnDlAllocTxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27175 RgSchCellCb                *cell;
27176 RgSchDlSf                  *subFrm;
27177 RgSchUeCb                  *ue;
27178 U32                        bo;
27179 U32                        *effBo;
27180 RgSchDlHqProcCb            *proc;
27181 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27182 #endif
27183 {
27184
27185    TRC2(rgSCHCmnDlAllocTxRbTM3);
27186
27187    /* Both TBs free for TX allocation */
27188    rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
27189          proc, cellWdAllocInfo);
27190
27191    RETVOID;
27192 }
27193
27194 \f
27195 /**
27196  * @brief This function determines the RBs and Bytes required for BO
27197  *        retransmission for UEs configured with TM 3.
27198  *
27199  * @details
27200  *
27201  *     Function: rgSCHCmnDlAllocRetxRbTM3
27202  *     Purpose:
27203  *
27204  *               Reference Parameter effBo is filled with alloced bytes.
27205  *               Returns RFAILED if BO not satisfied at all.
27206  *
27207  *     Invoked by: rgSCHCmnDlAllocRetxRb
27208  *
27209  *  @param[in]  RgSchCellCb           *cell
27210  *  @param[in]  RgSchDlSf             *subFrm
27211  *  @param[in]  RgSchUeCb             *ue
27212  *  @param[in]  U32                   bo
27213  *  @param[out] U32                   *effBo
27214  *  @param[in]  RgSchDlHqProcCb       *proc
27215  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27216  *  @return Void
27217  *
27218  **/
27219 #ifdef ANSI
27220 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3
27221 (
27222 RgSchCellCb                *cell,
27223 RgSchDlSf                  *subFrm,
27224 RgSchUeCb                  *ue,
27225 U32                        bo,
27226 U32                        *effBo,
27227 RgSchDlHqProcCb            *proc,
27228 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27229 )
27230 #else
27231 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27232 RgSchCellCb                *cell;
27233 RgSchDlSf                  *subFrm;
27234 RgSchUeCb                  *ue;
27235 U32                        bo;
27236 U32                        *effBo;
27237 RgSchDlHqProcCb            *proc;
27238 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27239 #endif
27240 {
27241
27242    TRC2(rgSCHCmnDlAllocRetxRbTM3);
27243
27244    if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
27245          (proc->tbInfo[1].state == HQ_TB_NACKED))
27246    {
27247 #ifdef LAA_DBG_LOG
27248       printf ("RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
27249 #endif
27250       /* Both TBs require RETX allocation */
27251       rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo,\
27252             proc, cellWdAllocInfo);
27253    }
27254    else
27255    {
27256       /* One of the TBs need RETX allocation. Other TB may/maynot
27257        * be available for new TX allocation. */
27258       rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo,\
27259             proc, cellWdAllocInfo);
27260    }
27261
27262    RETVOID;
27263 }
27264
27265 \f
27266 /**
27267  * @brief This function performs the DCI format selection in case of
27268  *        Transmit Diversity scheme where there can be more
27269  *        than 1 option for DCI format selection.
27270  *
27271  * @details
27272  *
27273  *     Function: rgSCHCmnSlctPdcchFrmt
27274  *     Purpose:  1. If DLFS is enabled, then choose TM specific
27275  *                  DCI format for Transmit diversity. All the
27276  *                  TM Specific DCI Formats support Type0 and/or
27277  *                  Type1 resource allocation scheme. DLFS
27278  *                  supports only Type-0&1 Resource allocation.
27279  *               2. If DLFS is not enabled, select a DCI format
27280  *                  which is of smaller size. Since Non-DLFS
27281  *                  scheduler supports all Resource allocation
27282  *                  schemes, selection is based on efficiency.
27283  *
27284  *     Invoked by: DL UE Allocation by Common Scheduler.
27285  *
27286  *  @param[in]  RgSchCellCb      *cell
27287  *  @param[in]  RgSchUeCb        *ue
27288  *  @param[out] U8               *raType
27289  *  @return  TfuDciFormat
27290  *
27291  **/
27292 #ifdef ANSI
27293 PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt
27294 (
27295 RgSchCellCb                *cell,
27296 RgSchUeCb                  *ue,
27297 U8                         *raType
27298 )
27299 #else
27300 PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
27301 RgSchCellCb                *cell;
27302 RgSchUeCb                  *ue;
27303 U8                         *raType;
27304 #endif
27305 {
27306    RgSchCmnCell   *cellSch = RG_SCH_CMN_GET_CELL(cell);
27307
27308    TRC2(rgSCHCmnSlctPdcchFrmt);
27309
27310    /* ccpu00140894- Selective DCI Format and RA type should be selected only 
27311     * after TX Mode transition is completed*/
27312    if ((cellSch->dl.isDlFreqSel) && (ue->txModeTransCmplt))
27313    {
27314       *raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciRAType;
27315       RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
27316    }
27317    else
27318    {
27319       *raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciRAType;
27320       RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
27321    }
27322 }
27323
27324 \f
27325 /**
27326  * @brief This function handles Retx allocation in case of TM3 UEs
27327  *        where both the TBs were NACKED previously.
27328  *
27329  * @details
27330  *
27331  *     Function: rgSCHCmnDlTM3RetxRetx
27332  *     Purpose:  If forceTD flag enabled
27333  *                  TD for TB1 on CW1.
27334  *               Else
27335  *                  DCI Frmt 2A and RA Type 0
27336  *                  RI layered SM of both TBs on 2 CWs
27337  *               Add UE to cell Alloc Info.
27338  *               Fill UE alloc Info.
27339  *
27340  *
27341  *               Successful allocation is indicated by non-zero effBo value.
27342  *
27343  *     Invoked by: rgSCHCmnDlAllocRbTM3
27344  *
27345  *  @param[in]  RgSchCellCb           *cell
27346  *  @param[in]  RgSchDlSf             *subFrm
27347  *  @param[in]  RgSchUeCb             *ue
27348  *  @param[in]  U32                   bo
27349  *  @param[out] U32                   *effBo
27350  *  @param[in]  RgSchDlHqProcCb       *proc
27351  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27352  *  @return  Void
27353  *
27354  **/
27355 #ifdef ANSI
27356 PRIVATE Void rgSCHCmnDlTM3RetxRetx
27357 (
27358 RgSchCellCb                *cell,
27359 RgSchDlSf                  *subFrm,
27360 RgSchUeCb                  *ue,
27361 U32                        bo,
27362 U32                        *effBo,
27363 RgSchDlHqProcCb            *proc,
27364 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27365 )
27366 #else
27367 PRIVATE Void rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27368 RgSchCellCb                *cell;
27369 RgSchDlSf                  *subFrm;
27370 RgSchUeCb                  *ue;
27371 U32                        bo;
27372 U32                        *effBo;
27373 RgSchDlHqProcCb            *proc;
27374 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27375 #endif
27376 {
27377    S16           ret;
27378    RgSchDlRbAlloc *allocInfo;
27379    U8            numRb;
27380    Bool          swpFlg;
27381    U8            precInfo;
27382    U8            noTxLyrs;
27383    U8            precInfoAntIdx;
27384
27385    TRC2(rgSCHCmnDlTM3RetxRetx);
27386
27387    ret = ROK;
27388    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
27389    swpFlg = FALSE;
27390 /* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
27391    {
27392       allocInfo->dciFormat = TFU_DCI_FORMAT_2A;
27393       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
27394
27395       ret = rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc, &numRb, &swpFlg,\
27396             effBo);
27397       if (ret == RFAILED)
27398       {
27399          /* Allocation couldn't be made for Retx */
27400          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
27401          RETVOID;
27402       }
27403       /* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
27404       noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
27405 #ifdef FOUR_TX_ANTENNA
27406       /*Chandra: For 4X4 MIM RETX with noTxLyrs=3, CW0 should be 1-LyrTB and CW1 should
27407        * have 2-LyrTB as per Table 6.3.3.2-1 of 36.211  */
27408       if(noTxLyrs == 3 &&  proc->tbInfo[0].numLyrs==2)
27409       {
27410          swpFlg = TRUE;
27411          proc->cwSwpEnabled = TRUE;
27412       }
27413 #endif
27414       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
27415       precInfo = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
27416    }
27417
27418 #ifdef LTEMAC_SPS
27419    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
27420 #endif
27421    {
27422       /* Adding UE to allocInfo RETX Lst */
27423       rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
27424    }
27425    /* Fill UE alloc Info scratch pad */
27426    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
27427          precInfo, noTxLyrs, subFrm);
27428
27429    RETVOID;
27430 }
27431
27432 \f
27433 /**
27434  * @brief This function handles Retx allocation in case of TM4 UEs
27435  *        where both the TBs were NACKED previously.
27436  *
27437  * @details
27438  *
27439  *     Function: rgSCHCmnDlTM4RetxRetx
27440  *     Purpose:  If forceTD flag enabled
27441  *                  TD for TB1 on CW1.
27442  *               Else
27443  *                  DCI Frmt 2 and RA Type 0
27444  *                  If RI == 1
27445  *                     1 layer SM of TB1 on CW1.
27446  *                  Else
27447  *                     RI layered SM of both TBs on 2 CWs
27448  *               Add UE to cell Alloc Info.
27449  *               Fill UE alloc Info.
27450  *
27451  *
27452  *               Successful allocation is indicated by non-zero effBo value.
27453  *
27454  *     Invoked by: rgSCHCmnDlAllocRbTM4
27455  *
27456  *  @param[in]  RgSchCellCb           *cell
27457  *  @param[in]  RgSchDlSf             *subFrm
27458  *  @param[in]  RgSchUeCb             *ue
27459  *  @param[in]  U32                   bo
27460  *  @param[out] U32                   *effBo
27461  *  @param[in]  RgSchDlHqProcCb       *proc
27462  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27463  *  @return  Void
27464  *
27465  **/
27466 #ifdef ANSI
27467 PRIVATE Void rgSCHCmnDlTM4RetxRetx
27468 (
27469 RgSchCellCb                *cell,
27470 RgSchDlSf                  *subFrm,
27471 RgSchUeCb                  *ue,
27472 U32                        bo,
27473 U32                        *effBo,
27474 RgSchDlHqProcCb            *proc,
27475 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27476 )
27477 #else
27478 PRIVATE Void rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27479 RgSchCellCb                *cell;
27480 RgSchDlSf                  *subFrm;
27481 RgSchUeCb                  *ue;
27482 U32                        bo;
27483 U32                        *effBo;
27484 RgSchDlHqProcCb            *proc;
27485 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27486 #endif
27487 {
27488    S16            ret;
27489    RgSchDlRbAlloc *allocInfo;
27490    U8             numRb;
27491    Bool           swpFlg = FALSE;
27492    U8             precInfo;
27493 #ifdef FOUR_TX_ANTENNA
27494    U8             precInfoAntIdx;
27495 #endif
27496    U8             noTxLyrs;
27497
27498    TRC2(rgSCHCmnDlTM4RetxRetx);
27499
27500    ret = ROK;
27501    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
27502                        
27503    /* Irrespective of RI Schedule both CWs */
27504    allocInfo->dciFormat = TFU_DCI_FORMAT_2;
27505    allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
27506
27507    ret = rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc, &numRb, &swpFlg,\
27508          effBo);
27509    if (ret == RFAILED)
27510    {
27511       /* Allocation couldn't be made for Retx */
27512       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
27513       RETVOID;
27514    }
27515    noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
27516    precInfo = 0; 
27517 #ifdef FOUR_TX_ANTENNA
27518    /*Chandra: For 4X4 MIM RETX with noTxLyrs=3, CW0 should be 1-LyrTB and CW1
27519     * should have 2-LyrTB as per Table 6.3.3.2-1 of 36.211  */
27520    if(noTxLyrs == 3 &&  proc->tbInfo[0].numLyrs==2)
27521    {
27522       swpFlg = TRUE;
27523       proc->cwSwpEnabled = TRUE;
27524 }
27525 precInfoAntIdx = cell->numTxAntPorts/2 - 1;
27526 precInfo = (getPrecInfoFunc[1][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
27527 #endif
27528
27529 #ifdef LTEMAC_SPS
27530    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
27531 #endif
27532    {
27533       /* Adding UE to allocInfo RETX Lst */
27534       rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
27535    }
27536    /* Fill UE alloc Info scratch pad */
27537    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
27538          precInfo, noTxLyrs, subFrm);
27539
27540    RETVOID;
27541 }
27542
27543
27544 \f
27545 /**
27546  * @brief This function determines Transmission attributes
27547  *        incase of Spatial multiplexing for TX and RETX TBs.
27548  *
27549  * @details
27550  *
27551  *     Function: rgSCHCmnDlSMGetAttrForTxRetx
27552  *     Purpose:  1. Reached here for a TM3/4 UE's HqP whose one of the TBs is
27553  *                  NACKED and the other TB is either NACKED or WAITING.
27554  *               2. Select the NACKED TB for RETX allocation.
27555  *               3. Allocation preference for RETX TB by mapping it to a better
27556  *                  CW (better in terms of efficiency).
27557  *               4. Determine the state of the other TB.
27558  *                  Determine if swapFlag were to be set.
27559  *                  Swap flag would be set if Retx TB is cross
27560  *                  mapped to a CW.
27561  *               5. If UE has new data available for TX and if the other TB's state
27562  *                  is ACKED then set furtherScope as TRUE.
27563  *
27564  *     Invoked by: rgSCHCmnDlTM3[4]TxRetx
27565  *
27566  *  @param[in]  RgSchUeCb        *ue
27567  *  @param[in]  RgSchDlHqProcCb  *proc
27568  *  @param[out] RgSchDlHqTbCb    **retxTb
27569  *  @param[out] RgSchDlHqTbCb    **txTb
27570  *  @param[out] Bool             *frthrScp
27571  *  @param[out] Bool             *swpFlg
27572  *  @return  Void
27573  *
27574  **/
27575 #ifdef ANSI
27576 PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx
27577 (
27578 RgSchUeCb                  *ue,
27579 RgSchDlHqProcCb            *proc,
27580 RgSchDlHqTbCb              **retxTb,
27581 RgSchDlHqTbCb              **txTb,
27582 Bool                       *frthrScp,
27583 Bool                       *swpFlg
27584 )
27585 #else
27586 PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, frthrScp,\
27587         swpFlg)
27588 RgSchUeCb                  *ue;
27589 RgSchDlHqProcCb            *proc;
27590 RgSchDlHqTbCb              **retxTb;
27591 RgSchDlHqTbCb              **txTb;
27592 Bool                       *frthrScp;
27593 Bool                       *swpFlg;
27594 #endif
27595 {
27596    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
27597    RgSchDlRbAlloc  *allocInfo;
27598
27599    TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
27600
27601    if (proc->tbInfo[0].state == HQ_TB_NACKED)
27602    {
27603       *retxTb = &proc->tbInfo[0];
27604       *txTb = &proc->tbInfo[1];
27605       /* TENB_BRDCM_TM4- Currently disabling swapflag for TM3/TM4, since 
27606        * HqFeedback processing does not consider a swapped hq feedback */
27607       if ((ue->mimoInfo.txMode == RGR_UE_TM_4) && (ueDl->mimoInfo.btrCwIdx == 1))
27608       {
27609          *swpFlg = TRUE;
27610          proc->cwSwpEnabled = TRUE;
27611       }
27612       if (proc->tbInfo[1].state == HQ_TB_ACKED)
27613       {
27614          allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, proc->hqE->cell);
27615          *frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
27616       }
27617    }
27618    else
27619    {
27620       *retxTb = &proc->tbInfo[1];
27621       *txTb = &proc->tbInfo[0];
27622       /* TENB_BRDCM_TM4 - Currently disabling swapflag for TM3/TM4, since 
27623        * HqFeedback processing does not consider a swapped hq feedback */
27624       if ((ue->mimoInfo.txMode == RGR_UE_TM_4) && (ueDl->mimoInfo.btrCwIdx == 0))
27625       {
27626          *swpFlg = TRUE;
27627          proc->cwSwpEnabled = TRUE;
27628       }
27629       if (proc->tbInfo[0].state == HQ_TB_ACKED)
27630       {
27631          allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, proc->hqE->cell);
27632          *frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
27633       }
27634    }
27635    RETVOID;
27636 }
27637
27638 \f
27639 /**
27640  * @brief Determine Precoding information for TM3 2 TX Antenna.
27641  *
27642  * @details
27643  *
27644  *     Function: rgSCHCmnDlTM3PrecInf2
27645  *     Purpose:
27646  *
27647  *     Invoked by: rgSCHCmnDlGetAttrForTM3
27648  *
27649  *  @param[in]  RgSchUeCb        *ue
27650  *  @param[in]  U8               numTxLyrs
27651  *  @param[in]  Bool             bothCwEnbld
27652  *  @return  U8
27653  *
27654  **/
27655 #ifdef ANSI
27656 PRIVATE U8 rgSCHCmnDlTM3PrecInf2
27657 (
27658 RgSchCellCb                *cell,
27659 RgSchUeCb                  *ue,
27660 U8                         numTxLyrs,
27661 Bool                       bothCwEnbld
27662 )
27663 #else
27664 PRIVATE U8 rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
27665 RgSchCellCb                *cell;
27666 RgSchUeCb                  *ue;
27667 U8                         numTxLyrs;
27668 Bool                       bothCwEnbld;
27669 #endif
27670 {
27671    TRC2(rgSCHCmnDlTM3PrecInf2);
27672
27673    RETVALUE(0);
27674 }
27675
27676 \f
27677 /**
27678  * @brief Determine Precoding information for TM4 2 TX Antenna.
27679  *
27680  * @details
27681  *
27682  *     Function: rgSCHCmnDlTM4PrecInf2
27683  *     Purpose:  To determine a logic of deriving precoding index
27684  *               information from 36.212 table 5.3.3.1.5-4
27685  *
27686  *     Invoked by: rgSCHCmnDlGetAttrForTM4
27687  *
27688  *  @param[in]  RgSchUeCb        *ue
27689  *  @param[in]  U8               numTxLyrs
27690  *  @param[in]  Bool             bothCwEnbld
27691  *  @return  U8
27692  *
27693  **/
27694 #ifdef ANSI
27695 PRIVATE U8 rgSCHCmnDlTM4PrecInf2
27696 (
27697 RgSchCellCb                *cell,
27698 RgSchUeCb                  *ue,
27699 U8                         numTxLyrs,
27700 Bool                       bothCwEnbld
27701 )
27702 #else
27703 PRIVATE U8 rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
27704 RgSchCellCb                *cell;
27705 RgSchUeCb                  *ue;
27706 U8                         numTxLyrs;
27707 Bool                       bothCwEnbld;
27708 #endif
27709 {
27710    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27711    U8            precIdx;
27712
27713    TRC2(rgSCHCmnDlTM4PrecInf2);
27714
27715    if (ueDl->mimoInfo.ri == numTxLyrs)
27716    {
27717       if (ueDl->mimoInfo.ri == 2)
27718       {
27719          /* PrecInfo corresponding to 2 CW
27720            Transmission */
27721          if (ue->mimoInfo.puschFdbkVld)
27722          {
27723             precIdx = 2;
27724          }
27725          else 
27726          {
27727             precIdx = ueDl->mimoInfo.pmi - 1;
27728          }
27729       }
27730       else
27731       {
27732          /* PrecInfo corresponding to 1 CW
27733           * Transmission */
27734          if (ue->mimoInfo.puschFdbkVld)
27735          {
27736             precIdx =  5;
27737          }
27738          else
27739          {
27740             precIdx =  ueDl->mimoInfo.pmi + 1;
27741          }
27742       }
27743    }
27744    else if (ueDl->mimoInfo.ri > numTxLyrs)
27745    {
27746       /* In case of choosing among the columns of a
27747        * precoding matrix, choose the column corresponding
27748        * to the MAX-CQI */
27749       if (ue->mimoInfo.puschFdbkVld)
27750       {
27751          precIdx = 5;
27752       }
27753       else
27754       {
27755          precIdx = (ueDl->mimoInfo.pmi- 1)* 2  + 1;
27756       }
27757    }
27758    else /* if RI < numTxLyrs */
27759    {
27760       precIdx = (ueDl->mimoInfo.pmi < 2)? 0:1;
27761    }
27762    RETVALUE(precIdx);
27763 }
27764
27765 \f
27766 /**
27767  * @brief Determine Precoding information for TM3 4 TX Antenna.
27768  *
27769  * @details
27770  *
27771  *     Function: rgSCHCmnDlTM3PrecInf4
27772  *     Purpose:  To determine a logic of deriving precoding index
27773  *               information from 36.212 table 5.3.3.1.5A-2
27774  *
27775  *     Invoked by: rgSCHCmnDlGetAttrForTM3
27776  *
27777  *  @param[in]  RgSchUeCb        *ue
27778  *  @param[in]  U8               numTxLyrs
27779  *  @param[in]  Bool             bothCwEnbld
27780  *  @return  U8
27781  *
27782  **/
27783 #ifdef ANSI
27784 PRIVATE U8 rgSCHCmnDlTM3PrecInf4
27785 (
27786 RgSchCellCb                *cell,
27787 RgSchUeCb                  *ue,
27788 U8                         numTxLyrs,
27789 Bool                       bothCwEnbld
27790 )
27791 #else
27792 PRIVATE U8 rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
27793 RgSchCellCb                *cell;
27794 RgSchUeCb                  *ue;
27795 U8                         numTxLyrs;
27796 Bool                       bothCwEnbld;
27797 #endif
27798 {
27799    U8            precIdx;
27800
27801    TRC2(rgSCHCmnDlTM3PrecInf4);
27802
27803    if (bothCwEnbld)
27804    {
27805       precIdx = numTxLyrs - 2;
27806    }
27807    else /* one 1 CW transmission */
27808    {
27809       precIdx = 1;
27810    }
27811    RETVALUE(precIdx);
27812 }
27813
27814 \f
27815 /**
27816  * @brief Determine Precoding information for TM4 4 TX Antenna.
27817  *
27818  * @details
27819  *
27820  *     Function: rgSCHCmnDlTM4PrecInf4
27821  *     Purpose:  To determine a logic of deriving precoding index
27822  *               information from 36.212 table 5.3.3.1.5-5
27823  *
27824  *     Invoked by: rgSCHCmnDlGetAttrForTM4
27825  *
27826  *  @param[in]  RgSchUeCb        *ue
27827  *  @param[in]  U8               numTxLyrs
27828  *  @param[in]  Bool             bothCwEnbld
27829  *  @return  U8
27830  *
27831  **/
27832 #ifdef ANSI
27833 PRIVATE U8 rgSCHCmnDlTM4PrecInf4
27834 (
27835 RgSchCellCb                *cell,
27836 RgSchUeCb                  *ue,
27837 U8                         numTxLyrs,
27838 Bool                       bothCwEnbld
27839 )
27840 #else
27841 PRIVATE U8 rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
27842 RgSchCellCb                *cell;
27843 RgSchUeCb                  *ue;
27844 U8                         numTxLyrs;
27845 Bool                       bothCwEnbld;
27846 #endif
27847 {
27848    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27849    U8            precInfoBaseIdx, precIdx;
27850
27851    TRC2(rgSCHCmnDlTM4PrecInf4);
27852
27853    precInfoBaseIdx  = (ue->mimoInfo.puschFdbkVld)? (16):
27854       (ueDl->mimoInfo.pmi);
27855    if (bothCwEnbld)
27856    {
27857       precIdx = precInfoBaseIdx + (numTxLyrs-2)*17;
27858    }
27859    else /* one 1 CW transmission */
27860    {
27861       precInfoBaseIdx += 1;
27862       precIdx = precInfoBaseIdx + (numTxLyrs-1)*17;
27863    }
27864    RETVALUE(precIdx);
27865 }
27866
27867 \f
27868 /**
27869  * @brief This function determines Transmission attributes
27870  *        incase of TM3 scheduling.
27871  *
27872  * @details
27873  *
27874  *     Function: rgSCHCmnDlGetAttrForTM3
27875  *     Purpose:  Determine retx TB and tx TB based on TB states.
27876  *               If forceTD enabled
27877  *                  perform only retx TB allocation.
27878  *                  If retxTB == TB2 then DCI Frmt = 2A, RA Type = 0.
27879  *                  Else DCI Frmt and RA Type based on cell->isDlfsEnbld
27880  *               If RI == 1
27881  *                  perform retxTB allocation on CW1.
27882  *               Else if RI > 1
27883  *                  Determine further Scope and Swap Flag attributes
27884  *                  assuming a 2 CW transmission of RetxTB and new Tx TB.
27885  *                  If no further scope for new TX allocation
27886  *                     Allocate only retx TB using 2 layers if
27887  *                     this TB was previously transmitted using 2 layers AND
27888  *                     number of Tx antenna ports == 4.
27889  *                     otherwise do single layer precoding.
27890  *
27891  *     Invoked by: rgSCHCmnDlTM3TxRetx
27892  *
27893  *  @param[in]  RgSchUeCb        *ue
27894  *  @param[in]  RgSchDlHqProcCb  *proc
27895  *  @param[out] U8               *numTxLyrs
27896  *  @param[out] Bool             *isTraDiv
27897  *  @param[out] U8               *prcdngInf
27898  *  @param[out] U8               *raType
27899  *  @return  Void
27900  *
27901  **/
27902 #ifdef ANSI
27903 PRIVATE Void rgSCHCmnDlGetAttrForTM3
27904 (
27905 RgSchCellCb                *cell,
27906 RgSchUeCb                  *ue,
27907 RgSchDlHqProcCb            *proc,
27908 U8                         *numTxLyrs,
27909 TfuDciFormat               *dciFrmt,
27910 U8                         *prcdngInf,
27911 RgSchDlHqTbCb              **retxTb,
27912 RgSchDlHqTbCb              **txTb,
27913 Bool                       *frthrScp,
27914 Bool                       *swpFlg,
27915 U8                         *raType
27916 )
27917 #else
27918 PRIVATE Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
27919         prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
27920 RgSchCellCb                *cell;
27921 RgSchUeCb                  *ue;
27922 RgSchDlHqProcCb            *proc;
27923 U8                         *numTxLyrs;
27924 TfuDciFormat               *dciFrmt;
27925 U8                         *prcdngInf;
27926 RgSchDlHqTbCb              **retxTb;
27927 RgSchDlHqTbCb              **txTb;
27928 Bool                       *frthrScp;
27929 Bool                       *swpFlg;
27930 U8                         *raType;
27931 #endif
27932 {
27933    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27934    U8            precInfoAntIdx;
27935
27936    TRC2(rgSCHCmnDlGetAttrForTM3);
27937
27938    /* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with 
27939       HQP */
27940    /* Integration_fix: SPS Proc shall always have only one Cw */
27941 #ifdef LTEMAC_SPS
27942    if (((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
27943          (ueDl->mimoInfo.forceTD)) 
27944 #ifdef LTE_ADV
27945      ||(TRUE == rgSCHLaaSCellEnabled(cell))
27946 #endif
27947       )
27948 #else
27949    if ((ueDl->mimoInfo.forceTD) 
27950 #ifdef LTE_ADV
27951        || (TRUE == rgSCHLaaSCellEnabled(cell))
27952 #endif
27953       )
27954 #endif
27955    {
27956       /* Transmit Diversity. Format based on dlfsEnabled
27957        * No further scope */
27958       if (proc->tbInfo[0].state == HQ_TB_NACKED)
27959       {
27960          *retxTb = &proc->tbInfo[0];
27961          *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
27962       }
27963       else
27964       {
27965          *retxTb = &proc->tbInfo[1];
27966          *dciFrmt = TFU_DCI_FORMAT_2A;
27967          *raType = RG_SCH_CMN_RA_TYPE0;
27968       }
27969       *numTxLyrs = 1;
27970       *frthrScp = FALSE;
27971       *prcdngInf = 0;
27972       RETVOID;
27973    }
27974
27975    /* Determine the 2 TB transmission attributes */
27976    rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, \
27977          frthrScp, swpFlg);
27978    if (*frthrScp)
27979    {
27980       /* Prefer allocation of RETX TB over 2 layers rather than combining
27981        * it with a new TX. */
27982       if ((ueDl->mimoInfo.ri == 2)
27983             && ((*retxTb)->numLyrs == 2) && (cell->numTxAntPorts == 4))
27984       {
27985          /* Allocate TB on CW1, using 2 Lyrs,
27986           * Format 2, precoding accordingly */
27987          *numTxLyrs = 2;
27988          *frthrScp = FALSE;
27989       }
27990       else
27991       {
27992          *numTxLyrs=  ((*retxTb)->numLyrs + ueDl->mimoInfo.cwInfo[!(ueDl->mimoInfo.btrCwIdx)].noLyr);
27993
27994          if((*retxTb)->tbIdx == 0 && ((*retxTb)->numLyrs == 2 ) && *numTxLyrs ==3)
27995          {
27996             *swpFlg = TRUE;
27997             proc->cwSwpEnabled = TRUE;
27998          }
27999          else if((*retxTb)->tbIdx == 1 && ((*retxTb)->numLyrs == 1) && *numTxLyrs ==3)
28000          {
28001             *swpFlg = TRUE;
28002             proc->cwSwpEnabled = TRUE;
28003          }
28004       }
28005
28006       precInfoAntIdx = cell->numTxAntPorts/2 - 1; 
28007       *prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])\
28008                    (cell, ue, ueDl->mimoInfo.ri, *frthrScp);
28009       *dciFrmt = TFU_DCI_FORMAT_2A;
28010       *raType = RG_SCH_CMN_RA_TYPE0;
28011    }
28012    else /* frthrScp == FALSE */
28013    {
28014       if (cell->numTxAntPorts == 2)
28015       {
28016          /*  Transmit Diversity  */
28017          *numTxLyrs = 1;
28018          if ((*retxTb)->tbIdx == 0)
28019          {
28020             *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28021          }
28022          else
28023          {
28024             /* If retxTB is TB2 then use format 2A */
28025             *dciFrmt = TFU_DCI_FORMAT_2A;
28026             *raType = RG_SCH_CMN_RA_TYPE0;
28027          }
28028          *prcdngInf = 0;
28029          RETVOID;
28030       }
28031       else /* NumAntPorts == 4 */
28032       {
28033          if ((*retxTb)->numLyrs == 2)
28034          {
28035             /* Allocate TB on CW1, using 2 Lyrs,
28036              * Format 2A, precoding accordingly */
28037             *numTxLyrs = 2;
28038             *dciFrmt = TFU_DCI_FORMAT_2A;
28039             *raType = RG_SCH_CMN_RA_TYPE0;
28040             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28041             *prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, *numTxLyrs, *frthrScp);
28042             RETVOID;
28043          }
28044          else
28045          {
28046             /*  Transmit Diversity  */
28047             *numTxLyrs = 1;
28048             if ((*retxTb)->tbIdx == 0)
28049             {
28050                *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28051             }
28052             else
28053             {
28054                /* If retxTB is TB2 then use format 2A */
28055                *dciFrmt = TFU_DCI_FORMAT_2A;
28056                *raType = RG_SCH_CMN_RA_TYPE0;
28057             }
28058             *prcdngInf = 0;
28059             RETVOID;
28060          }
28061       }
28062    }
28063
28064    RETVOID;
28065 }
28066
28067
28068 \f
28069 /**
28070  * @brief This function determines Transmission attributes
28071  *        incase of TM4 scheduling.
28072  *
28073  * @details
28074  *
28075  *     Function: rgSCHCmnDlGetAttrForTM4
28076  *     Purpose:  Determine retx TB and tx TB based on TB states.
28077  *               If forceTD enabled
28078  *                  perform only retx TB allocation.
28079  *                  If retxTB == TB2 then DCI Frmt = 2, RA Type = 0.
28080  *                  Else DCI Frmt and RA Type based on cell->isDlfsEnbld
28081  *               If RI == 1
28082  *                  perform retxTB allocation on CW1.
28083  *               Else if RI > 1
28084  *                  Determine further Scope and Swap Flag attributes
28085  *                  assuming a 2 CW transmission of RetxTB and new Tx TB.
28086  *                  If no further scope for new TX allocation
28087  *                     Allocate only retx TB using 2 layers if
28088  *                     this TB was previously transmitted using 2 layers AND
28089  *                     number of Tx antenna ports == 4.
28090  *                     otherwise do single layer precoding.
28091  *
28092  *     Invoked by: rgSCHCmnDlTM4TxRetx
28093  *
28094  *  @param[in]  RgSchUeCb        *ue
28095  *  @param[in]  RgSchDlHqProcCb  *proc
28096  *  @param[out] U8               *numTxLyrs
28097  *  @param[out] Bool             *isTraDiv
28098  *  @param[out] U8               *prcdngInf
28099  *  @param[out] U8               *raType
28100  *  @return  Void
28101  *
28102  **/
28103 #ifdef ANSI
28104 PRIVATE Void rgSCHCmnDlGetAttrForTM4
28105 (
28106 RgSchCellCb                *cell,
28107 RgSchUeCb                  *ue,
28108 RgSchDlHqProcCb            *proc,
28109 U8                         *numTxLyrs,
28110 TfuDciFormat               *dciFrmt,
28111 U8                         *prcdngInf,
28112 RgSchDlHqTbCb              **retxTb,
28113 RgSchDlHqTbCb              **txTb,
28114 Bool                       *frthrScp,
28115 Bool                       *swpFlg,
28116 U8                         *raType
28117 )
28118 #else
28119 PRIVATE Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
28120         prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
28121 RgSchCellCb                *cell;
28122 RgSchUeCb                  *ue;
28123 RgSchDlHqProcCb            *proc;
28124 U8                         *numTxLyrs;
28125 TfuDciFormat               *dciFrmt;
28126 U8                         *prcdngInf;
28127 RgSchDlHqTbCb              **retxTb;
28128 RgSchDlHqTbCb              **txTb;
28129 Bool                       *frthrScp;
28130 Bool                       *swpFlg;
28131 U8                         *raType;
28132 #endif
28133 {
28134    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
28135    U8 precInfoAntIdx;
28136
28137    TRC2(rgSCHCmnDlGetAttrForTM4);
28138
28139    *frthrScp = FALSE;
28140    /* Integration_fix: SPS Proc shall always have only one Cw */
28141 #ifdef LTEMAC_SPS
28142    if (((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28143          (ueDl->mimoInfo.forceTD)) 
28144 #ifdef LTE_ADV
28145      ||(TRUE == rgSCHLaaSCellEnabled(cell))
28146 #endif
28147       )
28148 #else
28149    if ((ueDl->mimoInfo.forceTD) 
28150 #ifdef LTE_ADV
28151        || (TRUE == rgSCHLaaSCellEnabled(cell))
28152 #endif
28153       )
28154 #endif
28155    {
28156       /* Transmit Diversity. Format based on dlfsEnabled
28157        * No further scope */
28158       if (proc->tbInfo[0].state == HQ_TB_NACKED)
28159       {
28160          *retxTb = &proc->tbInfo[0];
28161          *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28162       }
28163       else
28164       {
28165          *retxTb = &proc->tbInfo[1];
28166          *dciFrmt = TFU_DCI_FORMAT_2;
28167          *raType = RG_SCH_CMN_RA_TYPE0;
28168       }
28169       *numTxLyrs = 1;
28170       *frthrScp = FALSE;
28171       *prcdngInf = 0;
28172       RETVOID;
28173    }
28174
28175    if (ueDl->mimoInfo.ri == 1)
28176    {
28177       /* single layer precoding. Format 2.
28178        * No further scope */
28179       if (proc->tbInfo[0].state == HQ_TB_NACKED)
28180       {
28181          *retxTb = &proc->tbInfo[0];
28182       }
28183       else
28184       {
28185          *retxTb = &proc->tbInfo[1];
28186       }
28187       *numTxLyrs = 1;
28188       *dciFrmt = TFU_DCI_FORMAT_2;
28189       *raType = RG_SCH_CMN_RA_TYPE0;
28190       *frthrScp = FALSE;
28191       *prcdngInf = 0; /*When RI= 1*/
28192       RETVOID;
28193    }
28194
28195    /* Determine the 2 TB transmission attributes */
28196    rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, \
28197          frthrScp, swpFlg);
28198    *dciFrmt = TFU_DCI_FORMAT_2;
28199    *raType = RG_SCH_CMN_RA_TYPE0;
28200    if (*frthrScp)
28201    {
28202       /* Prefer allocation of RETX TB over 2 layers rather than combining
28203        * it with a new TX. */
28204       if ((ueDl->mimoInfo.ri == 2)
28205             && ((*retxTb)->numLyrs == 2) && (cell->numTxAntPorts == 4))
28206       {
28207          /* Allocate TB on CW1, using 2 Lyrs,
28208           * Format 2, precoding accordingly */
28209          *numTxLyrs = 2;
28210          *frthrScp = FALSE;
28211       }
28212       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28213       *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])
28214                    (cell, ue, ueDl->mimoInfo.ri, *frthrScp);
28215    }
28216    else /* frthrScp == FALSE */
28217    {
28218       if (cell->numTxAntPorts == 2)
28219       {
28220          /* single layer precoding. Format 2. */
28221          *numTxLyrs = 1;
28222          *prcdngInf = (getPrecInfoFunc[1][cell->numTxAntPorts/2 - 1])\
28223                       (cell, ue, *numTxLyrs, *frthrScp);
28224          RETVOID;
28225       }
28226       else /* NumAntPorts == 4 */
28227       {
28228          if ((*retxTb)->numLyrs == 2)
28229          {
28230             /* Allocate TB on CW1, using 2 Lyrs,
28231              * Format 2, precoding accordingly */
28232             *numTxLyrs = 2;
28233             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28234             *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
28235                          (cell, ue, *numTxLyrs, *frthrScp);
28236             RETVOID;
28237          }
28238          else
28239          {
28240             /* Allocate TB with 1 lyr precoding,
28241              * Format 2, precoding info accordingly */
28242             *numTxLyrs = 1;
28243             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28244             *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
28245                          (cell, ue, *numTxLyrs, *frthrScp);
28246             RETVOID;
28247          }
28248       }
28249    }
28250
28251    RETVOID;
28252 }
28253
28254 \f
28255 /**
28256  * @brief This function handles Retx allocation in case of TM3 UEs
28257  *        where previously one of the TBs was NACKED and the other
28258  *        TB is either ACKED/WAITING.
28259  *
28260  * @details
28261  *
28262  *     Function: rgSCHCmnDlTM3TxRetx
28263  *     Purpose:  Determine the TX attributes for TM3 TxRetx Allocation.
28264  *               If futher Scope for New Tx Allocation on other TB
28265  *                  Perform RETX alloc'n on 1 CW and TX alloc'n on other.
28266  *                  Add UE to cell wide RetxTx List.
28267  *               Else
28268  *                  Perform only RETX alloc'n on CW1.
28269  *                  Add UE to cell wide Retx List.
28270  *
28271  *               effBo is set to a non-zero value if allocation is
28272  *               successful.
28273  *
28274  *     Invoked by: rgSCHCmnDlAllocRbTM3
28275  *
28276  *  @param[in]  RgSchCellCb           *cell
28277  *  @param[in]  RgSchDlSf             *subFrm
28278  *  @param[in]  RgSchUeCb             *ue
28279  *  @param[in]  U32                   bo
28280  *  @param[out] U32                   *effBo
28281  *  @param[in]  RgSchDlHqProcCb       *proc
28282  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28283  *  @return  Void
28284  *
28285  **/
28286 #ifdef ANSI
28287 PRIVATE Void rgSCHCmnDlTM3TxRetx
28288 (
28289 RgSchCellCb                *cell,
28290 RgSchDlSf                  *subFrm,
28291 RgSchUeCb                  *ue,
28292 U32                        bo,
28293 U32                        *effBo,
28294 RgSchDlHqProcCb            *proc,
28295 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28296 )
28297 #else
28298 PRIVATE Void rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28299 RgSchCellCb                *cell;
28300 RgSchDlSf                  *subFrm;
28301 RgSchUeCb                  *ue;
28302 U32                        bo;
28303 U32                        *effBo;
28304 RgSchDlHqProcCb            *proc;
28305 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28306 #endif
28307 {
28308    S16              ret;
28309    RgSchDlRbAlloc   *allocInfo;
28310    U8               numRb;
28311    RgSchDlHqTbCb    *retxTb, *txTb;
28312    Bool             frthrScp;
28313    Bool             swpFlg;
28314    U8               prcdngInf;
28315    U8               numTxLyrs;
28316
28317    TRC2(rgSCHCmnDlTM3TxRetx);
28318    frthrScp = FALSE;
28319
28320    ret = ROK;
28321    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28322    swpFlg = FALSE;
28323
28324    /* Determine the transmission attributes */
28325    rgSCHCmnDlGetAttrForTM3(cell, ue, proc, &numTxLyrs, &allocInfo->dciFormat,\
28326          &prcdngInf, &retxTb, &txTb, &frthrScp, &swpFlg,\
28327          &allocInfo->raType);
28328
28329    if (frthrScp)
28330    {
28331 #ifdef LAA_DBG_LOG
28332       printf ("TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
28333 #endif
28334       ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
28335             &numRb, effBo);
28336       if (ret == RFAILED)
28337       {
28338          /* Allocation couldn't be made for Retx */
28339          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28340          RETVOID;
28341       }
28342       /* Adding UE to RbAllocInfo RETX-TX Lst */
28343       rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
28344    }
28345    else
28346    {
28347       ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, retxTb,
28348             numTxLyrs, &numRb, effBo);
28349       if (ret == RFAILED)
28350       {
28351          /* Allocation couldn't be made for Retx */
28352          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28353          RETVOID;
28354       }
28355 #ifdef LTEMAC_SPS
28356       if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28357 #endif
28358       {
28359          /* Adding UE to allocInfo RETX Lst */
28360          rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
28361       }
28362    }
28363    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
28364          prcdngInf, numTxLyrs, subFrm);
28365
28366    RETVOID;
28367 }
28368
28369 \f
28370 /**
28371  * @brief This function handles Retx allocation in case of TM4 UEs
28372  *        where previously one of the TBs was NACKED and the other
28373  *        TB is either ACKED/WAITING.
28374  *
28375  * @details
28376  *
28377  *     Function: rgSCHCmnDlTM4TxRetx
28378  *     Purpose:  Determine the TX attributes for TM4 TxRetx Allocation.
28379  *               If futher Scope for New Tx Allocation on other TB
28380  *                  Perform RETX alloc'n on 1 CW and TX alloc'n on other.
28381  *                  Add UE to cell wide RetxTx List.
28382  *               Else
28383  *                  Perform only RETX alloc'n on CW1.
28384  *                  Add UE to cell wide Retx List.
28385  *
28386  *               effBo is set to a non-zero value if allocation is
28387  *               successful.
28388  *
28389  *     Invoked by: rgSCHCmnDlAllocRbTM4
28390  *
28391  *  @param[in]  RgSchCellCb           *cell
28392  *  @param[in]  RgSchDlSf             *subFrm
28393  *  @param[in]  RgSchUeCb             *ue
28394  *  @param[in]  U32                   bo
28395  *  @param[out] U32                   *effBo
28396  *  @param[in]  RgSchDlHqProcCb       *proc
28397  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28398  *  @return  Void
28399  *
28400  **/
28401 #ifdef ANSI
28402 PRIVATE Void rgSCHCmnDlTM4TxRetx
28403 (
28404 RgSchCellCb                *cell,
28405 RgSchDlSf                  *subFrm,
28406 RgSchUeCb                  *ue,
28407 U32                        bo,
28408 U32                        *effBo,
28409 RgSchDlHqProcCb            *proc,
28410 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28411 )
28412 #else
28413 PRIVATE Void rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28414 RgSchCellCb                *cell;
28415 RgSchDlSf                  *subFrm;
28416 RgSchUeCb                  *ue;
28417 U32                        bo;
28418 U32                        *effBo;
28419 RgSchDlHqProcCb            *proc;
28420 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28421 #endif
28422 {
28423    S16              ret;
28424    RgSchDlRbAlloc   *allocInfo;
28425    U8               numRb;
28426    RgSchDlHqTbCb    *retxTb, *txTb;
28427    Bool             frthrScp;
28428    Bool             swpFlg;
28429    U8               prcdngInf;
28430    U8               numTxLyrs;
28431
28432    TRC2(rgSCHCmnDlTM4TxRetx);
28433
28434    ret = ROK;
28435    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28436    swpFlg = FALSE;
28437
28438    /* Determine the transmission attributes */
28439    rgSCHCmnDlGetAttrForTM4(cell, ue, proc, &numTxLyrs, &allocInfo->dciFormat,\
28440          &prcdngInf, &retxTb, &txTb, &frthrScp, &swpFlg,\
28441          &allocInfo->raType);
28442
28443    if (frthrScp)
28444    {
28445       ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
28446             &numRb, effBo);
28447       if (ret == RFAILED)
28448       {
28449          /* Fix : syed If TxRetx allocation failed then add the UE along 
28450           * with the proc to the nonSchdTxRetxUeLst and let spfc scheduler
28451           *  take care of it during finalization. */       
28452          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28453          RETVOID;
28454       }
28455       /* Adding UE to RbAllocInfo RETX-TX Lst */
28456       rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
28457    }
28458    else
28459    {
28460       ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, retxTb,
28461             numTxLyrs, &numRb, effBo);
28462       if (ret == RFAILED)
28463       {
28464          /* Allocation couldn't be made for Retx */
28465          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28466          RETVOID;
28467       }
28468 #ifdef LTEMAC_SPS
28469       if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28470 #endif
28471       {
28472          /* Adding UE to allocInfo RETX Lst */
28473          rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
28474       }
28475    }
28476    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
28477          prcdngInf, numTxLyrs, subFrm)
28478
28479       RETVOID;
28480 }
28481
28482 \f
28483 /**
28484  * @brief This function handles Retx allocation in case of TM4 UEs
28485  *        where previously both the TBs were ACKED and ACKED
28486  *        respectively.
28487  *
28488  * @details
28489  *
28490  *     Function: rgSCHCmnDlTM3TxTx
28491  *     Purpose:  Reached here for a TM3 UE's HqP's fresh allocation
28492  *                  where both the TBs are free for TX scheduling.
28493  *               If forceTD flag is set
28494  *                  perform TD on CW1 with TB1.
28495  *                  precInfo = 0
28496  *               else
28497  *                  DCI Format = 2A.
28498  *                  RA Type = Type0.
28499  *                  RI layered precoding 2 TB on 2 CW.
28500  *                  Set precoding info.
28501  *               Add UE to cellAllocInfo.
28502  *               Fill ueAllocInfo.
28503  *
28504  *              effBo is set to a non-zero value if allocation is
28505  *              successful.
28506  *
28507  *     Invoked by: rgSCHCmnDlAllocRbTM3
28508  *
28509  *  @param[in]  RgSchCellCb           *cell
28510  *  @param[in]  RgSchDlSf             *subFrm
28511  *  @param[in]  RgSchUeCb             *ue
28512  *  @param[in]  U32                   bo
28513  *  @param[out] U32                   *effBo
28514  *  @param[in]  RgSchDlHqProcCb       *proc
28515  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28516  *  @return  Void
28517  *
28518  **/
28519 #ifdef ANSI
28520 PRIVATE Void rgSCHCmnDlTM3TxTx
28521 (
28522 RgSchCellCb                *cell,
28523 RgSchDlSf                  *subFrm,
28524 RgSchUeCb                  *ue,
28525 U32                        bo,
28526 U32                        *effBo,
28527 RgSchDlHqProcCb            *proc,
28528 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28529 )
28530 #else
28531 PRIVATE Void rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28532 RgSchCellCb                *cell;
28533 RgSchDlSf                  *subFrm;
28534 RgSchUeCb                  *ue;
28535 U32                        bo;
28536 U32                        *effBo;
28537 RgSchDlHqProcCb            *proc;
28538 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28539 #endif
28540 {
28541    RgSchCmnDlUe     *ueDl;
28542    RgSchDlRbAlloc   *allocInfo;
28543    U8               numRb;
28544    U8               noTxLyrs;
28545    U8               precInfo;
28546    S16              ret;
28547    U8               precInfoAntIdx;
28548
28549    TRC2(rgSCHCmnDlTM3TxTx);
28550
28551    ret = ROK;
28552    ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
28553    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28554
28555    /* Integration_fix: SPS Proc shall always have only one Cw */
28556 #ifdef LTEMAC_SPS
28557 #ifdef FOUR_TX_ANTENNA
28558       if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28559                      (ueDl->mimoInfo.forceTD) || proc->hasDcch) /*Chandra Avoid DCCH to be SM */
28560 #else
28561    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28562          (ueDl->mimoInfo.forceTD))
28563 #endif
28564 #else
28565    if (ueDl->mimoInfo.forceTD) /* Transmit Diversity (TD) */
28566 #endif
28567    {
28568       allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
28569             &allocInfo->raType);
28570       ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28571             bo, &numRb, effBo);
28572       if (ret == RFAILED)
28573       {
28574          /* If allocation couldn't be made then return */
28575          RETVOID;
28576       }
28577       noTxLyrs = 1;
28578       precInfo = 0; /* TD */
28579    }
28580    else /* Precoding */
28581    {
28582       allocInfo->dciFormat = TFU_DCI_FORMAT_2A;
28583       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
28584
28585       /* Spatial Multiplexing using 2 CWs */
28586       ret = rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, &numRb, effBo);
28587       if (ret == RFAILED)
28588       {
28589          /* If allocation couldn't be made then return */
28590          RETVOID;
28591       }
28592       noTxLyrs = ueDl->mimoInfo.ri;
28593       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28594       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, getPrecInfoFunc[0], precInfoAntIdx);
28595       precInfo = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
28596    }
28597
28598 #ifdef LTEMAC_SPS
28599    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28600 #endif
28601    {
28602       /* Adding UE to RbAllocInfo TX Lst */
28603       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
28604    }
28605    /* Fill UE allocInfo scrath pad */
28606    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
28607          precInfo, noTxLyrs, subFrm);
28608
28609    RETVOID;
28610 }
28611
28612 \f
28613 /**
28614  * @brief This function handles Retx allocation in case of TM4 UEs
28615  *        where previously both the TBs were ACKED and ACKED
28616  *        respectively.
28617  *
28618  * @details
28619  *
28620  *     Function: rgSCHCmnDlTM4TxTx
28621  *     Purpose:  Reached here for a TM4 UE's HqP's fresh allocation
28622  *                  where both the TBs are free for TX scheduling.
28623  *               If forceTD flag is set
28624  *                  perform TD on CW1 with TB1.
28625  *                  precInfo = 0
28626  *               else
28627  *                  DCI Format = 2.
28628  *                  RA Type = Type0.
28629  *                  If Rank == 1
28630  *                     Single layer precoding of TB1 on CW1.
28631  *                     Set precoding info.
28632  *                  else
28633  *                     RI layered precoding 2 TB on 2 CW.
28634  *                     Set precoding info.
28635  *               Add UE to cellAllocInfo.
28636  *               Fill ueAllocInfo.
28637  *
28638  *              effBo is set to a non-zero value if allocation is
28639  *              successful.
28640  *
28641  *     Invoked by: rgSCHCmnDlAllocRbTM4
28642  *
28643  *  @param[in]  RgSchCellCb           *cell
28644  *  @param[in]  RgSchDlSf             *subFrm
28645  *  @param[in]  RgSchUeCb             *ue
28646  *  @param[in]  U32                   bo
28647  *  @param[out] U32                   *effBo
28648  *  @param[in]  RgSchDlHqProcCb       *proc
28649  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28650  *  @return  Void
28651  *
28652  **/
28653 #ifdef ANSI
28654 PRIVATE Void rgSCHCmnDlTM4TxTx
28655 (
28656 RgSchCellCb                *cell,
28657 RgSchDlSf                  *subFrm,
28658 RgSchUeCb                  *ue,
28659 U32                        bo,
28660 U32                        *effBo,
28661 RgSchDlHqProcCb            *proc,
28662 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28663 )
28664 #else
28665 PRIVATE Void rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28666 RgSchCellCb                *cell;
28667 RgSchDlSf                  *subFrm;
28668 RgSchUeCb                  *ue;
28669 U32                        bo;
28670 U32                        *effBo;
28671 RgSchDlHqProcCb            *proc;
28672 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28673 #endif
28674 {
28675    RgSchCmnDlUe     *ueDl;
28676    RgSchDlRbAlloc   *allocInfo;
28677    U8               numRb;
28678    U8               precInfo;
28679    U8               noTxLyrs;
28680    U8               precInfoAntIdx;
28681    S16              ret;
28682
28683    TRC2(rgSCHCmnDlTM4TxTx);
28684
28685    ret       = ROK;
28686    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
28687    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28688
28689    /* Integration_fix: SPS Proc shall always have only one Cw */
28690 #ifdef LTEMAC_SPS
28691 #ifdef FOUR_TX_ANTENNA
28692    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28693                   (ueDl->mimoInfo.forceTD) || proc->hasDcch) /*Chandra Avoid DCCH to be SM */
28694 #else
28695    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28696          (ueDl->mimoInfo.forceTD))
28697 #endif
28698 #else
28699    if (ueDl->mimoInfo.forceTD) /* Transmit Diversity (TD) */
28700 #endif
28701    {
28702       allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
28703             &allocInfo->raType);
28704
28705       ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28706             bo, &numRb, effBo);
28707       if (ret == RFAILED)
28708       {
28709          /* If allocation couldn't be made then return */
28710          RETVOID;
28711       }
28712       noTxLyrs = 1;
28713       precInfo = 0; /* TD */
28714    }
28715    else /* Precoding */
28716    {
28717       allocInfo->dciFormat = TFU_DCI_FORMAT_2;
28718       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
28719
28720       if (ueDl->mimoInfo.ri == 1)
28721       {
28722          /* Single Layer SM using FORMAT 2 */
28723          ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28724                bo, &numRb, effBo);
28725          if (ret == RFAILED)
28726          {
28727             /* If allocation couldn't be made then return */
28728             RETVOID;
28729          }
28730          noTxLyrs = 1;
28731          precInfo = 0; /* PrecInfo as 0 for RI=1*/
28732       }
28733       else
28734       {
28735          /* Spatial Multiplexing using 2 CWs */
28736          ret = rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, &numRb, effBo);
28737          if (ret == RFAILED)
28738          {
28739             /* If allocation couldn't be made then return */
28740             RETVOID;
28741          }
28742          noTxLyrs = ueDl->mimoInfo.ri;
28743          precInfoAntIdx = cell->numTxAntPorts/2 - 1; 
28744          precInfo = (getPrecInfoFunc[1][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
28745       }
28746    }
28747
28748    
28749 #ifdef LTEMAC_SPS
28750    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28751 #endif
28752    {
28753       /* Adding UE to RbAllocInfo TX Lst */
28754       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
28755    }
28756
28757    /* Fill UE allocInfo scrath pad */
28758    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
28759          precInfo, noTxLyrs, subFrm);
28760
28761    RETVOID;
28762 }
28763
28764 \f
28765 /**
28766  * @brief This function determines the RBs and Bytes required for BO
28767  *        transmission for UEs configured with TM 4.
28768  *
28769  * @details
28770  *
28771  *     Function: rgSCHCmnDlAllocTxRbTM4
28772  *     Purpose:  Invokes the functionality particular to the
28773  *               current state of the TBs of the "proc".
28774  *
28775  *               Reference Parameter effBo is filled with alloced bytes.
28776  *               Returns RFAILED if BO not satisfied at all.
28777  *
28778  *     Invoked by: rgSCHCmnDlAllocTxRb
28779  *
28780  *  @param[in]  RgSchCellCb           *cell
28781  *  @param[in]  RgSchDlSf             *subFrm
28782  *  @param[in]  RgSchUeCb             *ue
28783  *  @param[in]  U32                   bo
28784  *  @param[out] U32                   *effBo
28785  *  @param[in]  RgSchDlHqProcCb       *proc
28786  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28787  *  @return  Void
28788  *
28789  **/
28790 #ifdef ANSI
28791 PRIVATE Void rgSCHCmnDlAllocTxRbTM4
28792 (
28793 RgSchCellCb                *cell,
28794 RgSchDlSf                  *subFrm,
28795 RgSchUeCb                  *ue,
28796 U32                        bo,
28797 U32                        *effBo,
28798 RgSchDlHqProcCb            *proc,
28799 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28800 )
28801 #else
28802 PRIVATE Void rgSCHCmnDlAllocTxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28803 RgSchCellCb                *cell;
28804 RgSchDlSf                  *subFrm;
28805 RgSchUeCb                  *ue;
28806 U32                        bo;
28807 U32                        *effBo;
28808 RgSchDlHqProcCb            *proc;
28809 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28810 #endif
28811 {
28812    TRC2(rgSCHCmnDlAllocTxRbTM4);
28813
28814    /* Both TBs free for TX allocation */
28815    rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
28816          proc, cellWdAllocInfo);
28817
28818    RETVOID;
28819 }
28820
28821 \f
28822 /**
28823  * @brief This function determines the RBs and Bytes required for BO
28824  *        retransmission for UEs configured with TM 4.
28825  *
28826  * @details
28827  *
28828  *     Function: rgSCHCmnDlAllocRetxRbTM4
28829  *     Purpose:  Invokes the functionality particular to the
28830  *               current state of the TBs of the "proc".
28831  *
28832  *               Reference Parameter effBo is filled with alloced bytes.
28833  *               Returns RFAILED if BO not satisfied at all.
28834  *
28835  *     Invoked by: rgSCHCmnDlAllocRetxRb
28836  *
28837  *  @param[in]  RgSchCellCb           *cell
28838  *  @param[in]  RgSchDlSf             *subFrm
28839  *  @param[in]  RgSchUeCb             *ue
28840  *  @param[in]  U32                   bo
28841  *  @param[out] U32                   *effBo
28842  *  @param[in]  RgSchDlHqProcCb       *proc
28843  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28844  *  @return  Void
28845  *
28846  **/
28847 #ifdef ANSI
28848 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4
28849 (
28850 RgSchCellCb                *cell,
28851 RgSchDlSf                  *subFrm,
28852 RgSchUeCb                  *ue,
28853 U32                        bo,
28854 U32                        *effBo,
28855 RgSchDlHqProcCb            *proc,
28856 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28857 )
28858 #else
28859 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28860 RgSchCellCb                *cell;
28861 RgSchDlSf                  *subFrm;
28862 RgSchUeCb                  *ue;
28863 U32                        bo;
28864 U32                        *effBo;
28865 RgSchDlHqProcCb            *proc;
28866 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28867 #endif
28868 {
28869    TRC2(rgSCHCmnDlAllocRetxRbTM4);
28870
28871    if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
28872          (proc->tbInfo[1].state == HQ_TB_NACKED))
28873    {
28874       /* Both TBs require RETX allocation */
28875       rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo,\
28876             proc, cellWdAllocInfo);
28877    }
28878    else
28879    {
28880       /* One of the TBs need RETX allocation. Other TB may/maynot
28881        * be available for new TX allocation. */
28882       rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo,\
28883             proc, cellWdAllocInfo);
28884    }
28885
28886    RETVOID;
28887 }
28888
28889 #ifdef RG_UNUSED
28890 \f
28891 /**
28892  * @brief This function determines the RBs and Bytes required for BO
28893  *        transmission for UEs configured with TM 5.
28894  *
28895  * @details
28896  *
28897  *     Function: rgSCHCmnDlAllocTxRbTM5
28898  *     Purpose:
28899  *
28900  *               Reference Parameter effBo is filled with alloced bytes.
28901  *               Returns RFAILED if BO not satisfied at all.
28902  *
28903  *     Invoked by: rgSCHCmnDlAllocTxRb
28904  *
28905  *  @param[in]  RgSchCellCb           *cell
28906  *  @param[in]  RgSchDlSf             *subFrm
28907  *  @param[in]  RgSchUeCb             *ue
28908  *  @param[in]  U32                   bo
28909  *  @param[out] U32                   *effBo
28910  *  @param[in]  RgSchDlHqProcCb       *proc
28911  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28912  *  @return Void
28913  *
28914  **/
28915 #ifdef ANSI
28916 PRIVATE Void rgSCHCmnDlAllocTxRbTM5
28917 (
28918 RgSchCellCb                *cell,
28919 RgSchDlSf                  *subFrm,
28920 RgSchUeCb                  *ue,
28921 U32                        bo,
28922 U32                        *effBo,
28923 RgSchDlHqProcCb            *proc,
28924 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28925 )
28926 #else
28927 PRIVATE Void rgSCHCmnDlAllocTxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28928 RgSchCellCb                *cell;
28929 RgSchDlSf                  *subFrm;
28930 RgSchUeCb                  *ue;
28931 U32                        bo;
28932 U32                        *effBo;
28933 RgSchDlHqProcCb            *proc;
28934 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28935 #endif
28936 {
28937    TRC2(rgSCHCmnDlAllocTxRbTM5);
28938 #if (ERRCLASS & ERRCLS_DEBUG)
28939    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
28940 #endif
28941    RETVOID;
28942 }
28943
28944 \f
28945 /**
28946  * @brief This function determines the RBs and Bytes required for BO
28947  *        retransmission for UEs configured with TM 5.
28948  *
28949  * @details
28950  *
28951  *     Function: rgSCHCmnDlAllocRetxRbTM5
28952  *     Purpose:
28953  *
28954  *               Reference Parameter effBo is filled with alloced bytes.
28955  *               Returns RFAILED if BO not satisfied at all.
28956  *
28957  *     Invoked by: rgSCHCmnDlAllocRetxRb
28958  *
28959  *  @param[in]  RgSchCellCb           *cell
28960  *  @param[in]  RgSchDlSf             *subFrm
28961  *  @param[in]  RgSchUeCb             *ue
28962  *  @param[in]  U32                   bo
28963  *  @param[out] U32                   *effBo
28964  *  @param[in]  RgSchDlHqProcCb       *proc
28965  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28966  *  @return Void
28967  *
28968  **/
28969 #ifdef ANSI
28970 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5
28971 (
28972 RgSchCellCb                *cell,
28973 RgSchDlSf                  *subFrm,
28974 RgSchUeCb                  *ue,
28975 U32                        bo,
28976 U32                        *effBo,
28977 RgSchDlHqProcCb            *proc,
28978 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28979 )
28980 #else
28981 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28982 RgSchCellCb                *cell;
28983 RgSchDlSf                  *subFrm;
28984 RgSchUeCb                  *ue;
28985 U32                        bo;
28986 U32                        *effBo;
28987 RgSchDlHqProcCb            *proc;
28988 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28989 #endif
28990 {
28991    TRC2(rgSCHCmnDlAllocRetxRbTM5);
28992 #if (ERRCLASS & ERRCLS_DEBUG)
28993    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
28994 #endif
28995    RETVOID;
28996 }
28997 #endif
28998
28999 \f
29000 /**
29001  * @brief This function determines the RBs and Bytes required for BO
29002  *        transmission for UEs configured with TM 6.
29003  *
29004  * @details
29005  *
29006  *     Function: rgSCHCmnDlAllocTxRbTM6
29007  *     Purpose:
29008  *
29009  *               Reference Parameter effBo is filled with alloced bytes.
29010  *               Returns RFAILED if BO not satisfied at all.
29011  *
29012  *     Invoked by: rgSCHCmnDlAllocTxRb
29013  *
29014  *  @param[in]  RgSchCellCb           *cell
29015  *  @param[in]  RgSchDlSf             *subFrm
29016  *  @param[in]  RgSchUeCb             *ue
29017  *  @param[in]  U32                   bo
29018  *  @param[out] U32                   *effBo
29019  *  @param[in]  RgSchDlHqProcCb       *proc
29020  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29021  *  @return Void
29022  *
29023  **/
29024 #ifdef ANSI
29025 PRIVATE Void rgSCHCmnDlAllocTxRbTM6
29026 (
29027 RgSchCellCb                *cell,
29028 RgSchDlSf                  *subFrm,
29029 RgSchUeCb                  *ue,
29030 U32                        bo,
29031 U32                        *effBo,
29032 RgSchDlHqProcCb            *proc,
29033 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29034 )
29035 #else
29036 PRIVATE Void rgSCHCmnDlAllocTxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29037 RgSchCellCb                *cell;
29038 RgSchDlSf                  *subFrm;
29039 RgSchUeCb                  *ue;
29040 U32                        bo;
29041 U32                        *effBo;
29042 RgSchDlHqProcCb            *proc;
29043 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29044 #endif
29045 {
29046    RgSchDlRbAlloc *allocInfo;
29047    RgSchCmnDlUe   *ueDl;
29048    S16            ret;
29049    U8             numRb;
29050
29051    TRC2(rgSCHCmnDlAllocTxRbTM6);
29052
29053    ret       = ROK;
29054    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29055    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29056
29057    if (ueDl->mimoInfo.forceTD)
29058    {
29059       allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
29060       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29061    }
29062    else
29063    {
29064       allocInfo->dciFormat = TFU_DCI_FORMAT_1B;
29065       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29066       /* Fill precoding information for FORMAT 1B */
29067       /* First 4 least significant bits to indicate PMI.
29068        * 4th most significant corresponds to pmi Confirmation.
29069        */
29070       allocInfo->mimoAllocInfo.precIdxInfo |= ue->mimoInfo.puschFdbkVld << 4;
29071       allocInfo->mimoAllocInfo.precIdxInfo |= ueDl->mimoInfo.pmi;
29072    }
29073    ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
29074          bo, &numRb, effBo);
29075    if (ret == RFAILED)
29076    {
29077       /* If allocation couldn't be made then return */
29078       RETVOID;
29079    }
29080    
29081 #ifdef LTEMAC_SPS
29082    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
29083 #endif
29084    {
29085       /* Adding UE to RbAllocInfo TX Lst */
29086       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
29087    }
29088    /* Fill UE alloc Info */
29089    allocInfo->rbsReq = numRb;
29090    allocInfo->dlSf   = subFrm;
29091    RETVOID;
29092 }
29093
29094 \f
29095 /**
29096  * @brief This function determines the RBs and Bytes required for BO
29097  *        retransmission for UEs configured with TM 6.
29098  *
29099  * @details
29100  *
29101  *     Function: rgSCHCmnDlAllocRetxRbTM6
29102  *     Purpose:
29103  *
29104  *               Reference Parameter effBo is filled with alloced bytes.
29105  *               Returns RFAILED if BO not satisfied at all.
29106  *
29107  *     Invoked by: rgSCHCmnDlAllocRetxRb
29108  *
29109  *  @param[in]  RgSchCellCb           *cell
29110  *  @param[in]  RgSchDlSf             *subFrm
29111  *  @param[in]  RgSchUeCb             *ue
29112  *  @param[in]  U32                   bo
29113  *  @param[out] U32                   *effBo
29114  *  @param[in]  RgSchDlHqProcCb       *proc
29115  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29116  *  @return Void
29117  *
29118  **/
29119 #ifdef ANSI
29120 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6
29121 (
29122 RgSchCellCb                *cell,
29123 RgSchDlSf                  *subFrm,
29124 RgSchUeCb                  *ue,
29125 U32                        bo,
29126 U32                        *effBo,
29127 RgSchDlHqProcCb            *proc,
29128 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29129 )
29130 #else
29131 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29132 RgSchCellCb                *cell;
29133 RgSchDlSf                  *subFrm;
29134 RgSchUeCb                  *ue;
29135 U32                        bo;
29136 U32                        *effBo;
29137 RgSchDlHqProcCb            *proc;
29138 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29139 #endif
29140 {
29141    RgSchDlRbAlloc *allocInfo;
29142    RgSchCmnDlUe   *ueDl;
29143    S16            ret;
29144    U8             numRb;
29145
29146    TRC2(rgSCHCmnDlAllocRetxRbTM6);
29147
29148    ret       = ROK;
29149    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29150    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29151
29152    if (ueDl->mimoInfo.forceTD)
29153    {
29154       allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
29155       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29156    }
29157    else
29158    {
29159       allocInfo->dciFormat = TFU_DCI_FORMAT_1B;
29160       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29161       /* Fill precoding information for FORMAT 1B */
29162       /* First 4 least significant bits to indicate PMI.
29163        * 4th most significant corresponds to pmi Confirmation.
29164        */
29165       allocInfo->mimoAllocInfo.precIdxInfo |= ue->mimoInfo.puschFdbkVld << 4;
29166       allocInfo->mimoAllocInfo.precIdxInfo |= ueDl->mimoInfo.pmi;
29167    }
29168
29169    /* Get the Allocation in terms of RBs that are required for
29170     * this retx of TB1 */
29171    ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, &proc->tbInfo[0],
29172          1, &numRb, effBo);
29173    if (ret == RFAILED)
29174    {
29175       /* Allocation couldn't be made for Retx */
29176       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
29177       RETVOID;
29178    }
29179    /* Adding UE to allocInfo RETX Lst */
29180    rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
29181    /* Fill UE alloc Info */
29182    allocInfo->rbsReq = numRb;
29183    allocInfo->dlSf   = subFrm;
29184    RETVOID;
29185 }
29186
29187 \f
29188 /**
29189  * @brief This function determines the RBs and Bytes required for BO
29190  *        transmission for UEs configured with TM 7.
29191  *
29192  * @details
29193  *
29194  *     Function: rgSCHCmnDlAllocTxRbTM7
29195  *     Purpose:
29196  *
29197  *               Reference Parameter effBo is filled with alloced bytes.
29198  *               Returns RFAILED if BO not satisfied at all.
29199  *
29200  *     Invoked by: rgSCHCmnDlAllocTxRb
29201  *
29202  *  @param[in]  RgSchCellCb           *cell
29203  *  @param[in]  RgSchDlSf             *subFrm
29204  *  @param[in]  RgSchUeCb             *ue
29205  *  @param[in]  U32                   bo
29206  *  @param[out] U32                   *effBo
29207  *  @param[in]  RgSchDlHqProcCb       *proc
29208  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29209  *  @return Void
29210  *
29211  **/
29212 #ifdef ANSI
29213 PRIVATE Void rgSCHCmnDlAllocTxRbTM7
29214 (
29215 RgSchCellCb                *cell,
29216 RgSchDlSf                  *subFrm,
29217 RgSchUeCb                  *ue,
29218 U32                        bo,
29219 U32                        *effBo,
29220 RgSchDlHqProcCb            *proc,
29221 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29222 )
29223 #else
29224 PRIVATE Void rgSCHCmnDlAllocTxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29225 RgSchCellCb                *cell;
29226 RgSchDlSf                  *subFrm;
29227 RgSchUeCb                  *ue;
29228 U32                        bo;
29229 U32                        *effBo;
29230 RgSchDlHqProcCb            *proc;
29231 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29232 #endif
29233 {
29234    TRC2(rgSCHCmnDlAllocTxRbTM7);
29235    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
29236    RETVOID;
29237 }
29238
29239 \f
29240 /**
29241  * @brief This function determines the RBs and Bytes required for BO
29242  *        retransmission for UEs configured with TM 7.
29243  *
29244  * @details
29245  *
29246  *     Function: rgSCHCmnDlAllocRetxRbTM7
29247  *     Purpose:
29248  *
29249  *               Reference Parameter effBo is filled with alloced bytes.
29250  *               Returns RFAILED if BO not satisfied at all.
29251  *
29252  *     Invoked by: rgSCHCmnDlAllocRetxRb
29253  *
29254  *  @param[in]  RgSchCellCb           *cell
29255  *  @param[in]  RgSchDlSf             *subFrm
29256  *  @param[in]  RgSchUeCb             *ue
29257  *  @param[in]  U32                   bo
29258  *  @param[out] U32                   *effBo
29259  *  @param[in]  RgSchDlHqProcCb       *proc
29260  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29261  *  @return Void
29262  *
29263  **/
29264 #ifdef ANSI
29265 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7
29266 (
29267 RgSchCellCb                *cell,
29268 RgSchDlSf                  *subFrm,
29269 RgSchUeCb                  *ue,
29270 U32                        bo,
29271 U32                        *effBo,
29272 RgSchDlHqProcCb            *proc,
29273 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29274 )
29275 #else
29276 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29277 RgSchCellCb                *cell;
29278 RgSchDlSf                  *subFrm;
29279 RgSchUeCb                  *ue;
29280 U32                        bo;
29281 U32                        *effBo;
29282 RgSchDlHqProcCb            *proc;
29283 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29284 #endif
29285 {
29286    TRC2(rgSCHCmnDlAllocRetxRbTM7);
29287    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
29288    RETVOID;
29289 }
29290
29291 \f
29292 /**
29293  * @brief This function invokes the TM specific DL TX RB Allocation routine.
29294  *
29295  * @details
29296  *
29297  *     Function: rgSCHCmnDlAllocTxRb
29298  *     Purpose:  This function invokes the TM specific
29299  *               DL TX RB Allocation routine.
29300  *
29301  *     Invoked by: Specific Schedulers
29302  *
29303  *  @param[in]  RgSchCellCb           *cell
29304  *  @param[in]  RgSchDlSf             *subFrm
29305  *  @param[in]  RgSchUeCb             *ue
29306  *  @param[in]  U32                   bo
29307  *  @param[out] U32                   *effBo
29308  *  @param[in]  RgSchDlHqProcCb       *proc
29309  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29310  *  @return  S16
29311  *
29312  **/
29313 #ifdef ANSI
29314 PUBLIC S16 rgSCHCmnDlAllocTxRb
29315 (
29316 RgSchCellCb                *cell,
29317 RgSchDlSf                  *subFrm,
29318 RgSchUeCb                  *ue,
29319 U32                        bo,
29320 U32                        *effBo,
29321 RgSchDlHqProcCb            *proc,
29322 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29323 )
29324 #else
29325 PUBLIC S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29326 RgSchCellCb                *cell;
29327 RgSchDlSf                  *subFrm;
29328 RgSchUeCb                  *ue;
29329 U32                        bo;
29330 U32                        *effBo;
29331 RgSchDlHqProcCb            *proc;
29332 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29333 #endif
29334 {
29335    U32                     newSchBits = 0;
29336    U32                     prevSchBits = 0;
29337    RgSchDlRbAlloc          *allocInfo;
29338
29339    TRC2(rgSCHCmnDlAllocTxRb);
29340
29341    if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
29342    {
29343       ue->dl.aggTbBits = 0;
29344    }
29345    *effBo = 0;
29346
29347    /* Calculate totals bits previously allocated */
29348    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29349    if (allocInfo->tbInfo[0].schdlngForTb)
29350    {
29351       prevSchBits += allocInfo->tbInfo[0].bytesReq;
29352    }
29353    if (allocInfo->tbInfo[1].schdlngForTb)
29354    {
29355       prevSchBits += allocInfo->tbInfo[1].bytesReq;
29356    }
29357
29358    /* Call TM specific RB allocation routine */
29359    (dlAllocTxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
29360          proc, cellWdAllocInfo);
29361
29362    if (*effBo)
29363    {
29364       /* Calculate totals bits newly allocated */
29365       if (allocInfo->tbInfo[0].schdlngForTb)
29366       {
29367          newSchBits += allocInfo->tbInfo[0].bytesReq;
29368       }
29369       if (allocInfo->tbInfo[1].schdlngForTb)
29370       {
29371          newSchBits += allocInfo->tbInfo[1].bytesReq;
29372       }
29373       if (newSchBits > prevSchBits)
29374       {
29375          ue->dl.aggTbBits += ((newSchBits - prevSchBits) * 8);
29376          RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
29377       }
29378    }
29379
29380    RETVALUE(ROK);
29381 }
29382
29383 /* DwPTS Scheduling Changes Start */
29384 #ifdef LTE_TDD
29385 /**
29386  * @brief Retransmit decision for TDD. Retx is avoided in below cases
29387  *        1) DL Sf       -> Spl Sf
29388  *        2) DL SF       -> DL SF 0 
29389  *
29390  * @details
29391  *
29392  *     Function: rgSCHCmnRetxAvoidTdd 
29393  *     Purpose: Avoid allocating RETX for cases 1, 2 
29394  * 
29395  *     Invoked by: rgSCHCmnRetxAvoidTdd 
29396  *
29397  *  @param[in]  RgSchDlSf             *curSf
29398  *  @param[in]  RgSchCellCb           *cell
29399  *  @param[in]  RgSchDlHqProcCb       *proc
29400  *  @return  Bool 
29401  *
29402  **/
29403 #ifdef ANSI
29404 PUBLIC Bool rgSCHCmnRetxAvoidTdd 
29405 (
29406 RgSchDlSf                  *curSf,
29407 RgSchCellCb                *cell,
29408 RgSchDlHqProcCb            *proc
29409 )
29410 #else
29411 PUBLIC Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
29412 RgSchDlSf                  *curSf;
29413 RgSchCellCb                *cell;
29414 RgSchDlHqProcCb            *proc;
29415 #endif
29416 {
29417    RgSchTddSfType   txSfType = 0;
29418
29419    TRC2(rgSCHCmnRetxAvoidTdd);
29420
29421    /* Get the RBs of TB that will be retransmitted */
29422    if (proc->tbInfo[0].state == HQ_TB_NACKED)
29423    {
29424       txSfType = proc->tbInfo[0].sfType;
29425
29426 #ifdef XEON_SPECIFIC_CHANGES
29427 #ifndef XEON_TDD_SPCL
29428       /* Avoid re-transmission on Normal SF when the corresponding TB wss transmitted on SPCL SF */
29429       if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
29430       {
29431          RETVALUE(TRUE);
29432       }
29433 #endif
29434 #endif
29435    }
29436    if (proc->tbInfo[1].state == HQ_TB_NACKED) 
29437    {
29438       /* Select the TxSf with the highest num of possible REs 
29439        * In ascending order -> 1) SPL SF 2) DL_SF_0 3) DL_SF */
29440       txSfType = RGSCH_MAX(txSfType, proc->tbInfo[1].sfType);
29441
29442 #ifdef XEON_SPECIFIC_CHANGES
29443 #ifndef XEON_TDD_SPCL
29444       /* Avoid re-transmission on Normal SF when the corresponding TB wss tranmitted on SPCL SF */
29445       if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
29446       {
29447          RETVALUE(TRUE);
29448       }
29449 #endif
29450 #endif
29451    }
29452
29453    if (txSfType > curSf->sfType)
29454    {
29455       /* Avoid retx */
29456       RETVALUE(TRUE);
29457    }
29458    
29459    /* Allow Retx */
29460    RETVALUE(FALSE);
29461 }
29462
29463 #else
29464 /* DwPTS Scheduling Changes End */
29465 \f
29466 /**
29467  * @brief Avoid allocating RETX incase of collision
29468  * with reserved resources for BCH/PSS/SSS occassions.
29469  *
29470  * @details
29471  *
29472  *     Function: rgSCHCmnRetxAllocAvoid 
29473  *     Purpose: Avoid allocating RETX incase of collision
29474  * with reserved resources for BCH/PSS/SSS occassions 
29475  *
29476  *     Invoked by: rgSCHCmnDlAllocRetxRb 
29477  *
29478  *  @param[in]  RgSchDlSf             *subFrm
29479  *  @param[in]  RgSchUeCb             *ue
29480  *  @param[in]  RgSchDlHqProcCb       *proc
29481  *  @return  Bool 
29482  *
29483  **/
29484 #ifdef ANSI
29485 PUBLIC Bool rgSCHCmnRetxAllocAvoid 
29486 (
29487 RgSchDlSf                  *subFrm,
29488 RgSchCellCb                *cell,
29489 RgSchDlHqProcCb            *proc
29490 )
29491 #else
29492 PUBLIC Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
29493 RgSchDlSf                  *subFrm;
29494 RgSchCellCb                *cell;
29495 RgSchDlHqProcCb            *proc;
29496 #endif
29497 {
29498    U8          reqRbs;
29499
29500    TRC2(rgSCHCmnRetxAllocAvoid);
29501
29502    if (proc->tbInfo[0].state == HQ_TB_NACKED)
29503    {
29504       reqRbs = proc->tbInfo[0].dlGrnt.numRb;    
29505    }
29506    else
29507    {
29508       reqRbs = proc->tbInfo[1].dlGrnt.numRb;    
29509    }
29510    /* Consider the dlGrnt.numRb of the Retransmitting proc->tbInfo
29511     * and current available RBs to determine if this RETX TB
29512     * will collide with the BCH/PSS/SSS occassion */
29513    if (subFrm->sfNum % 5 == 0)
29514    {
29515       if ((subFrm->bwAssigned < cell->pbchRbEnd) &&
29516           (((subFrm->bwAssigned + reqRbs) - cell->pbchRbStart) > 0))
29517       {
29518          RETVALUE(TRUE);
29519       }
29520    }
29521    RETVALUE(FALSE);
29522 }
29523
29524 #endif
29525
29526 \f
29527 /**
29528  * @brief This function invokes the TM specific DL RETX RB Allocation routine.
29529  *
29530  * @details
29531  *
29532  *     Function: rgSCHCmnDlAllocRetxRb
29533  *     Purpose:  This function invokes the TM specific
29534  *               DL RETX RB Allocation routine.
29535  *
29536  *     Invoked by: Specific Schedulers
29537  *
29538  *  @param[in]  RgSchCellCb           *cell
29539  *  @param[in]  RgSchDlSf             *subFrm
29540  *  @param[in]  RgSchUeCb             *ue
29541  *  @param[in]  U32                   bo
29542  *  @param[out] U32                   *effBo
29543  *  @param[in]  RgSchDlHqProcCb       *proc
29544  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29545  *  @return  S16
29546  *
29547  **/
29548 #ifdef ANSI
29549 PUBLIC S16 rgSCHCmnDlAllocRetxRb
29550 (
29551 RgSchCellCb                *cell,
29552 RgSchDlSf                  *subFrm,
29553 RgSchUeCb                  *ue,
29554 U32                        bo,
29555 U32                        *effBo,
29556 RgSchDlHqProcCb            *proc,
29557 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29558 )
29559 #else
29560 PUBLIC S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29561 RgSchCellCb                *cell;
29562 RgSchDlSf                  *subFrm;
29563 RgSchUeCb                  *ue;
29564 U32                        bo;
29565 U32                        *effBo;
29566 RgSchDlHqProcCb            *proc;
29567 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29568 #endif
29569 {
29570    U32                     newSchBits = 0;
29571    RgSchDlRbAlloc          *allocInfo;
29572
29573    TRC2(rgSCHCmnDlAllocRetxRb);
29574
29575    if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
29576    {
29577       ue->dl.aggTbBits = 0;
29578    }
29579  
29580    *effBo = 0;
29581    /* Check for DL BW exhaustion */
29582    if (subFrm->bw <= subFrm->bwAssigned)
29583    {
29584       RETVALUE(RFAILED);
29585    }
29586    /* Call TM specific RB allocation routine */
29587    (dlAllocRetxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
29588          proc, cellWdAllocInfo);
29589
29590    if (*effBo)
29591    {
29592       allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29593       /* Calculate totals bits newly allocated */
29594       if (allocInfo->tbInfo[0].schdlngForTb)
29595       {
29596          newSchBits += allocInfo->tbInfo[0].bytesReq;
29597       }
29598       if (allocInfo->tbInfo[1].schdlngForTb)
29599       {
29600          newSchBits += allocInfo->tbInfo[1].bytesReq;
29601       }
29602       ue->dl.aggTbBits += (newSchBits * 8);
29603       RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
29604    }
29605    
29606    RETVALUE(ROK);
29607 }
29608
29609 \f
29610 /**
29611  * @brief This function determines the RBs and Bytes required for
29612  *        Transmission on 1 CW.
29613  *
29614  * @details
29615  *
29616  *     Function: rgSCHCmnDlAlloc1CwTxRb
29617  *     Purpose:  This function determines the RBs and Bytes required
29618  *               for Transmission of DL SVC BO on 1 CW.
29619  *               Also, takes care of SVC by SVC allocation by tracking
29620  *               previous SVCs allocations.
29621  *               Returns RFAILED if BO not satisfied at all.
29622  *
29623  *     Invoked by: DL UE Allocation
29624  *
29625  *  @param[in]  RgSchCellCb      *cell
29626  *  @param[in]  RgSchDlSf        *subFrm
29627  *  @param[in]  RgSchUeCb        *ue
29628  *  @param[in]  RgSchDlHqTbCb    *tbInfo
29629  *  @param[in]  U32              bo
29630  *  @param[out] U8               *numRb
29631  *  @param[out] U32              *effBo
29632  *  @return  S16
29633  *
29634  **/
29635 #ifdef ANSI
29636 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb
29637 (
29638 RgSchCellCb                *cell,
29639 RgSchDlSf                  *subFrm,
29640 RgSchUeCb                  *ue,
29641 RgSchDlHqTbCb              *tbInfo,
29642 U32                        bo,
29643 U8                         *numRb,
29644 U32                        *effBo
29645 )
29646 #else
29647 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
29648 RgSchCellCb                *cell;
29649 RgSchDlSf                  *subFrm;
29650 RgSchUeCb                  *ue;
29651 RgSchDlHqTbCb              *tbInfo;
29652 U32                        bo;
29653 U8                         *numRb;
29654 U32                        *effBo;
29655 #endif
29656 {
29657    U32                tbSz;
29658    U8                 imcs;
29659    U8                 iTbs;
29660    RgSchCmnDlUe       *ueDl;
29661    RgSchDlRbAlloc     *allocInfo;
29662    U32                oldReq;
29663    U32                reqBytes;
29664    /* Correcting wrap around issue.
29665     * This change has been done at mutliple places in this function.*/
29666    U32                tempNumRb;
29667    TRC2(rgSCHCmnDlAlloc1CwTxRb);
29668
29669    reqBytes  = bo;
29670    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29671    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29672    oldReq    = ueDl->outStndAlloc;
29673
29674 #ifdef RG_5GTF
29675    //TODO_SID: Currently setting max Tb size wrt to 5GTF TM3
29676    iTbs = ue->ue5gtfCb.mcs;
29677    ueDl->maxTbSz = MAX_5GTF_TB_SIZE * ue->ue5gtfCb.rank;
29678    ueDl->maxRb = MAX_5GTF_PRBS;
29679 #endif
29680    ueDl->outStndAlloc += bo;
29681    /* consider Cumulative amount of this BO and bytes so far allocated */
29682    bo = RGSCH_MIN(ueDl->outStndAlloc, ueDl->maxTbSz/8);
29683    /* Get the number of REs needed for this bo. */
29684    //noRes = ((bo * 8 * 1024) / eff);
29685
29686    /* Get the number of RBs needed for this transmission */
29687    /* Number of RBs = No of REs / No of REs per RB       */
29688    //tempNumRb = RGSCH_CEIL(noRes, cellDl->noResPerRb[cfi]);
29689    tempNumRb = MAX_5GTF_PRBS;
29690    tbSz = RGSCH_MIN(bo, (rgSch5gtfTbSzTbl[iTbs]/8) * ue->ue5gtfCb.rank);
29691
29692    /* DwPts Scheduling Changes End */
29693    *effBo = RGSCH_MIN(tbSz - oldReq, reqBytes);
29694
29695 #ifdef RG_5GTF
29696    //RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs);
29697    imcs = iTbs;
29698 #endif
29699
29700
29701    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbSz, \
29702          iTbs, imcs, tbInfo, ue->ue5gtfCb.rank);
29703    *numRb = (U8) tempNumRb;
29704    
29705    /* Update the subframe Allocated BW field */
29706    subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
29707    
29708    RETVALUE(ROK);
29709 }
29710
29711 \f
29712 /**
29713  * @brief This function is invoked in the event of any TB's allocation
29714  *  being underutilized by the specific scheduler. Here we reduce iMcs
29715  *  to increase redundancy and hence increase reception quality at UE.
29716  *
29717  * @details
29718  *
29719  *     Function: rgSCHCmnRdcImcsTxTb
29720  *     Purpose:  This function shall reduce the iMcs in accordance with
29721  *               the total consumed bytes by the UE at allocation
29722  *               finalization.
29723  *
29724  *     Invoked by: UE DL Allocation finalization routine
29725  *                 of specific scheduler.
29726  *
29727  *  @param[in]  RgSchDlRbAlloc   *allocInfo
29728  *  @param[in]  U8               tbInfoIdx
29729  *  @param[in]  U32              cnsmdBytes
29730  *  @return  Void
29731  *
29732  **/
29733 #ifdef ANSI
29734 PUBLIC Void rgSCHCmnRdcImcsTxTb
29735 (
29736 RgSchDlRbAlloc   *allocInfo,
29737 U8               tbInfoIdx,
29738 U32              cnsmdBytes
29739 )
29740 #else
29741 PUBLIC Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
29742 RgSchDlRbAlloc   *allocInfo;
29743 U8               tbInfoIdx;
29744 U32              cnsmdBytes;
29745 #endif
29746 {
29747    RETVOID;
29748    /*The below functionality is not needed.*/
29749    U8                 noLyr;
29750    U8                 iTbs;
29751    U16                numRb;
29752
29753    TRC2(rgSCHCmnRdcImcsTxTb);
29754
29755    iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
29756    noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
29757    numRb = allocInfo->rbsAlloc;
29758    if ( numRb > 0)
29759    {
29760       if ((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) == cnsmdBytes)
29761       {
29762          RETVOID;
29763       }
29764    }
29765    /* Get iTbs as suitable for the consumed bytes */
29766    while((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) > cnsmdBytes)
29767    {
29768       if (iTbs == 0)
29769       {
29770          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].\
29771                tbCb->dlGrnt.iMcs);
29772          RETVOID;
29773       }
29774       iTbs--;
29775    }
29776    iTbs++;
29777    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].tbCb->dlGrnt.iMcs);
29778
29779    RETVOID;
29780 }
29781
29782 \f
29783 /**
29784  * @brief This function determines the RBs and Bytes required for
29785  *        Transmission on 2 CWs.
29786  *
29787  * @details
29788  *
29789  *     Function: rgSCHCmnDlAlloc2CwTxRb
29790  *     Purpose:  This function determines the RBs and Bytes required
29791  *               for Transmission of DL SVC BO on 2 CWs.
29792  *               Also, takes care of SVC by SVC allocation by tracking
29793  *               previous SVCs allocations.
29794  *               Returns RFAILED if BO not satisfied at all.
29795  *
29796  *     Invoked by: TM3 and TM4 DL UE Allocation
29797  *
29798  *  @param[in]  RgSchCellCb      *cell
29799  *  @param[in]  RgSchDlSf        *subFrm
29800  *  @param[in]  RgSchUeCb        *ue
29801  *  @param[in]  RgSchDlHqProcCb  *proc
29802  *  @param[in]  RgSchDlHqProcCb  bo
29803  *  @param[out] U8               *numRb
29804  *  @param[out] U32              *effBo
29805  *  @return  Void
29806  *
29807  **/
29808 #ifdef ANSI
29809 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb
29810 (
29811 RgSchCellCb                *cell,
29812 RgSchDlSf                  *subFrm,
29813 RgSchUeCb                  *ue,
29814 RgSchDlHqProcCb            *proc,
29815 U32                        bo,
29816 U8                         *numRbRef,
29817 U32                        *effBo
29818 )
29819 #else
29820 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
29821 RgSchCellCb                *cell;
29822 RgSchDlSf                  *subFrm;
29823 RgSchUeCb                  *ue;
29824 RgSchDlHqProcCb            *proc;
29825 U32                        bo;
29826 U8                         *numRbRef;
29827 U32                        *effBo;
29828 #endif
29829 {
29830    U32                noRes;
29831    U32                eff1, eff2;
29832    U32                tb1Sz, tb2Sz;
29833    U8                 imcs1, imcs2;
29834    U8                 noLyr1, noLyr2;
29835    U8                 iTbs1, iTbs2;
29836    RgSchCmnDlCell     *cellDl;
29837    RgSchCmnDlUe       *ueDl;
29838    RgSchDlRbAlloc     *allocInfo;
29839    U32                oldReq;
29840    U32                reqBytes;
29841    /* Fix: MUE_PERTTI_DL */
29842    U32                numRb;
29843    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
29844    U8                 cfi = cellSch->dl.currCfi;
29845    S16                availBw; 
29846    U32                availBits = 0;
29847 #ifdef LTE_ADV
29848    U32                boTmp = bo;
29849 #endif
29850
29851    TRC2(rgSCHCmnDlAlloc2CwTxRb);
29852
29853    reqBytes  = bo;
29854    cellDl    = RG_SCH_CMN_GET_DL_CELL(cell);
29855    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29856    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29857    oldReq    = ueDl->outStndAlloc;
29858
29859    
29860    if (ueDl->maxTbBits > ue->dl.aggTbBits)
29861    {
29862       availBits = ueDl->maxTbBits - ue->dl.aggTbBits;
29863    }
29864    /* check if we can further allocate to this UE */
29865    if ((ue->dl.aggTbBits >= ueDl->maxTbBits) ||
29866          (allocInfo->tbInfo[0].bytesReq >= ueDl->maxTbSz/8) ||
29867          (allocInfo->tbInfo[1].bytesReq >= ueDl->maxTbSz/8) ||
29868          (allocInfo->rbsReq >= ueDl->maxRb))
29869    {
29870       RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
29871             "rgSCHCmnDlAllocRb(): UEs max allocation exceed");
29872       RETVALUE(RFAILED);
29873    }
29874
29875    noLyr1 = ueDl->mimoInfo.cwInfo[0].noLyr;
29876    noLyr2 = ueDl->mimoInfo.cwInfo[1].noLyr;
29877
29878    /* If there is no CFI change, continue to use the BLER based
29879     * iTBS value */
29880    if (ueDl->lastCfi == cfi)
29881    {   
29882       iTbs1  = ueDl->mimoInfo.cwInfo[0].iTbs[noLyr1 - 1];
29883       iTbs2  = ueDl->mimoInfo.cwInfo[1].iTbs[noLyr2 - 1];
29884    }
29885    else
29886    {  
29887       U8 cqi = ueDl->mimoInfo.cwInfo[0].cqi;
29888 #ifdef LTE_TDD      
29889       iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
29890 #else      
29891       iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
29892 #endif         
29893
29894       cqi = ueDl->mimoInfo.cwInfo[1].cqi;
29895 #ifdef LTE_TDD      
29896       iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
29897 #else      
29898       iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
29899 #endif         
29900    } 
29901
29902    /*ccpu00131191 and ccpu00131317 - Fix for RRC Reconfig failure
29903     * issue for VoLTE call */
29904    //if ((proc->hasDcch)  || (TRUE == rgSCHLaaSCellEnabled(cell)))
29905    if (proc->hasDcch)
29906    {
29907       if (iTbs1 > 5)
29908       {
29909          iTbs1  = iTbs1 - 5;
29910       }
29911       else
29912       {
29913          iTbs1  = 0; 
29914       }
29915       if (iTbs2 > 5)
29916       {
29917          iTbs2  = iTbs2 - 5;
29918       }
29919       else
29920       {
29921          iTbs2  = 0; 
29922       }
29923    }
29924    else if(!cellSch->dl.isDlFreqSel)
29925    {
29926 #ifdef LTE_TDD
29927       /* for Tdd reduce iTbs only for SF0. SF5 contains only 
29928        * SSS and can be ignored */
29929       if (subFrm->sfNum == 0)
29930       {
29931          (iTbs1 > 1)? (iTbs1 -= 1) : (iTbs1 = 0);
29932          (iTbs2 > 1)? (iTbs2 -= 1) : (iTbs2 = 0);
29933       }
29934       /* For SF 3 and 8 CRC is getting failed in DL.
29935          Need to do proper fix after the replay from 
29936          BRCM PHY team*/
29937 #ifdef CA_PHY_BRDCM_61765      
29938       if ((subFrm->sfNum == 3) || (subFrm->sfNum == 8))
29939       {
29940          (iTbs1 > 2)? (iTbs1 -= 2) : (iTbs1 = 0);
29941          (iTbs2 > 2)? (iTbs2 -= 2) : (iTbs2 = 0);
29942       }
29943 #endif
29944 #else
29945 #endif
29946    }
29947
29948 #ifdef LTE_TDD
29949    if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
29950    {
29951       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
29952    }
29953 #endif 
29954
29955    eff1 = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[noLyr1 - 1][cfi]))[iTbs1];
29956    eff2 = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[noLyr2 - 1][cfi]))[iTbs2];
29957
29958
29959    bo = RGSCH_MIN(bo,availBits/8);
29960    ueDl->outStndAlloc += bo;
29961    /* consider Cumulative amount of this BO and bytes so far allocated */
29962    bo = RGSCH_MIN(ueDl->outStndAlloc, ueDl->maxTbBits/8);
29963    bo = RGSCH_MIN(RGSCH_MAX(RGSCH_CMN_MIN_GRNT_HDR, (bo*eff1)/(eff1+eff2)), 
29964                   ueDl->maxTbSz/8) +
29965         RGSCH_MIN(RGSCH_MAX(RGSCH_CMN_MIN_GRNT_HDR, (bo*eff2)/(eff1+eff2)), 
29966                   (ueDl->maxTbSz)/8) +
29967         1; /* Add 1 to adjust the truncation at weighted averaging */
29968    /* Get the number of REs needed for this bo. */
29969    noRes = ((bo * 8 * 1024) / (eff1 + eff2));
29970
29971    /* Get the number of RBs needed for this transmission */
29972    /* Number of RBs = No of REs / No of REs per RB       */
29973    numRb = RGSCH_CEIL(noRes, cellDl->noResPerRb[cfi]);
29974    /* Cannot exceed the maximum number of RBs per UE */
29975    if (numRb > ueDl->maxRb)
29976    {
29977       numRb = ueDl->maxRb;
29978    }
29979    else
29980    {
29981 #ifdef LTE_ADV
29982       if(RFAILED == rgSCHLaaCmn2CwAdjustPrb(allocInfo,  boTmp, &numRb, ueDl, noLyr1, noLyr2, iTbs1, iTbs2))
29983 #endif
29984       {
29985          while ((numRb <= ueDl->maxRb) &&
29986                (rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1] <= ueDl->maxTbSz) &&
29987                (rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1] <= ueDl->maxTbSz) &&
29988                ((rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1]/8 +
29989                  rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1]/8) <= bo))
29990          {
29991             (numRb)++;
29992          }
29993       }
29994    }
29995    availBw = subFrm->bw - subFrm->bwAssigned;
29996    /* Cannot exceed the total number of RBs in the cell */
29997    if ((S16)(numRb - allocInfo->rbsReq) > availBw)
29998    {
29999       numRb = availBw + allocInfo->rbsReq;
30000    }
30001    tb1Sz = rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1]/8;
30002    tb2Sz = rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1]/8;
30003    /* DwPts Scheduling Changes Start */
30004 #ifdef LTE_TDD
30005    if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
30006    { 
30007       /* Max Rb for Special Sf is approximated as 4/3 of maxRb */
30008       rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (U8*)&numRb,  ueDl->maxRb*4/3, 
30009                                 &iTbs1, &iTbs2, noLyr1, 
30010                                 noLyr2, &tb1Sz, &tb2Sz, cfi);   
30011       /* Check for available Bw */
30012       if ((S16)numRb - allocInfo->rbsReq > availBw)
30013       {
30014          numRb = availBw + allocInfo->rbsReq;
30015          tb1Sz = rgTbSzTbl[noLyr1-1][iTbs1][RGSCH_MAX(numRb*3/4,1)-1]/8;
30016          tb2Sz = rgTbSzTbl[noLyr2-1][iTbs2][RGSCH_MAX(numRb*3/4,1)-1]/8;
30017       }
30018    }
30019 #endif
30020    /* DwPts Scheduling Changes End */
30021    /* Update the subframe Allocated BW field */
30022    subFrm->bwAssigned = subFrm->bwAssigned + numRb - \
30023                         allocInfo->rbsReq;
30024
30025    *effBo = RGSCH_MIN((tb1Sz + tb2Sz) - oldReq, reqBytes);
30026
30027 #ifdef LTE_ADV
30028    if (ROK != rgSCHLaaCmn2TBPrbCheck(allocInfo, tb1Sz, tb2Sz, boTmp, effBo, iTbs1, iTbs2, numRb, proc))
30029    {
30030       RETVALUE(RFAILED);
30031    }
30032 #endif
30033
30034    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs1, imcs1);
30035    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs2, imcs2);
30036    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tb1Sz, \
30037          iTbs1, imcs1, &proc->tbInfo[0], noLyr1);
30038    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
30039          iTbs2, imcs2, &proc->tbInfo[1], noLyr2);
30040    *numRbRef = (U8)numRb;
30041
30042
30043    RETVALUE(ROK);
30044 }
30045
30046 \f
30047 /**
30048  * @brief This function determines the RBs and Bytes required for
30049  *        Transmission & Retransmission on 2 CWs.
30050  *
30051  * @details
30052  *
30053  *     Function: rgSCHCmnDlAlloc2CwTxRetxRb
30054  *     Purpose:  This function determines the RBs and Bytes required
30055  *               for Transmission & Retransmission on 2 CWs. Allocate
30056  *               RETX TB on a better CW and restrict new TX TB by
30057  *               RETX allocation.
30058  *               Returns RFAILED if BO not satisfied at all.
30059  *
30060  *     Invoked by: TM3 and TM4 DL UE Allocation
30061  *
30062  *  @param[in]  RgSchCellCb      *cell
30063  *  @param[in]  RgSchDlSf        *subFrm
30064  *  @param[in]  RgSchUeCb        *ue
30065  *  @param[in]  RgSchDlHqTbCb    *reTxTb
30066  *  @param[in]  RgSchDlHqTbCb    *txTb
30067  *  @param[out] U8               *numRb
30068  *  @param[out] U32              *effBo
30069  *  @return  Void
30070  *
30071  **/
30072 #ifdef ANSI
30073 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb
30074 (
30075 RgSchCellCb                *cell,
30076 RgSchDlSf                  *subFrm,
30077 RgSchUeCb                  *ue,
30078 RgSchDlHqTbCb              *reTxTb,
30079 RgSchDlHqTbCb              *txTb,
30080 U8                         *numRb,
30081 U32                        *effBo
30082 )
30083 #else
30084 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
30085         effBo)
30086 RgSchCellCb                *cell;
30087 RgSchDlSf                  *subFrm;
30088 RgSchUeCb                  *ue;
30089 RgSchDlHqTbCb              *reTxTb;
30090 RgSchDlHqTbCb              *txTb;
30091 U8                         *numRb;
30092 U32                        *effBo;
30093 #endif
30094 {
30095    RgSchCmnDlUe       *ueDl;
30096    RgSchDlRbAlloc     *allocInfo;
30097    U8                 imcs1, imcs2;
30098    U8                  noLyr2;
30099    U16                 tb2Sz;
30100    RgSchCmnDlUeCwInfo *otherCw;
30101    S16                 availBw;
30102    RgSchCmnDlCell     *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
30103    U8                 cfi = cellDl->currCfi; 
30104    U8                 iTbs;
30105
30106    TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
30107
30108    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
30109    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30110    otherCw   = &ueDl->mimoInfo.cwInfo[!(ueDl->mimoInfo.btrCwIdx)];
30111
30112
30113    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30114     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30115     * MCS.  */
30116    availBw = subFrm->bw - subFrm->bwAssigned; 
30117    *numRb = reTxTb->dlGrnt.numRb;
30118
30119 #ifdef XEON_TDD_SPCL
30120    *numRb = (reTxTb->initTxNumRbs);
30121    if(reTxTb->sfType == RG_SCH_SPL_SF_DATA && subFrm->sfType != RG_SCH_SPL_SF_DATA)
30122    {
30123       *numRb = (reTxTb->initTxNumRbs*3/4);
30124
30125       if(*numRb <= 3)
30126       {
30127          RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
30128          RETVALUE(RFAILED);
30129       }
30130    }
30131 #endif
30132
30133    if ((S16)*numRb > availBw)
30134    {
30135       RETVALUE(RFAILED);
30136    }
30137    /* Update the subframe Allocated BW field */
30138    subFrm->bwAssigned += *numRb;
30139    noLyr2 = otherCw->noLyr;
30140    RG_SCH_CMN_GET_MCS_FOR_RETX(reTxTb, imcs1);
30141
30142    /* If there is no CFI change, continue to use the BLER based
30143     * iTBS value */
30144    if (ueDl->lastCfi == cfi)
30145    {   
30146       iTbs = otherCw->iTbs[noLyr2-1];
30147    }
30148    else
30149    {  
30150 #ifdef LTE_TDD      
30151       iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi, 
30152                                       !(ueDl->mimoInfo.btrCwIdx), noLyr2);
30153 #else      
30154       iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi, 
30155                                       !(ueDl->mimoInfo.btrCwIdx), noLyr2);
30156 #endif 
30157    } 
30158    tb2Sz = rgTbSzTbl[noLyr2-1][iTbs][*numRb-1]/8;
30159    /* DwPts Scheduling Changes Start */
30160 #ifdef LTE_TDD
30161 #endif
30162    /* DwPts Scheduling Changes End */
30163    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs2);
30164    
30165    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], reTxTb->tbSz, \
30166                               0, imcs1, reTxTb, reTxTb->numLyrs);
30167    
30168    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
30169                               iTbs, imcs2, txTb, noLyr2);
30170    
30171    *effBo = reTxTb->tbSz + tb2Sz;
30172
30173    RETVALUE(ROK);
30174 }
30175
30176 \f
30177 /**
30178  * @brief This function determines the RBs and Bytes required for BO
30179  *        Retransmission on 2 CWs.
30180  *
30181  * @details
30182  *
30183  *     Function: rgSCHCmnDlAlloc2CwRetxRb
30184  *     Purpose:  This function determines the RBs and Bytes required
30185  *               for BO Retransmission on 2 CWs. Allocate larger TB
30186  *               on a better CW and check if the smaller TB can be
30187  *               accomodated on the other CW.
30188  *               Returns RFAILED if BO not satisfied at all.
30189  *
30190  *     Invoked by: Common Scheduler
30191  *
30192  *  @param[in]  RgSchCellCb      *cell
30193  *  @param[in]  RgSchDlSf        *subFrm
30194  *  @param[in]  RgSchUeCb        *ue
30195  *  @param[in]  RgSchDlHqProcCb  *proc
30196  *  @param[out] U8               *numRb
30197  *  @param[out] Bool             *swpFlg
30198  *  @param[out] U32              *effBo
30199  *  @return  Void
30200  *
30201  **/
30202 #ifdef ANSI
30203 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb
30204 (
30205 RgSchCellCb                *cell,
30206 RgSchDlSf                  *subFrm,
30207 RgSchUeCb                  *ue,
30208 RgSchDlHqProcCb            *proc,
30209 U8                         *numRb,
30210 Bool                       *swpFlg,
30211 U32                        *effBo
30212 )
30213 #else
30214 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
30215         numRb, swpFlg, effBo)
30216 RgSchCellCb                *cell;
30217 RgSchDlSf                  *subFrm;
30218 RgSchUeCb                  *ue;
30219 RgSchDlHqProcCb            *proc;
30220 U8                         *numRb;
30221 Bool                       *swpFlg;
30222 U32                        *effBo;
30223 #endif
30224 {
30225    RgSchDlRbAlloc     *allocInfo;
30226    U8                 imcs1;
30227    U8                 imcs2;
30228    RgSchDlHqTbCb      *lrgTbInfo, *othrTbInfo;
30229
30230    TRC2(rgSCHCmnDlAlloc2CwRetxRb);
30231
30232    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30233
30234
30235    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30236     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30237     * MCS.  */
30238    lrgTbInfo  = &proc->tbInfo[0];
30239    othrTbInfo = &proc->tbInfo[1];
30240    *numRb = lrgTbInfo->dlGrnt.numRb;
30241 #ifdef XEON_TDD_SPCL
30242    if((lrgTbInfo->sfType == RG_SCH_SPL_SF_DATA || othrTbInfo->sfType == RG_SCH_SPL_SF_DATA))
30243    {
30244       if(lrgTbInfo->sfType == RG_SCH_SPL_SF_DATA)
30245       {       
30246           *numRb = (lrgTbInfo->initTxNumRbs);
30247       }
30248       else
30249       {
30250           *numRb = (othrTbInfo->initTxNumRbs);
30251       }
30252
30253       if(subFrm->sfType != RG_SCH_SPL_SF_DATA)
30254       {
30255          *numRb = (*numRb)*3/4;
30256       }
30257        
30258       if(*numRb <= 3)
30259       {
30260          RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
30261          RETVALUE(RFAILED);
30262       }
30263    }
30264 #endif
30265    if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
30266    {
30267       RETVALUE(RFAILED);
30268    }
30269    /* Update the subframe Allocated BW field */
30270    subFrm->bwAssigned += *numRb;
30271    RG_SCH_CMN_GET_MCS_FOR_RETX(lrgTbInfo, imcs1);
30272    RG_SCH_CMN_GET_MCS_FOR_RETX(othrTbInfo, imcs2);
30273    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], lrgTbInfo->tbSz, \
30274          0, imcs1, lrgTbInfo, lrgTbInfo->numLyrs);
30275    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], othrTbInfo->tbSz, \
30276          0, imcs2, othrTbInfo, othrTbInfo->numLyrs);
30277    *effBo = lrgTbInfo->tbSz + othrTbInfo->tbSz;
30278
30279
30280
30281    RETVALUE(ROK);
30282 }
30283
30284 \f
30285 /**
30286  * @brief This function determines the RBs and Bytes required for BO
30287  *        Retransmission on 1 CW.
30288  *
30289  * @details
30290  *
30291  *     Function: rgSCHCmnDlAlloc1CwRetxRb
30292  *     Purpose:  This function determines the RBs and Bytes required
30293  *               for BO Retransmission on 1 CW, the first CW.
30294  *               Returns RFAILED if BO not satisfied at all.
30295  *
30296  *     Invoked by: Common Scheduler
30297  *
30298  *  @param[in]  RgSchCellCb      *cell
30299  *  @param[in]  RgSchDlSf        *subFrm
30300  *  @param[in]  RgSchUeCb        *ue
30301  *  @param[in]  RgSchDlHqTbCb    *tbInfo
30302  *  @param[in]  U8               noLyr
30303  *  @param[out] U8               *numRb
30304  *  @param[out] U32              *effBo
30305  *  @return  S16
30306  *
30307  **/
30308 #ifdef ANSI
30309 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb
30310 (
30311 RgSchCellCb                *cell,
30312 RgSchDlSf                  *subFrm,
30313 RgSchUeCb                  *ue,
30314 RgSchDlHqTbCb              *tbInfo,
30315 U8                         noLyr,
30316 U8                         *numRb,
30317 U32                        *effBo
30318 )
30319 #else
30320 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
30321         numRb, effBo)
30322 RgSchCellCb                *cell;
30323 RgSchDlSf                  *subFrm;
30324 RgSchUeCb                  *ue;
30325 RgSchDlHqTbCb              *tbInfo;
30326 U8                         noLyr;
30327 U8                         *numRb;
30328 U32                        *effBo;
30329 #endif
30330 {
30331    RgSchDlRbAlloc  *allocInfo;
30332    U8              imcs;
30333
30334    TRC2(rgSCHCmnDlAlloc1CwRetxRb);
30335
30336    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30337
30338
30339    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30340     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30341     * MCS.  */
30342    *numRb = tbInfo->dlGrnt.numRb;
30343    if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
30344    {
30345       RETVALUE(RFAILED);
30346    }
30347    /* Update the subframe Allocated BW field */
30348    subFrm->bwAssigned += *numRb;
30349    imcs = tbInfo->dlGrnt.iMcs;
30350    allocInfo->dciFormat = tbInfo->dlGrnt.dciFormat; 
30351    /* Fix: For a RETX TB the iTbs is irrelevant, hence setting 0 */
30352    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbInfo->tbSz, \
30353          0, imcs, tbInfo, tbInfo->numLyrs);
30354    *effBo = tbInfo->tbSz;
30355
30356    RETVALUE(ROK);
30357 }
30358
30359 #ifdef LTEMAC_SPS
30360
30361 /**
30362  * @brief This function is called to handle Release PDCCH feedback for SPS UE
30363  *
30364  * @details
30365  *
30366  *     Function: rgSCHCmnDlRelPdcchFbk
30367  *     Purpose:  Invokes SPS module to handle release PDCCH feedback
30368  *
30369  *     Invoked by: DHM
30370  *
30371  *  @param[in]   RgSchCellCb     *cell
30372  *  @param[in]   RgSchUeCb       *ue
30373  *  @param[in]   Bool            isAck
30374  *  @return  Void
30375  *
30376  **/
30377 #ifdef ANSI
30378 PUBLIC Void rgSCHCmnDlRelPdcchFbk
30379 (
30380 RgSchCellCb        *cell,
30381 RgSchUeCb          *ue,
30382 Bool               isAck
30383 )
30384 #else
30385 PUBLIC Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
30386 RgSchCellCb        *cell;
30387 RgSchUeCb          *ue;
30388 Bool               isAck;
30389 #endif
30390 {
30391
30392    TRC2(rgSCHCmnDlRelPdcchFbk);
30393    rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
30394    RETVOID;
30395
30396 }
30397
30398
30399 /**
30400  * @brief This function is invoked to handle Ack processing for a HARQ proc.
30401  *
30402  * @details
30403  *
30404  *     Function: rgSCHCmnDlProcAck
30405  *     Purpose:  DTX processing for HARQ proc
30406  *
30407  *     Invoked by: DHM
30408  *
30409  *  @param[in]   RgSchCellCb     *cell
30410  *  @param[in]   RgSchDlHqProcCb *hqP
30411  *  @return  Void
30412  *
30413  **/
30414 #ifdef ANSI
30415 PUBLIC Void rgSCHCmnDlProcAck
30416 (
30417 RgSchCellCb        *cell,
30418 RgSchDlHqProcCb    *hqP
30419 )
30420 #else
30421 PUBLIC Void rgSCHCmnDlProcAck(cell, hqP)
30422 RgSchCellCb        *cell;
30423 RgSchDlHqProcCb    *hqP;
30424 #endif
30425 {
30426
30427    TRC2(rgSCHCmnDlProcAck);
30428
30429    if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
30430    {
30431       /* Invoke SPS module if SPS service was scheduled for this HARQ proc */
30432       rgSCHCmnSpsDlProcAck(cell, hqP);
30433    }
30434    RETVOID;
30435 }
30436 #ifdef RGSCH_SPS_STATS
30437 extern U32 rgSchStatCrntiCeRcvCnt;
30438 #endif
30439 /**
30440  * @brief This function is invoked to handle CRNTI CE reception for an UE
30441  *
30442  * @details
30443  *
30444  *     Function: rgSCHCmnHdlCrntiCE
30445  *     Purpose:  Handle CRNTI CE reception
30446  *
30447  *     Invoked by: DHM
30448  *
30449  *  @param[in]   RgSchCellCb     *cell
30450  *  @param[in]   RgSchDlHqProcCb *hqP
30451  *  @return  Void
30452  *
30453  **/
30454 #ifdef ANSI
30455 PUBLIC Void rgSCHCmnHdlCrntiCE
30456 (
30457 RgSchCellCb        *cell,
30458 RgSchUeCb          *ue
30459 )
30460 #else
30461 PUBLIC Void rgSCHCmnHdlCrntiCE(cell, ue)
30462 RgSchCellCb        *cell;
30463 RgSchUeCb          *ue;
30464 #endif
30465 {
30466
30467    TRC2(rgSCHCmnHdlCrntiCE);
30468 #ifdef RGSCH_SPS_STATS   
30469    rgSchStatCrntiCeRcvCnt++;
30470 #endif
30471
30472    /* When UL sync lost happened due to TA timer expiry UE is being moved to 
30473       PDCCH order inactivity list.But when CRNTI CE received in msg3 from UE
30474       we are not moving UE into active state due to that RRC Reconfiguration is
30475       not happening.
30476       So here we are moving UE to active list whenever we receive the CRNTI CE and
30477       UE is inactive */
30478    /* CR ccpu00144525 */      
30479    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
30480    {
30481        /* Activate this UE if it was inactive */
30482        RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
30483        RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
30484    }
30485
30486    /* Handling is same as reception of UE RESET for both DL and UL */
30487    if (ue->dl.dlSpsCfg.isDlSpsEnabled)
30488    {
30489       rgSCHCmnSpsDlUeReset(cell, ue);
30490    }
30491    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30492    {
30493       rgSCHCmnSpsUlUeReset(cell, ue);
30494    }
30495    
30496    RETVOID;
30497 }
30498
30499
30500 /**
30501  * @brief This function is called to handle relInd from MAC for a UE
30502  *
30503  * @details
30504  *
30505  *     Function: rgSCHCmnUlSpsRelInd
30506  *     Purpose:  Invokes SPS module to handle UL SPS release for a UE
30507  *
30508  *     Invoked by: SCH_UTL
30509  *
30510  *  @param[in]   RgSchCellCb        *cell
30511  *  @param[in]   RgSchUeCb          *ue
30512  *  @param[in]   Bool               isExplRel
30513  *  @return  Void
30514  *
30515  **/
30516 #ifdef ANSI
30517 PUBLIC Void rgSCHCmnUlSpsRelInd
30518 (
30519 RgSchCellCb        *cell,
30520 RgSchUeCb          *ue,
30521 Bool               isExplRel
30522 )
30523 #else
30524 PUBLIC Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
30525 RgSchCellCb        *cell;
30526 RgSchUeCb          *ue;
30527 Bool               isExplRel;
30528 #endif
30529 {
30530
30531    TRC2(rgSCHCmnUlSpsRelInd);
30532    rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
30533    RETVOID;
30534
30535 } /* end of rgSCHCmnUlSpsRelInd */
30536
30537 /**
30538  * @brief This function is called to handle SPS Activate Ind from MAC for a UE
30539  *
30540  * @details
30541  *
30542  *     Function: rgSCHCmnUlSpsActInd
30543  *     Purpose:  Invokes SPS module to handle UL SPS activate for a UE
30544  *
30545  *     Invoked by: SCH_UTL
30546  *
30547  *  @param[in]   RgSchCellCb        *cell
30548  *  @param[in]   RgSchUeCb          *ue
30549  *  @return  Void
30550  *
30551  **/
30552 #ifdef ANSI
30553 PUBLIC Void rgSCHCmnUlSpsActInd
30554 (
30555 RgSchCellCb        *cell,
30556 RgSchUeCb          *ue,
30557 U16                spsSduSize
30558 )
30559 #else
30560 PUBLIC Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
30561 RgSchCellCb        *cell;
30562 RgSchUeCb          *ue;
30563 U16                spsSduSize;
30564 #endif
30565 {
30566
30567    TRC2(rgSCHCmnUlSpsActInd);
30568
30569    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30570    {
30571       rgSCHCmnSpsUlProcActInd(cell, ue,spsSduSize);
30572    }
30573    RETVOID;
30574
30575 } /* end of rgSCHCmnUlSpsActInd */
30576
30577 /**
30578  * @brief This function is called to handle CRC in UL for UEs
30579  * undergoing SPS release
30580  *
30581  * @details
30582  *
30583  *     Function: rgSCHCmnUlCrcInd
30584  *     Purpose:  Invokes SPS module to handle CRC in UL for SPS UE
30585  *
30586  *     Invoked by: SCH_UTL
30587  *
30588  *  @param[in]   RgSchCellCb        *cell
30589  *  @param[in]   RgSchUeCb          *ue
30590  *  @param[in]   CmLteTimingInfo    crcTime
30591  *  @return  Void
30592  *
30593  **/
30594 #ifdef ANSI
30595 PUBLIC Void rgSCHCmnUlCrcInd
30596 (
30597 RgSchCellCb        *cell,
30598 RgSchUeCb          *ue,
30599 CmLteTimingInfo    crcTime
30600 )
30601 #else
30602 PUBLIC Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
30603 RgSchCellCb        *cell;
30604 RgSchUeCb          *ue;
30605 CmLteTimingInfo    crcTime;
30606 #endif
30607 {
30608
30609    TRC2(rgSCHCmnUlCrcInd);
30610    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30611    {
30612       rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
30613    }
30614    RETVOID;
30615
30616 } /* end of rgSCHCmnUlCrcFailInd */
30617
30618 /**
30619  * @brief This function is called to handle CRC failure in UL
30620  *
30621  * @details
30622  *
30623  *     Function: rgSCHCmnUlCrcFailInd
30624  *     Purpose:  Invokes SPS module to handle CRC failure in UL for SPS UE
30625  *
30626  *     Invoked by: SCH_UTL
30627  *
30628  *  @param[in]   RgSchCellCb        *cell
30629  *  @param[in]   RgSchUeCb          *ue
30630  *  @param[in]   CmLteTimingInfo    crcTime
30631  *  @return  Void
30632  *
30633  **/
30634 #ifdef ANSI
30635 PUBLIC Void rgSCHCmnUlCrcFailInd
30636 (
30637 RgSchCellCb        *cell,
30638 RgSchUeCb          *ue,
30639 CmLteTimingInfo    crcTime
30640 )
30641 #else
30642 PUBLIC Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
30643 RgSchCellCb        *cell;
30644 RgSchUeCb          *ue;
30645 CmLteTimingInfo    crcTime;
30646 #endif
30647 {
30648
30649    TRC2(rgSCHCmnUlCrcFailInd);
30650    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30651    {
30652       rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
30653    }
30654    RETVOID;
30655
30656 } /* end of rgSCHCmnUlCrcFailInd */
30657
30658 #endif /* LTEMAC_SPS */
30659
30660 /**
30661  * @brief BCH,BCCH,PCCH Dowlink Scheduling Handler.
30662  *
30663  * @details
30664  *
30665  *     Function: rgSCHCmnDlBcchPcchAlloc
30666  *     Purpose:  This function calls common scheduler APIs to
30667  *     schedule for BCCH/PCCH.
30668  *     It then invokes Allocator for actual RB
30669  *     allocations. It processes on the actual resources allocated
30670  *     against requested to the allocator module.
30671  *
30672  *     Invoked by: Common Scheduler
30673  *
30674  *  @param[in]  RgSchCellCb *cell
30675  *  @return  Void
30676  **/
30677 #ifdef ANSI
30678 PRIVATE Void rgSCHCmnDlBcchPcchAlloc
30679 (
30680 RgSchCellCb  *cell
30681 )
30682 #else
30683 PRIVATE Void rgSCHCmnDlBcchPcchAlloc(cell)
30684 RgSchCellCb  *cell;
30685 #endif
30686 {
30687 #ifdef LTE_TDD
30688    U8           nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
30689 #else
30690 #ifdef LTEMAC_HDFDD
30691    U8           nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
30692 #else
30693    U8           nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
30694 #endif
30695 #endif
30696    RgInfSfAlloc *nextsfAlloc = &(cell->sfAllocArr[nextSfIdx]);
30697    RgSchCmnCell           *cellSch   = RG_SCH_CMN_GET_CELL(cell);
30698    RgSchCmnDlRbAllocInfo  *allocInfo = &cellSch->allocInfo;  
30699    
30700    TRC2(rgSCHCmnDlBcchPcchAlloc);
30701
30702
30703    /*Reset the bitmask for BCCH/PCCH*/
30704    rgSCHUtlResetSfAlloc(nextsfAlloc,TRUE,FALSE);
30705 #ifndef DISABLE_MIB_SIB /* Not sending MIB and SIB to CL */
30706 #ifdef RGR_SI_SCH
30707    rgSCHChkNUpdSiCfg(cell);
30708    rgSCHSelectSi(cell);
30709 #endif
30710
30711    /*Perform the scheduling for BCCH,PCCH*/
30712    rgSCHCmnDlBcchPcch(cell, allocInfo, nextsfAlloc);
30713
30714    /* Call common allocator for RB Allocation */
30715    rgSCHBcchPcchDlRbAlloc(cell, allocInfo);
30716
30717    /* Finalize the Allocations for reqested Against alloced */
30718    rgSCHCmnDlBcchPcchFnlz(cell, allocInfo);
30719 #endif /* DISABLE_MIB_SIB */
30720    RETVOID;
30721 }
30722
30723 /**
30724  * @brief Handles RB allocation for BCCH/PCCH for downlink.
30725  *
30726  * @details
30727  *
30728  *     Function : rgSCHBcchPcchDlRbAlloc
30729  *
30730  *     Invoking Module Processing:
30731  *     - This function is invoked for DL RB allocation of BCCH/PCCH
30732  *
30733  *     Processing Steps:
30734  *     - If cell is frequency selecive,
30735  *       - Call rgSCHDlfsBcchPcchAllocRb().
30736  *     - else,
30737  *       - Do the processing
30738  *
30739  *  @param[in]  RgSchCellCb        *cell
30740  *  @param[in]  RgSchDlRbAllocInfo *allocInfo
30741  *  @return  Void
30742  **/
30743
30744 #ifdef ANSI
30745 PRIVATE Void rgSCHBcchPcchDlRbAlloc
30746 (
30747 RgSchCellCb           *cell,
30748 RgSchCmnDlRbAllocInfo *allocInfo
30749 )
30750 #else
30751 PRIVATE Void rgSCHBcchPcchDlRbAlloc(cell, allocInfo)
30752 RgSchCellCb           *cell;
30753 RgSchCmnDlRbAllocInfo *allocInfo;
30754 #endif
30755 {
30756    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
30757
30758    TRC2(rgSCHBcchPcchDlRbAlloc);
30759
30760
30761    if (cellSch->dl.isDlFreqSel)
30762    {
30763       cellSch->apisDlfs->rgSCHDlfsBcchPcchAllocRb(cell, allocInfo);
30764    }
30765    else
30766    {
30767       rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo);
30768    }
30769
30770    RETVOID;
30771 }
30772
30773 /**
30774  * @brief Handles RB allocation for BCCH,PCCH for frequency
30775  *  non-selective cell.
30776  *
30777  * @details
30778  *
30779  *     Function : rgSCHCmnNonDlfsBcchPcchRbAlloc
30780  *
30781  *     Invoking Module Processing:
30782  *      - SCH shall invoke this if downlink frequency selective is disabled for
30783  *        the cell for RB allocation.
30784  *      - MAX C/I/PFS/RR shall provide the requiredBytes, required RBs
30785  *        estimate and subframe for each allocation to be made to SCH.
30786  *
30787  *     Processing Steps:
30788  *     - Allocate sequentially for BCCH,PCCH common channels.
30789  *
30790  *  @param[in]  RgSchCellCb        *cell
30791  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
30792  *  @return  Void
30793  **/
30794
30795 #ifdef ANSI
30796 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc
30797 (
30798 RgSchCellCb           *cell,
30799 RgSchCmnDlRbAllocInfo *allocInfo
30800 )
30801 #else
30802 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo)
30803 RgSchCellCb           *cell;
30804 RgSchCmnDlRbAllocInfo *allocInfo;
30805 #endif
30806 {
30807    RgSchDlRbAlloc     *reqAllocInfo;
30808
30809    TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
30810
30811    /* 143473 */
30812    /* Allocate for PCCH */
30813    reqAllocInfo = &(allocInfo->pcchAlloc);
30814    if (reqAllocInfo->rbsReq)
30815    {
30816       rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
30817    }
30818    /* Allocate for BCCH on DLSCH */
30819    reqAllocInfo = &(allocInfo->bcchAlloc);
30820    if (reqAllocInfo->rbsReq)
30821    {
30822       rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
30823    }
30824    RETVOID;
30825 }
30826
30827
30828 #ifdef RGR_SI_SCH
30829 /**
30830  * @brief This function implements the handling to check and
30831  *        update the SI cfg at the start of the modificiation period.
30832  *
30833  * @details
30834  *
30835  *     Function: rgSCHChkNUpdSiCfg
30836  *     Purpose:  This function implements handling for update of SI Cfg
30837  *               at the start of modification period.
30838  *
30839  *     Invoked by: Scheduler
30840  *
30841  *  @param[in]  RgSchCellCb*     cell
30842  *  @return  S16
30843  *      -# ROK
30844  *      -# RFAILED
30845  **/
30846 #ifdef ANSI
30847 PRIVATE Void rgSCHChkNUpdSiCfg
30848 (
30849 RgSchCellCb             *cell
30850 )
30851 #else
30852 PRIVATE Void rgSCHChkNUpdSiCfg(cell)
30853 RgSchCellCb             *cell;
30854 #endif
30855 {
30856    CmLteTimingInfo   pdSchTmInfo;
30857
30858    TRC2(rgSCHChkNUpdSiCfg);
30859
30860
30861    pdSchTmInfo   = cell->crntTime;
30862 #ifdef LTEMAC_HDFDD
30863    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
30864       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
30865    RGSCH_INCR_SUB_FRAME(pdSchTmInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
30866 #else
30867    RGSCH_INCR_SUB_FRAME(pdSchTmInfo, RG_SCH_CMN_DL_DELTA);
30868 #endif
30869
30870
30871    /* Updating the SIB1 for Warning SI message immediately after it is received 
30872     * from application. No need to wait for next modification period.
30873     */
30874    if((pdSchTmInfo.sfn % RGSCH_SIB1_RPT_PERIODICITY == 0)
30875          && (RGSCH_SIB1_TX_SF_NUM == (pdSchTmInfo.subframe % RGSCH_NUM_SUB_FRAMES)))
30876    {   
30877       /*Check whether SIB1 with PWS has been updated*/
30878       if(cell->siCb.siBitMask & RGSCH_SI_SIB1_PWS_UPD)
30879       {
30880          RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.sib1Info.sib1,
30881                cell->siCb.newSiInfo.sib1Info.sib1);
30882          cell->siCb.crntSiInfo.sib1Info.mcs = 
30883             cell->siCb.newSiInfo.sib1Info.mcs;
30884          cell->siCb.crntSiInfo.sib1Info.nPrb = 
30885              cell->siCb.newSiInfo.sib1Info.nPrb;
30886          cell->siCb.crntSiInfo.sib1Info.msgLen = 
30887             cell->siCb.newSiInfo.sib1Info.msgLen;
30888          cell->siCb.siBitMask &= ~RGSCH_SI_SIB1_PWS_UPD;
30889       }
30890    }
30891
30892    /*Check if this SFN and SF No marks the start of next modification
30893      period. If current SFN,SF No doesn't marks the start of next
30894      modification period, then return. */
30895    if(!((pdSchTmInfo.sfn % cell->siCfg.modPrd == 0)
30896             && (0 == pdSchTmInfo.subframe)))
30897    /*if(!((((pdSchTmInfo.hSfn * 1024) + pdSchTmInfo.sfn) % cell->siCfg.modPrd == 0)
30898             && (0 == pdSchTmInfo.subframe)))*/
30899    {
30900       RETVOID;
30901    }
30902
30903    /*Check whether MIB has been updated*/
30904    if(cell->siCb.siBitMask & RGSCH_SI_MIB_UPD)
30905    {
30906       RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.mib,
30907             cell->siCb.newSiInfo.mib);
30908       cell->siCb.siBitMask &= ~RGSCH_SI_MIB_UPD;
30909    }
30910
30911    /*Check whether SIB1 has been updated*/
30912    if(cell->siCb.siBitMask & RGSCH_SI_SIB1_UPD)
30913    {
30914       RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.sib1Info.sib1,
30915             cell->siCb.newSiInfo.sib1Info.sib1);
30916       cell->siCb.crntSiInfo.sib1Info.mcs = cell->siCb.newSiInfo.sib1Info.mcs;
30917       cell->siCb.crntSiInfo.sib1Info.nPrb = cell->siCb.newSiInfo.sib1Info.nPrb;
30918       cell->siCb.crntSiInfo.sib1Info.msgLen = 
30919          cell->siCb.newSiInfo.sib1Info.msgLen;
30920       cell->siCb.siBitMask &= ~RGSCH_SI_SIB1_UPD;
30921    }
30922
30923    /*Check whether SIs have been updated*/
30924    if(cell->siCb.siBitMask & RGSCH_SI_SI_UPD)
30925    {
30926       U8  idx;
30927
30928       /*Check if SI cfg have been modified And Check if numSi have
30929         been changed, if yes then we would need to update the
30930         pointers for all the SIs */
30931       if((cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) &&
30932             (cell->siCfg.numSi != cell->siCb.newSiCfg.numSi))
30933       {
30934          for(idx = 0;idx < cell->siCb.newSiCfg.numSi;idx++)
30935          {
30936             RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[idx].si,
30937                   cell->siCb.newSiInfo.siInfo[idx].si);
30938             cell->siCb.siArray[idx].si = cell->siCb.crntSiInfo.siInfo[idx].si;
30939             cell->siCb.siArray[idx].isWarningSi = FALSE;
30940
30941             cell->siCb.crntSiInfo.siInfo[idx].mcs = cell->siCb.newSiInfo.siInfo[idx].mcs;
30942             cell->siCb.crntSiInfo.siInfo[idx].nPrb = cell->siCb.newSiInfo.siInfo[idx].nPrb;
30943             cell->siCb.crntSiInfo.siInfo[idx].msgLen = cell->siCb.newSiInfo.siInfo[idx].msgLen;
30944          }
30945
30946          /*If numSi have been reduced then we need to free the
30947            pointers at the indexes in crntSiInfo which haven't
30948            been exercised. If numSi has increased then nothing
30949            additional is requires as above handling has taken
30950            care.*/
30951          if(cell->siCfg.numSi > cell->siCb.newSiCfg.numSi)
30952          {
30953             for(idx = cell->siCb.newSiCfg.numSi;
30954                   idx < cell->siCfg.numSi;idx++)
30955             {
30956                RGSCH_FREE_MSG(cell->siCb.crntSiInfo.siInfo[idx].si);
30957                cell->siCb.siArray[idx].si = NULLP;
30958             }
30959          }
30960       }
30961       else
30962       {
30963          /*numSi has not been updated, we just need to update the
30964            pointers for the SIs which are set to NON NULLP */
30965          /*ccpu00118260 - Correct Update of SIB2 */
30966          for(idx = 0;idx < cell->siCfg.numSi;idx++)
30967          {
30968             if(NULLP != cell->siCb.newSiInfo.siInfo[idx].si)
30969             {
30970                RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[idx].si,
30971                      cell->siCb.newSiInfo.siInfo[idx].si);
30972
30973                cell->siCb.siArray[idx].si = cell->siCb.crntSiInfo.siInfo[idx].si;
30974                cell->siCb.siArray[idx].isWarningSi = FALSE;
30975                cell->siCb.crntSiInfo.siInfo[idx].mcs = cell->siCb.newSiInfo.siInfo[idx].mcs;
30976                cell->siCb.crntSiInfo.siInfo[idx].nPrb = cell->siCb.newSiInfo.siInfo[idx].nPrb;
30977                cell->siCb.crntSiInfo.siInfo[idx].msgLen = cell->siCb.newSiInfo.siInfo[idx].msgLen;
30978             }
30979          }
30980       }
30981       cell->siCb.siBitMask &= ~RGSCH_SI_SI_UPD;
30982    }
30983
30984    /*Check whether SI cfg have been updated*/
30985    if(cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
30986    {
30987       cell->siCfg = cell->siCb.newSiCfg;
30988       cell->siCb.siBitMask &= ~RGSCH_SI_SICFG_UPD;
30989    }
30990
30991    RETVOID;
30992 }
30993
30994
30995 /**
30996  * @brief This function implements the selection of the SI
30997  *        that is to be scheduled.
30998  *
30999  * @details
31000  *
31001  *     Function: rgSCHSelectSi
31002  *     Purpose:  This function implements the selection of SI
31003  *               that is to be scheduled.
31004  *
31005  *     Invoked by: Scheduler
31006  *
31007  *  @param[in]  RgSchCellCb*     cell
31008  *  @return  S16
31009  *      -# ROK
31010  *      -# RFAILED
31011  **/
31012 #ifdef ANSI
31013 PRIVATE Void rgSCHSelectSi
31014 (
31015 RgSchCellCb             *cell
31016 )
31017 #else
31018 PRIVATE Void rgSCHSelectSi(cell)
31019 RgSchCellCb             *cell;
31020 #endif
31021 {
31022    CmLteTimingInfo        crntTmInfo;
31023    U8                     siWinSize;
31024    U16                    x; 
31025    U16                    windowId; 
31026
31027    TRC2(rgSCHSelectSi);
31028
31029
31030    crntTmInfo  = cell->crntTime;
31031 #ifdef LTEMAC_HDFDD
31032    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
31033       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
31034    RGSCH_INCR_SUB_FRAME(crntTmInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
31035 #else
31036    RGSCH_INCR_SUB_FRAME(crntTmInfo, RG_SCH_CMN_DL_DELTA);
31037 #endif
31038
31039    siWinSize    = cell->siCfg.siWinSize;
31040
31041    /* Select SI only once at the starting of the new window */
31042    if(cell->siCb.inWindow)
31043    {
31044       if ((crntTmInfo.sfn % cell->siCfg.minPeriodicity) == 0 && 
31045           crntTmInfo.subframe == 0)
31046       {
31047          /* Reinit inWindow at the beginning of every SI window */
31048          cell->siCb.inWindow = siWinSize - 1;
31049       }
31050       else
31051       {
31052          cell->siCb.inWindow--;
31053          RETVOID;
31054       }
31055    }
31056    else /* New window. Re-init the winSize counter with the window length */
31057    {
31058       if((cell->siCb.siArray[cell->siCb.siCtx.siId - 1].isWarningSi == TRUE)&&
31059             (cell->siCb.siCtx.retxCntRem != 0))   
31060       {
31061          rgSCHUtlFreeWarningSiPdu(cell);
31062          cell->siCb.siCtx.warningSiFlag  = FALSE;
31063       }
31064
31065       cell->siCb.inWindow = siWinSize - 1;
31066    }
31067
31068    x = rgSCHCmnGetSiSetId(crntTmInfo.sfn, crntTmInfo.subframe, 
31069                                   cell->siCfg.minPeriodicity); 
31070
31071    /* Window Id within a SI set. This window Id directly maps to a
31072     * unique SI Id */
31073    windowId = (((crntTmInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + 
31074             crntTmInfo.subframe) - (x * (cell->siCfg.minPeriodicity * 10))) 
31075                                                                / siWinSize;
31076
31077    if(windowId >= RGR_MAX_NUM_SI)
31078       RETVOID;
31079
31080    /* Update the siCtx if there is a valid SI and its periodicity
31081     * has occurred */
31082    if (NULLP != cell->siCb.siArray[windowId].si)
31083    {
31084       /* Warning SI Periodicity is same as SIB2 Periodicity */
31085       if(((cell->siCb.siArray[windowId].isWarningSi == FALSE) && 
31086                (x % (cell->siCfg.siPeriodicity[windowId]
31087                      /cell->siCfg.minPeriodicity) == 0)) || 
31088             ((cell->siCb.siArray[windowId].isWarningSi == TRUE) &&
31089              (x % (cell->siCfg.siPeriodicity[0]
31090                    /cell->siCfg.minPeriodicity) == 0)))
31091       {
31092          cell->siCb.siCtx.siId = windowId+1;
31093          cell->siCb.siCtx.retxCntRem = cell->siCfg.retxCnt;
31094          cell->siCb.siCtx.warningSiFlag = cell->siCb.siArray[windowId].
31095                                                            isWarningSi;
31096          cell->siCb.siCtx.timeToTx.sfn = crntTmInfo.sfn;
31097          cell->siCb.siCtx.timeToTx.subframe = crntTmInfo.subframe;
31098
31099          RG_SCH_ADD_TO_CRNT_TIME(cell->siCb.siCtx.timeToTx,
31100                cell->siCb.siCtx.maxTimeToTx, (siWinSize - 1))
31101       }
31102    }
31103    else
31104    {/* Update the siCtx with invalid si Id */
31105       cell->siCb.siCtx.siId = 0;
31106    }
31107
31108    RETVOID;
31109 }
31110
31111
31112 /**
31113  * @brief This function implements scheduler DL allocation for
31114  *        SI.
31115  *
31116  * @details
31117  *
31118  *     Function: rgSCHDlSiSched
31119  *     Purpose:  This function implements scheduler for DL allocation
31120  *               for SI.
31121  *
31122  *     Invoked by: Scheduler
31123  *
31124  *  @param[in]  RgSchCellCb*     cell
31125  *  @return  S16
31126  *      -# ROK
31127  *      -# RFAILED
31128  **/
31129 #ifdef ANSI
31130 PRIVATE Void rgSCHDlSiSched
31131 (
31132 RgSchCellCb             *cell,
31133 RgSchCmnDlRbAllocInfo   *allocInfo,
31134 RgInfSfAlloc            *subfrmAlloc
31135 )
31136 #else
31137 PRIVATE Void rgSCHDlSiSched(cell, allocInfo, subfrmAlloc)
31138 RgSchCellCb             *cell;
31139 RgSchCmnDlRbAllocInfo   *allocInfo;
31140 RgInfSfAlloc            *subfrmAlloc;
31141 #endif
31142 {
31143    CmLteTimingInfo   crntTimInfo;
31144    RgSchDlSf         *sf;
31145    U8                nPrb = 0;
31146    U8                mcs  = 0;
31147    MsgLen            msgLen = 0;
31148    U32               rb=0;
31149    RgSchCmnDlCell    *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
31150    /* DwPTS Scheduling Changes Start */
31151 #ifdef LTE_TDD   
31152    U16                lostRe;  
31153    U8                 cfi = cellDl->currCfi;      
31154 #endif
31155    /* DwPTS Scheduling Changes End */
31156
31157    TRC2(rgSCHDlSiSched);
31158
31159
31160    crntTimInfo   = cell->crntTime;
31161 #ifdef LTEMAC_HDFDD
31162    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
31163       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
31164    RGSCH_INCR_SUB_FRAME(crntTimInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
31165 #else
31166    RGSCH_INCR_SUB_FRAME(crntTimInfo, RG_SCH_CMN_DL_DELTA);
31167 #endif
31168
31169    /* Compute the subframe for which allocation is being made.
31170       Essentially, we need pointer to the dl frame for this subframe */
31171    sf = rgSCHUtlSubFrmGet(cell, crntTimInfo);
31172
31173    /*Check if scheduling of MIB is required */
31174 #ifdef EMTC_ENABLE
31175    /* since we are adding the MIB repetition logic for EMTC UEs, checking if
31176     * emtcEnabled or not,  If enabled MIB would be repeted at as part of EMTC
31177     * feature, otherwise scheduling at (n,0) */
31178    if(0 == cell->emtcEnable)
31179    {
31180 #endif
31181    if((crntTimInfo.sfn % RGSCH_MIB_PERIODICITY == 0)
31182          && (RGSCH_MIB_TX_SF_NUM == crntTimInfo.subframe))
31183    {
31184       MsgLen  mibLen = 0;
31185       U8      sfnOctet, mibOct2 = 0;
31186       U8      mibOct1 = 0;
31187       /*If MIB has not been yet setup by Application, return*/
31188       if(NULLP == cell->siCb.crntSiInfo.mib)
31189          RETVOID;
31190
31191       SFndLenMsg(cell->siCb.crntSiInfo.mib, &mibLen);
31192       sf->bch.tbSize = mibLen;
31193       /*Fill the interface information */
31194       rgSCHUtlFillRgInfCmnLcInfo(sf, subfrmAlloc, NULLD, NULLD);
31195
31196       /*Set the bits of MIB to reflect SFN */
31197       /*First get the Most signficant 8 bits of SFN */
31198       sfnOctet = (U8)(crntTimInfo.sfn >> 2);
31199       /*Get the first two octets of MIB, and then update them
31200         using the SFN octet value obtained above.*/
31201       if(ROK != SExamMsg((Data *)(&mibOct1),
31202                cell->siCb.crntSiInfo.mib, 0))
31203          RETVOID;
31204
31205       if(ROK != SExamMsg((Data *)(&mibOct2),
31206                cell->siCb.crntSiInfo.mib, 1))
31207          RETVOID;
31208
31209       /* ccpu00114572- Fix for improper way of MIB Octet setting for SFN */
31210       mibOct1 = (mibOct1 & 0xFC) | (sfnOctet >> 6);
31211       mibOct2 = (mibOct2 & 0x03) | (sfnOctet << 2);
31212       /* ccpu00114572- Fix ends*/
31213
31214       /*Now, replace the two octets in MIB */
31215       if(ROK != SRepMsg((Data)(mibOct1),
31216                cell->siCb.crntSiInfo.mib, 0))
31217          RETVOID;
31218
31219       if(ROK != SRepMsg((Data)(mibOct2),
31220                cell->siCb.crntSiInfo.mib, 1))
31221          RETVOID;
31222
31223       /*Copy the MIB msg buff into interface buffer */
31224       SCpyMsgMsg(cell->siCb.crntSiInfo.mib,
31225             rgSchCb[cell->instIdx].rgSchInit.region,
31226             rgSchCb[cell->instIdx].rgSchInit.pool,
31227             &subfrmAlloc->cmnLcInfo.bchInfo.pdu);
31228       /* Added Dl TB count for MIB message transmission
31229        * This counter is incremented 4 times to consider 
31230        * the retransmission at the PHY level on PBCH channel*/
31231 #ifdef LTE_L2_MEAS
31232       cell->dlUlTbCnt.tbTransDlTotalCnt += RG_SCH_MIB_CNT;
31233 #endif      
31234    }
31235 #ifdef EMTC_ENABLE
31236    }
31237 #endif
31238
31239    allocInfo->bcchAlloc.schdFirst = FALSE;
31240    /*Check if scheduling of SIB1 is required.
31241      Check of (crntTimInfo.sfn % RGSCH_SIB1_PERIODICITY == 0)
31242      is not required here since the below check takes care
31243      of SFNs applicable for this one too.*/
31244    if((crntTimInfo.sfn % RGSCH_SIB1_RPT_PERIODICITY == 0)
31245          && (RGSCH_SIB1_TX_SF_NUM == crntTimInfo.subframe))
31246    {
31247       /*If SIB1 has not been yet setup by Application, return*/
31248       if(NULLP == (cell->siCb.crntSiInfo.sib1Info.sib1))
31249       {
31250          RETVOID;
31251       }
31252
31253       allocInfo->bcchAlloc.schdFirst = TRUE;
31254       mcs =  cell->siCb.crntSiInfo.sib1Info.mcs;
31255       nPrb =  cell->siCb.crntSiInfo.sib1Info.nPrb;
31256       msgLen =  cell->siCb.crntSiInfo.sib1Info.msgLen;
31257    }
31258    else
31259    {
31260       /*Check if scheduling of SI can be performed.*/
31261       Bool    invalid = FALSE;
31262
31263       if(cell->siCb.siCtx.siId == 0)
31264          RETVOID;
31265
31266       /*Check if the Si-Window for the current Si-Context is completed*/
31267       invalid = rgSCHCmnChkPastWin(crntTimInfo, cell->siCb.siCtx.maxTimeToTx);
31268       if(invalid)
31269       {
31270          /* LTE_ADV_FLAG_REMOVED_START */
31271          if(cell->siCb.siCtx.retxCntRem)
31272          { 
31273             RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,(ErrVal)cell->siCb.siCtx.siId,
31274                                 "rgSCHDlSiSched(): SI not scheduled and window expired");
31275          }
31276          /* LTE_ADV_FLAG_REMOVED_END */
31277          if(cell->siCb.siCtx.warningSiFlag == TRUE)
31278          {
31279             rgSCHUtlFreeWarningSiPdu(cell);
31280             cell->siCb.siCtx.warningSiFlag  = FALSE;
31281          }
31282          RETVOID;
31283       }
31284
31285       /*Check the timinginfo of the current SI-Context to see if its
31286         transmission can be scheduled. */
31287       if(FALSE == (rgSCHCmnChkInWin(crntTimInfo,
31288                   cell->siCb.siCtx.timeToTx,
31289                   cell->siCb.siCtx.maxTimeToTx)))
31290       {
31291          RETVOID;
31292
31293       }
31294       /*Check if retransmission count has become 0*/
31295       if(0 == cell->siCb.siCtx.retxCntRem)
31296       {
31297          RETVOID;
31298       }
31299
31300       /* LTE_ADV_FLAG_REMOVED_START */
31301       /* Check if ABS is enabled/configured  */
31302       if(RGR_ENABLE == cell->lteAdvCb.absCfg.status)
31303       {
31304          /* The pattern type is RGR_ABS_MUTE, then eNB need to blank the subframe */
31305          if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
31306          {
31307             /* Determine next scheduling subframe is ABS or not */
31308             if(RG_SCH_ABS_ENABLED_ABS_SF == (RgSchAbsSfEnum)(cell->lteAdvCb.absCfg.absPattern
31309                   [((crntTimInfo.sfn*RGSCH_NUM_SUB_FRAMES) + crntTimInfo.subframe) % RGR_ABS_PATTERN_LEN]))
31310             {
31311                /* Skip the SI scheduling to next tti */
31312                RETVOID;
31313             }
31314          }
31315       }
31316       /* LTE_ADV_FLAG_REMOVED_END */
31317
31318       /*Schedule the transmission of the current SI-Context */
31319       /*Find out the messg length for the SI message */
31320       /* warningSiFlag is to differentiate between Warning SI
31321        * and Other SI */
31322         if((rgSCHUtlGetMcsAndNPrb(cell, &nPrb, &mcs, &msgLen)) != ROK)
31323         {
31324            RETVOID; 
31325         }
31326
31327       cell->siCb.siCtx.i = RGSCH_CALC_SF_DIFF(crntTimInfo,
31328             cell->siCb.siCtx.timeToTx);
31329    } 
31330
31331
31332    /*Get the number of rb required */
31333    /*rgSCHCmnClcRbAllocForFxdTb(cell, msgLen, cellDl->ccchCqi, &rb);*/
31334    if(cellDl->bitsPerRb==0)
31335    {
31336       while ((rgTbSzTbl[0][0][rb]) < (U32) (msgLen*8))
31337       {
31338          rb++;
31339       }
31340       rb = rb+1;
31341    }
31342    else
31343    {
31344       rb = RGSCH_CEIL((msgLen*8), cellDl->bitsPerRb);
31345    }
31346    /* DwPTS Scheduling Changes Start */   
31347 #ifdef LTE_TDD
31348    if (sf->sfType == RG_SCH_SPL_SF_DATA) 
31349    {
31350       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
31351
31352       /* Calculate the less RE's because of DwPTS */
31353        lostRe = rb * (cellDl->noResPerRb[cfi] - cellDl->numReDwPts[cfi]);
31354
31355        /* Increase number of RBs in Spl SF to compensate for lost REs */
31356        rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]); 
31357    }
31358 #endif
31359    /* DwPTS Scheduling Changes End */   
31360    /*ccpu00115595- end*/
31361    /* Additional check to see if required RBs
31362     * exceeds the available */
31363    if (rb > sf->bw - sf->bwAssigned)
31364    {
31365       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "rgSCHDlSiSched(): "
31366          "BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
31367       RETVOID;
31368    }
31369
31370    /* Update the subframe Allocated BW field */
31371    sf->bwAssigned = sf->bwAssigned + rb;
31372
31373    /*Fill the parameters in allocInfo */
31374    allocInfo->bcchAlloc.rnti = RGSCH_SI_RNTI;
31375    allocInfo->bcchAlloc.dlSf = sf;
31376    allocInfo->bcchAlloc.rbsReq = rb;
31377    /*ccpu00116710- MCS is not getting assigned */
31378    allocInfo->bcchAlloc.tbInfo[0].imcs = mcs;
31379
31380    /* ccpu00117510 - ADD - Assignment of nPrb and other information */
31381    allocInfo->bcchAlloc.nPrb = nPrb;
31382    allocInfo->bcchAlloc.tbInfo[0].bytesReq = msgLen;
31383    allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
31384    RETVOID;
31385 }
31386 #endif /*RGR_SI_SCH*/
31387
31388 \f
31389 /* ccpu00117452 - MOD - Changed macro name from
31390    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
31391 #ifdef RGR_CQI_REPT
31392 /**
31393  * @brief This function Updates the DL CQI for the UE.
31394  *
31395  * @details
31396  *
31397  *     Function: rgSCHCmnUeDlPwrCtColltCqiRept
31398  *     Purpose:  Manages PUSH N CQI reporting
31399  *         Step 1: Store the CQI in collation array
31400  *         Step 2: Increament the tracking count
31401  *         Step 3: Check is it time to to send the report
31402  *         Step 4: if yes, Send StaInd to RRM
31403  *         Step 4.1: Fill StaInd for sending collated N CQI rpeorts
31404  *         Step 4.2: Call utility function (rgSCHUtlRgrStaInd) to send rpts to RRM
31405  *         Step 4.2.1: If sending was not sucessful, return RFAILED
31406  *         Step 4.2.2: If sending was sucessful, return ROK
31407  *         Step 5: If no, return
31408  *     Invoked by: rgSCHCmnDlCqiInd
31409  *
31410  *  @param[in]  RgSchCellCb        *cell
31411  *  @param[in]  RgSchUeCb          *ue
31412  *  @param[in]  RgrUeCqiRept        *ueCqiRpt
31413  *  @return  Void
31414  *
31415  **/
31416 #ifdef ANSI
31417 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept
31418 (
31419 RgSchCellCb        *cell,
31420 RgSchUeCb          *ue,
31421 RgrUeCqiRept        *ueCqiRpt
31422 )
31423 #else
31424 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, ueCqiRpt)
31425 RgSchCellCb        *cell;
31426 RgSchUeCb          *ue;
31427 RgrUeCqiRept        *ueCqiRpt;
31428 #endif
31429 {
31430    U8    *cqiCount = NULLP;
31431    S16   retVal;
31432    RgrStaIndInfo *staInfo = NULLP;
31433
31434    TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
31435
31436    /* Step 1: Store the CQI in collation array */
31437    /* Step 2: Increament the tracking count */
31438    cqiCount = &(ue->schCqiInfo.cqiCount);
31439    ue->schCqiInfo.cqiRept[(*cqiCount)++] =
31440                   *ueCqiRpt;
31441
31442
31443    /* Step 3: Check is it time to to send the report */
31444    if(RG_SCH_CQIR_IS_TIMTOSEND_CQIREPT(ue))
31445    {
31446    /* Step 4: if yes, Send StaInd to RRM */
31447       retVal = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&staInfo,
31448                sizeof(RgrStaIndInfo));
31449       if (retVal != ROK)
31450       {
31451          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
31452             "allocate memory for sending StaInd CRNTI:%d",ue->ueId);
31453          RETVALUE(retVal);
31454       }
31455
31456    /* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
31457 #ifdef CA_DBG
31458       {
31459          extern U32 gCqiReptToAppCount;
31460          gCqiReptToAppCount++;
31461       
31462       }
31463
31464 #endif
31465       retVal = rgSCHUtlFillSndStaInd(cell, ue, staInfo,
31466             ue->cqiReptCfgInfo.numColltdCqiRept);
31467       RETVALUE(retVal);
31468
31469    }
31470
31471    RETVALUE(ROK);
31472 } /* End of rgSCHCmnUeDlPwrCtColltCqiRept */
31473
31474 #endif /* End of RGR_CQI_REPT */
31475
31476 /**
31477  * @brief This function checks for the retransmisson
31478  *        for a DTX scenario.
31479  * @details
31480  *
31481  *     Function:
31482  *     Purpose:
31483  *     Invoked by:
31484  *
31485  *  @param[in]  RgSchCellCb        *cell
31486  *  @param[in]  RgSchUeCb          *ue
31487  *  @param[in]
31488  *  @return  Void
31489  *
31490  **/
31491 #ifdef ANSI
31492 PUBLIC Void rgSCHCmnChkRetxAllowDtx
31493 (
31494 RgSchCellCb        *cell,
31495 RgSchUeCb          *ueCb,
31496 RgSchDlHqProcCb    *proc,
31497 Bool               *reTxAllwd
31498 )
31499 #else
31500 PUBLIC Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
31501 RgSchCellCb        *cell;
31502 RgSchUeCb          *ueCb;
31503 RgSchDlHqProcCb    *proc;
31504 Bool               *reTxAllwd;
31505 #endif
31506 {
31507    TRC3(rgSCHCmnChkRetxAllowDtx)
31508
31509
31510    *reTxAllwd = TRUE;
31511    /* Fix */
31512    if ((proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX))
31513    {
31514        *reTxAllwd = FALSE;
31515    }
31516
31517    RETVOID;
31518 }
31519
31520 /**
31521  * @brief API for calculating the SI Set Id 
31522  *
31523  * @details
31524  *
31525  *     Function: rgSCHCmnGetSiSetId
31526  *
31527  *     This API is used for calculating the SI Set Id, as shown below
31528  *     
31529  *          siSetId = 0        siSetId = 1
31530  *     |******************|******************|---------------->
31531  *   (0,0)              (8,0)              (16,0)          (SFN, SF)
31532  *    
31533  *
31534  *  @param[in]  U16     sfn                   
31535  *  @param[in]  U8      sf
31536  *  @return     U16     siSetId
31537  **/
31538 #ifdef ANSI
31539 PUBLIC U16 rgSCHCmnGetSiSetId
31540 (
31541 U16    sfn,
31542 U8     sf,
31543 U16    minPeriodicity
31544 )
31545 #else
31546 PUBLIC U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
31547 U16    sfn;
31548 U8     sf
31549 U16    minPeriodicity;
31550 #endif
31551 {
31552    /* 80 is the minimum SI periodicity in sf. Also
31553     * all other SI periodicities are multiples of 80 */
31554     RETVALUE (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
31555 }
31556 #ifdef LTE_TDD
31557 /**
31558  * @brief API for calculating the DwPts Rb, Itbs and  tbSz 
31559  *
31560  * @details
31561  *
31562  *     Function: rgSCHCmnCalcDwPtsTbSz
31563  *
31564  *  @param[in]     RgSchCellCb    *cell                   
31565  *  @param[in]     U32             bo
31566  *  @param[in/out] U8             *rb
31567  *  @param[in/out] U8             *iTbs
31568  *  @param[in]     U8              lyr
31569  *  @param[in]     U8              cfi
31570  *  @return        U32             tbSz
31571  **/
31572 #ifdef ANSI
31573 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz
31574 (
31575 RgSchCellCb    *cell,
31576 U32             bo,
31577 U8             *rb,
31578 U8             *iTbs,
31579 U8              lyr,
31580 U8              cfi
31581 )
31582 #else
31583 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
31584 RgSchCellCb    *cell;
31585 U32             bo;
31586 U8             *rb;
31587 U8             *iTbs;
31588 U8              lyr;
31589 U8              cfi;
31590 #endif
31591 {
31592     U32             tbSz;
31593     RgSchCmnDlCell *cellDl     = RG_SCH_CMN_GET_DL_CELL(cell);
31594     U32             numRE      = *rb * cellDl->noResPerRb[cfi];
31595     U32             numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);   
31596
31597     TRC2(rgSCHCmnCalcDwPtsTbSz);
31598
31599     /* DwPts Rb cannot exceed the cell Bw */
31600     numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
31601     
31602     /* Adjust the iTbs for optimum usage of the DwPts region. 
31603      * Using the same iTbs adjustment will not work for all 
31604      * special subframe configurations and iTbs levels. Hence use the 
31605      * static iTbs Delta table for adjusting the iTbs  */
31606     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs);
31607     
31608     if (bo)
31609     {
31610        while(rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1] < bo*8 &&
31611              numDwPtsRb < cellDl->maxDlBwPerUe) 
31612        {
31613           (numDwPtsRb)++;
31614        }
31615
31616        tbSz = rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1];
31617     }
31618     else
31619     {
31620        tbSz = rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1];
31621     }
31622     *rb = numDwPtsRb;
31623
31624     RETVALUE(tbSz/8);
31625 }
31626
31627 /**
31628  * @brief API for calculating the DwPts Rb, Itbs and  tbSz 
31629  *
31630  * @details
31631  *
31632  *     Function: rgSCHCmnCalcDwPtsTbSz2Cw
31633  *
31634  *  @param[in]      RgSchCellCb    *cell                   
31635  *  @param[in]      U32             bo
31636  *  @param[in/out]  U8             *rb
31637  *  @param[in]      U8              maxRb
31638  *  @param[in/out]  U8             *iTbs1
31639  *  @param[in/out]  U8             *iTbs2
31640  *  @param[in]      U8              lyr1
31641  *  @param[in]      U8              lyr2
31642  *  @return[in/out] U32            *tb1Sz
31643  *  @return[in/out] U32            *tb2Sz
31644  *  @param[in]      U8              cfi 
31645  **/
31646 #ifdef ANSI
31647 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw
31648 (
31649 RgSchCellCb    *cell,
31650 U32             bo,
31651 U8             *rb,
31652 U8              maxRb,
31653 U8             *iTbs1,
31654 U8             *iTbs2,
31655 U8              lyr1,
31656 U8              lyr2,
31657 U32            *tb1Sz, 
31658 U32            *tb2Sz,
31659 U8              cfi
31660 )
31661 #else
31662 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2, 
31663       lyr1, lyr2, tb1Sz, tb2Sz, cfi)
31664 RgSchCellCb    *cell;
31665 U32             bo;
31666 U8             *rb;
31667 U8              maxRb;
31668 U8             *iTbs1;
31669 U8             *iTbs2;
31670 U8              lyr1;
31671 U8              lyr2;
31672 U32            *tb1Sz; 
31673 U32            *tb2Sz;
31674 U8              cfi;
31675 #endif
31676 {
31677     RgSchCmnDlCell *cellDl     = RG_SCH_CMN_GET_DL_CELL(cell);
31678     U32             numRE      = *rb * cellDl->noResPerRb[cfi];
31679     U32             numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);   
31680
31681     TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
31682
31683     /* DwPts Rb cannot exceed the cell Bw */
31684     numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
31685     
31686     /* Adjust the iTbs for optimum usage of the DwPts region. 
31687      * Using the same iTbs adjustment will not work for all 
31688      * special subframe configurations and iTbs levels. Hence use the 
31689      * static iTbs Delta table for adjusting the iTbs  */
31690     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs1);
31691     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs2);
31692     
31693     while((rgTbSzTbl[lyr1-1][*iTbs1][RGSCH_MAX(numDwPtsRb*3/4,1)-1] +
31694            rgTbSzTbl[lyr2-1][*iTbs2][RGSCH_MAX(numDwPtsRb*3/4,1)-1])< bo*8 &&
31695           numDwPtsRb < maxRb) 
31696     {
31697        (numDwPtsRb)++;
31698     }
31699
31700     *tb1Sz = rgTbSzTbl[lyr1-1][*iTbs1][RGSCH_MAX(numDwPtsRb*3/4,1)-1]/8;
31701     *tb2Sz = rgTbSzTbl[lyr2-1][*iTbs2][RGSCH_MAX(numDwPtsRb*3/4,1)-1]/8;
31702
31703     *rb = numDwPtsRb;
31704
31705     RETVOID;    
31706 }
31707
31708 #endif
31709
31710 /**
31711  * @brief Updates the GBR LCGs when datInd is received from MAC
31712  * 
31713  * @details
31714  *
31715  *     Function: rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
31716  *     Purpose:  This function updates the GBR LCGs 
31717  *               when datInd is received from MAC.
31718  *
31719  *     Invoked by: TOM
31720  *
31721  *  @param[in]  RgSchCellCb      *cell
31722  *  @param[in]  RgSchUeCb        *ue
31723  *  @param[in]  RgInfUeDatInd    *datInd
31724  *  @return Void
31725  **/
31726 #ifdef ANSI
31727 PUBLIC Void rgSCHCmnUpdUeDataIndLcg 
31728 (
31729 RgSchCellCb    *cell,
31730 RgSchUeCb      *ue,
31731 RgInfUeDatInd  *datInd
31732 )
31733 #else
31734 PUBLIC Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
31735 RgSchCellCb    *cell;
31736 RgSchUeCb      *ue;
31737 RgInfUeDatInd  *datInd;
31738 #endif
31739 {
31740    U32 idx = 0;
31741    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
31742 #ifdef DEBUGP
31743    Inst                inst = cell->instIdx;
31744 #endif
31745
31746    TRC2(rgSCHCmnUpdUeDataIndLcg);
31747
31748    for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
31749    {
31750       if (datInd->lcgInfo[idx].bytesRcvd != 0)
31751       {
31752          U8  lcgId     = datInd->lcgInfo[idx].lcgId;
31753          U32 bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
31754
31755          if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
31756          {
31757             RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
31758             if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
31759             {
31760                if(bytesRcvd > cmnLcg->effGbr)
31761                {
31762                   bytesRcvd -= cmnLcg->effGbr;
31763                   cmnLcg->effDeltaMbr = (cmnLcg->effDeltaMbr > bytesRcvd) ? \
31764                                         (cmnLcg->effDeltaMbr - bytesRcvd) : (0);
31765                   cmnLcg->effGbr = 0;
31766                }
31767                else
31768                {
31769                   cmnLcg->effGbr -= bytesRcvd;
31770                }
31771                /* To keep BS updated with the amount of data received for the GBR */
31772                cmnLcg->reportedBs = (cmnLcg->reportedBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31773                                     (cmnLcg->reportedBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31774                cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr+cmnLcg->effDeltaMbr);
31775             }
31776             else if(lcgId != 0)
31777             {
31778                ue->ul.effAmbr = (ue->ul.effAmbr > datInd->lcgInfo[idx].bytesRcvd) ? \
31779                                (ue->ul.effAmbr - datInd->lcgInfo[idx].bytesRcvd) : (0);
31780                cmnLcg->reportedBs = (cmnLcg->reportedBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31781                                     (cmnLcg->reportedBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31782                cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
31783                ue->ul.nonGbrLcgBs = (ue->ul.nonGbrLcgBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31784                                    (ue->ul.nonGbrLcgBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31785             }
31786             ue->ul.nonLcg0Bs = (ue->ul.nonLcg0Bs > datInd->lcgInfo[idx].bytesRcvd) ? \
31787                               (ue->ul.nonLcg0Bs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31788          }
31789       }
31790       else
31791       {
31792          break;
31793       }
31794    }
31795 #ifdef EMTC_ENABLE
31796    if(TRUE == ue->isEmtcUe)
31797    {
31798       if (cellSch->apisEmtcUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
31799       {
31800          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
31801       }
31802
31803    }
31804    else
31805 #endif
31806    {
31807       if (cellSch->apisUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
31808       {
31809          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
31810       }
31811    }
31812 }
31813
31814
31815 /** @brief This function initializes DL allocation lists and prepares
31816  *         for scheduling  
31817  *
31818  * @details
31819  *
31820  *     Function: rgSCHCmnInitRbAlloc
31821  *
31822  * @param  [in] RgSchCellCb    *cell
31823  *
31824  * Returns: Void
31825  *
31826  */
31827 #ifdef ANSI
31828 PRIVATE Void  rgSCHCmnInitRbAlloc 
31829 (
31830 RgSchCellCb        *cell
31831 )
31832 #else
31833 PRIVATE Void  rgSCHCmnInitRbAlloc (cell)
31834 RgSchCellCb        *cell;
31835 #endif
31836 {
31837    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
31838    CmLteTimingInfo        frm;
31839    RgSchDlSf              *dlSf;
31840         U8                     idx;
31841    
31842    TRC2(rgSCHCmnInitRbAlloc);
31843
31844 /* Initializing RgSchCmnUlRbAllocInfo structure.*/
31845    rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
31846
31847    frm = cellSch->dl.time;
31848
31849    dlSf = rgSCHUtlSubFrmGet(cell, frm);
31850 #ifdef RG_5GTF
31851    dlSf->numGrpPerTti = cell->cell5gtfCb.ueGrpPerTti;
31852    dlSf->numUePerGrp = cell->cell5gtfCb.uePerGrpPerTti;
31853         for(idx = 0; idx < MAX_5GTF_BEAMS; idx++)
31854    {
31855       dlSf->sfBeamInfo[idx].totVrbgAllocated = 0;
31856       dlSf->sfBeamInfo[idx].totVrbgRequired = 0;
31857       dlSf->sfBeamInfo[idx].vrbgStart = 0;
31858    }
31859 #endif
31860    dlSf->remUeCnt = cellSch->dl.maxUePerDlSf;
31861    /* Updating the Subframe information in RBAllocInfo */
31862    cellSch->allocInfo.dedAlloc.dedDlSf   = dlSf;
31863    cellSch->allocInfo.msg4Alloc.msg4DlSf = dlSf;
31864
31865    /* LTE_ADV_FLAG_REMOVED_START */
31866    /* Determine next scheduling subframe is ABS or not */
31867    if(RGR_ENABLE == cell->lteAdvCb.absCfg.status)
31868    {
31869       cell->lteAdvCb.absPatternDlIdx = 
31870          ((frm.sfn*RGSCH_NUM_SUB_FRAMES_5G) + frm.subframe) % RGR_ABS_PATTERN_LEN;
31871       cell->lteAdvCb.absDlSfInfo = (RgSchAbsSfEnum)(cell->lteAdvCb.absCfg.absPattern[
31872             cell->lteAdvCb.absPatternDlIdx]);
31873
31874    }
31875    else
31876    {
31877       cell->lteAdvCb.absDlSfInfo = RG_SCH_ABS_DISABLED;
31878    }
31879    /* LTE_ADV_FLAG_REMOVED_END */
31880
31881 #ifdef RGR_V1
31882    cellSch->allocInfo.ccchSduAlloc.ccchSduDlSf = dlSf;
31883 #endif
31884 #ifdef LTEMAC_SPS
31885    /* Update subframe-wide allocation information with SPS allocation */
31886    rgSCHCmnSpsDlUpdDlSfAllocWithSps(cell, frm, dlSf);
31887 #endif
31888    RETVOID;
31889 }
31890
31891
31892
31893 #ifdef DL_LA
31894 /**
31895  * @brief Check & Updates the TM Mode chnage threashold based on cqiiTbs and
31896  * actual iTbs
31897  * 
31898  * @details
31899  *
31900  *     Function: rgSCHCmnSendTxModeInd(cell, ueUl, newTxMode)
31901  *     Purpose:  This function sends the TX mode Change 
31902  *               indication to RRM
31903  *     change
31904  *
31905  *     Invoked by: CMN
31906  *
31907  *  @param[in]  RgSchCellCb      *cell
31908  *  @param[in]  RgSchUeCb        *ue
31909  *  @param[in]  U8               newTxMode
31910  *  @return Void
31911  **/
31912 #ifdef ANSI
31913 PRIVATE Void rgSCHCmnSendTxModeInd 
31914 (
31915 RgSchCellCb    *cell,
31916 RgSchUeCb      *ue,
31917 U8             newTxMode
31918 )
31919 #else
31920 PRIVATE Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
31921 RgSchCellCb    *cell;
31922 RgSchUeCb      *ue;
31923 U8             newTxMode;
31924 #endif
31925 { 
31926    RgmTransModeInd   *txModeChgInd;
31927    RgSchCmnDlUe      *ueDl =  RG_SCH_CMN_GET_DL_UE(ue,cell);
31928
31929    TRC2(rgSCHCmnSendTxModeInd);
31930
31931    if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
31932    {
31933       /* Mem Alloc */
31934       if(SGetSBuf(cell->rgmSap->sapCfg.sapPst.region,
31935                cell->rgmSap->sapCfg.sapPst.pool, (Data**)&txModeChgInd,
31936                sizeof(RgmTransModeInd)) != ROK)
31937       {
31938          RETVOID;
31939       }
31940       RG_SCH_FILL_RGM_TRANSMODE_IND(ue->ueId, cell->cellId, newTxMode, txModeChgInd);
31941       RgUiRgmChangeTransModeInd(&(cell->rgmSap->sapCfg.sapPst),
31942             cell->rgmSap->sapCfg.suId, txModeChgInd);
31943    }
31944
31945    ue->mimoInfo.txModUpChgFactor = 0;
31946    ue->mimoInfo.txModDownChgFactor = 0;
31947    ueDl->laCb[0].deltaiTbs = 0;
31948
31949    RETVOID;
31950 }
31951
31952 /**
31953  * @brief Check & Updates the TM Mode chnage threashold based on cqiiTbs and
31954  * actual iTbs
31955  * 
31956  * @details
31957  *
31958  *     Function: rgSchCheckAndTriggerModeChange(cell, ueUl, iTbsNew)
31959  *     Purpose:  This function update and check for threashold for TM mode
31960  *     change
31961  *
31962  *     Invoked by: CMN
31963  *
31964  *  @param[in]  RgSchCellCb      *cell
31965  *  @param[in]  RgSchUeCb        *ue
31966  *  @param[in]  U8               iTbs
31967  *  @return Void
31968  **/
31969 #ifdef ANSI
31970 PUBLIC Void rgSchCheckAndTriggerModeChange
31971 (
31972 RgSchCellCb    *cell,
31973 RgSchUeCb      *ue,
31974 U8             reportediTbs,
31975 U8             previTbs,
31976 U8             maxiTbs
31977 )
31978 #else
31979 PUBLIC Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
31980 RgSchCellCb    *cell;
31981 RgSchUeCb      *ue;
31982 U8             reportediTbs;
31983 U8             previTbs;
31984 U8             maxiTbs;
31985 #endif
31986 {
31987    RgrTxMode          txMode;       /*!< UE's Transmission Mode */
31988    RgrTxMode          modTxMode;       /*!< UE's Transmission Mode */
31989
31990    TRC2(rgSchCheckAndTriggerModeChange);
31991
31992    txMode = ue->mimoInfo.txMode;
31993
31994    /* Check for Step down */
31995    /* Step down only when TM4 is configured. */
31996    if(RGR_UE_TM_4 == txMode)
31997    {
31998       if((previTbs <= reportediTbs) && ((reportediTbs - previTbs) >= RG_SCH_MODE_CHNG_STEPDOWN_CHECK_FACTOR))
31999       {
32000          ue->mimoInfo.txModDownChgFactor += RG_SCH_MODE_CHNG_STEPUP_FACTOR;
32001       }
32002       else
32003       {
32004          ue->mimoInfo.txModDownChgFactor -= RG_SCH_MODE_CHNG_STEPDOWN_FACTOR;
32005       }
32006
32007       ue->mimoInfo.txModDownChgFactor =  
32008          RGSCH_MAX(ue->mimoInfo.txModDownChgFactor, -(RG_SCH_MODE_CHNG_STEPDOWN_THRSHD));
32009
32010       if(ue->mimoInfo.txModDownChgFactor >= RG_SCH_MODE_CHNG_STEPDOWN_THRSHD)
32011       {
32012          /* Trigger Mode step down */
32013          modTxMode = RGR_UE_TM_3;
32014          rgSCHCmnSendTxModeInd(cell, ue, modTxMode);
32015       }
32016    }
32017
32018    /* Check for Setup up */
32019    /* Step Up only when TM3 is configured, Max possible Mode is TM4*/
32020    if(RGR_UE_TM_3 == txMode)
32021    {
32022       if((previTbs > reportediTbs) || (maxiTbs == previTbs))
32023       {
32024          ue->mimoInfo.txModUpChgFactor += RG_SCH_MODE_CHNG_STEPUP_FACTOR;
32025       }
32026       else
32027       {
32028          ue->mimoInfo.txModUpChgFactor -= RG_SCH_MODE_CHNG_STEPDOWN_FACTOR;
32029       }
32030
32031       ue->mimoInfo.txModUpChgFactor = 
32032          RGSCH_MAX(ue->mimoInfo.txModUpChgFactor, -(RG_SCH_MODE_CHNG_STEPUP_THRSHD));
32033
32034       /* Check if TM step up need to be triggered */
32035       if(ue->mimoInfo.txModUpChgFactor >= RG_SCH_MODE_CHNG_STEPUP_THRSHD)
32036       {
32037          /* Trigger mode chnage */
32038          modTxMode =  RGR_UE_TM_4;
32039          rgSCHCmnSendTxModeInd(cell, ue, modTxMode);
32040       }
32041    }
32042
32043    RETVOID;
32044 }
32045 #endif
32046
32047 /**
32048 * @brief Updates the GBR LCGs when datInd is received from MAC
32049  * 
32050  * @details
32051  *
32052  *     Function: rgSCHCmnIsDlCsgPrio (cell)
32053  *     Purpose:  This function returns if csg UEs are
32054  *               having priority at current time
32055  *
32056  *     Invoked by: Scheduler
32057  *
32058  *  @param[in]  RgSchCellCb      *cell
32059  *  @param[in]  RgSchUeCb        *ue
32060  *  @param[in]  RgInfUeDatInd    *datInd
32061  *  @return Void
32062  **/
32063 #ifdef ANSI
32064 PUBLIC Bool rgSCHCmnIsDlCsgPrio
32065 (
32066 RgSchCellCb    *cell
32067 )
32068 #else
32069 PUBLIC Bool rgSCHCmnIsDlCsgPrio(cell)
32070 RgSchCellCb    *cell;
32071 #endif
32072 {
32073   
32074    RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
32075  
32076    TRC2(rgSCHCmnIsDlCsgPrio)
32077    /* Calculating the percentage resource allocated */
32078    if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
32079    {
32080       RETVALUE(FALSE);
32081    }
32082    else
32083    {
32084       if(((cmnDlCell->ncsgPrbCnt * 100) / cmnDlCell->totPrbCnt) < cell->minDlResNonCsg)
32085       {
32086          RETVALUE(FALSE);
32087       }
32088       else
32089       {
32090          RETVALUE(TRUE);
32091       }
32092    }
32093 }
32094
32095 /**
32096 * @brief Updates the GBR LCGs when datInd is received from MAC
32097  * 
32098  * @details
32099  *
32100  *     Function: rgSCHCmnIsUlCsgPrio (cell)
32101  *     Purpose:  This function returns if csg UEs are
32102  *               having priority at current time
32103  *
32104  *     Invoked by: Scheduler
32105  *
32106  *  @param[in]  RgSchCellCb      *cell
32107  *  @param[in]  RgSchUeCb        *ue
32108  *  @param[in]  RgInfUeDatInd    *datInd
32109  *  @return Void
32110  **/
32111 #ifdef ANSI
32112 PUBLIC Bool rgSCHCmnIsUlCsgPrio
32113 (
32114 RgSchCellCb    *cell
32115 )
32116 #else
32117 PUBLIC Bool rgSCHCmnIsUlCsgPrio(cell)
32118 RgSchCellCb    *cell;
32119 #endif
32120 {
32121    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
32122  
32123    TRC2(rgSCHCmnIsUlCsgPrio)
32124
32125    /* Calculating the percentage resource allocated */
32126    if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
32127    {
32128       RETVALUE(FALSE);
32129    }
32130    else
32131    {
32132       if (((cmnUlCell->ncsgPrbCnt * 100) /cmnUlCell->totPrbCnt) < cell->minUlResNonCsg)
32133       {
32134          RETVALUE(FALSE);
32135       }
32136       else
32137       {
32138          RETVALUE(TRUE);
32139       }
32140    }
32141 }
32142
32143 /** @brief DL scheduler for SPS, and all other downlink data
32144  *
32145  * @details
32146  *
32147  *      Function: rgSchCmnPreDlSch
32148  *
32149  *  @param  [in] Inst               schInst;
32150  *   Returns: Void
32151  *
32152  */
32153 #ifdef ANSI
32154    PUBLIC Void rgSchCmnPreDlSch
32155 (
32156  RgSchCellCb        **cell,
32157  U8                 nCell,
32158  RgSchCellCb        **cellLst
32159  )
32160 #else
32161 PUBLIC Void rgSchCmnPreDlSch(cell, nCell, cellLst)
32162    RgSchCellCb        **cell;
32163    U8                 nCell;
32164    RgSchCellCb        **cellLst;
32165 #endif
32166 {
32167    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell[0]);
32168    RgSchDlSf     *sf;
32169    U8            idx;
32170
32171    TRC2(rgSchCmnPreDlSch);
32172
32173    if(nCell > CM_LTE_MAX_CELLS)
32174    {
32175       RETVOID;
32176    }
32177
32178    if (cell[0]->isDlDataAllwd && (cell[0]->stopDlSch == FALSE))
32179    {
32180       /* Specific DL scheduler to perform UE scheduling */
32181       cellSch->apisDl->rgSCHDlPreSched(cell[0]);
32182
32183       /* Rearranging the cell entries based on their remueCnt in SF.
32184        * cells will be processed in the order of number of ue scheduled
32185        * in that cell */
32186       for (idx = 0; idx < nCell; idx++)
32187       {
32188          U8    j;
32189          cellSch = RG_SCH_CMN_GET_CELL(cell[idx]);
32190          sf = cellSch->allocInfo.dedAlloc.dedDlSf;
32191
32192          if(idx == 0)
32193          {
32194             cellLst[idx] = cell[idx];
32195             continue;
32196          }
32197
32198          for(j = 0; j < idx; j++)
32199          {
32200             RgSchCmnCell *cmnCell = RG_SCH_CMN_GET_CELL(cellLst[j]);
32201             RgSchDlSf    *subfrm = cmnCell->allocInfo.dedAlloc.dedDlSf;
32202
32203             if(sf->remUeCnt < subfrm->remUeCnt)
32204             {
32205                U8  k;
32206                for(k = idx; k > j; k--)
32207                {
32208                   cellLst[k] = cellLst[k-1];
32209                }
32210                break;
32211             }
32212          }
32213          cellLst[j] = cell[idx];
32214       }
32215    }
32216    else
32217    {
32218       for (idx = 0; idx < nCell; idx++)
32219       {
32220          cellLst[idx] = cell[idx];
32221       }
32222    }
32223    RETVOID;
32224 }
32225
32226 /** @brief DL scheduler for SPS, and all other downlink data
32227  *  @details
32228  *
32229  *       Function: rgSchCmnPstDlSch
32230  *
32231  *        @param  [in] Inst               schInst;
32232  *        Returns: Void
32233  *
32234  */
32235 #ifdef ANSI
32236 PUBLIC Void rgSchCmnPstDlSch
32237 (
32238  RgSchCellCb       *cell
32239 )
32240 #else
32241 PUBLIC Void rgSchCmnPstDlSch(cell)
32242    RgSchCellCb        *cell
32243 #endif
32244 {
32245    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
32246
32247    TRC2(rgSchCmnPstDlSch);
32248
32249    if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
32250    {
32251       cellSch->apisDl->rgSCHDlPstSched(cell->instIdx);
32252    }
32253 }
32254
32255 #ifdef ANSI
32256 PUBLIC U8 rgSCHCmnCalcPcqiBitSz
32257 (
32258  RgSchUeCb    *ueCb, 
32259  U8           numTxAnt
32260 )
32261 #else
32262 PUBLIC U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
32263    RgSchUeCb     *ueCb;
32264    U8            numTxAnt;
32265 #endif
32266 {
32267    U8 confRepMode;
32268    U8 pcqiSz;
32269    U8 ri;
32270    RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
32271
32272    TRC3(rgSCHCmnCalcPcqiBitSz);
32273
32274    confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
32275    if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) && 
32276          (ueCb->mimoInfo.txMode != RGR_UE_TM_4))
32277    {
32278       ri =1;
32279    }
32280    else
32281    {
32282       ri = cqiCb->perRiVal;
32283    }
32284    switch(confRepMode)
32285    {
32286       case RGR_PRD_CQI_MOD10:
32287          {
32288             pcqiSz = 4;
32289          }
32290          break;
32291
32292       case RGR_PRD_CQI_MOD11:
32293          {
32294             if(numTxAnt == 2)
32295             {
32296                if (ri ==1)
32297                {
32298                   pcqiSz = 6;
32299                }
32300                else
32301                {
32302                   pcqiSz = 8;
32303                }
32304             }
32305             else if(numTxAnt == 4)
32306             {
32307                if (ri ==1)
32308                {
32309                   pcqiSz = 8;
32310                }
32311                else
32312                {
32313                   pcqiSz = 11;
32314                }
32315             }
32316             else
32317             {
32318                /* This is number of antenna case 1.
32319                 * This is not applicable for Mode 1-1. 
32320                 * So setting it to invalid value */
32321                pcqiSz = 0;
32322             }
32323          }
32324          break;
32325
32326       case RGR_PRD_CQI_MOD20:
32327          {
32328             if(cqiCb->isWb)
32329             {
32330                pcqiSz = 4;
32331             }
32332             else
32333             {
32334                pcqiSz = 4 + cqiCb->label;
32335             }
32336          }
32337          break;
32338
32339       case RGR_PRD_CQI_MOD21:
32340          {
32341             if(cqiCb->isWb)
32342             {
32343                if(numTxAnt == 2)
32344                {
32345                   if (ri ==1)
32346                   {
32347                      pcqiSz = 6;
32348                   }
32349                   else
32350                   {
32351                      pcqiSz = 8;
32352                   }
32353                }
32354                else if(numTxAnt == 4)
32355                {
32356                   if (ri ==1)
32357                   {
32358                      pcqiSz = 8;
32359                   }
32360                   else
32361                   {
32362                      pcqiSz = 11;
32363                   }
32364                }
32365                else
32366                {
32367                   /* This might be number of antenna case 1.
32368                    * For mode 2-1 wideband case only antenna port 2 or 4 is supported.
32369                    * So setting invalid value.*/
32370                   pcqiSz = 0;
32371                }
32372             }
32373             else
32374             {
32375                if (ri ==1)
32376                {
32377                   pcqiSz = 4 + cqiCb->label;
32378                }
32379                else
32380                {
32381                   pcqiSz = 7 + cqiCb->label;
32382                }
32383             }
32384          }
32385          break;
32386       default:
32387           pcqiSz = 0;
32388           break;
32389    }
32390    
32391    RETVALUE(pcqiSz);
32392 }
32393
32394 /** @brief DL scheduler for SPS, and all other downlink data
32395  *
32396  * @details
32397  *
32398  *     Function: rgSCHCmnDlSch
32399  *
32400  * @param  [in] RgSchCellCb    *cell
32401  *
32402  * Returns: Void
32403  *
32404  */
32405 #ifdef ANSI
32406 PUBLIC Void rgSCHCmnDlSch
32407 (
32408  RgSchCellCb        *cell
32409  )
32410 #else
32411 PUBLIC Void rgSCHCmnDlSch (cell)
32412    RgSchCellCb        *cell;
32413 #endif
32414 {
32415    RgSchDlSf *dlSf;
32416    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
32417 #ifdef RG_5GTF
32418    RgSchDynTddCb  *rgSchDynTddInfo = &(rgSchCb[cell->instIdx].rgSchDynTdd);
32419    U16 dlCntrlSfIdx;
32420 #endif
32421
32422    TRC2(rgSCHCmnDlSch);
32423
32424    dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
32425 #ifdef RG_5GTF
32426         if (rgSchDynTddInfo->isDynTddEnbld)
32427    {
32428       RG_SCH_DYN_TDD_GET_SFIDX(dlCntrlSfIdx, rgSchDynTddInfo->crntDTddSfIdx, 
32429                                             RG_SCH_CMN_DL_DELTA);
32430                 if(RG_SCH_DYNTDD_DLC_ULD == rgSchDynTddInfo->sfInfo[dlCntrlSfIdx].sfType)
32431                 {
32432                    if(1 == cell->cellId)
32433          {
32434                       ul5gtfsidDlAlreadyMarkUl++;
32435             /*
32436                       printf("ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n", 
32437                     ul5gtfsidDlAlreadyMarkUl, cellSch->dl.time.sfn, 
32438                     cellSch->dl.time.subframe);
32439             */
32440          }
32441                    RETVOID;
32442                 }
32443    }
32444 #endif
32445
32446    /* Specific DL scheduler to perform UE scheduling */
32447    cellSch->apisDl->rgSCHDlNewSched(cell, &cellSch->allocInfo);      
32448    /* LTE_ADV_FLAG_REMOVED_END */
32449
32450    /* call common allocator for RB Allocation */
32451    rgSCHCmnDlRbAlloc(cell, &cellSch->allocInfo);
32452
32453    /* Finalize the Allocations for reqested Against alloced */
32454    rgSCHCmnDlAllocFnlz(cell);
32455
32456    /* Perform Pdcch allocations for PDCCH Order Q.
32457     * As of now, giving this the least preference.
32458     * This func call could be moved above other allocations
32459     * as per need */
32460    rgSCHCmnGenPdcchOrder(cell, dlSf);
32461
32462    /* Do group power control for PUCCH */
32463    rgSCHCmnGrpPwrCntrlPucch(cell, dlSf);
32464
32465    RETVOID;
32466 }
32467
32468 /**********************************************************************
32469
32470   End of file
32471 **********************************************************************/
O-RAN DU Layer 2